julee 0.1.0__py3-none-any.whl

julee/domain/models/policy/policy.py

@@ -0,0 +1,203 @@
+"""
+Policy domain models for the Capture, Extract, Assemble,
+Publish workflow.
+
+This module contains the Policy domain object that represents
+policy configurations in the CEAP workflow system.
+
+A Policy defines validation criteria and optional transformations
+for documents. It includes validation scores that must be met and optional
+transformation queries that can be applied to improve document quality.
+
+All domain models use Pydantic BaseModel for validation, serialization,
+and type safety, following the patterns established in the sample project.
+"""
+
+from pydantic import BaseModel, Field, field_validator
+from typing import Optional, List, Tuple
+from datetime import datetime, timezone
+from enum import Enum
+
+
+class PolicyStatus(str, Enum):
+    """Status of a policy configuration."""
+
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+    DRAFT = "draft"
+    DEPRECATED = "deprecated"
+
+
+class Policy(BaseModel):
+    """Policy configuration that defines validation and
+    transformation criteria for documents.
+
+    A Policy represents a set of quality criteria that documents
+    must meet. It includes validation scores that are calculated using
+    knowledge service queries, and optional transformation queries that can
+    be applied to improve document quality before re-validation.
+
+    The policy operates in two modes:
+    1. Validation-only: Calculates scores and passes/fails based on criteria
+    2. Validation with transformation: Calculates scores, applies
+       transformations, then re-calculates scores for final pass/fail
+    """
+
+    # Core policy identification
+    policy_id: str = Field(description="Unique identifier for this policy")
+    title: str = Field(description="Human-readable title for the policy")
+    description: str = Field(
+        description="Detailed description of what this policy validates "
+        "and optionally transforms"
+    )
+
+    # Policy configuration
+    status: PolicyStatus = PolicyStatus.ACTIVE
+    validation_scores: List[Tuple[str, int]] = Field(
+        description="List of (knowledge_service_query_id, required_score) "
+        "tuples where required_score is between 0 and 100. All scores "
+        "must be met or exceeded for the policy to pass"
+    )
+    transformation_queries: Optional[List[str]] = Field(
+        default=None,
+        description="Optional list of knowledge service query IDs for "
+        "transformations to apply before re-validation. If not provided "
+        "or empty, policy operates in validation-only mode",
+    )
+
+    # Policy metadata
+    version: str = Field(default="0.1.0", description="Policy version")
+    created_at: Optional[datetime] = Field(
+        default_factory=lambda: datetime.now(timezone.utc)
+    )
+    updated_at: Optional[datetime] = Field(default=None)
+
+    @field_validator("policy_id")
+    @classmethod
+    def policy_id_must_not_be_empty(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("Policy ID cannot be empty")
+        return v.strip()
+
+    @field_validator("title")
+    @classmethod
+    def title_must_not_be_empty(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("Policy title cannot be empty")
+        return v.strip()
+
+    @field_validator("description")
+    @classmethod
+    def description_must_not_be_empty(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("Policy description cannot be empty")
+        return v.strip()
+
+    @field_validator("validation_scores")
+    @classmethod
+    def validation_scores_must_be_valid(
+        cls, v: List[Tuple[str, int]]
+    ) -> List[Tuple[str, int]]:
+        if not isinstance(v, list):
+            raise ValueError("Validation scores must be a list")
+
+        if not v:
+            raise ValueError("Validation scores list cannot be empty")
+
+        validated_scores = []
+        query_ids_seen = set()
+
+        for item in v:
+            if not isinstance(item, tuple) or len(item) != 2:
+                raise ValueError(
+                    "Each validation score must be a 2-tuple of "
+                    "(query_id, required_score)"
+                )
+
+            query_id, required_score = item
+
+            # Validate query ID
+            if not isinstance(query_id, str) or not query_id.strip():
+                raise ValueError(
+                    "Query ID in validation scores must be a non-empty string"
+                )
+            query_id = query_id.strip()
+
+            # Check for duplicate query IDs
+            if query_id in query_ids_seen:
+                raise ValueError(
+                    f"Duplicate query ID '{query_id}' in validation scores"
+                )
+            query_ids_seen.add(query_id)
+
+            # Validate required score
+            if not isinstance(required_score, int):
+                raise ValueError("Required score must be an integer between 0 and 100")
+            if required_score < 0 or required_score > 100:
+                raise ValueError(
+                    f"Required score {required_score} must be between " f"0 and 100"
+                )
+
+            validated_scores.append((query_id, required_score))
+
+        return validated_scores
+
+    @field_validator("transformation_queries")
+    @classmethod
+    def transformation_queries_must_be_valid(
+        cls, v: Optional[List[str]]
+    ) -> Optional[List[str]]:
+        if v is None:
+            return v
+
+        if not isinstance(v, list):
+            raise ValueError("Transformation queries must be a list or None")
+
+        # Empty list is valid - means no transformations
+        if not v:
+            return v
+
+        validated_queries = []
+        query_ids_seen = set()
+
+        for query_id in v:
+            if not isinstance(query_id, str) or not query_id.strip():
+                raise ValueError(
+                    "Each transformation query ID must be a non-empty string"
+                )
+            query_id = query_id.strip()
+
+            # Check for duplicate query IDs
+            if query_id in query_ids_seen:
+                raise ValueError(
+                    f"Duplicate query ID '{query_id}' in transformation " f"queries"
+                )
+            query_ids_seen.add(query_id)
+
+            validated_queries.append(query_id)
+
+        return validated_queries
+
+    @field_validator("version")
+    @classmethod
+    def version_must_not_be_empty(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("Policy version cannot be empty")
+        return v.strip()
+
+    @property
+    def is_validation_only(self) -> bool:
+        """Check if this policy operates in validation-only mode.
+
+        Returns True if no transformation queries are defined or if the
+        transformation queries list is empty.
+        """
+        return not self.transformation_queries
+
+    @property
+    def has_transformations(self) -> bool:
+        """Check if this policy includes transformation queries.
+
+        Returns True if transformation queries are defined and non-empty.
+        """
+        return not self.is_validation_only

julee/domain/models/policy/tests/factories.py

@@ -0,0 +1,47 @@
+"""
+Test factories for Policy domain objects using factory_boy.
+
+This module provides factory_boy factories for creating test instances of
+Policy domain objects with sensible defaults.
+"""
+
+from datetime import datetime, timezone
+from factory.base import Factory
+from factory.faker import Faker
+from factory.declarations import LazyFunction
+
+from julee.domain.models.policy import (
+    DocumentPolicyValidation,
+    DocumentPolicyValidationStatus,
+)
+
+
+class DocumentPolicyValidationFactory(Factory):
+    """Factory for creating DocumentPolicyValidation instances with sensible
+    test defaults."""
+
+    class Meta:
+        model = DocumentPolicyValidation
+
+    # Core validation identification
+    validation_id = Faker("uuid4")
+    input_document_id = Faker("uuid4")
+    policy_id = Faker("uuid4")
+
+    # Validation process status
+    status = DocumentPolicyValidationStatus.PENDING
+
+    # Initial validation results (empty by default)
+    validation_scores: list[tuple[str, int]] = []
+
+    # Transformation results (None by default)
+    transformed_document_id = None
+    post_transform_validation_scores = None
+
+    # Validation metadata
+    started_at = LazyFunction(lambda: datetime.now(timezone.utc))
+    completed_at = None
+    error_message = None
+
+    # Results summary
+    passed = None

julee/domain/models/policy/tests/test_document_policy_validation.py

@@ -0,0 +1,420 @@
+"""
+Tests for DocumentPolicyValidation domain model.
+
+This module tests the DocumentPolicyValidation domain object validation,
+field requirements, and business rules following the same testing patterns
+as the Policy model tests.
+
+Tests focus on:
+- Required field validation
+- Field format validation
+- Score tuple validation
+- Status enum validation
+- Edge cases and error conditions
+"""
+
+import pytest
+from datetime import datetime, timezone
+from pydantic import ValidationError
+
+from julee.domain.models.policy import (
+    DocumentPolicyValidation,
+    DocumentPolicyValidationStatus,
+)
+from .factories import DocumentPolicyValidationFactory
+
+
+class TestDocumentPolicyValidationValidation:
+    """Test validation rules for DocumentPolicyValidation model."""
+
+    def test_minimal_valid_validation(self) -> None:
+        """Test creating a minimal valid DocumentPolicyValidation."""
+        validation = DocumentPolicyValidationFactory()
+
+        assert validation.input_document_id is not None
+        assert validation.policy_id is not None
+        assert validation.status == DocumentPolicyValidationStatus.PENDING
+        assert validation.validation_scores == []
+        assert validation.transformed_document_id is None
+        assert validation.post_transform_validation_scores is None
+        assert validation.validation_id is not None
+        assert validation.passed is None
+        assert validation.error_message is None
+        assert validation.completed_at is None
+        assert isinstance(validation.started_at, datetime)
+
+    def test_full_valid_validation(self) -> None:
+        """Test creating a fully populated DocumentPolicyValidation."""
+        started_at = datetime.now(timezone.utc)
+        completed_at = datetime.now(timezone.utc)
+
+        validation = DocumentPolicyValidation(
+            validation_id="val-789",
+            input_document_id="doc-123",
+            policy_id="policy-456",
+            status=DocumentPolicyValidationStatus.PASSED,
+            validation_scores=[("query1", 85), ("query2", 92)],
+            transformed_document_id="doc-123-transformed",
+            post_transform_validation_scores=[("query1", 95), ("query2", 88)],
+            started_at=started_at,
+            completed_at=completed_at,
+            error_message=None,
+            passed=True,
+        )
+
+        assert validation.validation_id == "val-789"
+        assert validation.input_document_id == "doc-123"
+        assert validation.policy_id == "policy-456"
+        assert validation.status == DocumentPolicyValidationStatus.PASSED
+        assert validation.validation_scores == [
+            ("query1", 85),
+            ("query2", 92),
+        ]
+        assert validation.transformed_document_id == "doc-123-transformed"
+        assert validation.post_transform_validation_scores == [
+            ("query1", 95),
+            ("query2", 88),
+        ]
+        assert validation.started_at == started_at
+        assert validation.completed_at == completed_at
+        assert validation.passed is True
+
+
+class TestDocumentPolicyValidationRequiredFields:
+    """Test required field validation."""
+
+    def test_required_fields_present_in_factory(self) -> None:
+        """Test that factory creates validation with required fields."""
+        validation = DocumentPolicyValidationFactory()
+        assert validation.input_document_id is not None
+        assert validation.policy_id is not None
+        assert isinstance(validation.input_document_id, str)
+        assert isinstance(validation.policy_id, str)
+
+
+class TestDocumentPolicyValidationFieldValidation:
+    """Test individual field validation rules."""
+
+    def test_input_document_id_cannot_be_empty(self) -> None:
+        """Test that input_document_id cannot be empty or whitespace."""
+        test_cases = ["", "   ", "\t", "\n"]
+
+        for empty_value in test_cases:
+            with pytest.raises(ValidationError) as exc_info:
+                DocumentPolicyValidation(
+                    validation_id="val-123",
+                    input_document_id=empty_value,
+                    policy_id="policy-456",
+                )
+
+            errors = exc_info.value.errors()
+            assert any(
+                "Input document ID cannot be empty" in str(error) for error in errors
+            )
+
+    def test_input_document_id_strips_whitespace(self) -> None:
+        """Test that input_document_id strips whitespace."""
+        validation = DocumentPolicyValidation(
+            validation_id="val-123",
+            input_document_id="  doc-123  ",
+            policy_id="policy-456",
+        )
+        assert validation.input_document_id == "doc-123"
+
+    def test_policy_id_cannot_be_empty(self) -> None:
+        """Test that policy_id cannot be empty or whitespace."""
+        test_cases = ["", "   ", "\t", "\n"]
+
+        for empty_value in test_cases:
+            with pytest.raises(ValidationError) as exc_info:
+                DocumentPolicyValidation(
+                    validation_id="val-123",
+                    input_document_id="doc-123",
+                    policy_id=empty_value,
+                )
+
+            errors = exc_info.value.errors()
+            assert any("Policy ID cannot be empty" in str(error) for error in errors)
+
+    def test_policy_id_strips_whitespace(self) -> None:
+        """Test that policy_id strips whitespace."""
+        validation = DocumentPolicyValidation(
+            validation_id="val-123",
+            input_document_id="doc-123",
+            policy_id="  policy-456  ",
+        )
+        assert validation.policy_id == "policy-456"
+
+    def test_transformed_document_id_validation(self) -> None:
+        """Test transformed_document_id field validation."""
+        # None is valid
+        validation = DocumentPolicyValidation(
+            validation_id="val-123",
+            input_document_id="doc-123",
+            policy_id="policy-456",
+            transformed_document_id=None,
+        )
+        assert validation.transformed_document_id is None
+
+        # Non-empty string is valid
+        validation = DocumentPolicyValidation(
+            validation_id="val-123",
+            input_document_id="doc-123",
+            policy_id="policy-456",
+            transformed_document_id="doc-123-transformed",
+        )
+        assert validation.transformed_document_id == "doc-123-transformed"
+
+        # Empty string should be invalid
+        with pytest.raises(ValidationError) as exc_info:
+            DocumentPolicyValidation(
+                validation_id="val-123",
+                input_document_id="doc-123",
+                policy_id="policy-456",
+                transformed_document_id="",
+            )
+
+        errors = exc_info.value.errors()
+        assert any(
+            "must be a non-empty string or None" in str(error) for error in errors
+        )
+
+    def test_error_message_validation(self) -> None:
+        """Test error_message field validation."""
+        # None is valid
+        validation = DocumentPolicyValidation(
+            validation_id="val-123",
+            input_document_id="doc-123",
+            policy_id="policy-456",
+            error_message=None,
+        )
+        assert validation.error_message is None
+
+        # Non-empty string is valid
+        validation = DocumentPolicyValidation(
+            validation_id="val-123",
+            input_document_id="doc-123",
+            policy_id="policy-456",
+            error_message="Something went wrong",
+        )
+        assert validation.error_message == "Something went wrong"
+
+        # Empty/whitespace string becomes None
+        validation = DocumentPolicyValidation(
+            validation_id="val-123",
+            input_document_id="doc-123",
+            policy_id="policy-456",
+            error_message="   ",
+        )
+        assert validation.error_message is None
+
+
+class TestValidationScores:
+    """Test validation_scores field validation."""
+
+    def test_empty_validation_scores_valid(self) -> None:
+        """Test that empty validation_scores list is valid."""
+        validation = DocumentPolicyValidation(
+            validation_id="val-123",
+            input_document_id="doc-123",
+            policy_id="policy-456",
+            validation_scores=[],
+        )
+        assert validation.validation_scores == []
+
+    def test_valid_validation_scores(self) -> None:
+        """Test valid validation_scores."""
+        scores = [("query1", 85), ("query2", 92), ("query3", 78)]
+        validation = DocumentPolicyValidation(
+            validation_id="val-123",
+            input_document_id="doc-123",
+            policy_id="policy-456",
+            validation_scores=scores,
+        )
+        assert validation.validation_scores == scores
+
+    def test_validation_scores_with_valid_integers(self) -> None:
+        """Test that validation_scores work with valid integer scores."""
+        validation = DocumentPolicyValidation(
+            validation_id="val-123",
+            input_document_id="doc-123",
+            policy_id="policy-456",
+            validation_scores=[("query1", 85), ("query2", 92)],
+        )
+        assert validation.validation_scores == [
+            ("query1", 85),
+            ("query2", 92),
+        ]
+
+    def test_validation_scores_query_id_validation(self) -> None:
+        """Test validation_scores query_id validation."""
+        # Empty query_id should fail
+        with pytest.raises(ValidationError) as exc_info:
+            DocumentPolicyValidation(
+                validation_id="val-123",
+                input_document_id="doc-123",
+                policy_id="policy-456",
+                validation_scores=[("", 85)],
+            )
+
+        errors = exc_info.value.errors()
+        assert any("must be a non-empty string" in str(error) for error in errors)
+
+        # Whitespace-only query_id should fail
+        with pytest.raises(ValidationError) as exc_info:
+            DocumentPolicyValidation(
+                validation_id="val-123",
+                input_document_id="doc-123",
+                policy_id="policy-456",
+                validation_scores=[("   ", 85)],
+            )
+
+        errors = exc_info.value.errors()
+        assert any("must be a non-empty string" in str(error) for error in errors)
+
+    def test_validation_scores_score_range(self) -> None:
+        """Test validation_scores score range validation."""
+        # Score too low
+        with pytest.raises(ValidationError) as exc_info:
+            DocumentPolicyValidation(
+                validation_id="val-123",
+                input_document_id="doc-123",
+                policy_id="policy-456",
+                validation_scores=[("query1", -1)],
+            )
+
+        errors = exc_info.value.errors()
+        assert any("must be between 0 and 100" in str(error) for error in errors)
+
+        # Score too high
+        with pytest.raises(ValidationError) as exc_info:
+            DocumentPolicyValidation(
+                validation_id="val-123",
+                input_document_id="doc-123",
+                policy_id="policy-456",
+                validation_scores=[("query1", 101)],
+            )
+
+        errors = exc_info.value.errors()
+        assert any("must be between 0 and 100" in str(error) for error in errors)
+
+        # Valid edge cases
+        validation = DocumentPolicyValidation(
+            validation_id="val-123",
+            input_document_id="doc-123",
+            policy_id="policy-456",
+            validation_scores=[("query1", 0), ("query2", 100)],
+        )
+        assert validation.validation_scores == [
+            ("query1", 0),
+            ("query2", 100),
+        ]
+
+    def test_validation_scores_no_duplicates(self) -> None:
+        """Test that validation_scores cannot have duplicate query_ids."""
+        with pytest.raises(ValidationError) as exc_info:
+            DocumentPolicyValidation(
+                validation_id="val-123",
+                input_document_id="doc-123",
+                policy_id="policy-456",
+                validation_scores=[("query1", 85), ("query1", 92)],
+            )
+
+        errors = exc_info.value.errors()
+        assert any("Duplicate query ID 'query1'" in str(error) for error in errors)
+
+
+class TestPostTransformValidationScores:
+    """Test post_transform_validation_scores field validation."""
+
+    def test_none_post_transform_scores_valid(self) -> None:
+        """Test that None post_transform_validation_scores is valid."""
+        validation = DocumentPolicyValidation(
+            validation_id="val-123",
+            input_document_id="doc-123",
+            policy_id="policy-456",
+            post_transform_validation_scores=None,
+        )
+        assert validation.post_transform_validation_scores is None
+
+    def test_empty_post_transform_scores_valid(self) -> None:
+        """Test that empty post_transform_validation_scores list is valid."""
+        validation = DocumentPolicyValidation(
+            validation_id="val-123",
+            input_document_id="doc-123",
+            policy_id="policy-456",
+            post_transform_validation_scores=[],
+        )
+        assert validation.post_transform_validation_scores == []
+
+    def test_valid_post_transform_scores(self) -> None:
+        """Test valid post_transform_validation_scores."""
+        scores = [("query1", 95), ("query2", 88)]
+        validation = DocumentPolicyValidation(
+            validation_id="val-123",
+            input_document_id="doc-123",
+            policy_id="policy-456",
+            post_transform_validation_scores=scores,
+        )
+        assert validation.post_transform_validation_scores == scores
+
+    def test_post_transform_scores_validation_rules(self) -> None:
+        """Test that post_transform_validation_scores follows same rules as
+        validation_scores."""
+        # Same score range validation
+        with pytest.raises(ValidationError) as exc_info:
+            DocumentPolicyValidation(
+                validation_id="val-123",
+                input_document_id="doc-123",
+                policy_id="policy-456",
+                post_transform_validation_scores=[("query1", -5)],
+            )
+
+        errors = exc_info.value.errors()
+        assert any("must be between 0 and 100" in str(error) for error in errors)
+
+        # Same duplicate detection
+        with pytest.raises(ValidationError) as exc_info:
+            DocumentPolicyValidation(
+                validation_id="val-123",
+                input_document_id="doc-123",
+                policy_id="policy-456",
+                post_transform_validation_scores=[
+                    ("query1", 85),
+                    ("query1", 92),
+                ],
+            )
+
+        errors = exc_info.value.errors()
+        assert any("Duplicate query ID 'query1'" in str(error) for error in errors)
+
+
+class TestDocumentPolicyValidationStatusEnum:
+    """Test DocumentPolicyValidationStatus enum usage."""
+
+    def test_default_status_is_pending(self) -> None:
+        """Test that default status is PENDING."""
+        validation = DocumentPolicyValidation(
+            validation_id="val-123",
+            input_document_id="doc-123",
+            policy_id="policy-456",
+        )
+        assert validation.status == DocumentPolicyValidationStatus.PENDING
+
+    def test_all_valid_statuses_work(self) -> None:
+        """Test that all valid status enum values work correctly."""
+        valid_statuses = [
+            DocumentPolicyValidationStatus.PENDING,
+            DocumentPolicyValidationStatus.IN_PROGRESS,
+            DocumentPolicyValidationStatus.PASSED,
+            DocumentPolicyValidationStatus.FAILED,
+        ]
+
+        for status in valid_statuses:
+            validation = DocumentPolicyValidation(
+                validation_id="val-123",
+                input_document_id="doc-123",
+                policy_id="policy-456",
+                status=status,
+            )
+            assert validation.status == status