pygeai 0.5.0__py3-none-any.whl → 0.6.0b3__py3-none-any.whl

pygeai/tests/cli/commands/test_secrets.py

@@ -0,0 +1,171 @@
+import unittest
+from unittest.mock import patch, Mock
+
+from pygeai.cli.commands.secrets import (
+    show_help,
+    get_secret,
+    create_secret,
+    update_secret,
+    list_secrets,
+    set_secret_accesses,
+    get_secret_accesses
+)
+from pygeai.core.common.exceptions import MissingRequirementException, WrongArgumentError
+
+
+class TestSecretsCommands(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.cli.commands.test_secrets.TestSecretsCommands
+    """
+
+    def test_show_help(self):
+        with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+            show_help()
+            mock_stdout.assert_called_once()
+
+    def test_get_secret_success(self):
+        option_list = [
+            (Mock(spec=['name'], name="secret_id"), "secret-123")
+        ]
+        option_list[0][0].name = "secret_id"
+
+        with patch('pygeai.core.secrets.clients.SecretClient.get_secret', return_value="Secret data") as mock_get:
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                get_secret(option_list)
+                mock_get.assert_called_once_with(secret_id="secret-123")
+                mock_stdout.assert_called_once_with("Get secret result: \nSecret data")
+
+    def test_get_secret_missing_id(self):
+        option_list = []
+        with self.assertRaises(MissingRequirementException) as context:
+            get_secret(option_list)
+        self.assertEqual(str(context.exception), "Cannot retrieve secret without specifying secret-id")
+
+    def test_create_secret_success(self):
+        option_list = [
+            (Mock(spec=['name'], name="name"), "MySecret"),
+            (Mock(spec=['name'], name="secret_string"), "secret-value"),
+            (Mock(spec=['name'], name="description"), "Test description")
+        ]
+        for opt, _ in option_list:
+            opt.name = opt._mock_name
+
+        with patch('pygeai.core.secrets.clients.SecretClient.create_secret', return_value="Created secret") as mock_create:
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                create_secret(option_list)
+                mock_create.assert_called_once_with(
+                    name="MySecret",
+                    secret_string="secret-value",
+                    description="Test description"
+                )
+                mock_stdout.assert_called_once_with("Create secret result: \nCreated secret")
+
+    def test_create_secret_missing_name(self):
+        option_list = [
+            (Mock(spec=['name'], name="secret_string"), "secret-value")
+        ]
+        option_list[0][0].name = "secret_string"
+
+        with self.assertRaises(MissingRequirementException) as context:
+            create_secret(option_list)
+        self.assertEqual(str(context.exception), "Cannot create secret without specifying name and secret-string")
+
+    def test_create_secret_missing_secret_string(self):
+        option_list = [
+            (Mock(spec=['name'], name="name"), "MySecret")
+        ]
+        option_list[0][0].name = "name"
+
+        with self.assertRaises(MissingRequirementException) as context:
+            create_secret(option_list)
+        self.assertEqual(str(context.exception), "Cannot create secret without specifying name and secret-string")
+
+    def test_update_secret_success(self):
+        option_list = [
+            (Mock(spec=['name'], name="secret_id"), "secret-123"),
+            (Mock(spec=['name'], name="name"), "UpdatedSecret"),
+            (Mock(spec=['name'], name="secret_string"), "updated-value")
+        ]
+        for opt, _ in option_list:
+            opt.name = opt._mock_name
+
+        with patch('pygeai.core.secrets.clients.SecretClient.update_secret', return_value="Updated secret") as mock_update:
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                update_secret(option_list)
+                mock_update.assert_called_once()
+                mock_stdout.assert_called_once_with("Update secret result: \nUpdated secret")
+
+    def test_update_secret_missing_id(self):
+        option_list = [
+            (Mock(spec=['name'], name="name"), "UpdatedSecret")
+        ]
+        option_list[0][0].name = "name"
+
+        with self.assertRaises(MissingRequirementException) as context:
+            update_secret(option_list)
+        self.assertEqual(str(context.exception), "Cannot update secret without specifying secret-id, name, and secret-string")
+
+    def test_list_secrets_success(self):
+        option_list = []
+
+        with patch('pygeai.core.secrets.clients.SecretClient.list_secrets', return_value="Secrets list") as mock_list:
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                list_secrets(option_list)
+                mock_list.assert_called_once_with(name=None, id=None, start=0, count=10)
+                mock_stdout.assert_called_once_with("List secrets result: \nSecrets list")
+
+    def test_set_secret_accesses_success(self):
+        option_list = [
+            (Mock(spec=['name'], name="secret_id"), "secret-123"),
+            (Mock(spec=['name'], name="access_list"), '[{"project_id": "project-456"}]')
+        ]
+        for opt, _ in option_list:
+            opt.name = opt._mock_name
+
+        with patch('pygeai.core.secrets.clients.SecretClient.set_secret_accesses', return_value="Access set") as mock_set:
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                set_secret_accesses(option_list)
+                mock_set.assert_called_once()
+                mock_stdout.assert_called_once_with("Set secret accesses result: \nAccess set")
+
+    def test_set_secret_accesses_missing_secret_id(self):
+        option_list = [
+            (Mock(spec=['name'], name="project_id"), "project-456")
+        ]
+        option_list[0][0].name = "project_id"
+
+        with self.assertRaises(MissingRequirementException) as context:
+            set_secret_accesses(option_list)
+        self.assertEqual(str(context.exception), "Cannot set secret accesses without specifying secret-id and access-list")
+
+    def test_set_secret_accesses_missing_project_id(self):
+        option_list = [
+            (Mock(spec=['name'], name="secret_id"), "secret-123")
+        ]
+        option_list[0][0].name = "secret_id"
+
+        with self.assertRaises(MissingRequirementException) as context:
+            set_secret_accesses(option_list)
+        self.assertEqual(str(context.exception), "Cannot set secret accesses without specifying secret-id and access-list")
+
+    def test_get_secret_accesses_success(self):
+        option_list = [
+            (Mock(spec=['name'], name="secret_id"), "secret-123")
+        ]
+        option_list[0][0].name = "secret_id"
+
+        with patch('pygeai.core.secrets.clients.SecretClient.get_secret_accesses', return_value="Access list") as mock_get:
+            with patch('pygeai.core.utils.console.Console.write_stdout') as mock_stdout:
+                get_secret_accesses(option_list)
+                mock_get.assert_called_once_with(secret_id="secret-123")
+                mock_stdout.assert_called_once_with("Get secret accesses result: \nAccess list")
+
+    def test_get_secret_accesses_missing_id(self):
+        option_list = []
+        with self.assertRaises(MissingRequirementException) as context:
+            get_secret_accesses(option_list)
+        self.assertEqual(str(context.exception), "Cannot retrieve secret accesses without specifying secret-id")
+
+
+if __name__ == '__main__':
+    unittest.main()

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

@@ -149,12 +149,19 @@ LLM_SETTINGS_5 = {
 }
 
 REQUEST_ITEM = {
+    "apiToken": "test-api-token",
     "assistant": "N/D",
+    "cost": 0.001,
+    "elapsedTimeMs": 1500,
+    "endTimestamp": "2025-02-25T15:03:15.144",
     "intent": None,
     "timestamp": "2025-02-25T15:03:13.644",
     "prompt": None,
     "output": None,
     "inputText": None,
+    "module": "test-module",
+    "sessionId": "test-session-id",
+    "startTimestamp": "2025-02-25T15:03:13.644",
     "status": "succeeded"
 }
 

pygeai/tests/core/base/test_mappers.py

@@ -351,8 +351,22 @@ class TestModelMapper(TestCase):
         self.assertEqual(usage_limit.remaining_usage, 50)
 
     def test_map_to_item(self):
-        data = {"assistant": "Assistant 1", "intent": "Intent 1", "timestamp": "2025-02-05T12:00:00Z",
-                "prompt": "Test prompt", "output": "Test output", "inputText": "Test input", "status": "Success"}
+        data = {
+            "apiToken": "test-token",
+            "assistant": "Assistant 1",
+            "cost": 0.5,
+            "elapsedTimeMs": 100,
+            "endTimestamp": "2025-02-05T12:00:05Z",
+            "intent": "Intent 1",
+            "module": "test-module",
+            "timestamp": "2025-02-05T12:00:00Z",
+            "prompt": "Test prompt",
+            "output": "Test output",
+            "inputText": "Test input",
+            "sessionId": "test-session",
+            "startTimestamp": "2025-02-05T12:00:00Z",
+            "status": "succeeded"
+        }
         item = ModelMapper.map_to_item(data)
 
         self.assertTrue(isinstance(item, RequestItem))
@@ -472,45 +486,65 @@ class TestModelMapper(TestCase):
 
     def test_map_to_project_item(self):
         data = {
+            "apiToken": "test-token",
             "assistant": "Test Assistant",
+            "cost": 0.5,
+            "elapsedTimeMs": 100,
+            "endTimestamp": "2025-02-05T12:00:05Z",
             "intent": "Test Intent",
+            "module": "test-module",
             "timestamp": "2025-02-05T12:00:00Z",
             "prompt": "Test prompt",
             "output": "Test output",
             "inputText": "Test input text",
-            "status": "active"
+            "sessionId": "test-session-id",
+            "startTimestamp": "2025-02-05T12:00:00Z",
+            "status": "succeeded"
         }
         item = ModelMapper.map_to_item(data)
 
         self.assertTrue(isinstance(item, RequestItem))
         self.assertEqual(item.assistant, "Test Assistant")
         self.assertEqual(item.intent, "Test Intent")
-        self.assertEqual(item.timestamp, "2025-02-05T12:00:00Z")
         self.assertEqual(item.prompt, "Test prompt")
         self.assertEqual(item.output, "Test output")
         self.assertEqual(item.input_text, "Test input text")
-        self.assertEqual(item.status, "active")
+        self.assertEqual(item.status, "succeeded")
 
     def test_map_to_item_list(self):
         data = {
             "items": [
                 {
+                    "apiToken": "test-token-1",
                     "assistant": "Assistant 1",
+                    "cost": 0.5,
+                    "elapsedTimeMs": 100,
+                    "endTimestamp": "2025-02-05T12:00:05Z",
                     "intent": "Intent 1",
+                    "module": "test-module",
                     "timestamp": "2025-02-05T12:00:00Z",
                     "prompt": "Prompt 1",
                     "output": "Output 1",
                     "inputText": "Input Text 1",
-                    "status": "active"
+                    "sessionId": "test-session-1",
+                    "startTimestamp": "2025-02-05T12:00:00Z",
+                    "status": "succeeded"
                 },
                 {
+                    "apiToken": "test-token-2",
                     "assistant": "Assistant 2",
+                    "cost": 0.7,
+                    "elapsedTimeMs": 150,
+                    "endTimestamp": "2025-02-05T12:05:10Z",
                     "intent": "Intent 2",
+                    "module": "test-module",
                     "timestamp": "2025-02-05T12:05:00Z",
                     "prompt": "Prompt 2",
                     "output": "Output 2",
                     "inputText": "Input Text 2",
-                    "status": "inactive"
+                    "sessionId": "test-session-2",
+                    "startTimestamp": "2025-02-05T12:05:00Z",
+                    "status": "succeeded"
                 }
             ]
         }
@@ -522,16 +556,14 @@ class TestModelMapper(TestCase):
 
         self.assertEqual(items[0].assistant, "Assistant 1")
         self.assertEqual(items[0].intent, "Intent 1")
-        self.assertEqual(items[0].timestamp, "2025-02-05T12:00:00Z")
         self.assertEqual(items[0].prompt, "Prompt 1")
         self.assertEqual(items[0].output, "Output 1")
         self.assertEqual(items[0].input_text, "Input Text 1")
-        self.assertEqual(items[0].status, "active")
+        self.assertEqual(items[0].status, "succeeded")
 
         self.assertEqual(items[1].assistant, "Assistant 2")
         self.assertEqual(items[1].intent, "Intent 2")
-        self.assertEqual(items[1].timestamp, "2025-02-05T12:05:00Z")
         self.assertEqual(items[1].prompt, "Prompt 2")
         self.assertEqual(items[1].output, "Output 2")
         self.assertEqual(items[1].input_text, "Input Text 2")
-        self.assertEqual(items[1].status, "inactive")
+        self.assertEqual(items[1].status, "succeeded")

pygeai/tests/core/base/test_models.py

@@ -192,7 +192,9 @@ class TestModels(TestCase):
         request_item = RequestItem.model_validate(request_item_data)
         self.assertEqual(request_item.assistant, request_item_data.get("assistant"))
         self.assertEqual(request_item.intent, request_item_data.get("intent"))
-        self.assertEqual(request_item.timestamp, request_item_data.get("timestamp"))
+        # Compare timestamps by checking that the string representation starts with the expected value
+        expected_timestamp = request_item_data.get("timestamp").replace("Z", "+00:00") if request_item_data.get("timestamp").endswith("Z") else request_item_data.get("timestamp")
+        self.assertTrue(request_item.timestamp.isoformat().startswith(expected_timestamp))
         self.assertEqual(request_item.prompt, request_item_data.get("prompt"))
         self.assertEqual(request_item.output, request_item_data.get("output"))
         self.assertEqual(request_item.input_text, request_item_data.get("inputText"))

pygeai/tests/core/base/test_responses.py

@@ -0,0 +1,53 @@
+import unittest
+from unittest.mock import MagicMock
+
+from pygeai.core.base.responses import ErrorListResponse, EmptyResponse
+from pygeai.core.base.models import Error
+
+
+class TestCoreBaseResponses(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.core.base.test_responses.TestCoreBaseResponses
+    """
+
+    def test_error_list_response_to_dict(self):
+        error1 = MagicMock(spec=Error)
+        error1.to_dict.return_value = {"code": "E001", "message": "Error 1"}
+        error2 = MagicMock(spec=Error)
+        error2.to_dict.return_value = {"code": "E002", "message": "Error 2"}
+        
+        response = ErrorListResponse(errors=[error1, error2])
+        result = response.to_dict()
+        
+        self.assertEqual(len(result), 2)
+        self.assertEqual(result[0], {"code": "E001", "message": "Error 1"})
+        self.assertEqual(result[1], {"code": "E002", "message": "Error 2"})
+
+    def test_empty_response_with_dict_content(self):
+        response = EmptyResponse(content={"key": "value"})
+        result = response.to_dict()
+        
+        self.assertEqual(result, {"content": {"key": "value"}})
+
+    def test_empty_response_with_string_content(self):
+        response = EmptyResponse(content="test message")
+        result = response.to_dict()
+        
+        self.assertEqual(result, {"content": "test message"})
+
+    def test_empty_response_with_none_content(self):
+        response = EmptyResponse(content=None)
+        result = response.to_dict()
+        
+        self.assertEqual(result, {})
+
+    def test_empty_response_str(self):
+        response = EmptyResponse(content={"test": "data"})
+        result = str(response)
+        
+        self.assertIn("content", result)
+        self.assertIn("test", result)
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/core/common/test_config.py

@@ -90,9 +90,8 @@ GEAI_API_BASE_URL = https://api.alias1.com
         self.assertEqual(value, "test_api_key")
 
     def test_get_setting_value_non_existing_alias(self):
-        with self.assertRaises(ValueError) as context:
-            self.settings.get_setting_value("GEAI_API_KEY", "invalid_alias")
-        self.assertIn("Alias 'invalid_alias' not found", str(context.exception))
+        value = self.settings.get_setting_value("GEAI_API_KEY", "invalid_alias")
+        self.assertIsNone(value)
 
     def test_get_setting_value_non_existing_key(self):
         with patch('sys.stdout.write') as mock_write:

pygeai/tests/core/files/test_mappers.py

@@ -0,0 +1,137 @@
+import unittest
+
+from pygeai.core.files.mappers import FileResponseMapper
+from pygeai.core.files.models import FileList, File
+from pygeai.core.files.responses import UploadFileResponse
+
+
+class TestFileResponseMapper(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.core.files.test_mappers.TestFileResponseMapper
+    """
+
+    def test_map_to_upload_file_response(self):
+        data = {
+            'dataFileId': 'file-123',
+            'dataFileUrl': 'https://example.com/file.txt',
+            'success': True
+        }
+        
+        result = FileResponseMapper.map_to_upload_file_response(data)
+        
+        self.assertIsInstance(result, UploadFileResponse)
+        self.assertEqual(result.id, 'file-123')
+        self.assertEqual(result.url, 'https://example.com/file.txt')
+        self.assertTrue(result.success)
+
+    def test_map_to_upload_file_response_missing_fields(self):
+        data = {}
+        
+        result = FileResponseMapper.map_to_upload_file_response(data)
+        
+        self.assertIsNone(result.id)
+        self.assertIsNone(result.url)
+        self.assertIsNone(result.success)
+
+    def test_map_to_file_list_response(self):
+        data = {
+            'dataFiles': [
+                {
+                    'dataFileId': 'file-1',
+                    'dataFileName': 'test1.txt',
+                    'dataFileExtension': 'txt',
+                    'dataFilePurpose': 'testing',
+                    'dataFileSize': 1024,
+                    'dataFileUrl': 'https://example.com/file1.txt'
+                },
+                {
+                    'dataFileId': 'file-2',
+                    'dataFileName': 'test2.pdf',
+                    'dataFileExtension': 'pdf',
+                    'dataFilePurpose': 'document',
+                    'dataFileSize': 2048,
+                    'dataFileUrl': 'https://example.com/file2.pdf'
+                }
+            ]
+        }
+        
+        result = FileResponseMapper.map_to_file_list_response(data)
+        
+        self.assertIsInstance(result, FileList)
+        self.assertEqual(len(result.files), 2)
+        self.assertEqual(result.files[0].id, 'file-1')
+        self.assertEqual(result.files[1].id, 'file-2')
+
+    def test_map_to_file_list_empty(self):
+        data = {'dataFiles': []}
+        
+        result = FileResponseMapper.map_to_file_list(data)
+        
+        self.assertEqual(result, [])
+
+    def test_map_to_file_list_none(self):
+        data = {}
+        
+        result = FileResponseMapper.map_to_file_list(data)
+        
+        self.assertEqual(result, [])
+
+    def test_map_to_file_lowercase_keys(self):
+        data = {
+            'dataFileId': 'file-1',
+            'dataFileName': 'test.txt',
+            'dataFileExtension': 'txt',
+            'dataFilePurpose': 'testing',
+            'dataFileSize': 1024,
+            'dataFileUrl': 'https://example.com/file.txt'
+        }
+        
+        result = FileResponseMapper.map_to_file(data)
+        
+        self.assertIsInstance(result, File)
+        self.assertEqual(result.id, 'file-1')
+        self.assertEqual(result.name, 'test.txt')
+        self.assertEqual(result.extension, 'txt')
+        self.assertEqual(result.purpose, 'testing')
+        self.assertEqual(result.size, 1024)
+        self.assertEqual(result.url, 'https://example.com/file.txt')
+
+    def test_map_to_file_uppercase_keys(self):
+        data = {
+            'DataFileId': 'file-2',
+            'DataFileName': 'document.pdf',
+            'DataFileExtension': 'pdf',
+            'DataFilePurpose': 'documentation',
+            'DataFileSize': 2048,
+            'DataFileUrl': 'https://example.com/doc.pdf'
+        }
+        
+        result = FileResponseMapper.map_to_file(data)
+        
+        self.assertIsInstance(result, File)
+        self.assertEqual(result.id, 'file-2')
+        self.assertEqual(result.name, 'document.pdf')
+        self.assertEqual(result.extension, 'pdf')
+        self.assertEqual(result.purpose, 'documentation')
+        self.assertEqual(result.size, 2048)
+        self.assertEqual(result.url, 'https://example.com/doc.pdf')
+
+    def test_map_to_file_mixed_keys(self):
+        data = {
+            'DataFileId': 'file-3',
+            'dataFileName': 'mixed.csv',
+            'DataFileExtension': 'csv',
+            'dataFilePurpose': 'data',
+            'DataFileSize': 512,
+            'dataFileUrl': 'https://example.com/data.csv'
+        }
+        
+        result = FileResponseMapper.map_to_file(data)
+        
+        self.assertEqual(result.id, 'file-3')
+        self.assertEqual(result.name, 'mixed.csv')
+        self.assertEqual(result.extension, 'csv')
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/core/plugins/test_clients.py

@@ -0,0 +1,64 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from json import JSONDecodeError
+
+from pygeai.core.plugins.clients import PluginClient
+from pygeai.core.common.exceptions import InvalidAPIResponseException
+
+
+class TestPluginClient(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.core.plugins.test_clients.TestPluginClient
+    """
+
+    def setUp(self):
+        self.client = PluginClient()
+        self.mock_response = MagicMock()
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_list_assistants_success(self, mock_get):
+        self.mock_response.json.return_value = {
+            "assistants": [
+                {"id": "assistant-1", "name": "Assistant 1"},
+                {"id": "assistant-2", "name": "Assistant 2"}
+            ]
+        }
+        mock_get.return_value = self.mock_response
+        
+        result = self.client.list_assistants(
+            organization_id="org-123",
+            project_id="proj-456"
+        )
+        
+        mock_get.assert_called_once()
+        call_args = mock_get.call_args
+        self.assertEqual(call_args[1]['params']['organization'], "org-123")
+        self.assertEqual(call_args[1]['params']['project'], "proj-456")
+        self.assertEqual(len(result["assistants"]), 2)
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_list_assistants_empty(self, mock_get):
+        self.mock_response.json.return_value = {"assistants": []}
+        mock_get.return_value = self.mock_response
+        
+        result = self.client.list_assistants(
+            organization_id="org-123",
+            project_id="proj-456"
+        )
+        
+        self.assertEqual(result["assistants"], [])
+
+    @patch('pygeai.core.services.rest.ApiService.get')
+    def test_list_assistants_json_decode_error(self, mock_get):
+        self.mock_response.json.side_effect = JSONDecodeError("error", "doc", 0)
+        self.mock_response.status_code = 500
+        self.mock_response.text = "Internal server error"
+        mock_get.return_value = self.mock_response
+        
+        with self.assertRaises(InvalidAPIResponseException) as context:
+            self.client.list_assistants("org-123", "proj-456")
+        self.assertIn("Unable to list assistants for organization org-123 and project proj-456", str(context.exception))
+
+
+if __name__ == '__main__':
+    unittest.main()