julee 0.1.4__py3-none-any.whl → 0.1.6__py3-none-any.whl

julee/docs/sphinx_hcd/tests/domain/models/test_integration.py

@@ -0,0 +1,327 @@
+"""Tests for Integration domain model."""
+
+import pytest
+from pydantic import ValidationError
+
+from julee.docs.sphinx_hcd.domain.models.integration import (
+    Direction,
+    ExternalDependency,
+    Integration,
+)
+
+
+class TestDirection:
+    """Test Direction enum."""
+
+    def test_direction_values(self) -> None:
+        """Test Direction enum values."""
+        assert Direction.INBOUND.value == "inbound"
+        assert Direction.OUTBOUND.value == "outbound"
+        assert Direction.BIDIRECTIONAL.value == "bidirectional"
+
+    def test_from_string_valid(self) -> None:
+        """Test from_string with valid values."""
+        assert Direction.from_string("inbound") == Direction.INBOUND
+        assert Direction.from_string("outbound") == Direction.OUTBOUND
+        assert Direction.from_string("bidirectional") == Direction.BIDIRECTIONAL
+
+    def test_from_string_case_insensitive(self) -> None:
+        """Test from_string is case-insensitive."""
+        assert Direction.from_string("INBOUND") == Direction.INBOUND
+        assert Direction.from_string("Outbound") == Direction.OUTBOUND
+
+    def test_from_string_unknown(self) -> None:
+        """Test from_string defaults to BIDIRECTIONAL for invalid values."""
+        assert Direction.from_string("invalid") == Direction.BIDIRECTIONAL
+        assert Direction.from_string("") == Direction.BIDIRECTIONAL
+
+    def test_direction_labels(self) -> None:
+        """Test direction label property."""
+        assert Direction.INBOUND.label == "Inbound (data source)"
+        assert Direction.OUTBOUND.label == "Outbound (data sink)"
+        assert Direction.BIDIRECTIONAL.label == "Bidirectional"
+
+
+class TestExternalDependency:
+    """Test ExternalDependency model."""
+
+    def test_create_with_name_only(self) -> None:
+        """Test creating with just name."""
+        dep = ExternalDependency(name="External API")
+        assert dep.name == "External API"
+        assert dep.url is None
+        assert dep.description == ""
+
+    def test_create_with_all_fields(self) -> None:
+        """Test creating with all fields."""
+        dep = ExternalDependency(
+            name="External API",
+            url="https://api.example.com",
+            description="Third party API",
+        )
+        assert dep.name == "External API"
+        assert dep.url == "https://api.example.com"
+        assert dep.description == "Third party API"
+
+    def test_empty_name_raises_error(self) -> None:
+        """Test that empty name raises validation error."""
+        with pytest.raises(ValidationError, match="name cannot be empty"):
+            ExternalDependency(name="")
+
+    def test_from_dict_complete(self) -> None:
+        """Test from_dict with complete data."""
+        data = {
+            "name": "External API",
+            "url": "https://api.example.com",
+            "description": "Third party API",
+        }
+        dep = ExternalDependency.from_dict(data)
+        assert dep.name == "External API"
+        assert dep.url == "https://api.example.com"
+
+    def test_from_dict_minimal(self) -> None:
+        """Test from_dict with minimal data."""
+        data = {"name": "Simple API"}
+        dep = ExternalDependency.from_dict(data)
+        assert dep.name == "Simple API"
+        assert dep.url is None
+
+
+class TestIntegrationCreation:
+    """Test Integration model creation and validation."""
+
+    def test_create_with_required_fields(self) -> None:
+        """Test creating with minimum required fields."""
+        integration = Integration(
+            slug="data-sync",
+            module="data_sync",
+            name="Data Sync",
+        )
+
+        assert integration.slug == "data-sync"
+        assert integration.module == "data_sync"
+        assert integration.name == "Data Sync"
+        assert integration.direction == Direction.BIDIRECTIONAL
+        assert integration.depends_on == []
+
+    def test_create_with_all_fields(self) -> None:
+        """Test creating with all fields."""
+        deps = [ExternalDependency(name="AWS S3", url="https://aws.amazon.com/s3")]
+        integration = Integration(
+            slug="data-sync",
+            module="data_sync",
+            name="Data Sync",
+            description="Synchronizes data with external systems",
+            direction=Direction.OUTBOUND,
+            depends_on=deps,
+            manifest_path="/path/to/integration.yaml",
+        )
+
+        assert integration.slug == "data-sync"
+        assert integration.direction == Direction.OUTBOUND
+        assert len(integration.depends_on) == 1
+        assert integration.depends_on[0].name == "AWS S3"
+
+    def test_name_normalized_computed(self) -> None:
+        """Test that name_normalized is computed."""
+        integration = Integration(
+            slug="data-sync",
+            module="data_sync",
+            name="Data Sync Service",
+        )
+        assert integration.name_normalized == "data sync service"
+
+    def test_empty_slug_raises_error(self) -> None:
+        """Test that empty slug raises validation error."""
+        with pytest.raises(ValidationError, match="slug cannot be empty"):
+            Integration(slug="", module="test", name="Test")
+
+    def test_empty_module_raises_error(self) -> None:
+        """Test that empty module raises validation error."""
+        with pytest.raises(ValidationError, match="module cannot be empty"):
+            Integration(slug="test", module="", name="Test")
+
+    def test_empty_name_raises_error(self) -> None:
+        """Test that empty name raises validation error."""
+        with pytest.raises(ValidationError, match="name cannot be empty"):
+            Integration(slug="test", module="test", name="")
+
+
+class TestIntegrationFromManifest:
+    """Test Integration.from_manifest factory method."""
+
+    def test_from_manifest_complete(self) -> None:
+        """Test creating from complete manifest."""
+        manifest = {
+            "slug": "pilot-data",
+            "name": "Pilot Data Collection",
+            "description": "Collects pilot data",
+            "direction": "inbound",
+            "depends_on": [
+                {"name": "Pilot API", "url": "https://pilot.example.com"},
+                {"name": "Data Lake"},
+            ],
+        }
+
+        integration = Integration.from_manifest(
+            module_name="pilot_data_collection",
+            manifest=manifest,
+            manifest_path="/integrations/pilot_data_collection/integration.yaml",
+        )
+
+        assert integration.slug == "pilot-data"
+        assert integration.module == "pilot_data_collection"
+        assert integration.name == "Pilot Data Collection"
+        assert integration.direction == Direction.INBOUND
+        assert len(integration.depends_on) == 2
+        assert integration.depends_on[0].name == "Pilot API"
+        assert integration.depends_on[0].url == "https://pilot.example.com"
+
+    def test_from_manifest_default_slug(self) -> None:
+        """Test default slug from module name."""
+        manifest = {"name": "Test Integration"}
+
+        integration = Integration.from_manifest(
+            module_name="my_integration",
+            manifest=manifest,
+            manifest_path="/path/to/integration.yaml",
+        )
+
+        assert integration.slug == "my-integration"
+
+    def test_from_manifest_default_name(self) -> None:
+        """Test default name from slug."""
+        manifest = {}
+
+        integration = Integration.from_manifest(
+            module_name="data_sync",
+            manifest=manifest,
+            manifest_path="/path/to/integration.yaml",
+        )
+
+        assert integration.name == "Data Sync"
+
+    def test_from_manifest_default_direction(self) -> None:
+        """Test default direction is bidirectional."""
+        manifest = {"name": "Test"}
+
+        integration = Integration.from_manifest(
+            module_name="test",
+            manifest=manifest,
+            manifest_path="/path/to/integration.yaml",
+        )
+
+        assert integration.direction == Direction.BIDIRECTIONAL
+
+    def test_from_manifest_string_dependency(self) -> None:
+        """Test parsing simple string dependencies."""
+        manifest = {
+            "name": "Test",
+            "depends_on": ["Simple Dep"],
+        }
+
+        integration = Integration.from_manifest(
+            module_name="test",
+            manifest=manifest,
+            manifest_path="/path/to/integration.yaml",
+        )
+
+        assert len(integration.depends_on) == 1
+        assert integration.depends_on[0].name == "Simple Dep"
+
+
+class TestIntegrationMatching:
+    """Test Integration matching methods."""
+
+    @pytest.fixture
+    def sample_integration(self) -> Integration:
+        """Create a sample integration for testing."""
+        return Integration(
+            slug="data-sync",
+            module="data_sync",
+            name="Data Sync Service",
+            direction=Direction.OUTBOUND,
+            depends_on=[
+                ExternalDependency(name="AWS S3"),
+                ExternalDependency(name="External API"),
+            ],
+        )
+
+    def test_matches_direction_with_enum(self, sample_integration: Integration) -> None:
+        """Test direction matching with enum."""
+        assert sample_integration.matches_direction(Direction.OUTBOUND) is True
+        assert sample_integration.matches_direction(Direction.INBOUND) is False
+
+    def test_matches_direction_with_string(
+        self, sample_integration: Integration
+    ) -> None:
+        """Test direction matching with string."""
+        assert sample_integration.matches_direction("outbound") is True
+        assert sample_integration.matches_direction("inbound") is False
+
+    def test_matches_name_exact(self, sample_integration: Integration) -> None:
+        """Test name matching with exact name."""
+        assert sample_integration.matches_name("Data Sync Service") is True
+
+    def test_matches_name_case_insensitive(
+        self, sample_integration: Integration
+    ) -> None:
+        """Test name matching is case-insensitive."""
+        assert sample_integration.matches_name("data sync service") is True
+
+    def test_has_dependency(self, sample_integration: Integration) -> None:
+        """Test checking for dependency."""
+        assert sample_integration.has_dependency("AWS S3") is True
+        assert sample_integration.has_dependency("aws s3") is True
+        assert sample_integration.has_dependency("Unknown") is False
+
+
+class TestIntegrationProperties:
+    """Test Integration properties."""
+
+    def test_direction_label(self) -> None:
+        """Test direction_label property."""
+        integration = Integration(
+            slug="test",
+            module="test",
+            name="Test",
+            direction=Direction.INBOUND,
+        )
+        assert integration.direction_label == "Inbound (data source)"
+
+    def test_module_path(self) -> None:
+        """Test module_path property."""
+        integration = Integration(
+            slug="test",
+            module="my_module",
+            name="Test",
+        )
+        assert integration.module_path == "integrations.my_module"
+
+
+class TestIntegrationSerialization:
+    """Test Integration serialization."""
+
+    def test_integration_to_dict(self) -> None:
+        """Test integration can be serialized to dict."""
+        integration = Integration(
+            slug="test",
+            module="test",
+            name="Test",
+            direction=Direction.INBOUND,
+        )
+
+        data = integration.model_dump()
+        assert data["slug"] == "test"
+        assert data["direction"] == Direction.INBOUND
+
+    def test_integration_to_json(self) -> None:
+        """Test integration can be serialized to JSON."""
+        integration = Integration(
+            slug="test",
+            module="test",
+            name="Test",
+        )
+
+        json_str = integration.model_dump_json()
+        assert '"slug":"test"' in json_str

julee/docs/sphinx_hcd/tests/domain/models/test_journey.py

@@ -0,0 +1,249 @@
+"""Tests for Journey domain model."""
+
+import pytest
+from pydantic import ValidationError
+
+from julee.docs.sphinx_hcd.domain.models.journey import (
+    Journey,
+    JourneyStep,
+    StepType,
+)
+
+
+class TestStepType:
+    """Test StepType enum."""
+
+    def test_step_type_values(self) -> None:
+        """Test StepType enum values."""
+        assert StepType.STORY.value == "story"
+        assert StepType.EPIC.value == "epic"
+        assert StepType.PHASE.value == "phase"
+
+    def test_from_string_valid(self) -> None:
+        """Test from_string with valid values."""
+        assert StepType.from_string("story") == StepType.STORY
+        assert StepType.from_string("epic") == StepType.EPIC
+        assert StepType.from_string("phase") == StepType.PHASE
+
+    def test_from_string_case_insensitive(self) -> None:
+        """Test from_string is case-insensitive."""
+        assert StepType.from_string("STORY") == StepType.STORY
+        assert StepType.from_string("Epic") == StepType.EPIC
+
+    def test_from_string_invalid(self) -> None:
+        """Test from_string raises for invalid values."""
+        with pytest.raises(ValueError, match="Invalid step type"):
+            StepType.from_string("invalid")
+
+
+class TestJourneyStep:
+    """Test JourneyStep model."""
+
+    def test_create_story_step(self) -> None:
+        """Test creating a story step."""
+        step = JourneyStep(step_type=StepType.STORY, ref="Upload Document")
+        assert step.step_type == StepType.STORY
+        assert step.ref == "Upload Document"
+        assert step.is_story is True
+        assert step.is_epic is False
+        assert step.is_phase is False
+
+    def test_create_epic_step(self) -> None:
+        """Test creating an epic step."""
+        step = JourneyStep(step_type=StepType.EPIC, ref="vocabulary-management")
+        assert step.step_type == StepType.EPIC
+        assert step.ref == "vocabulary-management"
+        assert step.is_epic is True
+
+    def test_create_phase_step(self) -> None:
+        """Test creating a phase step with description."""
+        step = JourneyStep(
+            step_type=StepType.PHASE,
+            ref="Upload Sources",
+            description="Add reference materials to the knowledge base.",
+        )
+        assert step.step_type == StepType.PHASE
+        assert step.ref == "Upload Sources"
+        assert step.description == "Add reference materials to the knowledge base."
+        assert step.is_phase is True
+
+    def test_empty_ref_raises_error(self) -> None:
+        """Test that empty ref raises validation error."""
+        with pytest.raises(ValidationError, match="ref cannot be empty"):
+            JourneyStep(step_type=StepType.STORY, ref="")
+
+    def test_story_factory(self) -> None:
+        """Test story factory method."""
+        step = JourneyStep.story("Upload Document")
+        assert step.step_type == StepType.STORY
+        assert step.ref == "Upload Document"
+
+    def test_epic_factory(self) -> None:
+        """Test epic factory method."""
+        step = JourneyStep.epic("vocabulary-management")
+        assert step.step_type == StepType.EPIC
+        assert step.ref == "vocabulary-management"
+
+    def test_phase_factory(self) -> None:
+        """Test phase factory method."""
+        step = JourneyStep.phase("Upload Sources", "Add materials.")
+        assert step.step_type == StepType.PHASE
+        assert step.ref == "Upload Sources"
+        assert step.description == "Add materials."
+
+    def test_phase_factory_without_description(self) -> None:
+        """Test phase factory without description."""
+        step = JourneyStep.phase("Upload Sources")
+        assert step.description == ""
+
+
+class TestJourneyCreation:
+    """Test Journey model creation and validation."""
+
+    def test_create_journey_minimal(self) -> None:
+        """Test creating a journey with minimum fields."""
+        journey = Journey(slug="build-vocabulary")
+        assert journey.slug == "build-vocabulary"
+        assert journey.persona == ""
+        assert journey.steps == []
+        assert journey.depends_on == []
+
+    def test_create_journey_complete(self) -> None:
+        """Test creating a journey with all fields."""
+        steps = [
+            JourneyStep.story("Upload Document"),
+            JourneyStep.epic("vocabulary-management"),
+        ]
+        journey = Journey(
+            slug="build-vocabulary",
+            persona="Knowledge Curator",
+            intent="Ensure consistent terminology across programs",
+            outcome="Semantic interoperability enabling compliance mapping",
+            goal="Create a Sustainable Vocabulary Catalog",
+            depends_on=["operate-pipelines", "setup-system"],
+            steps=steps,
+            preconditions=["Source materials available", "SME accessible"],
+            postconditions=["SVC published and versioned"],
+            docname="journeys/build-vocabulary",
+        )
+
+        assert journey.slug == "build-vocabulary"
+        assert journey.persona == "Knowledge Curator"
+        assert journey.persona_normalized == "knowledge curator"
+        assert journey.intent == "Ensure consistent terminology across programs"
+        assert len(journey.steps) == 2
+        assert len(journey.depends_on) == 2
+        assert journey.docname == "journeys/build-vocabulary"
+
+    def test_persona_normalized_computed(self) -> None:
+        """Test that persona_normalized is computed."""
+        journey = Journey(slug="test", persona="Knowledge Curator")
+        assert journey.persona_normalized == "knowledge curator"
+
+    def test_empty_slug_raises_error(self) -> None:
+        """Test that empty slug raises validation error."""
+        with pytest.raises(ValidationError, match="slug cannot be empty"):
+            Journey(slug="")
+
+
+class TestJourneyMatching:
+    """Test Journey matching methods."""
+
+    @pytest.fixture
+    def sample_journey(self) -> Journey:
+        """Create a sample journey for testing."""
+        return Journey(
+            slug="build-vocabulary",
+            persona="Knowledge Curator",
+            depends_on=["operate-pipelines", "setup-system"],
+            steps=[
+                JourneyStep.story("Upload Document"),
+                JourneyStep.epic("vocabulary-management"),
+                JourneyStep.story("Review Vocabulary"),
+            ],
+        )
+
+    def test_matches_persona_exact(self, sample_journey: Journey) -> None:
+        """Test persona matching with exact name."""
+        assert sample_journey.matches_persona("Knowledge Curator") is True
+
+    def test_matches_persona_case_insensitive(self, sample_journey: Journey) -> None:
+        """Test persona matching is case-insensitive."""
+        assert sample_journey.matches_persona("knowledge curator") is True
+        assert sample_journey.matches_persona("KNOWLEDGE CURATOR") is True
+
+    def test_matches_persona_no_match(self, sample_journey: Journey) -> None:
+        """Test persona matching returns False for non-match."""
+        assert sample_journey.matches_persona("Analyst") is False
+
+    def test_has_dependency(self, sample_journey: Journey) -> None:
+        """Test dependency checking."""
+        assert sample_journey.has_dependency("operate-pipelines") is True
+        assert sample_journey.has_dependency("setup-system") is True
+        assert sample_journey.has_dependency("unknown") is False
+
+    def test_get_story_refs(self, sample_journey: Journey) -> None:
+        """Test getting story references."""
+        refs = sample_journey.get_story_refs()
+        assert refs == ["Upload Document", "Review Vocabulary"]
+
+    def test_get_epic_refs(self, sample_journey: Journey) -> None:
+        """Test getting epic references."""
+        refs = sample_journey.get_epic_refs()
+        assert refs == ["vocabulary-management"]
+
+
+class TestJourneySteps:
+    """Test Journey step operations."""
+
+    def test_add_step(self) -> None:
+        """Test adding a step."""
+        journey = Journey(slug="test")
+        assert journey.step_count == 0
+
+        journey.add_step(JourneyStep.story("Test Story"))
+        assert journey.step_count == 1
+        assert journey.has_steps is True
+
+    def test_has_steps_empty(self) -> None:
+        """Test has_steps with empty journey."""
+        journey = Journey(slug="test")
+        assert journey.has_steps is False
+
+
+class TestJourneyProperties:
+    """Test Journey properties."""
+
+    def test_display_title(self) -> None:
+        """Test display_title property."""
+        journey = Journey(slug="build-vocabulary")
+        assert journey.display_title == "Build Vocabulary"
+
+    def test_display_title_multiple_words(self) -> None:
+        """Test display_title with multiple hyphens."""
+        journey = Journey(slug="operate-data-pipelines")
+        assert journey.display_title == "Operate Data Pipelines"
+
+
+class TestJourneySerialization:
+    """Test Journey serialization."""
+
+    def test_journey_to_dict(self) -> None:
+        """Test journey can be serialized to dict."""
+        journey = Journey(
+            slug="test",
+            persona="User",
+            steps=[JourneyStep.story("Test Story")],
+        )
+
+        data = journey.model_dump()
+        assert data["slug"] == "test"
+        assert data["persona"] == "User"
+        assert len(data["steps"]) == 1
+        assert data["steps"][0]["step_type"] == StepType.STORY
+
+    def test_journey_to_json(self) -> None:
+        """Test journey can be serialized to JSON."""
+        journey = Journey(slug="test", persona="User")
+        json_str = journey.model_dump_json()
+        assert '"slug":"test"' in json_str