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

pygeai/tests/core/base/test_models.py

@@ -0,0 +1,261 @@
+from datetime import datetime
+from unittest import TestCase
+
+from pygeai.core.models import UsageLimit, ChatVariable, WelcomeData, WelcomeDataFeature, WelcomeDataExamplePrompt, \
+    LlmSettings, GuardrailSettings, RequestItem, Project, Assistant
+from pygeai.tests.core.base.data.models import USAGE_LIMIT_1, CHAT_VARIABLE, WELCOME_DATA, WELCOME_DATA_FEATURE_1, \
+    WELCOME_DATA_EXAMPLE_PROMPT_1, LLM_SETTINGS_1, LLM_SETTINGS_2, LLM_SETTINGS_3, LLM_SETTINGS_4, LLM_SETTINGS_5, \
+    REQUEST_ITEM, PROJECT_1, ASSISTANT_1
+
+
+class TestModels(TestCase):
+    """
+    python -m unittest pygeai.tests.core.base.test_models.TestModels
+    """
+
+    def test_usage_limit_model_validate(self):
+        usage_limit_data = USAGE_LIMIT_1
+
+        usage_limit = UsageLimit.model_validate(usage_limit_data)
+        self.assertEqual(usage_limit.hard_limit, usage_limit_data.get('hardLimit'))
+        self.assertEqual(usage_limit.id, usage_limit_data.get('id'))
+        self.assertEqual(usage_limit.related_entity_name, usage_limit_data.get('relatedEntityName'))
+        self.assertEqual(usage_limit.remaining_usage, usage_limit_data.get('remainingUsage'))
+        self.assertEqual(usage_limit.renewal_status, usage_limit_data.get('renewalStatus'))
+        self.assertEqual(usage_limit.soft_limit, usage_limit_data.get('softLimit'))
+        self.assertEqual(usage_limit.status, usage_limit_data.get('status'))
+        self.assertEqual(usage_limit.subscription_type, usage_limit_data.get('subscriptionType'))
+        self.assertEqual(usage_limit.usage_unit, usage_limit_data.get('usageUnit'))
+        self.assertEqual(usage_limit.used_amount, usage_limit_data.get('usedAmount'))
+        self.assertEqual(usage_limit.valid_from, datetime.fromisoformat(usage_limit_data.get('validFrom')))
+        self.assertEqual(usage_limit.valid_until, datetime.fromisoformat(usage_limit_data.get('validUntil')))
+
+    def test_llm_settings_model_validate(self):
+        llm_settings_data = LLM_SETTINGS_1
+
+        llm_settings = LlmSettings.model_validate(llm_settings_data)
+        self.assertEqual(llm_settings.provider_name, llm_settings_data.get('providerName'))
+        self.assertEqual(llm_settings.model_name, llm_settings_data.get('modelName'))
+        self.assertEqual(llm_settings.temperature, llm_settings_data.get('temperature'))
+        self.assertEqual(llm_settings.max_tokens, llm_settings_data.get('maxTokens'))
+        self.assertEqual(llm_settings.frequency_penalty, llm_settings_data.get('frequencyPenalty'))
+        self.assertEqual(llm_settings.presence_penalty, llm_settings_data.get('presencePenalty'))
+        self.assertEqual(llm_settings.upload_files, llm_settings_data.get('uploadFiles'))
+        self.assertEqual(llm_settings.n, llm_settings_data.get('n'))
+        self.assertEqual(llm_settings.stream, llm_settings_data.get('stream'))
+        self.assertEqual(llm_settings.top_p, llm_settings_data.get('topP'))
+        self.assertEqual(llm_settings.type, llm_settings_data.get('type'))
+        self.assertEqual(llm_settings.cache, llm_settings_data.get('cache'))
+        self.assertEqual(llm_settings.verbose, llm_settings_data.get('verbose'))
+
+        guardrail_settings = GuardrailSettings.model_validate(llm_settings_data)
+        self.assertEqual(llm_settings.guardrail_settings, guardrail_settings)
+
+    def test_llm_settings_model_validate_2(self):
+        llm_settings_data = LLM_SETTINGS_2
+
+        llm_settings = LlmSettings.model_validate(llm_settings_data)
+        self.assertEqual(llm_settings.provider_name, llm_settings_data.get('providerName'))
+        self.assertEqual(llm_settings.model_name, llm_settings_data.get('modelName'))
+        self.assertEqual(llm_settings.temperature, llm_settings_data.get('temperature'))
+        self.assertEqual(llm_settings.max_tokens, llm_settings_data.get('maxTokens'))
+        self.assertEqual(llm_settings.upload_files, llm_settings_data.get('uploadFiles'))
+        self.assertEqual(llm_settings.n, llm_settings_data.get('n'))
+        self.assertEqual(llm_settings.stream, llm_settings_data.get('stream'))
+        self.assertEqual(llm_settings.top_p, llm_settings_data.get('topP'))
+        self.assertEqual(llm_settings.type, llm_settings_data.get('type'))
+        self.assertEqual(llm_settings.cache, llm_settings_data.get('cache'))
+        self.assertEqual(llm_settings.verbose, llm_settings_data.get('verbose'))
+        self.assertIsNone(llm_settings.guardrail_settings)
+
+    def test_llm_settings_model_validate_3(self):
+        llm_settings_data = LLM_SETTINGS_3
+
+        llm_settings = LlmSettings.model_validate(llm_settings_data)
+        self.assertEqual(llm_settings.provider_name, llm_settings_data.get('providerName'))
+        self.assertEqual(llm_settings.model_name, llm_settings_data.get('modelName'))
+        self.assertEqual(llm_settings.temperature, llm_settings_data.get('temperature'))
+        self.assertEqual(llm_settings.max_tokens, llm_settings_data.get('maxTokens'))
+        self.assertEqual(llm_settings.upload_files, llm_settings_data.get('uploadFiles'))
+        self.assertEqual(llm_settings.n, llm_settings_data.get('n'))
+        self.assertEqual(llm_settings.stream, llm_settings_data.get('stream'))
+        self.assertEqual(llm_settings.top_p, llm_settings_data.get('topP'))
+        self.assertEqual(llm_settings.type, llm_settings_data.get('type'))
+        self.assertEqual(llm_settings.cache, llm_settings_data.get('cache'))
+        self.assertEqual(llm_settings.verbose, llm_settings_data.get('verbose'))
+
+        guardrail_data = {
+            "llmOutputGuardrail": llm_settings_data.get("llmOutputGuardrail"),
+            "inputModerationGuardrail": llm_settings_data.get("inputModerationGuardrail"),
+            "promptInjectionGuardrail": llm_settings_data.get("promptInjectionGuardrail")
+        }
+        if any(guardrail_data):
+            guardrail_settings = GuardrailSettings.model_validate(guardrail_data)
+            self.assertEqual(llm_settings.guardrail_settings, guardrail_settings)
+        else:
+            self.assertIsNone(llm_settings.guardrail_settings)
+
+    def test_llm_settings_model_validate_4(self):
+        llm_settings_data = LLM_SETTINGS_4
+
+        llm_settings = LlmSettings.model_validate(llm_settings_data)
+        self.assertEqual(llm_settings.provider_name, llm_settings_data.get('providerName'))
+        self.assertEqual(llm_settings.model_name, llm_settings_data.get('modelName'))
+        self.assertEqual(llm_settings.temperature, llm_settings_data.get('temperature'))
+        self.assertEqual(llm_settings.max_tokens, llm_settings_data.get('maxTokens'))
+        self.assertEqual(llm_settings.upload_files, llm_settings_data.get('uploadFiles'))
+        self.assertEqual(llm_settings.n, llm_settings_data.get('n'))
+        self.assertEqual(llm_settings.stream, llm_settings_data.get('stream'))
+        self.assertEqual(llm_settings.top_p, llm_settings_data.get('topP'))
+        self.assertEqual(llm_settings.type, llm_settings_data.get('type'))
+        self.assertEqual(llm_settings.cache, llm_settings_data.get('cache'))
+        self.assertEqual(llm_settings.verbose, llm_settings_data.get('verbose'))
+
+        guardrail_data = {
+            "llmOutputGuardrail": llm_settings_data.get("llmOutputGuardrail"),
+            "inputModerationGuardrail": llm_settings_data.get("inputModerationGuardrail"),
+            "promptInjectionGuardrail": llm_settings_data.get("promptInjectionGuardrail")
+        }
+        if any(guardrail_data.values()):
+            guardrail_settings = GuardrailSettings.model_validate(guardrail_data)
+            self.assertEqual(llm_settings.guardrail_settings, guardrail_settings)
+        else:
+            self.assertIsNone(llm_settings.guardrail_settings)
+
+    def test_llm_settings_model_validate_5(self):
+        llm_settings_data = LLM_SETTINGS_5
+
+        llm_settings = LlmSettings.model_validate(llm_settings_data)
+        self.assertEqual(llm_settings.provider_name, llm_settings_data.get('providerName'))
+        self.assertEqual(llm_settings.model_name, llm_settings_data.get('modelName'))
+        self.assertEqual(llm_settings.temperature, llm_settings_data.get('temperature'))
+        self.assertEqual(llm_settings.max_tokens, llm_settings_data.get('maxTokens'))
+        self.assertEqual(llm_settings.upload_files, llm_settings_data.get('uploadFiles'))
+        self.assertEqual(llm_settings.n, llm_settings_data.get('n'))
+        self.assertEqual(llm_settings.stream, llm_settings_data.get('stream'))
+        self.assertEqual(llm_settings.top_p, llm_settings_data.get('topP'))
+        self.assertEqual(llm_settings.type, llm_settings_data.get('type'))
+        self.assertEqual(llm_settings.cache, llm_settings_data.get('cache'))
+        self.assertEqual(llm_settings.verbose, llm_settings_data.get('verbose'))
+
+        guardrail_data = {
+            "llmOutputGuardrail": llm_settings_data.get("llmOutputGuardrail"),
+            "inputModerationGuardrail": llm_settings_data.get("inputModerationGuardrail"),
+            "promptInjectionGuardrail": llm_settings_data.get("promptInjectionGuardrail")
+        }
+        if any(guardrail_data.values()):
+            guardrail_settings = GuardrailSettings.model_validate(guardrail_data)
+            self.assertEqual(llm_settings.guardrail_settings, guardrail_settings)
+        else:
+            self.assertIsNone(llm_settings.guardrail_settings)
+
+    def test_welcome_data_feature_model_validate(self):
+        feature_data = WELCOME_DATA_FEATURE_1
+
+        feature = WelcomeDataFeature.model_validate(feature_data)
+        self.assertEqual(feature.title, feature_data.get('title'))
+        self.assertEqual(feature.description, feature_data.get('description'))
+
+    def test_welcome_data_example_prompt_model_validate(self):
+        example_prompt_data = WELCOME_DATA_EXAMPLE_PROMPT_1
+
+        example_prompt = WelcomeDataExamplePrompt.model_validate(example_prompt_data)
+        self.assertEqual(example_prompt.title, example_prompt_data.get('title'))
+        self.assertEqual(example_prompt.description, example_prompt_data.get('description'))
+        self.assertEqual(example_prompt.prompt_text, example_prompt_data.get('promptText'))
+
+    def test_welcome_data_model_validate(self):
+        welcome_data_data = WELCOME_DATA
+
+        welcome_data = WelcomeData.model_validate(welcome_data_data)
+        self.assertEqual(welcome_data.title, welcome_data_data.get('title'))
+        self.assertEqual(welcome_data.description, welcome_data_data.get('description'))
+        self.assertEqual(
+            welcome_data.features,
+            [WelcomeDataFeature.model_validate(feature) for feature in welcome_data_data.get('features', [])]
+        )
+        self.assertEqual(
+            welcome_data.examples_prompt,
+            [WelcomeDataExamplePrompt.model_validate(example) for example in welcome_data_data.get('examplesPrompt', [])]
+        )
+
+    def test_chat_variable_model_validate(self):
+        chat_variable_data = CHAT_VARIABLE
+
+        chat_variable = ChatVariable.model_validate(chat_variable_data)
+        self.assertEqual(chat_variable.key, chat_variable_data.get('key'))
+        self.assertEqual(chat_variable.value, chat_variable_data.get('value'))
+
+    def test_request_item_model_validate(self):
+        request_item_data = REQUEST_ITEM
+
+        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"))
+        # 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"))
+        self.assertEqual(request_item.status, request_item_data.get("status"))
+
+    def test_project_model_validate(self):
+        project_data = PROJECT_1
+
+        project = Project.model_validate(project_data)
+        self.assertEqual(project.id, project_data["projectId"])
+        self.assertEqual(project.name, project_data["projectName"])
+        self.assertEqual(project.active, project_data["projectActive"])
+        self.assertEqual(project.description, project_data["projectDescription"])
+        self.assertEqual(project.status, project_data["projectStatus"])
+        self.assertEqual(project.organization.id, project_data["organizationId"])
+        self.assertEqual(project.organization.name, project_data["organizationName"])
+        self.assertEqual(len(project.tokens), len(project_data["tokens"]))
+
+        if project.usage_limit:
+            self.assertEqual(project.usage_limit.id, project_data["usageLimit"]["id"])
+            self.assertEqual(project.usage_limit.hard_limit, project_data["usageLimit"]["hardLimit"])
+            self.assertEqual(project.usage_limit.soft_limit, project_data["usageLimit"]["softLimit"])
+            self.assertEqual(project.usage_limit.remaining_usage, project_data["usageLimit"]["remainingUsage"])
+            self.assertEqual(project.usage_limit.renewal_status, project_data["usageLimit"]["renewalStatus"])
+            self.assertEqual(project.usage_limit.status, project_data["usageLimit"]["status"])
+            self.assertEqual(project.usage_limit.subscription_type, project_data["usageLimit"]["subscriptionType"])
+            self.assertEqual(project.usage_limit.usage_unit, project_data["usageLimit"]["usageUnit"])
+            self.assertEqual(project.usage_limit.used_amount, project_data["usageLimit"]["usedAmount"])
+            self.assertEqual(project.usage_limit.valid_from.isoformat(), project_data["usageLimit"]["validFrom"])
+            self.assertEqual(project.usage_limit.valid_until.isoformat(), project_data["usageLimit"]["validUntil"])
+
+    def test_assistant_model_validate(self):
+        assistant_data = ASSISTANT_1
+
+        assistant = Assistant.model_validate(assistant_data)
+
+        self.assertEqual(assistant.id, assistant_data.get("assistantId"))
+        self.assertEqual(assistant.name, assistant_data.get("assistantName"))
+        self.assertEqual(assistant.description, assistant_data.get("assistantDescription"))
+        self.assertEqual(assistant.status, assistant_data.get("assistantStatus"))
+        self.assertEqual(assistant.priority, assistant_data.get("assistantPriority"))
+        self.assertEqual(assistant.type, assistant_data.get("type"))
+        self.assertEqual(assistant.default_revision, assistant_data.get("assistantIntentDefaultRevision"))
+        self.assertEqual(assistant.intent_description, assistant_data.get("assistantIntentDescription"))
+        self.assertEqual(assistant.intent_id, assistant_data.get("assistantIntentId"))
+        self.assertEqual(assistant.intent_name, assistant_data.get("assistantIntentName"))
+
+        revision = assistant.revisions[0]
+        self.assertEqual(revision.model_name, assistant_data['revisions'][0]['modelName'])
+        self.assertEqual(revision.prompt, assistant_data['revisions'][0]['prompt'])
+        self.assertEqual(revision.provider_name, assistant_data['revisions'][0]['providerName'])
+        self.assertEqual(revision.revision_description, assistant_data['revisions'][0]['revisionDescription'])
+        self.assertEqual(revision.revision_id, assistant_data['revisions'][0]['revisionId'])
+        self.assertEqual(revision.revision_name, assistant_data['revisions'][0]['revisionName'])
+        timestamp_str = assistant_data['revisions'][0]['timestamp']
+        timestamp_obj = datetime.strptime(timestamp_str, "%Y-%m-%dT%H:%M:%S")
+        self.assertEqual(revision.timestamp, timestamp_obj)
+
+        project = assistant.project
+        self.assertEqual(project.id, assistant_data['project']['projectId'])
+        self.assertEqual(project.name, assistant_data['project']['projectName'])
+
+        self.assertEqual(assistant.welcome_data.features, assistant_data['welcomeData']['features'])
+        self.assertEqual(assistant.welcome_data.examples_prompt, assistant_data['welcomeData']['examplesPrompt'])

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))
+