julee 0.1.0__py3-none-any.whl

julee/api/tests/test_app.py

@@ -0,0 +1,285 @@
+"""
+Tests for the julee FastAPI application.
+
+This module provides tests for the API endpoints, focusing on testing the
+HTTP layer behavior with proper dependency injection and mocking patterns.
+"""
+
+import pytest
+from typing import Generator
+from unittest.mock import patch
+from fastapi.testclient import TestClient
+
+from julee.api.app import app
+from julee.api.dependencies import (
+    get_knowledge_service_query_repository,
+    get_knowledge_service_config_repository,
+)
+from julee.domain.models import KnowledgeServiceQuery
+from julee.repositories.memory import (
+    MemoryKnowledgeServiceQueryRepository,
+)
+from julee.repositories.memory.knowledge_service_config import (
+    MemoryKnowledgeServiceConfigRepository,
+)
+from julee.api.responses import ServiceStatus
+
+
+@pytest.fixture
+def memory_repo() -> MemoryKnowledgeServiceQueryRepository:
+    """Create a memory knowledge service query repository for testing."""
+    return MemoryKnowledgeServiceQueryRepository()
+
+
+@pytest.fixture
+def memory_config_repo() -> MemoryKnowledgeServiceConfigRepository:
+    """Create a memory knowledge service config repository for testing."""
+    return MemoryKnowledgeServiceConfigRepository()
+
+
+@pytest.fixture
+def client(
+    memory_repo: MemoryKnowledgeServiceQueryRepository,
+    memory_config_repo: MemoryKnowledgeServiceConfigRepository,
+) -> Generator[TestClient, None, None]:
+    """Create a test client with memory repository."""
+    # Override the dependencies with our memory repositories
+    app.dependency_overrides[get_knowledge_service_query_repository] = (
+        lambda: memory_repo
+    )
+    app.dependency_overrides[get_knowledge_service_config_repository] = (
+        lambda: memory_config_repo
+    )
+
+    with (
+        patch("julee.api.routers.system.check_temporal_health") as mock_temporal,
+        patch("julee.api.routers.system.check_storage_health") as mock_storage,
+    ):
+        # Mock health checks to return UP status
+        mock_temporal.return_value = ServiceStatus.UP
+        mock_storage.return_value = ServiceStatus.UP
+
+        with TestClient(app) as test_client:
+            yield test_client
+
+    # Clean up the overrides after the test
+    app.dependency_overrides.clear()
+
+
+@pytest.fixture
+def sample_knowledge_service_query() -> KnowledgeServiceQuery:
+    """Create a sample knowledge service query for testing."""
+    return KnowledgeServiceQuery(
+        query_id="test-query-123",
+        name="Extract Meeting Summary",
+        knowledge_service_id="anthropic-claude",
+        prompt="Extract the main summary from this meeting transcript",
+        query_metadata={"model": "claude-3", "temperature": 0.2},
+        assistant_prompt="Please format as JSON",
+    )
+
+
+class TestHealthEndpoint:
+    """Test the health check endpoint."""
+
+    def test_health_check(self, client: TestClient) -> None:
+        """Test that health check returns expected response."""
+        response = client.get("/health")
+
+        assert response.status_code == 200
+        data = response.json()
+        assert data["status"] == "healthy"
+        assert "timestamp" in data
+        assert "services" in data
+        assert data["services"]["api"] == "up"
+        assert data["services"]["temporal"] == "up"
+        assert data["services"]["storage"] == "up"
+
+
+class TestKnowledgeServiceQueriesEndpoint:
+    """Test the knowledge service queries endpoint."""
+
+    def test_get_knowledge_service_queries_empty_list(
+        self,
+        client: TestClient,
+        memory_repo: MemoryKnowledgeServiceQueryRepository,
+    ) -> None:
+        """Test getting queries when repository is empty."""
+        # Memory repository starts empty
+        # Note: Current implementation returns empty list as placeholder,
+        # this test verifies the endpoint structure works
+
+        response = client.get("/knowledge_service_queries")
+
+        assert response.status_code == 200
+        data = response.json()
+
+        # Verify pagination structure
+        assert "items" in data
+        assert "total" in data
+        assert "page" in data
+        assert "size" in data
+        assert "pages" in data
+
+        # Should return empty list when repository is empty
+        assert data["items"] == []
+        assert data["total"] == 0
+
+    def test_get_knowledge_service_queries_with_pagination_params(
+        self,
+        client: TestClient,
+        memory_repo: MemoryKnowledgeServiceQueryRepository,
+    ) -> None:
+        """Test getting queries with pagination parameters."""
+        response = client.get("/knowledge_service_queries?page=2&size=10")
+
+        assert response.status_code == 200
+        data = response.json()
+
+        # Verify pagination parameters are handled
+        assert "items" in data
+        assert "page" in data
+        assert "size" in data
+
+        # Even with pagination params, should work with empty repository
+        assert data["items"] == []
+
+    def test_knowledge_service_queries_endpoint_error_handling(
+        self,
+        client: TestClient,
+        memory_repo: MemoryKnowledgeServiceQueryRepository,
+    ) -> None:
+        """Test error handling in the queries endpoint."""
+        response = client.get("/knowledge_service_queries")
+        assert response.status_code == 200
+
+        # Test passes if no exceptions are raised during repository calls
+
+    def test_openapi_schema_includes_knowledge_service_queries(
+        self, client: TestClient
+    ) -> None:
+        """Test that the OpenAPI schema includes our endpoint."""
+        response = client.get("/openapi.json")
+
+        assert response.status_code == 200
+        openapi_schema = response.json()
+
+        # Verify our endpoint is in the schema
+        paths = openapi_schema.get("paths", {})
+        assert "/knowledge_service_queries/" in paths
+
+        # Verify the endpoint has GET method
+        endpoint = paths["/knowledge_service_queries/"]
+        assert "get" in endpoint
+
+        # Verify response model is defined
+        get_info = endpoint["get"]
+        assert "responses" in get_info
+        assert "200" in get_info["responses"]
+
+    async def test_repository_can_store_and_retrieve_queries(
+        self,
+        memory_repo: MemoryKnowledgeServiceQueryRepository,
+        sample_knowledge_service_query: KnowledgeServiceQuery,
+    ) -> None:
+        """Test that the memory repository can store and retrieve queries.
+
+        This demonstrates how the endpoint will work once list_all() is added.
+        """
+        # Save a query to the repository
+        await memory_repo.save(sample_knowledge_service_query)
+
+        # Verify it can be retrieved
+        retrieved = await memory_repo.get(sample_knowledge_service_query.query_id)
+        assert retrieved == sample_knowledge_service_query
+
+        # This shows we can store and retrieve queries from the repository
+
+    async def test_get_knowledge_service_queries_with_data(
+        self,
+        client: TestClient,
+        memory_repo: MemoryKnowledgeServiceQueryRepository,
+        sample_knowledge_service_query: KnowledgeServiceQuery,
+    ) -> None:
+        """Test getting queries when repository contains data."""
+        # Create a second query for testing
+        query2 = KnowledgeServiceQuery(
+            query_id="test-query-456",
+            name="Extract Attendees",
+            knowledge_service_id="openai-service",
+            prompt="Extract all attendees from this meeting",
+            query_metadata={"model": "gpt-4", "temperature": 0.1},
+            assistant_prompt="Format as JSON array",
+        )
+
+        # Save queries to the repository
+        await memory_repo.save(sample_knowledge_service_query)
+        await memory_repo.save(query2)
+
+        response = client.get("/knowledge_service_queries")
+
+        assert response.status_code == 200
+        data = response.json()
+
+        # Verify pagination structure
+        assert "items" in data
+        assert "total" in data
+        assert "page" in data
+        assert "size" in data
+
+        # Should return both queries
+        assert data["total"] == 2
+        assert len(data["items"]) == 2
+
+        # Verify the queries are returned (order may vary)
+        returned_ids = {item["query_id"] for item in data["items"]}
+        expected_ids = {
+            sample_knowledge_service_query.query_id,
+            query2.query_id,
+        }
+        assert returned_ids == expected_ids
+
+        # Verify query data structure
+        for item in data["items"]:
+            assert "query_id" in item
+            assert "name" in item
+            assert "knowledge_service_id" in item
+            assert "prompt" in item
+
+    async def test_get_knowledge_service_queries_pagination(
+        self,
+        client: TestClient,
+        memory_repo: MemoryKnowledgeServiceQueryRepository,
+    ) -> None:
+        """Test pagination with multiple queries."""
+        # Create several queries
+        queries = []
+        for i in range(5):
+            query = KnowledgeServiceQuery(
+                query_id=f"query-{i:03d}",
+                name=f"Query {i}",
+                knowledge_service_id="test-service",
+                prompt=f"Test prompt {i}",
+            )
+            queries.append(query)
+            await memory_repo.save(query)
+
+        # Test first page with size 2
+        response = client.get("/knowledge_service_queries?page=1&size=2")
+        assert response.status_code == 200
+        data = response.json()
+
+        assert data["total"] == 5
+        assert data["page"] == 1
+        assert data["size"] == 2
+        assert len(data["items"]) == 2
+
+        # Test second page
+        response = client.get("/knowledge_service_queries?page=2&size=2")
+        assert response.status_code == 200
+        data = response.json()
+
+        assert data["total"] == 5
+        assert data["page"] == 2
+        assert data["size"] == 2
+        assert len(data["items"]) == 2

julee/api/tests/test_dependencies.py

@@ -0,0 +1,245 @@
+"""
+Tests for dependency injection components.
+
+This module tests the dependency injection utilities, particularly the
+StartupDependenciesProvider that provides clean access to dependencies
+during application startup without exposing internal container details.
+"""
+
+import pytest
+from unittest.mock import AsyncMock, MagicMock
+
+from julee.api.dependencies import (
+    StartupDependenciesProvider,
+    DependencyContainer,
+    get_startup_dependencies,
+)
+
+
+@pytest.fixture
+def mock_container() -> AsyncMock:
+    """Create mock dependency container."""
+    return AsyncMock(spec=DependencyContainer)
+
+
+@pytest.fixture
+def mock_minio_client() -> MagicMock:
+    """Create mock Minio client."""
+    return MagicMock()
+
+
+@pytest.fixture
+def startup_provider(
+    mock_container: AsyncMock,
+) -> StartupDependenciesProvider:
+    """Create startup dependencies provider with mock container."""
+    return StartupDependenciesProvider(mock_container)
+
+
+class TestStartupDependenciesProvider:
+    """Test the StartupDependenciesProvider."""
+
+    def test_initialization(self, mock_container: AsyncMock) -> None:
+        """Test provider initialization."""
+        provider = StartupDependenciesProvider(mock_container)
+
+        assert provider.container == mock_container
+        assert provider.logger is not None
+
+    @pytest.mark.asyncio
+    async def test_get_knowledge_service_config_repository(
+        self,
+        startup_provider: StartupDependenciesProvider,
+        mock_container: AsyncMock,
+        mock_minio_client: MagicMock,
+    ) -> None:
+        """Test getting knowledge service config repository."""
+        # Setup mock
+        mock_container.get_minio_client.return_value = mock_minio_client
+
+        # Get repository
+        repo = await startup_provider.get_knowledge_service_config_repository()
+
+        # Verify container was called
+        mock_container.get_minio_client.assert_called_once()
+
+        # Verify repository was created with correct client
+        assert repo is not None
+        # Note: We can't easily test the internal client without exposing
+        # implementation details, but we can verify the method completed
+
+    @pytest.mark.asyncio
+    async def test_get_system_initialization_service(
+        self,
+        startup_provider: StartupDependenciesProvider,
+        mock_container: AsyncMock,
+        mock_minio_client: MagicMock,
+    ) -> None:
+        """Test getting system initialization service."""
+        # Setup mock
+        mock_container.get_minio_client.return_value = mock_minio_client
+
+        # Get service
+        service = await startup_provider.get_system_initialization_service()
+
+        # Verify service was created
+        assert service is not None
+        assert hasattr(service, "initialize")
+
+        # Verify container was called to create dependencies
+        # The service may need multiple minio clients for different repos
+        assert mock_container.get_minio_client.call_count >= 1
+
+    @pytest.mark.asyncio
+    async def test_get_system_initialization_service_creates_full_chain(
+        self,
+        startup_provider: StartupDependenciesProvider,
+        mock_container: AsyncMock,
+        mock_minio_client: MagicMock,
+    ) -> None:
+        """Test that service creation builds the complete dependency chain."""
+        # Setup mock
+        mock_container.get_minio_client.return_value = mock_minio_client
+
+        # Get service
+        service = await startup_provider.get_system_initialization_service()
+
+        # Verify the service has the expected structure
+        assert service is not None
+        assert hasattr(service, "initialize_system_data_use_case")
+        assert service.initialize_system_data_use_case is not None
+
+        # Verify the use case has the repositories
+        use_case = service.initialize_system_data_use_case
+        assert hasattr(use_case, "config_repo")
+        assert use_case.config_repo is not None
+        assert hasattr(use_case, "document_repo")
+        assert use_case.document_repo is not None
+        assert hasattr(use_case, "query_repo")
+        assert use_case.query_repo is not None
+        assert hasattr(use_case, "assembly_spec_repo")
+        assert use_case.assembly_spec_repo is not None
+
+    @pytest.mark.asyncio
+    async def test_container_error_propagation(
+        self,
+        startup_provider: StartupDependenciesProvider,
+        mock_container: AsyncMock,
+    ) -> None:
+        """Test that container errors are properly propagated."""
+        # Setup mock to raise error
+        mock_container.get_minio_client.side_effect = Exception("Container error")
+
+        # Verify error is propagated
+        with pytest.raises(Exception, match="Container error"):
+            await startup_provider.get_knowledge_service_config_repository()
+
+
+class TestStartupDependenciesIntegration:
+    """Integration tests for startup dependencies."""
+
+    @pytest.mark.asyncio
+    async def test_get_startup_dependencies_function(self) -> None:
+        """Test the get_startup_dependencies function."""
+        provider = await get_startup_dependencies()
+
+        assert provider is not None
+        assert isinstance(provider, StartupDependenciesProvider)
+        assert provider.container is not None
+
+    @pytest.mark.asyncio
+    async def test_startup_dependencies_singleton_behavior(self) -> None:
+        """Test that startup dependencies provider behaves as singleton."""
+        provider1 = await get_startup_dependencies()
+        provider2 = await get_startup_dependencies()
+
+        # Should be the same instance
+        assert provider1 is provider2
+        assert provider1.container is provider2.container
+
+    @pytest.mark.asyncio
+    async def test_end_to_end_dependency_creation(self) -> None:
+        """Test complete end-to-end dependency creation flow."""
+        # This test verifies the complete flow works without mocking
+        # the internal dependencies (integration test style)
+
+        provider = await get_startup_dependencies()
+
+        # This should work without throwing errors
+        # (though it might fail if Minio isn't available, which is expected)
+        try:
+            service = await provider.get_system_initialization_service()
+            assert service is not None
+
+            # Verify the service has the expected methods
+            assert hasattr(service, "initialize")
+            assert hasattr(service, "get_initialization_status")
+            assert hasattr(service, "reinitialize")
+
+        except Exception as e:
+            # In test environments, Minio might not be available
+            # We just verify that the dependency chain is correctly structured
+            # and any errors are related to infrastructure, not our code
+            assert "minio" in str(e).lower() or "connection" in str(e).lower()
+
+
+class TestStartupDependenciesProviderEdgeCases:
+    """Test edge cases and error conditions."""
+
+    @pytest.mark.asyncio
+    async def test_multiple_repository_requests(
+        self,
+        startup_provider: StartupDependenciesProvider,
+        mock_container: AsyncMock,
+        mock_minio_client: MagicMock,
+    ) -> None:
+        """Test multiple requests for the same repository type."""
+        # Setup mock
+        mock_container.get_minio_client.return_value = mock_minio_client
+
+        # Get repository multiple times
+        repo1 = await startup_provider.get_knowledge_service_config_repository()
+        repo2 = await startup_provider.get_knowledge_service_config_repository()
+
+        # Each call should create a new repository instance
+        assert repo1 is not None
+        assert repo2 is not None
+        # They should be different instances (no caching at provider level)
+        assert repo1 is not repo2
+
+        # But container should be called each time (container handles caching)
+        assert mock_container.get_minio_client.call_count == 2
+
+    @pytest.mark.asyncio
+    async def test_service_creation_isolation(
+        self,
+        startup_provider: StartupDependenciesProvider,
+        mock_container: AsyncMock,
+        mock_minio_client: MagicMock,
+    ) -> None:
+        """Test that service creation doesn't interfere with operations."""
+        # Setup mock
+        mock_container.get_minio_client.return_value = mock_minio_client
+
+        # Get repository first
+        repo = await startup_provider.get_knowledge_service_config_repository()
+
+        # Then get service
+        service = await startup_provider.get_system_initialization_service()
+
+        # Both should be valid
+        assert repo is not None
+        assert service is not None
+
+        # Container should have been called multiple times:
+        # 1 for direct repo call + 4 for service (config + document + query +
+        # assembly spec repos)
+        assert mock_container.get_minio_client.call_count == 5
+
+    def test_provider_with_none_container(self) -> None:
+        """Test provider behavior with None container."""
+        # This should not happen in practice, but test defensive behavior
+        with pytest.raises(AttributeError):
+            provider = StartupDependenciesProvider(None)  # type: ignore
+            # Any operation should fail gracefully
+            provider.container.get_minio_client()  # type: ignore