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

julee/docs/sphinx_hcd/tests/repositories/test_integration.py

@@ -0,0 +1,268 @@
+"""Tests for MemoryIntegrationRepository."""
+
+import pytest
+import pytest_asyncio
+
+from julee.docs.sphinx_hcd.domain.models.integration import (
+    Direction,
+    ExternalDependency,
+    Integration,
+)
+from julee.docs.sphinx_hcd.repositories.memory.integration import (
+    MemoryIntegrationRepository,
+)
+
+
+def create_integration(
+    slug: str = "test-integration",
+    module: str = "test_integration",
+    name: str = "Test Integration",
+    direction: Direction = Direction.BIDIRECTIONAL,
+    depends_on: list[ExternalDependency] | None = None,
+) -> Integration:
+    """Helper to create test integrations."""
+    return Integration(
+        slug=slug,
+        module=module,
+        name=name,
+        direction=direction,
+        depends_on=depends_on or [],
+        manifest_path=f"integrations/{module}/integration.yaml",
+    )
+
+
+class TestMemoryIntegrationRepositoryBasicOperations:
+    """Test basic CRUD operations."""
+
+    @pytest.fixture
+    def repo(self) -> MemoryIntegrationRepository:
+        """Create a fresh repository."""
+        return MemoryIntegrationRepository()
+
+    @pytest.mark.asyncio
+    async def test_save_and_get(self, repo: MemoryIntegrationRepository) -> None:
+        """Test saving and retrieving an integration."""
+        integration = create_integration(slug="data-sync")
+        await repo.save(integration)
+
+        retrieved = await repo.get("data-sync")
+        assert retrieved is not None
+        assert retrieved.slug == "data-sync"
+
+    @pytest.mark.asyncio
+    async def test_get_nonexistent(self, repo: MemoryIntegrationRepository) -> None:
+        """Test getting a nonexistent integration returns None."""
+        result = await repo.get("nonexistent")
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_list_all(self, repo: MemoryIntegrationRepository) -> None:
+        """Test listing all integrations."""
+        await repo.save(create_integration(slug="int-1", module="int_1"))
+        await repo.save(create_integration(slug="int-2", module="int_2"))
+        await repo.save(create_integration(slug="int-3", module="int_3"))
+
+        all_integrations = await repo.list_all()
+        assert len(all_integrations) == 3
+        slugs = {i.slug for i in all_integrations}
+        assert slugs == {"int-1", "int-2", "int-3"}
+
+    @pytest.mark.asyncio
+    async def test_delete(self, repo: MemoryIntegrationRepository) -> None:
+        """Test deleting an integration."""
+        await repo.save(create_integration(slug="to-delete", module="to_delete"))
+        assert await repo.get("to-delete") is not None
+
+        result = await repo.delete("to-delete")
+        assert result is True
+        assert await repo.get("to-delete") is None
+
+    @pytest.mark.asyncio
+    async def test_delete_nonexistent(self, repo: MemoryIntegrationRepository) -> None:
+        """Test deleting a nonexistent integration."""
+        result = await repo.delete("nonexistent")
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_clear(self, repo: MemoryIntegrationRepository) -> None:
+        """Test clearing all integrations."""
+        await repo.save(create_integration(slug="int-1", module="int_1"))
+        await repo.save(create_integration(slug="int-2", module="int_2"))
+        assert len(await repo.list_all()) == 2
+
+        await repo.clear()
+        assert len(await repo.list_all()) == 0
+
+
+class TestMemoryIntegrationRepositoryQueries:
+    """Test integration-specific query methods."""
+
+    @pytest.fixture
+    def repo(self) -> MemoryIntegrationRepository:
+        """Create a repository."""
+        return MemoryIntegrationRepository()
+
+    @pytest_asyncio.fixture
+    async def populated_repo(
+        self, repo: MemoryIntegrationRepository
+    ) -> MemoryIntegrationRepository:
+        """Create a repository with sample integrations."""
+        integrations = [
+            create_integration(
+                slug="pilot-data",
+                module="pilot_data",
+                name="Pilot Data Collection",
+                direction=Direction.INBOUND,
+                depends_on=[ExternalDependency(name="Pilot API")],
+            ),
+            create_integration(
+                slug="analytics-export",
+                module="analytics_export",
+                name="Analytics Export",
+                direction=Direction.OUTBOUND,
+                depends_on=[
+                    ExternalDependency(name="AWS S3"),
+                    ExternalDependency(name="Analytics Service"),
+                ],
+            ),
+            create_integration(
+                slug="data-sync",
+                module="data_sync",
+                name="Data Sync",
+                direction=Direction.BIDIRECTIONAL,
+                depends_on=[ExternalDependency(name="AWS S3")],
+            ),
+            create_integration(
+                slug="notifications",
+                module="notifications",
+                name="Notifications",
+                direction=Direction.OUTBOUND,
+            ),
+            create_integration(
+                slug="file-import",
+                module="file_import",
+                name="File Import",
+                direction=Direction.INBOUND,
+            ),
+        ]
+        for integration in integrations:
+            await repo.save(integration)
+        return repo
+
+    @pytest.mark.asyncio
+    async def test_get_by_direction_inbound(
+        self, populated_repo: MemoryIntegrationRepository
+    ) -> None:
+        """Test getting inbound integrations."""
+        integrations = await populated_repo.get_by_direction(Direction.INBOUND)
+        assert len(integrations) == 2
+        assert all(i.direction == Direction.INBOUND for i in integrations)
+
+    @pytest.mark.asyncio
+    async def test_get_by_direction_outbound(
+        self, populated_repo: MemoryIntegrationRepository
+    ) -> None:
+        """Test getting outbound integrations."""
+        integrations = await populated_repo.get_by_direction(Direction.OUTBOUND)
+        assert len(integrations) == 2
+        assert all(i.direction == Direction.OUTBOUND for i in integrations)
+
+    @pytest.mark.asyncio
+    async def test_get_by_direction_bidirectional(
+        self, populated_repo: MemoryIntegrationRepository
+    ) -> None:
+        """Test getting bidirectional integrations."""
+        integrations = await populated_repo.get_by_direction(Direction.BIDIRECTIONAL)
+        assert len(integrations) == 1
+        assert integrations[0].slug == "data-sync"
+
+    @pytest.mark.asyncio
+    async def test_get_by_module(
+        self, populated_repo: MemoryIntegrationRepository
+    ) -> None:
+        """Test getting integration by module name."""
+        integration = await populated_repo.get_by_module("pilot_data")
+        assert integration is not None
+        assert integration.slug == "pilot-data"
+
+    @pytest.mark.asyncio
+    async def test_get_by_module_not_found(
+        self, populated_repo: MemoryIntegrationRepository
+    ) -> None:
+        """Test getting integration by nonexistent module."""
+        integration = await populated_repo.get_by_module("nonexistent")
+        assert integration is None
+
+    @pytest.mark.asyncio
+    async def test_get_by_name(
+        self, populated_repo: MemoryIntegrationRepository
+    ) -> None:
+        """Test getting integration by name."""
+        integration = await populated_repo.get_by_name("Pilot Data Collection")
+        assert integration is not None
+        assert integration.slug == "pilot-data"
+
+    @pytest.mark.asyncio
+    async def test_get_by_name_case_insensitive(
+        self, populated_repo: MemoryIntegrationRepository
+    ) -> None:
+        """Test name matching is case-insensitive."""
+        integration = await populated_repo.get_by_name("pilot data collection")
+        assert integration is not None
+        assert integration.slug == "pilot-data"
+
+    @pytest.mark.asyncio
+    async def test_get_by_name_not_found(
+        self, populated_repo: MemoryIntegrationRepository
+    ) -> None:
+        """Test getting integration by nonexistent name."""
+        integration = await populated_repo.get_by_name("Nonexistent Integration")
+        assert integration is None
+
+    @pytest.mark.asyncio
+    async def test_get_all_directions(
+        self, populated_repo: MemoryIntegrationRepository
+    ) -> None:
+        """Test getting all unique directions."""
+        directions = await populated_repo.get_all_directions()
+        assert directions == {
+            Direction.INBOUND,
+            Direction.OUTBOUND,
+            Direction.BIDIRECTIONAL,
+        }
+
+    @pytest.mark.asyncio
+    async def test_get_with_dependencies(
+        self, populated_repo: MemoryIntegrationRepository
+    ) -> None:
+        """Test getting integrations with dependencies."""
+        integrations = await populated_repo.get_with_dependencies()
+        assert len(integrations) == 3
+        slugs = {i.slug for i in integrations}
+        assert slugs == {"pilot-data", "analytics-export", "data-sync"}
+
+    @pytest.mark.asyncio
+    async def test_get_by_dependency(
+        self, populated_repo: MemoryIntegrationRepository
+    ) -> None:
+        """Test getting integrations by dependency name."""
+        integrations = await populated_repo.get_by_dependency("AWS S3")
+        assert len(integrations) == 2
+        slugs = {i.slug for i in integrations}
+        assert slugs == {"analytics-export", "data-sync"}
+
+    @pytest.mark.asyncio
+    async def test_get_by_dependency_case_insensitive(
+        self, populated_repo: MemoryIntegrationRepository
+    ) -> None:
+        """Test dependency matching is case-insensitive."""
+        integrations = await populated_repo.get_by_dependency("aws s3")
+        assert len(integrations) == 2
+
+    @pytest.mark.asyncio
+    async def test_get_by_dependency_not_found(
+        self, populated_repo: MemoryIntegrationRepository
+    ) -> None:
+        """Test getting integrations by nonexistent dependency."""
+        integrations = await populated_repo.get_by_dependency("Unknown Service")
+        assert len(integrations) == 0

julee/docs/sphinx_hcd/tests/repositories/test_journey.py

@@ -0,0 +1,294 @@
+"""Tests for MemoryJourneyRepository."""
+
+import pytest
+import pytest_asyncio
+
+from julee.docs.sphinx_hcd.domain.models.journey import Journey, JourneyStep
+from julee.docs.sphinx_hcd.repositories.memory.journey import MemoryJourneyRepository
+
+
+def create_journey(
+    slug: str = "test-journey",
+    persona: str = "User",
+    docname: str = "journeys/test",
+    depends_on: list[str] | None = None,
+    steps: list[JourneyStep] | None = None,
+) -> Journey:
+    """Helper to create test journeys."""
+    return Journey(
+        slug=slug,
+        persona=persona,
+        docname=docname,
+        depends_on=depends_on or [],
+        steps=steps or [],
+    )
+
+
+class TestMemoryJourneyRepositoryBasicOperations:
+    """Test basic CRUD operations."""
+
+    @pytest.fixture
+    def repo(self) -> MemoryJourneyRepository:
+        """Create a fresh repository."""
+        return MemoryJourneyRepository()
+
+    @pytest.mark.asyncio
+    async def test_save_and_get(self, repo: MemoryJourneyRepository) -> None:
+        """Test saving and retrieving a journey."""
+        journey = create_journey(slug="build-vocabulary")
+        await repo.save(journey)
+
+        retrieved = await repo.get("build-vocabulary")
+        assert retrieved is not None
+        assert retrieved.slug == "build-vocabulary"
+
+    @pytest.mark.asyncio
+    async def test_get_nonexistent(self, repo: MemoryJourneyRepository) -> None:
+        """Test getting a nonexistent journey returns None."""
+        result = await repo.get("nonexistent")
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_list_all(self, repo: MemoryJourneyRepository) -> None:
+        """Test listing all journeys."""
+        await repo.save(create_journey(slug="journey-1"))
+        await repo.save(create_journey(slug="journey-2"))
+        await repo.save(create_journey(slug="journey-3"))
+
+        all_journeys = await repo.list_all()
+        assert len(all_journeys) == 3
+        slugs = {j.slug for j in all_journeys}
+        assert slugs == {"journey-1", "journey-2", "journey-3"}
+
+    @pytest.mark.asyncio
+    async def test_delete(self, repo: MemoryJourneyRepository) -> None:
+        """Test deleting a journey."""
+        await repo.save(create_journey(slug="to-delete"))
+        assert await repo.get("to-delete") is not None
+
+        result = await repo.delete("to-delete")
+        assert result is True
+        assert await repo.get("to-delete") is None
+
+    @pytest.mark.asyncio
+    async def test_delete_nonexistent(self, repo: MemoryJourneyRepository) -> None:
+        """Test deleting a nonexistent journey."""
+        result = await repo.delete("nonexistent")
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_clear(self, repo: MemoryJourneyRepository) -> None:
+        """Test clearing all journeys."""
+        await repo.save(create_journey(slug="journey-1"))
+        await repo.save(create_journey(slug="journey-2"))
+        assert len(await repo.list_all()) == 2
+
+        await repo.clear()
+        assert len(await repo.list_all()) == 0
+
+
+class TestMemoryJourneyRepositoryQueries:
+    """Test journey-specific query methods."""
+
+    @pytest.fixture
+    def repo(self) -> MemoryJourneyRepository:
+        """Create a repository."""
+        return MemoryJourneyRepository()
+
+    @pytest_asyncio.fixture
+    async def populated_repo(
+        self, repo: MemoryJourneyRepository
+    ) -> MemoryJourneyRepository:
+        """Create a repository with sample journeys."""
+        journeys = [
+            create_journey(
+                slug="build-vocabulary",
+                persona="Knowledge Curator",
+                docname="journeys/build-vocabulary",
+                depends_on=["operate-pipelines"],
+                steps=[
+                    JourneyStep.story("Upload Document"),
+                    JourneyStep.epic("vocabulary-management"),
+                ],
+            ),
+            create_journey(
+                slug="operate-pipelines",
+                persona="Knowledge Curator",
+                docname="journeys/operate-pipelines",
+                steps=[
+                    JourneyStep.story("Configure Pipeline"),
+                ],
+            ),
+            create_journey(
+                slug="analyze-data",
+                persona="Analyst",
+                docname="journeys/analyze-data",
+                depends_on=["build-vocabulary", "operate-pipelines"],
+                steps=[
+                    JourneyStep.story("Run Analysis"),
+                    JourneyStep.epic("vocabulary-management"),
+                ],
+            ),
+            create_journey(
+                slug="review-results",
+                persona="Analyst",
+                docname="journeys/review-results",
+            ),
+            create_journey(
+                slug="admin-setup",
+                persona="Administrator",
+                docname="journeys/admin-setup",
+            ),
+        ]
+        for journey in journeys:
+            await repo.save(journey)
+        return repo
+
+    @pytest.mark.asyncio
+    async def test_get_by_persona(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test getting journeys by persona."""
+        journeys = await populated_repo.get_by_persona("Knowledge Curator")
+        assert len(journeys) == 2
+        slugs = {j.slug for j in journeys}
+        assert slugs == {"build-vocabulary", "operate-pipelines"}
+
+    @pytest.mark.asyncio
+    async def test_get_by_persona_case_insensitive(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test persona matching is case-insensitive."""
+        journeys = await populated_repo.get_by_persona("knowledge curator")
+        assert len(journeys) == 2
+
+    @pytest.mark.asyncio
+    async def test_get_by_persona_no_results(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test getting journeys for persona with none."""
+        journeys = await populated_repo.get_by_persona("Unknown Persona")
+        assert len(journeys) == 0
+
+    @pytest.mark.asyncio
+    async def test_get_by_docname(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test getting journeys by document name."""
+        journeys = await populated_repo.get_by_docname("journeys/build-vocabulary")
+        assert len(journeys) == 1
+        assert journeys[0].slug == "build-vocabulary"
+
+    @pytest.mark.asyncio
+    async def test_get_by_docname_no_results(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test getting journeys for unknown document."""
+        journeys = await populated_repo.get_by_docname("unknown/document")
+        assert len(journeys) == 0
+
+    @pytest.mark.asyncio
+    async def test_clear_by_docname(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test clearing journeys by document name."""
+        count = await populated_repo.clear_by_docname("journeys/build-vocabulary")
+        assert count == 1
+        assert await populated_repo.get("build-vocabulary") is None
+        # Other journeys should remain
+        assert len(await populated_repo.list_all()) == 4
+
+    @pytest.mark.asyncio
+    async def test_clear_by_docname_none_found(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test clearing non-existent document returns 0."""
+        count = await populated_repo.clear_by_docname("unknown/document")
+        assert count == 0
+
+    @pytest.mark.asyncio
+    async def test_get_dependents(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test getting journeys that depend on a journey."""
+        dependents = await populated_repo.get_dependents("operate-pipelines")
+        assert len(dependents) == 2
+        slugs = {j.slug for j in dependents}
+        assert slugs == {"build-vocabulary", "analyze-data"}
+
+    @pytest.mark.asyncio
+    async def test_get_dependents_none(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test getting dependents for journey with none."""
+        dependents = await populated_repo.get_dependents("admin-setup")
+        assert len(dependents) == 0
+
+    @pytest.mark.asyncio
+    async def test_get_dependencies(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test getting journeys that a journey depends on."""
+        deps = await populated_repo.get_dependencies("analyze-data")
+        assert len(deps) == 2
+        slugs = {j.slug for j in deps}
+        assert slugs == {"build-vocabulary", "operate-pipelines"}
+
+    @pytest.mark.asyncio
+    async def test_get_dependencies_nonexistent_journey(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test getting dependencies for nonexistent journey."""
+        deps = await populated_repo.get_dependencies("nonexistent")
+        assert len(deps) == 0
+
+    @pytest.mark.asyncio
+    async def test_get_all_personas(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test getting all unique personas."""
+        personas = await populated_repo.get_all_personas()
+        assert personas == {"knowledge curator", "analyst", "administrator"}
+
+    @pytest.mark.asyncio
+    async def test_get_with_story_ref(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test getting journeys with a story reference."""
+        journeys = await populated_repo.get_with_story_ref("Upload Document")
+        assert len(journeys) == 1
+        assert journeys[0].slug == "build-vocabulary"
+
+    @pytest.mark.asyncio
+    async def test_get_with_story_ref_case_insensitive(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test story ref matching is case-insensitive."""
+        journeys = await populated_repo.get_with_story_ref("upload document")
+        assert len(journeys) == 1
+
+    @pytest.mark.asyncio
+    async def test_get_with_story_ref_none(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test getting journeys with nonexistent story."""
+        journeys = await populated_repo.get_with_story_ref("Unknown Story")
+        assert len(journeys) == 0
+
+    @pytest.mark.asyncio
+    async def test_get_with_epic_ref(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test getting journeys with an epic reference."""
+        journeys = await populated_repo.get_with_epic_ref("vocabulary-management")
+        assert len(journeys) == 2
+        slugs = {j.slug for j in journeys}
+        assert slugs == {"build-vocabulary", "analyze-data"}
+
+    @pytest.mark.asyncio
+    async def test_get_with_epic_ref_none(
+        self, populated_repo: MemoryJourneyRepository
+    ) -> None:
+        """Test getting journeys with nonexistent epic."""
+        journeys = await populated_repo.get_with_epic_ref("unknown-epic")
+        assert len(journeys) == 0