pygeai 0.6.0b14__py3-none-any.whl → 0.6.1__py3-none-any.whl

pygeai/tests/auth/test_clients.py

@@ -3,7 +3,7 @@ from unittest.mock import patch, MagicMock
 from json import JSONDecodeError
 
 from pygeai.auth.clients import AuthClient
-from pygeai.core.common.exceptions import InvalidAPIResponseException, APIResponseError
+from pygeai.core.common.exceptions import APIResponseError
 
 
 class TestAuthClient(unittest.TestCase):
@@ -16,7 +16,7 @@ class TestAuthClient(unittest.TestCase):
         self.mock_response = MagicMock()
         self.mock_response.status_code = 200  # Default to success status
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_get_oauth2_access_token_success(self, mock_get):
         self.mock_response.json.return_value = {"access_token": "token-123", "token_type": "Bearer"}
         mock_get.return_value = self.mock_response
@@ -35,7 +35,7 @@ class TestAuthClient(unittest.TestCase):
         self.assertEqual(call_args[1]['params']['scope'], "gam_user_data gam_user_roles")
         self.assertEqual(result, {"access_token": "token-123", "token_type": "Bearer"})
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_get_oauth2_access_token_custom_scope(self, mock_get):
         self.mock_response.json.return_value = {"access_token": "token-123"}
         self.mock_response.status_code = 200
@@ -51,7 +51,7 @@ class TestAuthClient(unittest.TestCase):
         call_args = mock_get.call_args
         self.assertEqual(call_args[1]['params']['scope'], "custom_scope")
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_get_oauth2_access_token_error_status(self, mock_get):
         self.mock_response.status_code = 401
         self.mock_response.text = "Invalid credentials"
@@ -65,44 +65,46 @@ class TestAuthClient(unittest.TestCase):
             )
         self.assertIn("API returned an error", str(context.exception))  # "API returned an error", str(context.exception))
 
-    @patch.object(AuthClient, 'api_service', create=True)
-    def test_get_user_profile_information_success(self, mock_api_service):
+    @patch('pygeai.core.services.rest.GEAIApiService')
+    def test_get_user_profile_information_success(self, mock_api_service_class):
         self.mock_response.json.return_value = {
             "user_id": "user-123",
             "email": "user@example.com",
             "name": "Test User"
         }
         self.mock_response.status_code = 200
-        mock_api_service.get.return_value = self.mock_response
-        mock_api_service.token = None
+        
+        mock_api_service_instance = MagicMock()
+        mock_api_service_instance.get.return_value = self.mock_response
+        mock_api_service_class.return_value = mock_api_service_instance
         
         client = AuthClient()
-        client.api_service = mock_api_service
-        result = client.get_user_profile_information("access-token-123")
+        result = client.get_user_profile_information("access-token-123", project_id="proj-123")
         
-        mock_api_service.get.assert_called_once()
+        mock_api_service_instance.get.assert_called_once()
         self.assertEqual(result, {
             "user_id": "user-123",
             "email": "user@example.com",
             "name": "Test User"
         })
 
-    @patch.object(AuthClient, 'api_service', create=True)
-    def test_get_user_profile_information_json_decode_error(self, mock_api_service):
+    @patch('pygeai.core.services.rest.GEAIApiService')
+    def test_get_user_profile_information_json_decode_error(self, mock_api_service_class):
         self.mock_response.json.side_effect = JSONDecodeError("error", "doc", 0)
         self.mock_response.status_code = 401
         self.mock_response.text = "Invalid token"
-        mock_api_service.get.return_value = self.mock_response
-        mock_api_service.token = None
+        
+        mock_api_service_instance = MagicMock()
+        mock_api_service_instance.get.return_value = self.mock_response
+        mock_api_service_class.return_value = mock_api_service_instance
         
         client = AuthClient()
-        client.api_service = mock_api_service
         
         with self.assertRaises(APIResponseError) as context:
-            client.get_user_profile_information("invalid-token")
+            client.get_user_profile_information("invalid-token", project_id="proj-123")
         self.assertIn("API returned an error", str(context.exception))  # "API returned an error", str(context.exception))
 
-    @patch('pygeai.core.services.rest.ApiService.post')
+    @patch('pygeai.core.services.rest.GEAIApiService.post')
     def test_create_project_api_token_success(self, mock_post):
         self.mock_response.json.return_value = {
             "id": "test_token_id",
@@ -138,7 +140,7 @@ class TestAuthClient(unittest.TestCase):
         self.assertEqual(result['name'], "TestToken")
         self.assertEqual(result['id'], "test_token_id")
 
-    @patch('pygeai.core.services.rest.ApiService.post')
+    @patch('pygeai.core.services.rest.GEAIApiService.post')
     def test_create_project_api_token_without_description(self, mock_post):
         self.mock_response.json.return_value = {
             "id": "test_token_id",
@@ -156,7 +158,7 @@ class TestAuthClient(unittest.TestCase):
         call_args = mock_post.call_args
         self.assertNotIn('description', call_args[1]['data'])
 
-    @patch('pygeai.core.services.rest.ApiService.post')
+    @patch('pygeai.core.services.rest.GEAIApiService.post')
     def test_create_project_api_token_json_decode_error(self, mock_post):
         self.mock_response.json.side_effect = JSONDecodeError("error", "doc", 0)
         self.mock_response.status_code = 400
@@ -170,7 +172,7 @@ class TestAuthClient(unittest.TestCase):
             )
         self.assertIn("API returned an error", str(context.exception))  # "API returned an error", str(context.exception))
 
-    @patch('pygeai.core.services.rest.ApiService.delete')
+    @patch('pygeai.core.services.rest.GEAIApiService.delete')
     def test_delete_project_api_token_success(self, mock_delete):
         self.mock_response.json.return_value = {}
         self.mock_response.status_code = 200
@@ -183,7 +185,7 @@ class TestAuthClient(unittest.TestCase):
         self.assertIn("token-123", call_args[1]['endpoint'])
         self.assertEqual(result, {})
 
-    @patch('pygeai.core.services.rest.ApiService.delete')
+    @patch('pygeai.core.services.rest.GEAIApiService.delete')
     def test_delete_project_api_token_json_decode_error(self, mock_delete):
         self.mock_response.json.side_effect = JSONDecodeError("error", "doc", 0)
         self.mock_response.status_code = 404
@@ -194,7 +196,7 @@ class TestAuthClient(unittest.TestCase):
             self.client.delete_project_api_token(api_token_id="invalid-token")
         self.assertIn("API returned an error", str(context.exception))  # "API returned an error", str(context.exception))
 
-    @patch('pygeai.core.services.rest.ApiService.put')
+    @patch('pygeai.core.services.rest.GEAIApiService.put')
     def test_update_project_api_token_success(self, mock_put):
         self.mock_response.json.return_value = [
             {
@@ -218,7 +220,7 @@ class TestAuthClient(unittest.TestCase):
         self.assertIsInstance(result, list)
         self.assertEqual(result[0]['type'], "Success")
 
-    @patch('pygeai.core.services.rest.ApiService.put')
+    @patch('pygeai.core.services.rest.GEAIApiService.put')
     def test_update_project_api_token_only_description(self, mock_put):
         self.mock_response.json.return_value = [
             {
@@ -238,7 +240,7 @@ class TestAuthClient(unittest.TestCase):
         self.assertEqual(call_args[1]['data']['description'], "New description")
         self.assertNotIn('status', call_args[1]['data'])
 
-    @patch('pygeai.core.services.rest.ApiService.put')
+    @patch('pygeai.core.services.rest.GEAIApiService.put')
     def test_update_project_api_token_json_decode_error(self, mock_put):
         self.mock_response.json.side_effect = JSONDecodeError("error", "doc", 0)
         self.mock_response.status_code = 400
@@ -252,7 +254,7 @@ class TestAuthClient(unittest.TestCase):
             )
         self.assertIn("API returned an error", str(context.exception))  # "API returned an error", str(context.exception))
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_get_project_api_token_success(self, mock_get):
         self.mock_response.json.return_value = {
             "id": "token-123",
@@ -273,7 +275,7 @@ class TestAuthClient(unittest.TestCase):
         self.assertEqual(result['id'], "token-123")
         self.assertEqual(result['status'], "Active")
 
-    @patch('pygeai.core.services.rest.ApiService.get')
+    @patch('pygeai.core.services.rest.GEAIApiService.get')
     def test_get_project_api_token_json_decode_error(self, mock_get):
         self.mock_response.json.side_effect = JSONDecodeError("error", "doc", 0)
         self.mock_response.status_code = 404

pygeai/tests/auth/test_config_manager.py

@@ -0,0 +1,305 @@
+import unittest
+import tempfile
+import os
+
+from pygeai.core.common.config import SettingsManager, get_settings, reset_settings
+
+
+class TestSettingsManager(unittest.TestCase):
+    """
+    Tests for SettingsManager configuration file operations.
+    
+    python -m unittest pygeai.tests.auth.test_config_manager.TestSettingsManager
+    """
+
+    def setUp(self):
+        """Set up test fixtures"""
+        reset_settings()
+        self.temp_creds_file = tempfile.NamedTemporaryFile(mode='w', suffix='_credentials', delete=False)
+        self.temp_creds_file.close()
+
+    def tearDown(self):
+        """Clean up test fixtures"""
+        if os.path.exists(self.temp_creds_file.name):
+            os.unlink(self.temp_creds_file.name)
+        reset_settings()
+
+    def test_creates_empty_credentials_file_if_not_exists(self):
+        """Test that SettingsManager creates empty credentials file if it doesn't exist"""
+        os.unlink(self.temp_creds_file.name)
+        
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        self.assertTrue(os.path.exists(self.temp_creds_file.name))
+
+    def test_set_and_get_api_key(self):
+        """Test setting and getting API key for an alias"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        settings.set_api_key("test_api_key", alias="test")
+        api_key = settings.get_api_key(alias="test")
+        
+        self.assertEqual(api_key, "test_api_key")
+
+    def test_set_and_get_base_url(self):
+        """Test setting and getting base URL for an alias"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        settings.set_base_url("https://test.example.com", alias="test")
+        base_url = settings.get_base_url(alias="test")
+        
+        self.assertEqual(base_url, "https://test.example.com")
+
+    def test_set_and_get_access_token(self):
+        """Test setting and getting OAuth access token"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        settings.set_access_token("oauth_token_123", alias="test")
+        access_token = settings.get_access_token(alias="test")
+        
+        self.assertEqual(access_token, "oauth_token_123")
+
+    def test_set_and_get_project_id(self):
+        """Test setting and getting project ID"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        settings.set_project_id("project-456", alias="test")
+        project_id = settings.get_project_id(alias="test")
+        
+        self.assertEqual(project_id, "project-456")
+
+    def test_set_and_get_organization_id(self):
+        """Test setting and getting organization ID"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        settings.set_organization_id("org-789", alias="test")
+        org_id = settings.get_organization_id(alias="test")
+        
+        self.assertEqual(org_id, "org-789")
+
+    def test_set_and_get_eval_url(self):
+        """Test setting and getting eval URL"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        settings.set_eval_url("https://eval.example.com", alias="test")
+        eval_url = settings.get_eval_url(alias="test")
+        
+        self.assertEqual(eval_url, "https://eval.example.com")
+
+    def test_multiple_aliases(self):
+        """Test that multiple aliases can be managed independently"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        settings.set_api_key("dev_key", alias="dev")
+        settings.set_base_url("https://dev.example.com", alias="dev")
+        
+        settings.set_api_key("prod_key", alias="prod")
+        settings.set_base_url("https://prod.example.com", alias="prod")
+        
+        self.assertEqual(settings.get_api_key(alias="dev"), "dev_key")
+        self.assertEqual(settings.get_base_url(alias="dev"), "https://dev.example.com")
+        
+        self.assertEqual(settings.get_api_key(alias="prod"), "prod_key")
+        self.assertEqual(settings.get_base_url(alias="prod"), "https://prod.example.com")
+
+    def test_list_aliases(self):
+        """Test listing all configured aliases"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        settings.set_base_url("https://dev.example.com", alias="dev")
+        settings.set_base_url("https://staging.example.com", alias="staging")
+        settings.set_base_url("https://prod.example.com", alias="prod")
+        
+        aliases = settings.list_aliases()
+        
+        self.assertEqual(len(aliases), 3)
+        self.assertIn("dev", aliases)
+        self.assertIn("staging", aliases)
+        self.assertIn("prod", aliases)
+        self.assertEqual(aliases["dev"], "https://dev.example.com")
+
+    def test_has_value_returns_true_for_existing(self):
+        """Test has_value returns True for existing setting"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        settings.set_api_key("test_key", alias="test")
+        
+        self.assertTrue(settings.has_value("GEAI_API_KEY", "test"))
+
+    def test_has_value_returns_false_for_missing(self):
+        """Test has_value returns False for missing setting"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        settings.set_api_key("test_key", alias="test")
+        
+        self.assertFalse(settings.has_value("GEAI_API_BASE_URL", "test"))
+
+    def test_has_value_returns_false_for_missing_alias(self):
+        """Test has_value returns False for non-existent alias"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        self.assertFalse(settings.has_value("GEAI_API_KEY", "nonexistent"))
+
+    def test_get_setting_value_returns_empty_for_missing_alias(self):
+        """Test get_setting_value returns None and logs warning for missing alias"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        value = settings.get_setting_value("GEAI_API_KEY", "nonexistent")
+        
+        self.assertIsNone(value)
+
+    def test_auto_adds_eval_url_when_missing(self):
+        """Test that eval_url is auto-added when requested but missing"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        settings.set_api_key("test_key", alias="test")
+        settings.set_base_url("https://test.example.com", alias="test")
+        
+        eval_url = settings.get_setting_value("GEAI_API_EVAL_URL", "test")
+        
+        self.assertEqual(eval_url, "")
+        self.assertTrue(settings.has_value("GEAI_API_EVAL_URL", "test"))
+
+    def test_auto_adds_oauth_vars_when_access_token_present(self):
+        """Test that OAuth vars are auto-added when access_token is present"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        settings.set_access_token("oauth_token_123", alias="test")
+        
+        project_id = settings.get_setting_value("GEAI_PROJECT_ID", "test")
+        org_id = settings.get_setting_value("GEAI_ORGANIZATION_ID", "test")
+        
+        self.assertEqual(project_id, "")
+        self.assertEqual(org_id, "")
+        self.assertTrue(settings.has_value("GEAI_PROJECT_ID", "test"))
+        self.assertTrue(settings.has_value("GEAI_ORGANIZATION_ID", "test"))
+
+
+class TestSettingsManagerEnvironmentVariables(unittest.TestCase):
+    """
+    Tests for environment variable precedence in SettingsManager.
+    
+    python -m unittest pygeai.tests.auth.test_config_manager.TestSettingsManagerEnvironmentVariables
+    """
+
+    def setUp(self):
+        """Set up test fixtures"""
+        reset_settings()
+        self.temp_creds_file = tempfile.NamedTemporaryFile(mode='w', suffix='_credentials', delete=False)
+        self.temp_creds_file.close()
+        
+        self.original_env = {}
+        for key in ['GEAI_API_KEY', 'GEAI_API_BASE_URL', 'GEAI_OAUTH_ACCESS_TOKEN', 
+                    'GEAI_PROJECT_ID', 'GEAI_ORGANIZATION_ID', 'GEAI_API_EVAL_URL']:
+            self.original_env[key] = os.environ.get(key)
+            if key in os.environ:
+                del os.environ[key]
+
+    def tearDown(self):
+        """Clean up test fixtures"""
+        for key, value in self.original_env.items():
+            if value is not None:
+                os.environ[key] = value
+            elif key in os.environ:
+                del os.environ[key]
+        
+        if os.path.exists(self.temp_creds_file.name):
+            os.unlink(self.temp_creds_file.name)
+        reset_settings()
+
+    def test_env_var_overrides_config_for_default_alias(self):
+        """Test that environment variable overrides config file for default alias"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        settings.set_api_key("config_key", alias="default")
+        
+        os.environ['GEAI_API_KEY'] = "env_key"
+        
+        api_key = settings.get_api_key(alias="default")
+        
+        self.assertEqual(api_key, "env_key")
+
+    def test_env_var_does_not_override_non_default_alias(self):
+        """Test that environment variable doesn't override non-default alias"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        settings.set_api_key("config_key", alias="staging")
+        
+        os.environ['GEAI_API_KEY'] = "env_key"
+        
+        api_key = settings.get_api_key(alias="staging")
+        
+        self.assertEqual(api_key, "config_key")
+
+    def test_env_var_used_when_no_config_for_default(self):
+        """Test that environment variable is used when no config exists for default"""
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        os.environ['GEAI_API_KEY'] = "env_key"
+        
+        api_key = settings.get_api_key(alias="default")
+        
+        self.assertEqual(api_key, "env_key")
+
+    def test_all_env_vars_work_for_default_alias(self):
+        """Test that all supported environment variables work"""
+        os.environ['GEAI_API_KEY'] = "env_api_key"
+        os.environ['GEAI_API_BASE_URL'] = "https://env.example.com"
+        os.environ['GEAI_OAUTH_ACCESS_TOKEN'] = "env_oauth_token"
+        os.environ['GEAI_PROJECT_ID'] = "env_project_id"
+        os.environ['GEAI_ORGANIZATION_ID'] = "env_org_id"
+        os.environ['GEAI_API_EVAL_URL'] = "https://env.eval.example.com"
+        
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        self.assertEqual(settings.get_api_key(), "env_api_key")
+        self.assertEqual(settings.get_base_url(), "https://env.example.com")
+        self.assertEqual(settings.get_access_token(), "env_oauth_token")
+        self.assertEqual(settings.get_project_id(), "env_project_id")
+        self.assertEqual(settings.get_organization_id(), "env_org_id")
+        self.assertEqual(settings.get_eval_url(), "https://env.eval.example.com")
+
+    def test_env_var_only_applies_to_default_alias_query(self):
+        """Test that env vars only apply when querying default or no alias"""
+        os.environ['GEAI_API_KEY'] = "env_key"
+        
+        settings = SettingsManager(credentials_file=self.temp_creds_file.name)
+        
+        default_key = settings.get_api_key()
+        self.assertEqual(default_key, "env_key")
+        
+        explicit_default_key = settings.get_api_key(alias="default")
+        self.assertEqual(explicit_default_key, "env_key")
+
+
+class TestGetSettingsSingleton(unittest.TestCase):
+    """
+    Tests for get_settings singleton behavior.
+    
+    python -m unittest pygeai.tests.auth.test_config_manager.TestGetSettingsSingleton
+    """
+
+    def setUp(self):
+        """Set up test fixtures"""
+        reset_settings()
+
+    def tearDown(self):
+        """Clean up test fixtures"""
+        reset_settings()
+
+    def test_get_settings_returns_singleton(self):
+        """Test that get_settings returns the same instance"""
+        settings1 = get_settings()
+        settings2 = get_settings()
+        
+        self.assertIs(settings1, settings2)
+
+    def test_reset_settings_clears_singleton(self):
+        """Test that reset_settings clears the singleton"""
+        settings1 = get_settings()
+        reset_settings()
+        settings2 = get_settings()
+        
+        self.assertIsNot(settings1, settings2)
+
+
+if __name__ == '__main__':
+    unittest.main()