julee 0.1.0__py3-none-any.whl

julee/repositories/memory/tests/test_policy.py

@@ -0,0 +1,443 @@
+"""
+Tests for MemoryPolicyRepository implementation.
+
+This module provides comprehensive tests for the memory-based policy
+repository implementation, following the testing patterns established in the
+project.
+"""
+
+import pytest
+from datetime import datetime, timezone
+
+from julee.domain.models.policy import Policy, PolicyStatus
+from julee.repositories.memory.policy import MemoryPolicyRepository
+
+
+@pytest.fixture
+def policy_repo() -> MemoryPolicyRepository:
+    """Create a fresh policy repository for each test."""
+    return MemoryPolicyRepository()
+
+
+@pytest.fixture
+def sample_policy() -> Policy:
+    """Create a sample policy for testing."""
+    return Policy(
+        policy_id="policy-test-123",
+        title="Content Quality Policy",
+        description="Validates content meets quality standards",
+        status=PolicyStatus.ACTIVE,
+        validation_scores=[
+            ("quality-check-query", 80),
+            ("completeness-check", 90),
+        ],
+        transformation_queries=["improve-quality", "fix-grammar"],
+        version="1.0.0",
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc),
+    )
+
+
+@pytest.fixture
+def validation_only_policy() -> Policy:
+    """Create a validation-only policy (no transformations) for testing."""
+    return Policy(
+        policy_id="policy-validation-only",
+        title="Validation Only Policy",
+        description="Only validates content without transformations",
+        status=PolicyStatus.ACTIVE,
+        validation_scores=[
+            ("basic-validation", 70),
+        ],
+        transformation_queries=[],  # Empty list - validation only
+        version="1.0.0",
+        created_at=datetime.now(timezone.utc),
+        updated_at=datetime.now(timezone.utc),
+    )
+
+
+class TestMemoryPolicyRepositoryBasicOperations:
+    """Test basic CRUD operations on policies."""
+
+    @pytest.mark.asyncio
+    async def test_save_and_get_policy(
+        self,
+        policy_repo: MemoryPolicyRepository,
+        sample_policy: Policy,
+    ) -> None:
+        """Test saving and retrieving a policy."""
+        # Save policy
+        await policy_repo.save(sample_policy)
+
+        # Retrieve policy
+        retrieved = await policy_repo.get(sample_policy.policy_id)
+
+        assert retrieved is not None
+        assert retrieved.policy_id == sample_policy.policy_id
+        assert retrieved.title == sample_policy.title
+        assert retrieved.description == sample_policy.description
+        assert retrieved.status == sample_policy.status
+        assert retrieved.validation_scores == sample_policy.validation_scores
+        assert retrieved.transformation_queries == sample_policy.transformation_queries
+        assert retrieved.version == sample_policy.version
+
+    @pytest.mark.asyncio
+    async def test_get_nonexistent_policy(
+        self, policy_repo: MemoryPolicyRepository
+    ) -> None:
+        """Test retrieving a non-existent policy returns None."""
+        result = await policy_repo.get("nonexistent-policy")
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_generate_id(self, policy_repo: MemoryPolicyRepository) -> None:
+        """Test generating unique policy IDs."""
+        id1 = await policy_repo.generate_id()
+        id2 = await policy_repo.generate_id()
+
+        assert isinstance(id1, str)
+        assert isinstance(id2, str)
+        assert id1 != id2
+        assert len(id1) > 0
+        assert len(id2) > 0
+        assert id1.startswith("policy-")
+        assert id2.startswith("policy-")
+
+
+class TestMemoryPolicyRepositoryPolicyTypes:
+    """Test handling of different policy types."""
+
+    @pytest.mark.asyncio
+    async def test_validation_only_policy(
+        self,
+        policy_repo: MemoryPolicyRepository,
+        validation_only_policy: Policy,
+    ) -> None:
+        """Test storing and retrieving validation-only policy."""
+        # Save validation-only policy
+        await policy_repo.save(validation_only_policy)
+
+        # Retrieve and verify
+        retrieved = await policy_repo.get(validation_only_policy.policy_id)
+        assert retrieved is not None
+        assert retrieved.is_validation_only is True
+        assert retrieved.has_transformations is False
+        assert retrieved.transformation_queries == []
+
+    @pytest.mark.asyncio
+    async def test_transformation_policy(
+        self,
+        policy_repo: MemoryPolicyRepository,
+        sample_policy: Policy,
+    ) -> None:
+        """Test storing and retrieving policy with transformations."""
+        # Save transformation policy
+        await policy_repo.save(sample_policy)
+
+        # Retrieve and verify
+        retrieved = await policy_repo.get(sample_policy.policy_id)
+        assert retrieved is not None
+        assert retrieved.is_validation_only is False
+        assert retrieved.has_transformations is True
+        assert retrieved.transformation_queries is not None
+        assert len(retrieved.transformation_queries) == 2
+        assert "improve-quality" in retrieved.transformation_queries
+        assert "fix-grammar" in retrieved.transformation_queries
+
+    @pytest.mark.asyncio
+    async def test_policy_with_none_transformations(
+        self, policy_repo: MemoryPolicyRepository
+    ) -> None:
+        """Test policy with None transformation queries."""
+        policy = Policy(
+            policy_id="policy-none-transforms",
+            title="Policy with None Transformations",
+            description="Policy where transformation_queries is None",
+            validation_scores=[("test-query", 75)],
+            transformation_queries=None,  # Explicitly None
+        )
+
+        await policy_repo.save(policy)
+        retrieved = await policy_repo.get(policy.policy_id)
+
+        assert retrieved is not None
+        assert retrieved.transformation_queries is None
+        assert retrieved.is_validation_only is True
+        assert retrieved.has_transformations is False
+
+
+class TestMemoryPolicyRepositoryUpdates:
+    """Test policy update operations."""
+
+    @pytest.mark.asyncio
+    async def test_update_policy_status(
+        self,
+        policy_repo: MemoryPolicyRepository,
+        sample_policy: Policy,
+    ) -> None:
+        """Test updating policy status."""
+        # Save initial policy
+        await policy_repo.save(sample_policy)
+
+        # Update status
+        sample_policy.status = PolicyStatus.INACTIVE
+        await policy_repo.save(sample_policy)
+
+        # Verify update
+        retrieved = await policy_repo.get(sample_policy.policy_id)
+        assert retrieved is not None
+        assert retrieved.status == PolicyStatus.INACTIVE
+
+    @pytest.mark.asyncio
+    async def test_update_policy_validation_scores(
+        self,
+        policy_repo: MemoryPolicyRepository,
+        sample_policy: Policy,
+    ) -> None:
+        """Test updating policy validation scores."""
+        # Save initial policy
+        await policy_repo.save(sample_policy)
+
+        # Update validation scores
+        sample_policy.validation_scores = [
+            ("new-quality-check", 85),
+            ("advanced-validation", 95),
+        ]
+        await policy_repo.save(sample_policy)
+
+        # Verify update
+        retrieved = await policy_repo.get(sample_policy.policy_id)
+        assert retrieved is not None
+        assert len(retrieved.validation_scores) == 2
+        assert ("new-quality-check", 85) in retrieved.validation_scores
+        assert ("advanced-validation", 95) in retrieved.validation_scores
+
+    @pytest.mark.asyncio
+    async def test_update_transformation_queries(
+        self,
+        policy_repo: MemoryPolicyRepository,
+        sample_policy: Policy,
+    ) -> None:
+        """Test updating transformation queries."""
+        # Save initial policy
+        await policy_repo.save(sample_policy)
+
+        # Update transformation queries
+        sample_policy.transformation_queries = ["new-transform"]
+        await policy_repo.save(sample_policy)
+
+        # Verify update
+        retrieved = await policy_repo.get(sample_policy.policy_id)
+        assert retrieved is not None
+        assert retrieved.transformation_queries == ["new-transform"]
+        assert retrieved.has_transformations is True
+
+    @pytest.mark.asyncio
+    async def test_save_updates_timestamp(
+        self,
+        policy_repo: MemoryPolicyRepository,
+        sample_policy: Policy,
+    ) -> None:
+        """Test that save operations update the updated_at timestamp."""
+        original_updated_at = sample_policy.updated_at
+
+        # Save policy
+        await policy_repo.save(sample_policy)
+
+        # Retrieve and check timestamp was updated
+        retrieved = await policy_repo.get(sample_policy.policy_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
+
+
+class TestMemoryPolicyRepositoryEdgeCases:
+    """Test edge cases and complex scenarios."""
+
+    @pytest.mark.asyncio
+    async def test_policy_with_complex_validation_scores(
+        self, policy_repo: MemoryPolicyRepository
+    ) -> None:
+        """Test policy with many validation scores."""
+        policy = Policy(
+            policy_id="complex-policy",
+            title="Complex Validation Policy",
+            description="Policy with multiple validation criteria",
+            validation_scores=[
+                ("grammar-check", 80),
+                ("completeness-check", 85),
+                ("accuracy-check", 90),
+                ("style-check", 75),
+                ("readability-check", 70),
+            ],
+            transformation_queries=["improve-all-aspects"],
+        )
+
+        await policy_repo.save(policy)
+        retrieved = await policy_repo.get("complex-policy")
+
+        assert retrieved is not None
+        assert len(retrieved.validation_scores) == 5
+        assert retrieved.has_transformations is True
+        assert retrieved.transformation_queries is not None
+        assert len(retrieved.transformation_queries) == 1
+
+    @pytest.mark.asyncio
+    async def test_policy_lifecycle_management(
+        self, policy_repo: MemoryPolicyRepository
+    ) -> None:
+        """Test complete policy lifecycle from draft to deprecated."""
+        # Create draft policy
+        policy = Policy(
+            policy_id="lifecycle-policy",
+            title="Lifecycle Test Policy",
+            description="Testing policy lifecycle",
+            status=PolicyStatus.DRAFT,
+            validation_scores=[("test-check", 80)],
+            version="0.1.0",
+        )
+
+        # Save as draft
+        await policy_repo.save(policy)
+        retrieved = await policy_repo.get("lifecycle-policy")
+        assert retrieved is not None
+        assert retrieved.status == PolicyStatus.DRAFT
+
+        # Activate policy
+        policy.status = PolicyStatus.ACTIVE
+        policy.version = "1.0.0"
+        await policy_repo.save(policy)
+
+        retrieved = await policy_repo.get("lifecycle-policy")
+        assert retrieved is not None
+        assert retrieved.status == PolicyStatus.ACTIVE
+        assert retrieved.version == "1.0.0"
+
+        # Deprecate policy
+        policy.status = PolicyStatus.DEPRECATED
+        await policy_repo.save(policy)
+
+        retrieved = await policy_repo.get("lifecycle-policy")
+        assert retrieved is not None
+        assert retrieved.status == PolicyStatus.DEPRECATED
+
+    @pytest.mark.asyncio
+    async def test_multiple_policies_independence(
+        self, policy_repo: MemoryPolicyRepository
+    ) -> None:
+        """Test that multiple policies are stored independently."""
+        # Create multiple policies
+        policy1 = Policy(
+            policy_id="policy-1",
+            title="First Policy",
+            description="First test policy",
+            validation_scores=[("check-1", 80)],
+        )
+
+        policy2 = Policy(
+            policy_id="policy-2",
+            title="Second Policy",
+            description="Second test policy",
+            validation_scores=[("check-2", 90)],
+            transformation_queries=["transform-2"],
+        )
+
+        # Save both policies
+        await policy_repo.save(policy1)
+        await policy_repo.save(policy2)
+
+        # Retrieve both and verify independence
+        retrieved1 = await policy_repo.get("policy-1")
+        retrieved2 = await policy_repo.get("policy-2")
+
+        assert retrieved1 is not None
+        assert retrieved2 is not None
+        assert retrieved1.title == "First Policy"
+        assert retrieved2.title == "Second Policy"
+        assert retrieved1.is_validation_only is True
+        assert retrieved2.has_transformations is True
+
+        # Update one policy and verify the other is unchanged
+        policy1.title = "Updated First Policy"
+        await policy_repo.save(policy1)
+
+        retrieved1_updated = await policy_repo.get("policy-1")
+        retrieved2_unchanged = await policy_repo.get("policy-2")
+
+        assert retrieved1_updated is not None
+        assert retrieved2_unchanged is not None
+        assert retrieved1_updated.title == "Updated First Policy"
+        assert retrieved2_unchanged.title == "Second Policy"
+
+
+class TestMemoryPolicyRepositoryIdempotency:
+    """Test idempotent operations."""
+
+    @pytest.mark.asyncio
+    async def test_save_idempotency(
+        self,
+        policy_repo: MemoryPolicyRepository,
+        sample_policy: Policy,
+    ) -> None:
+        """Test that saving the same policy multiple times is idempotent."""
+        # Save policy first time
+        await policy_repo.save(sample_policy)
+
+        # Get the policy to check initial state
+        retrieved1 = await policy_repo.get(sample_policy.policy_id)
+        assert retrieved1 is not None
+        first_updated_at = retrieved1.updated_at
+
+        # Save same policy again (should update timestamp but maintain data)
+        await policy_repo.save(sample_policy)
+
+        # Verify policy is still there with updated timestamp
+        retrieved2 = await policy_repo.get(sample_policy.policy_id)
+        assert retrieved2 is not None
+        assert retrieved2.policy_id == sample_policy.policy_id
+        assert retrieved2.title == sample_policy.title
+        assert retrieved2.validation_scores == sample_policy.validation_scores
+        assert retrieved2.updated_at is not None
+        assert first_updated_at is not None
+        assert retrieved2.updated_at > first_updated_at
+
+
+class TestMemoryPolicyRepositoryRoundtrip:
+    """Test full round-trip scenarios."""
+
+    @pytest.mark.asyncio
+    async def test_full_policy_lifecycle_success(
+        self, policy_repo: MemoryPolicyRepository
+    ) -> None:
+        """Test complete successful policy lifecycle."""
+        # Generate new policy ID
+        policy_id = await policy_repo.generate_id()
+
+        # Create and save initial policy
+        policy = Policy(
+            policy_id=policy_id,
+            title="Round-trip Test Policy",
+            description="Testing complete policy round-trip",
+            status=PolicyStatus.DRAFT,
+            validation_scores=[("round-trip-check", 85)],
+            transformation_queries=["round-trip-transform"],
+            version="0.1.0",
+            created_at=datetime.now(timezone.utc),
+            updated_at=datetime.now(timezone.utc),
+        )
+        await policy_repo.save(policy)
+
+        # Activate policy
+        policy.status = PolicyStatus.ACTIVE
+        policy.version = "1.0.0"
+        await policy_repo.save(policy)
+
+        # Final verification
+        retrieved = await policy_repo.get(policy_id)
+        assert retrieved is not None
+        assert retrieved.status == PolicyStatus.ACTIVE
+        assert retrieved.version == "1.0.0"
+        assert retrieved.has_transformations is True
+        assert len(retrieved.validation_scores) == 1
+        assert retrieved.validation_scores[0] == ("round-trip-check", 85)

julee/repositories/minio/__init__.py

@@ -0,0 +1,31 @@
+"""
+Minio repository implementations for julee domain.
+
+This module exports Minio-based implementations of all repository protocols
+for the Capture, Extract, Assemble, Publish workflow. These implementations
+use Minio for object storage and are suitable for production environments
+where persistent, scalable storage is required.
+
+All implementations maintain the same async interfaces as their memory
+counterparts while providing durable, distributed storage capabilities.
+"""
+
+from .assembly import MinioAssemblyRepository
+from .assembly_specification import MinioAssemblySpecificationRepository
+from .document import MinioDocumentRepository
+from .document_policy_validation import (
+    MinioDocumentPolicyValidationRepository,
+)
+from .knowledge_service_config import MinioKnowledgeServiceConfigRepository
+from .knowledge_service_query import MinioKnowledgeServiceQueryRepository
+from .policy import MinioPolicyRepository
+
+__all__ = [
+    "MinioAssemblyRepository",
+    "MinioAssemblySpecificationRepository",
+    "MinioDocumentRepository",
+    "MinioDocumentPolicyValidationRepository",
+    "MinioKnowledgeServiceConfigRepository",
+    "MinioKnowledgeServiceQueryRepository",
+    "MinioPolicyRepository",
+]

julee/repositories/minio/assembly.py

@@ -0,0 +1,103 @@
+"""
+Minio implementation of AssemblyRepository.
+
+This module provides a Minio-based implementation of the AssemblyRepository
+protocol that follows the Clean Architecture patterns defined in the
+Fun-Police Framework. It handles assembly storage, ensuring idempotency and
+proper error handling.
+
+The implementation stores assembly data as JSON objects in Minio, following
+the large payload handling pattern from the architectural guidelines.
+"""
+
+import logging
+from typing import Optional, List, Dict
+
+from julee.domain.models.assembly import Assembly
+from julee.domain.repositories.assembly import AssemblyRepository
+from .client import MinioClient, MinioRepositoryMixin
+
+
+class MinioAssemblyRepository(AssemblyRepository, MinioRepositoryMixin):
+    """
+    Minio implementation of AssemblyRepository using Minio for persistence.
+
+    This implementation stores assembly data as JSON objects in the
+    "assemblies" bucket.
+    """
+
+    def __init__(self, client: MinioClient) -> None:
+        """Initialize repository with Minio client.
+
+        Args:
+            client: MinioClient protocol implementation (real or fake)
+        """
+        self.client = client
+        self.logger = logging.getLogger("MinioAssemblyRepository")
+        self.assembly_bucket = "assemblies"
+        self.ensure_buckets_exist([self.assembly_bucket])
+
+    async def get(self, assembly_id: str) -> Optional[Assembly]:
+        """Retrieve an assembly by ID."""
+        # Get the assembly using mixin methods
+        assembly = self.get_json_object(
+            bucket_name=self.assembly_bucket,
+            object_name=assembly_id,
+            model_class=Assembly,
+            not_found_log_message="Assembly not found",
+            error_log_message="Error retrieving assembly",
+            extra_log_data={"assembly_id": assembly_id},
+        )
+
+        return assembly
+
+    async def save(self, assembly: Assembly) -> None:
+        """Save assembly metadata (status, updated_at, etc.)."""
+        # Update timestamp
+        self.update_timestamps(assembly)
+
+        self.put_json_object(
+            bucket_name=self.assembly_bucket,
+            object_name=assembly.assembly_id,
+            model=assembly,
+            success_log_message="Assembly saved successfully",
+            error_log_message="Error saving assembly",
+            extra_log_data={
+                "assembly_id": assembly.assembly_id,
+                "status": assembly.status.value,
+                "assembled_document_id": assembly.assembled_document_id,
+            },
+        )
+
+    async def get_many(self, assembly_ids: List[str]) -> Dict[str, Optional[Assembly]]:
+        """Retrieve multiple assemblies by ID.
+
+        Args:
+            assembly_ids: List of unique assembly identifiers
+
+        Returns:
+            Dict mapping assembly_id to Assembly (or None if not found)
+        """
+        # Convert assembly IDs to object names (direct mapping in this case)
+        object_names = assembly_ids
+
+        # Get objects from Minio using batch method
+        object_results = self.get_many_json_objects(
+            bucket_name=self.assembly_bucket,
+            object_names=object_names,
+            model_class=Assembly,
+            not_found_log_message="Assembly not found",
+            error_log_message="Error retrieving assembly",
+            extra_log_data={"assembly_ids": assembly_ids},
+        )
+
+        # Convert object names back to assembly IDs for the result
+        result: Dict[str, Optional[Assembly]] = {}
+        for assembly_id in assembly_ids:
+            result[assembly_id] = object_results[assembly_id]
+
+        return result
+
+    async def generate_id(self) -> str:
+        """Generate a unique assembly identifier."""
+        return self.generate_id_with_prefix("assembly")