pygeai 0.6.0b6__py3-none-any.whl → 0.6.0b10__py3-none-any.whl

pygeai/tests/cli/commands/test_migrate.py

@@ -1,294 +1,163 @@
 import unittest
 from unittest.mock import patch, Mock
-from pygeai.cli.commands.migrate import (
-    show_help,
-    migrate_base,
-    clone_project,
-    clone_agent,
-    clone_tool,
-    clone_process,
-    clone_task,
-    Option
-)
-from pygeai.core.common.exceptions import MissingRequirementException
+from pygeai.cli.commands.migrate import clone_project, show_help, migrate_commands
 
 
 class TestMigrateCommands(unittest.TestCase):
-    """
-    python -m unittest pygeai.tests.cli.commands.test_migrate.TestMigrateCommands
-    """
-    def setUp(self):
-        # Helper to create Option objects for testing
-        self.mock_option = lambda name, value: (Option(name, [f"--{name}"], f"Description for {name}", True), value)
 
-    @patch('pygeai.cli.commands.migrate.Console.write_stdout')
-    @patch('pygeai.cli.commands.migrate.build_help_text')
-    def test_show_help(self, mock_build_help, mock_write_stdout):
-        mock_help_text = "Mocked help text"
-        mock_build_help.return_value = mock_help_text
+    def mock_option(self, name, value=None):
+        option = Mock()
+        option.name = name
+        return (option, value)
 
+    def test_show_help(self):
         show_help()
 
-        mock_build_help.assert_called_once()
-        mock_write_stdout.assert_called_once_with(mock_help_text)
-
-    def test_migrate_base_success(self):
-        option_list = [
-            self.mock_option("from_api_key", "from_key"),
-            self.mock_option("from_instance", "from_instance"),
-            self.mock_option("to_api_key", "to_key"),
-            self.mock_option("to_instance", "to_instance")
-        ]
-
-        result = migrate_base(option_list)
-
-        self.assertEqual(result, ("from_key", "from_instance", "to_key", "to_instance"))
-
-    def test_migrate_base_missing_source(self):
-        option_list = [
-            self.mock_option("to_api_key", "to_key"),
-            self.mock_option("to_instance", "to_instance")
-        ]
-
-        with self.assertRaises(MissingRequirementException) as context:
-            migrate_base(option_list)
-
-        self.assertEqual(str(context.exception), "Cannot migrate resources without indicating source: API key and instance")
-
+    @patch('pygeai.auth.clients.AuthClient')
     @patch('pygeai.cli.commands.migrate.Console.write_stdout')
     @patch('pygeai.cli.commands.migrate.MigrationTool')
-    @patch('pygeai.cli.commands.migrate.ProjectMigrationStrategy')
-    def test_clone_project_success(self, mock_strategy, mock_tool, mock_write_stdout):
-        mock_strategy_instance = Mock()
-        mock_strategy.return_value = mock_strategy_instance
-        mock_tool_instance = Mock()
-        mock_tool.return_value = mock_tool_instance
-        mock_tool_instance.run_migration.return_value = {"status": "success"}
+    @patch('pygeai.cli.commands.migrate.MigrationOrchestrator')
+    @patch('pygeai.cli.commands.migrate.RAGAssistantClient')
+    @patch('pygeai.cli.commands.migrate.FileManager')
+    @patch('pygeai.cli.commands.migrate.AILabManager')
+    @patch("pygeai.admin.clients.AdminClient.validate_api_token", return_value={"projectId": "test_project"})
+    def test_clone_project_with_all_flag(self, mock_base_client, mock_lab_mgr, mock_file_mgr, mock_rag_client, mock_orchestrator, mock_migration_tool, mock_stdout, mock_auth_client):
+        mock_lab_instance = Mock()
+        mock_lab_mgr.return_value = mock_lab_instance
+        
+        mock_lab_instance.get_agent_list.return_value = Mock(agents=[Mock(id="agent1")])
+        mock_lab_instance.list_tools.return_value = Mock(tools=[Mock(id="tool1")])
+        mock_lab_instance.list_processes.return_value = Mock(processes=[Mock(id="proc1")])
+        mock_lab_instance.list_tasks.return_value = Mock(tasks=[Mock(id="task1")])
+        
+        mock_rag_instance = Mock()
+        mock_rag_client.return_value = mock_rag_instance
+        mock_rag_instance.get_assistants_from_project.return_value = {
+            "assistants": [
+                {
+                    "name": "asst1",
+                    "searchOptions": {},
+                    "indexOptions": {},
+                    "welcomeData": None,
+                    "llmSettings": None
+                }
+            ]
+        }
+        
+        mock_file_instance = Mock()
+        mock_file_mgr.return_value = mock_file_instance
+        mock_file_instance.get_file_list.return_value = Mock(files=[Mock(id="file1")])
+        
+        mock_migration_tool_instance = Mock()
+        mock_migration_tool.return_value = mock_migration_tool_instance
+        mock_migration_tool_instance.run_migration.return_value = "proj456"
+        
+        mock_auth_instance = Mock()
+        mock_auth_client.return_value = mock_auth_instance
+        mock_auth_instance.create_project_api_token.return_value = {"id": "new_project_api_key", "name": "Migration API Key"}
+        
+        mock_orch_instance = Mock()
+        mock_orchestrator.return_value = mock_orch_instance
+        mock_orch_instance.execute.return_value = {"completed": 1, "total": 1, "failed": 0}
+
         option_list = [
             self.mock_option("from_api_key", "from_key"),
+            self.mock_option("from_organization_api_key", "from_org_key"),
             self.mock_option("from_project_id", "proj123"),
             self.mock_option("from_instance", "from_instance"),
-            self.mock_option("to_api_key", "to_key"),
+            self.mock_option("from_organization_id", "org123"),
+            self.mock_option("to_organization_api_key", "to_org_key"),
             self.mock_option("to_project_name", "new_project"),
-            self.mock_option("to_instance", "to_instance"),
-            self.mock_option("admin_email", "admin@example.com")
+            self.mock_option("to_organization_id", "org456"),
+            self.mock_option("admin_email", "admin@example.com"),
+            self.mock_option("all", True)
         ]
 
         clone_project(option_list)
 
-        mock_strategy.assert_called_once_with(
-            from_api_key="from_key",
-            from_project_id="proj123",
-            from_instance="from_instance",
-            to_api_key="to_key",
-            to_project_name="new_project",
-            to_instance="to_instance",
-            admin_email="admin@example.com"
-        )
-        mock_tool.assert_called_once_with(mock_strategy_instance)
-        mock_tool_instance.run_migration.assert_called_once()
-        mock_write_stdout.assert_called_once_with("Migration result: \n{'status': 'success'}")
+        mock_migration_tool_instance.run_migration.assert_called_once()
+        mock_auth_instance.create_project_api_token.assert_called_once()
+        mock_lab_instance.get_agent_list.assert_called_once()
+        mock_lab_instance.list_tools.assert_called_once()
+        mock_lab_instance.list_processes.assert_called_once()
+        mock_lab_instance.list_tasks.assert_called_once()
+        mock_rag_instance.get_assistants_from_project.assert_called_once()
+        mock_file_instance.get_file_list.assert_called_once()
+        mock_orch_instance.execute.assert_called_once()
 
-    def test_clone_project_missing_source(self):
-        option_list = [
-            self.mock_option("to_api_key", "to_key"),
-            self.mock_option("to_project_name", "new_project"),
-            self.mock_option("to_instance", "to_instance"),
-            self.mock_option("admin_email", "admin@example.com")
-        ]
-
-        with self.assertRaises(MissingRequirementException) as context:
-            clone_project(option_list)
-
-        self.assertEqual(str(context.exception), "Cannot migrate resources without indicating source: project and instance")
-
-    def test_clone_project_missing_admin_email(self):
-        option_list = [
-            self.mock_option("from_api_key", "from_key"),
-            self.mock_option("from_project_id", "proj123"),
-            self.mock_option("from_instance", "from_instance"),
-            self.mock_option("to_api_key", "to_key"),
-            self.mock_option("to_project_name", "new_project"),
-            self.mock_option("to_instance", "to_instance")
-        ]
-
-        with self.assertRaises(MissingRequirementException) as context:
-            clone_project(option_list)
-
-        self.assertEqual(str(context.exception), "Admin email for new project must be defined.")
+    @patch('pygeai.cli.commands.migrate.Console.write_stdout')
+    @patch('pygeai.cli.commands.migrate.MigrationOrchestrator')
+    @patch('pygeai.cli.commands.migrate.AILabManager')
+    @patch("pygeai.admin.clients.AdminClient.validate_api_token", return_value={"projectId": "test_project"})
+    def test_clone_project_without_project_creation_no_org_keys_needed(self, mock_base_client, mock_lab_mgr, 
+                                                                         mock_orchestrator, mock_stdout):
+        """Test that migration to existing project works without org keys but requires to_api_key"""
+        mock_lab_instance = Mock()
+        mock_lab_mgr.return_value = mock_lab_instance
+        
+        mock_lab_instance.get_agent_list.return_value = Mock(agents=[Mock(id="agent1")])
+        
+        mock_orch_instance = Mock()
+        mock_orchestrator.return_value = mock_orch_instance
+        mock_orch_instance.execute.return_value = {"completed": 1, "total": 1, "failed": 0}
 
-    @patch('pygeai.cli.commands.migrate.MigrationTool')
-    @patch('pygeai.cli.commands.migrate.AgentMigrationStrategy')
-    def test_clone_agent_success(self, mock_strategy, mock_tool):
-        mock_strategy_instance = Mock()
-        mock_strategy.return_value = mock_strategy_instance
-        mock_tool_instance = Mock()
-        mock_tool.return_value = mock_tool_instance
         option_list = [
             self.mock_option("from_api_key", "from_key"),
             self.mock_option("from_project_id", "proj123"),
             self.mock_option("from_instance", "from_instance"),
+            self.mock_option("to_project_id", "proj456"),
             self.mock_option("to_api_key", "to_key"),
-            self.mock_option("to_project_id", "to_proj123"),
-            self.mock_option("to_instance", "to_instance"),
-            self.mock_option("agent_id", "agent456")
-        ]
-
-        clone_agent(option_list)
-
-        mock_strategy.assert_called_once_with(
-            from_api_key="from_key",
-            from_project_id="proj123",
-            from_instance="from_instance",
-            to_api_key="to_key",
-            to_project_id="to_proj123",
-            to_instance="to_instance",
-            agent_id="agent456"
-        )
-        mock_tool.assert_called_once_with(mock_strategy_instance)
-        mock_tool_instance.run_migration.assert_called_once()
-
-    def test_clone_agent_missing_source(self):
-        option_list = [
-            self.mock_option("to_api_key", "to_key"),
-            self.mock_option("to_project_id", "to_proj123"),
-            self.mock_option("to_instance", "to_instance")
+            self.mock_option("agents", "all")
         ]
 
-        with self.assertRaises(MissingRequirementException) as context:
-            clone_agent(option_list)
+        clone_project(option_list)
 
-        self.assertEqual(str(context.exception), "Cannot migrate resources without indicating source: project, instance and agent id")
+        mock_lab_instance.get_agent_list.assert_called_once()
+        mock_orch_instance.execute.assert_called_once()
 
-    @patch('pygeai.cli.commands.migrate.MigrationTool')
-    @patch('pygeai.cli.commands.migrate.ToolMigrationStrategy')
-    def test_clone_tool_success(self, mock_strategy, mock_tool):
-        mock_strategy_instance = Mock()
-        mock_strategy.return_value = mock_strategy_instance
-        mock_tool_instance = Mock()
-        mock_tool.return_value = mock_tool_instance
+    def test_clone_project_missing_required_params(self):
+        from pygeai.core.common.exceptions import MissingRequirementException
+        
         option_list = [
             self.mock_option("from_api_key", "from_key"),
-            self.mock_option("from_project_id", "proj123"),
-            self.mock_option("from_instance", "from_instance"),
-            self.mock_option("to_api_key", "to_key"),
-            self.mock_option("to_project_id", "to_proj123"),
-            self.mock_option("to_instance", "to_instance"),
-            self.mock_option("tool_id", "tool789")
         ]
 
-        clone_tool(option_list)
-
-        mock_strategy.assert_called_once_with(
-            from_api_key="from_key",
-            from_project_id="proj123",
-            from_instance="from_instance",
-            to_api_key="to_key",
-            to_project_id="to_proj123",
-            to_instance="to_instance",
-            tool_id="tool789"
-        )
-        mock_tool.assert_called_once_with(mock_strategy_instance)
-        mock_tool_instance.run_migration.assert_called_once()
-
-    def test_clone_tool_missing_source(self):
-        option_list = [
-            self.mock_option("to_api_key", "to_key"),
-            self.mock_option("to_project_id", "to_proj123"),
-            self.mock_option("to_instance", "to_instance")
-        ]
-
-        with self.assertRaises(MissingRequirementException) as context:
-            clone_tool(option_list)
-
-        self.assertEqual(str(context.exception), "Cannot migrate resources without indicating source: project, instance, and tool ID")
+        with self.assertRaises(MissingRequirementException):
+            clone_project(option_list)
 
-    @patch('pygeai.cli.commands.migrate.MigrationTool')
-    @patch('pygeai.cli.commands.migrate.AgenticProcessMigrationStrategy')
-    def test_clone_process_success(self, mock_strategy, mock_tool):
-        mock_strategy_instance = Mock()
-        mock_strategy.return_value = mock_strategy_instance
-        mock_tool_instance = Mock()
-        mock_tool.return_value = mock_tool_instance
+    def test_clone_project_missing_org_key_when_creating_project(self):
+        from pygeai.core.common.exceptions import MissingRequirementException
+        
         option_list = [
             self.mock_option("from_api_key", "from_key"),
             self.mock_option("from_project_id", "proj123"),
             self.mock_option("from_instance", "from_instance"),
-            self.mock_option("to_api_key", "to_key"),
-            self.mock_option("to_project_id", "to_proj123"),
-            self.mock_option("to_instance", "to_instance"),
-            self.mock_option("process_id", "proc101")
+            self.mock_option("to_project_name", "new_project"),
+            self.mock_option("admin_email", "admin@example.com"),
+            self.mock_option("agents", "all")
         ]
 
-        clone_process(option_list)
-
-        mock_strategy.assert_called_once_with(
-            from_api_key="from_key",
-            from_project_id="proj123",
-            from_instance="from_instance",
-            to_api_key="to_key",
-            to_project_id="to_proj123",
-            to_instance="to_instance",
-            process_id="proc101"
-        )
-        mock_tool.assert_called_once_with(mock_strategy_instance)
-        mock_tool_instance.run_migration.assert_called_once()
+        with self.assertRaises(MissingRequirementException) as cm:
+            clone_project(option_list)
+        
+        self.assertIn("organization scope API key", str(cm.exception))
 
-    def test_clone_process_missing_source(self):
-        option_list = [
-            self.mock_option("to_api_key", "to_key"),
-            self.mock_option("to_project_id", "to_proj123"),
-            self.mock_option("to_instance", "to_instance")
-        ]
-
-        with self.assertRaises(MissingRequirementException) as context:
-            clone_process(option_list)
-
-        self.assertEqual(str(context.exception), "Cannot migrate resources without indicating source: project, instance, and process ID")
-
-    @patch('pygeai.cli.commands.migrate.Console.write_stdout')
-    @patch('pygeai.cli.commands.migrate.MigrationTool')
-    @patch('pygeai.cli.commands.migrate.TaskMigrationStrategy')
-    def test_clone_task_success(self, mock_strategy, mock_tool, mock_write_stdout):
-        mock_strategy_instance = Mock()
-        mock_strategy.return_value = mock_strategy_instance
-        mock_tool_instance = Mock()
-        mock_tool.return_value = mock_tool_instance
-        mock_tool_instance.run_migration.return_value = {"status": "success"}
+    def test_clone_project_missing_to_api_key_when_using_existing_project(self):
+        from pygeai.core.common.exceptions import MissingRequirementException
+        
         option_list = [
             self.mock_option("from_api_key", "from_key"),
             self.mock_option("from_project_id", "proj123"),
             self.mock_option("from_instance", "from_instance"),
-            self.mock_option("to_api_key", "to_key"),
-            self.mock_option("to_project_id", "to_proj123"),
-            self.mock_option("to_instance", "to_instance"),
-            self.mock_option("task_id", "task202")
+            self.mock_option("to_project_id", "proj456"),
+            self.mock_option("agents", "all")
         ]
 
-        clone_task(option_list)
-
-        mock_strategy.assert_called_once_with(
-            from_api_key="from_key",
-            from_project_id="proj123",
-            from_instance="from_instance",
-            to_api_key="to_key",
-            to_project_id="to_proj123",
-            to_instance="to_instance",
-            task_id="task202"
-        )
-        mock_tool.assert_called_once_with(mock_strategy_instance)
-        mock_tool_instance.run_migration.assert_called_once()
-        mock_write_stdout.assert_called_once_with("Migration result: \n{'status': 'success'}")
-
-    def test_clone_task_missing_source(self):
-        option_list = [
-            self.mock_option("to_api_key", "to_key"),
-            self.mock_option("to_project_id", "to_proj123"),
-            self.mock_option("to_instance", "to_instance")
-        ]
-
-        with self.assertRaises(MissingRequirementException) as context:
-            clone_task(option_list)
+        with self.assertRaises(MissingRequirementException) as cm:
+            clone_project(option_list)
+        
+        self.assertIn("Destination project API key", str(cm.exception))
 
-        self.assertEqual(str(context.exception), "Cannot migrate resources without indicating source: project, instance, and task ID")
 
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/cli/test_error_handler.py

@@ -0,0 +1,225 @@
+import unittest
+from unittest import TestCase
+from unittest.mock import MagicMock
+
+from pygeai.cli.commands import Command, Option, ArgumentsEnum
+from pygeai.cli.error_handler import ErrorHandler, ExitCode
+
+
+class TestErrorHandler(TestCase):
+    """
+    Test suite for the ErrorHandler class.
+    Run with: python -m unittest pygeai.tests.cli.test_error_handler.TestErrorHandler
+    """
+
+    def setUp(self):
+        self.commands = [
+            Command(
+                name='help',
+                identifiers=['help', 'h'],
+                description='Display help',
+                action=None,
+                additional_args=ArgumentsEnum.NOT_AVAILABLE,
+                subcommands=[],
+                options=[]
+            ),
+            Command(
+                name='version',
+                identifiers=['version', 'v'],
+                description='Display version',
+                action=None,
+                additional_args=ArgumentsEnum.NOT_AVAILABLE,
+                subcommands=[],
+                options=[]
+            ),
+            Command(
+                name='configure',
+                identifiers=['configure', 'config', 'c'],
+                description='Configure settings',
+                action=None,
+                additional_args=ArgumentsEnum.OPTIONAL,
+                subcommands=[],
+                options=[]
+            ),
+        ]
+
+        self.options = [
+            Option(
+                name='key',
+                identifiers=['--key', '-k'],
+                description='API key',
+                requires_args=True
+            ),
+            Option(
+                name='url',
+                identifiers=['--url', '-u'],
+                description='API URL',
+                requires_args=True
+            ),
+        ]
+
+    def test_exit_codes_defined(self):
+        """Test that all exit codes are properly defined"""
+        self.assertEqual(ExitCode.SUCCESS, 0)
+        self.assertEqual(ExitCode.USER_INPUT_ERROR, 1)
+        self.assertEqual(ExitCode.MISSING_REQUIREMENT, 2)
+        self.assertEqual(ExitCode.SERVICE_ERROR, 3)
+        self.assertEqual(ExitCode.KEYBOARD_INTERRUPT, 130)
+        self.assertEqual(ExitCode.UNEXPECTED_ERROR, 255)
+
+    def test_format_error_basic(self):
+        """Test basic error formatting"""
+        result = ErrorHandler.format_error("Test Error", "Something went wrong")
+        self.assertIn("ERROR: Something went wrong", result)
+        self.assertIn("Run 'geai help' for usage information.", result)
+
+    def test_format_error_with_suggestion(self):
+        """Test error formatting with suggestion"""
+        result = ErrorHandler.format_error(
+            "Test Error",
+            "Command not found",
+            suggestion="Try using 'help' command"
+        )
+        self.assertIn("ERROR: Command not found", result)
+        self.assertIn("→ Try using 'help' command", result)
+
+    def test_format_error_without_help(self):
+        """Test error formatting without help text"""
+        result = ErrorHandler.format_error(
+            "Test Error",
+            "Critical error",
+            show_help=False
+        )
+        self.assertIn("ERROR: Critical error", result)
+        self.assertNotIn("Run 'geai help'", result)
+
+    def test_find_similar_items_exact_match(self):
+        """Test fuzzy matching with high similarity"""
+        items = ['help', 'version', 'configure']
+        similar = ErrorHandler.find_similar_items('halp', items)
+        self.assertIn('help', similar)
+
+    def test_find_similar_items_no_match(self):
+        """Test fuzzy matching with no similar items"""
+        items = ['help', 'version', 'configure']
+        similar = ErrorHandler.find_similar_items('xyz123', items, threshold=0.6)
+        self.assertEqual(len(similar), 0)
+
+    def test_find_similar_items_multiple_matches(self):
+        """Test fuzzy matching returns top matches"""
+        items = ['configure', 'config', 'configuration', 'help']
+        similar = ErrorHandler.find_similar_items('config', items)
+        self.assertGreater(len(similar), 0)
+        self.assertLessEqual(len(similar), 3)
+
+    def test_get_available_commands(self):
+        """Test extraction of available command identifiers"""
+        identifiers = ErrorHandler.get_available_commands(self.commands)
+        self.assertIn('help', identifiers)
+        self.assertIn('h', identifiers)
+        self.assertIn('version', identifiers)
+        self.assertIn('v', identifiers)
+        self.assertIn('configure', identifiers)
+        self.assertIn('config', identifiers)
+        self.assertIn('c', identifiers)
+
+    def test_get_available_options(self):
+        """Test extraction of available option identifiers"""
+        identifiers = ErrorHandler.get_available_options(self.options)
+        self.assertIn('--key', identifiers)
+        self.assertIn('-k', identifiers)
+        self.assertIn('--url', identifiers)
+        self.assertIn('-u', identifiers)
+
+    def test_handle_unknown_command_with_fuzzy_match(self):
+        """Test unknown command error with fuzzy matching suggestion"""
+        result = ErrorHandler.handle_unknown_command('halp', self.commands)
+        self.assertIn("'halp' is not a valid command", result)
+        self.assertIn("Did you mean", result)
+        self.assertIn("help", result)
+
+    def test_handle_unknown_command_no_match(self):
+        """Test unknown command error without fuzzy match"""
+        result = ErrorHandler.handle_unknown_command('xyz123', self.commands)
+        self.assertIn("'xyz123' is not a valid command", result)
+        self.assertIn("Available commands:", result)
+
+    def test_handle_unknown_option_with_fuzzy_match(self):
+        """Test unknown option error with fuzzy matching"""
+        result = ErrorHandler.handle_unknown_option('--kee', self.options)
+        self.assertIn("'--kee' is not a valid option", result)
+        self.assertIn("Did you mean", result)
+
+    def test_handle_unknown_option_no_match(self):
+        """Test unknown option error without fuzzy match"""
+        result = ErrorHandler.handle_unknown_option('--completely-different-option-xyz123', self.options)
+        self.assertIn("'--completely-different-option-xyz123' is not a valid option", result)
+        self.assertIn("Available options:", result)
+
+    def test_handle_missing_requirement(self):
+        """Test missing requirement error formatting"""
+        result = ErrorHandler.handle_missing_requirement("API key is required")
+        self.assertIn("API key is required", result)
+        self.assertIn("Please provide all required parameters", result)
+
+    def test_handle_invalid_agent(self):
+        """Test invalid agent error formatting"""
+        result = ErrorHandler.handle_invalid_agent("Agent 'test-agent' not found")
+        self.assertIn("Failed to retrieve or validate the agent", result)
+        self.assertIn("Agent 'test-agent' not found", result)
+        self.assertIn("Check your agent configuration", result)
+
+    def test_handle_wrong_argument(self):
+        """Test wrong argument error formatting"""
+        usage = "geai <command> [options]"
+        result = ErrorHandler.handle_wrong_argument("Invalid format", usage)
+        self.assertIn("Invalid format", result)
+        self.assertIn("Check the command syntax", result)
+
+    def test_handle_keyboard_interrupt(self):
+        """Test keyboard interrupt message"""
+        result = ErrorHandler.handle_keyboard_interrupt()
+        self.assertIn("Operation cancelled by user", result)
+
+    def test_handle_unexpected_error(self):
+        """Test unexpected error formatting"""
+        exception = ValueError("Test error")
+        result = ErrorHandler.handle_unexpected_error(exception)
+        self.assertIn("unexpected error occurred", result)
+        self.assertIn("Test error", result)
+        self.assertIn("geai-sdk@globant.com", result)
+
+    def test_fuzzy_matching_threshold(self):
+        """Test that threshold parameter works correctly"""
+        items = ['configure', 'help', 'version']
+        
+        # With high threshold, should not match
+        similar_high = ErrorHandler.find_similar_items('xyz', items, threshold=0.9)
+        self.assertEqual(len(similar_high), 0)
+        
+        # With low threshold, might match
+        similar_low = ErrorHandler.find_similar_items('c', items, threshold=0.3)
+        self.assertGreaterEqual(len(similar_low), 0)
+
+    def test_multiple_command_identifiers_in_suggestions(self):
+        """Test that fuzzy matching works with multiple identifiers"""
+        result = ErrorHandler.handle_unknown_command('configurr', self.commands)
+        # Should suggest 'configure' or 'config'
+        self.assertTrue('configure' in result or 'config' in result)
+
+    def test_error_format_consistency(self):
+        """Test that all error handlers produce consistent format"""
+        results = [
+            ErrorHandler.handle_unknown_command('test', self.commands),
+            ErrorHandler.handle_unknown_option('--test', self.options),
+            ErrorHandler.handle_missing_requirement("test requirement"),
+            ErrorHandler.handle_invalid_agent("test agent"),
+        ]
+        
+        for result in results:
+            self.assertIn("ERROR:", result)
+            self.assertIn("→", result)
+
+
+if __name__ == '__main__':
+    unittest.main()