pygeai 0.1.51b3__py3-none-any.whl → 0.6.0b15__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/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

@@ -0,0 +1,186 @@
+import unittest
+from unittest import TestCase
+from unittest.mock import patch, mock_open
+import os
+from pathlib import Path
+from pygeai.core.common.config import SettingsManager, get_settings
+
+
+class TestSettingsManager(TestCase):
+    """
+    python -m unittest pygeai.tests.core.common.test_config.TestSettingsManager
+    """
+
+    def setUp(self):
+        # Mock the credentials file path to use a sample file for testing
+        self.sample_creds_path = Path("pygeai/tests/core/common/data/credentials")
+        self.creds_content = """
+[default]
+GEAI_API_KEY = test_api_key
+GEAI_API_BASE_URL = https://api.test.com
+GEAI_API_EVAL_URL = https://eval.test.com
+
+[alias1]
+GEAI_API_KEY = alias1_key
+GEAI_API_BASE_URL = https://api.alias1.com
+"""
+        # Mock file existence and content to avoid touching real filesystem
+        self.file_patch = patch('pathlib.Path.exists', return_value=True)
+        self.file_patch.start()
+        self.open_patch = patch('pathlib.Path.open', mock_open(read_data=self.creds_content))
+        self.open_patch.start()
+        self.touch_patch = patch('pathlib.Path.touch', return_value=None)
+        self.touch_patch.start()
+
+        # Mock configparser read to enforce our test content
+        self.config_read_patch = patch('configparser.ConfigParser.read')
+        self.mock_config_read = self.config_read_patch.start()
+        self.mock_config_read.return_value = None  # We'll set up config manually in tests if needed
+
+        # Mock environment variables to be empty initially
+        self.env_patch = patch.dict('os.environ', {}, clear=True)
+        self.env_patch.start()
+
+        # Mock sys.stdout.write to capture output
+        self.stdout_patch = patch('sys.stdout.write')
+        self.mock_stdout = self.stdout_patch.start()
+
+        # Initialize SettingsManager with mocked settings dir and creds file
+        self.settings = SettingsManager()
+
+        # Manually set up config with test content for consistency
+        self.settings.config.clear()
+        self.settings.config.read_string(self.creds_content)
+
+    def tearDown(self):
+        self.file_patch.stop()
+        self.open_patch.stop()
+        self.touch_patch.stop()
+        self.env_patch.stop()
+        self.stdout_patch.stop()
+        self.config_read_patch.stop()
+
+    def test_init_with_existing_file(self):
+        self.assertTrue("default" in self.settings.config)
+        self.assertTrue("alias1" in self.settings.config)
+        self.assertEqual(self.settings.config["default"]["GEAI_API_KEY"], "test_api_key")
+        self.mock_stdout.assert_not_called()  # No message since file exists
+
+    def test_init_with_non_existing_file(self):
+        with patch('pathlib.Path.exists', return_value=False):
+            settings = SettingsManager()
+            self.assertEqual(len(settings.config.sections()), 0)  # No sections in empty config
+            self.mock_stdout.assert_called()
+            self.assertTrue(any("Credentials file not found" in str(call) for call in self.mock_stdout.call_args_list))
+
+    def test_has_value_existing(self):
+        result = self.settings.has_value("GEAI_API_KEY", "default")
+        self.assertTrue(result)
+
+    def test_has_value_non_existing_key(self):
+        result = self.settings.has_value("INVALID_KEY", "default")
+        self.assertFalse(result)
+
+    def test_has_value_non_existing_alias(self):
+        result = self.settings.has_value("GEAI_API_KEY", "invalid_alias")
+        self.assertFalse(result)
+
+    def test_get_setting_value_existing(self):
+        value = self.settings.get_setting_value("GEAI_API_KEY", "default")
+        self.assertEqual(value, "test_api_key")
+
+    def test_get_setting_value_non_existing_alias(self):
+        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:
+            value = self.settings.get_setting_value("INVALID_KEY", "default")
+            self.assertEqual(value, "")
+            mock_write.assert_called()
+            self.assertIn("'INVALID_KEY' not found in alias 'default'", str(mock_write.call_args))
+
+    def test_get_setting_value_non_existing_key_eval_url(self):
+        with patch('sys.stdout.write') as mock_write:
+            with patch.object(self.settings, 'set_eval_url') as mock_set_eval:
+                value = self.settings.get_setting_value("GEAI_API_EVAL_URL", "default")
+                self.assertEqual(value, "https://eval.test.com")  # From mocked content
+                mock_write.assert_not_called()  # No message since it's in creds file
+                mock_set_eval.assert_not_called()  # Not called since value exists
+
+    def test_set_setting_value_new_alias(self):
+        with patch('pathlib.Path.open', mock_open()) as mock_file:
+            self.settings.set_setting_value("NEW_KEY", "new_value", "new_alias")
+            self.assertTrue("new_alias" in self.settings.config)
+            self.assertEqual(self.settings.config["new_alias"]["NEW_KEY"], "new_value")
+            mock_file.assert_called_once()
+
+    def test_set_setting_value_existing_alias(self):
+        with patch('pathlib.Path.open', mock_open()) as mock_file:
+            self.settings.set_setting_value("GEAI_API_KEY", "updated_key", "default")
+            self.assertEqual(self.settings.config["default"]["GEAI_API_KEY"], "updated_key")
+            mock_file.assert_called_once()
+
+    def test_get_api_key_from_env(self):
+        with patch.dict('os.environ', {'GEAI_API_KEY': 'env_api_key'}, clear=True):
+            api_key = self.settings.get_api_key("default")
+            self.assertEqual(api_key, "env_api_key")
+
+    def test_get_api_key_from_file(self):
+        api_key = self.settings.get_api_key("default")
+        self.assertEqual(api_key, "test_api_key")
+
+    def test_get_api_key_alias(self):
+        api_key = self.settings.get_api_key("alias1")
+        self.assertEqual(api_key, "alias1_key")
+
+    def test_set_api_key(self):
+        with patch('pathlib.Path.open', mock_open()) as mock_file:
+            self.settings.set_api_key("new_api_key", "default")
+            self.assertEqual(self.settings.config["default"]["GEAI_API_KEY"], "new_api_key")
+            mock_file.assert_called_once()
+
+    def test_get_base_url_from_env(self):
+        with patch.dict('os.environ', {'GEAI_API_BASE_URL': 'https://env.test.com'}, clear=True):
+            base_url = self.settings.get_base_url("default")
+            self.assertEqual(base_url, "https://env.test.com")
+
+    def test_get_base_url_from_file(self):
+        base_url = self.settings.get_base_url("default")
+        self.assertEqual(base_url, "https://api.test.com")
+
+    def test_get_base_url_alias(self):
+        base_url = self.settings.get_base_url("alias1")
+        self.assertEqual(base_url, "https://api.alias1.com")
+
+    def test_set_base_url(self):
+        with patch('pathlib.Path.open', mock_open()) as mock_file:
+            self.settings.set_base_url("https://new.test.com", "default")
+            self.assertEqual(self.settings.config["default"]["GEAI_API_BASE_URL"], "https://new.test.com")
+            mock_file.assert_called_once()
+
+    def test_get_eval_url_from_env(self):
+        with patch.dict('os.environ', {'GEAI_API_EVAL_URL': 'https://env.eval.test.com'}, clear=True):
+            eval_url = self.settings.get_eval_url("default")
+            self.assertEqual(eval_url, "https://env.eval.test.com")
+
+    def test_get_eval_url_from_file(self):
+        eval_url = self.settings.get_eval_url("default")
+        self.assertEqual(eval_url, "https://eval.test.com")
+
+    def test_set_eval_url(self):
+        with patch('pathlib.Path.open', mock_open()) as mock_file:
+            self.settings.set_eval_url("https://new.eval.test.com", "default")
+            self.assertEqual(self.settings.config["default"]["GEAI_API_EVAL_URL"], "https://new.eval.test.com")
+            mock_file.assert_called_once()
+
+    def test_list_aliases(self):
+        aliases = self.settings.list_aliases()
+        self.assertEqual(len(aliases), 2)
+        self.assertEqual(aliases["default"], "https://api.test.com")
+        self.assertEqual(aliases["alias1"], "https://api.alias1.com")
+
+    def test_get_settings_lru_cache(self):
+        settings1 = get_settings()
+        settings2 = get_settings()
+        self.assertIs(settings1, settings2)  # Should return the same instance due to lru_cache

pygeai/tests/core/common/test_decorators.py

@@ -0,0 +1,69 @@
+import unittest
+import io
+import sys
+from unittest.mock import patch
+from pygeai.core.common.decorators import measure_execution_time, handler_server_error
+from pygeai.core.common.exceptions import ServerResponseError
+
+
+class TestDecorators(unittest.TestCase):
+    """
+    python -m unittest pygeai.tests.core.common.test_decorators.TestDecorators
+    """
+
+    def test_measure_execution_time_success(self):
+        @measure_execution_time
+        def sample_function():
+            return "Success"
+
+        # Capture stdout to verify printed messages
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        result = sample_function()
+
+        sys.stdout = sys.__stdout__  # Restore stdout
+        output = captured_output.getvalue()
+        self.assertIn("Measuring execution time for: sample_function", output)
+        self.assertIn("Function sample_function executed in", output)
+        self.assertEqual(result, "Success")
+
+    def test_measure_execution_time_with_exception(self):
+        @measure_execution_time
+        def failing_function():
+            raise ValueError("Test error")
+
+        # Capture stdout to verify printed messages
+        captured_output = io.StringIO()
+        sys.stdout = captured_output
+
+        result = None
+        try:
+            result = failing_function()
+        except ValueError:
+            pass  # The decorator catches the exception, so this won't be reached
+
+        sys.stdout = sys.__stdout__  # Restore stdout
+        output = captured_output.getvalue()
+        self.assertIn("Measuring execution time for: failing_function", output)
+        self.assertIn("Error measuring execution time: Test error", output)
+        self.assertIsNone(result)  # No return value since exception was caught
+
+    def test_handler_server_error_no_error(self):
+        @handler_server_error
+        def successful_function():
+            return {"data": "Success"}
+
+        result = successful_function()
+        self.assertEqual(result, {"data": "Success"})
+
+    def test_handler_server_error_with_error(self):
+        @handler_server_error
+        def error_function():
+            return {"error": "Server error message"}
+
+        with self.assertRaises(ServerResponseError) as context:
+            error_function()
+
+        self.assertIn("There was an error communicating with the server: Server error message", str(context.exception))
+