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

pygeai/tests/analytics/test_clients.py

@@ -0,0 +1,86 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from pygeai.analytics.clients import AnalyticsClient
+
+
+class TestAnalyticsClient(unittest.TestCase):
+
+    def setUp(self):
+        self.client = AnalyticsClient()
+
+    @patch('pygeai.analytics.clients.AnalyticsClient.api_service')
+    def test_get_agents_created_and_modified(self, mock_api_service):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"createdAgents": 10, "modifiedAgents": 5}
+        mock_api_service.get.return_value = mock_response
+
+        result = self.client.get_agents_created_and_modified("2024-01-01", "2024-01-31")
+
+        self.assertEqual(result["createdAgents"], 10)
+        self.assertEqual(result["modifiedAgents"], 5)
+        mock_api_service.get.assert_called_once()
+
+    @patch('pygeai.analytics.clients.AnalyticsClient.api_service')
+    def test_get_total_requests_per_day(self, mock_api_service):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "requestsPerDay": [
+                {"date": "2024-01-01", "totalRequests": 100, "totalRequestsWithError": 5}
+            ]
+        }
+        mock_api_service.get.return_value = mock_response
+
+        result = self.client.get_total_requests_per_day("2024-01-01", "2024-01-31")
+
+        self.assertIn("requestsPerDay", result)
+        mock_api_service.get.assert_called_once()
+
+    @patch('pygeai.analytics.clients.AnalyticsClient.api_service')
+    def test_get_total_requests_per_day_with_agent_name(self, mock_api_service):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "requestsPerDay": [
+                {"date": "2024-01-01", "totalRequests": 50, "totalRequestsWithError": 2}
+            ]
+        }
+        mock_api_service.get.return_value = mock_response
+
+        result = self.client.get_total_requests_per_day("2024-01-01", "2024-01-31", agent_name="TestAgent")
+
+        self.assertIn("requestsPerDay", result)
+        mock_api_service.get.assert_called_once()
+
+    @patch('pygeai.analytics.clients.AnalyticsClient.api_service')
+    def test_get_average_cost_per_request(self, mock_api_service):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {"averageCost": 2.50}
+        mock_api_service.get.return_value = mock_response
+
+        result = self.client.get_average_cost_per_request("2024-01-01", "2024-01-31")
+
+        self.assertEqual(result["averageCost"], 2.50)
+        mock_api_service.get.assert_called_once()
+
+    @patch('pygeai.analytics.clients.AnalyticsClient.api_service')
+    def test_get_total_tokens(self, mock_api_service):
+        mock_response = MagicMock()
+        mock_response.status_code = 200
+        mock_response.json.return_value = {
+            "totalInputTokens": 5000,
+            "totalOutputTokens": 3000,
+            "totalTokens": 8000
+        }
+        mock_api_service.get.return_value = mock_response
+
+        result = self.client.get_total_tokens("2024-01-01", "2024-01-31")
+
+        self.assertEqual(result["totalTokens"], 8000)
+        mock_api_service.get.assert_called_once()
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/analytics/test_managers.py

@@ -0,0 +1,94 @@
+import unittest
+from unittest.mock import patch
+from pygeai.core.common.exceptions import APIError
+from pygeai.core.handlers import ErrorHandler
+from pygeai.analytics.managers import AnalyticsManager
+from pygeai.analytics.mappers import AnalyticsResponseMapper
+from pygeai.analytics.responses import (
+    AgentsCreatedAndModifiedResponse, TotalRequestsPerDayResponse,
+    AverageCostPerRequestResponse, NumberOfTokensResponse
+)
+
+
+class TestAnalyticsManager(unittest.TestCase):
+
+    def setUp(self):
+        self.manager = AnalyticsManager()
+        self.error_response = {"errors": [{"id": 404, "description": "Not found"}]}
+
+    @patch("pygeai.analytics.clients.AnalyticsClient.get_agents_created_and_modified")
+    def test_get_agents_created_and_modified(self, mock_get_agents):
+        mock_response = AgentsCreatedAndModifiedResponse(createdAgents=10, modifiedAgents=5)
+        mock_get_agents.return_value = {"createdAgents": 10, "modifiedAgents": 5}
+
+        with patch.object(AnalyticsResponseMapper, 'map_to_agents_created_and_modified_response', return_value=mock_response):
+            response = self.manager.get_agents_created_and_modified("2024-01-01", "2024-01-31")
+
+        self.assertIsInstance(response, AgentsCreatedAndModifiedResponse)
+        self.assertEqual(response.createdAgents, 10)
+        self.assertEqual(response.modifiedAgents, 5)
+        mock_get_agents.assert_called_once_with(start_date="2024-01-01", end_date="2024-01-31")
+
+    @patch("pygeai.analytics.clients.AnalyticsClient.get_agents_created_and_modified")
+    def test_get_agents_created_and_modified_error(self, mock_get_agents):
+        mock_get_agents.return_value = self.error_response
+
+        with patch.object(ErrorHandler, 'has_errors', return_value=True):
+            with patch.object(ErrorHandler, 'extract_error', return_value="Not found"):
+                with self.assertRaises(APIError) as context:
+                    self.manager.get_agents_created_and_modified("2024-01-01", "2024-01-31")
+
+        self.assertIn("Error received while retrieving agents created and modified", str(context.exception))
+        mock_get_agents.assert_called_once_with(start_date="2024-01-01", end_date="2024-01-31")
+
+    @patch("pygeai.analytics.clients.AnalyticsClient.get_total_requests_per_day")
+    def test_get_total_requests_per_day(self, mock_get_requests):
+        mock_response = TotalRequestsPerDayResponse(requestsPerDay=[])
+        mock_get_requests.return_value = {"requestsPerDay": []}
+
+        with patch.object(AnalyticsResponseMapper, 'map_to_total_requests_per_day_response', return_value=mock_response):
+            response = self.manager.get_total_requests_per_day("2024-01-01", "2024-01-31")
+
+        self.assertIsInstance(response, TotalRequestsPerDayResponse)
+        mock_get_requests.assert_called_once_with(start_date="2024-01-01", end_date="2024-01-31", agent_name=None)
+
+    @patch("pygeai.analytics.clients.AnalyticsClient.get_total_requests_per_day")
+    def test_get_total_requests_per_day_with_agent_name(self, mock_get_requests):
+        mock_response = TotalRequestsPerDayResponse(requestsPerDay=[])
+        mock_get_requests.return_value = {"requestsPerDay": []}
+
+        with patch.object(AnalyticsResponseMapper, 'map_to_total_requests_per_day_response', return_value=mock_response):
+            response = self.manager.get_total_requests_per_day("2024-01-01", "2024-01-31", agent_name="TestAgent")
+
+        self.assertIsInstance(response, TotalRequestsPerDayResponse)
+        mock_get_requests.assert_called_once_with(start_date="2024-01-01", end_date="2024-01-31", agent_name="TestAgent")
+
+    @patch("pygeai.analytics.clients.AnalyticsClient.get_average_cost_per_request")
+    def test_get_average_cost_per_request(self, mock_get_cost):
+        mock_response = AverageCostPerRequestResponse(averageCost=2.50)
+        mock_get_cost.return_value = {"averageCost": 2.50}
+
+        with patch.object(AnalyticsResponseMapper, 'map_to_average_cost_per_request_response', return_value=mock_response):
+            response = self.manager.get_average_cost_per_request("2024-01-01", "2024-01-31")
+
+        self.assertIsInstance(response, AverageCostPerRequestResponse)
+        self.assertEqual(response.averageCost, 2.50)
+
+    @patch("pygeai.analytics.clients.AnalyticsClient.get_total_tokens")
+    def test_get_total_tokens(self, mock_get_tokens):
+        mock_response = NumberOfTokensResponse(totalInputTokens=5000, totalOutputTokens=3000, totalTokens=8000)
+        mock_get_tokens.return_value = {
+            "totalInputTokens": 5000,
+            "totalOutputTokens": 3000,
+            "totalTokens": 8000
+        }
+
+        with patch.object(AnalyticsResponseMapper, 'map_to_total_tokens_response', return_value=mock_response):
+            response = self.manager.get_total_tokens("2024-01-01", "2024-01-31")
+
+        self.assertIsInstance(response, NumberOfTokensResponse)
+        self.assertEqual(response.totalTokens, 8000)
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/analytics/test_mappers.py

@@ -0,0 +1,84 @@
+import unittest
+from pygeai.analytics.mappers import AnalyticsResponseMapper
+from pygeai.analytics.responses import (
+    AgentsCreatedAndModifiedResponse, AgentsCreatedAndModifiedPerDayResponse,
+    FlowsCreatedAndModifiedResponse, AverageCostPerRequestResponse,
+    TotalRequestsPerDayResponse, NumberOfTokensResponse
+)
+
+
+class TestAnalyticsResponseMapper(unittest.TestCase):
+
+    def test_map_to_agents_created_and_modified_response(self):
+        data = {
+            "createdAgents": 15,
+            "modifiedAgents": 8
+        }
+        response = AnalyticsResponseMapper.map_to_agents_created_and_modified_response(data)
+        self.assertIsInstance(response, AgentsCreatedAndModifiedResponse)
+        self.assertEqual(response.createdAgents, 15)
+        self.assertEqual(response.modifiedAgents, 8)
+
+    def test_map_to_agents_created_and_modified_per_day_response(self):
+        data = {
+            "agentsCreatedAndModifiedPerDay": [
+                {"date": "2024-01-01", "createdAgents": 5, "modifiedAgents": 2},
+                {"date": "2024-01-02", "createdAgents": 3, "modifiedAgents": 1}
+            ]
+        }
+        response = AnalyticsResponseMapper.map_to_agents_created_and_modified_per_day_response(data)
+        self.assertIsInstance(response, AgentsCreatedAndModifiedPerDayResponse)
+        self.assertEqual(len(response.agentsCreatedAndModifiedPerDay), 2)
+        self.assertEqual(response.agentsCreatedAndModifiedPerDay[0].date, "2024-01-01")
+
+    def test_map_to_flows_created_and_modified_response(self):
+        data = {
+            "createdFlows": 10,
+            "modifiedFlows": 5
+        }
+        response = AnalyticsResponseMapper.map_to_flows_created_and_modified_response(data)
+        self.assertIsInstance(response, FlowsCreatedAndModifiedResponse)
+        self.assertEqual(response.createdFlows, 10)
+        self.assertEqual(response.modifiedFlows, 5)
+
+    def test_map_to_average_cost_per_request_response(self):
+        data = {
+            "averageCost": 3.25
+        }
+        response = AnalyticsResponseMapper.map_to_average_cost_per_request_response(data)
+        self.assertIsInstance(response, AverageCostPerRequestResponse)
+        self.assertEqual(response.averageCost, 3.25)
+
+    def test_map_to_total_requests_per_day_response(self):
+        data = {
+            "requestsPerDay": [
+                {"date": "2024-01-01", "totalRequests": 150, "totalRequestsWithError": 10},
+                {"date": "2024-01-02", "totalRequests": 200, "totalRequestsWithError": 5}
+            ]
+        }
+        response = AnalyticsResponseMapper.map_to_total_requests_per_day_response(data)
+        self.assertIsInstance(response, TotalRequestsPerDayResponse)
+        self.assertEqual(len(response.requestsPerDay), 2)
+        self.assertEqual(response.requestsPerDay[0].totalRequests, 150)
+
+    def test_map_to_number_of_tokens_response(self):
+        data = {
+            "totalInputTokens": 5000,
+            "totalOutputTokens": 3000,
+            "totalTokens": 8000
+        }
+        response = AnalyticsResponseMapper.map_to_number_of_tokens_response(data)
+        self.assertIsInstance(response, NumberOfTokensResponse)
+        self.assertEqual(response.totalInputTokens, 5000)
+        self.assertEqual(response.totalOutputTokens, 3000)
+        self.assertEqual(response.totalTokens, 8000)
+
+    def test_map_with_missing_fields(self):
+        data = {}
+        response = AnalyticsResponseMapper.map_to_agents_created_and_modified_response(data)
+        self.assertEqual(response.createdAgents, 0)
+        self.assertEqual(response.modifiedAgents, 0)
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/analytics/test_responses.py

@@ -0,0 +1,73 @@
+import unittest
+from pygeai.analytics.responses import (
+    AgentsCreatedAndModifiedResponse, AgentActivityPerDayItem, AgentsCreatedAndModifiedPerDayResponse,
+    FlowsCreatedAndModifiedResponse, FlowActivityPerDayItem, FlowsCreatedAndModifiedPerDayResponse,
+    ProcessesCreatedAndModifiedResponse, AgentUsagePerUserItem, AgentUsagePerUserResponse,
+    AverageCostPerRequestResponse, AverageCostPerUserResponse, TotalRequestsPerDayResponse,
+    RequestsPerDayItem
+)
+
+
+class TestAnalyticsResponses(unittest.TestCase):
+
+    def test_agents_created_and_modified_response(self):
+        response = AgentsCreatedAndModifiedResponse(createdAgents=10, modifiedAgents=5)
+        self.assertEqual(response.createdAgents, 10)
+        self.assertEqual(response.modifiedAgents, 5)
+
+    def test_agents_created_and_modified_per_day_response(self):
+        items = [
+            AgentActivityPerDayItem(date="2024-01-01", createdAgents=5, modifiedAgents=2),
+            AgentActivityPerDayItem(date="2024-01-02", createdAgents=3, modifiedAgents=1)
+        ]
+        response = AgentsCreatedAndModifiedPerDayResponse(agentsCreatedAndModifiedPerDay=items)
+        self.assertEqual(len(response.agentsCreatedAndModifiedPerDay), 2)
+        self.assertEqual(response.agentsCreatedAndModifiedPerDay[0].date, "2024-01-01")
+
+    def test_flows_created_and_modified_response(self):
+        response = FlowsCreatedAndModifiedResponse(createdFlows=8, modifiedFlows=3)
+        self.assertEqual(response.createdFlows, 8)
+        self.assertEqual(response.modifiedFlows, 3)
+
+    def test_flows_created_and_modified_per_day_response(self):
+        items = [
+            FlowActivityPerDayItem(date="2024-01-01", createdFlows=4, modifiedFlows=1)
+        ]
+        response = FlowsCreatedAndModifiedPerDayResponse(flowsCreatedAndModifiedPerDay=items)
+        self.assertEqual(len(response.flowsCreatedAndModifiedPerDay), 1)
+
+    def test_processes_created_and_modified_response(self):
+        response = ProcessesCreatedAndModifiedResponse(createdProcesses=12, modifiedProcesses=6)
+        self.assertEqual(response.createdProcesses, 12)
+        self.assertEqual(response.modifiedProcesses, 6)
+
+    def test_agent_usage_per_user_response(self):
+        items = [
+            AgentUsagePerUserItem(userId="user1", userName="John Doe", totalCost=100.50, totalRequests=50, totalTokens=1000)
+        ]
+        response = AgentUsagePerUserResponse(agentUsagePerUser=items)
+        self.assertEqual(len(response.agentUsagePerUser), 1)
+        self.assertEqual(response.agentUsagePerUser[0].userId, "user1")
+        self.assertEqual(response.agentUsagePerUser[0].totalCost, 100.50)
+
+    def test_average_cost_per_request_response(self):
+        response = AverageCostPerRequestResponse(averageCost=2.50)
+        self.assertEqual(response.averageCost, 2.50)
+
+    def test_average_cost_per_user_response(self):
+        response = AverageCostPerUserResponse(averageCost=150.75)
+        self.assertEqual(response.averageCost, 150.75)
+
+    def test_total_requests_per_day_response(self):
+        items = [
+            RequestsPerDayItem(date="2024-01-01", totalRequests=100, totalRequestsWithError=5),
+            RequestsPerDayItem(date="2024-01-02", totalRequests=120, totalRequestsWithError=3)
+        ]
+        response = TotalRequestsPerDayResponse(requestsPerDay=items)
+        self.assertEqual(len(response.requestsPerDay), 2)
+        self.assertEqual(response.requestsPerDay[0].totalRequests, 100)
+        self.assertEqual(response.requestsPerDay[1].totalRequestsWithError, 3)
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/auth/test_oauth.py

@@ -0,0 +1,172 @@
+import unittest
+from unittest.mock import patch, MagicMock
+
+from pygeai.lab.clients import AILabClient
+from pygeai.evaluation.clients import EvaluationClient
+from pygeai.core.secrets.clients import SecretClient
+from pygeai.core.base.clients import BaseClient
+from pygeai.core.common.exceptions import MissingRequirementException
+
+
+class TestOAuthAuthentication(unittest.TestCase):
+    """
+    Tests for OAuth authentication support across all clients.
+    
+    python -m unittest pygeai.tests.auth.test_oauth.TestOAuthAuthentication
+    """
+
+    def test_base_client_oauth_initialization(self):
+        """Test BaseClient accepts OAuth parameters"""
+        client = BaseClient(
+            base_url="https://api.test.com",
+            access_token="oauth_token_123",
+            project_id="project-456"
+        )
+        
+        self.assertEqual(client.api_service.token, "oauth_token_123")
+        self.assertEqual(client.api_service.project_id, "project-456")
+
+    def test_base_client_api_key_initialization(self):
+        """Test BaseClient backward compatibility with API key"""
+        client = BaseClient(
+            api_key="api_key_123",
+            base_url="https://api.test.com"
+        )
+        
+        self.assertEqual(client.api_service.token, "api_key_123")
+        self.assertIsNone(client.api_service.project_id)
+
+    def test_base_client_incomplete_oauth_raises_error(self):
+        """Test that providing only access_token without project_id raises error"""
+        with self.assertRaises(MissingRequirementException) as context:
+            BaseClient(
+                base_url="https://api.test.com",
+                access_token="oauth_token_123"
+            )
+        
+        self.assertIn("project_id is required when using access_token", str(context.exception))
+
+    def test_oauth_headers_are_added_correctly(self):
+        """Test that OAuth headers are added correctly by _add_token_to_headers"""
+        client = BaseClient(
+            base_url="https://api.test.com",
+            access_token="oauth_token_123",
+            project_id="project-456"
+        )
+        
+        headers = client.api_service._add_token_to_headers({})
+        
+        self.assertEqual(headers.get('Authorization'), 'Bearer oauth_token_123')
+        self.assertEqual(headers.get('ProjectId'), 'project-456')
+
+    def test_api_key_headers_use_bearer(self):
+        """Test that API key also uses Bearer format in Authorization header"""
+        client = BaseClient(
+            api_key="api_key_123",
+            base_url="https://api.test.com"
+        )
+        
+        headers = client.api_service._add_token_to_headers({})
+        
+        self.assertEqual(headers.get('Authorization'), 'Bearer api_key_123')
+        self.assertNotIn('ProjectId', headers)
+
+    def test_oauth_headers_preserve_existing_headers(self):
+        """Test that OAuth headers are added while preserving existing headers"""
+        client = BaseClient(
+            base_url="https://api.test.com",
+            access_token="oauth_token_123",
+            project_id="project-456"
+        )
+        
+        existing_headers = {'Content-Type': 'application/json', 'Custom-Header': 'value'}
+        headers = client.api_service._add_token_to_headers(existing_headers.copy())
+        
+        self.assertEqual(headers.get('Authorization'), 'Bearer oauth_token_123')
+        self.assertEqual(headers.get('ProjectId'), 'project-456')
+        self.assertEqual(headers.get('Content-Type'), 'application/json')
+        self.assertEqual(headers.get('Custom-Header'), 'value')
+
+    def test_ailab_client_oauth_initialization(self):
+        """Test AILabClient accepts OAuth parameters with project_id keyword-only"""
+        client = AILabClient(
+            base_url="https://api.test.com",
+            access_token="oauth_token_123",
+            project_id="project-456"
+        )
+        
+        self.assertEqual(client.api_service.token, "oauth_token_123")
+        self.assertEqual(client.api_service.project_id, "project-456")
+        self.assertEqual(client.project_id, "project-456")
+
+    def test_ailab_client_api_key_with_project_id(self):
+        """Test AILabClient with API key and project_id"""
+        client = AILabClient(
+            api_key="api_key_123",
+            base_url="https://api.test.com",
+            project_id="project-456"
+        )
+        
+        self.assertEqual(client.api_service.token, "api_key_123")
+        self.assertEqual(client.project_id, "project-456")
+
+    def test_evaluation_client_oauth_initialization(self):
+        """Test EvaluationClient accepts OAuth parameters"""
+        client = EvaluationClient(
+            base_url="https://api.test.com",
+            eval_url="https://eval.test.com",
+            access_token="oauth_token_123",
+            project_id="project-456"
+        )
+        
+        self.assertEqual(client.api_service.token, "oauth_token_123")
+        self.assertEqual(client.api_service.project_id, "project-456")
+
+    def test_evaluation_client_api_key_backward_compatibility(self):
+        """Test EvaluationClient backward compatibility with API key"""
+        client = EvaluationClient(
+            api_key="api_key_123",
+            base_url="https://api.test.com",
+            eval_url="https://eval.test.com"
+        )
+        
+        self.assertEqual(client.api_service.token, "api_key_123")
+
+    def test_secret_client_oauth_initialization(self):
+        """Test SecretClient accepts OAuth parameters"""
+        client = SecretClient(
+            base_url="https://api.test.com",
+            access_token="oauth_token_123",
+            project_id="project-456"
+        )
+        
+        self.assertEqual(client.api_service.token, "oauth_token_123")
+        self.assertEqual(client.api_service.project_id, "project-456")
+
+    def test_secret_client_api_key_backward_compatibility(self):
+        """Test SecretClient backward compatibility with API key"""
+        client = SecretClient(
+            api_key="api_key_123",
+            base_url="https://api.test.com"
+        )
+        
+        self.assertEqual(client.api_service.token, "api_key_123")
+
+    def test_oauth_token_used_over_api_key_in_headers(self):
+        """Test that when OAuth token is used, it's properly formatted"""
+        client = BaseClient(
+            base_url="https://api.test.com",
+            access_token="oauth_token_wins",
+            project_id="project-wins"
+        )
+        
+        self.assertEqual(client.api_service.token, "oauth_token_wins")
+        self.assertEqual(client.api_service.project_id, "project-wins")
+        
+        headers = client.api_service._add_token_to_headers({})
+        self.assertEqual(headers['Authorization'], 'Bearer oauth_token_wins')
+        self.assertEqual(headers['ProjectId'], 'project-wins')
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/cli/commands/test_migrate.py

@@ -19,9 +19,10 @@ class TestMigrateCommands(unittest.TestCase):
     @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_file_mgr, mock_rag_client, mock_orchestrator, mock_migration_tool, mock_stdout, mock_auth_client):
+    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
         
@@ -48,6 +49,17 @@ class TestMigrateCommands(unittest.TestCase):
         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"
@@ -83,6 +95,7 @@ class TestMigrateCommands(unittest.TestCase):
         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')

pygeai/tests/cli/commands/test_organization.py

@@ -1,5 +1,5 @@
 import unittest
-from unittest.mock import patch, Mock
+from unittest.mock import patch, Mock, mock_open
 from pygeai.cli.commands.organization import (
     show_help,
     list_assistants,
@@ -10,6 +10,8 @@ from pygeai.cli.commands.organization import (
     delete_project,
     get_project_tokens,
     export_request_data,
+    add_project_member,
+    add_project_member_in_batch,
     Option
 )
 from pygeai.core.common.exceptions import MissingRequirementException
@@ -206,3 +208,69 @@ class TestOrganizationCommands(unittest.TestCase):
         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))

pygeai/tests/cli/test_error_handler.py

@@ -70,7 +70,7 @@ class TestErrorHandler(TestCase):
     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("ERROR [Test Error]: Something went wrong", result)
         self.assertIn("Run 'geai help' for usage information.", result)
 
     def test_format_error_with_suggestion(self):
@@ -80,7 +80,7 @@ class TestErrorHandler(TestCase):
             "Command not found",
             suggestion="Try using 'help' command"
         )
-        self.assertIn("ERROR: Command not found", result)
+        self.assertIn("ERROR [Test Error]: Command not found", result)
         self.assertIn("→ Try using 'help' command", result)
 
     def test_format_error_without_help(self):
@@ -90,7 +90,7 @@ class TestErrorHandler(TestCase):
             "Critical error",
             show_help=False
         )
-        self.assertIn("ERROR: Critical error", result)
+        self.assertIn("ERROR [Test Error]: Critical error", result)
         self.assertNotIn("Run 'geai help'", result)
 
     def test_find_similar_items_exact_match(self):
@@ -217,7 +217,7 @@ class TestErrorHandler(TestCase):
         ]
         
         for result in results:
-            self.assertIn("ERROR:", result)
+            self.assertIn("ERROR [", result)
             self.assertIn("→", result)