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

pygeai/tests/cli/test_geai_driver.py

@@ -0,0 +1,154 @@
+import unittest
+import sys
+from unittest import TestCase
+from unittest.mock import patch
+from io import StringIO
+
+from pygeai.cli.geai import CLIDriver
+from pygeai.cli.error_handler import ExitCode
+
+
+class TestCLIDriver(TestCase):
+    """
+    Test suite for CLIDriver error handling integration.
+    Run with: python -m unittest pygeai.tests.cli.test_geai_driver.TestCLIDriver
+    """
+
+    def setUp(self):
+        """Set up test fixtures"""
+        self.driver = CLIDriver()
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_unknown_command_exit_code(self, mock_stderr):
+        """Test that unknown command returns correct exit code"""
+        sys.argv = ['geai', 'unknown_command_xyz']
+        exit_code = self.driver.main()
+        self.assertEqual(exit_code, ExitCode.USER_INPUT_ERROR)
+        output = mock_stderr.getvalue()
+        self.assertIn("'unknown_command_xyz' is not a valid command", output)
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_unknown_command_with_fuzzy_match(self, mock_stderr):
+        """Test unknown command with fuzzy matching suggestion"""
+        sys.argv = ['geai', 'halp']
+        exit_code = self.driver.main()
+        self.assertEqual(exit_code, ExitCode.USER_INPUT_ERROR)
+        output = mock_stderr.getvalue()
+        self.assertIn("'halp' is not a valid command", output)
+        self.assertIn("Did you mean", output)
+
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_help_command_exit_code(self, mock_stdout):
+        """Test that help command returns success exit code"""
+        sys.argv = ['geai', 'help']
+        exit_code = self.driver.main()
+        self.assertEqual(exit_code, ExitCode.SUCCESS)
+
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_version_command_exit_code(self, mock_stdout):
+        """Test that version command returns success exit code"""
+        sys.argv = ['geai', 'version']
+        exit_code = self.driver.main()
+        self.assertEqual(exit_code, ExitCode.SUCCESS)
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_invalid_option_exit_code(self, mock_stderr):
+        """Test that invalid option returns correct exit code"""
+        sys.argv = ['geai', 'configure', '--invalid-option-xyz']
+        exit_code = self.driver.main()
+        self.assertEqual(exit_code, ExitCode.USER_INPUT_ERROR)
+        output = mock_stderr.getvalue()
+        self.assertIn("'--invalid-option-xyz' is not a valid option", output)
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_error_message_format(self, mock_stderr):
+        """Test that error messages follow the standard format"""
+        sys.argv = ['geai', 'invalidcmd']
+        exit_code = self.driver.main()
+        output = mock_stderr.getvalue()
+        
+        # Check for standard error format
+        self.assertIn("ERROR:", output)
+        self.assertIn("→", output)
+        self.assertIn("Run 'geai help' for usage information", output)
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_available_commands_shown(self, mock_stderr):
+        """Test that available commands are shown for unknown command"""
+        sys.argv = ['geai', 'xyz123']
+        exit_code = self.driver.main()
+        output = mock_stderr.getvalue()
+        
+        # Should show available commands
+        self.assertIn("Available commands:", output)
+        self.assertIn("help", output)
+        self.assertIn("version", output)
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_similar_command_suggestion(self, mock_stderr):
+        """Test that similar commands are suggested"""
+        sys.argv = ['geai', 'versoin']  # Typo in 'version'
+        exit_code = self.driver.main()
+        output = mock_stderr.getvalue()
+        
+        self.assertIn("Did you mean", output)
+        self.assertIn("version", output)
+
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_keyboard_interrupt_exit_code(self, mock_stdout):
+        """Test keyboard interrupt handling"""
+        sys.argv = ['geai', 'help']
+        
+        with patch.object(self.driver, 'process_command', side_effect=KeyboardInterrupt):
+            exit_code = self.driver.main()
+            self.assertEqual(exit_code, ExitCode.KEYBOARD_INTERRUPT)
+            output = mock_stdout.getvalue()
+            self.assertIn("Operation cancelled", output)
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_unexpected_error_exit_code(self, mock_stderr):
+        """Test unexpected error handling"""
+        sys.argv = ['geai', 'help']
+        
+        with patch.object(self.driver, 'process_command', side_effect=RuntimeError("Test error")):
+            exit_code = self.driver.main()
+            self.assertEqual(exit_code, ExitCode.UNEXPECTED_ERROR)
+            output = mock_stderr.getvalue()
+            self.assertIn("unexpected error", output)
+            self.assertIn("Test error", output)
+
+    @patch('sys.stderr', new_callable=StringIO)
+    def test_configure_with_typo_in_option(self, mock_stderr):
+        """Test configure command with typo in option"""
+        sys.argv = ['geai', 'configure', '--kee']  # Typo in '--key'
+        exit_code = self.driver.main()
+        self.assertEqual(exit_code, ExitCode.USER_INPUT_ERROR)
+        output = mock_stderr.getvalue()
+        self.assertIn("'--kee' is not a valid option", output)
+
+    @patch('sys.stdout', new_callable=StringIO)
+    def test_default_to_help_when_no_args(self, mock_stdout):
+        """Test that CLI defaults to help when no arguments provided"""
+        sys.argv = ['geai']
+        exit_code = self.driver.main()
+        self.assertEqual(exit_code, ExitCode.SUCCESS)
+        output = mock_stdout.getvalue()
+        self.assertIn("GEAI CLI", output)
+
+    def test_exit_codes_are_different(self):
+        """Test that different error types have different exit codes"""
+        exit_codes = [
+            ExitCode.SUCCESS,
+            ExitCode.USER_INPUT_ERROR,
+            ExitCode.MISSING_REQUIREMENT,
+            ExitCode.SERVICE_ERROR,
+            ExitCode.KEYBOARD_INTERRUPT,
+            ExitCode.UNEXPECTED_ERROR,
+        ]
+        
+        # All exit codes should be unique
+        self.assertEqual(len(exit_codes), len(set(exit_codes)))
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/cli/test_parsers.py

@@ -35,7 +35,7 @@ class TestCommandParser(TestCase):
     def test_identify_command_invalid(self):
         with self.assertRaises(UnknownArgumentError) as context:
             self.parser.identify_command('invalid')
-        self.assertEqual(str(context.exception), "'invalid' is not a valid command. Run with help or h to check usage.")
+        self.assertEqual(str(context.exception), "'invalid' is not a valid command.")
 
     def test_extract_option_list_valid(self):
         args = ['--detail', 'full', '--name', 'Project1']
@@ -51,7 +51,7 @@ class TestCommandParser(TestCase):
         with self.assertRaises(UnknownArgumentError) as context:
             self.parser.extract_option_list(args)
         self.assertEqual(str(context.exception),
-                         "'--invalid' is not a valid option. Run with help or h to check usage.")
+                         "'--invalid' is not a valid option.")
 
     def test_identify_command_valid_multiple_identifiers(self):
         command = self.parser.identify_command('organization')
@@ -77,7 +77,7 @@ class TestCommandParser(TestCase):
     def test_identify_command_empty_string(self):
         with self.assertRaises(UnknownArgumentError) as context:
             self.parser.identify_command('')
-        self.assertEqual(str(context.exception), "'' is not a valid command. Run with help or h to check usage.")
+        self.assertEqual(str(context.exception), "'' is not a valid command.")
 
     def test_extract_option_list_empty_arguments(self):
         args = []
@@ -122,7 +122,7 @@ class TestCommandParser(TestCase):
         with self.assertRaises(UnknownArgumentError) as context:
             self.parser.extract_option_list(args)
         self.assertEqual(str(context.exception),
-                         "'--invalid' is not a valid option. Run with help or h to check usage.")
+                         "'--invalid' is not a valid option.")
 
     def test_identify_command_subcommand(self):
         command_with_subcommands = Command(
@@ -151,4 +151,4 @@ class TestCommandParser(TestCase):
         with self.assertRaises(UnknownArgumentError) as context:
             self.parser.identify_command('nonexistent')
         self.assertEqual(str(context.exception),
-                         "'nonexistent' is not a valid command. Run with help or h to check usage.")
+                         "'nonexistent' is not a valid command.")

pygeai/tests/core/embeddings/test_clients.py

@@ -17,6 +17,7 @@ class TestEmbeddingsClient(unittest.TestCase):
         with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
             mock_response = MagicMock()
             mock_response.json.return_value = {"model": self.model, "data": [{"embedding": [0.1, 0.2]}]}
+            mock_response.status_code = 200
             mock_api_service.post.return_value = mock_response
 
             result = self.client.generate_embeddings(input_list=self.input_list, model=self.model)
@@ -29,6 +30,7 @@ class TestEmbeddingsClient(unittest.TestCase):
         with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
             mock_response = MagicMock()
             mock_response.json.return_value = {"model": self.model, "data": [{"embedding": [0.1, 0.2]}]}
+            mock_response.status_code = 200
             mock_api_service.post.return_value = mock_response
 
             result = self.client.generate_embeddings(
@@ -59,6 +61,7 @@ class TestEmbeddingsClient(unittest.TestCase):
         with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
             mock_response = MagicMock()
             mock_response.json.return_value = {"model": self.model, "data": [{"embedding": [0.1, 0.2]}]}
+            mock_response.status_code = 200
             mock_api_service.post.return_value = mock_response
 
             result = self.client.generate_embeddings(
@@ -79,3 +82,144 @@ class TestEmbeddingsClient(unittest.TestCase):
             self.assertNotIn("X-Saia-Cache-Enabled", call_args[1]["headers"])
             self.assertEqual(result["model"], self.model)
             self.assertIn("data", result)
+
+    def test_generate_embeddings_empty_input_list(self):
+        with self.assertRaises(ValueError) as context:
+            self.client.generate_embeddings(input_list=[], model=self.model)
+        self.assertIn("cannot be empty", str(context.exception))
+
+    def test_generate_embeddings_none_input_list(self):
+        with self.assertRaises(ValueError) as context:
+            self.client.generate_embeddings(input_list=None, model=self.model)
+        self.assertIn("cannot be empty", str(context.exception))
+
+    def test_generate_embeddings_empty_string_input(self):
+        with self.assertRaises(ValueError) as context:
+            self.client.generate_embeddings(input_list=[""], model=self.model)
+        self.assertIn("cannot be empty", str(context.exception))
+
+    def test_generate_embeddings_whitespace_input(self):
+        with self.assertRaises(ValueError) as context:
+            self.client.generate_embeddings(input_list=["   "], model=self.model)
+        self.assertIn("cannot be empty", str(context.exception))
+
+    def test_generate_embeddings_invalid_encoding_format(self):
+        with self.assertRaises(ValueError) as context:
+            self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                encoding_format="invalid"
+            )
+        self.assertIn("encoding_format must be either 'float' or 'base64'", str(context.exception))
+
+    def test_generate_embeddings_valid_encoding_format_float(self):
+        with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {"model": self.model, "data": [{"embedding": [0.1, 0.2]}]}
+            mock_response.status_code = 200
+            mock_api_service.post.return_value = mock_response
+
+            result = self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                encoding_format="float"
+            )
+            self.assertIn("data", result)
+
+    def test_generate_embeddings_valid_encoding_format_base64(self):
+        with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {"model": self.model, "data": [{"embedding": "base64string"}]}
+            mock_response.status_code = 200
+            mock_api_service.post.return_value = mock_response
+
+            result = self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                encoding_format="base64"
+            )
+            self.assertIn("data", result)
+
+    def test_generate_embeddings_invalid_dimensions(self):
+        with self.assertRaises(ValueError) as context:
+            self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                dimensions=0
+            )
+        self.assertIn("dimensions must be a positive integer", str(context.exception))
+
+    def test_generate_embeddings_negative_dimensions(self):
+        with self.assertRaises(ValueError) as context:
+            self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                dimensions=-10
+            )
+        self.assertIn("dimensions must be a positive integer", str(context.exception))
+
+    def test_generate_embeddings_valid_dimensions(self):
+        with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {"model": self.model, "data": [{"embedding": [0.1] * 512}]}
+            mock_response.status_code = 200
+            mock_api_service.post.return_value = mock_response
+
+            result = self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                dimensions=512
+            )
+            call_args = mock_api_service.post.call_args
+            self.assertEqual(call_args[1]["data"]["dimensions"], 512)
+
+    def test_generate_embeddings_multiple_inputs(self):
+        with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {
+            
+                "model": self.model,
+                "data": [
+                    {"index": 0, "embedding": [0.1, 0.2]},
+                    {"index": 1, "embedding": [0.3, 0.4]},
+                    {"index": 2, "embedding": [0.5, 0.6]}
+                ]
+            }
+            mock_response.status_code = 200
+            mock_api_service.post.return_value = mock_response
+
+            result = self.client.generate_embeddings(
+                input_list=["input1", "input2", "input3"],
+                model=self.model
+            )
+            self.assertEqual(len(result["data"]), 3)
+
+    def test_generate_embeddings_with_cache_enabled(self):
+        with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {"model": self.model, "data": [{"embedding": [0.1, 0.2]}]}
+            mock_response.status_code = 200
+            mock_api_service.post.return_value = mock_response
+
+            result = self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                cache=True
+            )
+            call_args = mock_api_service.post.call_args
+            self.assertEqual(call_args[1]["headers"]["X-Saia-Cache-Enabled"], "true")
+
+    def test_generate_embeddings_with_cache_disabled(self):
+        with patch('pygeai.core.base.clients.BaseClient.api_service') as mock_api_service:
+            mock_response = MagicMock()
+            mock_response.json.return_value = {"model": self.model, "data": [{"embedding": [0.1, 0.2]}]}
+            mock_response.status_code = 200
+            mock_api_service.post.return_value = mock_response
+
+            result = self.client.generate_embeddings(
+                input_list=self.input_list,
+                model=self.model,
+                cache=False
+            )
+            call_args = mock_api_service.post.call_args
+            self.assertNotIn("X-Saia-Cache-Enabled", call_args[1]["headers"])

pygeai/tests/core/embeddings/test_managers.py

@@ -0,0 +1,171 @@
+import unittest
+from unittest.mock import patch, MagicMock
+from pygeai.core.embeddings.managers import EmbeddingsManager
+from pygeai.core.embeddings.models import EmbeddingConfiguration
+from pygeai.core.embeddings.responses import EmbeddingResponse
+from pygeai.core.common.exceptions import APIError
+
+
+class TestEmbeddingsManager(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.core.embeddings.test_managers.TestEmbeddingsManager
+    """
+
+    def setUp(self):
+        self.manager = EmbeddingsManager()
+        self.config = EmbeddingConfiguration(
+            inputs=["test input"],
+            model="test-model"
+        )
+
+    @patch('pygeai.core.embeddings.clients.EmbeddingsClient.generate_embeddings')
+    def test_generate_embeddings_success(self, mock_generate):
+        mock_generate.return_value = {
+            "model": "test-model",
+            "object": "list",
+            "data": [
+                {
+                    "index": 0,
+                    "embedding": [0.1, 0.2, 0.3],
+                    "object": "embedding"
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 5,
+                "total_tokens": 5,
+                "total_cost": 0.0001,
+                "currency": "USD",
+                "prompt_cost": 0.0001,
+                "completion_tokens_details": None,
+                "prompt_tokens_details": None
+            }
+        }
+
+        result = self.manager.generate_embeddings(self.config)
+
+        self.assertIsInstance(result, EmbeddingResponse)
+        self.assertEqual(result.model, "test-model")
+        self.assertEqual(len(result.data), 1)
+        self.assertEqual(result.data[0].index, 0)
+        self.assertEqual(result.usage.prompt_tokens, 5)
+        self.assertEqual(result.usage.total_cost, 0.0001)
+
+    @patch('pygeai.core.embeddings.clients.EmbeddingsClient.generate_embeddings')
+    def test_generate_embeddings_with_all_config_parameters(self, mock_generate):
+        mock_generate.return_value = {
+            "model": "test-model",
+            "object": "list",
+            "data": [{"index": 0, "embedding": [0.1], "object": "embedding"}],
+            "usage": {
+                "prompt_tokens": 5,
+                "total_tokens": 5,
+                "total_cost": 0.0001,
+                "currency": "USD",
+                "prompt_cost": 0.0001,
+                "completion_tokens_details": None,
+                "prompt_tokens_details": None
+            }
+        }
+
+        config = EmbeddingConfiguration(
+            inputs=["test"],
+            model="test-model",
+            encoding_format="base64",
+            dimensions=512,
+            user="user123",
+            input_type="query",
+            timeout=30,
+            cache=True
+        )
+
+        result = self.manager.generate_embeddings(config)
+
+        mock_generate.assert_called_once_with(
+            input_list=["test"],
+            model="test-model",
+            encoding_format="base64",
+            dimensions=512,
+            user="user123",
+            input_type="query",
+            timeout=30,
+            cache=True
+        )
+        self.assertIsInstance(result, EmbeddingResponse)
+
+    @patch('pygeai.core.embeddings.clients.EmbeddingsClient.generate_embeddings')
+    def test_generate_embeddings_with_error(self, mock_generate):
+        mock_generate.return_value = {
+            "error": {
+                "message": "Invalid model",
+                "type": "invalid_request_error"
+            }
+        }
+
+        with self.assertRaises(APIError) as context:
+            self.manager.generate_embeddings(self.config)
+
+        self.assertIn("Error received while generating embeddings", str(context.exception))
+
+    @patch('pygeai.core.embeddings.clients.EmbeddingsClient.generate_embeddings')
+    def test_generate_embeddings_multiple_inputs(self, mock_generate):
+        mock_generate.return_value = {
+            "model": "test-model",
+            "object": "list",
+            "data": [
+                {"index": 0, "embedding": [0.1, 0.2], "object": "embedding"},
+                {"index": 1, "embedding": [0.3, 0.4], "object": "embedding"}
+            ],
+            "usage": {
+                "prompt_tokens": 10,
+                "total_tokens": 10,
+                "total_cost": 0.0002,
+                "currency": "USD",
+                "prompt_cost": 0.0002,
+                "completion_tokens_details": None,
+                "prompt_tokens_details": None
+            }
+        }
+
+        config = EmbeddingConfiguration(
+            inputs=["input1", "input2"],
+            model="test-model"
+        )
+
+        result = self.manager.generate_embeddings(config)
+
+        self.assertEqual(len(result.data), 2)
+        self.assertEqual(result.data[0].index, 0)
+        self.assertEqual(result.data[1].index, 1)
+
+    @patch('pygeai.core.embeddings.clients.EmbeddingsClient.generate_embeddings')
+    def test_generate_embeddings_with_token_details(self, mock_generate):
+        mock_generate.return_value = {
+            "model": "test-model",
+            "object": "list",
+            "data": [{"index": 0, "embedding": [0.1], "object": "embedding"}],
+            "usage": {
+                "prompt_tokens": 5,
+                "total_tokens": 5,
+                "total_cost": 0.0001,
+                "currency": "USD",
+                "prompt_cost": 0.0001,
+                "completion_tokens_details": {
+                    "reasoning_tokens": 0,
+                    "cached_tokens": 0
+                },
+                "prompt_tokens_details": {
+                    "reasoning_tokens": 0,
+                    "cached_tokens": 5
+                }
+            }
+        }
+
+        result = self.manager.generate_embeddings(self.config)
+
+        self.assertIsNotNone(result.usage.completion_tokens_details)
+        self.assertIsNotNone(result.usage.prompt_tokens_details)
+        self.assertEqual(result.usage.prompt_tokens_details.cached_tokens, 5)
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/core/embeddings/test_mappers.py

@@ -0,0 +1,142 @@
+import unittest
+from pygeai.core.embeddings.mappers import EmbeddingsResponseMapper
+from pygeai.core.embeddings.responses import EmbeddingResponse, EmbeddingData, UsageInfo, TokenDetails
+
+
+class TestEmbeddingsResponseMapper(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.core.embeddings.test_mappers.TestEmbeddingsResponseMapper
+    """
+
+    def test_map_to_embedding_response_basic(self):
+        data = {
+            "model": "test-model",
+            "object": "list",
+            "data": [
+                {
+                    "index": 0,
+                    "embedding": [0.1, 0.2, 0.3],
+                    "object": "embedding"
+                }
+            ],
+            "usage": {
+                "prompt_tokens": 5,
+                "total_tokens": 5,
+                "total_cost": 0.0001,
+                "currency": "USD",
+                "prompt_cost": 0.0001,
+                "completion_tokens_details": None,
+                "prompt_tokens_details": None
+            }
+        }
+
+        result = EmbeddingsResponseMapper.map_to_embedding_response(data)
+
+        self.assertIsInstance(result, EmbeddingResponse)
+        self.assertEqual(result.model, "test-model")
+        self.assertEqual(result.object, "list")
+        self.assertEqual(len(result.data), 1)
+        self.assertEqual(result.data[0].index, 0)
+        self.assertEqual(result.data[0].embedding, [0.1, 0.2, 0.3])
+
+    def test_map_to_embedding_data_list(self):
+        data = [
+            {"index": 0, "embedding": [0.1, 0.2], "object": "embedding"},
+            {"index": 1, "embedding": [0.3, 0.4], "object": "embedding"}
+        ]
+
+        result = EmbeddingsResponseMapper.map_to_embedding_data_list(data)
+
+        self.assertEqual(len(result), 2)
+        self.assertIsInstance(result[0], EmbeddingData)
+        self.assertEqual(result[0].index, 0)
+        self.assertEqual(result[1].index, 1)
+
+    def test_map_to_embedding_data_with_base64(self):
+        data = [
+            {"index": 0, "embedding": "base64string==", "object": "embedding"}
+        ]
+
+        result = EmbeddingsResponseMapper.map_to_embedding_data_list(data)
+
+        self.assertEqual(len(result), 1)
+        self.assertEqual(result[0].embedding, "base64string==")
+        self.assertIsInstance(result[0].embedding, str)
+
+    def test_map_to_usage_info_basic(self):
+        data = {
+            "prompt_tokens": 10,
+            "total_tokens": 10,
+            "total_cost": 0.0002,
+            "currency": "USD",
+            "prompt_cost": 0.0002,
+            "completion_tokens_details": None,
+            "prompt_tokens_details": None
+        }
+
+        result = EmbeddingsResponseMapper.map_to_usage_info(data)
+
+        self.assertIsInstance(result, UsageInfo)
+        self.assertEqual(result.prompt_tokens, 10)
+        self.assertEqual(result.total_tokens, 10)
+        self.assertEqual(result.total_cost, 0.0002)
+        self.assertEqual(result.currency, "USD")
+        self.assertEqual(result.prompt_cost, 0.0002)
+        self.assertIsNone(result.completion_tokens_details)
+        self.assertIsNone(result.prompt_tokens_details)
+
+    def test_map_to_usage_info_with_token_details(self):
+        data = {
+            "prompt_tokens": 10,
+            "total_tokens": 10,
+            "total_cost": 0.0002,
+            "currency": "USD",
+            "prompt_cost": 0.0002,
+            "completion_tokens_details": {
+                "reasoning_tokens": 0,
+                "cached_tokens": 0
+            },
+            "prompt_tokens_details": {
+                "reasoning_tokens": 0,
+                "cached_tokens": 5
+            }
+        }
+
+        result = EmbeddingsResponseMapper.map_to_usage_info(data)
+
+        self.assertIsNotNone(result.completion_tokens_details)
+        self.assertIsNotNone(result.prompt_tokens_details)
+        self.assertIsInstance(result.completion_tokens_details, TokenDetails)
+        self.assertIsInstance(result.prompt_tokens_details, TokenDetails)
+        self.assertEqual(result.prompt_tokens_details.cached_tokens, 5)
+
+    def test_parse_token_details_with_none(self):
+        result = EmbeddingsResponseMapper._parse_token_details(None)
+        self.assertIsNone(result)
+
+    def test_parse_token_details_with_data(self):
+        data = {
+            "reasoning_tokens": 10,
+            "cached_tokens": 5
+        }
+
+        result = EmbeddingsResponseMapper._parse_token_details(data)
+
+        self.assertIsInstance(result, TokenDetails)
+        self.assertEqual(result.reasoning_tokens, 10)
+        self.assertEqual(result.cached_tokens, 5)
+
+    def test_map_to_embedding_response_with_missing_fields(self):
+        data = {
+            "model": "test-model"
+        }
+
+        result = EmbeddingsResponseMapper.map_to_embedding_response(data)
+
+        self.assertEqual(result.model, "test-model")
+        self.assertEqual(result.object, "")
+        self.assertEqual(len(result.data), 0)
+
+
+if __name__ == '__main__':
+    unittest.main()