hdsp-jupyter-extension 2.0.0__py3-none-any.whl

hdsp_agent_core/tests/test_factory.py

@@ -0,0 +1,251 @@
+"""
+HDSP Agent Core - ServiceFactory Tests
+
+Tests for ServiceFactory mode detection, initialization, and service creation.
+"""
+
+import os
+from unittest.mock import AsyncMock, patch
+
+import pytest
+
+from hdsp_agent_core.factory import AgentMode, ServiceFactory, get_service_factory
+from hdsp_agent_core.interfaces import IAgentService, IChatService, IRAGService
+
+
+class TestAgentMode:
+    """Tests for AgentMode enum"""
+
+    def test_embedded_mode_value(self):
+        """Test embedded mode has correct value"""
+        assert AgentMode.EMBEDDED.value == "embedded"
+
+    def test_proxy_mode_value(self):
+        """Test proxy mode has correct value"""
+        assert AgentMode.PROXY.value == "proxy"
+
+
+class TestServiceFactorySingleton:
+    """Tests for ServiceFactory singleton pattern"""
+
+    def test_get_instance_returns_same_instance(self, reset_factory):
+        """Test get_instance returns the same instance"""
+        instance1 = ServiceFactory.get_instance()
+        instance2 = ServiceFactory.get_instance()
+        assert instance1 is instance2
+
+    def test_reset_instance_clears_singleton(self, reset_factory):
+        """Test reset_instance clears the singleton"""
+        instance1 = ServiceFactory.get_instance()
+        ServiceFactory.reset_instance()
+        instance2 = ServiceFactory.get_instance()
+        assert instance1 is not instance2
+
+    def test_get_service_factory_convenience_function(self, reset_factory):
+        """Test get_service_factory returns singleton"""
+        factory1 = get_service_factory()
+        factory2 = ServiceFactory.get_instance()
+        assert factory1 is factory2
+
+
+class TestServiceFactoryModeDetection:
+    """Tests for mode detection from environment"""
+
+    def test_default_mode_is_proxy(self, reset_factory):
+        """Test default mode is proxy when no env var set"""
+        with patch.dict(os.environ, {}, clear=True):
+            # Clear HDSP_AGENT_MODE if it exists
+            os.environ.pop("HDSP_AGENT_MODE", None)
+            factory = ServiceFactory()
+            assert factory.mode == AgentMode.PROXY
+            assert factory.is_proxy is True
+            assert factory.is_embedded is False
+
+    def test_embedded_mode_detection(self, reset_factory, mock_env_embedded):
+        """Test embedded mode is detected from env var"""
+        factory = ServiceFactory()
+        assert factory.mode == AgentMode.EMBEDDED
+        assert factory.is_embedded is True
+        assert factory.is_proxy is False
+
+    def test_proxy_mode_detection(self, reset_factory, mock_env_proxy):
+        """Test proxy mode is detected from env var"""
+        factory = ServiceFactory()
+        assert factory.mode == AgentMode.PROXY
+        assert factory.is_proxy is True
+        assert factory.is_embedded is False
+
+    def test_case_insensitive_mode_detection(self, reset_factory):
+        """Test mode detection is case-insensitive"""
+        with patch.dict(os.environ, {"HDSP_AGENT_MODE": "EMBEDDED"}):
+            factory = ServiceFactory()
+            assert factory.mode == AgentMode.EMBEDDED
+
+    def test_invalid_mode_defaults_to_proxy(self, reset_factory):
+        """Test invalid mode defaults to proxy"""
+        with patch.dict(os.environ, {"HDSP_AGENT_MODE": "invalid_mode"}):
+            factory = ServiceFactory()
+            assert factory.mode == AgentMode.PROXY
+
+
+class TestServiceFactoryConfiguration:
+    """Tests for proxy mode configuration"""
+
+    def test_default_server_url(self, reset_factory):
+        """Test default server URL"""
+        with patch.dict(os.environ, {}, clear=True):
+            os.environ.pop("AGENT_SERVER_URL", None)
+            factory = ServiceFactory()
+            assert factory.server_url == "http://localhost:8000"
+
+    def test_custom_server_url(self, reset_factory, mock_env_proxy_with_url):
+        """Test custom server URL from env var"""
+        factory = ServiceFactory()
+        assert factory.server_url == "http://agent.example.com:9000"
+
+    def test_default_timeout(self, reset_factory):
+        """Test default timeout"""
+        with patch.dict(os.environ, {}, clear=True):
+            os.environ.pop("AGENT_SERVER_TIMEOUT", None)
+            factory = ServiceFactory()
+            assert factory.timeout == 120.0
+
+    def test_custom_timeout(self, reset_factory, mock_env_proxy_with_url):
+        """Test custom timeout from env var"""
+        factory = ServiceFactory()
+        assert factory.timeout == 60.0
+
+
+class TestServiceFactoryInitialization:
+    """Tests for ServiceFactory initialization"""
+
+    def test_not_initialized_by_default(self, reset_factory, mock_env_proxy):
+        """Test factory is not initialized by default"""
+        factory = ServiceFactory.get_instance()
+        assert factory.is_initialized is False
+
+    @pytest.mark.asyncio
+    async def test_initialize_proxy_mode(self, reset_factory, mock_env_proxy):
+        """Test initialization in proxy mode"""
+        factory = ServiceFactory.get_instance()
+        await factory.initialize()
+        assert factory.is_initialized is True
+
+    @pytest.mark.asyncio
+    async def test_initialize_embedded_mode(self, reset_factory, mock_env_embedded):
+        """Test initialization in embedded mode"""
+        # Mock the RAG service initialization
+        with patch(
+            "hdsp_agent_core.services.rag_service.EmbeddedRAGService.initialize",
+            new_callable=AsyncMock
+        ):
+            factory = ServiceFactory.get_instance()
+            await factory.initialize()
+            assert factory.is_initialized is True
+
+    @pytest.mark.asyncio
+    async def test_double_initialization_is_noop(self, reset_factory, mock_env_proxy):
+        """Test calling initialize twice is safe"""
+        factory = ServiceFactory.get_instance()
+        await factory.initialize()
+        await factory.initialize()  # Should not raise
+        assert factory.is_initialized is True
+
+    @pytest.mark.asyncio
+    async def test_shutdown_resets_state(self, reset_factory, mock_env_proxy):
+        """Test shutdown resets initialization state"""
+        factory = ServiceFactory.get_instance()
+        await factory.initialize()
+        assert factory.is_initialized is True
+        await factory.shutdown()
+        assert factory.is_initialized is False
+
+
+class TestServiceFactoryServiceAccess:
+    """Tests for service accessor methods"""
+
+    @pytest.mark.asyncio
+    async def test_get_agent_service_after_init(self, reset_factory, mock_env_proxy):
+        """Test get_agent_service returns service after init"""
+        factory = ServiceFactory.get_instance()
+        await factory.initialize()
+        service = factory.get_agent_service()
+        assert service is not None
+        assert isinstance(service, IAgentService)
+
+    @pytest.mark.asyncio
+    async def test_get_chat_service_after_init(self, reset_factory, mock_env_proxy):
+        """Test get_chat_service returns service after init"""
+        factory = ServiceFactory.get_instance()
+        await factory.initialize()
+        service = factory.get_chat_service()
+        assert service is not None
+        assert isinstance(service, IChatService)
+
+    @pytest.mark.asyncio
+    async def test_get_rag_service_after_init(self, reset_factory, mock_env_proxy):
+        """Test get_rag_service returns service after init"""
+        factory = ServiceFactory.get_instance()
+        await factory.initialize()
+        service = factory.get_rag_service()
+        assert service is not None
+        assert isinstance(service, IRAGService)
+
+    def test_get_agent_service_before_init_raises(self, reset_factory, mock_env_proxy):
+        """Test get_agent_service raises before initialization"""
+        factory = ServiceFactory.get_instance()
+        with pytest.raises(RuntimeError, match="not initialized"):
+            factory.get_agent_service()
+
+    def test_get_chat_service_before_init_raises(self, reset_factory, mock_env_proxy):
+        """Test get_chat_service raises before initialization"""
+        factory = ServiceFactory.get_instance()
+        with pytest.raises(RuntimeError, match="not initialized"):
+            factory.get_chat_service()
+
+    def test_get_rag_service_before_init_raises(self, reset_factory, mock_env_proxy):
+        """Test get_rag_service raises before initialization"""
+        factory = ServiceFactory.get_instance()
+        with pytest.raises(RuntimeError, match="not initialized"):
+            factory.get_rag_service()
+
+
+class TestServiceFactoryModeSpecificServices:
+    """Tests for mode-specific service creation"""
+
+    @pytest.mark.asyncio
+    async def test_proxy_mode_creates_proxy_services(
+        self, reset_factory, mock_env_proxy
+    ):
+        """Test proxy mode creates ProxyXxxService instances"""
+        from hdsp_agent_core.services.agent_service import ProxyAgentService
+        from hdsp_agent_core.services.chat_service import ProxyChatService
+        from hdsp_agent_core.services.rag_service import ProxyRAGService
+
+        factory = ServiceFactory.get_instance()
+        await factory.initialize()
+
+        assert isinstance(factory.get_agent_service(), ProxyAgentService)
+        assert isinstance(factory.get_chat_service(), ProxyChatService)
+        assert isinstance(factory.get_rag_service(), ProxyRAGService)
+
+    @pytest.mark.asyncio
+    async def test_embedded_mode_creates_embedded_services(
+        self, reset_factory, mock_env_embedded
+    ):
+        """Test embedded mode creates EmbeddedXxxService instances"""
+        from hdsp_agent_core.services.agent_service import EmbeddedAgentService
+        from hdsp_agent_core.services.chat_service import EmbeddedChatService
+        from hdsp_agent_core.services.rag_service import EmbeddedRAGService
+
+        # Mock RAG initialization
+        with patch(
+            "hdsp_agent_core.services.rag_service.EmbeddedRAGService.initialize",
+            new_callable=AsyncMock
+        ):
+            factory = ServiceFactory.get_instance()
+            await factory.initialize()
+
+            assert isinstance(factory.get_agent_service(), EmbeddedAgentService)
+            assert isinstance(factory.get_chat_service(), EmbeddedChatService)
+            assert isinstance(factory.get_rag_service(), EmbeddedRAGService)

hdsp_agent_core/tests/test_services.py

@@ -0,0 +1,326 @@
+"""
+HDSP Agent Core - Service Implementation Tests
+
+Tests for Embedded and Proxy service implementations.
+"""
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from hdsp_agent_core.interfaces import IAgentService, IChatService, IRAGService
+
+
+class TestProxyAgentService:
+    """Tests for ProxyAgentService"""
+
+    @pytest.fixture
+    def proxy_agent_service(self):
+        """Create ProxyAgentService instance"""
+        from hdsp_agent_core.services.agent_service import ProxyAgentService
+        return ProxyAgentService(
+            base_url="http://localhost:8000",
+            timeout=30.0
+        )
+
+    def test_implements_interface(self, proxy_agent_service):
+        """Test ProxyAgentService implements IAgentService"""
+        assert isinstance(proxy_agent_service, IAgentService)
+
+    def test_base_url_configuration(self, proxy_agent_service):
+        """Test base URL is configured correctly"""
+        assert proxy_agent_service._base_url == "http://localhost:8000"
+
+    def test_timeout_configuration(self, proxy_agent_service):
+        """Test timeout is configured correctly"""
+        assert proxy_agent_service._timeout == 30.0
+
+    @pytest.mark.asyncio
+    async def test_generate_plan_makes_http_request(
+        self, proxy_agent_service, sample_plan_request
+    ):
+        """Test generate_plan makes HTTP POST request"""
+        mock_response_data = {
+            "plan": {
+                "goal": "Create a simple plot",
+                "totalSteps": 1,
+                "steps": []
+            },
+            "reasoning": "Test reasoning"
+        }
+
+        with patch(
+            "hdsp_agent_core.services.agent_service.httpx.AsyncClient"
+        ) as mock_client_class:
+            mock_client = AsyncMock()
+            mock_response = MagicMock()
+            mock_response.json.return_value = mock_response_data
+            mock_response.raise_for_status = MagicMock()
+            mock_client.post = AsyncMock(return_value=mock_response)
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=None)
+            mock_client_class.return_value = mock_client
+
+            result = await proxy_agent_service.generate_plan(sample_plan_request)
+
+            # Verify HTTP call was made
+            mock_client.post.assert_called_once()
+            call_args = mock_client.post.call_args
+            assert "/agent/plan" in call_args[0][0]
+
+
+class TestProxyChatService:
+    """Tests for ProxyChatService"""
+
+    @pytest.fixture
+    def proxy_chat_service(self):
+        """Create ProxyChatService instance"""
+        from hdsp_agent_core.services.chat_service import ProxyChatService
+        return ProxyChatService(
+            base_url="http://localhost:8000",
+            timeout=30.0
+        )
+
+    def test_implements_interface(self, proxy_chat_service):
+        """Test ProxyChatService implements IChatService"""
+        assert isinstance(proxy_chat_service, IChatService)
+
+    @pytest.mark.asyncio
+    async def test_send_message_makes_http_request(
+        self, proxy_chat_service, sample_chat_request
+    ):
+        """Test send_message makes HTTP POST request"""
+        mock_response_data = {
+            "response": "Hello! I can help you analyze the data.",
+            "conversationId": "test-conversation",
+        }
+
+        with patch(
+            "hdsp_agent_core.services.chat_service.httpx.AsyncClient"
+        ) as mock_client_class:
+            mock_client = AsyncMock()
+            mock_response = MagicMock()
+            mock_response.json.return_value = mock_response_data
+            mock_response.raise_for_status = MagicMock()
+            mock_client.post = AsyncMock(return_value=mock_response)
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=None)
+            mock_client_class.return_value = mock_client
+
+            result = await proxy_chat_service.send_message(sample_chat_request)
+
+            mock_client.post.assert_called_once()
+
+
+class TestProxyRAGService:
+    """Tests for ProxyRAGService"""
+
+    @pytest.fixture
+    def proxy_rag_service(self):
+        """Create ProxyRAGService instance"""
+        from hdsp_agent_core.services.rag_service import ProxyRAGService
+        return ProxyRAGService(
+            base_url="http://localhost:8000",
+            timeout=30.0
+        )
+
+    def test_implements_interface(self, proxy_rag_service):
+        """Test ProxyRAGService implements IRAGService"""
+        assert isinstance(proxy_rag_service, IRAGService)
+
+    @pytest.mark.asyncio
+    async def test_search_makes_http_request(
+        self, proxy_rag_service, sample_search_request
+    ):
+        """Test search makes HTTP POST request"""
+        mock_response_data = {
+            "results": [],
+            "query": "pandas dataframe operations",
+            "total_results": 0,
+        }
+
+        with patch(
+            "hdsp_agent_core.services.rag_service.httpx.AsyncClient"
+        ) as mock_client_class:
+            mock_client = AsyncMock()
+            mock_response = MagicMock()
+            mock_response.json.return_value = mock_response_data
+            mock_response.raise_for_status = MagicMock()
+            mock_client.post = AsyncMock(return_value=mock_response)
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=None)
+            mock_client_class.return_value = mock_client
+
+            result = await proxy_rag_service.search(sample_search_request)
+
+            mock_client.post.assert_called_once()
+
+    def test_is_ready_returns_false_before_init(self, proxy_rag_service):
+        """Test is_ready returns False before initialization"""
+        # Proxy service is not ready until initialize() is called
+        assert proxy_rag_service.is_ready() is False
+
+    @pytest.mark.asyncio
+    async def test_is_ready_after_init(self, proxy_rag_service):
+        """Test is_ready after successful initialization"""
+        mock_status = {"ready": True}
+
+        with patch(
+            "hdsp_agent_core.services.rag_service.httpx.AsyncClient"
+        ) as mock_client_class:
+            mock_client = AsyncMock()
+            mock_response = MagicMock()
+            mock_response.json.return_value = mock_status
+            mock_response.raise_for_status = MagicMock()
+            mock_client.get = AsyncMock(return_value=mock_response)
+            mock_client.__aenter__ = AsyncMock(return_value=mock_client)
+            mock_client.__aexit__ = AsyncMock(return_value=None)
+            mock_client_class.return_value = mock_client
+
+            await proxy_rag_service.initialize()
+
+            assert proxy_rag_service.is_ready() is True
+
+
+class TestEmbeddedAgentService:
+    """Tests for EmbeddedAgentService"""
+
+    @pytest.fixture
+    def embedded_agent_service(self):
+        """Create EmbeddedAgentService instance"""
+        from hdsp_agent_core.services.agent_service import EmbeddedAgentService
+        return EmbeddedAgentService()
+
+    def test_implements_interface(self, embedded_agent_service):
+        """Test EmbeddedAgentService implements IAgentService"""
+        assert isinstance(embedded_agent_service, IAgentService)
+
+    @pytest.mark.asyncio
+    async def test_generate_plan_with_mock_llm(
+        self, embedded_agent_service, sample_plan_request
+    ):
+        """Test generate_plan calls LLM service"""
+        # Mock the LLM service
+        with patch.object(
+            embedded_agent_service, '_llm_service', create=True
+        ) as mock_llm:
+            mock_llm.generate_response = AsyncMock(
+                return_value='{"steps": [], "plan_id": "test"}'
+            )
+
+            # Note: Full integration test would require more mocking
+            # This is a placeholder for when LLM integration is complete
+
+
+class TestEmbeddedChatService:
+    """Tests for EmbeddedChatService"""
+
+    @pytest.fixture
+    def embedded_chat_service(self):
+        """Create EmbeddedChatService instance"""
+        from hdsp_agent_core.services.chat_service import EmbeddedChatService
+        return EmbeddedChatService()
+
+    def test_implements_interface(self, embedded_chat_service):
+        """Test EmbeddedChatService implements IChatService"""
+        assert isinstance(embedded_chat_service, IChatService)
+
+
+class TestEmbeddedRAGService:
+    """Tests for EmbeddedRAGService"""
+
+    @pytest.fixture
+    def embedded_rag_service(self):
+        """Create EmbeddedRAGService instance with mocked RAG manager"""
+        from hdsp_agent_core.services.rag_service import EmbeddedRAGService
+        service = EmbeddedRAGService()
+        return service
+
+    def test_implements_interface(self, embedded_rag_service):
+        """Test EmbeddedRAGService implements IRAGService"""
+        assert isinstance(embedded_rag_service, IRAGService)
+
+    def test_is_ready_before_init(self, embedded_rag_service):
+        """Test is_ready returns False before initialization"""
+        assert embedded_rag_service.is_ready() is False
+
+    @pytest.mark.asyncio
+    async def test_initialize_sets_ready(self, embedded_rag_service, mock_rag_manager):
+        """Test initialize makes service ready when RAGManager is available"""
+        # Directly set the internal state to simulate successful initialization
+        # since the actual rag_manager module might not be available
+        mock_rag_manager.is_ready = True
+        embedded_rag_service._rag_manager = mock_rag_manager
+        embedded_rag_service._initialized = True
+
+        assert embedded_rag_service.is_ready() is True
+
+    @pytest.mark.asyncio
+    async def test_initialize_handles_import_error(self, embedded_rag_service):
+        """Test initialize handles ImportError gracefully"""
+        # The service should remain not ready if rag_manager import fails
+        # Since rag_manager doesn't exist yet, initialize() should catch the error
+        await embedded_rag_service.initialize()
+
+        # Service should not be ready because rag_manager module doesn't exist
+        assert embedded_rag_service.is_ready() is False
+
+
+class TestServiceInterfaceCompliance:
+    """Tests to verify all services implement their interfaces correctly"""
+
+    def test_all_agent_service_methods_exist(self):
+        """Verify all IAgentService methods are implemented"""
+        from hdsp_agent_core.services.agent_service import (
+            EmbeddedAgentService,
+            ProxyAgentService,
+        )
+
+        required_methods = [
+            "generate_plan",
+            "refine_code",
+            "replan",
+            "validate_code",
+        ]
+
+        for cls in [EmbeddedAgentService, ProxyAgentService]:
+            for method in required_methods:
+                assert hasattr(cls, method), f"{cls.__name__} missing {method}"
+                assert callable(getattr(cls, method))
+
+    def test_all_chat_service_methods_exist(self):
+        """Verify all IChatService methods are implemented"""
+        from hdsp_agent_core.services.chat_service import (
+            EmbeddedChatService,
+            ProxyChatService,
+        )
+
+        required_methods = [
+            "send_message",
+            "send_message_stream",
+        ]
+
+        for cls in [EmbeddedChatService, ProxyChatService]:
+            for method in required_methods:
+                assert hasattr(cls, method), f"{cls.__name__} missing {method}"
+                assert callable(getattr(cls, method))
+
+    def test_all_rag_service_methods_exist(self):
+        """Verify all IRAGService methods are implemented"""
+        from hdsp_agent_core.services.rag_service import (
+            EmbeddedRAGService,
+            ProxyRAGService,
+        )
+
+        required_methods = [
+            "search",
+            "get_context_for_query",
+            "is_ready",
+            "get_index_status",
+            "trigger_reindex",
+        ]
+
+        for cls in [EmbeddedRAGService, ProxyRAGService]:
+            for method in required_methods:
+                assert hasattr(cls, method), f"{cls.__name__} missing {method}"
+                assert callable(getattr(cls, method))

hdsp_jupyter_extension-2.0.0.data/data/etc/jupyter/jupyter_server_config.d/hdsp_jupyter_extension.json

@@ -0,0 +1,7 @@
+{
+  "ServerApp": {
+    "jpserver_extensions": {
+      "jupyter_ext": true
+    }
+  }
+}