julee 0.1.0__py3-none-any.whl

julee/repositories/memory/knowledge_service_query.py

@@ -0,0 +1,120 @@
+"""
+Memory implementation of KnowledgeServiceQueryRepository.
+
+This module provides an in-memory implementation of the
+KnowledgeServiceQueryRepository protocol that follows the Clean Architecture
+patterns defined in the Fun-Police Framework. It handles knowledge service
+query storage in memory dictionaries, ensuring idempotency and proper error
+handling.
+
+The implementation uses Python dictionaries to store knowledge service query
+data, making it ideal for testing scenarios where external dependencies
+should be avoided.
+"""
+
+import logging
+from typing import Dict, Optional, Any, List
+
+from julee.domain.models.assembly_specification import (
+    KnowledgeServiceQuery,
+)
+from julee.domain.repositories.knowledge_service_query import (
+    KnowledgeServiceQueryRepository,
+)
+from .base import MemoryRepositoryMixin
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryKnowledgeServiceQueryRepository(
+    KnowledgeServiceQueryRepository,
+    MemoryRepositoryMixin[KnowledgeServiceQuery],
+):
+    """
+    Memory implementation of KnowledgeServiceQueryRepository using Python
+    dictionaries.
+
+    This implementation stores knowledge service queries in memory:
+    - Queries: Dictionary keyed by query_id containing KnowledgeServiceQuery
+      objects
+
+    This provides a lightweight, dependency-free option for testing while
+    maintaining the same interface as other implementations.
+    """
+
+    def __init__(self) -> None:
+        """Initialize repository with empty in-memory storage."""
+        self.logger = logger
+        self.entity_name = "KnowledgeServiceQuery"
+        self.storage_dict: Dict[str, KnowledgeServiceQuery] = {}
+
+        logger.debug("Initializing MemoryKnowledgeServiceQueryRepository")
+
+    async def get(self, query_id: str) -> Optional[KnowledgeServiceQuery]:
+        """Retrieve a knowledge service query by ID.
+
+        Args:
+            query_id: Unique query identifier
+
+        Returns:
+            KnowledgeServiceQuery object if found, None otherwise
+        """
+        return self.get_entity(query_id)
+
+    async def save(self, query: KnowledgeServiceQuery) -> None:
+        """Store or update a knowledge service query.
+
+        Args:
+            query: KnowledgeServiceQuery object to store
+        """
+        self.save_entity(query, "query_id")
+
+    async def get_many(
+        self, query_ids: List[str]
+    ) -> Dict[str, Optional[KnowledgeServiceQuery]]:
+        """Retrieve multiple knowledge service queries by ID.
+
+        Args:
+            query_ids: List of unique query identifiers
+
+        Returns:
+            Dict mapping query_id to KnowledgeServiceQuery (or None if not
+            found)
+        """
+        return self.get_many_entities(query_ids)
+
+    async def generate_id(self) -> str:
+        """Generate a unique query identifier.
+
+        Returns:
+            Unique string identifier for a new query
+        """
+        return self.generate_entity_id("query")
+
+    async def list_all(self) -> List[KnowledgeServiceQuery]:
+        """List all knowledge service queries.
+
+        Returns:
+            List of all knowledge service queries, sorted by query_id
+        """
+        self.logger.debug("MemoryKnowledgeServiceQueryRepository: Listing all queries")
+
+        # Get all entities and sort by query_id
+        entities = list(self.storage_dict.values())
+        entities.sort(key=lambda x: x.query_id)
+
+        self.logger.info(
+            "MemoryKnowledgeServiceQueryRepository: Retrieved "
+            f"{len(entities)} queries",
+            extra={"count": len(entities)},
+        )
+
+        return entities
+
+    def _add_entity_specific_log_data(
+        self, entity: KnowledgeServiceQuery, log_data: Dict[str, Any]
+    ) -> None:
+        """Add knowledge service query-specific data to log entries."""
+        super()._add_entity_specific_log_data(entity, log_data)
+        log_data["query_name"] = entity.name
+        log_data["knowledge_service_id"] = entity.knowledge_service_id

julee/repositories/memory/policy.py

@@ -0,0 +1,87 @@
+"""
+Memory implementation of PolicyRepository.
+
+This module provides an in-memory implementation of the PolicyRepository
+protocol that follows the Clean Architecture patterns defined in the
+Fun-Police Framework. It handles policy storage in memory dictionaries,
+ensuring idempotency and proper error handling.
+
+The implementation uses Python dictionaries to store policy data, making it
+ideal for testing scenarios where external dependencies should be avoided.
+All operations are still async to maintain interface compatibility.
+"""
+
+import logging
+from typing import Optional, Dict, Any, List
+
+from julee.domain.models.policy import Policy
+from julee.domain.repositories.policy import PolicyRepository
+from .base import MemoryRepositoryMixin
+
+logger = logging.getLogger(__name__)
+
+
+class MemoryPolicyRepository(PolicyRepository, MemoryRepositoryMixin[Policy]):
+    """
+    Memory implementation of PolicyRepository using Python dictionaries.
+
+    This implementation stores policy data in memory using a dictionary
+    keyed by policy_id. This provides a lightweight, dependency-free
+    option for testing.
+    """
+
+    def __init__(self) -> None:
+        """Initialize repository with empty in-memory storage."""
+        self.logger = logger
+        self.entity_name = "Policy"
+        self.storage_dict: Dict[str, Policy] = {}
+
+        logger.debug("Initializing MemoryPolicyRepository")
+
+    async def get(self, policy_id: str) -> Optional[Policy]:
+        """Retrieve a policy by ID.
+
+        Args:
+            policy_id: Unique policy identifier
+
+        Returns:
+            Policy if found, None otherwise
+        """
+        return self.get_entity(policy_id)
+
+    async def save(self, policy: Policy) -> None:
+        """Save a policy.
+
+        Args:
+            policy: Complete Policy to save
+        """
+        self.save_entity(policy, "policy_id")
+
+    async def generate_id(self) -> str:
+        """Generate a unique policy identifier.
+
+        Returns:
+            Unique policy ID string
+        """
+        return self.generate_entity_id("policy")
+
+    async def get_many(self, policy_ids: List[str]) -> Dict[str, Optional[Policy]]:
+        """Retrieve multiple policies by ID.
+
+        Args:
+            policy_ids: List of unique policy identifiers
+
+        Returns:
+            Dict mapping policy_id to Policy (or None if not found)
+        """
+        return self.get_many_entities(policy_ids)
+
+    def _add_entity_specific_log_data(
+        self, entity: Policy, log_data: Dict[str, Any]
+    ) -> None:
+        """Add policy-specific data to log entries."""
+        super()._add_entity_specific_log_data(entity, log_data)
+        log_data["title"] = entity.title
+        log_data["validation_scores_count"] = len(entity.validation_scores)
+        log_data["has_transformations"] = entity.has_transformations
+        log_data["is_validation_only"] = entity.is_validation_only

julee/repositories/memory/tests/test_document.py

@@ -0,0 +1,212 @@
+"""
+Unit tests for MemoryDocumentRepository.
+
+These tests verify the memory implementation logic without requiring external
+dependencies. They follow the Clean Architecture testing patterns and verify
+idempotency, error handling, and content operations including content_string.
+"""
+
+import io
+import pytest
+from julee.repositories.memory.document import (
+    MemoryDocumentRepository,
+)
+from julee.domain.models.document import Document, DocumentStatus
+from julee.domain.models.custom_fields.content_stream import (
+    ContentStream,
+)
+
+
+@pytest.fixture
+def repository() -> MemoryDocumentRepository:
+    """Provide a repository instance for testing."""
+    return MemoryDocumentRepository()
+
+
+@pytest.fixture
+def sample_content() -> ContentStream:
+    """Sample content for testing."""
+    content_bytes = b"This is test content for document storage"
+    return ContentStream(io.BytesIO(content_bytes))
+
+
+@pytest.fixture
+def sample_document(sample_content: ContentStream) -> Document:
+    """Sample document for testing."""
+    return Document(
+        document_id="test-doc-123",
+        original_filename="test.txt",
+        content_type="text/plain",
+        size_bytes=41,
+        content_multihash="test_hash_placeholder",
+        status=DocumentStatus.CAPTURED,
+        content=sample_content,
+    )
+
+
+class TestMemoryDocumentRepositoryContentString:
+    """Test content_string functionality."""
+
+    async def test_save_document_with_content_string(
+        self, repository: MemoryDocumentRepository
+    ) -> None:
+        """Test saving document with content_string (small content)."""
+        content = '{"assembled": "document", "data": "test"}'
+
+        # Create document with content_string
+        document = Document(
+            document_id="test-doc-content-string",
+            original_filename="assembled.json",
+            content_type="application/json",
+            size_bytes=100,  # Will be updated automatically
+            content_multihash="placeholder",  # Will be updated automatically
+            status=DocumentStatus.CAPTURED,
+            content_string=content,
+        )
+
+        # Act - save should convert content_string to ContentStream
+        await repository.save(document)
+
+        # Assert document was saved successfully
+        retrieved = await repository.get(document.document_id)
+        assert retrieved is not None
+        assert retrieved.content_multihash != "placeholder"  # Hash was calculated
+        assert retrieved.size_bytes == len(content.encode("utf-8"))
+
+        # Verify content can be read
+        assert retrieved.content is not None
+        retrieved_content = retrieved.content.read().decode("utf-8")
+        assert retrieved_content == content
+
+    async def test_save_document_with_content_string_unicode(
+        self, repository: MemoryDocumentRepository
+    ) -> None:
+        """Test saving document with unicode content_string."""
+        content = '{"title": "测试文档", "emoji": "🚀", "content": "éñ"}'
+
+        document = Document(
+            document_id="test-doc-unicode",
+            original_filename="unicode.json",
+            content_type="application/json",
+            size_bytes=100,
+            content_multihash="placeholder",
+            status=DocumentStatus.CAPTURED,
+            content_string=content,
+        )
+
+        await repository.save(document)
+        retrieved = await repository.get(document.document_id)
+
+        assert retrieved is not None
+        assert retrieved.content is not None
+        retrieved_content = retrieved.content.read().decode("utf-8")
+        assert retrieved_content == content
+
+    # Note: Empty content test removed because domain model requires
+    # size_bytes > 0
+
+    async def test_save_excludes_content_string_from_storage(
+        self, repository: MemoryDocumentRepository
+    ) -> None:
+        """Test that content_string is not stored in memory storage."""
+        content = '{"test": "data that should not be in storage"}'
+
+        document = Document(
+            document_id="test-storage-exclusion",
+            original_filename="test.json",
+            content_type="application/json",
+            size_bytes=100,
+            content_multihash="placeholder",
+            status=DocumentStatus.CAPTURED,
+            content_string=content,
+        )
+
+        await repository.save(document)
+
+        # Check stored document directly from internal storage
+        stored_document = repository.storage_dict.get("test-storage-exclusion")
+        assert stored_document is not None
+
+        # Verify content_string is not in stored document
+        assert stored_document.content_string is None
+
+        # Verify essential fields are still present
+        assert stored_document.document_id == "test-storage-exclusion"
+        assert stored_document.content_multihash is not None
+        assert stored_document.content_multihash != "placeholder"
+
+        # Verify we can still retrieve with content
+        retrieved = await repository.get("test-storage-exclusion")
+        assert retrieved is not None
+        assert retrieved.content is not None
+        retrieved_content = retrieved.content.read().decode("utf-8")
+        assert retrieved_content == content
+
+
+class TestMemoryDocumentRepositoryBasicOperations:
+    """Test basic repository operations."""
+
+    async def test_save_and_get_document_with_content_stream(
+        self, repository: MemoryDocumentRepository, sample_document: Document
+    ) -> None:
+        """Test basic save and retrieve operations with ContentStream."""
+        # Act
+        await repository.save(sample_document)
+        retrieved = await repository.get(sample_document.document_id)
+
+        # Assert
+        assert retrieved is not None
+        assert retrieved.document_id == sample_document.document_id
+        assert retrieved.original_filename == sample_document.original_filename
+
+    async def test_get_nonexistent_document(
+        self, repository: MemoryDocumentRepository
+    ) -> None:
+        """Test retrieving a document that doesn't exist."""
+        result = await repository.get("nonexistent-123")
+        assert result is None
+
+    async def test_generate_id(self, repository: MemoryDocumentRepository) -> None:
+        """Test that generate_id returns a unique string."""
+        doc_id_1 = await repository.generate_id()
+        doc_id_2 = await repository.generate_id()
+
+        assert isinstance(doc_id_1, str)
+        assert isinstance(doc_id_2, str)
+        assert doc_id_1 != doc_id_2
+        assert len(doc_id_1) > 0
+        assert len(doc_id_2) > 0
+
+
+class TestMemoryDocumentRepositoryErrorHandling:
+    """Test error handling scenarios."""
+
+    async def test_save_handles_empty_document_id(
+        self, repository: MemoryDocumentRepository
+    ) -> None:
+        """Test error handling for empty document ID."""
+        with pytest.raises(ValueError, match="Document ID cannot be empty"):
+            Document(
+                document_id="",
+                original_filename="test.txt",
+                content_type="text/plain",
+                size_bytes=100,
+                content_multihash="test_hash",
+                status=DocumentStatus.CAPTURED,
+                content_string="test content",
+            )
+
+    async def test_save_handles_empty_filename(
+        self, repository: MemoryDocumentRepository
+    ) -> None:
+        """Test error handling for empty filename."""
+        with pytest.raises(ValueError, match="Original filename cannot be empty"):
+            Document(
+                document_id="test-123",
+                original_filename="",
+                content_type="text/plain",
+                size_bytes=100,
+                content_multihash="test_hash",
+                status=DocumentStatus.CAPTURED,
+                content_string="test content",
+            )

julee/repositories/memory/tests/test_document_policy_validation.py

@@ -0,0 +1,161 @@
+"""
+Tests for MemoryDocumentPolicyValidationRepository implementation.
+
+This module provides tests for the memory-based document policy validation
+repository implementation, focusing on functionality specific to this
+repository that differs from the inherited mixins.
+"""
+
+import pytest
+from datetime import datetime, timezone
+from typing import Any
+
+from julee.domain.models.policy import (
+    DocumentPolicyValidation,
+    DocumentPolicyValidationStatus,
+)
+from julee.repositories.memory.document_policy_validation import (
+    MemoryDocumentPolicyValidationRepository,
+)
+
+
+@pytest.fixture
+def validation_repo() -> MemoryDocumentPolicyValidationRepository:
+    """Create a fresh validation repository for each test."""
+    return MemoryDocumentPolicyValidationRepository()
+
+
+@pytest.fixture
+def sample_validation() -> DocumentPolicyValidation:
+    """Create a sample document policy validation for testing."""
+    return DocumentPolicyValidation(
+        validation_id="validation-test-123",
+        input_document_id="doc-123",
+        policy_id="policy-456",
+        status=DocumentPolicyValidationStatus.PASSED,
+        validation_scores=[
+            ("quality-check-query", 85),
+            ("completeness-check", 92),
+        ],
+        transformed_document_id="doc-123-transformed",
+        post_transform_validation_scores=[
+            ("quality-check-query", 95),
+            ("completeness-check", 88),
+        ],
+        started_at=datetime.now(timezone.utc),
+        completed_at=datetime.now(timezone.utc),
+        passed=True,
+    )
+
+
+class TestMemoryDocumentPolicyValidationRepositorySpecific:
+    """Test functionality specific to DocumentPolicyValidation repository."""
+
+    @pytest.mark.asyncio
+    async def test_generate_id_prefix(
+        self, validation_repo: MemoryDocumentPolicyValidationRepository
+    ) -> None:
+        """Test that generated IDs use the correct prefix for validations."""
+        id1 = await validation_repo.generate_id()
+        id2 = await validation_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("validation-")
+        assert id2.startswith("validation-")
+
+    @pytest.mark.asyncio
+    async def test_entity_specific_logging_data(
+        self,
+        validation_repo: MemoryDocumentPolicyValidationRepository,
+        sample_validation: DocumentPolicyValidation,
+    ) -> None:
+        """Test that entity-specific logging data is added correctly."""
+        log_data: dict[str, Any] = {}
+        validation_repo._add_entity_specific_log_data(sample_validation, log_data)
+
+        # Check validation-specific fields are added
+        assert log_data["input_document_id"] == "doc-123"
+        assert log_data["policy_id"] == "policy-456"
+        assert log_data["validation_scores_count"] == 2
+        assert log_data["has_transformations"] is True
+        assert log_data["passed"] is True
+        assert "has_error" not in log_data  # No error message
+
+    @pytest.mark.asyncio
+    async def test_entity_specific_logging_data_with_error(
+        self, validation_repo: MemoryDocumentPolicyValidationRepository
+    ) -> None:
+        """Test logging data includes error flag when error_message is
+        present."""
+        validation_with_error = DocumentPolicyValidation(
+            validation_id="validation-error-123",
+            input_document_id="doc-456",
+            policy_id="policy-789",
+            status=DocumentPolicyValidationStatus.ERROR,
+            validation_scores=[],
+            error_message="Something went wrong",
+            passed=False,
+        )
+
+        log_data: dict[str, Any] = {}
+        validation_repo._add_entity_specific_log_data(validation_with_error, log_data)
+
+        assert log_data["has_error"] is True
+        assert log_data["passed"] is False
+
+    @pytest.mark.asyncio
+    async def test_entity_specific_logging_data_no_transformations(
+        self, validation_repo: MemoryDocumentPolicyValidationRepository
+    ) -> None:
+        """Test logging data correctly identifies validations without
+        transformations."""
+        validation_no_transform = DocumentPolicyValidation(
+            validation_id="validation-no-transform-123",
+            input_document_id="doc-789",
+            policy_id="policy-abc",
+            status=DocumentPolicyValidationStatus.VALIDATION_COMPLETE,
+            validation_scores=[("basic-check", 75)],
+            transformed_document_id=None,
+            post_transform_validation_scores=None,
+        )
+
+        log_data: dict[str, Any] = {}
+        validation_repo._add_entity_specific_log_data(validation_no_transform, log_data)
+
+        assert log_data["has_transformations"] is False
+        assert log_data["validation_scores_count"] == 1
+
+    @pytest.mark.asyncio
+    async def test_entity_specific_logging_data_passed_none(
+        self, validation_repo: MemoryDocumentPolicyValidationRepository
+    ) -> None:
+        """Test logging data handles None passed value correctly."""
+        validation_in_progress = DocumentPolicyValidation(
+            validation_id="validation-progress-123",
+            input_document_id="doc-progress",
+            policy_id="policy-progress",
+            status=DocumentPolicyValidationStatus.IN_PROGRESS,
+            validation_scores=[],
+            passed=None,  # Still in progress
+        )
+
+        log_data: dict[str, Any] = {}
+        validation_repo._add_entity_specific_log_data(validation_in_progress, log_data)
+
+        # passed field should not be added when None
+        assert "passed" not in log_data
+        assert log_data["has_transformations"] is False
+
+    @pytest.mark.asyncio
+    async def test_initialization_sets_correct_attributes(
+        self, validation_repo: MemoryDocumentPolicyValidationRepository
+    ) -> None:
+        """Test that repository initialization sets the correct attributes."""
+        assert validation_repo.entity_name == "DocumentPolicyValidation"
+        assert isinstance(validation_repo.storage_dict, dict)
+        assert len(validation_repo.storage_dict) == 0
+        assert validation_repo.logger is not None