Restore tests and coverage

LowVoltage/actions/batch_get_item.py

@@ -31,7 +31,6 @@
 )
 from .return_types import ConsumedCapacity, _is_dict, _is_list_of_dict
 
-# @todo Document return types
 
 class BatchGetItemResponse(object):
     """
@@ -342,8 +341,7 @@ def test_expression_attribute_name(self):
 
 
 class BatchGetItemLocalIntegTests(_tst.LocalIntegTestsWithTableH):
-    # @todo pep8 test names (everywhere)
-    def testSimpleBatchGet(self):
+    def test_simple_batch_get(self):
         self.connection(_lv.BatchWriteItem().table("Aaa").put(
             {"h": u"1", "a": "xxx"},
             {"h": u"2", "a": "yyy"},
@@ -352,16 +350,13 @@ def testSimpleBatchGet(self):
 
         r = self.connection(_lv.BatchGetItem().table("Aaa").keys({"h": u"1"}, {"h": u"2"}, {"h": u"3"}))
 
-        with _tst.cover("r", r) as r:
-            self.assertEqual(r.consumed_capacity, None)
-            self.assertEqual(r.responses.keys(), ["Aaa"])
-            self.assertEqual(
-                sorted(r.responses["Aaa"], key=lambda i: i["h"]),
-                [{"h": u"1", "a": "xxx"}, {"h": u"2", "a": "yyy"}, {"h": u"3", "a": "zzz"}]
-            )
-            self.assertEqual(r.unprocessed_keys, {})
+        self.assertEqual(r.responses.keys(), ["Aaa"])
+        self.assertEqual(
+            sorted(r.responses["Aaa"], key=lambda i: i["h"]),
+            [{"h": u"1", "a": "xxx"}, {"h": u"2", "a": "yyy"}, {"h": u"3", "a": "zzz"}]
+        )
 
-    def testBatchGetWithProjections(self):
+    def test_batch_get_with_projections(self):
         self.connection(_lv.BatchWriteItem().table("Aaa").put(
             {"h": u"1", "a": "a1", "b": "b1", "c": "c1"},
             {"h": u"2", "a": "a2", "b": "b2", "c": "c2"},
@@ -371,15 +366,10 @@ def testBatchGetWithProjections(self):
         r = self.connection(
             _lv.BatchGetItem().table("Aaa").keys({"h": u"1"}, {"h": u"2"}, {"h": u"3"}).expression_attribute_name("p", "b").project("h").project("a", ["#p"])
         )
-
-        with _tst.cover("r", r) as r:
-            self.assertEqual(r.consumed_capacity, None)
-            self.assertEqual(r.responses.keys(), ["Aaa"])
-            self.assertEqual(
-                sorted(r.responses["Aaa"], key=lambda i: i["h"]),
-                [{"h": u"1", "a": "a1", "b": "b1"}, {"h": u"2", "a": "a2", "b": "b2"}, {"h": u"3", "a": "a3", "b": "b3"}]
-            )
-            self.assertEqual(r.unprocessed_keys, {})
+        self.assertEqual(
+            sorted(r.responses["Aaa"], key=lambda i: i["h"]),
+            [{"h": u"1", "a": "a1", "b": "b1"}, {"h": u"2", "a": "a2", "b": "b2"}, {"h": u"3", "a": "a3", "b": "b3"}]
+        )
 
     def test_get_unexisting_keys(self):
         self.connection(_lv.BatchWriteItem().table("Aaa").put(
@@ -389,26 +379,25 @@ def test_get_unexisting_keys(self):
 
         r = self.connection(_lv.BatchGetItem().table("Aaa").keys({"h": u"1"}, {"h": u"2"}, {"h": u"3"}))
 
-        with _tst.cover("r", r) as r:
-            self.assertEqual(r.consumed_capacity, None)
-            self.assertEqual(r.responses.keys(), ["Aaa"])
-            self.assertEqual(
-                sorted(r.responses["Aaa"], key=lambda i: i["h"]),
-                [{"h": u"1", "a": "xxx"}, {"h": u"2", "a": "yyy"}]
-            )
-            self.assertEqual(r.unprocessed_keys, {})
+        self.assertEqual(
+            sorted(r.responses["Aaa"], key=lambda i: i["h"]),
+            [{"h": u"1", "a": "xxx"}, {"h": u"2", "a": "yyy"}]
+        )
+        self.assertEqual(r.unprocessed_keys, {})
 
     def test_get_without_unprocessed_keys(self):
         _lv.BatchPutItem(self.connection, "Aaa", [{"h": unicode(i)} for i in range(100)])
 
         r = self.connection(_lv.BatchGetItem().table("Aaa").keys({"h": unicode(i)} for i in range(100)))
+
         self.assertEqual(r.unprocessed_keys, {})
         self.assertEqual(len(r.responses["Aaa"]), 100)
 
     def test_get_with_unprocessed_keys(self):
         _lv.BatchPutItem(self.connection, "Aaa", [{"h": unicode(i), "xs": "x" * 300000} for i in range(100)])  # 300kB items ensure a single BatchGetItem will return at most 55 items
 
         r1 = self.connection(_lv.BatchGetItem().table("Aaa").keys({"h": unicode(i)} for i in range(100)))
+
         self.assertEqual(len(r1.unprocessed_keys["Aaa"]["Keys"]), 45)
         self.assertEqual(len(r1.responses["Aaa"]), 55)
 
@@ -424,11 +413,9 @@ def tearDown(self):
 
     def test_return_consumed_capacity_total(self):
         r = self.connection(_lv.BatchGetItem().table(self.table).keys(self.tab_key).return_consumed_capacity_total())
-        with _tst.cover("r", r) as r:
-            self.assertEqual(r.consumed_capacity[0].capacity_units, 0.5)
-            self.assertEqual(r.consumed_capacity[0].global_secondary_indexes, None)
-            self.assertEqual(r.consumed_capacity[0].local_secondary_indexes, None)
-            self.assertEqual(r.consumed_capacity[0].table, None)
-            self.assertEqual(r.consumed_capacity[0].table_name, self.table)
-            self.assertEqual(r.responses[self.table][0], self.item)
-            self.assertEqual(r.unprocessed_keys, {})
+
+        self.assertEqual(r.consumed_capacity[0].capacity_units, 0.5)
+        self.assertEqual(r.consumed_capacity[0].global_secondary_indexes, None)
+        self.assertEqual(r.consumed_capacity[0].local_secondary_indexes, None)
+        self.assertEqual(r.consumed_capacity[0].table, None)
+        self.assertEqual(r.consumed_capacity[0].table_name, self.table)

LowVoltage/actions/batch_write_item.py

@@ -331,15 +331,9 @@ def test_simple_batch_put(self):
             {"h": u"3", "a": "zzz"},
         ))
 
-        with _tst.cover("r", r) as r:
-            self.assertEqual(r.consumed_capacity, None)
-            self.assertEqual(r.item_collection_metrics, None)
-            self.assertEqual(r.unprocessed_items, {})
-
-        self.assertEqual(
-            self.connection(_lv.GetItem("Aaa", {"h": u"1"})).item,
-            {"h": "1", "a": "xxx"}
-        )
+        self.assertEqual(self.connection(_lv.GetItem("Aaa", {"h": u"1"})).item, {"h": "1", "a": "xxx"})
+        self.assertEqual(self.connection(_lv.GetItem("Aaa", {"h": u"2"})).item, {"h": "2", "a": "yyy"})
+        self.assertEqual(self.connection(_lv.GetItem("Aaa", {"h": u"3"})).item, {"h": "3", "a": "zzz"})
 
     def test_simple_batch_delete(self):
         self.connection(_lv.BatchWriteItem().table("Aaa").put(
@@ -354,15 +348,9 @@ def test_simple_batch_delete(self):
             {"h": u"3"}
         ))
 
-        with _tst.cover("r", r) as r:
-            self.assertEqual(r.consumed_capacity, None)
-            self.assertEqual(r.item_collection_metrics, None)
-            self.assertEqual(r.unprocessed_items, {})
-
-        self.assertEqual(
-            self.connection(_lv.GetItem("Aaa", {"h": u"1"})).item,
-            None
-        )
+        self.assertEqual(self.connection(_lv.GetItem("Aaa", {"h": u"1"})).item, None)
+        self.assertEqual(self.connection(_lv.GetItem("Aaa", {"h": u"2"})).item, None)
+        self.assertEqual(self.connection(_lv.GetItem("Aaa", {"h": u"3"})).item, None)
 
 
 class BatchWriteItemConnectedIntegTests(_tst.ConnectedIntegTestsWithTable):
@@ -373,21 +361,15 @@ def tearDown(self):
     def test_return_consumed_capacity_indexes(self):
         r = self.connection(_lv.BatchWriteItem().table(self.table).put(self.item).return_consumed_capacity_indexes())
 
-        with _tst.cover("r", r) as r:
-            self.assertEqual(r.consumed_capacity[0].capacity_units, 3.0)
-            self.assertEqual(r.consumed_capacity[0].global_secondary_indexes["gsi"].capacity_units, 1.0)
-            self.assertEqual(r.consumed_capacity[0].local_secondary_indexes["lsi"].capacity_units, 1.0)
-            self.assertEqual(r.consumed_capacity[0].table.capacity_units, 1.0)
-            self.assertEqual(r.consumed_capacity[0].table_name, self.table)
-            self.assertEqual(r.item_collection_metrics, None)
-            self.assertEqual(r.unprocessed_items, {})
+        self.assertEqual(r.consumed_capacity[0].capacity_units, 3.0)
+        self.assertEqual(r.consumed_capacity[0].global_secondary_indexes["gsi"].capacity_units, 1.0)
+        self.assertEqual(r.consumed_capacity[0].local_secondary_indexes["lsi"].capacity_units, 1.0)
+        self.assertEqual(r.consumed_capacity[0].table.capacity_units, 1.0)
+        self.assertEqual(r.consumed_capacity[0].table_name, self.table)
 
     def test_return_item_collection_metrics_size(self):
         r = self.connection(_lv.BatchWriteItem().table(self.table).put(self.item).return_item_collection_metrics_size())
 
-        with _tst.cover("r", r) as r:
-            self.assertEqual(r.consumed_capacity, None)
-            self.assertEqual(r.item_collection_metrics[self.table][0].item_collection_key, {"tab_h": "0"})
-            self.assertEqual(r.item_collection_metrics[self.table][0].size_estimate_range_gb[0], 0.0)
-            self.assertEqual(r.item_collection_metrics[self.table][0].size_estimate_range_gb[1], 1.0)
-            self.assertEqual(r.unprocessed_items, {})
+        self.assertEqual(r.item_collection_metrics[self.table][0].item_collection_key, {"tab_h": "0"})
+        self.assertEqual(r.item_collection_metrics[self.table][0].size_estimate_range_gb[0], 0.0)
+        self.assertEqual(r.item_collection_metrics[self.table][0].size_estimate_range_gb[1], 1.0)

LowVoltage/actions/conversion.py

@@ -79,96 +79,96 @@ def _convert_db_to_value(value):
 
 
 class ConversionUnitTests(_tst.UnitTests):
-    def test_convert_unicode_to_db(self):
+    def test_convert_unicode_value_to_db(self):
         self.assertEqual(_convert_value_to_db(u"éoà"), {"S": u"éoà"})
 
-    def test_convert_bytes_to_db(self):
+    def test_convert_bytes_value_to_db(self):
         self.assertEqual(_convert_value_to_db(b"\xFF\x00\xAB"), {"B": u"/wCr"})
 
-    def test_convert_bool_to_db(self):
+    def test_convert_bool_value_to_db(self):
         self.assertEqual(_convert_value_to_db(True), {"BOOL": True})
         self.assertEqual(_convert_value_to_db(False), {"BOOL": False})
 
-    def test_convert_int_to_db(self):
+    def test_convert_int_value_to_db(self):
         self.assertEqual(_convert_value_to_db(42), {"N": "42"})
 
-    def test_convert_none_to_db(self):
+    def test_convert_none_value_to_db(self):
         self.assertEqual(_convert_value_to_db(None), {"NULL": True})
 
-    def test_convert_set_of_int_to_db(self):
+    def test_convert_set_of_int_value_to_db(self):
         self.assertIn(_convert_value_to_db(set([42, 43])), [{"NS": ["42", "43"]}, {"NS": ["43", "42"]}])
 
-    def test_convert_frozenset_to_db(self):
+    def test_convert_frozenset_value_to_db(self):
         self.assertIn(_convert_value_to_db(frozenset([42, 43])), [{"NS": ["42", "43"]}, {"NS": ["43", "42"]}])
 
-    def test_convert_set_of_unicode_to_db(self):
+    def test_convert_set_of_unicode_value_to_db(self):
         self.assertIn(_convert_value_to_db(set([u"éoà", u"bar"])), [{"SS": [u"éoà", u"bar"]}, {"SS": [u"bar", u"éoà"]}])
 
-    def test_convert_set_of_byte_to_db(self):
+    def test_convert_set_of_byte_value_to_db(self):
         self.assertIn(_convert_value_to_db(set([b"\xFF\x00\xAB", b"bar"])), [{"BS": [u"/wCr", u"YmFy"]}, {"BS": [u"YmFy", u"/wCr"]}])
 
-    def test_convert_list_to_db(self):
+    def test_convert_list_value_to_db(self):
         self.assertEqual(_convert_value_to_db([True, 42]), {"L": [{"BOOL": True}, {"N": "42"}]})
 
-    def test_convert_dict_to_db(self):
+    def test_convert_dict_value_to_db(self):
         self.assertEqual(_convert_value_to_db({"a": True, "b": 42}), {"M": {"a": {"BOOL": True}, "b": {"N": "42"}}})
 
-    def test_convert_empty_set_to_db(self):
+    def test_convert_empty_set_value_to_db(self):
         with self.assertRaises(TypeError):
             _convert_value_to_db(set())
 
-    def test_convert_set_of_tuple_to_db(self):
+    def test_convert_set_of_tuple_value_to_db(self):
         with self.assertRaises(TypeError):
             _convert_value_to_db(set([(1, 2)]))
 
-    def test_convert_heterogenous_set_to_db(self):
+    def test_convert_heterogenous_set_value_to_db(self):
         with self.assertRaises(TypeError):
             _convert_value_to_db(set([1, "2"]))
 
-    def test_convert_tuple_to_db(self):
+    def test_convert_tuple_value_to_db(self):
         with self.assertRaises(TypeError):
             _convert_value_to_db((1, 2))
 
-    def test_convert_db_to_unicode(self):
+    def test_convert_db_to_unicode_value(self):
         self.assertEqual(_convert_db_to_value({"S": u"éoà"}), u"éoà")
 
-    def test_convert_db_to_bytes(self):
+    def test_convert_db_to_bytes_value(self):
         self.assertEqual(_convert_db_to_value({"B": u"/wCr"}), b"\xFF\x00\xAB")
 
-    def test_convert_db_to_bool(self):
+    def test_convert_db_to_bool_value(self):
         self.assertEqual(_convert_db_to_value({"BOOL": True}), True)
         self.assertEqual(_convert_db_to_value({"BOOL": False}), False)
 
-    def test_convert_db_to_int(self):
+    def test_convert_db_to_int_value(self):
         self.assertEqual(_convert_db_to_value({"N": "42"}), 42)
 
-    def test_convert_db_to_none(self):
+    def test_convert_db_to_none_value(self):
         self.assertEqual(_convert_db_to_value({"NULL": True}), None)
 
-    def test_convert_db_to_set_of_int(self):
+    def test_convert_db_to_set_of_int_value(self):
         self.assertEqual(_convert_db_to_value({"NS": ["42", "43"]}), set([42, 43]))
 
-    def test_convert_db_to_set_of_unicode(self):
+    def test_convert_db_to_set_of_unicode_value(self):
         self.assertEqual(_convert_db_to_value({"SS": [u"éoà", u"bar"]}), set([u"éoà", u"bar"]))
 
-    def test_convert_db_to_set_of_byte(self):
+    def test_convert_db_to_set_of_byte_value(self):
         self.assertEqual(_convert_db_to_value({"BS": [u"/wCr", u"YmFy"]}), set([b"\xFF\x00\xAB", b"bar"]))
 
-    def test_convert_db_to_list(self):
+    def test_convert_db_to_list_value(self):
         self.assertEqual(_convert_db_to_value({"L": [{"BOOL": True}, {"N": "42"}]}), [True, 42])
 
-    def test_convert_db_to_dict(self):
+    def test_convert_db_to_dict_value(self):
         self.assertEqual(_convert_db_to_value({"M": {"a": {"BOOL": True}, "b": {"N": "42"}}}), {"a": True, "b": 42})
 
-    def test_convert_db_empty_dict(self):
+    def test_convert_db_to_empty_dict_value(self):
         with self.assertRaises(TypeError):
             _convert_db_to_value({})
 
-    def test_convert_db_empty_list(self):
+    def test_convert_db_to_empty_list_value(self):
         with self.assertRaises(TypeError):
             _convert_db_to_value([])
 
-    def test_convert_db_string(self):
+    def test_convert_db_to_string_value(self):
         with self.assertRaises(TypeError):
             _convert_db_to_value("SSS")