paramify 0.1.4__py3-none-any.whl

tests/test_paramify_dynamic.py

@@ -0,0 +1,64 @@
+import unittest
+from paramify.paramify import Paramify
+
+class TestParamifyDynamicSetters(unittest.TestCase):
+
+    def setUp(self):
+        # Sample configuration for dynamic setter tests
+        self.valid_dict_config = {
+            "parameters": [
+                {"name": "param1", "type": "bool", "default": True},
+                {"name": "param2", "type": "int", "default": 42}
+            ]
+        }
+
+    def test_dynamic_setter_creation(self):
+        """Test that dynamic setters are created for each parameter."""
+        paramify = Paramify(self.valid_dict_config, enable_cli=False)
+
+        # Verify that setter methods exist
+        self.assertTrue(hasattr(paramify, "set_param1"))
+        self.assertTrue(hasattr(paramify, "set_param2"))
+
+    def test_dynamic_setter_updates_value(self):
+        """Test that dynamic setters correctly update parameter values."""
+        paramify = Paramify(self.valid_dict_config, enable_cli=False)
+
+        # Use dynamic setters to update values
+        paramify.set_param1(False)
+        paramify.set_param2(100)
+
+        # Verify that values are updated
+        self.assertFalse(paramify.get_parameters()["param1"])
+        self.assertEqual(paramify.get_parameters()["param2"], 100)
+
+    def test_dynamic_setter_validation(self):
+        """Test that dynamic setters validate values before updating."""
+        paramify = Paramify(self.valid_dict_config, enable_cli=False)
+
+        # Attempt to set invalid values and verify exceptions
+        with self.assertRaises(TypeError):
+            paramify.set_param1("not_a_bool")  # Invalid bool value
+
+        with self.assertRaises(TypeError):
+            paramify.set_param2("not_an_int")  # Invalid int value
+
+    def test_dynamic_setter_callbacks(self):
+        """Test that dynamic setters invoke callback methods if defined."""
+        class CallbackTestParamify(Paramify):
+            def __init__(self, *args, **kwargs):
+                super().__init__(*args, **kwargs)
+                self.callback_triggered = False
+
+            def on_param1_set(self, value):
+                self.callback_triggered = True
+
+        # Initialize the Paramify subclass with a callback
+        paramify = CallbackTestParamify(self.valid_dict_config, enable_cli=False)
+
+        # Update param1 and verify the callback is triggered
+        paramify.set_param1(False)
+        self.assertTrue(paramify.callback_triggered)
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_paramify_init.py

@@ -0,0 +1,88 @@
+import unittest
+import json
+import os
+from paramify.paramify import Paramify
+from tempfile import NamedTemporaryFile
+from ruamel.yaml import scanner
+
+
+class TestParamifyInitialization(unittest.TestCase):
+
+    def setUp(self):
+        # Prepare sample configurations for testing
+        self.valid_dict_config = {
+            "parameters": [
+                {"name": "param1", "type": "bool", "default": True},
+                {"name": "param2", "type": "int", "default": 42}
+            ]
+        }
+
+        self.valid_json_file = NamedTemporaryFile(suffix=".json", mode='w', delete=False)
+        json.dump(self.valid_dict_config, self.valid_json_file)
+        self.valid_json_file.close()
+
+        self.invalid_json_file = NamedTemporaryFile(suffix=".json", mode='w', delete=False)
+        self.invalid_json_file.write("invalid-json")
+        self.invalid_json_file.close()
+
+        self.valid_yaml_file = NamedTemporaryFile(suffix=".yaml", mode='w', delete=False)
+        self.valid_yaml_file.write("parameters:\n  - name: param1\n    type: bool\n    default: true\n  - name: param2\n    type: int\n    default: 42\n")
+        self.valid_yaml_file.close()
+
+        self.invalid_yaml_file = NamedTemporaryFile(suffix=".yaml", mode='w', delete=False)
+        self.invalid_yaml_file.write("invalid: yaml: content")
+        self.invalid_yaml_file.close()
+
+    def tearDown(self):
+        # Clean up temporary files
+        os.unlink(self.valid_json_file.name)
+        os.unlink(self.invalid_json_file.name)
+        os.unlink(self.valid_yaml_file.name)
+        os.unlink(self.invalid_yaml_file.name)
+
+    def test_valid_dict_configuration(self):
+        """Test initialization with a valid dictionary configuration."""
+        paramify = Paramify(self.valid_dict_config, enable_cli=False)
+        self.assertEqual(paramify.get_parameters()["param1"], True)
+        self.assertEqual(paramify.get_parameters()["param2"], 42)
+
+    def test_valid_json_file_configuration(self):
+        """Test initialization with a valid JSON file."""
+        paramify = Paramify(self.valid_json_file.name, enable_cli=False)
+        self.assertEqual(paramify.get_parameters()["param1"], True)
+        self.assertEqual(paramify.get_parameters()["param2"], 42)
+
+    def test_valid_yaml_file_configuration(self):
+        """Test initialization with a valid YAML file."""
+        paramify = Paramify(self.valid_yaml_file.name, enable_cli=False)
+        self.assertEqual(paramify.get_parameters()["param1"], True)
+        self.assertEqual(paramify.get_parameters()["param2"], 42)
+
+    def test_invalid_file_format(self):
+        """Test that an invalid file format raises a ValueError."""
+        with self.assertRaises(ValueError):
+            Paramify("invalid_file.txt")
+
+    def test_invalid_json_configuration(self):
+        """Test that an invalid JSON file raises a ValueError."""
+        with self.assertRaises(ValueError):
+            Paramify(self.invalid_json_file.name)
+
+    def test_invalid_yaml_configuration(self):
+        """Test that an invalid YAML file raises a ValueError."""
+        with self.assertRaises(scanner.ScannerError):
+            Paramify(self.invalid_yaml_file.name, enable_cli=False)
+
+    def test_missing_parameters_key(self):
+        """Test that a configuration without a 'parameters' key raises a ValueError."""
+        invalid_config = {"settings": []}  # Missing 'parameters' key
+        with self.assertRaises(ValueError):
+            Paramify(invalid_config)
+
+    def test_empty_configuration(self):
+        """Test that an empty configuration raises a ValueError."""
+        with self.assertRaises(ValueError):
+            Paramify({})
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_paramify_misc.py

@@ -0,0 +1,61 @@
+import unittest
+from paramify.paramify import Paramify
+
+class TestParamifyMiscellaneous(unittest.TestCase):
+
+    def setUp(self):
+        # Sample configuration for testing miscellaneous methods
+        self.valid_dict_config = {
+            "parameters": [
+                {"name": "param1", "type": "bool", "default": True, "label": "Enable Feature"},
+                {"name": "param2", "type": "int", "default": 42, "label": "Maximum Value"}
+            ],
+            "name": "TestApp"
+        }
+
+    def test_get_parameters(self):
+        """Test that get_parameters returns the current parameter values as a dictionary."""
+        paramify = Paramify(self.valid_dict_config, enable_cli=False)
+        parameters = paramify.get_parameters()
+
+        # Verify the returned dictionary matches the expected values
+        expected_parameters = {
+            "param1": True,
+            "param2": 42
+        }
+        self.assertEqual(parameters, expected_parameters)
+
+    def test_update_non_existent_parameter(self):
+        """Test that updating a non-existent parameter raises an AttributeError."""
+        paramify = Paramify(self.valid_dict_config, enable_cli=False)
+
+        # Attempt to set a parameter that doesn't exist
+        with self.assertRaises(AttributeError):
+            paramify.set_param3("value")  # param3 is not defined
+
+    def test_invalid_type_update(self):
+        """Test that updating a parameter with an invalid type raises TypeError."""
+        paramify = Paramify(self.valid_dict_config, enable_cli=False)
+
+        # Attempt to set an invalid type
+        with self.assertRaises(TypeError):
+            paramify.set_param1("not_a_bool")  # param1 expects a bool
+
+        with self.assertRaises(TypeError):
+            paramify.set_param2("not_an_int")  # param2 expects an int
+
+    def test_out_of_range_update(self):
+        """Test that updating a parameter with a value out of acceptable range raises an error."""
+        class RangeValidatingParamify(Paramify):
+            def on_param2_set(self, value):
+                if not (0 <= value <= 100):
+                    raise ValueError("param2 must be between 0 and 100")
+
+        paramify = RangeValidatingParamify(self.valid_dict_config, enable_cli=False)
+
+        # Attempt to set a value out of range
+        with self.assertRaises(ValueError):
+            paramify.set_param2(150)  # Out of range for param2
+                        
+if __name__ == "__main__":
+    unittest.main()

tests/test_paramify_performance.py

@@ -0,0 +1,95 @@
+import unittest
+from paramify.paramify import Paramify
+
+class TestParamifyPerformanceEdgeCases(unittest.TestCase):
+
+    def setUp(self):
+        # Sample configuration for edge case and performance testing
+        self.small_config = {
+            "parameters": [
+                {"name": "param1", "type": "bool", "default": True, "label": "Enable Feature"},
+                {"name": "param2", "type": "int", "default": 42, "label": "Maximum Value"}
+            ],
+            "name": "TestApp"
+        }
+
+        self.large_config = {
+            "parameters": [
+                {"name": f"param{i}", "type": "int", "default": i} for i in range(1000)
+            ],
+            "name": "LargeTestApp"
+        }
+
+    def test_large_configuration(self):
+        """Test initialization and operations with a large configuration."""
+        paramify = Paramify(self.large_config, enable_cli=False)
+
+        # Verify that all parameters are initialized correctly
+        parameters = paramify.get_parameters()
+        self.assertEqual(len(parameters), 1000)
+        for i in range(1000):
+            self.assertEqual(parameters[f"param{i}"], i)
+
+    def test_edge_case_parameter_names(self):
+        """Test handling of edge case parameter names."""
+        edge_case_config = {
+            "parameters": [
+                {"name": "param_with_@_symbol", "type": "str", "default": "value"},
+                {"name": "param_with_a_really_really_long_name_exceeding_normal_limits", "type": "int", "default": 999},
+                {"name": "param_with spaces", "type": "bool", "default": True}
+            ]
+        }
+
+        paramify = Paramify(edge_case_config, enable_cli=False)
+        parameters = paramify.get_parameters()
+
+        # Verify that all edge case parameters are handled correctly
+        self.assertEqual(parameters["param_with_@_symbol"], "value")
+        self.assertEqual(parameters["param_with_a_really_really_long_name_exceeding_normal_limits"], 999)
+        self.assertTrue(parameters["param_with spaces"])
+
+    def test_empty_configuration(self):
+        """Test initialization with an empty configuration."""
+        with self.assertRaises(ValueError):
+            Paramify({}, enable_cli=False)
+
+    def test_conflicting_updates(self):
+        """Test behavior when conflicting updates are made via setters and CLI arguments."""
+        class ConflictParamify(Paramify):
+            def on_param2_set(self, value):
+                self.param2_updated_via_setter = value
+
+        config = {
+            "parameters": [
+                {"name": "param1", "type": "bool", "default": True},
+                {"name": "param2", "type": "int", "default": 42}
+            ]
+        }
+
+        # Simulate CLI arguments
+        with unittest.mock.patch('sys.argv', ['execution.py', '--param2', '100']):
+            paramify = ConflictParamify(config, enable_cli=True)
+
+        # Update via setter after CLI parsing
+        paramify.set_param2(200)
+
+        # Verify the final value
+        self.assertEqual(paramify.get_parameters()["param2"], 200)
+        self.assertEqual(paramify.param2_updated_via_setter, 200)
+
+    def test_stress_dynamic_updates(self):
+        """Stress test for dynamically updating a large number of parameters."""
+        paramify = Paramify(self.large_config, enable_cli=False)
+
+        # Dynamically update all parameters
+        for i in range(1000):
+            setter = getattr(paramify, f"set_param{i}")
+            setter(i * 2)  # Double each parameter's value
+
+        # Verify the updates
+        parameters = paramify.get_parameters()
+        for i in range(1000):
+            self.assertEqual(parameters[f"param{i}"], i * 2)
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_paramify_persist.py

@@ -0,0 +1,80 @@
+import unittest
+import json
+import os
+from tempfile import NamedTemporaryFile
+from paramify.paramify import Paramify
+from ruamel.yaml import YAML
+
+class TestParamifyPersistence(unittest.TestCase):
+
+    def setUp(self):
+        # Prepare a valid JSON configuration file
+        self.valid_json_config = {
+            "parameters": [
+                {"name": "param1", "type": "bool", "default": True},
+                {"name": "param2", "type": "int", "default": 42}
+            ]
+        }
+
+        self.valid_json_file = NamedTemporaryFile(suffix=".json", mode="w", delete=False)
+        json.dump(self.valid_json_config, self.valid_json_file)
+        self.valid_json_file.close()
+
+        # Prepare a valid YAML configuration file
+        self.valid_yaml_file = NamedTemporaryFile(suffix=".yaml", mode="w", delete=False)
+        yaml = YAML()
+        yaml.dump(self.valid_json_config, self.valid_yaml_file)
+        self.valid_yaml_file.close()
+
+    def tearDown(self):
+        # Clean up temporary files
+        os.unlink(self.valid_json_file.name)
+        os.unlink(self.valid_yaml_file.name)
+
+    def test_json_persistence(self):
+        """Test that changes to parameters are persisted to a JSON file."""
+        paramify = Paramify(self.valid_json_file.name, enable_cli=False)
+
+        # Update parameters
+        paramify.set_param1(False)
+        paramify.set_param2(100)
+
+        # Reload the file and verify changes
+        with open(self.valid_json_file.name, "r") as f:
+            updated_config = json.load(f)
+
+        updated_params = {p["name"]: p["default"] for p in updated_config["parameters"]}
+        self.assertFalse(updated_params["param1"])
+        self.assertEqual(updated_params["param2"], 100)
+
+    def test_yaml_persistence(self):
+        """Test that changes to parameters are persisted to a YAML file."""
+        paramify = Paramify(self.valid_yaml_file.name, enable_cli=False)
+
+        # Update parameters
+        paramify.set_param1(False)
+        paramify.set_param2(100)
+
+        # Reload the file and verify changes
+        yaml = YAML()
+        with open(self.valid_yaml_file.name, "r") as f:
+            updated_config = yaml.load(f)
+
+        updated_params = {p["name"]: p["default"] for p in updated_config["parameters"]}
+        self.assertFalse(updated_params["param1"])
+        self.assertEqual(updated_params["param2"], 100)
+
+    def test_no_persistence_for_dict_config(self):
+        """Test that changes are not persisted when initialized with a dictionary configuration."""
+        paramify = Paramify(self.valid_json_config, enable_cli=False)
+
+        # Update parameters
+        paramify.set_param1(False)
+        paramify.set_param2(100)
+
+        # Verify the original configuration is unchanged
+        self.assertTrue(self.valid_json_config["parameters"][0]["default"])
+        self.assertEqual(self.valid_json_config["parameters"][1]["default"], 42)
+
+if __name__ == "__main__":
+    unittest.main()

tests/test_paramify_validation.py

@@ -0,0 +1,61 @@
+import unittest
+from paramify.paramify import Paramify
+from tempfile import NamedTemporaryFile
+
+class TestParamifyValidation(unittest.TestCase):
+
+    def setUp(self):
+        # Prepare sample configurations for testing
+        self.valid_dict_config = {
+            "parameters": [
+                {"name": "param1", "type": "bool", "default": True},
+                {"name": "param2", "type": "int", "default": 42}
+            ]
+        }
+
+    def tearDown(self):
+        pass
+
+    def test_valid_dict_configuration(self):
+        """Test initialization with a valid dictionary configuration."""
+        paramify = Paramify(self.valid_dict_config, enable_cli=False)  # Disable CLI parsing
+        self.assertEqual(paramify.get_parameters()["param1"], True)
+        self.assertEqual(paramify.get_parameters()["param2"], 42)
+
+    def test_type_enforcement(self):
+        """Test that parameter types are enforced during initialization."""
+        invalid_config = {
+            "parameters": [
+                {"name": "param1", "type": "bool", "default": "not_a_bool"},  # Invalid bool
+                {"name": "param2", "type": "int", "default": "not_an_int"}   # Invalid int
+            ]
+        }
+
+        with self.assertRaises(ValueError):
+            Paramify(invalid_config, enable_cli=False)
+
+    def test_missing_default(self):
+        """Test that parameters without a default are initialized as None."""
+        config = {
+            "parameters": [
+                {"name": "param1", "type": "str"},  # No default value
+                {"name": "param2", "type": "int", "default": 10}
+            ]
+        }
+        paramify = Paramify(config, enable_cli=False)
+        self.assertIsNone(paramify.get_parameters()["param1"])
+        self.assertEqual(paramify.get_parameters()["param2"], 10)
+
+
+    def test_optional_parameters(self):
+        """Test that parameters without default values are treated as optional."""
+        config = {
+            "parameters": [
+                {"name": "param1", "type": "float"}  # No default
+            ]
+        }
+        paramify = Paramify(config, enable_cli=False)
+        self.assertIsNone(paramify.get_parameters()["param1"])
+
+if __name__ == "__main__":
+    unittest.main()