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

pygeai/tests/cli/commands/test_migrate.py

@@ -0,0 +1,176 @@
+import unittest
+from unittest.mock import patch, Mock
+from pygeai.cli.commands.migrate import clone_project, show_help, migrate_commands
+
+
+class TestMigrateCommands(unittest.TestCase):
+
+    def mock_option(self, name, value=None):
+        option = Mock()
+        option.name = name
+        return (option, value)
+
+    def test_show_help(self):
+        show_help()
+
+    @patch('pygeai.auth.clients.AuthClient')
+    @patch('pygeai.cli.commands.migrate.Console.write_stdout')
+    @patch('pygeai.cli.commands.migrate.MigrationTool')
+    @patch('pygeai.cli.commands.migrate.MigrationOrchestrator')
+    @patch('pygeai.cli.commands.migrate.RAGAssistantClient')
+    @patch('pygeai.cli.commands.migrate.FileManager')
+    @patch('pygeai.cli.commands.migrate.SecretClient')
+    @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_secret_client, 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_secret_instance = Mock()
+        mock_secret_client.return_value = mock_secret_instance
+        mock_secret_instance.list_secrets.return_value = {
+            "secrets": [
+                {
+                    "id": "secret1",
+                    "name": "Test Secret"
+                }
+            ]
+        }
+        
+        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("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_organization_id", "org456"),
+            self.mock_option("admin_email", "admin@example.com"),
+            self.mock_option("all", True)
+        ]
+
+        clone_project(option_list)
+
+        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_secret_instance.list_secrets.assert_called_once()
+        mock_orch_instance.execute.assert_called_once()
+
+    @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}
+
+        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("agents", "all")
+        ]
+
+        clone_project(option_list)
+
+        mock_lab_instance.get_agent_list.assert_called_once()
+        mock_orch_instance.execute.assert_called_once()
+
+    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"),
+        ]
+
+        with self.assertRaises(MissingRequirementException):
+            clone_project(option_list)
+
+    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_project_name", "new_project"),
+            self.mock_option("admin_email", "admin@example.com"),
+            self.mock_option("agents", "all")
+        ]
+
+        with self.assertRaises(MissingRequirementException) as cm:
+            clone_project(option_list)
+        
+        self.assertIn("organization scope API key", str(cm.exception))
+
+    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_project_id", "proj456"),
+            self.mock_option("agents", "all")
+        ]
+
+        with self.assertRaises(MissingRequirementException) as cm:
+            clone_project(option_list)
+        
+        self.assertIn("Destination project API key", str(cm.exception))
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/cli/commands/test_organization.py

@@ -0,0 +1,276 @@
+import unittest
+from unittest.mock import patch, Mock, mock_open
+from pygeai.cli.commands.organization import (
+    show_help,
+    list_assistants,
+    get_project_list,
+    get_project_detail,
+    create_project,
+    update_project,
+    delete_project,
+    get_project_tokens,
+    export_request_data,
+    add_project_member,
+    add_project_member_in_batch,
+    Option
+)
+from pygeai.core.common.exceptions import MissingRequirementException
+
+
+class TestOrganizationCommands(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.cli.commands.test_organization.TestOrganizationCommands
+    """
+    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.organization.Console.write_stdout')
+    @patch('pygeai.cli.commands.organization.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
+
+        show_help()
+
+        mock_build_help.assert_called_once()
+        mock_write_stdout.assert_called_once_with(mock_help_text)
+
+    @patch('pygeai.cli.commands.organization.Console.write_stdout')
+    @patch('pygeai.cli.commands.organization.PluginClient')
+    def test_list_assistants_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.list_assistants.return_value = {"assistants": ["assistant1", "assistant2"]}
+        option_list = [
+            self.mock_option("organization_id", "org123"),
+            self.mock_option("project_id", "proj456")
+        ]
+
+        list_assistants(option_list)
+
+        mock_instance.list_assistants.assert_called_once_with(organization_id="org123", project_id="proj456")
+        mock_write_stdout.assert_called_once_with("Assistant list: \n{'assistants': ['assistant1', 'assistant2']}")
+
+    def test_list_assistants_missing_organization_id(self):
+        option_list = [self.mock_option("project_id", "proj456")]
+
+        with self.assertRaises(MissingRequirementException) as context:
+            list_assistants(option_list)
+
+        self.assertEqual(str(context.exception), "Organization ID and Project ID are required.")
+
+    @patch('pygeai.cli.commands.organization.Console.write_stdout')
+    @patch('pygeai.cli.commands.organization.OrganizationClient')
+    def test_get_project_list_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.get_project_list.return_value = {"projects": ["project1", "project2"]}
+        option_list = [
+            self.mock_option("detail", "full"),
+            self.mock_option("name", "test_project")
+        ]
+
+        get_project_list(option_list)
+
+        mock_instance.get_project_list.assert_called_once_with("full", "test_project")
+        mock_write_stdout.assert_called_once_with("Project list: \n{'projects': ['project1', 'project2']}")
+
+    @patch('pygeai.cli.commands.organization.Console.write_stdout')
+    @patch('pygeai.cli.commands.organization.OrganizationClient')
+    def test_get_project_detail_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.get_project_data.return_value = {"id": "proj123", "name": "Test Project"}
+        option_list = [self.mock_option("project_id", "proj123")]
+
+        get_project_detail(option_list)
+
+        mock_instance.get_project_data.assert_called_once_with(project_id="proj123")
+        mock_write_stdout.assert_called_once_with("Project detail: \n{'id': 'proj123', 'name': 'Test Project'}")
+
+    def test_get_project_detail_missing_project_id(self):
+        option_list = []
+
+        with self.assertRaises(MissingRequirementException) as context:
+            get_project_detail(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot retrieve project detail without project-id")
+
+    @patch('pygeai.cli.commands.organization.Console.write_stdout')
+    @patch('pygeai.cli.commands.organization.OrganizationClient')
+    def test_create_project_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.create_project.return_value = {"id": "proj123", "name": "New Project"}
+        option_list = [
+            self.mock_option("name", "New Project"),
+            self.mock_option("admin_email", "admin@example.com"),
+            self.mock_option("description", "A test project"),
+            self.mock_option("subscription_type", "basic")
+        ]
+
+        create_project(option_list)
+
+        mock_instance.create_project.assert_called_once_with("New Project", "admin@example.com", "A test project")
+        mock_write_stdout.assert_called_once_with("New project: \n{'id': 'proj123', 'name': 'New Project'}")
+
+    def test_create_project_missing_name_and_email(self):
+        option_list = []
+
+        with self.assertRaises(MissingRequirementException) as context:
+            create_project(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot create project without name and administrator's email")
+
+    @patch('pygeai.cli.commands.organization.Console.write_stdout')
+    @patch('pygeai.cli.commands.organization.OrganizationClient')
+    def test_update_project_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.update_project.return_value = {"id": "proj123", "name": "Updated Project"}
+        option_list = [
+            self.mock_option("project_id", "proj123"),
+            self.mock_option("name", "Updated Project"),
+            self.mock_option("description", "Updated description")
+        ]
+
+        update_project(option_list)
+
+        mock_instance.update_project.assert_called_once_with("proj123", "Updated Project", "Updated description")
+        mock_write_stdout.assert_called_once_with("Updated project: \n{'id': 'proj123', 'name': 'Updated Project'}")
+
+    def test_update_project_missing_project_id_and_name(self):
+        option_list = []
+
+        with self.assertRaises(MissingRequirementException) as context:
+            update_project(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot update project without project-id and/or name")
+
+    @patch('pygeai.cli.commands.organization.Console.write_stdout')
+    @patch('pygeai.cli.commands.organization.OrganizationClient')
+    def test_delete_project_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.delete_project.return_value = {"status": "deleted"}
+        option_list = [self.mock_option("project_id", "proj123")]
+
+        delete_project(option_list)
+
+        mock_instance.delete_project.assert_called_once_with("proj123")
+        mock_write_stdout.assert_called_once_with("Deleted project: \n{'status': 'deleted'}")
+
+    def test_delete_project_missing_project_id(self):
+        option_list = []
+
+        with self.assertRaises(MissingRequirementException) as context:
+            delete_project(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot delete project without project-id")
+
+    @patch('pygeai.cli.commands.organization.Console.write_stdout')
+    @patch('pygeai.cli.commands.organization.OrganizationClient')
+    def test_get_project_tokens_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.get_project_tokens.return_value = {"tokens": ["token1", "token2"]}
+        option_list = [self.mock_option("project_id", "proj123")]
+
+        get_project_tokens(option_list)
+
+        mock_instance.get_project_tokens.assert_called_once_with("proj123")
+        mock_write_stdout.assert_called_once_with("Project tokens: \n{'tokens': ['token1', 'token2']}")
+
+    def test_get_project_tokens_missing_project_id(self):
+        option_list = []
+
+        with self.assertRaises(MissingRequirementException) as context:
+            get_project_tokens(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot retrieve project tokens without project-id")
+
+    @patch('pygeai.cli.commands.organization.Console.write_stdout')
+    @patch('pygeai.cli.commands.organization.OrganizationClient')
+    def test_export_request_data_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.export_request_data.return_value = {"data": ["request1", "request2"]}
+        option_list = [
+            self.mock_option("assistant_name", "assistant1"),
+            self.mock_option("status", "completed"),
+            self.mock_option("skip", "10"),
+            self.mock_option("count", "20")
+        ]
+
+        export_request_data(option_list)
+
+        mock_instance.export_request_data.assert_called_once_with("assistant1", "completed", "10", "20")
+        mock_write_stdout.assert_called_once_with("Request data: \n{'data': ['request1', 'request2']}")
+
+    @patch('pygeai.cli.commands.organization.Console.write_stdout')
+    @patch('pygeai.cli.commands.organization.OrganizationClient')
+    def test_add_project_member_success(self, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.add_project_member.return_value = {"status": "invitation sent"}
+        option_list = [
+            self.mock_option("project_id", "proj123"),
+            self.mock_option("user_email", "user@example.com"),
+            self.mock_option("roles", "Project member,Project administrator")
+        ]
+
+        add_project_member(option_list)
+
+        mock_instance.add_project_member.assert_called_once_with("proj123", "user@example.com", ["Project member", "Project administrator"])
+        mock_write_stdout.assert_called_once_with("User invitation sent: \n{'status': 'invitation sent'}")
+
+    def test_add_project_member_missing_fields(self):
+        option_list = [
+            self.mock_option("project_id", "proj123")
+        ]
+
+        with self.assertRaises(MissingRequirementException) as context:
+            add_project_member(option_list)
+
+        self.assertEqual(str(context.exception), "Cannot add project member without project-id, user email, and roles")
+
+    @patch('pygeai.cli.commands.organization.Console.write_stdout')
+    @patch('pygeai.cli.commands.organization.OrganizationClient')
+    @patch('builtins.open', new_callable=mock_open, read_data='proj1,user1@example.com,Project member\nproj2,user2@example.com,Project member,Project administrator\n')
+    @patch('os.path.exists', return_value=True)
+    def test_add_project_member_batch_success(self, mock_exists, mock_file, mock_client, mock_write_stdout):
+        mock_instance = Mock()
+        mock_client.return_value = mock_instance
+        mock_instance.add_project_member.return_value = {"status": "invitation sent"}
+        option_list = [
+            self.mock_option("batch_file", "test.csv")
+        ]
+
+        add_project_member(option_list)
+
+        self.assertEqual(mock_instance.add_project_member.call_count, 2)
+        mock_instance.add_project_member.assert_any_call("proj1", "user1@example.com", ["Project member"])
+        mock_instance.add_project_member.assert_any_call("proj2", "user2@example.com", ["Project member", "Project administrator"])
+
+    @patch('os.path.exists', return_value=False)
+    def test_add_project_member_batch_file_not_found(self, mock_exists):
+        mock_client = Mock()
+
+        with self.assertRaises(MissingRequirementException) as context:
+            add_project_member_in_batch(mock_client, "nonexistent.csv")
+
+        self.assertIn("Batch file not found", str(context.exception))
+
+    @patch('pygeai.cli.commands.organization.Console.write_stdout')
+    @patch('builtins.open', new_callable=mock_open, read_data='proj1,user1@example.com\n')
+    @patch('os.path.exists', return_value=True)
+    def test_add_project_member_batch_invalid_format(self, mock_exists, mock_file, mock_write_stdout):
+        mock_client = Mock()
+        mock_client.add_project_member.return_value = {"status": "invitation sent"}
+
+        add_project_member_in_batch(mock_client, "test.csv")
+
+        calls = [call[0][0] for call in mock_write_stdout.call_args_list]
+        self.assertTrue(any("0 successful, 1 failed" in call for call in calls))
+        self.assertTrue(any("Invalid format" in call for call in calls))