Fix test cases in relation to changes made with the introduction of the logging system

Author: harryswift01

CodeEntropy/calculations/__init__.py CodeEntropy/__init__.pyCodeEntropy/calculations/__init__.py renamed to CodeEntropy/__init__.py

@@ -2,13 +2,8 @@
 import unittest
 from unittest.mock import MagicMock, mock_open, patch
 
-from CodeEntropy.main_mcc import (
-    arg_map,
-    load_config,
-    main,
-    merge_configs,
-    setup_argparse,
-)
+from CodeEntropy.config.arg_config_manager import ConfigManager
+from CodeEntropy.main_mcc import main
 
 
 class test_maincc(unittest.TestCase):
@@ -58,9 +53,12 @@ def test_load_config(self, mock_exists, mock_file):
         """
         Test loading a valid configuration file.
         """
+
+        arg_config = ConfigManager()
+
         self.setup_file(mock_file)
 
-        config = load_config(self.config_file)
+        config = arg_config.load_config(self.config_file)
 
         self.assertIn("run1", config)
         self.assertEqual(
@@ -72,34 +70,35 @@ def test_load_config_file_not_found(self, mock_file):
         """
         Test loading a configuration file that does not exist.
         """
+
+        arg_config = ConfigManager()
+
         with self.assertRaises(FileNotFoundError):
-            load_config(self.config_file)
+            arg_config.load_config(self.config_file)
 
-    @patch("CodeEntropy.main_mcc.load_config", return_value=None)
+    @patch.object(ConfigManager, "load_config", return_value=None)
     def test_no_cli_no_yaml(self, mock_load_config):
-        """
-        Test behavior when no CLI arguments and no YAML file are provided.
-        Should raise an exception or use defaults.
-        """
+        """Test behavior when no CLI arguments and no YAML file are provided."""
 
         with self.assertRaises(ValueError) as context:
             self.code_entropy()
 
-        self.assertTrue(
-            "No configuration file found, and no CLI arguments were provided."
-            in str(context.exception)
+        self.assertEqual(
+            str(context.exception),
+            "No configuration file found, and no CLI arguments were provided.",
         )
 
     def test_invalid_run_config_type(self):
         """
         Test that passing an invalid type for run_config raises a TypeError.
         """
+        arg_config = ConfigManager()
         args = MagicMock()
         invalid_configs = ["string", 123, 3.14, ["list"], {("tuple_key",): "value"}]
 
         for invalid in invalid_configs:
             with self.assertRaises(TypeError):
-                merge_configs(args, invalid)
+                arg_config.merge_configs(args, invalid)
 
     @patch(
         "argparse.ArgumentParser.parse_args",
@@ -124,7 +123,8 @@ def test_setup_argparse(self, mock_args):
         """
         Test parsing command-line arguments.
         """
-        parser = setup_argparse()
+        arg_config = ConfigManager()
+        parser = arg_config.setup_argparse()
         args = parser.parse_args()
         self.assertEqual(args.top_traj_file, ["/path/to/tpr", "/path/to/trr"])
         self.assertEqual(args.selection_string, "all")
@@ -133,7 +133,8 @@ def test_cli_overrides_defaults(self):
         """
         Test if CLI parameters override default values.
         """
-        parser = setup_argparse()
+        arg_config = ConfigManager()
+        parser = arg_config.setup_argparse()
         args = parser.parse_args(
             ["--top_traj_file", "/cli/path", "--selection_string", "cli_value"]
         )
@@ -146,27 +147,30 @@ def test_yaml_overrides_defaults(self):
         """
         run_config = {"top_traj_file": ["/yaml/path"], "selection_string": "yaml_value"}
         args = argparse.Namespace()
-        merged_args = merge_configs(args, run_config)
+        arg_config = ConfigManager()
+        merged_args = arg_config.merge_configs(args, run_config)
         self.assertEqual(merged_args.top_traj_file, ["/yaml/path"])
         self.assertEqual(merged_args.selection_string, "yaml_value")
 
     def test_cli_overrides_yaml(self):
         """
         Test if CLI parameters override YAML parameters correctly.
         """
-        parser = setup_argparse()
+        arg_config = ConfigManager()
+        parser = arg_config.setup_argparse()
         args = parser.parse_args(
             ["--top_traj_file", "/cli/path", "--selection_string", "cli_value"]
         )
         run_config = {"top_traj_file": ["/yaml/path"], "selection_string": "yaml_value"}
-        merged_args = merge_configs(args, run_config)
+        merged_args = arg_config.merge_configs(args, run_config)
         self.assertEqual(merged_args.top_traj_file, ["/cli/path"])
         self.assertEqual(merged_args.selection_string, "cli_value")
 
     def test_merge_configs(self):
         """
         Test merging default arguments with a run configuration.
         """
+        arg_config = ConfigManager()
         args = MagicMock(
             top_traj_file=None,
             selection_string=None,
@@ -199,7 +203,7 @@ def test_merge_configs(self):
             "force_partitioning": 0.5,
             "waterEntropy": False,
         }
-        merged_args = merge_configs(args, run_config)
+        merged_args = arg_config.merge_configs(args, run_config)
         self.assertEqual(merged_args.top_traj_file, ["/path/to/tpr", "/path/to/trr"])
         self.assertEqual(merged_args.selection_string, "all")
 
@@ -208,12 +212,26 @@ def test_default_values(self, mock_parse_args):
         """
         Test if argument parser assigns default values correctly.
         """
-        default_args = {arg: params["default"] for arg, params in arg_map.items()}
+        arg_config = ConfigManager()
+
+        # Ensure every argument gets a sensible default
+        default_args = {
+            arg: params.get("default", False if "action" in params else None)
+            for arg, params in arg_config.arg_map.items()
+        }
+
+        # Mock argparse to return expected defaults
         mock_parse_args.return_value = MagicMock(**default_args)
-        parser = setup_argparse()
+
+        parser = arg_config.setup_argparse()
         args = parser.parse_args()
-        for arg, params in arg_map.items():
-            self.assertEqual(getattr(args, arg), params["default"])
+
+        # Compare parsed args with expected defaults
+        for arg, params in arg_config.arg_map.items():
+            expected_default = params.get(
+                "default", False if "action" in params else None
+            )
+            self.assertEqual(getattr(args, arg), expected_default)
 
     @patch(
         "argparse.ArgumentParser.parse_args", return_value=MagicMock(top_traj_file=None)
@@ -222,7 +240,8 @@ def test_missing_required_arguments(self, mock_args):
         """
         Test behavior when required arguments are missing.
         """
-        parser = setup_argparse()
+        arg_config = ConfigManager()
+        parser = arg_config.setup_argparse()
         args = parser.parse_args()
         with self.assertRaises(ValueError):
             if not args.top_traj_file:
@@ -234,7 +253,8 @@ def test_invalid_argument_type(self):
         """
         Test handling of invalid argument types.
         """
-        parser = setup_argparse()
+        arg_config = ConfigManager()
+        parser = arg_config.setup_argparse()
         with self.assertRaises(SystemExit):
             parser.parse_args(["--start", "invalid"])
 
@@ -245,7 +265,8 @@ def test_edge_case_argument_values(self, mock_args):
         """
         Test parsing of edge case values.
         """
-        parser = setup_argparse()
+        arg_config = ConfigManager()
+        parser = arg_config.setup_argparse()
         args = parser.parse_args()
         self.assertEqual(args.start, -1)
         self.assertEqual(args.end, -10)
@@ -257,7 +278,10 @@ def test_empty_yaml_config(self, mock_exists, mock_file):
         Test behavior when an empty YAML file is provided.
         Should use defaults or raise an appropriate error.
         """
-        config = load_config(self.config_file)
+
+        arg_config = ConfigManager()
+
+        config = arg_config.load_config(self.config_file)
 
         self.assertIsInstance(config, dict)
         self.assertEqual(config, {})