extend arguments

tests/unit_tests/test_argparser.py

@@ -0,0 +1,164 @@
+import unittest
+from unittest.mock import MagicMock, patch
+from argparse import Namespace
+
+from argenta.orchestrator.argparser.entity import ArgParser, ArgSpace
+from argenta.orchestrator.argparser.arguments.models import (
+    ValueArgument,
+    BooleanArgument,
+    InputArgument,
+    BaseArgument
+)
+
+
+class TestArgumentClasses(unittest.TestCase):
+    def test_value_argument_creation(self):
+        arg = ValueArgument(
+            name="test_arg",
+            prefix="--",
+            help="A test argument.",
+            possible_values=["one", "two"],
+            default="one",
+            is_required=True,
+            is_deprecated=False
+        )
+        self.assertEqual(arg.name, "test_arg")
+        self.assertEqual(arg.prefix, "--")
+        self.assertEqual(arg.help, "A test argument.")
+        self.assertEqual(arg.possible_values, ["one", "two"])
+        self.assertEqual(arg.default, "one")
+        self.assertTrue(arg.is_required)
+        self.assertFalse(arg.is_deprecated)
+        self.assertEqual(arg.action, "store")
+        self.assertEqual(arg.string_entity, "--test_arg")
+
+    def test_boolean_argument_creation(self):
+        arg = BooleanArgument(
+            name="verbose",
+            prefix="-",
+            help="Enable verbose mode.",
+            is_deprecated=True
+        )
+        self.assertEqual(arg.name, "verbose")
+        self.assertEqual(arg.prefix, "-")
+        self.assertEqual(arg.help, "Enable verbose mode.")
+        self.assertTrue(arg.is_deprecated)
+        self.assertEqual(arg.action, "store_true")
+        self.assertEqual(arg.string_entity, "-verbose")
+
+    def test_input_argument_creation(self):
+        arg = InputArgument(
+            name="file",
+            value="/path/to/file",
+            founder_class=ValueArgument
+        )
+        self.assertEqual(arg.name, "file")
+        self.assertEqual(arg.value, "/path/to/file")
+        self.assertEqual(arg.founder_class, ValueArgument)
+
+
+class TestArgParser(unittest.TestCase):
+    def setUp(self):
+        self.value_arg = ValueArgument(name="config", help="Path to config file")
+        self.bool_arg = BooleanArgument(name="debug", help="Enable debug mode")
+        self.processed_args = [self.value_arg, self.bool_arg]
+
+    def test_argparser_initialization(self):
+        parser = ArgParser(
+            processed_args=self.processed_args,
+            name="TestApp",
+            description="A test application.",
+            epilog="Test epilog."
+        )
+        self.assertEqual(parser.name, "TestApp")
+        self.assertEqual(parser.description, "A test application.")
+        self.assertEqual(parser.epilog, "Test epilog.")
+        self.assertEqual(parser.processed_args, self.processed_args)
+
+    @patch('argenta.orchestrator.argparser.entity.ArgumentParser.parse_args')
+    def test_parse_args(self, mock_parse_args: MagicMock):
+        mock_namespace = Namespace(config='config.json', debug=True)
+        mock_parse_args.return_value = mock_namespace
+
+        parser = ArgParser(processed_args=self.processed_args)
+        arg_space = parser.parse_args()
+
+        self.assertIsInstance(arg_space, ArgSpace)
+        self.assertEqual(len(arg_space.all_arguments), 2)
+
+        config_arg = arg_space.get_by_name('config')
+        debug_arg = arg_space.get_by_name('debug')
+
+        self.assertIsNotNone(config_arg)
+        if config_arg:
+            self.assertEqual(config_arg.value, 'config.json')
+            self.assertEqual(config_arg.founder_class, ValueArgument)
+
+        self.assertIsNotNone(debug_arg)
+        if debug_arg:
+            self.assertTrue(debug_arg.value)
+            self.assertEqual(debug_arg.founder_class, BooleanArgument)
+
+
+class TestArgSpace(unittest.TestCase):
+    def setUp(self):
+        self.input_arg1 = InputArgument(name="arg1", value="val1", founder_class=ValueArgument)
+        self.input_arg2 = InputArgument(name="arg2", value="val2", founder_class=BooleanArgument)
+        self.input_arg3 = InputArgument(name="arg3", value="val3", founder_class=ValueArgument)
+        self.arg_space = ArgSpace(all_arguments=[self.input_arg1, self.input_arg2, self.input_arg3])
+
+    def test_argspace_initialization(self):
+        self.assertEqual(len(self.arg_space.all_arguments), 3)
+        self.assertIn(self.input_arg1, self.arg_space.all_arguments)
+        self.assertIn(self.input_arg2, self.arg_space.all_arguments)
+        self.assertIn(self.input_arg3, self.arg_space.all_arguments)
+
+    def test_get_by_name(self):
+        found_arg = self.arg_space.get_by_name("arg1")
+        self.assertIsNotNone(found_arg)
+        if found_arg:
+            self.assertEqual(found_arg, self.input_arg1)
+
+    def test_get_by_name_not_found(self):
+        found_arg = self.arg_space.get_by_name("non_existent_arg")
+        self.assertIsNone(found_arg)
+
+    def test_get_by_type(self):
+        value_args = self.arg_space.get_by_type(ValueArgument)
+        self.assertEqual(len(value_args), 2)
+        self.assertIn(self.input_arg1, value_args)
+        self.assertIn(self.input_arg3, value_args)
+
+        bool_args = self.arg_space.get_by_type(BooleanArgument)
+        self.assertEqual(len(bool_args), 1)
+        self.assertIn(self.input_arg2, bool_args)
+
+    def test_get_by_type_not_found(self):
+        class OtherArgument(BaseArgument):
+            pass
+
+        other_args = self.arg_space.get_by_type(OtherArgument)
+        self.assertEqual(len(other_args), 0)
+
+    def test_from_namespace(self):
+        namespace = Namespace(arg1="val1", debug=True)
+        processed_args = [
+            ValueArgument(name="arg1", prefix="--"),
+            BooleanArgument(name="debug", prefix="-")
+        ]
+
+        arg_space = ArgSpace.from_namespace(namespace, processed_args)
+        self.assertEqual(len(arg_space.all_arguments), 2)
+
+        arg1 = arg_space.get_by_name('arg1')
+        debug_arg = arg_space.get_by_name('debug')
+
+        self.assertIsNotNone(arg1)
+        if arg1:
+            self.assertEqual(arg1.value, "val1")
+            self.assertEqual(arg1.founder_class, ValueArgument)
+
+        self.assertIsNotNone(debug_arg)
+        if debug_arg:
+            self.assertTrue(debug_arg.value)
+            self.assertEqual(debug_arg.founder_class, BooleanArgument)