julee 0.1.0__py3-none-any.whl

julee/domain/models/assembly/tests/test_assembly.py

@@ -0,0 +1,430 @@
+"""
+Comprehensive tests for Assembly domain model.
+
+This test module documents the design decisions made for the Assembly domain
+model using table-based tests. It covers:
+
+- Assembly instantiation with various field combinations
+- JSON serialization behavior
+- Field validation for required fields
+- Assembly status transitions
+- Assembly document output management
+
+Design decisions documented:
+- Assemblies must have all required fields (assembly_id,
+  assembly_specification_id, input_document_id)
+- All ID fields must be non-empty and non-whitespace
+- Status defaults to PENDING
+- assembled_document_id is optional and defaults to None
+- Timestamps are automatically set with timezone-aware defaults
+"""
+
+import pytest
+import json
+from datetime import datetime, timezone
+
+from julee.domain.models.assembly import Assembly, AssemblyStatus
+from .factories import AssemblyFactory
+
+
+class TestAssemblyInstantiation:
+    """Test Assembly creation with various field combinations."""
+
+    @pytest.mark.parametrize(
+        "assembly_id,assembly_specification_id,input_document_id,expected_success",
+        [
+            # Valid cases
+            ("asm-1", "spec-1", "doc-1", True),
+            ("assembly-uuid-456", "spec-uuid-789", "input-doc-123", True),
+            ("asm_abc", "spec_def", "doc_ghi", True),
+            # Invalid cases - empty required fields
+            ("", "spec-1", "doc-1", False),  # Empty assembly_id
+            ("asm-1", "", "doc-1", False),  # Empty assembly_specification_id
+            ("asm-1", "spec-1", "", False),  # Empty input_document_id
+            # Invalid cases - whitespace only
+            ("   ", "spec-1", "doc-1", False),  # Whitespace assembly_id
+            (
+                "asm-1",
+                "   ",
+                "doc-1",
+                False,
+            ),  # Whitespace assembly_specification_id
+            ("asm-1", "spec-1", "   ", False),  # Whitespace input_document_id
+        ],
+    )
+    def test_assembly_creation_validation(
+        self,
+        assembly_id: str,
+        assembly_specification_id: str,
+        input_document_id: str,
+        expected_success: bool,
+    ) -> None:
+        """Test assembly creation with various field validation scenarios."""
+        if expected_success:
+            # Should create successfully
+            assembly = Assembly(
+                assembly_id=assembly_id,
+                assembly_specification_id=assembly_specification_id,
+                input_document_id=input_document_id,
+                workflow_id="test-workflow-123",
+            )
+            assert assembly.assembly_id == assembly_id.strip()
+            assert (
+                assembly.assembly_specification_id == assembly_specification_id.strip()
+            )
+            assert assembly.input_document_id == input_document_id.strip()
+            assert assembly.status == AssemblyStatus.PENDING  # Default
+            assert assembly.assembled_document_id is None  # Default None
+            assert assembly.created_at is not None
+            assert assembly.updated_at is not None
+        else:
+            # Should raise validation error
+            with pytest.raises(Exception):  # Could be ValueError or ValidationError
+                Assembly(
+                    assembly_id=assembly_id,
+                    assembly_specification_id=assembly_specification_id,
+                    input_document_id=input_document_id,
+                    workflow_id="test-workflow-123",
+                )
+
+
+class TestAssemblySerialization:
+    """Test Assembly JSON serialization behavior."""
+
+    def test_assembly_json_serialization(self) -> None:
+        """Test that Assembly serializes to JSON correctly."""
+        assembly = AssemblyFactory.build(
+            assembly_id="test-assembly-123",
+            assembly_specification_id="spec-456",
+            input_document_id="input-789",
+            status=AssemblyStatus.IN_PROGRESS,
+            assembled_document_id="output-doc-456",
+        )
+
+        json_str = assembly.model_dump_json()
+        json_data = json.loads(json_str)
+
+        # All fields should be present in JSON
+        assert json_data["assembly_id"] == assembly.assembly_id
+        assert (
+            json_data["assembly_specification_id"] == assembly.assembly_specification_id
+        )
+        assert json_data["input_document_id"] == assembly.input_document_id
+        assert json_data["workflow_id"] == assembly.workflow_id
+        assert json_data["status"] == assembly.status.value
+        assert "created_at" in json_data
+        assert "updated_at" in json_data
+        assert json_data["assembled_document_id"] == assembly.assembled_document_id
+
+    def test_assembly_json_roundtrip(self) -> None:
+        """Test that Assembly can be serialized to JSON and deserialized
+        back."""
+        original_assembly = AssemblyFactory.build(
+            assembled_document_id="test-output-doc"
+        )
+
+        # Serialize to JSON
+        json_str = original_assembly.model_dump_json()
+        json_data = json.loads(json_str)
+
+        # Deserialize back to Assembly
+        reconstructed_assembly = Assembly(**json_data)
+
+        # Should be equivalent
+        assert reconstructed_assembly.assembly_id == original_assembly.assembly_id
+        assert (
+            reconstructed_assembly.assembly_specification_id
+            == original_assembly.assembly_specification_id
+        )
+        assert (
+            reconstructed_assembly.input_document_id
+            == original_assembly.input_document_id
+        )
+        assert reconstructed_assembly.workflow_id == original_assembly.workflow_id
+        assert reconstructed_assembly.status == original_assembly.status
+        assert (
+            reconstructed_assembly.assembled_document_id
+            == original_assembly.assembled_document_id
+        )
+
+
+class TestAssemblyDefaults:
+    """Test Assembly default values and behavior."""
+
+    def test_assembly_default_values(self) -> None:
+        """Test that Assembly has correct default values."""
+        minimal_assembly = Assembly(
+            assembly_id="test-id",
+            assembly_specification_id="spec-id",
+            input_document_id="doc-id",
+            workflow_id="test-workflow-123",
+        )
+
+        assert minimal_assembly.status == AssemblyStatus.PENDING
+        assert minimal_assembly.assembled_document_id is None
+        assert minimal_assembly.created_at is not None
+        assert minimal_assembly.updated_at is not None
+        assert isinstance(minimal_assembly.created_at, datetime)
+        assert isinstance(minimal_assembly.updated_at, datetime)
+        # Should be timezone-aware
+        assert minimal_assembly.created_at.tzinfo is not None
+        assert minimal_assembly.updated_at.tzinfo is not None
+
+    def test_assembly_custom_values(self) -> None:
+        """Test Assembly with custom non-default values."""
+        custom_created_at = datetime(2023, 1, 1, 12, 0, 0, tzinfo=timezone.utc)
+        custom_updated_at = datetime(2023, 1, 2, 12, 0, 0, tzinfo=timezone.utc)
+
+        custom_assembly = Assembly(
+            assembly_id="custom-id",
+            assembly_specification_id="custom-spec",
+            input_document_id="custom-doc",
+            workflow_id="custom-workflow-456",
+            status=AssemblyStatus.COMPLETED,
+            assembled_document_id="custom-output-doc",
+            created_at=custom_created_at,
+            updated_at=custom_updated_at,
+        )
+
+        assert custom_assembly.status == AssemblyStatus.COMPLETED
+        assert custom_assembly.assembled_document_id == "custom-output-doc"
+        assert custom_assembly.created_at == custom_created_at
+        assert custom_assembly.updated_at == custom_updated_at
+
+    @pytest.mark.parametrize(
+        "status",
+        [
+            AssemblyStatus.PENDING,
+            AssemblyStatus.IN_PROGRESS,
+            AssemblyStatus.COMPLETED,
+            AssemblyStatus.FAILED,
+            AssemblyStatus.CANCELLED,
+        ],
+    )
+    def test_assembly_status_values(self, status: AssemblyStatus) -> None:
+        """Test Assembly with different status values."""
+        assembly = AssemblyFactory.build(status=status)
+        assert assembly.status == status
+
+
+class TestAssemblyFieldValidation:
+    """Test Assembly field-specific validation."""
+
+    def test_assembly_id_validation(self) -> None:
+        """Test assembly_id field validation."""
+        # Valid cases
+        valid_assembly = Assembly(
+            assembly_id="valid-id",
+            assembly_specification_id="spec-id",
+            input_document_id="doc-id",
+            workflow_id="test-workflow-123",
+        )
+        assert valid_assembly.assembly_id == "valid-id"
+
+        # Invalid cases
+        with pytest.raises(Exception):
+            Assembly(
+                assembly_id="",
+                assembly_specification_id="spec-id",
+                input_document_id="doc-id",
+                workflow_id="test-workflow-123",
+            )
+
+        with pytest.raises(Exception):
+            Assembly(
+                assembly_id="   ",
+                assembly_specification_id="spec-id",
+                input_document_id="doc-id",
+                workflow_id="test-workflow-123",
+            )
+
+    def test_assembly_specification_id_validation(self) -> None:
+        """Test assembly_specification_id field validation."""
+        # Valid cases
+        valid_assembly = Assembly(
+            assembly_id="asm-id",
+            assembly_specification_id="valid-spec-id",
+            input_document_id="doc-id",
+            workflow_id="test-workflow-123",
+        )
+        assert valid_assembly.assembly_specification_id == "valid-spec-id"
+
+        # Invalid cases
+        with pytest.raises(Exception):
+            Assembly(
+                assembly_id="asm-id",
+                assembly_specification_id="",
+                input_document_id="doc-id",
+                workflow_id="test-workflow-123",
+            )
+
+        with pytest.raises(Exception):
+            Assembly(
+                assembly_id="asm-id",
+                assembly_specification_id="   ",
+                input_document_id="doc-id",
+                workflow_id="test-workflow-123",
+            )
+
+    def test_input_document_id_validation(self) -> None:
+        """Test input_document_id field validation."""
+        # Valid cases
+        valid_assembly = Assembly(
+            assembly_id="asm-id",
+            assembly_specification_id="spec-id",
+            input_document_id="valid-doc-id",
+            workflow_id="test-workflow-123",
+        )
+        assert valid_assembly.input_document_id == "valid-doc-id"
+
+        # Invalid cases
+        with pytest.raises(Exception):
+            Assembly(
+                assembly_id="asm-id",
+                assembly_specification_id="spec-id",
+                input_document_id="",
+                workflow_id="test-workflow-123",
+            )
+
+        with pytest.raises(Exception):
+            Assembly(
+                assembly_id="asm-id",
+                assembly_specification_id="spec-id",
+                input_document_id="   ",
+                workflow_id="test-workflow-123",
+            )
+
+    def test_field_trimming(self) -> None:
+        """Test that string fields are properly trimmed."""
+        assembly = Assembly(
+            assembly_id="  trim-asm  ",
+            assembly_specification_id="  trim-spec  ",
+            input_document_id="  trim-doc  ",
+            workflow_id="  trim-workflow  ",
+        )
+
+        assert assembly.assembly_id == "trim-asm"
+        assert assembly.assembly_specification_id == "trim-spec"
+        assert assembly.input_document_id == "trim-doc"
+        assert assembly.workflow_id == "trim-workflow"
+
+
+class TestAssemblyDocumentManagement:
+    """Test Assembly assembled document management."""
+
+    def test_default_assembled_document_id(self) -> None:
+        """Test Assembly with default assembled_document_id (None)."""
+        assembly = AssemblyFactory.build(assembled_document_id=None)
+        assert assembly.assembled_document_id is None
+
+    def test_valid_assembled_document_id(self) -> None:
+        """Test Assembly with valid assembled document ID."""
+        assembly = AssemblyFactory.build(assembled_document_id="output-doc-123")
+        assert assembly.assembled_document_id == "output-doc-123"
+
+    def test_assembled_document_id_validation(self) -> None:
+        """Test assembled_document_id field validation."""
+        # Valid cases
+        valid_assembly = Assembly(
+            assembly_id="asm-id",
+            assembly_specification_id="spec-id",
+            input_document_id="doc-id",
+            workflow_id="test-workflow-123",
+            assembled_document_id="valid-output-doc",
+        )
+        assert valid_assembly.assembled_document_id == "valid-output-doc"
+
+        # None is valid
+        none_assembly = Assembly(
+            assembly_id="asm-id",
+            assembly_specification_id="spec-id",
+            input_document_id="doc-id",
+            workflow_id="test-workflow-123",
+            assembled_document_id=None,
+        )
+        assert none_assembly.assembled_document_id is None
+
+        # Invalid cases - empty string
+        with pytest.raises(Exception):
+            Assembly(
+                assembly_id="asm-id",
+                assembly_specification_id="spec-id",
+                input_document_id="doc-id",
+                workflow_id="test-workflow-123",
+                assembled_document_id="",
+            )
+
+        # Invalid cases - whitespace only
+        with pytest.raises(Exception):
+            Assembly(
+                assembly_id="asm-id",
+                assembly_specification_id="spec-id",
+                input_document_id="doc-id",
+                workflow_id="test-workflow-123",
+                assembled_document_id="   ",
+            )
+
+    def test_assembled_document_id_trimming(self) -> None:
+        """Test that assembled_document_id is properly trimmed."""
+        assembly = Assembly(
+            assembly_id="asm-id",
+            assembly_specification_id="spec-id",
+            input_document_id="doc-id",
+            workflow_id="test-workflow-123",
+            assembled_document_id="  trim-output-doc  ",
+        )
+        assert assembly.assembled_document_id == "trim-output-doc"
+
+
+class TestAssemblyWorkflowIdValidation:
+    """Test Assembly workflow_id field validation."""
+
+    def test_workflow_id_validation(self) -> None:
+        """Test workflow_id field validation."""
+        # Valid cases
+        valid_assembly = Assembly(
+            assembly_id="asm-id",
+            assembly_specification_id="spec-id",
+            input_document_id="doc-id",
+            workflow_id="valid-workflow-id",
+        )
+        assert valid_assembly.workflow_id == "valid-workflow-id"
+
+        # Invalid cases - empty string
+        with pytest.raises(Exception):
+            Assembly(
+                assembly_id="asm-id",
+                assembly_specification_id="spec-id",
+                input_document_id="doc-id",
+                workflow_id="",
+            )
+
+        # Invalid cases - whitespace only
+        with pytest.raises(Exception):
+            Assembly(
+                assembly_id="asm-id",
+                assembly_specification_id="spec-id",
+                input_document_id="doc-id",
+                workflow_id="   ",
+            )
+
+    def test_workflow_id_trimming(self) -> None:
+        """Test that workflow_id is properly trimmed."""
+        assembly = Assembly(
+            assembly_id="asm-id",
+            assembly_specification_id="spec-id",
+            input_document_id="doc-id",
+            workflow_id="  trim-workflow-id  ",
+        )
+        assert assembly.workflow_id == "trim-workflow-id"
+
+    def test_workflow_id_required(self) -> None:
+        """Test that workflow_id is required."""
+        # workflow_id is required and cannot be omitted
+        with pytest.raises(Exception):
+            Assembly(  # type: ignore[call-arg]
+                assembly_id="asm-id",
+                assembly_specification_id="spec-id",
+                input_document_id="doc-id",
+                # workflow_id is missing - should fail
+            )

julee/domain/models/assembly_specification/__init__.py

@@ -0,0 +1,24 @@
+"""
+Assembly domain package for the Capture, Extract, Assemble, Publish workflow.
+
+This package contains the AssemblySpecification and KnowledgeServiceQuery
+domain objects that work together to define assembly configurations in the
+CEAP workflow.
+
+AssemblySpecification defines document output types (like "meeting minutes")
+with their JSON schemas and applicability rules. KnowledgeServiceQuery defines
+specific extraction operations that can be performed against knowledge
+services to populate the AssemblySpecification's schema.
+"""
+
+from .assembly_specification import (
+    AssemblySpecification,
+    AssemblySpecificationStatus,
+)
+from .knowledge_service_query import KnowledgeServiceQuery
+
+__all__ = [
+    "AssemblySpecification",
+    "AssemblySpecificationStatus",
+    "KnowledgeServiceQuery",
+]

julee/domain/models/assembly_specification/assembly_specification.py

@@ -0,0 +1,172 @@
+"""
+AssemblySpecification domain models for the Capture, Extract, Assemble,
+Publish workflow.
+
+This module contains the AssemblySpecification domain object that represents
+assembly configurations in the CEAP workflow system.
+
+An AssemblySpecification defines a type of document output (like "meeting
+minutes"), includes information about its applicability and and specifies
+which extractors are needed to collect the data for that output.
+
+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, Dict, Any
+from datetime import datetime, timezone
+from enum import Enum
+import jsonschema
+import jsonpointer  # type: ignore
+
+
+class AssemblySpecificationStatus(str, Enum):
+    """Status of an assembly specification configuration."""
+
+    ACTIVE = "active"
+    INACTIVE = "inactive"
+    DRAFT = "draft"
+    DEPRECATED = "deprecated"
+
+
+class AssemblySpecification(BaseModel):
+    """Assembly specification configuration that defines how to assemble
+    documents of a specific type.
+
+    An AssemblySpecification represents a type of document output (like
+    "meeting minutes", "project report", etc.) and defines which extractors
+    should be used to collect the necessary data from source documents.
+
+    The AssemblySpecification does not contain the template itself - templates
+    will be handled separately during the assembly rendering (or publishing?)
+    phase. This separation allows the same AssemblySpecification definition to
+    be used with different templates over time.
+    """
+
+    # Core assembly identification
+    assembly_specification_id: str = Field(
+        description="Unique identifier for this assembly specification"
+    )
+    name: str = Field(description="Human-readable name like 'meeting minutes'")
+    applicability: str = Field(
+        description="Text description identifying to what type of "
+        "information this assembly applies, such as an online transcript "
+        "of a video meeting. This information may be used by knowledge "
+        "service for document-assembly matching"
+    )
+
+    jsonschema: Dict[str, Any] = Field(
+        description="JSON Schema defining the structure of data to be "
+        "extracted for this assembly"
+    )
+
+    # AssemblySpecification configuration
+    status: AssemblySpecificationStatus = AssemblySpecificationStatus.ACTIVE
+    knowledge_service_queries: Dict[str, str] = Field(
+        default_factory=dict,
+        description="Mapping from JSON Pointer paths to "
+        "KnowledgeServiceQuery IDs. Keys are JSON Pointer strings "
+        "(e.g., '/properties/attendees', '') and values are query IDs "
+        "for extracting data for that schema section",
+    )
+
+    # AssemblySpecification metadata
+    version: str = Field(default="0.1.0", description="Assembly definition version")
+    created_at: Optional[datetime] = Field(
+        default_factory=lambda: datetime.now(timezone.utc)
+    )
+    updated_at: Optional[datetime] = Field(
+        default_factory=lambda: datetime.now(timezone.utc)
+    )
+    # May later add a detailed description, change log, additional metadata
+    # Timestamps
+
+    @field_validator("assembly_specification_id")
+    @classmethod
+    def assembly_specification_id_must_not_be_empty(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("AssemblySpecification ID cannot be empty")
+        return v.strip()
+
+    @field_validator("name")
+    @classmethod
+    def name_must_not_be_empty(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("AssemblySpecification name cannot be empty")
+        return v.strip()
+
+    @field_validator("applicability")
+    @classmethod
+    def applicability_must_not_be_empty(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("AssemblySpecification applicability cannot be empty")
+        return v.strip()
+
+    @field_validator("jsonschema")
+    @classmethod
+    def jsonschema_must_be_valid(cls, v: Dict[str, Any]) -> Dict[str, Any]:
+        if not isinstance(v, dict):
+            raise ValueError("JSON Schema must be a dictionary")
+
+        # Basic validation that it looks like a JSON schema
+        if "type" not in v:
+            raise ValueError("JSON Schema must have a 'type' field")
+
+        # Validate that it's a proper JSON Schema using jsonschema library
+        try:
+            jsonschema.Draft7Validator.check_schema(v)
+        except jsonschema.SchemaError as e:
+            raise ValueError(f"Invalid JSON Schema: {e.message}")
+
+        return v
+
+    @field_validator("knowledge_service_queries")
+    @classmethod
+    def knowledge_service_queries_must_be_valid(
+        cls, v: Dict[str, str], info: Any
+    ) -> Dict[str, str]:
+        if not isinstance(v, dict):
+            raise ValueError("Knowledge service queries must be a dictionary")
+
+        # Get the jsonschema field value to validate pointers against it
+        jsonschema_value = info.data.get("jsonschema")
+        if not jsonschema_value:
+            raise ValueError("Cannot validate schema pointers without jsonschema field")
+
+        cleaned_queries = {}
+        for schema_pointer, query_id in v.items():
+            # Validate schema pointer keys are strings
+            if not isinstance(schema_pointer, str):
+                raise ValueError("Schema pointer keys must be strings")
+
+            # Validate JSON Pointer format and that it exists in the schema
+            try:
+                if schema_pointer == "":
+                    # Empty string is valid - refers to root of schema
+                    pass
+                else:
+                    # Use jsonpointer to validate format and existence
+                    ptr = jsonpointer.JsonPointer(schema_pointer)
+                    ptr.resolve(jsonschema_value)
+            except jsonpointer.JsonPointerException as e:
+                raise ValueError(f"Invalid JSON Pointer '{schema_pointer}': {e}")
+            except (KeyError, IndexError, TypeError):
+                raise ValueError(
+                    f"JSON Pointer '{schema_pointer}' does not exist in " f"schema"
+                )
+
+            # Validate query ID values
+            if not isinstance(query_id, str) or not query_id.strip():
+                raise ValueError("Query ID values must be non-empty strings")
+
+            cleaned_queries[schema_pointer] = query_id.strip()
+
+        return cleaned_queries
+
+    @field_validator("version")
+    @classmethod
+    def version_must_not_be_empty(cls, v: str) -> str:
+        if not v or not v.strip():
+            raise ValueError("AssemblySpecification version cannot be empty")
+        return v.strip()