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

pygeai/tests/lab/tools/test_mappers.py

@@ -0,0 +1,198 @@
+import unittest
+import json
+from pygeai.lab.tools.mappers import ToolMapper
+from pygeai.lab.models import Tool, ToolParameter, ToolMessage, ToolList
+
+
+class TestToolMapper(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.lab.tools.test_mappers.TestToolMapper
+    """
+
+    def test_map_parameters_success(self):
+        params_data = [
+            {
+                "key": "param1",
+                "dataType": "String",
+                "description": "First parameter",
+                "isRequired": True,
+                "type": "config",
+                "fromSecret": False,
+                "value": "default1"
+            },
+            {
+                "key": "param2",
+                "dataType": "Integer",
+                "description": "Second parameter",
+                "isRequired": False,
+                "type": "app",
+                "fromSecret": True,
+                "value": "default2"
+            }
+        ]
+        result = ToolMapper._map_parameters(params_data)
+
+        self.assertEqual(len(result), 2)
+        self.assertIsInstance(result[0], ToolParameter)
+        self.assertEqual(result[0].key, "param1")
+        self.assertEqual(result[0].data_type, "String")
+        self.assertEqual(result[0].description, "First parameter")
+        self.assertTrue(result[0].is_required)
+        self.assertEqual(result[0].type, "config")
+        self.assertFalse(result[0].from_secret)
+        self.assertEqual(result[0].value, "default1")
+        self.assertEqual(result[1].key, "param2")
+        self.assertEqual(result[1].data_type, "Integer")
+        self.assertEqual(result[1].type, "app")
+        self.assertTrue(result[1].from_secret)
+
+    def test_map_messages_success(self):
+        messages_data = [
+            {"description": "Warning message", "type": "warning"},
+            {"description": "Error message", "type": "error"}
+        ]
+        result = ToolMapper._map_messages(messages_data)
+
+        self.assertEqual(len(result), 2)
+        self.assertIsInstance(result[0], ToolMessage)
+        self.assertEqual(result[0].description, "Warning message")
+        self.assertEqual(result[0].type, "warning")
+        self.assertEqual(result[1].description, "Error message")
+        self.assertEqual(result[1].type, "error")
+
+    def test_map_to_tool_success_flat_data(self):
+        data = {
+            "name": "TestTool",
+            "description": "A test tool",
+            "scope": "builtin",
+            "parameters": [
+                {"key": "param1", "dataType": "String", "description": "Param 1", "isRequired": True}
+            ],
+            "accessScope": "private",
+            "publicName": "test-tool",
+            "icon": "http://example.com/icon.png",
+            "openApi": "http://example.com/api",
+            "openApiJson": "{\"info\": {\"title\": \"Test API\"}}",
+            "reportEvents": "All",
+            "id": "tool-123",
+            "isDraft": False,
+            "messages": [{"description": "Test warning", "type": "warning"}],
+            "revision": 1,
+            "status": "active"
+        }
+        result = ToolMapper.map_to_tool(data)
+
+        self.assertIsInstance(result, Tool)
+        self.assertEqual(result.name, "TestTool")
+        self.assertEqual(result.description, "A test tool")
+        self.assertEqual(result.scope, "builtin")
+        self.assertEqual(len(result.parameters), 1)
+        self.assertIsInstance(result.parameters[0], ToolParameter)
+        self.assertEqual(result.access_scope, "private")
+        self.assertEqual(result.public_name, "test-tool")
+        self.assertEqual(result.icon, "http://example.com/icon.png")
+        self.assertEqual(result.open_api, "http://example.com/api")
+        self.assertIsInstance(result.open_api_json, dict)
+        self.assertEqual(result.report_events, "All")
+        self.assertEqual(result.id, "tool-123")
+        self.assertFalse(result.is_draft)
+        self.assertEqual(len(result.messages), 1)
+        self.assertIsInstance(result.messages[0], ToolMessage)
+        self.assertEqual(result.revision, 1)
+        self.assertEqual(result.status, "active")
+
+    def test_map_to_tool_success_nested_data(self):
+        data = {
+            "tool": {
+                "name": "NestedTool",
+                "description": "A nested test tool",
+                "scope": "external",
+                "parameters": [
+                    {"key": "param1", "dataType": "String", "description": "Param 1", "isRequired": True}
+                ]
+            }
+        }
+        result = ToolMapper.map_to_tool(data)
+
+        self.assertIsInstance(result, Tool)
+        self.assertEqual(result.name, "NestedTool")
+        self.assertEqual(result.description, "A nested test tool")
+        self.assertEqual(result.scope, "external")
+        self.assertEqual(len(result.parameters), 1)
+
+    def test_map_to_tool_invalid_open_api_json(self):
+        data = {
+            "name": "InvalidTool",
+            "description": "A tool with invalid JSON",
+            "scope": "api",
+            "openApiJson": "invalid_json_string"
+        }
+        with self.assertRaises(ValueError) as context:
+            ToolMapper.map_to_tool(data)
+        self.assertEqual(str(context.exception), "open_api_json must be a valid JSON string or a dict")
+
+    def test_map_to_tool_list_success_with_list(self):
+        data = [
+            {"name": "Tool1", "description": "First tool", "scope": "builtin"},
+            {"name": "Tool2", "description": "Second tool", "scope": "external"}
+        ]
+        result = ToolMapper.map_to_tool_list(data)
+
+        self.assertIsInstance(result, ToolList)
+        self.assertEqual(len(result.tools), 2)
+        self.assertIsInstance(result.tools[0], Tool)
+        self.assertEqual(result.tools[0].name, "Tool1")
+        self.assertEqual(result.tools[1].name, "Tool2")
+
+    def test_map_to_tool_list_success_with_dict(self):
+        data = {
+            "tools": [
+                {"name": "Tool1", "description": "First tool", "scope": "builtin"},
+                {"name": "Tool2", "description": "Second tool", "scope": "external"}
+            ]
+        }
+        result = ToolMapper.map_to_tool_list(data)
+
+        self.assertIsInstance(result, ToolList)
+        self.assertEqual(len(result.tools), 2)
+        self.assertIsInstance(result.tools[0], Tool)
+        self.assertEqual(result.tools[0].name, "Tool1")
+        self.assertEqual(result.tools[1].name, "Tool2")
+
+    def test_map_to_tool_list_empty(self):
+        data = {"tools": []}
+        result = ToolMapper.map_to_tool_list(data)
+
+        self.assertIsInstance(result, ToolList)
+        self.assertEqual(len(result.tools), 0)
+
+    def test_map_to_parameter_list_success_with_list(self):
+        data = [
+            {"key": "param1", "dataType": "String", "description": "Param 1", "isRequired": True},
+            {"key": "param2", "dataType": "Integer", "description": "Param 2", "isRequired": False}
+        ]
+        result = ToolMapper.map_to_parameter_list(data)
+
+        self.assertEqual(len(result), 2)
+        self.assertIsInstance(result[0], ToolParameter)
+        self.assertEqual(result[0].key, "param1")
+        self.assertEqual(result[1].key, "param2")
+
+    def test_map_to_parameter_list_success_with_dict(self):
+        data = {
+            "parameters": [
+                {"key": "param1", "dataType": "String", "description": "Param 1", "isRequired": True}
+            ]
+        }
+        result = ToolMapper.map_to_parameter_list(data)
+
+        self.assertEqual(len(result), 1)
+        self.assertIsInstance(result[0], ToolParameter)
+        self.assertEqual(result[0].key, "param1")
+
+    def test_map_to_parameter_list_empty(self):
+        data = {"parameters": []}
+        result = ToolMapper.map_to_parameter_list(data)
+
+        self.assertEqual(len(result), 0)
+

pygeai/tests/migration/test_strategies.py

@@ -0,0 +1,405 @@
+import unittest
+from unittest.mock import Mock, patch
+
+from pygeai.core.base.models import Error
+from pygeai.migration.strategies import (
+    ProjectMigrationStrategy,
+    AgentMigrationStrategy,
+    ToolMigrationStrategy,
+    AgenticProcessMigrationStrategy,
+    TaskMigrationStrategy,
+)
+from pygeai.core.models import Project
+from pygeai.core.base.responses import ErrorListResponse
+from pygeai.lab.models import Agent, Tool, AgenticProcess, Task
+
+
+class TestMigrationStrategies(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.migration.test_strategies.TestMigrationStrategies
+    """
+
+    def setUp(self):
+        self.from_api_key = "from_key"
+        self.from_instance = "http://from.instance"
+        self.to_api_key = "to_key"
+        self.to_instance = "http://to.instance"
+        self.from_project_id = "proj_123"
+        self.to_project_name = "New Project"
+        self.admin_email = "admin@example.com"
+        self.agent_id = "agent_123"
+        self.tool_id = "tool_123"
+        self.process_id = "process_123"
+        self.task_id = "task_123"
+
+    @patch('pygeai.migration.strategies.OrganizationManager')
+    def test_project_migration_strategy_init(self, mock_org_manager):
+        strategy = ProjectMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            from_project_id=self.from_project_id,
+            to_project_name=self.to_project_name,
+            admin_email=self.admin_email
+        )
+        self.assertEqual(strategy.from_api_key, self.from_api_key)
+        self.assertEqual(strategy.from_instance, self.from_instance)
+        self.assertEqual(strategy.to_api_key, self.to_api_key)
+        self.assertEqual(strategy.to_instance, self.to_instance)
+        self.assertEqual(strategy.from_project_id, self.from_project_id)
+        self.assertEqual(strategy.to_project_name, self.to_project_name)
+        self.assertEqual(strategy.admin_email, self.admin_email)
+        mock_org_manager.assert_any_call(api_key=self.from_api_key, base_url=self.from_instance)
+        mock_org_manager.assert_any_call(api_key=self.to_api_key, base_url=self.to_instance)
+
+    @patch('pygeai.migration.strategies.OrganizationManager')
+    def test_project_migration_success(self, mock_org_manager):
+        mock_source = Mock()
+        mock_destination = Mock()
+        mock_org_manager.side_effect = [mock_source, mock_destination]
+
+        mock_project = Mock(spec=Project, name="Old Project", email="old@example.com")
+        mock_new_project = Mock(spec=Project, name=self.to_project_name, email=self.admin_email)
+        mock_response = Mock(project=mock_new_project)
+
+        mock_source.get_project_data.return_value = Mock(project=mock_project)
+        mock_destination.create_project.return_value = mock_response
+
+        strategy = ProjectMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            from_project_id=self.from_project_id,
+            to_project_name=self.to_project_name,
+            admin_email=self.admin_email
+        )
+        strategy.migrate()
+
+        mock_source.get_project_data.assert_called_with(project_id=self.from_project_id)
+        mock_destination.create_project.assert_called_with(mock_project)
+
+    @patch('pygeai.migration.strategies.OrganizationManager')
+    def test_project_migration_error_no_project_data(self, mock_org_manager):
+        mock_source = Mock()
+        mock_destination = Mock()
+        mock_org_manager.side_effect = [mock_source, mock_destination]
+
+        mock_source.get_project_data.return_value = Mock(spec=[])
+
+        strategy = ProjectMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            from_project_id=self.from_project_id,
+            to_project_name=self.to_project_name,
+            admin_email=self.admin_email
+        )
+
+        with self.assertRaises(ValueError) as context:
+            strategy.migrate()
+        self.assertIn("Unable to retrieve project data", str(context.exception))
+        mock_destination.create_project.assert_not_called()
+
+    @patch('pygeai.migration.strategies.OrganizationManager')
+    def test_project_migration_error_response(self, mock_org_manager):
+        mock_source = Mock()
+        mock_destination = Mock()
+        mock_org_manager.side_effect = [mock_source, mock_destination]
+
+        mock_project = Mock(spec=Project)
+        mock_source.get_project_data.return_value = Mock(project=mock_project)
+        mock_error_response = ErrorListResponse(errors=[Error(id=1, description="Creation failed")])
+        mock_destination.create_project.return_value = mock_error_response
+
+        strategy = ProjectMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            from_project_id=self.from_project_id,
+            to_project_name=self.to_project_name,
+            admin_email=self.admin_email
+        )
+
+        with self.assertRaises(ValueError) as context:
+            strategy.migrate()
+        self.assertIn("Failed to create project", str(context.exception))
+
+    @patch('pygeai.migration.strategies.AILabManager')
+    def test_agent_migration_strategy_init(self, mock_lab_manager):
+        strategy = AgentMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            agent_id=self.agent_id
+        )
+        self.assertEqual(strategy.from_api_key, self.from_api_key)
+        self.assertEqual(strategy.from_instance, self.from_instance)
+        self.assertEqual(strategy.to_api_key, self.to_api_key)
+        self.assertEqual(strategy.to_instance, self.to_instance)
+        self.assertEqual(strategy.agent_id, self.agent_id)
+        mock_lab_manager.assert_any_call(api_key=self.from_api_key, base_url=self.from_instance)
+        mock_lab_manager.assert_any_call(api_key=self.to_api_key, base_url=self.to_instance)
+
+    @patch('pygeai.core.utils.console.Console.write_stdout')
+    @patch('pygeai.migration.strategies.AILabManager')
+    def test_agent_migration_success(self, mock_lab_manager, mock_stdout):
+        mock_source = Mock()
+        mock_destination = Mock()
+        mock_lab_manager.side_effect = [mock_source, mock_destination]
+
+        mock_agent = Mock(spec=Agent)
+        mock_source.get_agent.return_value = mock_agent
+        mock_destination.create_agent.return_value = mock_agent
+
+        strategy = AgentMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            agent_id=self.agent_id
+        )
+        strategy.migrate()
+
+        mock_source.get_agent.assert_called_with(agent_id=self.agent_id)
+        mock_destination.create_agent.assert_called_with(agent=mock_agent)
+        mock_stdout.assert_called_once()
+        self.assertIn("New agent detail:", mock_stdout.call_args[0][0])
+
+    @patch('pygeai.migration.strategies.AILabManager')
+    def test_agent_migration_error_not_agent(self, mock_lab_manager):
+        mock_source = Mock()
+        mock_destination = Mock()
+        mock_lab_manager.side_effect = [mock_source, mock_destination]
+
+        mock_source.get_agent.return_value = Mock(spec=[])
+
+        strategy = AgentMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            agent_id=self.agent_id
+        )
+
+        with self.assertRaises(ValueError) as context:
+            strategy.migrate()
+        self.assertIn("Agent migration failed", str(context.exception))
+        mock_destination.create_agent.assert_not_called()
+
+    @patch('pygeai.migration.strategies.AILabManager')
+    def test_agent_migration_error_exception(self, mock_lab_manager):
+        mock_source = Mock()
+        mock_destination = Mock()
+        mock_lab_manager.side_effect = [mock_source, mock_destination]
+
+        mock_source.get_agent.side_effect = Exception("API Error")
+
+        strategy = AgentMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            agent_id=self.agent_id
+        )
+
+        with self.assertRaises(ValueError) as context:
+            strategy.migrate()
+        self.assertIn("Agent migration failed", str(context.exception))
+
+    @patch('pygeai.migration.strategies.AILabManager')
+    def test_tool_migration_strategy_init(self, mock_lab_manager):
+        strategy = ToolMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            tool_id=self.tool_id
+        )
+        self.assertEqual(strategy.from_api_key, self.from_api_key)
+        self.assertEqual(strategy.from_instance, self.from_instance)
+        self.assertEqual(strategy.to_api_key, self.to_api_key)
+        self.assertEqual(strategy.to_instance, self.to_instance)
+        self.assertEqual(strategy.tool_id, self.tool_id)
+        mock_lab_manager.assert_any_call(api_key=self.from_api_key, base_url=self.from_instance)
+        mock_lab_manager.assert_any_call(api_key=self.to_api_key, base_url=self.to_instance)
+
+    @patch('pygeai.core.utils.console.Console.write_stdout')
+    @patch('pygeai.migration.strategies.AILabManager')
+    def test_tool_migration_success(self, mock_lab_manager, mock_stdout):
+        mock_source = Mock()
+        mock_destination = Mock()
+        mock_lab_manager.side_effect = [mock_source, mock_destination]
+
+        mock_tool = Mock(spec=Tool)
+        mock_source.get_tool.return_value = mock_tool
+        mock_destination.create_tool.return_value = mock_tool
+
+        strategy = ToolMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            tool_id=self.tool_id
+        )
+        strategy.migrate()
+
+        mock_source.get_tool.assert_called_with(tool_id=self.tool_id)
+        mock_destination.create_tool.assert_called_with(tool=mock_tool)
+        mock_stdout.assert_called_once()
+        self.assertIn("New tool detail:", mock_stdout.call_args[0][0])
+
+    @patch('pygeai.migration.strategies.AILabManager')
+    def test_tool_migration_error_not_tool(self, mock_lab_manager):
+        mock_source = Mock()
+        mock_destination = Mock()
+        mock_lab_manager.side_effect = [mock_source, mock_destination]
+
+        mock_source.get_tool.return_value = Mock(spec=[])
+
+        strategy = ToolMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            tool_id=self.tool_id
+        )
+
+        with self.assertRaises(ValueError) as context:
+            strategy.migrate()
+        self.assertIn("Tool migration failed", str(context.exception))
+        mock_destination.create_tool.assert_not_called()
+
+    @patch('pygeai.migration.strategies.AILabManager')
+    def test_process_migration_strategy_init(self, mock_lab_manager):
+        strategy = AgenticProcessMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            process_id=self.process_id
+        )
+        self.assertEqual(strategy.from_api_key, self.from_api_key)
+        self.assertEqual(strategy.from_instance, self.from_instance)
+        self.assertEqual(strategy.to_api_key, self.to_api_key)
+        self.assertEqual(strategy.to_instance, self.to_instance)
+        self.assertEqual(strategy.process_id, self.process_id)
+        mock_lab_manager.assert_any_call(api_key=self.from_api_key, base_url=self.from_instance)
+        mock_lab_manager.assert_any_call(api_key=self.to_api_key, base_url=self.to_instance)
+
+    @patch('pygeai.core.utils.console.Console.write_stdout')
+    @patch('pygeai.migration.strategies.AILabManager')
+    def test_process_migration_success(self, mock_lab_manager, mock_stdout):
+        mock_source = Mock()
+        mock_destination = Mock()
+        mock_lab_manager.side_effect = [mock_source, mock_destination]
+
+        mock_process = Mock(spec=AgenticProcess)
+        mock_source.get_process.return_value = mock_process
+        mock_destination.create_process.return_value = mock_process
+
+        strategy = AgenticProcessMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            process_id=self.process_id
+        )
+        strategy.migrate()
+
+        mock_source.get_process.assert_called_with(process_id=self.process_id)
+        mock_destination.create_process.assert_called_with(process=mock_process)
+        mock_stdout.assert_called_once()
+        self.assertIn("New process detail:", mock_stdout.call_args[0][0])
+
+    @patch('pygeai.migration.strategies.AILabManager')
+    def test_process_migration_error_not_process(self, mock_lab_manager):
+        mock_source = Mock()
+        mock_destination = Mock()
+        mock_lab_manager.side_effect = [mock_source, mock_destination]
+
+        mock_source.get_process.return_value = Mock(spec=[])
+
+        strategy = AgenticProcessMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            process_id=self.process_id
+        )
+
+        with self.assertRaises(ValueError) as context:
+            strategy.migrate()
+        self.assertIn("Process migration failed", str(context.exception))
+        mock_destination.create_process.assert_not_called()
+
+    @patch('pygeai.migration.strategies.AILabManager')
+    def test_task_migration_strategy_init(self, mock_lab_manager):
+        strategy = TaskMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            task_id=self.task_id
+        )
+        self.assertEqual(strategy.from_api_key, self.from_api_key)
+        self.assertEqual(strategy.from_instance, self.from_instance)
+        self.assertEqual(strategy.to_api_key, self.to_api_key)
+        self.assertEqual(strategy.to_instance, self.to_instance)
+        self.assertEqual(strategy.task_id, self.task_id)
+        mock_lab_manager.assert_any_call(api_key=self.from_api_key, base_url=self.from_instance)
+        mock_lab_manager.assert_any_call(api_key=self.to_api_key, base_url=self.to_instance)
+
+    @patch('pygeai.core.utils.console.Console.write_stdout')
+    @patch('pygeai.migration.strategies.AILabManager')
+    def test_task_migration_success(self, mock_lab_manager, mock_stdout):
+        mock_source = Mock()
+        mock_destination = Mock()
+        mock_lab_manager.side_effect = [mock_source, mock_destination]
+
+        mock_task = Mock(spec=Task)
+        mock_source.get_task.return_value = mock_task
+        mock_destination.create_task.return_value = mock_task
+
+        strategy = TaskMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            task_id=self.task_id
+        )
+        strategy.migrate()
+
+        mock_source.get_task.assert_called_with(task_id=self.task_id)
+        mock_destination.create_task.assert_called_with(task=mock_task)
+        mock_stdout.assert_called_once()
+        self.assertIn("New task detail:", mock_stdout.call_args[0][0])
+
+    @patch('pygeai.migration.strategies.AILabManager')
+    def test_task_migration_error_not_task(self, mock_lab_manager):
+        mock_source = Mock()
+        mock_destination = Mock()
+        mock_lab_manager.side_effect = [mock_source, mock_destination]
+
+        mock_source.get_task.return_value = Mock(spec=[])
+
+        strategy = TaskMigrationStrategy(
+            from_api_key=self.from_api_key,
+            from_instance=self.from_instance,
+            to_api_key=self.to_api_key,
+            to_instance=self.to_instance,
+            task_id=self.task_id
+        )
+
+        with self.assertRaises(ValueError) as context:
+            strategy.migrate()
+        self.assertIn("Task migration failed", str(context.exception))
+        mock_destination.create_task.assert_not_called()
+
+
+if __name__ == '__main__':
+    unittest.main()