NPI-4453 clean up, refactor and rename things to allow easy extention to support any object type, not just DataFrames

Author: treefern

gnssanalysis/gn_utils.py

@@ -5,7 +5,7 @@
 from pyfakefs.fake_filesystem_unittest import TestCase
 from pathlib import Path
 
-from gnssanalysis.gn_utils import DataFrameHashUtils, delete_entire_directory
+from gnssanalysis.gn_utils import UnitTestBaseliner, delete_entire_directory
 import gnssanalysis.gn_utils as ga_utils
 
 
@@ -69,30 +69,30 @@ def test_configure_logging(self):
         self.assertEqual(logger_not_output, None)
 
 
-class TestDataFrameHashUtils(unittest.TestCase):
+class TestUnitTestBaseliner(unittest.TestCase):
 
     def test_verify_refusal_in_wrong_mode(self):
-        mode_backup = DataFrameHashUtils.mode
+        mode_backup = UnitTestBaseliner.mode
         try:
             df = DataFrame(["a", "b", "c"])
 
             # Baseline (do not commit uncommented!) Note: every function needs its own baseline, becuase the
             # function name determines the filename, unless we override that.
-            # DataFrameHashUtils.mode = "baseline"
-            # DataFrameHashUtils.record_baseline([df])
+            # UnitTestBaseliner.mode = "baseline"
+            # UnitTestBaseliner.record_baseline([df])
 
             # In baseline (write) mode, verify should be refused.
-            DataFrameHashUtils.mode = "baseline"
+            UnitTestBaseliner.mode = "baseline"
 
             with self.assertWarns(Warning) as warning_assessor:
                 self.assertFalse(
-                    DataFrameHashUtils.verify([df]),
-                    "DF list verification should not succeed in 'baseline' mode",
+                    UnitTestBaseliner.verify([df]),
+                    "DF / object list verification should not succeed in 'baseline' mode",
                 )
             # Ensure the expected warning, and only that warning, was raised
             captured_warnings = warning_assessor.warnings
             self.assertEqual(
-                "Refusing to run verify method while not in verify mode. Set DataframeHashUtils.mode = 'verify' first",
+                "Refusing to run verify method while not in verify mode. Set UnitTestBaseliner.mode = 'verify' first",
                 str(captured_warnings[0].message),
             )
             self.assertEqual(
@@ -102,22 +102,23 @@ def test_verify_refusal_in_wrong_mode(self):
             )
 
             # Should succeed in correct mode.
-            DataFrameHashUtils.mode = "verify"
+            UnitTestBaseliner.mode = "verify"
             self.assertTrue(
-                DataFrameHashUtils.verify([df]),
-                "DF list verification should succeed in 'verify' mode",
+                UnitTestBaseliner.verify([df]),
+                "DF / object list verification should succeed in 'verify' mode",
             )
         finally:
             # Ensure flag reset to avoid impacts on other tests (across the whole suite)
-            DataFrameHashUtils.mode = mode_backup
+            UnitTestBaseliner.mode = mode_backup
 
     def test_repeat_caller_rejection(self):
         # These functions determine what files to write/read baselines from, based on the identity of the (test)
         # function that called them. Therefore, calling twice from the same function would cause the *same baseline
         # files* to be read/written for a different part of the unit test.
         # That would have the effect of:
         # - in write mode: overwriting the baseline file for a previous part of the test function.
-        # - in read mode: repeating verification of the same file against a different DF list (which would likely fail).
+        # - in read mode: repeating verification of the same file against a different DF / object list (which would
+        #   likely fail).
 
         # We're only testing it with the verify function below, but both verify and baseline functions use the same
         # caller check logic, and store the caller record statically in a class variable. ?
@@ -126,51 +127,51 @@ def test_repeat_caller_rejection(self):
 
         # Baseline (every function needs its own baseline, becuase the function name determines the filename,
         # unless we override that)
-        # DataFrameHashUtils.mode = "baseline"
-        # DataFrameHashUtils.record_baseline([df])
+        # UnitTestBaseliner.mode = "baseline"
+        # UnitTestBaseliner.record_baseline([df])
 
         self.assertTrue(
-            DataFrameHashUtils.verify([df]),
-            "DF list verification should succeed on *first* call from a function.",
+            UnitTestBaseliner.verify([df]),
+            "DF / object list verification should succeed on *first* call from a function.",
         )
         with self.assertRaises(ValueError):
-            DataFrameHashUtils.verify([df])
-            self.fail("DF list verification should fail on *second*/repeated calls from a function.")
+            UnitTestBaseliner.verify([df])
+            self.fail("DF / object list verification should fail on *second*/repeated calls from a function.")
 
-    def test_duplicate_df_rejection(self):
+    def test_duplicate_object_rejection(self):
 
-        # List to aggregate DFs for hashing
-        dfs_to_hash: list[DataFrame] = []
+        # List to aggregate DFs / objects for hashing
+        objects_to_hash: list[object] = []
 
         df = DataFrame(["a", "b", "c"])  # Let's call this Dataframe 'a'
-        dfs_to_hash.extend([df])
+        objects_to_hash.extend([df])
 
         # Overwrite local variable, as often happens in our unit tests
         df = DataFrame(["b", "c", "d"])  # Let's call this Dataframe 'b'
 
         # This might look questionable, but is ok, because we saved a reference to dataframe 'a' to the list,
         # before overwriting local var 'df' to point at dataframe 'b'.
-        dfs_to_hash.extend([df])
+        objects_to_hash.extend([df])
 
         # Baseline this test (this should only be committed commented out!)
-        # DataFrameHashUtils.mode = "baseline"
-        # DataFrameHashUtils.record_baseline(dfs_to_hash)
+        # UnitTestBaseliner.mode = "baseline"
+        # UnitTestBaseliner.record_baseline(dfs_to_hash)
 
         # Will return True if verification succeeded. False if baseline missing or mode != verify
         self.assertTrue(
-            DataFrameHashUtils.verify(dfs_to_hash),
-            "DF list verification should succeed here (unless baseline files are missing, or baselining has been turned on)",
+            UnitTestBaseliner.verify(objects_to_hash),
+            "DF / object list verification should succeed here (unless baseline files are missing, or baselining has been turned on)",
         )
 
         # The local variable df still points to the same DF, so now the list contains [a,b,b]. This should be an error.
-        dfs_to_hash.extend([df])
+        objects_to_hash.extend([df])
         with self.assertRaises(ValueError):
-            DataFrameHashUtils.verify(dfs_to_hash)
+            UnitTestBaseliner.verify(objects_to_hash)
 
     def test_caller_identity_fetch(self):
         def wrapper_function():
-            class_name, func_name = DataFrameHashUtils.get_grandparent_caller_id()
-            self.assertEqual(class_name, "TestDataFrameHashUtils")
+            class_name, func_name = UnitTestBaseliner.get_grandparent_caller_id()
+            self.assertEqual(class_name, "TestUnitTestBaseliner")
             self.assertEqual(func_name, "test_caller_identity_fetch")
 
         # We have to do this (create an extra stack frame) because the function looks for
@@ -187,8 +188,8 @@ def wrapper_function():
 
 #     os.chdir("./tests")
 
-#     df_hash_tests = TestDataFrameHashUtils()
-#     df_hash_tests.test_duplicate_df_rejection()
-#     df_hash_tests.test_verify_refusal_in_wrong_mode
-#     df_hash_tests.test_repeat_caller_rejection()
-#     df_hash_tests.test_caller_identity_fetch()
+#     baseliner_tests = TestUnitTestBaseliner()
+#     baseliner_tests.test_duplicate_object_rejection()
+#     baseliner_tests.test_verify_refusal_in_wrong_mode
+#     baseliner_tests.test_repeat_caller_rejection()
+#     baseliner_tests.test_caller_identity_fetch()