pygeai 0.1.6__py3-none-any.whl → 0.6.0b15__py3-none-any.whl

pygeai/tests/cli/test_geai_driver.py

@@ -0,0 +1,154 @@
+import unittest
+import sys
+from unittest import TestCase
+from unittest.mock import patch
+from io import StringIO
+
+from pygeai.cli.geai import CLIDriver
+from pygeai.cli.error_handler import ExitCode
+
+
+class TestCLIDriver(TestCase):
+    """
+    Test suite for CLIDriver error handling integration.
+    Run with: python -m unittest pygeai.tests.cli.test_geai_driver.TestCLIDriver
+    """
+
+    def setUp(self):
+        """Set up test fixtures"""
+        self.driver = CLIDriver()
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_unknown_command_exit_code(self, mock_stderr):
+        """Test that unknown command returns correct exit code"""
+        sys.argv = ['geai', 'unknown_command_xyz']
+        exit_code = self.driver.main()
+        self.assertEqual(exit_code, ExitCode.USER_INPUT_ERROR)
+        output = mock_stderr.getvalue()
+        self.assertIn("'unknown_command_xyz' is not a valid command", output)
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_unknown_command_with_fuzzy_match(self, mock_stderr):
+        """Test unknown command with fuzzy matching suggestion"""
+        sys.argv = ['geai', 'halp']
+        exit_code = self.driver.main()
+        self.assertEqual(exit_code, ExitCode.USER_INPUT_ERROR)
+        output = mock_stderr.getvalue()
+        self.assertIn("'halp' is not a valid command", output)
+        self.assertIn("Did you mean", output)
+
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_help_command_exit_code(self, mock_stdout):
+        """Test that help command returns success exit code"""
+        sys.argv = ['geai', 'help']
+        exit_code = self.driver.main()
+        self.assertEqual(exit_code, ExitCode.SUCCESS)
+
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_version_command_exit_code(self, mock_stdout):
+        """Test that version command returns success exit code"""
+        sys.argv = ['geai', 'version']
+        exit_code = self.driver.main()
+        self.assertEqual(exit_code, ExitCode.SUCCESS)
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_invalid_option_exit_code(self, mock_stderr):
+        """Test that invalid option returns correct exit code"""
+        sys.argv = ['geai', 'configure', '--invalid-option-xyz']
+        exit_code = self.driver.main()
+        self.assertEqual(exit_code, ExitCode.USER_INPUT_ERROR)
+        output = mock_stderr.getvalue()
+        self.assertIn("'--invalid-option-xyz' is not a valid option", output)
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_error_message_format(self, mock_stderr):
+        """Test that error messages follow the standard format"""
+        sys.argv = ['geai', 'invalidcmd']
+        exit_code = self.driver.main()
+        output = mock_stderr.getvalue()
+        
+        # Check for standard error format
+        self.assertIn("ERROR [", output)
+        self.assertIn("→", output)
+        self.assertIn("Run 'geai help' for usage information", output)
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_available_commands_shown(self, mock_stderr):
+        """Test that available commands are shown for unknown command"""
+        sys.argv = ['geai', 'xyz123']
+        exit_code = self.driver.main()
+        output = mock_stderr.getvalue()
+        
+        # Should show available commands
+        self.assertIn("Available commands:", output)
+        self.assertIn("help", output)
+        self.assertIn("version", output)
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_similar_command_suggestion(self, mock_stderr):
+        """Test that similar commands are suggested"""
+        sys.argv = ['geai', 'versoin']  # Typo in 'version'
+        exit_code = self.driver.main()
+        output = mock_stderr.getvalue()
+        
+        self.assertIn("Did you mean", output)
+        self.assertIn("version", output)
+
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_keyboard_interrupt_exit_code(self, mock_stdout):
+        """Test keyboard interrupt handling"""
+        sys.argv = ['geai', 'help']
+        
+        with patch.object(self.driver, 'process_command', side_effect=KeyboardInterrupt):
+            exit_code = self.driver.main()
+            self.assertEqual(exit_code, ExitCode.KEYBOARD_INTERRUPT)
+            output = mock_stdout.getvalue()
+            self.assertIn("Operation cancelled", output)
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_unexpected_error_exit_code(self, mock_stderr):
+        """Test unexpected error handling"""
+        sys.argv = ['geai', 'help']
+        
+        with patch.object(self.driver, 'process_command', side_effect=RuntimeError("Test error")):
+            exit_code = self.driver.main()
+            self.assertEqual(exit_code, ExitCode.UNEXPECTED_ERROR)
+            output = mock_stderr.getvalue()
+            self.assertIn("unexpected error", output)
+            self.assertIn("Test error", output)
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_configure_with_typo_in_option(self, mock_stderr):
+        """Test configure command with typo in option"""
+        sys.argv = ['geai', 'configure', '--kee']  # Typo in '--key'
+        exit_code = self.driver.main()
+        self.assertEqual(exit_code, ExitCode.USER_INPUT_ERROR)
+        output = mock_stderr.getvalue()
+        self.assertIn("'--kee' is not a valid option", output)
+
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_default_to_help_when_no_args(self, mock_stdout):
+        """Test that CLI defaults to help when no arguments provided"""
+        sys.argv = ['geai']
+        exit_code = self.driver.main()
+        self.assertEqual(exit_code, ExitCode.SUCCESS)
+        output = mock_stdout.getvalue()
+        self.assertIn("GEAI CLI", output)
+
+    def test_exit_codes_are_different(self):
+        """Test that different error types have different exit codes"""
+        exit_codes = [
+            ExitCode.SUCCESS,
+            ExitCode.USER_INPUT_ERROR,
+            ExitCode.MISSING_REQUIREMENT,
+            ExitCode.SERVICE_ERROR,
+            ExitCode.KEYBOARD_INTERRUPT,
+            ExitCode.UNEXPECTED_ERROR,
+        ]
+        
+        # All exit codes should be unique
+        self.assertEqual(len(exit_codes), len(set(exit_codes)))
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/cli/test_parsers.py

@@ -0,0 +1,154 @@
+import unittest
+from unittest import TestCase
+
+from pygeai.cli.commands import Command, Option, ArgumentsEnum
+from pygeai.cli.parsers import CommandParser
+from pygeai.core.common.exceptions import UnknownArgumentError, MissingRequirementException
+
+
+class TestCommandParser(TestCase):
+    """
+    python -m unittest pygeai.tests.cli.test_parsers.TestCommandParser
+    """
+
+    def setUp(self):
+        self.command_list = [
+            Command(name='organization', identifiers=['org', 'organization'], description='Manage organizations',
+                    action=None, additional_args=ArgumentsEnum.OPTIONAL, subcommands=[], options=[]),
+            Command(name='chat', identifiers=['chat'], description='Interact with chat assistants',
+                    action=None, additional_args=ArgumentsEnum.OPTIONAL, subcommands=[], options=[]),
+            Command(name='help', identifiers=['h', 'help'], description='Display help text',
+                    action=None, additional_args=ArgumentsEnum.OPTIONAL, subcommands=[], options=[]),
+        ]
+
+        self.option_list = [
+            Option(name="detail", identifiers=['--detail', '-d'], description='Defines the level of detail', requires_args=True),
+            Option(name="name", identifiers=['--name', '-n'], description='Name of the project', requires_args=True),
+        ]
+
+        self.parser = CommandParser(self.command_list, self.option_list)
+
+    def test_identify_command_valid(self):
+        command = self.parser.identify_command('org')
+        self.assertEqual(command.name, 'organization')
+
+    def test_identify_command_invalid(self):
+        with self.assertRaises(UnknownArgumentError) as context:
+            self.parser.identify_command('invalid')
+        self.assertEqual(str(context.exception), "'invalid' is not a valid command.")
+
+    def test_extract_option_list_valid(self):
+        args = ['--detail', 'full', '--name', 'Project1']
+        options = self.parser.extract_option_list(args)
+        self.assertEqual(len(options), 2)
+        self.assertEqual(options[0][0].identifiers, ['--detail', '-d'])
+        self.assertEqual(options[0][1], 'full')
+        self.assertEqual(options[1][0].identifiers, ['--name', '-n'])
+        self.assertEqual(options[1][1], 'Project1')
+
+    def test_extract_option_list_invalid(self):
+        args = ['--invalid']
+        with self.assertRaises(UnknownArgumentError) as context:
+            self.parser.extract_option_list(args)
+        self.assertEqual(str(context.exception),
+                         "'--invalid' is not a valid option.")
+
+    def test_identify_command_valid_multiple_identifiers(self):
+        command = self.parser.identify_command('organization')
+        self.assertEqual(command.name, 'organization')
+
+    def test_extract_option_list_valid_multiple_options(self):
+        args = ['--detail', 'full', '--name', 'Project1', '--name', 'Project2']
+        options = self.parser.extract_option_list(args)
+        self.assertEqual(len(options), 3)
+        self.assertEqual(options[0][0].identifiers, ['--detail', '-d'])
+        self.assertEqual(options[0][1], 'full')
+        self.assertEqual(options[1][0].identifiers, ['--name', '-n'])
+        self.assertEqual(options[1][1], 'Project1')
+        self.assertEqual(options[2][0].identifiers, ['--name', '-n'])
+        self.assertEqual(options[2][1], 'Project2')
+
+    def test_extract_option_list_missing_argument(self):
+        args = ['--detail']
+        with self.assertRaises(MissingRequirementException) as context:
+            self.parser.extract_option_list(args)
+        self.assertEqual(str(context.exception), "'detail' requires an argument.")
+
+    def test_identify_command_empty_string(self):
+        with self.assertRaises(UnknownArgumentError) as context:
+            self.parser.identify_command('')
+        self.assertEqual(str(context.exception), "'' is not a valid command.")
+
+    def test_extract_option_list_empty_arguments(self):
+        args = []
+        options = self.parser.extract_option_list(args)
+        self.assertEqual(options, [])
+
+    def test_identify_command_with_subcommands(self):
+        command_with_subcommands = Command(
+            name='organization',
+            identifiers=['org', 'organization'],
+            description='Manage organizations',
+            action=None,
+            additional_args=ArgumentsEnum.OPTIONAL,
+            subcommands=['create', 'delete'],
+            options=[]
+        )
+        self.command_list.append(command_with_subcommands)
+        command = self.parser.identify_command('org')
+        self.assertEqual(command.name, 'organization')
+        self.assertIn('create', command_with_subcommands.subcommands)
+
+    @unittest.skip("Will throw an exception when command is executed because of wrong argument.")
+    def test_extract_option_list_invalid_multiple_missing_arguments(self):
+        args = ['--detail', '--name']
+        with self.assertRaises(MissingRequirementException) as context:
+            self.parser.extract_option_list(args)
+        self.assertIn('requires an argument', str(context.exception))
+
+    def test_identify_command_case_insensitivity(self):
+        with self.assertRaises(UnknownArgumentError) as context:
+             self.parser.identify_command('ORG')
+        self.assertIn('is not a valid command', str(context.exception))
+
+    def test_extract_option_list_valid_with_case_insensitivity(self):
+        args = ['--Detail', 'full', '--NAME', 'Project1']
+        with self.assertRaises(UnknownArgumentError) as context:
+            self.parser.extract_option_list(args)
+        self.assertIn('is not a valid option', str(context.exception))
+
+    def test_extract_option_list_invalid_option_after_valid(self):
+        args = ['--detail', 'full', '--invalid']
+        with self.assertRaises(UnknownArgumentError) as context:
+            self.parser.extract_option_list(args)
+        self.assertEqual(str(context.exception),
+                         "'--invalid' is not a valid option.")
+
+    def test_identify_command_subcommand(self):
+        command_with_subcommands = Command(
+            name='organization',
+            identifiers=['org', 'organization'],
+            description='Manage organizations',
+            action=None,
+            additional_args=ArgumentsEnum.OPTIONAL,
+            subcommands=['create', 'delete'],
+            options=[]
+        )
+        self.command_list.append(command_with_subcommands)
+        subcommand_name = 'create'
+        self.assertIn(subcommand_name, command_with_subcommands.subcommands)
+
+    def test_extract_option_list_ordered_args(self):
+        args = ['--name', 'Project1', '--detail', 'full']
+        options = self.parser.extract_option_list(args)
+        self.assertEqual(len(options), 2)
+        self.assertEqual(options[0][0].identifiers, ['--name', '-n'])
+        self.assertEqual(options[0][1], 'Project1')
+        self.assertEqual(options[1][0].identifiers, ['--detail', '-d'])
+        self.assertEqual(options[1][1], 'full')
+
+    def test_identify_command_no_identifier(self):
+        with self.assertRaises(UnknownArgumentError) as context:
+            self.parser.identify_command('nonexistent')
+        self.assertEqual(str(context.exception),
+                         "'nonexistent' is not a valid command.")

pygeai/tests/core/base/data/mappers.py

@@ -0,0 +1,117 @@
+ORGANIZATION_ID = "cfbff0d1-9375-5685-968c-48ce8b15ae17"
+ORGANIZATION_NAME = "Test Organization"
+
+ASSISTANT_ID = "eac65b96-5ad4-54b4-9baf-449efc21345a"
+ASSISTANT_NAME = "Test Assistant"
+ASSISTANT_TYPE_TEXT = "text"
+ASSISTANT_STATUS_ACTIVE = 1
+ASSISTANT_STATUS_HIDDEN = 2
+ASSISTANT_DESCRIPTION = "Description"
+ASSISTANT_PROMPT = "Your job is to test tests"
+
+ASSISTANT_METADATA_1 = {
+    "key": "category",
+    "type": "string",
+    "value": "support"
+}
+ASSISTANT_METADATA_2 = {
+    "key": "priority",
+    "type": "string",
+    "value": "high"
+}
+
+ASSISTANT_REVISION_1 = {
+    "metadata": [
+        ASSISTANT_METADATA_1,
+        ASSISTANT_METADATA_2,
+    ],
+    "modelId": "model-001",
+    "modelName": "SupportAI",
+    "prompt": "How can I assist you with your support request?",
+    "providerName": "OpenAI",
+    "revisionDescription": "Initial version for support requests",
+    "revisionId": 1,
+    "revisionName": "v1.0",
+    "timestamp": "2025-02-05T12:00:00Z"
+}
+
+ASSISTANT_INTENT_1 = {
+    "assistantIntentDefaultRevision": 1,
+    "assistantIntentDescription": "Handles customer support inquiries",
+    "assistantIntentId": "intent-12345",
+    "assistantIntentName": "Customer Support",
+    "revisions": [
+        ASSISTANT_REVISION_1
+    ]
+}
+
+ASSISTANT_REVISION_2 = {
+    "metadata": [
+        {
+            "key": "category",
+            "type": "string",
+            "value": "recommendation"
+        },
+        {
+            "key": "model_version",
+            "type": "string",
+            "value": "v2.1"
+        }
+    ],
+    "modelId": "model-002",
+    "modelName": "RecommenderAI",
+    "prompt": "Based on your preferences, here are some product recommendations.",
+    "providerName": "OpenAI",
+    "revisionDescription": "Updated recommendation logic",
+    "revisionId": 2,
+    "revisionName": "v2.1",
+    "timestamp": "2025-02-05T14:30:00Z"
+}
+
+ASSISTANT_INTENT_2 = {
+    "assistantIntentDefaultRevision": 2,
+    "assistantIntentDescription": "Handles product recommendations",
+    "assistantIntentId": "intent-67890",
+    "assistantIntentName": "Product Recommendation",
+    "revisions": [
+        ASSISTANT_REVISION_2
+    ]
+}
+
+ASSISTANT_REVISION_3 = {
+    "metadata": [
+        {
+            "key": "category",
+            "type": "string",
+            "value": "scheduling"
+        },
+        {
+            "key": "timezone",
+            "type": "string",
+            "value": "UTC"
+        }
+    ],
+    "modelId": "model-003",
+    "modelName": "SchedulerAI",
+    "prompt": "Let's find a suitable time for your appointment.",
+    "providerName": "Google",
+    "revisionDescription": "Enhanced scheduling features",
+    "revisionId": 3,
+    "revisionName": "v3.0",
+    "timestamp": "2025-02-05T16:45:00Z"
+}
+
+ASSISTANT_INTENT_3 = {
+    "assistantIntentDefaultRevision": 3,
+    "assistantIntentDescription": "Handles appointment scheduling",
+    "assistantIntentId": "intent-54321",
+    "assistantIntentName": "Appointment Scheduler",
+    "revisions": [
+        ASSISTANT_REVISION_3
+    ]
+}
+
+PROJECT_ID = "8c7decd3-2155-5e51-b98b-8e332070a269"
+PROJECT_NAME = "Test Project"
+PROJECT_DESCRIPTION = "This is a test project"
+