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

pygeai/tests/auth/test_session_validation.py

@@ -0,0 +1,408 @@
+import unittest
+import warnings
+import logging
+import io
+import tempfile
+import os
+
+from pygeai.core.base.session import Session, get_session, reset_session, _validate_alias
+from pygeai.core.common.config import reset_settings, get_settings
+from pygeai.core.common.constants import AuthType
+from pygeai.core.common.exceptions import MissingRequirementException, MixedAuthenticationException
+
+
+class TestSessionValidation(unittest.TestCase):
+    """
+    Tests for Session validation, warnings, and error handling.
+    
+    python -m unittest pygeai.tests.auth.test_session_validation.TestSessionValidation
+    """
+
+    def setUp(self):
+        """Set up test fixtures"""
+        reset_session()
+        reset_settings()
+        
+        self.log_capture = io.StringIO()
+        self.handler = logging.StreamHandler(self.log_capture)
+        self.handler.setLevel(logging.WARNING)
+        
+        self.geai_logger = logging.getLogger('geai')
+        self._original_handlers = self.geai_logger.handlers.copy()
+        self._original_level = self.geai_logger.level
+        
+        self.geai_logger.handlers = []
+        self.geai_logger.addHandler(self.handler)
+        self.geai_logger.setLevel(logging.WARNING)
+        self.geai_logger.propagate = False
+
+    def tearDown(self):
+        """Clean up test fixtures"""
+        self.geai_logger.handlers = self._original_handlers
+        self.geai_logger.level = self._original_level
+        reset_session()
+        reset_settings()
+
+    def test_oauth_requires_project_id(self):
+        """Test that OAuth access_token requires project_id"""
+        with self.assertRaises(MissingRequirementException) as context:
+            Session(
+                base_url="https://api.test.com",
+                access_token="oauth_token_123"
+            )
+        
+        self.assertIn("project_id", str(context.exception).lower())
+
+    def test_project_id_without_access_token_warns(self):
+        """Test that project_id without access_token issues UserWarning"""
+        with warnings.catch_warnings(record=True) as w:
+            warnings.simplefilter("always")
+            
+            session = Session(
+                api_key="api_key_123",
+                base_url="https://api.test.com",
+                project_id="project-123"
+            )
+            
+            self.assertEqual(len(w), 1)
+            self.assertTrue(issubclass(w[0].category, UserWarning))
+            self.assertIn("project_id provided without access_token", str(w[0].message))
+
+    def test_mixed_auth_without_allow_raises_error(self):
+        """Test that both api_key and access_token without allow_mixed_auth raises MixedAuthenticationException"""
+        with self.assertRaises(MixedAuthenticationException) as context:
+            Session(
+                api_key="api_key_123",
+                base_url="https://api.test.com",
+                access_token="oauth_token_123",
+                project_id="project-456",
+                allow_mixed_auth=False
+            )
+        
+        self.assertIn("Cannot specify both", str(context.exception))
+
+    def test_mixed_auth_with_allow_succeeds(self):
+        """Test that mixed auth works when allow_mixed_auth=True"""
+        session = Session(
+            api_key="api_key_123",
+            base_url="https://api.test.com",
+            access_token="oauth_token_123",
+            project_id="project-456",
+            allow_mixed_auth=True
+        )
+        
+        self.assertEqual(session.api_key, "api_key_123")
+        self.assertEqual(session.access_token, "oauth_token_123")
+        self.assertEqual(session.project_id, "project-456")
+        self.assertEqual(session.auth_type, AuthType.OAUTH_TOKEN)
+
+    def test_no_authentication_logs_warning(self):
+        """Test that no authentication method logs warning"""
+        Session(base_url="https://api.test.com")
+        
+        log_output = self.log_capture.getvalue()
+        self.assertIn("No authentication method configured", log_output)
+
+    def test_no_base_url_logs_warning(self):
+        """Test that missing base_url logs warning"""
+        Session(api_key="api_key_123")
+        
+        log_output = self.log_capture.getvalue()
+        self.assertIn("Cannot instantiate session without base_url", log_output)
+
+    def test_auth_type_api_key_only(self):
+        """Test auth type is API_KEY when only api_key is provided"""
+        session = Session(
+            api_key="api_key_123",
+            base_url="https://api.test.com"
+        )
+        
+        self.assertEqual(session.auth_type, AuthType.API_KEY)
+        self.assertTrue(session.is_api_key())
+        self.assertFalse(session.is_oauth())
+
+    def test_auth_type_oauth_only(self):
+        """Test auth type is OAUTH_TOKEN when OAuth credentials are provided"""
+        session = Session(
+            base_url="https://api.test.com",
+            access_token="oauth_token_123",
+            project_id="project-456"
+        )
+        
+        self.assertEqual(session.auth_type, AuthType.OAUTH_TOKEN)
+        self.assertTrue(session.is_oauth())
+        self.assertFalse(session.is_api_key())
+
+    def test_auth_type_none(self):
+        """Test auth type is NONE when no credentials are provided"""
+        session = Session(base_url="https://api.test.com")
+        
+        self.assertEqual(session.auth_type, AuthType.NONE)
+        self.assertFalse(session.is_oauth())
+        self.assertFalse(session.is_api_key())
+
+    def test_auth_type_oauth_takes_precedence(self):
+        """Test that OAuth takes precedence over API key when both are present"""
+        session = Session(
+            api_key="api_key_123",
+            base_url="https://api.test.com",
+            access_token="oauth_token_123",
+            project_id="project-456",
+            allow_mixed_auth=True
+        )
+        
+        self.assertEqual(session.auth_type, AuthType.OAUTH_TOKEN)
+
+    def test_get_active_token_api_key(self):
+        """Test get_active_token returns api_key when using API key auth"""
+        session = Session(
+            api_key="api_key_123",
+            base_url="https://api.test.com"
+        )
+        
+        self.assertEqual(session.get_active_token(), "api_key_123")
+
+    def test_get_active_token_oauth(self):
+        """Test get_active_token returns access_token when using OAuth"""
+        session = Session(
+            base_url="https://api.test.com",
+            access_token="oauth_token_123",
+            project_id="project-456"
+        )
+        
+        self.assertEqual(session.get_active_token(), "oauth_token_123")
+
+    def test_get_active_token_none(self):
+        """Test get_active_token returns None when no auth is configured"""
+        session = Session(base_url="https://api.test.com")
+        
+        self.assertIsNone(session.get_active_token())
+
+    def test_setter_updates_auth_type_api_key(self):
+        """Test that setting api_key updates auth type"""
+        session = Session(base_url="https://api.test.com")
+        self.assertEqual(session.auth_type, AuthType.NONE)
+        
+        session.api_key = "new_api_key"
+        self.assertEqual(session.auth_type, AuthType.API_KEY)
+
+    def test_setter_updates_auth_type_oauth(self):
+        """Test that setting OAuth properties updates auth type"""
+        session = Session(
+            api_key="api_key_123",
+            base_url="https://api.test.com"
+        )
+        self.assertEqual(session.auth_type, AuthType.API_KEY)
+        
+        session.access_token = "oauth_token_123"
+        session.project_id = "project-456"
+        self.assertEqual(session.auth_type, AuthType.OAUTH_TOKEN)
+
+    def test_alias_defaults_to_default(self):
+        """Test that alias defaults to 'default' when not provided"""
+        session = Session(
+            api_key="api_key_123",
+            base_url="https://api.test.com"
+        )
+        
+        self.assertEqual(session.alias, "default")
+
+    def test_alias_can_be_set(self):
+        """Test that custom alias can be set"""
+        session = Session(
+            api_key="api_key_123",
+            base_url="https://api.test.com",
+            alias="production"
+        )
+        
+        self.assertEqual(session.alias, "production")
+
+    def test_organization_id_can_be_set(self):
+        """Test that organization_id can be set and retrieved"""
+        session = Session(
+            base_url="https://api.test.com",
+            access_token="oauth_token_123",
+            project_id="project-456",
+            organization_id="org-789"
+        )
+        
+        self.assertEqual(session.organization_id, "org-789")
+
+
+class TestGetSession(unittest.TestCase):
+    """
+    Tests for get_session function and singleton behavior.
+    
+    python -m unittest pygeai.tests.auth.test_session_validation.TestGetSession
+    """
+
+    def setUp(self):
+        """Set up test fixtures"""
+        reset_session()
+        reset_settings()
+        
+        self.log_capture = io.StringIO()
+        self.handler = logging.StreamHandler(self.log_capture)
+        self.handler.setLevel(logging.WARNING)
+        
+        self.geai_logger = logging.getLogger('geai')
+        self._original_handlers = self.geai_logger.handlers.copy()
+        self._original_level = self.geai_logger.level
+        
+        self.geai_logger.handlers = []
+        self.geai_logger.addHandler(self.handler)
+        self.geai_logger.setLevel(logging.WARNING)
+        self.geai_logger.propagate = False
+
+    def tearDown(self):
+        """Clean up test fixtures"""
+        self.geai_logger.handlers = self._original_handlers
+        self.geai_logger.level = self._original_level
+        reset_session()
+        reset_settings()
+
+    def test_get_session_is_singleton(self):
+        """Test that get_session returns the same instance"""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='_credentials', delete=False) as f:
+            creds_file = f.name
+            f.write('[default]\n')
+            f.write('GEAI_API_KEY = test_key\n')
+            f.write('GEAI_API_BASE_URL = https://test.example.com\n')
+        
+        try:
+            reset_settings()
+            get_settings(credentials_file=creds_file)
+            
+            session1 = get_session()
+            session2 = get_session()
+            
+            self.assertIs(session1, session2)
+        finally:
+            os.unlink(creds_file)
+
+    def test_get_session_loads_from_config(self):
+        """Test that get_session loads credentials from config file"""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='_credentials', delete=False) as f:
+            creds_file = f.name
+            f.write('[default]\n')
+            f.write('GEAI_API_KEY = config_key_123\n')
+            f.write('GEAI_API_BASE_URL = https://config.example.com\n')
+        
+        try:
+            reset_settings()
+            get_settings(credentials_file=creds_file)
+            
+            session = get_session()
+            
+            self.assertEqual(session.api_key, "config_key_123")
+            self.assertEqual(session.base_url, "https://config.example.com")
+        finally:
+            os.unlink(creds_file)
+
+    def test_get_session_loads_oauth_from_config(self):
+        """Test that get_session loads OAuth credentials from config"""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='_credentials', delete=False) as f:
+            creds_file = f.name
+            f.write('[default]\n')
+            f.write('GEAI_OAUTH_ACCESS_TOKEN = oauth_token_123\n')
+            f.write('GEAI_PROJECT_ID = project-456\n')
+            f.write('GEAI_API_BASE_URL = https://oauth.example.com\n')
+        
+        try:
+            reset_settings()
+            get_settings(credentials_file=creds_file)
+            
+            session = get_session()
+            
+            self.assertEqual(session.access_token, "oauth_token_123")
+            self.assertEqual(session.project_id, "project-456")
+            self.assertEqual(session.auth_type, AuthType.OAUTH_TOKEN)
+        finally:
+            os.unlink(creds_file)
+
+    def test_get_session_warns_about_mixed_auth(self):
+        """Test that get_session warns when both API key and OAuth are configured"""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='_credentials', delete=False) as f:
+            creds_file = f.name
+            f.write('[default]\n')
+            f.write('GEAI_API_KEY = api_key_123\n')
+            f.write('GEAI_OAUTH_ACCESS_TOKEN = oauth_token_123\n')
+            f.write('GEAI_PROJECT_ID = project-456\n')
+            f.write('GEAI_API_BASE_URL = https://mixed.example.com\n')
+        
+        try:
+            reset_settings()
+            get_settings(credentials_file=creds_file)
+            
+            session = get_session()
+            
+            log_output = self.log_capture.getvalue()
+            self.assertIn("Both API key and OAuth token configured", log_output)
+            self.assertIn("OAuth token will take precedence", log_output)
+        finally:
+            os.unlink(creds_file)
+
+    def test_get_session_updates_existing_with_alias(self):
+        """Test that get_session with alias updates existing session"""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='_credentials', delete=False) as f:
+            creds_file = f.name
+            f.write('[default]\n')
+            f.write('GEAI_API_KEY = default_key\n')
+            f.write('GEAI_API_BASE_URL = https://default.example.com\n')
+            f.write('\n')
+            f.write('[staging]\n')
+            f.write('GEAI_API_KEY = staging_key\n')
+            f.write('GEAI_API_BASE_URL = https://staging.example.com\n')
+        
+        try:
+            reset_settings()
+            get_settings(credentials_file=creds_file)
+            
+            session1 = get_session('default')
+            self.assertEqual(session1.api_key, "default_key")
+            
+            session2 = get_session('staging')
+            self.assertEqual(session2.api_key, "staging_key")
+            
+            self.assertIs(session1, session2)
+        finally:
+            os.unlink(creds_file)
+
+    def test_validate_alias_raises_for_missing(self):
+        """Test that _validate_alias raises exception for non-existent alias"""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='_credentials', delete=False) as f:
+            creds_file = f.name
+            f.write('[default]\n')
+            f.write('GEAI_API_KEY = test_key\n')
+            f.write('GEAI_API_BASE_URL = https://test.example.com\n')
+        
+        try:
+            reset_settings()
+            get_settings(credentials_file=creds_file)
+            
+            with self.assertRaises(MissingRequirementException) as context:
+                _validate_alias('nonexistent', allow_missing_default=False)
+            
+            self.assertIn("doesn't exist", str(context.exception))
+        finally:
+            os.unlink(creds_file)
+
+    def test_validate_alias_allows_missing_default(self):
+        """Test that _validate_alias allows missing 'default' when flag is set"""
+        with tempfile.NamedTemporaryFile(mode='w', suffix='_credentials', delete=False) as f:
+            creds_file = f.name
+            f.write('[production]\n')
+            f.write('GEAI_API_KEY = prod_key\n')
+            f.write('GEAI_API_BASE_URL = https://prod.example.com\n')
+        
+        try:
+            reset_settings()
+            get_settings(credentials_file=creds_file)
+            
+            _validate_alias('default', allow_missing_default=True)
+        finally:
+            os.unlink(creds_file)
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/auth/test_singleton_reset.py

@@ -0,0 +1,201 @@
+import unittest
+
+from pygeai.core.singleton import Singleton
+from pygeai.core.base.session import Session, reset_session
+from pygeai.core.common.constants import AuthType
+
+
+class TestSingletonReset(unittest.TestCase):
+    """
+    Tests for Singleton reset functionality to ensure proper test isolation.
+    
+    python -m unittest pygeai.tests.auth.test_singleton_reset.TestSingletonReset
+    """
+
+    def setUp(self):
+        """Set up test fixtures"""
+        reset_session()
+
+    def tearDown(self):
+        """Clean up test fixtures"""
+        reset_session()
+
+    def test_singleton_returns_same_instance(self):
+        """Test that Singleton returns the same instance without reset"""
+        s1 = Session(api_key="key1", base_url="https://test1.com")
+        s2 = Session(api_key="key2", base_url="https://test2.com")
+        
+        self.assertIs(s1, s2)
+        self.assertEqual(s1.api_key, "key1")
+        self.assertEqual(s2.api_key, "key1")
+
+    def test_reset_instance_clears_singleton_cache(self):
+        """Test that Singleton.reset_instance clears the cache for specific class"""
+        s1 = Session(api_key="key1", base_url="https://test1.com")
+        self.assertEqual(s1.api_key, "key1")
+        
+        Singleton.reset_instance(Session)
+        
+        s2 = Session(api_key="key2", base_url="https://test2.com")
+        
+        self.assertIsNot(s1, s2)
+        self.assertEqual(s2.api_key, "key2")
+
+    def test_reset_session_clears_singleton_cache(self):
+        """Test that reset_session() clears both global variable and singleton cache"""
+        s1 = Session(api_key="key1", base_url="https://test1.com")
+        self.assertEqual(s1.api_key, "key1")
+        self.assertEqual(s1.auth_type, AuthType.API_KEY)
+        
+        reset_session()
+        
+        s2 = Session(
+            base_url="https://test2.com",
+            access_token="token2",
+            project_id="project2"
+        )
+        
+        self.assertIsNot(s1, s2)
+        self.assertEqual(s2.access_token, "token2")
+        self.assertEqual(s2.auth_type, AuthType.OAUTH_TOKEN)
+        self.assertIsNone(s2.api_key)
+
+    def test_reset_allows_different_auth_types(self):
+        """Test that reset allows switching between auth types"""
+        s1 = Session(api_key="api_key", base_url="https://test.com")
+        self.assertEqual(s1.auth_type, AuthType.API_KEY)
+        
+        reset_session()
+        
+        s2 = Session(
+            base_url="https://test.com",
+            access_token="oauth_token",
+            project_id="project_id"
+        )
+        self.assertEqual(s2.auth_type, AuthType.OAUTH_TOKEN)
+        
+        reset_session()
+        
+        s3 = Session(base_url="https://test.com")
+        self.assertEqual(s3.auth_type, AuthType.NONE)
+
+    def test_reset_session_allows_clean_state(self):
+        """Test that reset_session creates truly independent instances"""
+        s1 = Session(
+            api_key="key1",
+            base_url="https://test1.com",
+            access_token="token1",
+            project_id="project1",
+            organization_id="org1",
+            allow_mixed_auth=True
+        )
+        
+        self.assertEqual(s1.api_key, "key1")
+        self.assertEqual(s1.access_token, "token1")
+        self.assertEqual(s1.project_id, "project1")
+        self.assertEqual(s1.organization_id, "org1")
+        
+        reset_session()
+        
+        s2 = Session(base_url="https://test2.com")
+        
+        self.assertIsNot(s1, s2)
+        self.assertIsNone(s2.api_key)
+        self.assertIsNone(s2.access_token)
+        self.assertIsNone(s2.project_id)
+        self.assertIsNone(s2.organization_id)
+        self.assertEqual(s2.auth_type, AuthType.NONE)
+
+    def test_reset_all_instances_clears_everything(self):
+        """Test that reset_all_instances clears all singleton caches"""
+        s1 = Session(api_key="key1", base_url="https://test1.com")
+        
+        Singleton.reset_all_instances()
+        
+        s2 = Session(api_key="key2", base_url="https://test2.com")
+        
+        self.assertIsNot(s1, s2)
+        self.assertEqual(s2.api_key, "key2")
+
+    def test_singleton_cache_persists_without_reset(self):
+        """Test that without reset, singleton cache persists"""
+        s1 = Session(api_key="persistent_key", base_url="https://test.com")
+        
+        s2 = Session(api_key="ignored_key", base_url="https://ignored.com")
+        
+        self.assertIs(s1, s2)
+        self.assertEqual(s2.api_key, "persistent_key")
+        self.assertEqual(s2.base_url, "https://test.com")
+
+    def test_reset_does_not_affect_other_sessions(self):
+        """Test that reset only affects Session class singleton"""
+        s1 = Session(api_key="key1", base_url="https://test1.com")
+        
+        reset_session()
+        
+        s2 = Session(api_key="key2", base_url="https://test2.com")
+        
+        self.assertIsNot(s1, s2)
+        self.assertNotEqual(s1.api_key, s2.api_key)
+
+
+class TestSingletonResetSequence(unittest.TestCase):
+    """
+    Tests that simulate the sequence of tests running to verify isolation.
+    
+    python -m unittest pygeai.tests.auth.test_singleton_reset.TestSingletonResetSequence
+    """
+
+    def setUp(self):
+        """Set up test fixtures"""
+        reset_session()
+
+    def tearDown(self):
+        """Clean up test fixtures"""
+        reset_session()
+
+    def test_sequence_1_oauth_session(self):
+        """Simulates a test creating OAuth session"""
+        session = Session(
+            base_url="https://test.com",
+            access_token="oauth_token",
+            project_id="project_id"
+        )
+        
+        self.assertEqual(session.auth_type, AuthType.OAUTH_TOKEN)
+        self.assertEqual(session.access_token, "oauth_token")
+
+    def test_sequence_2_api_key_session(self):
+        """Simulates next test creating API key session - should not see OAuth"""
+        session = Session(
+            api_key="api_key",
+            base_url="https://test.com"
+        )
+        
+        self.assertEqual(session.auth_type, AuthType.API_KEY)
+        self.assertEqual(session.api_key, "api_key")
+        self.assertIsNone(session.access_token)
+
+    def test_sequence_3_no_auth_session(self):
+        """Simulates test creating session with no auth - should not see previous auth"""
+        session = Session(base_url="https://test.com")
+        
+        self.assertEqual(session.auth_type, AuthType.NONE)
+        self.assertIsNone(session.api_key)
+        self.assertIsNone(session.access_token)
+
+    def test_sequence_4_different_oauth_session(self):
+        """Simulates test creating different OAuth session - should not see previous"""
+        session = Session(
+            base_url="https://test.com",
+            access_token="different_token",
+            project_id="different_project"
+        )
+        
+        self.assertEqual(session.auth_type, AuthType.OAUTH_TOKEN)
+        self.assertEqual(session.access_token, "different_token")
+        self.assertEqual(session.project_id, "different_project")
+
+
+if __name__ == '__main__':
+    unittest.main()

pygeai/tests/chat/test_clients.py

@@ -1,5 +1,5 @@
 import unittest
-from unittest.mock import patch, MagicMock
+from unittest.mock import MagicMock
 import json
 from pygeai.chat.clients import ChatClient
 from pygeai.core.common.exceptions import InvalidAPIResponseException

pygeai/tests/chat/test_iris.py

@@ -1,5 +1,5 @@
 import unittest
-from unittest.mock import patch, MagicMock
+from unittest.mock import MagicMock
 from pygeai.chat.iris import Iris
 
 

pygeai/tests/chat/test_ui.py

@@ -3,7 +3,6 @@ import os
 import json
 from datetime import datetime
 from unittest.mock import patch, MagicMock
-import streamlit as st
 from pygeai.chat.ui import (
     parse_args,
     save_session_to_file,
@@ -17,7 +16,6 @@ from pygeai.chat.ui import (
     save_recent_agents,
     load_recent_agents
 )
-from pygeai.lab.models import AgentList, Agent
 
 
 class TestStreamlitChat(unittest.TestCase):

pygeai/tests/cli/commands/lab/test_ai_lab.py

@@ -1,6 +1,5 @@
 import unittest
 from unittest.mock import patch, MagicMock
-import json
 from pygeai.cli.commands.lab.ai_lab import (
     show_help,
     list_agents,
@@ -38,7 +37,6 @@ from pygeai.cli.commands.lab.ai_lab import (
     start_instance,
     abort_instance,
     get_instance,
-    get_instance_history,
     get_thread_information,
     send_user_signal,
     create_kb,
@@ -91,7 +89,7 @@ class TestAILab(unittest.TestCase):
         option_list = [(Option("project_id", ["--project-id"], "", True), "proj123")]
         with self.assertRaises(MissingRequirementException) as cm:
             create_agent(option_list)
-        self.assertEqual(str(cm.exception), "Cannot create assistant without specifying name, access scope and public name")
+        self.assertEqual(str(cm.exception), "Cannot create assistant without specifying name.")
 
     def test_create_agent_invalid_input_json(self):
         option_list = [

pygeai/tests/cli/commands/lab/test_common.py

@@ -1,4 +1,3 @@
-import unittest
 from unittest import TestCase
 from pygeai.cli.commands.lab.common import (
     get_agent_data_prompt_inputs,

pygeai/tests/cli/commands/test_chat.py

@@ -1,6 +1,6 @@
 import unittest
 from unittest.mock import patch, MagicMock
-from pygeai.cli.commands.chat import show_help, get_chat_completion, chat_with_iris, chat_with_agent
+from pygeai.cli.commands.chat import get_chat_completion, chat_with_iris, chat_with_agent
 from pygeai.core.common.exceptions import MissingRequirementException, WrongArgumentError
 from pygeai.cli.commands import Option
 

pygeai/tests/cli/commands/test_common.py

@@ -1,5 +1,4 @@
 import unittest
-from unittest.mock import patch
 
 from pygeai.cli.commands.common import (
     get_llm_settings,