Refactored Test Code

src/data-hub/role-stage-discovery-microservice/app/test_coverage.py

@@ -3,7 +3,9 @@ import sys
 for path in ['../', './']:
     sys.path.insert(1, path)
 
-
+#####################################
+### Don't include for test report ###
+#####################################
 try: 
     class TestCoverage(unittest.TestCase):
         def test_init_main(self):

src/data-hub/role-stage-discovery-microservice/app/tests/test_cluster.py

-try:
-    import unittest
-    import sys
-    for path in ['../', './']:
-        sys.path.insert(1, path)
 
-    # python -m unittest discover
-    from db.entities import Cluster
+import unittest
+import sys
+for path in ['../', './']:
+    sys.path.insert(1, path)
 
-    from datetime import date, datetime
-    import json
+# python -m unittest discover
+from db.entities import Cluster
 
+from datetime import date, datetime
+import json
 
-    class TestCluster(unittest.TestCase):
-        def test_init_Cluster(self):
-            try:
-                c = Cluster('debug', 'debug-table1', 'layer1', 1, [1, 2, 3])
 
-                self.assertEqual('debug', c.use_case)
-                self.assertEqual('debug-table1', c.use_case_table)
-                self.assertEqual(1, c.cluster_label)
-                self.assertEqual([1, 2, 3], c.nodes)
-            except Exception as e:
-                print(e)
+class TestCluster(unittest.TestCase):
+    def test_init_Cluster(self):
+        c = Cluster('debug', 'debug-table1', 'layer1', 1, [1, 2, 3])
 
-    if __name__ == '__main__':
-        unittest.main()
-except Exception as e:
-    print ("Exception found:")
-    print (e)
+        self.assertEqual('debug', c.use_case)
+        self.assertEqual('debug-table1', c.use_case_table)
+        self.assertEqual(1, c.cluster_label)
+        self.assertEqual([1, 2, 3], c.nodes)
+
+if __name__ == '__main__':
+    unittest.main()

src/data-hub/role-stage-discovery-microservice/app/tests/test_cluster_result.py

-try:
-    import unittest
-    import sys
-    for path in ['../', './']:
-        sys.path.insert(1, path)
-
-    # python -m unittest discover
-    from processing.clustering import ClusterResultConverter, ClusterResult
-    from typing import List, Dict, Any
-
-    class TestClusterResult(unittest.TestCase):
-        converter:ClusterResultConverter = None
-
-        def setUp(self):
-            try:
-                self.converter = ClusterResultConverter()
-            except Exception as e:
-                print (e)
-
-        def test_result_undefined_feature(self):
-            try:
-                cluster_groups = self._get_some_cluster_groups_1d()
-                cluster_res = self.converter.convert_to_cluster_results(
-                    cluster_groups=cluster_groups,
-                    features=[]
-                )
-
-                self.assert_correct_cluster_result_len(cluster_groups, cluster_res)
-                self.assert_correct_cluster_result_labels(['n.a.','n.a.','n.a.'], cluster_res)
-            except Exception as e:
-                print (e)
-
-        def test_result_1d_feature(self):
-            try:
-                cluster_groups = self._get_some_cluster_groups_1d()
-                cluster_res = self.converter.convert_to_cluster_results(
-                    cluster_groups=cluster_groups,
-                    features=['v']
-                )
-                
-
-                self.assert_correct_cluster_result_len(cluster_groups, cluster_res)
-                self.assert_correct_cluster_result_labels(['-1.0 -- 1.0','10.0 -- 11.0','2.0 -- 2.0'], cluster_res)
-
-            except Exception as e:
-                print (e)
-
-        def test_result_2d_features(self):
-
-            try:
-                cluster_groups = self._get_some_cluster_groups_2d()
-                cluster_res = self.converter.convert_to_cluster_results(
-                    cluster_groups=cluster_groups,
-                    features=['v', 'u']
-                )
-
-                self.assert_correct_cluster_result_len(cluster_groups, cluster_res)
-                self.assert_correct_cluster_result_labels([str((0.0,0.0)), str((10.5,10.5)), str((2.0,2.0)), str((3.0,6.0))], cluster_res)
-
-            except Exception as e:
-                print (e)
+import unittest
+import sys
+for path in ['../', './']:
+    sys.path.insert(1, path)
+
+# python -m unittest discover
+from processing.clustering import ClusterResultConverter, ClusterResult
+from typing import List, Dict, Any
+
+class TestClusterResult(unittest.TestCase):
+    converter:ClusterResultConverter = None
+
+    def setUp(self):
+    
+        self.converter = ClusterResultConverter()
+    
+
+    def test_result_undefined_feature(self):
+        cluster_groups = self._get_some_cluster_groups_1d()
+        cluster_res = self.converter.convert_to_cluster_results(
+            cluster_groups=cluster_groups,
+            features=[]
+        )
+
+        self.assert_correct_cluster_result_len(cluster_groups, cluster_res)
+        self.assert_correct_cluster_result_labels(['n.a.','n.a.','n.a.'], cluster_res)
+
+    def test_result_1d_feature(self):
+        cluster_groups = self._get_some_cluster_groups_1d()
+        cluster_res = self.converter.convert_to_cluster_results(
+            cluster_groups=cluster_groups,
+            features=['v']
+        )
         
 
-        #region Custom Assertions
-
-        def assert_correct_cluster_result_len(self, expected: 'original dict of lists', actual: Dict[Any, ClusterResult]):
-            try:
-                self.assertEqual(len(expected), len(actual))
-                for i in range(len(expected)):
-                    self.assertEqual(len(expected[i]), len(actual[i].nodes))
-                    self.assertEqual(expected[i], actual[i].nodes)
-
-            except Exception as e:
-                print (e)
-
-        def assert_correct_cluster_result_labels(self, expected: List[str], actual: Dict[Any, ClusterResult]):
-            try:
-                self.assertEqual(len(expected), len(actual))
-                for i in range(len(expected)):
-                    self.assertEqual(expected[i], actual[i].label)
-            except Exception as e:
-                print (e)
-
-        #endregion Custom Assertions
-
-        #region helper methods
-        def _get_some_cluster_groups_1d(self):
-            return {
-                0: [{'v':'0'}, {'v':'1'}, {'v':'-1'}],
-                1: [{'v':'10'}, {'v':'11'}],
-                2: [{'v':'2'}],
-            }
-
-        def _get_some_cluster_groups_2d(self):
-            return {
-                0: [{'v':'0', 'u':'0'}, {'v':'1', 'u':'1'}, {'v':'-1', 'u':'-1'}],
-                1: [{'v':'10', 'u':'10'}, {'v':'11', 'u':'11'}],
-                2: [{'v':'2', 'u':'2'}],
-                3: [{'v':'7', 'u':'7'}, {'v':'5', 'u':'3'}, {'v':'-3', 'u':'8'}],
-            }
-        #endregion helper methods
-
-    if __name__ == '__main__':
-        unittest.main()
-except Exception as e:
-    print ("Exception found:")
-    print (e)
+        self.assert_correct_cluster_result_len(cluster_groups, cluster_res)
+        self.assert_correct_cluster_result_labels(['-1.0 -- 1.0','10.0 -- 11.0','2.0 -- 2.0'], cluster_res)
+
+    def test_result_2d_features(self):
+
+        cluster_groups = self._get_some_cluster_groups_2d()
+        cluster_res = self.converter.convert_to_cluster_results(
+            cluster_groups=cluster_groups,
+            features=['v', 'u']
+        )
+
+        self.assert_correct_cluster_result_len(cluster_groups, cluster_res)
+        self.assert_correct_cluster_result_labels([str((0.0,0.0)), str((10.5,10.5)), str((2.0,2.0)), str((3.0,6.0))], cluster_res)
+
+    
+
+    #region Custom Assertions
+
+    def assert_correct_cluster_result_len(self, expected: 'original dict of lists', actual: Dict[Any, ClusterResult]):
+        self.assertEqual(len(expected), len(actual))
+        for i in range(len(expected)):
+            self.assertEqual(len(expected[i]), len(actual[i].nodes))
+            self.assertEqual(expected[i], actual[i].nodes)
+
+
+    def assert_correct_cluster_result_labels(self, expected: List[str], actual: Dict[Any, ClusterResult]):
+        self.assertEqual(len(expected), len(actual))
+        for i in range(len(expected)):
+            self.assertEqual(expected[i], actual[i].label)
+
+    #endregion Custom Assertions
+
+    #region helper methods
+    def _get_some_cluster_groups_1d(self):
+        return {
+            0: [{'v':'0'}, {'v':'1'}, {'v':'-1'}],
+            1: [{'v':'10'}, {'v':'11'}],
+            2: [{'v':'2'}],
+        }
+
+    def _get_some_cluster_groups_2d(self):
+        return {
+            0: [{'v':'0', 'u':'0'}, {'v':'1', 'u':'1'}, {'v':'-1', 'u':'-1'}],
+            1: [{'v':'10', 'u':'10'}, {'v':'11', 'u':'11'}],
\ No newline at end of file
+            2: [{'v':'2', 'u':'2'}],
+            3: [{'v':'7', 'u':'7'}, {'v':'5', 'u':'3'}, {'v':'-3', 'u':'8'}],
+        }
+    #endregion helper methods
+
+if __name__ == '__main__':
+    unittest.main()
\ No newline at end of file

src/data-hub/semantic-linking-microservice/app/test_coverage.py

@@ -3,7 +3,9 @@ import sys
 for path in ['../', './']:
     sys.path.insert(1, path)
 
-
+#####################################
+### Don't include for test report ###
+#####################################
 try:
     class TestCoverage(unittest.TestCase):
         def test_init_main(self):

src/data-hub/semantic-linking-microservice/app/tests/test_pipeline.py

@@ -67,8 +67,8 @@ class Test_Pipeline(unittest.TestCase):
                 }
             }
         }
-
-    def testTraceProcessing(self):
+#original name testTraceProcessing
+    def test_handle_new_trace_newTraceMsg_correctlyInserted(self):
         msg = self._buildTraceMessage()
         self.handler.handle_new_trace(msg["content"])
         self.assertEqual(len(self.handler._repository.layernodes),1)

src/participation-hub/business-logic-microservice/app/test_coverage.py

@@ -3,7 +3,9 @@ import sys
 for path in ['../', './']:
     sys.path.insert(1, path)
 
-
+#####################################
+### Don't include for test report ###
+#####################################
 try:
     class TestCoverage(unittest.TestCase):
         def test_init_main(self):

src/participation-hub/business-logic-microservice/app/tests/test_layer_adapter.py

@@ -4,7 +4,7 @@ from db.entities.layer_adapter import LayerAdapter
 
 
 class Test_Layer_Adapter(unittest.TestCase):
-    def test_valid_adapter(self):
+    def test_LayerAdapter_newLayerAdapterObj_validInstantiation(self):
         adapter1 = LayerAdapter("layer1", "use_case", "table", ["a", "c"], ["a"])
         print(adapter1.to_serializable_dict)
 

src/rest-gateway/app/test_coverage.py

@@ -2,6 +2,11 @@ import unittest
 import sys
 for path in ['../', './']:
     sys.path.insert(1, path)
+
+#####################################
+### Don't include for test report ###
+#####################################
+
 try:
     class TestCoverage(unittest.TestCase):
         def test_init_main(self):

src/transaction-hub-in/trace-retrieval-microservice/app/test_coverage.py

@@ -3,6 +3,10 @@ import sys
 for path in ['../', './']:
     sys.path.insert(1, path)
 
+#####################################
+### Don't include for test report ###
+#####################################
+
 try:
     class TestCoverage(unittest.TestCase):
         def test_init_main(self):

src/transaction-hub-in/trace-retrieval-microservice/app/tests/test_MessageHandler.py

@@ -170,7 +170,7 @@ class Test_MessageHandler(unittest.TestCase):
         self.assertEqual('semantic-linking', self.msg_sender.last_message['key'])
         self.assertEqual('new-trace', json.loads(self.msg_sender.last_message['msg'])["type"])
 
-    def test_handleblockchain_duplicateTrace(self):
+    def test_handleBlockchainTransaction_duplicateTrace_oneTransAddedToDuplicateRepo(self):
         msg = self._get_valid_message()
         msg2 = self._get_valid_message()
         msg = eval(msg)
@@ -179,7 +179,7 @@ class Test_MessageHandler(unittest.TestCase):
         self.handler.handle_blockchain_transaction(msg2['content'])
         self.assertEqual(len(self.repo.added_transactions),len(self.repo.duplicated_transactions))
 
-    def test_handleblockchain_duplicateTraceDifferentTable(self):
+    def test_handleBlockchainTransaction_duplicateTraceDifferentTable_bothTransactionsAddedAsUnique(self):
         msg = self._get_valid_message()
         msg2 = self._get_valid_message2()
         msg = eval(msg)
@@ -188,7 +188,7 @@ class Test_MessageHandler(unittest.TestCase):
         self.handler.handle_blockchain_transaction(msg2['content'])
         self.assertEqual(len(self.repo.added_transactions),2)
 
-    def test_handleblockchain_duplicateTraceDifferentUseCase(self):
+    def test_handleBlockchainTransaction_duplicateTraceDifferentUseCase_bothTransactionsAddedAsUnique(self):
         msg = self._get_valid_message()
         msg2 = self._get_valid_message3()
         msg = eval(msg)