julee 0.1.0__py3-none-any.whl

julee/repositories/minio/tests/fake_client.py

@@ -0,0 +1,213 @@
+"""
+Fake Minio client for state-based testing.
+
+This module provides a FakeMinioClient that implements the same interface as
+the real Minio client but stores objects in memory for testing. This enables
+state-based testing where you can verify actual storage state rather than
+just mocking method calls.
+"""
+
+from typing import Dict, Any, Optional, Callable, BinaryIO, Union, List
+from functools import wraps
+from unittest.mock import Mock
+from datetime import datetime, timezone
+from minio.error import S3Error
+from minio.datatypes import Object
+from minio.api import ObjectWriteResult
+from urllib3.response import BaseHTTPResponse
+from urllib3 import HTTPHeaderDict
+
+from ..client import MinioClient
+
+
+def requires_bucket(func: Callable) -> Callable:
+    """Decorator to check if bucket exists before method execution."""
+
+    @wraps(func)
+    def wrapper(self: Any, bucket_name: str, *args: Any, **kwargs: Any) -> Any:
+        if bucket_name not in self._buckets:
+            raise S3Error(
+                code="NoSuchBucket",
+                message="Bucket does not exist",
+                resource=bucket_name,
+                request_id="req123",
+                host_id="host123",
+                response=Mock(),
+            )
+        return func(self, bucket_name, *args, **kwargs)
+
+    return wrapper
+
+
+def requires_object(func: Callable) -> Callable:
+    """Decorator to check if object exists before method execution."""
+
+    @wraps(func)
+    def wrapper(
+        self: Any,
+        bucket_name: str,
+        object_name: str,
+        *args: Any,
+        **kwargs: Any,
+    ) -> Any:
+        if bucket_name not in self._objects:
+            raise S3Error(
+                code="NoSuchBucket",
+                message="Bucket does not exist",
+                resource=bucket_name,
+                request_id="req123",
+                host_id="host123",
+                response=Mock(),
+            )
+        if object_name not in self._objects[bucket_name]:
+            raise S3Error(
+                code="NoSuchKey",
+                message="Object not found",
+                resource=object_name,
+                request_id="req123",
+                host_id="host123",
+                response=Mock(),
+            )
+        return func(self, bucket_name, object_name, *args, **kwargs)
+
+    return wrapper
+
+
+class FakeMinioClient(MinioClient):
+    """
+    Fake Minio client that stores objects in memory for testing.
+
+    This client implements the MinioClient protocol and stores all data in
+    memory, allowing for fast state-based testing without requiring a real
+    MinIO server.
+    """
+
+    def __init__(self) -> None:
+        self._buckets: Dict[str, Dict[str, Any]] = {}
+        self._objects: Dict[str, Dict[str, Dict[str, Any]]] = {}
+
+    def bucket_exists(self, bucket_name: str) -> bool:
+        """Check if a bucket exists."""
+        return bucket_name in self._buckets
+
+    def make_bucket(self, bucket_name: str) -> None:
+        """Create a bucket."""
+        if bucket_name in self._buckets:
+            raise S3Error(
+                code="BucketAlreadyExists",
+                message="Bucket already exists",
+                resource=bucket_name,
+                request_id="req123",
+                host_id="host123",
+                response=Mock(),
+            )
+        self._buckets[bucket_name] = {}
+        self._objects[bucket_name] = {}
+
+    @requires_bucket
+    def put_object(
+        self,
+        bucket_name: str,
+        object_name: str,
+        data: BinaryIO,
+        length: int,
+        content_type: str = "application/octet-stream",
+        metadata: Optional[Dict[str, Union[str, List[str], tuple[str]]]] = None,
+    ) -> ObjectWriteResult:
+        """Store an object in the bucket."""
+
+        # Read the data from stream
+        if hasattr(data, "read"):
+            if hasattr(data, "seek"):
+                data.seek(0)  # Ensure we're at the beginning
+            content = data.read()
+            if hasattr(data, "seek"):
+                data.seek(0)  # Reset for potential re-use
+        else:
+            content = data if isinstance(data, bytes) else str(data).encode("utf-8")
+
+        self._objects[bucket_name][object_name] = {
+            "data": content,
+            "metadata": metadata or {},
+            "content_type": content_type,
+            "size": len(content),
+        }
+
+        # Return a proper ObjectWriteResult
+        return ObjectWriteResult(
+            bucket_name=bucket_name,
+            object_name=object_name,
+            version_id=None,
+            etag="fake-etag",
+            http_headers=HTTPHeaderDict(),
+            last_modified=datetime.now(timezone.utc),
+            location=f"/{bucket_name}/{object_name}",
+        )
+
+    @requires_object
+    def get_object(self, bucket_name: str, object_name: str) -> BaseHTTPResponse:
+        """Retrieve an object from the bucket."""
+
+        obj_info = self._objects[bucket_name][object_name]
+        # Create a mock BaseHTTPResponse with the data
+        mock_response = Mock(spec=BaseHTTPResponse)
+        mock_response.read = Mock(return_value=obj_info["data"])
+        mock_response.close = Mock()
+        mock_response.release_conn = Mock()
+        return mock_response
+
+    @requires_object
+    def stat_object(self, bucket_name: str, object_name: str) -> Object:
+        """Get object metadata without retrieving the object data."""
+
+        obj_info = self._objects[bucket_name][object_name]
+        # Create a real Minio Object
+        return Object(
+            bucket_name=bucket_name,
+            object_name=object_name,
+            last_modified=datetime.now(timezone.utc),
+            etag="fake-etag",
+            size=obj_info["size"],
+            content_type=obj_info["content_type"],
+            metadata=obj_info["metadata"],
+        )
+
+    def list_objects(self, bucket_name: str, prefix: str = "") -> list:
+        """List objects in a bucket with optional prefix filter."""
+        if bucket_name not in self._objects:
+            return []
+
+        objects = []
+        for object_name, obj_info in self._objects[bucket_name].items():
+            if object_name.startswith(prefix):
+                # Create a simple object info structure
+                obj = Mock()
+                obj.object_name = object_name
+                obj.size = obj_info["size"]
+                objects.append(obj)
+
+        return objects
+
+    @requires_object
+    def remove_object(self, bucket_name: str, object_name: str) -> None:
+        """Remove an object from the bucket."""
+
+        del self._objects[bucket_name][object_name]
+
+    # Inspection methods for testing
+    def get_stored_objects(self, bucket_name: str) -> Dict[str, Dict[str, Any]]:
+        """Get all stored objects in a bucket (for testing purposes)."""
+        return self._objects.get(bucket_name, {}).copy()
+
+    def get_object_count(self, bucket_name: str) -> int:
+        """Get the number of objects in a bucket (for testing purposes)."""
+        return len(self._objects.get(bucket_name, {}))
+
+    def get_total_object_count(self) -> int:
+        """Get total number of objects across all buckets (for testing)."""
+        return sum(len(objects) for objects in self._objects.values())
+
+    def clear_all_data(self) -> None:
+        """Clear all buckets and objects (for testing purposes)."""
+        self._buckets.clear()
+        self._objects.clear()

julee/repositories/minio/tests/test_assembly.py

@@ -0,0 +1,374 @@
+"""
+Tests for MinioAssemblyRepository implementation.
+
+This module provides comprehensive tests for the Minio-based assembly
+repository implementation, using the fake client to avoid external
+dependencies during testing.
+"""
+
+import pytest
+from datetime import datetime, timezone
+
+from julee.domain.models.assembly import Assembly, AssemblyStatus
+from julee.repositories.minio.assembly import MinioAssemblyRepository
+from .fake_client import FakeMinioClient
+
+
+@pytest.fixture
+def fake_client() -> FakeMinioClient:
+    """Create a fresh fake Minio client for each test."""
+    return FakeMinioClient()
+
+
+@pytest.fixture
+def assembly_repo(fake_client: FakeMinioClient) -> MinioAssemblyRepository:
+    """Create assembly repository with fake client."""
+    return MinioAssemblyRepository(fake_client)
+
+
+@pytest.fixture
+def sample_assembly() -> Assembly:
+    """Create a sample assembly for testing."""
+    return Assembly(
+        assembly_id="test-assembly-123",
+        assembly_specification_id="spec-456",
+        input_document_id="input-doc-789",
+        workflow_id="test-workflow-123",
+        status=AssemblyStatus.PENDING,
+        assembled_document_id=None,
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc),
+    )
+
+
+class TestMinioAssemblyRepositoryBasicOperations:
+    """Test basic CRUD operations on assemblies."""
+
+    @pytest.mark.asyncio
+    async def test_save_and_get_assembly(
+        self,
+        assembly_repo: MinioAssemblyRepository,
+        sample_assembly: Assembly,
+    ) -> None:
+        """Test saving and retrieving an assembly."""
+        # Save assembly
+        await assembly_repo.save(sample_assembly)
+
+        # Retrieve assembly
+        retrieved = await assembly_repo.get(sample_assembly.assembly_id)
+
+        assert retrieved is not None
+        assert retrieved.assembly_id == sample_assembly.assembly_id
+        assert (
+            retrieved.assembly_specification_id
+            == sample_assembly.assembly_specification_id
+        )
+        assert retrieved.input_document_id == sample_assembly.input_document_id
+        assert retrieved.status == sample_assembly.status
+        assert retrieved.assembled_document_id is None
+
+    @pytest.mark.asyncio
+    async def test_get_nonexistent_assembly(
+        self, assembly_repo: MinioAssemblyRepository
+    ) -> None:
+        """Test retrieving a non-existent assembly returns None."""
+        result = await assembly_repo.get("nonexistent-assembly")
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_generate_id(self, assembly_repo: MinioAssemblyRepository) -> None:
+        """Test generating unique assembly IDs."""
+        id1 = await assembly_repo.generate_id()
+        id2 = await assembly_repo.generate_id()
+
+        assert isinstance(id1, str)
+        assert isinstance(id2, str)
+        assert id1 != id2
+        assert len(id1) > 0
+        assert len(id2) > 0
+
+
+class TestMinioAssemblyRepositoryDirectCompletion:
+    """Test assembly completion using direct field assignment."""
+
+    @pytest.mark.asyncio
+    async def test_complete_assembly_with_direct_assignment(
+        self,
+        assembly_repo: MinioAssemblyRepository,
+        sample_assembly: Assembly,
+    ) -> None:
+        """Test completing assembly using direct field assignment + save."""
+        # Save initial assembly
+        await assembly_repo.save(sample_assembly)
+
+        # Complete assembly using direct assignment (new approach)
+        sample_assembly.assembled_document_id = "output-doc-123"
+        sample_assembly.status = AssemblyStatus.COMPLETED
+        await assembly_repo.save(sample_assembly)
+
+        # Verify completion by retrieving again
+        retrieved = await assembly_repo.get(sample_assembly.assembly_id)
+        assert retrieved is not None
+        assert retrieved.assembled_document_id == "output-doc-123"
+        assert retrieved.status == AssemblyStatus.COMPLETED
+
+    @pytest.mark.asyncio
+    async def test_assembly_completion_idempotency(
+        self,
+        assembly_repo: MinioAssemblyRepository,
+        sample_assembly: Assembly,
+    ) -> None:
+        """Test that direct assignment approach maintains idempotency."""
+        # Save initial assembly
+        await assembly_repo.save(sample_assembly)
+
+        # Complete assembly first time
+        sample_assembly.assembled_document_id = "output-doc-456"
+        sample_assembly.status = AssemblyStatus.COMPLETED
+        await assembly_repo.save(sample_assembly)
+
+        first_updated_at = sample_assembly.updated_at
+
+        # "Complete" same assembly again with same values (idempotent)
+        sample_assembly.assembled_document_id = "output-doc-456"
+        sample_assembly.status = AssemblyStatus.COMPLETED
+        await assembly_repo.save(sample_assembly)
+
+        # Verify state and that updated_at changed (save updates timestamp)
+        retrieved = await assembly_repo.get(sample_assembly.assembly_id)
+        assert retrieved is not None
+        assert retrieved.assembled_document_id == "output-doc-456"
+        assert retrieved.status == AssemblyStatus.COMPLETED
+        assert retrieved.updated_at is not None
+        assert first_updated_at is not None
+        assert retrieved.updated_at > first_updated_at
+
+
+class TestMinioAssemblyRepositoryStatusUpdates:
+    """Test assembly status management."""
+
+    @pytest.mark.asyncio
+    async def test_update_assembly_status(
+        self,
+        assembly_repo: MinioAssemblyRepository,
+        sample_assembly: Assembly,
+    ) -> None:
+        """Test updating assembly status."""
+        # Save initial assembly
+        await assembly_repo.save(sample_assembly)
+
+        # Update status
+        sample_assembly.status = AssemblyStatus.IN_PROGRESS
+        await assembly_repo.save(sample_assembly)
+
+        # Verify update
+        retrieved = await assembly_repo.get(sample_assembly.assembly_id)
+        assert retrieved is not None
+        assert retrieved.status == AssemblyStatus.IN_PROGRESS
+
+        # Update to completed
+        sample_assembly.status = AssemblyStatus.COMPLETED
+        await assembly_repo.save(sample_assembly)
+
+        # Verify final state
+        retrieved = await assembly_repo.get(sample_assembly.assembly_id)
+        assert retrieved is not None
+        assert retrieved.status == AssemblyStatus.COMPLETED
+
+    @pytest.mark.asyncio
+    async def test_save_updates_timestamp(
+        self,
+        assembly_repo: MinioAssemblyRepository,
+        sample_assembly: Assembly,
+    ) -> None:
+        """Test that save operations update the updated_at timestamp."""
+        original_updated_at = sample_assembly.updated_at
+
+        # Save assembly
+        await assembly_repo.save(sample_assembly)
+
+        # Retrieve and check timestamp was updated
+        retrieved = await assembly_repo.get(sample_assembly.assembly_id)
+        assert retrieved is not None
+        assert retrieved.updated_at is not None
+        assert original_updated_at is not None
+        assert retrieved.updated_at > original_updated_at
+
+    @pytest.mark.asyncio
+    async def test_save_preserves_assembled_document_id(
+        self,
+        assembly_repo: MinioAssemblyRepository,
+        sample_assembly: Assembly,
+    ) -> None:
+        """Test that save operations preserve assembled_document_id."""
+        # Set assembled document first
+        sample_assembly.assembled_document_id = "test-doc-123"
+        sample_assembly.status = AssemblyStatus.COMPLETED
+        await assembly_repo.save(sample_assembly)
+
+        # Update other fields and save again
+        sample_assembly.status = AssemblyStatus.FAILED
+        await assembly_repo.save(sample_assembly)
+
+        # Verify assembled_document_id is preserved
+        retrieved = await assembly_repo.get(sample_assembly.assembly_id)
+        assert retrieved is not None
+        assert retrieved.assembled_document_id == "test-doc-123"
+        assert retrieved.status == AssemblyStatus.FAILED
+
+
+class TestMinioAssemblyRepositoryEdgeCases:
+    """Test edge cases and error conditions."""
+
+    @pytest.mark.asyncio
+    async def test_assembly_with_no_assembled_document(
+        self,
+        assembly_repo: MinioAssemblyRepository,
+        sample_assembly: Assembly,
+    ) -> None:
+        """Test handling assembly with no assembled document."""
+        await assembly_repo.save(sample_assembly)
+
+        retrieved = await assembly_repo.get(sample_assembly.assembly_id)
+        assert retrieved is not None
+        assert retrieved.assembled_document_id is None
+
+    @pytest.mark.asyncio
+    async def test_complex_workflow_scenario(
+        self,
+        assembly_repo: MinioAssemblyRepository,
+        sample_assembly: Assembly,
+    ) -> None:
+        """Test complex scenario with multiple operations."""
+        # Save initial assembly
+        await assembly_repo.save(sample_assembly)
+
+        # Start processing
+        sample_assembly.status = AssemblyStatus.IN_PROGRESS
+        await assembly_repo.save(sample_assembly)
+
+        # Set assembled document using direct assignment
+        sample_assembly.assembled_document_id = "final-output-doc"
+        sample_assembly.status = AssemblyStatus.COMPLETED
+        await assembly_repo.save(sample_assembly)
+
+        # Verify final state
+        updated_assembly = await assembly_repo.get(sample_assembly.assembly_id)
+        assert updated_assembly is not None
+
+        # Verify final state
+        assert updated_assembly.assembled_document_id == "final-output-doc"
+        assert updated_assembly.status == AssemblyStatus.COMPLETED
+
+        # Double-check by retrieving fresh
+        retrieved = await assembly_repo.get(sample_assembly.assembly_id)
+        assert retrieved is not None
+        assert retrieved.assembled_document_id == "final-output-doc"
+        assert retrieved.status == AssemblyStatus.COMPLETED
+
+    @pytest.mark.asyncio
+    async def test_assembly_failure_scenario(
+        self,
+        assembly_repo: MinioAssemblyRepository,
+        sample_assembly: Assembly,
+    ) -> None:
+        """Test assembly that fails during processing."""
+        # Save initial assembly
+        await assembly_repo.save(sample_assembly)
+
+        # Start processing
+        sample_assembly.status = AssemblyStatus.IN_PROGRESS
+        await assembly_repo.save(sample_assembly)
+
+        # Mark as failed (without setting assembled document)
+        sample_assembly.status = AssemblyStatus.FAILED
+        await assembly_repo.save(sample_assembly)
+
+        # Verify final state - no assembled document
+        retrieved = await assembly_repo.get(sample_assembly.assembly_id)
+        assert retrieved is not None
+        assert retrieved.assembled_document_id is None
+        assert retrieved.status == AssemblyStatus.FAILED
+
+
+class TestMinioAssemblyRepositoryRoundtrip:
+    """Test full round-trip scenarios."""
+
+    @pytest.mark.asyncio
+    async def test_full_assembly_lifecycle_success(
+        self, assembly_repo: MinioAssemblyRepository
+    ) -> None:
+        """Test complete successful assembly lifecycle from creation to
+        completion."""
+        # Generate new assembly
+        assembly_id = await assembly_repo.generate_id()
+
+        # Create and save initial assembly
+        assembly = Assembly(
+            assembly_id=assembly_id,
+            assembly_specification_id="spec-test",
+            input_document_id="input-test",
+            workflow_id="test-workflow-success",
+            status=AssemblyStatus.PENDING,
+            assembled_document_id=None,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        )
+        await assembly_repo.save(assembly)
+
+        # Start processing
+        assembly.status = AssemblyStatus.IN_PROGRESS
+        await assembly_repo.save(assembly)
+
+        # Complete assembly with output document
+        assembly.assembled_document_id = "final-output-document"
+        assembly.status = AssemblyStatus.COMPLETED
+        await assembly_repo.save(assembly)
+
+        final_assembly = await assembly_repo.get(assembly_id)
+        assert final_assembly is not None
+
+        # Final verification
+        assert final_assembly.status == AssemblyStatus.COMPLETED
+        assert final_assembly.assembled_document_id == "final-output-document"
+
+        # Verify persistence
+        retrieved = await assembly_repo.get(assembly_id)
+        assert retrieved is not None
+        assert retrieved.status == AssemblyStatus.COMPLETED
+        assert retrieved.assembled_document_id == "final-output-document"
+
+    @pytest.mark.asyncio
+    async def test_full_assembly_lifecycle_failure(
+        self, assembly_repo: MinioAssemblyRepository
+    ) -> None:
+        """Test complete failed assembly lifecycle."""
+        # Generate new assembly
+        assembly_id = await assembly_repo.generate_id()
+
+        # Create and save initial assembly
+        assembly = Assembly(
+            assembly_id=assembly_id,
+            assembly_specification_id="spec-test",
+            input_document_id="input-test",
+            workflow_id="test-workflow-failure",
+            status=AssemblyStatus.PENDING,
+            assembled_document_id=None,
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        )
+        await assembly_repo.save(assembly)
+
+        # Start processing
+        assembly.status = AssemblyStatus.IN_PROGRESS
+        await assembly_repo.save(assembly)
+
+        # Fail assembly (without setting output document)
+        assembly.status = AssemblyStatus.FAILED
+        await assembly_repo.save(assembly)
+
+        # Final verification
+        retrieved = await assembly_repo.get(assembly_id)
+        assert retrieved is not None
+        assert retrieved.status == AssemblyStatus.FAILED
+        assert retrieved.assembled_document_id is None