julee 0.1.0__py3-none-any.whl

julee/api/tests/routers/test_system.py

@@ -0,0 +1,179 @@
+"""
+Tests for the system API router.
+
+This module provides tests for system-level endpoints including health checks
+and other operational endpoints.
+"""
+
+import pytest
+import time
+from datetime import datetime
+from typing import Generator
+from unittest.mock import patch
+from fastapi.testclient import TestClient
+from fastapi import FastAPI
+
+from julee.api.routers.system import router
+from julee.api.responses import ServiceStatus
+
+
+@pytest.fixture
+def app_with_router() -> FastAPI:
+    """Create a FastAPI app with just the system router."""
+    app = FastAPI()
+
+    # Include the router (system routes are typically at root level)
+    app.include_router(router, tags=["System"])
+
+    return app
+
+
+@pytest.fixture
+def client(
+    app_with_router: FastAPI,
+) -> Generator[TestClient, None, None]:
+    """Create a test client with the system router app."""
+    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_with_router) as test_client:
+            yield test_client
+
+
+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"] in ["healthy", "degraded", "unhealthy"]
+        assert "timestamp" in data
+        assert "services" in data
+
+    def test_health_check_response_structure(self, client: TestClient) -> None:
+        """Test that health check response has correct structure."""
+        response = client.get("/health")
+
+        assert response.status_code == 200
+        data = response.json()
+
+        # Verify all required fields are present
+        required_fields = ["status", "timestamp", "services"]
+        for field in required_fields:
+            assert field in data, f"Missing required field: {field}"
+
+        # Verify field types
+        assert isinstance(data["status"], str)
+        assert isinstance(data["timestamp"], str)
+        assert isinstance(data["services"], dict)
+
+        # Verify status value
+        assert data["status"] in ["healthy", "degraded", "unhealthy"]
+
+        # Verify services structure
+        services = data["services"]
+        required_services = ["api", "temporal", "storage"]
+        for service in required_services:
+            assert service in services, f"Missing service: {service}"
+            assert services[service] in [
+                "up",
+                "down",
+            ], f"Invalid status for {service}: {services[service]}"
+
+    def test_health_check_timestamp_format(self, client: TestClient) -> None:
+        """Test that health check timestamp is in ISO format."""
+
+        response = client.get("/health")
+        assert response.status_code == 200
+
+        data = response.json()
+        timestamp_str = data["timestamp"]
+
+        # Should be able to parse as ISO format datetime
+        try:
+            parsed_timestamp = datetime.fromisoformat(
+                timestamp_str.replace("Z", "+00:00")
+            )
+            assert parsed_timestamp is not None
+        except ValueError:
+            pytest.fail(f"Timestamp '{timestamp_str}' is not in valid ISO format")
+
+    def test_health_check_services_status(self, client: TestClient) -> None:
+        """Test that health check includes all service statuses."""
+        response = client.get("/health")
+        assert response.status_code == 200
+
+        data = response.json()
+        services = data["services"]
+
+        # API should always be up since we're responding
+        assert services["api"] == "up"
+
+        # Temporal and storage may be up or down depending on environment
+        assert services["temporal"] in ["up", "down"]
+        assert services["storage"] in ["up", "down"]
+
+    def test_health_check_overall_status_logic(self, client: TestClient) -> None:
+        """Test that overall status reflects service health correctly."""
+        response = client.get("/health")
+        assert response.status_code == 200
+
+        data = response.json()
+        overall_status = data["status"]
+        services = data["services"]
+
+        # Count up services
+        up_services = sum(1 for status in services.values() if status == "up")
+        total_services = len(services)
+
+        # Validate logic
+        if up_services == total_services:
+            assert overall_status == "healthy"
+        elif up_services > 0:
+            assert overall_status == "degraded"
+        else:
+            assert overall_status == "unhealthy"
+
+    def test_health_check_multiple_calls_consistent(self, client: TestClient) -> None:
+        """Test multiple health check calls return consistent structure."""
+        # Make multiple calls
+        responses = [client.get("/health") for _ in range(3)]
+
+        # All should be successful
+        for response in responses:
+            assert response.status_code == 200
+
+        # All should have the same structure
+        data_list = [response.json() for response in responses]
+
+        for data in data_list:
+            assert data["status"] in ["healthy", "degraded", "unhealthy"]
+            assert "timestamp" in data
+            assert "services" in data
+
+            # Services structure should be consistent
+            services = data["services"]
+            required_services = ["api", "temporal", "storage"]
+            for service in required_services:
+                assert service in services
+                assert services[service] in ["up", "down"]
+
+    def test_health_check_response_time(self, client: TestClient) -> None:
+        """Test that health check responds quickly."""
+
+        start_time = time.time()
+        response = client.get("/health")
+        end_time = time.time()
+
+        assert response.status_code == 200
+        # Health check should complete within 10 seconds even with external
+        # service checks
+        assert end_time - start_time < 10.0

julee/api/tests/routers/test_workflows.py

@@ -0,0 +1,393 @@
+"""
+Tests for workflows API router.
+
+This module provides unit tests for the workflows API endpoints,
+focusing on workflow triggering, status monitoring, and error handling.
+"""
+
+import pytest
+from typing import Generator
+from unittest.mock import AsyncMock, MagicMock
+from fastapi.testclient import TestClient
+from fastapi import FastAPI
+from fastapi_pagination import add_pagination
+
+from julee.api.routers.workflows import router
+from julee.api.dependencies import get_temporal_client
+
+
+@pytest.fixture
+def mock_temporal_client() -> MagicMock:
+    """Create mock Temporal client."""
+    mock_client = MagicMock()
+    mock_client.start_workflow = AsyncMock()
+    mock_client.get_workflow_handle = MagicMock()  # Synchronous method
+    return mock_client
+
+
+@pytest.fixture
+def app_with_router(mock_temporal_client: MagicMock) -> FastAPI:
+    """Create a FastAPI app with just the workflows router."""
+    app = FastAPI()
+
+    # Override the dependency with our mock temporal client
+    app.dependency_overrides[get_temporal_client] = lambda: mock_temporal_client
+
+    # Add pagination support (required for potential future endpoints)
+    add_pagination(app)
+
+    app.include_router(router, prefix="/workflows", tags=["Workflows"])
+
+    return app
+
+
+@pytest.fixture
+def client(
+    app_with_router: FastAPI,
+) -> Generator[TestClient, None, None]:
+    """Create a test client with the workflows router app."""
+    with TestClient(app_with_router) as test_client:
+        yield test_client
+
+
+class TestStartExtractAssembleWorkflow:
+    """Test cases for the start extract-assemble workflow endpoint."""
+
+    def test_start_workflow_success_with_auto_generated_id(
+        self,
+        client: TestClient,
+        mock_temporal_client: MagicMock,
+    ) -> None:
+        """Test successful workflow start with auto-generated workflow ID."""
+        # Setup mock
+        mock_handle = MagicMock()
+        mock_handle.run_id = "test-run-id-123"
+        mock_temporal_client.start_workflow.return_value = mock_handle
+
+        # Make request
+        request_data = {
+            "document_id": "doc-123",
+            "assembly_specification_id": "spec-456",
+        }
+        response = client.post("/workflows/extract-assemble", json=request_data)
+
+        # Assertions
+        assert response.status_code == 200
+        data = response.json()
+
+        assert data["run_id"] == "test-run-id-123"
+        assert data["status"] == "RUNNING"
+        assert data["message"] == "Workflow started successfully"
+        assert "extract-assemble-doc-123-spec-456" in data["workflow_id"]
+
+        # Verify temporal client was called correctly
+        mock_temporal_client.start_workflow.assert_called_once()
+        call_args = mock_temporal_client.start_workflow.call_args
+
+        # Check positional arguments
+        assert call_args[1]["args"] == ["doc-123", "spec-456"]
+        assert call_args[1]["task_queue"] == "julee-extract-assemble-queue"
+        assert "extract-assemble-doc-123-spec-456" in call_args[1]["id"]
+
+    def test_start_workflow_success_with_custom_id(
+        self,
+        client: TestClient,
+        mock_temporal_client: MagicMock,
+    ) -> None:
+        """Test successful workflow start with custom workflow ID."""
+        # Setup mock
+        mock_handle = MagicMock()
+        mock_handle.run_id = "custom-run-id"
+        mock_temporal_client.start_workflow.return_value = mock_handle
+
+        # Make request
+        request_data = {
+            "document_id": "doc-789",
+            "assembly_specification_id": "spec-101",
+            "workflow_id": "my-custom-workflow-id",
+        }
+        response = client.post("/workflows/extract-assemble", json=request_data)
+
+        # Assertions
+        assert response.status_code == 200
+        data = response.json()
+
+        assert data["workflow_id"] == "my-custom-workflow-id"
+        assert data["run_id"] == "custom-run-id"
+        assert data["status"] == "RUNNING"
+
+        # Verify temporal client was called with custom ID
+        mock_temporal_client.start_workflow.assert_called_once()
+        call_args = mock_temporal_client.start_workflow.call_args
+        assert call_args[1]["id"] == "my-custom-workflow-id"
+
+    def test_start_workflow_missing_document_id(self, client: TestClient) -> None:
+        """Test workflow start with missing document_id."""
+        request_data = {
+            "assembly_specification_id": "spec-456",
+        }
+        response = client.post("/workflows/extract-assemble", json=request_data)
+
+        assert response.status_code == 422  # Validation error
+        data = response.json()
+        assert "document_id" in str(data["detail"])
+
+    def test_start_workflow_missing_assembly_specification_id(
+        self, client: TestClient
+    ) -> None:
+        """Test workflow start with missing assembly_specification_id."""
+        request_data = {
+            "document_id": "doc-123",
+        }
+        response = client.post("/workflows/extract-assemble", json=request_data)
+
+        assert response.status_code == 422  # Validation error
+        data = response.json()
+        assert "assembly_specification_id" in str(data["detail"])
+
+    def test_start_workflow_empty_string_ids(
+        self,
+        client: TestClient,
+        mock_temporal_client: MagicMock,
+    ) -> None:
+        """Test workflow start with empty string IDs."""
+        # Setup mock (though it shouldn't be called due to validation)
+        mock_handle = MagicMock()
+        mock_handle.run_id = "should-not-be-called"
+        mock_temporal_client.start_workflow.return_value = mock_handle
+
+        request_data = {
+            "document_id": "",
+            "assembly_specification_id": "",
+        }
+        response = client.post("/workflows/extract-assemble", json=request_data)
+
+        assert response.status_code == 422  # Validation error
+
+    def test_start_workflow_temporal_client_error(
+        self,
+        client: TestClient,
+        mock_temporal_client: MagicMock,
+    ) -> None:
+        """Test workflow start when Temporal client raises exception."""
+        # Setup mock to raise exception
+        mock_temporal_client.start_workflow.side_effect = Exception(
+            "Temporal connection failed"
+        )
+
+        # Make request
+        request_data = {
+            "document_id": "doc-123",
+            "assembly_specification_id": "spec-456",
+        }
+        response = client.post("/workflows/extract-assemble", json=request_data)
+
+        # Assertions
+        assert response.status_code == 500
+        data = response.json()
+        assert "Failed to start workflow" in data["detail"]
+
+
+class TestGetWorkflowStatus:
+    """Test cases for the get workflow status endpoint."""
+
+    def test_get_workflow_status_success(
+        self,
+        client: TestClient,
+        mock_temporal_client: MagicMock,
+    ) -> None:
+        """Test successful workflow status retrieval."""
+        # Setup mocks
+        mock_handle = MagicMock()
+        mock_description = MagicMock()
+        mock_description.run_id = "test-run-123"
+        mock_description.status.name = "RUNNING"
+
+        mock_handle.describe = AsyncMock(return_value=mock_description)
+        mock_handle.query = AsyncMock(
+            side_effect=[
+                "extracting_data",  # current_step
+                "assembly-789",  # assembly_id
+            ]
+        )
+
+        mock_temporal_client.get_workflow_handle.return_value = mock_handle
+
+        # Make request
+        response = client.get("/workflows/test-workflow-id/status")
+
+        # Assertions
+        assert response.status_code == 200
+        data = response.json()
+
+        assert data["workflow_id"] == "test-workflow-id"
+        assert data["run_id"] == "test-run-123"
+        assert data["status"] == "RUNNING"
+        assert data["current_step"] == "extracting_data"
+        assert data["assembly_id"] == "assembly-789"
+
+        # Verify temporal client calls
+        mock_temporal_client.get_workflow_handle.assert_called_once_with(
+            "test-workflow-id"
+        )
+        mock_handle.describe.assert_called_once()
+        assert mock_handle.query.call_count == 2
+
+    def test_get_workflow_status_completed(
+        self,
+        client: TestClient,
+        mock_temporal_client: MagicMock,
+    ) -> None:
+        """Test workflow status for completed workflow."""
+        # Setup mocks
+        mock_handle = MagicMock()
+        mock_description = MagicMock()
+        mock_description.run_id = "completed-run-456"
+        mock_description.status.name = "COMPLETED"
+
+        mock_handle.describe = AsyncMock(return_value=mock_description)
+        mock_handle.query = AsyncMock(
+            side_effect=[
+                "completed",  # current_step
+                "final-assembly",  # assembly_id
+            ]
+        )
+
+        mock_temporal_client.get_workflow_handle.return_value = mock_handle
+
+        # Make request
+        response = client.get("/workflows/completed-workflow/status")
+
+        # Assertions
+        assert response.status_code == 200
+        data = response.json()
+
+        assert data["workflow_id"] == "completed-workflow"
+        assert data["status"] == "COMPLETED"
+        assert data["current_step"] == "completed"
+        assert data["assembly_id"] == "final-assembly"
+
+    def test_get_workflow_status_query_failure(
+        self,
+        client: TestClient,
+        mock_temporal_client: MagicMock,
+    ) -> None:
+        """Test workflow status when queries fail (returns basic status)."""
+        # Setup mocks
+        mock_handle = MagicMock()
+        mock_description = MagicMock()
+        mock_description.run_id = "no-query-run"
+        mock_description.status.name = "RUNNING"
+
+        mock_handle.describe = AsyncMock(return_value=mock_description)
+        mock_handle.query = AsyncMock(side_effect=Exception("Query not supported"))
+
+        mock_temporal_client.get_workflow_handle.return_value = mock_handle
+
+        # Make request
+        response = client.get("/workflows/no-query-workflow/status")
+
+        # Assertions
+        assert response.status_code == 200
+        data = response.json()
+
+        assert data["workflow_id"] == "no-query-workflow"
+        assert data["status"] == "RUNNING"
+        assert data["current_step"] is None  # Query failed gracefully
+        assert data["assembly_id"] is None  # Query failed gracefully
+
+    def test_get_workflow_status_not_found(
+        self,
+        client: TestClient,
+        mock_temporal_client: MagicMock,
+    ) -> None:
+        """Test workflow status for non-existent workflow."""
+        # Setup mock to raise a generic Exception (workflow not found)
+        mock_temporal_client.get_workflow_handle.side_effect = Exception(
+            "Workflow not found"
+        )
+
+        # Make request
+        response = client.get("/workflows/non-existent-workflow/status")
+
+        # Assertions
+        assert response.status_code == 404
+        data = response.json()
+        assert "not found" in data["detail"].lower()
+
+    def test_get_workflow_status_temporal_error(
+        self,
+        client: TestClient,
+        mock_temporal_client: MagicMock,
+    ) -> None:
+        """Test workflow status when Temporal client raises exception."""
+        # Setup mock to raise exception
+        mock_temporal_client.get_workflow_handle.side_effect = Exception(
+            "Temporal service unavailable"
+        )
+
+        # Make request
+        response = client.get("/workflows/error-workflow/status")
+
+        # Assertions
+        assert response.status_code == 500
+        data = response.json()
+        assert "Failed to retrieve workflow handle" in data["detail"]
+
+    def test_get_workflow_status_describe_error(
+        self,
+        client: TestClient,
+        mock_temporal_client: MagicMock,
+    ) -> None:
+        """Test workflow status when describe fails."""
+        # Setup mocks
+        mock_handle = MagicMock()
+        mock_handle.describe = AsyncMock(side_effect=Exception("Describe failed"))
+        mock_temporal_client.get_workflow_handle.return_value = mock_handle
+
+        # Make request
+        response = client.get("/workflows/describe-error-workflow/status")
+
+        # Assertions
+        assert response.status_code == 500
+        data = response.json()
+        assert "Failed to retrieve workflow description" in data["detail"]
+
+
+class TestWorkflowValidation:
+    """Test cases for workflow request validation."""
+
+    def test_start_workflow_invalid_json(self, client: TestClient) -> None:
+        """Test workflow start with invalid JSON."""
+        response = client.post(
+            "/workflows/extract-assemble",
+            content="invalid json",
+            headers={"Content-Type": "application/json"},
+        )
+
+        assert response.status_code == 422
+
+    def test_start_workflow_extra_fields_ignored(
+        self,
+        client: TestClient,
+        mock_temporal_client: MagicMock,
+    ) -> None:
+        """Test that extra fields in request are ignored."""
+        # Setup mock
+        mock_handle = MagicMock()
+        mock_handle.run_id = "extra-fields-run"
+        mock_temporal_client.start_workflow.return_value = mock_handle
+
+        # Make request with extra fields
+        request_data = {
+            "document_id": "doc-123",
+            "assembly_specification_id": "spec-456",
+            "extra_field": "should_be_ignored",
+            "another_extra": 42,
+        }
+        response = client.post("/workflows/extract-assemble", json=request_data)
+
+        # Should succeed and ignore extra fields
+        assert response.status_code == 200
+        data = response.json()
+        assert data["status"] == "RUNNING"