test helpers

Author: kelvich

contrib/mmts/tests2/lib/bank_client.py

@@ -111,10 +111,10 @@ def status(self):
         while self.running:
             msg = yield from self.child_pipe.coro_recv()
             if msg == 'status':
-                serialized_aggs = {}
+                serialized_aggs = []
 
                 for conn_id, conn_aggs in self.aggregates.items():
-                    serialized_aggs[conn_id] = {}
+                    serialized_aggs.append({})
                     for aggname, agg in conn_aggs.items():
                         serialized_aggs[conn_id][aggname] = agg.as_dict()
                         agg.clear_values()
@@ -224,9 +224,8 @@ def print_aggregates(cls, aggs):
                 print(col, end="\t")
             print("\n", end="")
 
-            for conn_id in aggs.keys():
-                for aggname in aggs[conn_id].keys():
-                    agg = aggs[conn_id][aggname]
+            for conn_id, agg_conn in enumerate(aggs):
+                for aggname, agg in agg_conn.items():
                     print("Node %d: %s\t" % (conn_id + 1, aggname), end="")
                     for col in columns:
                         if isinstance(agg[col], float):

contrib/mmts/tests2/lib/failure_injector.py

@@ -2,15 +2,12 @@
 
 class FailureInjector(object):
 
-    # def __init__(self):
-    #     self.docker_api = docker.Client()
+    def __init__(self):
+        self.docker_api = docker.Client()
 
     def container_exec(self, node, command):
-        self.docker_api = docker.Client()
         exec_id = self.docker_api.exec_create(node, command, user='root')
         output = self.docker_api.exec_start(exec_id)
-        self.docker_api.close()
-        # print(command, ' -> ', output)
 
 
 class SingleNodePartition(FailureInjector):

contrib/mmts/tests2/test_recovery.py

@@ -14,7 +14,47 @@
 TEST_DURATION = 10
 TEST_RECOVERY_TIME = 20
 
-class RecoveryTest(unittest.TestCase):
+class TestHelper(object):
+
+    def assertIsolation(self, aggs):
+        isolated = True
+        for conn_id, agg in enumerate(aggs):
+            isolated = isolated and agg['sumtotal']['isolation'] == 0
+        if not isolated:
+            raise AssertionError('Isolation failure')
+
+    def assertCommits(self, aggs):
+        commits = True
+        for conn_id, agg in enumerate(aggs):
+            commits = commits and 'commit' in agg['transfer']['finish']
+        if not commits:
+            raise AssertionError('No commits during aggregation interval')
+
+    def assertNoCommits(self, aggs):
+        commits = True
+        for conn_id, agg in enumerate(aggs):
+            commits = commits and 'commit' in agg['transfer']['finish']
+        if commits:
+            raise AssertionError('There are commits during aggregation interval')
+
+    def performFailure(self, failure):
+        failure.start()
+
+        self.client.clean_aggregates()
+        time.sleep(TEST_DURATION)
+        aggs_failure = self.client.get_aggregates()
+
+        failure.stop()
+
+        self.client.clean_aggregates()
+        time.sleep(TEST_RECOVERY_TIME)
+        aggs = self.client.get_aggregates()
+
+        return (aggs_failure, aggs)
+
+
+class RecoveryTest(unittest.TestCase, TestHelper):
+
     @classmethod
     def setUpClass(self):
         # subprocess.check_call(['docker-compose','up',
@@ -58,32 +98,14 @@ def test_normal_operations(self):
     def test_node_partition(self):
         print('### nodePartitionTest ###')
 
-        failure = SingleNodePartition('node3')
-        failure.start()
-
-        self.client.clean_aggregates()
-        time.sleep(TEST_DURATION)
-        aggs_failure = self.client.get_aggregates()
-
-        failure.stop()
+        aggs_failure, aggs = self.performFailure(SingleNodePartition('node3'))
 
-        self.client.clean_aggregates()
-        time.sleep(TEST_RECOVERY_TIME)
-        aggs = self.client.get_aggregates()
+        self.assertCommits(aggs_failure[:2])
+        self.assertNoCommits(aggs_failure[2:])
+        self.assertIsolation(aggs_failure)
 
-        self.assertTrue( 'commit' in aggs_failure[0]['transfer']['finish'] )
-        self.assertTrue( 'commit' in aggs_failure[1]['transfer']['finish'] )
-        self.assertTrue( 'commit' not in aggs_failure[2]['transfer']['finish'] )
-        self.assertTrue( aggs_failure[0]['sumtotal']['isolation'] == 0)
-        self.assertTrue( aggs_failure[1]['sumtotal']['isolation'] == 0)
-        self.assertTrue( aggs_failure[2]['sumtotal']['isolation'] == 0)
-
-        self.assertTrue( 'commit' in aggs[0]['transfer']['finish'] )
-        self.assertTrue( 'commit' in aggs[1]['transfer']['finish'] )
-        self.assertTrue( 'commit' in aggs[2]['transfer']['finish'] )
-        self.assertTrue( aggs[0]['sumtotal']['isolation'] == 0)
-        self.assertTrue( aggs[1]['sumtotal']['isolation'] == 0)
-        self.assertTrue( aggs[2]['sumtotal']['isolation'] == 0)
+        self.assertCommits(aggs)
+        self.assertIsolation(aggs)
 
 
     def test_edge_partition(self):