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

pygeai/tests/core/secrets/test_clients.py

@@ -0,0 +1,264 @@
+import unittest
+from unittest.mock import patch, MagicMock
+import json
+from json import JSONDecodeError
+from pygeai.core.secrets.clients import SecretClient
+from pygeai.core.common.exceptions import InvalidAPIResponseException, APIResponseError, APIResponseError
+
+
+class TestSecretClient(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.core.secrets.test_clients.TestSecretClient
+    """
+    def setUp(self):
+        self.secret_client = SecretClient(api_key="test_key", base_url="test_url", alias="test_alias")
+        self.mock_api_service = MagicMock()
+        self.secret_client.api_service = self.mock_api_service
+
+    def test_list_secrets_success(self):
+        expected_response = {"secrets": [{"id": "1", "name": "secret1"}]}
+        mock_response = MagicMock()
+        mock_response.json.return_value = expected_response
+        mock_response.status_code = 200
+        self.mock_api_service.get.return_value = mock_response
+
+        result = self.secret_client.list_secrets(name="secret1", start=0, count=5)
+
+        self.assertEqual(result, expected_response)
+        self.mock_api_service.get.assert_called_once()
+        call_args = self.mock_api_service.get.call_args
+        self.assertEqual(call_args[1]['params']['name'], "secret1")
+        self.assertEqual(call_args[1]['params']['start'], 0)
+        self.assertEqual(call_args[1]['params']['count'], 5)
+
+    def test_list_secrets_json_decode_error(self):
+        expected_text = "Raw response text"
+        mock_response = MagicMock()
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = expected_text
+        mock_response.status_code = 500
+        self.mock_api_service.get.return_value = mock_response
+
+        with self.assertRaises(APIResponseError) as context:
+            self.secret_client.list_secrets()
+
+        self.assertIn("API returned an error", str(context.exception))  # "Unable to list secrets with params", str(context.exception))
+        self.mock_api_service.get.assert_called_once()
+
+    def test_get_secret_success(self):
+        secret_id = "secret-123"
+        expected_response = {"id": "secret-123", "name": "test-secret"}
+        mock_response = MagicMock()
+        mock_response.json.return_value = expected_response
+        mock_response.status_code = 200
+        self.mock_api_service.get.return_value = mock_response
+
+        result = self.secret_client.get_secret(secret_id)
+
+        self.assertEqual(result, expected_response)
+        self.mock_api_service.get.assert_called_once()
+
+    def test_get_secret_json_decode_error(self):
+        secret_id = "secret-123"
+        expected_text = "Raw response text"
+        mock_response = MagicMock()
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = expected_text
+        mock_response.status_code = 500
+        self.mock_api_service.get.return_value = mock_response
+
+        with self.assertRaises(APIResponseError) as context:
+            self.secret_client.get_secret(secret_id)
+
+        self.assertIn("API returned an error", str(context.exception))  # f"Unable to get secret with ID '{secret_id}'", str(context.exception))
+        self.mock_api_service.get.assert_called_once()
+
+    def test_get_secret_invalid_id(self):
+        with self.assertRaises(ValueError) as context:
+            self.secret_client.get_secret("")
+        self.assertEqual(str(context.exception), "secret_id must be provided and non-empty.")
+
+    def test_create_secret_success(self):
+        name = "test-secret"
+        secret_string = "secret-value"
+        description = "A test secret"
+        expected_response = {"id": "secret-123", "name": name}
+        mock_response = MagicMock()
+        mock_response.json.return_value = expected_response
+        mock_response.status_code = 200
+        self.mock_api_service.post.return_value = mock_response
+
+        result = self.secret_client.create_secret(name, secret_string, description)
+
+        self.assertEqual(result, expected_response)
+        self.mock_api_service.post.assert_called_once()
+        call_args = self.mock_api_service.post.call_args
+        data = call_args[1]['data']['secretDefinition']
+        self.assertEqual(data['name'], name)
+        self.assertEqual(data['secretString'], secret_string)
+        self.assertEqual(data['description'], description)
+
+    def test_create_secret_json_decode_error(self):
+        name = "test-secret"
+        secret_string = "secret-value"
+        expected_text = "Raw response text"
+        mock_response = MagicMock()
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = expected_text
+        mock_response.status_code = 500
+        self.mock_api_service.post.return_value = mock_response
+
+        with self.assertRaises(APIResponseError) as context:
+            self.secret_client.create_secret(name, secret_string)
+
+        self.assertIn("API returned an error", str(context.exception))  # f"Unable to create secret with name '{name}'", str(context.exception))
+        self.mock_api_service.post.assert_called_once()
+
+    def test_create_secret_invalid_input(self):
+        with self.assertRaises(ValueError) as context:
+            self.secret_client.create_secret("", "secret-value")
+        self.assertEqual(str(context.exception), "name and secret_string must be provided and non-empty.")
+
+        with self.assertRaises(ValueError) as context:
+            self.secret_client.create_secret("test-secret", "")
+        self.assertEqual(str(context.exception), "name and secret_string must be provided and non-empty.")
+
+    def test_update_secret_success(self):
+        secret_id = "secret-123"
+        name = "updated-secret"
+        secret_string = "updated-value"
+        description = "Updated description"
+        expected_response = {"id": secret_id, "name": name}
+        mock_response = MagicMock()
+        mock_response.json.return_value = expected_response
+        mock_response.status_code = 200
+        self.mock_api_service.put.return_value = mock_response
+
+        result = self.secret_client.update_secret(secret_id, name, secret_string, description)
+
+        self.assertEqual(result, expected_response)
+        self.mock_api_service.put.assert_called_once()
+        call_args = self.mock_api_service.put.call_args
+        data = call_args[1]['data']['secretDefinition']
+        self.assertEqual(data['name'], name)
+        self.assertEqual(data['secretString'], secret_string)
+        self.assertEqual(data['description'], description)
+
+    def test_update_secret_json_decode_error(self):
+        secret_id = "secret-123"
+        name = "updated-secret"
+        secret_string = "updated-value"
+        expected_text = "Raw response text"
+        mock_response = MagicMock()
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = expected_text
+        mock_response.status_code = 500
+        self.mock_api_service.put.return_value = mock_response
+
+        with self.assertRaises(APIResponseError) as context:
+            self.secret_client.update_secret(secret_id, name, secret_string)
+
+        self.assertIn("API returned an error", str(context.exception))  # f"Unable to update secret with ID '{secret_id}'", str(context.exception))
+        self.mock_api_service.put.assert_called_once()
+
+    def test_update_secret_invalid_input(self):
+        with self.assertRaises(ValueError) as context:
+            self.secret_client.update_secret("", "name", "value")
+        self.assertEqual(str(context.exception), "secret_id, name, and secret_string must be provided and non-empty.")
+
+        with self.assertRaises(ValueError) as context:
+            self.secret_client.update_secret("id", "", "value")
+        self.assertEqual(str(context.exception), "secret_id, name, and secret_string must be provided and non-empty.")
+
+        with self.assertRaises(ValueError) as context:
+            self.secret_client.update_secret("id", "name", "")
+        self.assertEqual(str(context.exception), "secret_id, name, and secret_string must be provided and non-empty.")
+
+    def test_set_secret_accesses_success(self):
+        secret_id = "secret-123"
+        access_list = [
+            {"accessLevel": "write", "principalType": "service"},
+            {"accessLevel": "read", "principalType": "user"}
+        ]
+        expected_response = {"status": "success"}
+        mock_response = MagicMock()
+        mock_response.json.return_value = expected_response
+        mock_response.status_code = 200
+        self.mock_api_service.post.return_value = mock_response
+
+        result = self.secret_client.set_secret_accesses(secret_id, access_list)
+
+        self.assertEqual(result, expected_response)
+        self.mock_api_service.post.assert_called_once()
+        call_args = self.mock_api_service.post.call_args
+        data = call_args[1]['data']['secretDefinition']
+        self.assertEqual(data['accessList'], access_list)
+
+    def test_set_secret_accesses_json_decode_error(self):
+        secret_id = "secret-123"
+        access_list = [
+            {"accessLevel": "write", "principalType": "service"}
+        ]
+        expected_text = "Raw response text"
+        mock_response = MagicMock()
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = expected_text
+        mock_response.status_code = 500
+        self.mock_api_service.post.return_value = mock_response
+
+        with self.assertRaises(APIResponseError) as context:
+            self.secret_client.set_secret_accesses(secret_id, access_list)
+
+        self.assertIn("API returned an error", str(context.exception))  # f"Unable to set accesses for secret with ID '{secret_id}'", str(context.exception))
+        self.mock_api_service.post.assert_called_once()
+
+    def test_set_secret_accesses_invalid_input(self):
+        with self.assertRaises(ValueError) as context:
+            self.secret_client.set_secret_accesses("", [{"accessLevel": "write", "principalType": "service"}])
+        self.assertEqual(str(context.exception), "secret_id must be provided and non-empty.")
+
+        with self.assertRaises(ValueError) as context:
+            self.secret_client.set_secret_accesses("id", [])
+        self.assertEqual(str(context.exception), "access_list must be provided and non-empty.")
+
+        with self.assertRaises(ValueError) as context:
+            self.secret_client.set_secret_accesses("id", [{"accessLevel": "write"}])
+        self.assertEqual(str(context.exception), "Each access entry must contain 'accessLevel' and 'principalType'.")
+
+        with self.assertRaises(ValueError) as context:
+            self.secret_client.set_secret_accesses("id", [{"accessLevel": "", "principalType": "service"}])
+        self.assertEqual(str(context.exception), "'accessLevel' and 'principalType' must be non-empty strings.")
+
+    def test_get_secret_accesses_success(self):
+        secret_id = "secret-123"
+        expected_response = {"accesses": [{"accessLevel": "write", "principalType": "service"}]}
+        mock_response = MagicMock()
+        mock_response.json.return_value = expected_response
+        mock_response.status_code = 200
+        self.mock_api_service.get.return_value = mock_response
+
+        result = self.secret_client.get_secret_accesses(secret_id)
+
+        self.assertEqual(result, expected_response)
+        self.mock_api_service.get.assert_called_once()
+
+    def test_get_secret_accesses_json_decode_error(self):
+        secret_id = "secret-123"
+        expected_text = "Raw response text"
+        mock_response = MagicMock()
+        mock_response.json.side_effect = JSONDecodeError("Invalid JSON", "", 0)
+        mock_response.text = expected_text
+        mock_response.status_code = 500
+        self.mock_api_service.get.return_value = mock_response
+
+        with self.assertRaises(APIResponseError) as context:
+            self.secret_client.get_secret_accesses(secret_id)
+
+        self.assertIn("API returned an error", str(context.exception))  # f"Unable to get accesses for secret with ID '{secret_id}'", str(context.exception))
+        self.mock_api_service.get.assert_called_once()
+
+    def test_get_secret_accesses_invalid_id(self):
+        with self.assertRaises(ValueError) as context:
+            self.secret_client.get_secret_accesses("")
+        self.assertEqual(str(context.exception), "secret_id must be provided and non-empty.")
+

pygeai/tests/core/services/test_rest.py

@@ -0,0 +1,273 @@
+import unittest
+from unittest.mock import patch, Mock
+
+from pygeai.core.services.rest import ApiService
+from pygeai.core.common.exceptions import InvalidResponseException
+
+
+class TestApiService(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.core.services.test_rest.TestApiService
+    """
+    def setUp(self):
+        self.base_url = "https://api.example.com"
+        self.api_service = ApiService(self.base_url, username="user", password="pass", token="test_token")
+
+    def test_init_with_credentials(self):
+        service = ApiService(self.base_url, username="user", password="pass", token="token")
+
+        self.assertEqual(service.base_url, self.base_url)
+        self.assertEqual(service.username, "user")
+        self.assertEqual(service.password, "pass")
+        self.assertEqual(service.token, "token")
+
+    def test_init_without_credentials(self):
+        service = ApiService(self.base_url)
+
+        self.assertEqual(service.base_url, self.base_url)
+        self.assertIsNone(service.username)
+        self.assertIsNone(service.password)
+        self.assertIsNone(service.token)
+
+    @patch('requests.Session.get')
+    def test_get_request_with_basic_auth(self, mock_get):
+        mock_response = Mock()
+        mock_response.url = f"{self.base_url}/test_endpoint"
+        mock_get.return_value = mock_response
+
+        response = self.api_service.get(endpoint="test_endpoint", params={"key": "value"}, headers={"Custom": "Header"})
+
+        mock_get.assert_called_once_with(
+            url=f"{self.base_url}/test_endpoint",
+            params={"key": "value"},
+            headers={"Custom": "Header"}
+        )
+        self.assertEqual(response, mock_response)
+
+    @patch('requests.Session.get')
+    def test_get_request_with_token(self, mock_get):
+        api_service = ApiService(self.base_url, token="test_token")
+        mock_response = Mock()
+        mock_response.url = f"{self.base_url}/test_endpoint"
+        mock_get.return_value = mock_response
+
+        response = api_service.get(endpoint="test_endpoint", headers={"Custom": "Header"})
+
+        mock_get.assert_called_once_with(
+            url=f"{self.base_url}/test_endpoint",
+            params=None,
+            headers={"Custom": "Header", "Authorization": "Bearer test_token"}
+        )
+        self.assertEqual(response, mock_response)
+
+    @patch('requests.Session.get')
+    def test_get_request_ssl_verify_false(self, mock_get):
+        mock_response = Mock()
+        mock_response.url = f"{self.base_url}/test_endpoint"
+        mock_get.return_value = mock_response
+
+        response = self.api_service.get(endpoint="test_endpoint", verify=False)
+
+        mock_get.assert_called_once_with(
+            url=f"{self.base_url}/test_endpoint",
+            params=None,
+            headers=None
+        )
+        self.assertEqual(response, mock_response)
+
+    @patch('requests.Session.get')
+    def test_get_request_raises_exception(self, mock_get):
+        mock_get.side_effect = Exception("Request failed")
+
+        with self.assertRaises(InvalidResponseException) as context:
+            self.api_service.get(endpoint="test_endpoint")
+
+        self.assertIn("Error sending GET request", str(context.exception))
+
+    @patch('requests.Session.post')
+    def test_post_request_json(self, mock_post):
+        mock_response = Mock()
+        mock_response.url = f"{self.base_url}/test_endpoint"
+        mock_post.return_value = mock_response
+
+        response = self.api_service.post(endpoint="test_endpoint", data={"key": "value"}, headers={"Custom": "Header"})
+
+        mock_post.assert_called_once_with(
+            url=f"{self.base_url}/test_endpoint",
+            json={"key": "value"},
+            headers={"Custom": "Header"}
+        )
+        self.assertEqual(response, mock_response)
+
+    @patch('requests.Session.post')
+    def test_post_request_form(self, mock_post):
+        mock_response = Mock()
+        mock_response.url = f"{self.base_url}/test_endpoint"
+        mock_post.return_value = mock_response
+
+        response = self.api_service.post(endpoint="test_endpoint", data={"key": "value"}, headers={"Custom": "Header"}, form=True)
+
+        mock_post.assert_called_once_with(
+            url=f"{self.base_url}/test_endpoint",
+            data={"key": "value"},
+            headers={"Custom": "Header"}
+        )
+        self.assertEqual(response, mock_response)
+
+    @patch('requests.Session.post')
+    def test_post_request_raises_exception(self, mock_post):
+        mock_post.side_effect = Exception("Request failed")
+
+        with self.assertRaises(InvalidResponseException) as context:
+            self.api_service.post(endpoint="test_endpoint", data={"key": "value"})
+
+        self.assertIn("Error sending POST request", str(context.exception))
+
+    @patch('requests.Session.post')
+    def test_stream_post_request(self, mock_post):
+        mock_response = Mock()
+        mock_response.url = f"{self.base_url}/test_endpoint"
+        mock_response.iter_lines.return_value = ["line1", "line2"]
+        mock_post.return_value = mock_response
+
+        result = list(self.api_service.stream_post(endpoint="test_endpoint", data={"key": "value"}))
+
+        mock_post.assert_called_once_with(
+            url=f"{self.base_url}/test_endpoint",
+            json={"key": "value"},
+            headers=None,
+            stream=True
+        )
+        self.assertEqual(result, ["line1", "line2"])
+
+    @patch('requests.Session.post')
+    def test_stream_post_request_raises_exception(self, mock_post):
+        mock_post.side_effect = Exception("Streaming failed")
+
+        with self.assertRaises(InvalidResponseException) as context:
+            list(self.api_service.stream_post(endpoint="test_endpoint", data={"key": "value"}))
+
+        self.assertIn("Error sending streaming POST request", str(context.exception))
+
+    @patch('requests.Session.post')
+    def test_post_file_binary(self, mock_post):
+        mock_response = Mock()
+        mock_response.url = f"{self.base_url}/test_endpoint"
+        mock_post.return_value = mock_response
+        mock_file = Mock()
+
+        response = self.api_service.post_file_binary(endpoint="test_endpoint", file=mock_file)
+
+        mock_post.assert_called_once_with(
+            url=f"{self.base_url}/test_endpoint",
+            headers=None,
+            data=mock_file
+        )
+        self.assertEqual(response, mock_response)
+
+    @patch('requests.Session.post')
+    def test_post_file_binary_raises_exception(self, mock_post):
+        mock_post.side_effect = Exception("File upload failed")
+        mock_file = Mock()
+
+        with self.assertRaises(InvalidResponseException) as context:
+            self.api_service.post_file_binary(endpoint="test_endpoint", file=mock_file)
+
+        self.assertIn("Error sending POST request with binary file", str(context.exception))
+
+    @patch('requests.Session.post')
+    def test_post_files_multipart(self, mock_post):
+        mock_response = Mock()
+        mock_response.url = f"{self.base_url}/test_endpoint"
+        mock_post.return_value = mock_response
+        mock_files = {"file": "path/to/file"}
+
+        response = self.api_service.post_files_multipart(endpoint="test_endpoint", data={"key": "value"}, files=mock_files)
+
+        mock_post.assert_called_once_with(
+            url=f"{self.base_url}/test_endpoint",
+            headers=None,
+            data={"key": "value"},
+            files=mock_files
+        )
+        self.assertEqual(response, mock_response)
+
+    @patch('requests.Session.post')
+    def test_post_files_multipart_raises_exception(self, mock_post):
+        mock_post.side_effect = Exception("Multipart upload failed")
+        mock_files = {"file": "path/to/file"}
+
+        with self.assertRaises(InvalidResponseException) as context:
+            self.api_service.post_files_multipart(endpoint="test_endpoint", data={"key": "value"}, files=mock_files)
+
+        self.assertIn("Error sending POST request with files multipart", str(context.exception))
+
+    @patch('requests.Session.put')
+    def test_put_request(self, mock_put):
+        mock_response = Mock()
+        mock_response.url = f"{self.base_url}/test_endpoint"
+        mock_put.return_value = mock_response
+
+        response = self.api_service.put(endpoint="test_endpoint", data={"key": "value"}, headers={"Custom": "Header"})
+
+        mock_put.assert_called_once_with(
+            url=f"{self.base_url}/test_endpoint",
+            json={"key": "value"},
+            headers={"Custom": "Header", "Content-Type": "application/json"}
+        )
+        self.assertEqual(response, mock_response)
+
+    @patch('requests.Session.put')
+    def test_put_request_raises_exception(self, mock_put):
+        mock_put.side_effect = Exception("Request failed")
+
+        with self.assertRaises(InvalidResponseException) as context:
+            self.api_service.put(endpoint="test_endpoint", data={"key": "value"})
+
+        self.assertIn("Error sending PUT request", str(context.exception))
+
+    @patch('requests.Session.delete')
+    def test_delete_request(self, mock_delete):
+        mock_response = Mock()
+        mock_response.url = f"{self.base_url}/test_endpoint"
+        mock_delete.return_value = mock_response
+
+        response = self.api_service.delete(endpoint="test_endpoint", data={"key": "value"}, headers={"Custom": "Header"})
+
+        mock_delete.assert_called_once_with(
+            url=f"{self.base_url}/test_endpoint",
+            headers={"Custom": "Header"},
+            params={"key": "value"}
+        )
+        self.assertEqual(response, mock_response)
+
+    @patch('requests.Session.delete')
+    def test_delete_request_raises_exception(self, mock_delete):
+        mock_delete.side_effect = Exception("Request failed")
+
+        with self.assertRaises(InvalidResponseException) as context:
+            self.api_service.delete(endpoint="test_endpoint")
+
+        self.assertIn("Error sending DELETE request", str(context.exception))
+
+    def test_add_endpoint_to_url_with_protocol(self):
+        result = self.api_service._add_endpoint_to_url("test_endpoint")
+
+        self.assertEqual(result, f"{self.base_url}/test_endpoint")
+
+    def test_add_endpoint_to_url_without_protocol(self):
+        api_service = ApiService("api.example.com")
+        result = api_service._add_endpoint_to_url("test_endpoint")
+
+        self.assertEqual(result, "https://api.example.com/test_endpoint")
+
+    def test_add_token_to_headers_new_headers(self):
+        result = self.api_service._add_token_to_headers()
+
+        self.assertEqual(result, {"Authorization": "Bearer test_token"})
+
+    def test_add_token_to_headers_existing_headers(self):
+        headers = {"Custom": "Header"}
+        result = self.api_service._add_token_to_headers(headers)
+
+        self.assertEqual(result, {"Custom": "Header", "Authorization": "Bearer test_token"})

pygeai/tests/core/test_handlers.py

@@ -0,0 +1,66 @@
+import unittest
+from unittest.mock import MagicMock
+from pygeai.core.handlers import ErrorHandler
+from pygeai.core.base.mappers import ErrorMapper
+
+
+class TestErrorHandler(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.core.test_handlers.TestErrorHandler
+    """
+
+    def setUp(self):
+        # Mock the ErrorMapper methods to avoid actual mapping logic in tests
+        self.error_mapper_map_to_error_list_response = MagicMock(return_value={"error_list": "mapped_errors"})
+        self.error_mapper_map_to_error = MagicMock(return_value={"single_error": "mapped_error"})
+        ErrorMapper.map_to_error_list_response = self.error_mapper_map_to_error_list_response
+        ErrorMapper.map_to_error = self.error_mapper_map_to_error
+
+    def test_has_errors_with_errors_key(self):
+        response = {"errors": [{"code": "123", "message": "Error message"}]}
+
+        result = ErrorHandler.has_errors(response)
+
+        self.assertTrue(result)
+
+    def test_has_errors_with_error_key(self):
+        response = {"error": {"code": "456", "message": "Single error"}}
+
+        result = ErrorHandler.has_errors(response)
+
+        self.assertTrue(result)
+
+    def test_has_errors_without_error_keys(self):
+        response = {"data": "some data"}
+
+        result = ErrorHandler.has_errors(response)
+
+        self.assertFalse(result)
+
+    def test_extract_error_with_errors_key(self):
+        response = {"errors": [{"code": "123", "message": "Error message"}]}
+
+        result = ErrorHandler.extract_error(response)
+
+        self.error_mapper_map_to_error_list_response.assert_called_once_with(response)
+        self.assertEqual(result, {"error_list": "mapped_errors"})
+        self.error_mapper_map_to_error.assert_not_called()
+
+    def test_extract_error_with_error_key(self):
+        response = {"error": {"code": "456", "message": "Single error"}}
+
+        result = ErrorHandler.extract_error(response)
+
+        self.error_mapper_map_to_error.assert_called_once_with(response.get('error'))
+        self.assertEqual(result, {"single_error": "mapped_error"})
+        self.error_mapper_map_to_error_list_response.assert_not_called()
+
+    def test_extract_error_without_error_keys(self):
+        response = {"data": "some data"}
+
+        result = ErrorHandler.extract_error(response)
+
+        self.assertEqual(result, response)
+        self.error_mapper_map_to_error_list_response.assert_not_called()
+        self.error_mapper_map_to_error.assert_not_called()
+