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

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

@@ -0,0 +1,298 @@
+"""Tests for MemoryAcceleratorRepository."""
+
+import pytest
+import pytest_asyncio
+
+from julee.docs.sphinx_hcd.domain.models.accelerator import (
+    Accelerator,
+    IntegrationReference,
+)
+from julee.docs.sphinx_hcd.repositories.memory.accelerator import (
+    MemoryAcceleratorRepository,
+)
+
+
+def create_accelerator(
+    slug: str = "test-accelerator",
+    status: str = "alpha",
+    docname: str = "accelerators/test",
+    sources_from: list[IntegrationReference] | None = None,
+    publishes_to: list[IntegrationReference] | None = None,
+    feeds_into: list[str] | None = None,
+    depends_on: list[str] | None = None,
+) -> Accelerator:
+    """Helper to create test accelerators."""
+    return Accelerator(
+        slug=slug,
+        status=status,
+        docname=docname,
+        sources_from=sources_from or [],
+        publishes_to=publishes_to or [],
+        feeds_into=feeds_into or [],
+        depends_on=depends_on or [],
+    )
+
+
+class TestMemoryAcceleratorRepositoryBasicOperations:
+    """Test basic CRUD operations."""
+
+    @pytest.fixture
+    def repo(self) -> MemoryAcceleratorRepository:
+        """Create a fresh repository."""
+        return MemoryAcceleratorRepository()
+
+    @pytest.mark.asyncio
+    async def test_save_and_get(self, repo: MemoryAcceleratorRepository) -> None:
+        """Test saving and retrieving an accelerator."""
+        accel = create_accelerator(slug="vocabulary")
+        await repo.save(accel)
+
+        retrieved = await repo.get("vocabulary")
+        assert retrieved is not None
+        assert retrieved.slug == "vocabulary"
+
+    @pytest.mark.asyncio
+    async def test_get_nonexistent(self, repo: MemoryAcceleratorRepository) -> None:
+        """Test getting a nonexistent accelerator returns None."""
+        result = await repo.get("nonexistent")
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_list_all(self, repo: MemoryAcceleratorRepository) -> None:
+        """Test listing all accelerators."""
+        await repo.save(create_accelerator(slug="accel-1"))
+        await repo.save(create_accelerator(slug="accel-2"))
+        await repo.save(create_accelerator(slug="accel-3"))
+
+        all_accels = await repo.list_all()
+        assert len(all_accels) == 3
+        slugs = {a.slug for a in all_accels}
+        assert slugs == {"accel-1", "accel-2", "accel-3"}
+
+    @pytest.mark.asyncio
+    async def test_delete(self, repo: MemoryAcceleratorRepository) -> None:
+        """Test deleting an accelerator."""
+        await repo.save(create_accelerator(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: MemoryAcceleratorRepository) -> None:
+        """Test deleting a nonexistent accelerator."""
+        result = await repo.delete("nonexistent")
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_clear(self, repo: MemoryAcceleratorRepository) -> None:
+        """Test clearing all accelerators."""
+        await repo.save(create_accelerator(slug="accel-1"))
+        await repo.save(create_accelerator(slug="accel-2"))
+        assert len(await repo.list_all()) == 2
+
+        await repo.clear()
+        assert len(await repo.list_all()) == 0
+
+
+class TestMemoryAcceleratorRepositoryQueries:
+    """Test accelerator-specific query methods."""
+
+    @pytest.fixture
+    def repo(self) -> MemoryAcceleratorRepository:
+        """Create a repository."""
+        return MemoryAcceleratorRepository()
+
+    @pytest_asyncio.fixture
+    async def populated_repo(
+        self, repo: MemoryAcceleratorRepository
+    ) -> MemoryAcceleratorRepository:
+        """Create a repository with sample accelerators."""
+        accelerators = [
+            create_accelerator(
+                slug="vocabulary",
+                status="alpha",
+                docname="accelerators/vocabulary",
+                sources_from=[
+                    IntegrationReference(slug="pilot-data", description="Pilot data"),
+                ],
+                publishes_to=[
+                    IntegrationReference(slug="reference-impl", description="SVC"),
+                ],
+                feeds_into=["traceability"],
+                depends_on=["core-infrastructure"],
+            ),
+            create_accelerator(
+                slug="traceability",
+                status="alpha",
+                docname="accelerators/traceability",
+                sources_from=[
+                    IntegrationReference(slug="pilot-data", description="Trace data"),
+                ],
+                depends_on=["vocabulary"],
+            ),
+            create_accelerator(
+                slug="conformity",
+                status="future",
+                docname="accelerators/conformity",
+                depends_on=["vocabulary", "traceability"],
+            ),
+            create_accelerator(
+                slug="core-infrastructure",
+                status="production",
+                docname="accelerators/core",
+            ),
+            create_accelerator(
+                slug="analytics",
+                status="alpha",
+                docname="accelerators/vocabulary",  # Same docname as vocabulary
+            ),
+        ]
+        for accel in accelerators:
+            await repo.save(accel)
+        return repo
+
+    @pytest.mark.asyncio
+    async def test_get_by_status(
+        self, populated_repo: MemoryAcceleratorRepository
+    ) -> None:
+        """Test getting accelerators by status."""
+        accels = await populated_repo.get_by_status("alpha")
+        assert len(accels) == 3
+        slugs = {a.slug for a in accels}
+        assert slugs == {"vocabulary", "traceability", "analytics"}
+
+    @pytest.mark.asyncio
+    async def test_get_by_status_case_insensitive(
+        self, populated_repo: MemoryAcceleratorRepository
+    ) -> None:
+        """Test status matching is case-insensitive."""
+        accels = await populated_repo.get_by_status("ALPHA")
+        assert len(accels) == 3
+
+    @pytest.mark.asyncio
+    async def test_get_by_status_no_results(
+        self, populated_repo: MemoryAcceleratorRepository
+    ) -> None:
+        """Test getting accelerators with unknown status."""
+        accels = await populated_repo.get_by_status("unknown")
+        assert len(accels) == 0
+
+    @pytest.mark.asyncio
+    async def test_get_by_docname(
+        self, populated_repo: MemoryAcceleratorRepository
+    ) -> None:
+        """Test getting accelerators by document name."""
+        accels = await populated_repo.get_by_docname("accelerators/vocabulary")
+        assert len(accels) == 2
+        slugs = {a.slug for a in accels}
+        assert slugs == {"vocabulary", "analytics"}
+
+    @pytest.mark.asyncio
+    async def test_get_by_docname_no_results(
+        self, populated_repo: MemoryAcceleratorRepository
+    ) -> None:
+        """Test getting accelerators for unknown document."""
+        accels = await populated_repo.get_by_docname("unknown/document")
+        assert len(accels) == 0
+
+    @pytest.mark.asyncio
+    async def test_clear_by_docname(
+        self, populated_repo: MemoryAcceleratorRepository
+    ) -> None:
+        """Test clearing accelerators by document name."""
+        count = await populated_repo.clear_by_docname("accelerators/vocabulary")
+        assert count == 2
+        assert await populated_repo.get("vocabulary") is None
+        assert await populated_repo.get("analytics") is None
+        # Other accelerators should remain
+        assert len(await populated_repo.list_all()) == 3
+
+    @pytest.mark.asyncio
+    async def test_clear_by_docname_none_found(
+        self, populated_repo: MemoryAcceleratorRepository
+    ) -> 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_by_integration_sources_from(
+        self, populated_repo: MemoryAcceleratorRepository
+    ) -> None:
+        """Test getting accelerators that source from an integration."""
+        accels = await populated_repo.get_by_integration("pilot-data", "sources_from")
+        assert len(accels) == 2
+        slugs = {a.slug for a in accels}
+        assert slugs == {"vocabulary", "traceability"}
+
+    @pytest.mark.asyncio
+    async def test_get_by_integration_publishes_to(
+        self, populated_repo: MemoryAcceleratorRepository
+    ) -> None:
+        """Test getting accelerators that publish to an integration."""
+        accels = await populated_repo.get_by_integration(
+            "reference-impl", "publishes_to"
+        )
+        assert len(accels) == 1
+        assert accels[0].slug == "vocabulary"
+
+    @pytest.mark.asyncio
+    async def test_get_by_integration_no_results(
+        self, populated_repo: MemoryAcceleratorRepository
+    ) -> None:
+        """Test getting accelerators with unknown integration."""
+        accels = await populated_repo.get_by_integration("unknown", "sources_from")
+        assert len(accels) == 0
+
+    @pytest.mark.asyncio
+    async def test_get_dependents(
+        self, populated_repo: MemoryAcceleratorRepository
+    ) -> None:
+        """Test getting accelerators that depend on another."""
+        dependents = await populated_repo.get_dependents("vocabulary")
+        assert len(dependents) == 2
+        slugs = {a.slug for a in dependents}
+        assert slugs == {"traceability", "conformity"}
+
+    @pytest.mark.asyncio
+    async def test_get_dependents_none(
+        self, populated_repo: MemoryAcceleratorRepository
+    ) -> None:
+        """Test getting dependents for accelerator with none."""
+        dependents = await populated_repo.get_dependents("conformity")
+        assert len(dependents) == 0
+
+    @pytest.mark.asyncio
+    async def test_get_fed_by(
+        self, populated_repo: MemoryAcceleratorRepository
+    ) -> None:
+        """Test getting accelerators that feed into another."""
+        fed_by = await populated_repo.get_fed_by("traceability")
+        assert len(fed_by) == 1
+        assert fed_by[0].slug == "vocabulary"
+
+    @pytest.mark.asyncio
+    async def test_get_fed_by_none(
+        self, populated_repo: MemoryAcceleratorRepository
+    ) -> None:
+        """Test getting fed_by for accelerator with none."""
+        fed_by = await populated_repo.get_fed_by("vocabulary")
+        assert len(fed_by) == 0
+
+    @pytest.mark.asyncio
+    async def test_get_all_statuses(
+        self, populated_repo: MemoryAcceleratorRepository
+    ) -> None:
+        """Test getting all unique statuses."""
+        statuses = await populated_repo.get_all_statuses()
+        assert statuses == {"alpha", "future", "production"}
+
+    @pytest.mark.asyncio
+    async def test_get_all_statuses_empty_repo(
+        self, repo: MemoryAcceleratorRepository
+    ) -> None:
+        """Test getting statuses from empty repository."""
+        statuses = await repo.get_all_statuses()
+        assert statuses == set()

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

@@ -0,0 +1,218 @@
+"""Tests for MemoryAppRepository."""
+
+import pytest
+import pytest_asyncio
+
+from julee.docs.sphinx_hcd.domain.models.app import App, AppType
+from julee.docs.sphinx_hcd.repositories.memory.app import MemoryAppRepository
+
+
+def create_app(
+    slug: str = "test-app",
+    name: str = "Test App",
+    app_type: AppType = AppType.STAFF,
+    status: str | None = None,
+    accelerators: list[str] | None = None,
+) -> App:
+    """Helper to create test apps."""
+    return App(
+        slug=slug,
+        name=name,
+        app_type=app_type,
+        status=status,
+        accelerators=accelerators or [],
+        manifest_path=f"apps/{slug}/app.yaml",
+    )
+
+
+class TestMemoryAppRepositoryBasicOperations:
+    """Test basic CRUD operations."""
+
+    @pytest.fixture
+    def repo(self) -> MemoryAppRepository:
+        """Create a fresh repository."""
+        return MemoryAppRepository()
+
+    @pytest.mark.asyncio
+    async def test_save_and_get(self, repo: MemoryAppRepository) -> None:
+        """Test saving and retrieving an app."""
+        app = create_app(slug="staff-portal")
+        await repo.save(app)
+
+        retrieved = await repo.get("staff-portal")
+        assert retrieved is not None
+        assert retrieved.slug == "staff-portal"
+
+    @pytest.mark.asyncio
+    async def test_get_nonexistent(self, repo: MemoryAppRepository) -> None:
+        """Test getting a nonexistent app returns None."""
+        result = await repo.get("nonexistent")
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_list_all(self, repo: MemoryAppRepository) -> None:
+        """Test listing all apps."""
+        await repo.save(create_app(slug="app-1"))
+        await repo.save(create_app(slug="app-2"))
+        await repo.save(create_app(slug="app-3"))
+
+        all_apps = await repo.list_all()
+        assert len(all_apps) == 3
+        slugs = {a.slug for a in all_apps}
+        assert slugs == {"app-1", "app-2", "app-3"}
+
+    @pytest.mark.asyncio
+    async def test_delete(self, repo: MemoryAppRepository) -> None:
+        """Test deleting an app."""
+        await repo.save(create_app(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: MemoryAppRepository) -> None:
+        """Test deleting a nonexistent app."""
+        result = await repo.delete("nonexistent")
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_clear(self, repo: MemoryAppRepository) -> None:
+        """Test clearing all apps."""
+        await repo.save(create_app(slug="app-1"))
+        await repo.save(create_app(slug="app-2"))
+        assert len(await repo.list_all()) == 2
+
+        await repo.clear()
+        assert len(await repo.list_all()) == 0
+
+
+class TestMemoryAppRepositoryQueries:
+    """Test app-specific query methods."""
+
+    @pytest.fixture
+    def repo(self) -> MemoryAppRepository:
+        """Create a repository with sample data."""
+        return MemoryAppRepository()
+
+    @pytest_asyncio.fixture
+    async def populated_repo(self, repo: MemoryAppRepository) -> MemoryAppRepository:
+        """Create a repository with sample apps."""
+        apps = [
+            create_app(
+                slug="staff-portal",
+                name="Staff Portal",
+                app_type=AppType.STAFF,
+                accelerators=["user-auth", "doc-upload"],
+            ),
+            create_app(
+                slug="admin-tool",
+                name="Admin Tool",
+                app_type=AppType.STAFF,
+                accelerators=["admin-config"],
+            ),
+            create_app(
+                slug="customer-portal",
+                name="Customer Portal",
+                app_type=AppType.EXTERNAL,
+            ),
+            create_app(
+                slug="checkout-app",
+                name="Checkout App",
+                app_type=AppType.EXTERNAL,
+                accelerators=["payment-processor"],
+            ),
+            create_app(
+                slug="member-tool",
+                name="Member Tool",
+                app_type=AppType.MEMBER_TOOL,
+            ),
+        ]
+        for app in apps:
+            await repo.save(app)
+        return repo
+
+    @pytest.mark.asyncio
+    async def test_get_by_type_staff(self, populated_repo: MemoryAppRepository) -> None:
+        """Test getting apps by staff type."""
+        apps = await populated_repo.get_by_type(AppType.STAFF)
+        assert len(apps) == 2
+        assert all(a.app_type == AppType.STAFF for a in apps)
+
+    @pytest.mark.asyncio
+    async def test_get_by_type_external(
+        self, populated_repo: MemoryAppRepository
+    ) -> None:
+        """Test getting apps by external type."""
+        apps = await populated_repo.get_by_type(AppType.EXTERNAL)
+        assert len(apps) == 2
+        assert all(a.app_type == AppType.EXTERNAL for a in apps)
+
+    @pytest.mark.asyncio
+    async def test_get_by_type_member_tool(
+        self, populated_repo: MemoryAppRepository
+    ) -> None:
+        """Test getting apps by member-tool type."""
+        apps = await populated_repo.get_by_type(AppType.MEMBER_TOOL)
+        assert len(apps) == 1
+        assert apps[0].slug == "member-tool"
+
+    @pytest.mark.asyncio
+    async def test_get_by_type_no_results(
+        self, populated_repo: MemoryAppRepository
+    ) -> None:
+        """Test getting apps by type with no matches."""
+        apps = await populated_repo.get_by_type(AppType.UNKNOWN)
+        assert len(apps) == 0
+
+    @pytest.mark.asyncio
+    async def test_get_by_name(self, populated_repo: MemoryAppRepository) -> None:
+        """Test getting an app by name."""
+        app = await populated_repo.get_by_name("Staff Portal")
+        assert app is not None
+        assert app.slug == "staff-portal"
+
+    @pytest.mark.asyncio
+    async def test_get_by_name_case_insensitive(
+        self, populated_repo: MemoryAppRepository
+    ) -> None:
+        """Test name matching is case-insensitive."""
+        app = await populated_repo.get_by_name("staff portal")
+        assert app is not None
+        assert app.slug == "staff-portal"
+
+    @pytest.mark.asyncio
+    async def test_get_by_name_not_found(
+        self, populated_repo: MemoryAppRepository
+    ) -> None:
+        """Test getting app by nonexistent name."""
+        app = await populated_repo.get_by_name("Nonexistent App")
+        assert app is None
+
+    @pytest.mark.asyncio
+    async def test_get_all_types(self, populated_repo: MemoryAppRepository) -> None:
+        """Test getting all unique app types."""
+        types = await populated_repo.get_all_types()
+        assert types == {AppType.STAFF, AppType.EXTERNAL, AppType.MEMBER_TOOL}
+
+    @pytest.mark.asyncio
+    async def test_get_apps_with_accelerators(
+        self, populated_repo: MemoryAppRepository
+    ) -> None:
+        """Test getting apps that have accelerators."""
+        apps = await populated_repo.get_apps_with_accelerators()
+        assert len(apps) == 3
+        slugs = {a.slug for a in apps}
+        assert slugs == {"staff-portal", "admin-tool", "checkout-app"}
+
+    @pytest.mark.asyncio
+    async def test_get_apps_with_accelerators_empty(
+        self, repo: MemoryAppRepository
+    ) -> None:
+        """Test getting apps with accelerators when none have any."""
+        await repo.save(create_app(slug="no-accel-1"))
+        await repo.save(create_app(slug="no-accel-2"))
+
+        apps = await repo.get_apps_with_accelerators()
+        assert len(apps) == 0

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

@@ -0,0 +1,151 @@
+"""Tests for MemoryRepositoryMixin base utility methods."""
+
+import pytest
+
+from julee.docs.sphinx_hcd.domain.models.story import Story
+from julee.docs.sphinx_hcd.repositories.memory.story import MemoryStoryRepository
+
+
+def create_story(
+    slug: str = "test",
+    feature_title: str = "Test Feature",
+    persona: str = "User",
+    app_slug: str = "app",
+) -> Story:
+    """Helper to create test stories."""
+    return Story(
+        slug=slug,
+        feature_title=feature_title,
+        persona=persona,
+        app_slug=app_slug,
+        file_path=f"tests/e2e/{app_slug}/features/{slug}.feature",
+    )
+
+
+class TestFindByField:
+    """Test the find_by_field utility method from MemoryRepositoryMixin."""
+
+    @pytest.fixture
+    def repo(self) -> MemoryStoryRepository:
+        """Create a fresh repository."""
+        return MemoryStoryRepository()
+
+    @pytest.mark.asyncio
+    async def test_find_by_field_single_match(
+        self, repo: MemoryStoryRepository
+    ) -> None:
+        """Test finding entities by a field with single match."""
+        await repo.save(create_story(slug="story-1", persona="Admin"))
+        await repo.save(create_story(slug="story-2", persona="User"))
+        await repo.save(create_story(slug="story-3", persona="User"))
+
+        result = await repo.find_by_field("persona", "Admin")
+
+        assert len(result) == 1
+        assert result[0].slug == "story-1"
+
+    @pytest.mark.asyncio
+    async def test_find_by_field_multiple_matches(
+        self, repo: MemoryStoryRepository
+    ) -> None:
+        """Test finding entities by a field with multiple matches."""
+        await repo.save(create_story(slug="story-1", app_slug="portal"))
+        await repo.save(create_story(slug="story-2", app_slug="portal"))
+        await repo.save(create_story(slug="story-3", app_slug="other"))
+
+        result = await repo.find_by_field("app_slug", "portal")
+
+        assert len(result) == 2
+        slugs = {s.slug for s in result}
+        assert slugs == {"story-1", "story-2"}
+
+    @pytest.mark.asyncio
+    async def test_find_by_field_no_matches(self, repo: MemoryStoryRepository) -> None:
+        """Test finding entities by a field with no matches."""
+        await repo.save(create_story(slug="story-1", persona="User"))
+
+        result = await repo.find_by_field("persona", "Admin")
+
+        assert result == []
+
+    @pytest.mark.asyncio
+    async def test_find_by_field_nonexistent_field(
+        self, repo: MemoryStoryRepository
+    ) -> None:
+        """Test finding by a field that doesn't exist returns empty list."""
+        await repo.save(create_story(slug="story-1"))
+
+        result = await repo.find_by_field("nonexistent_field", "value")
+
+        assert result == []
+
+
+class TestFindByFieldIn:
+    """Test the find_by_field_in utility method from MemoryRepositoryMixin."""
+
+    @pytest.fixture
+    def repo(self) -> MemoryStoryRepository:
+        """Create a fresh repository."""
+        return MemoryStoryRepository()
+
+    @pytest.mark.asyncio
+    async def test_find_by_field_in_multiple_values(
+        self, repo: MemoryStoryRepository
+    ) -> None:
+        """Test finding entities where field is in a list of values."""
+        await repo.save(create_story(slug="story-1", persona="Admin"))
+        await repo.save(create_story(slug="story-2", persona="User"))
+        await repo.save(create_story(slug="story-3", persona="Guest"))
+
+        result = await repo.find_by_field_in("persona", ["Admin", "User"])
+
+        assert len(result) == 2
+        personas = {s.persona for s in result}
+        assert personas == {"Admin", "User"}
+
+    @pytest.mark.asyncio
+    async def test_find_by_field_in_single_value(
+        self, repo: MemoryStoryRepository
+    ) -> None:
+        """Test finding entities with single value in list."""
+        await repo.save(create_story(slug="story-1", app_slug="portal"))
+        await repo.save(create_story(slug="story-2", app_slug="other"))
+
+        result = await repo.find_by_field_in("app_slug", ["portal"])
+
+        assert len(result) == 1
+        assert result[0].slug == "story-1"
+
+    @pytest.mark.asyncio
+    async def test_find_by_field_in_no_matches(
+        self, repo: MemoryStoryRepository
+    ) -> None:
+        """Test finding entities with no matching values."""
+        await repo.save(create_story(slug="story-1", persona="User"))
+
+        result = await repo.find_by_field_in("persona", ["Admin", "Guest"])
+
+        assert result == []
+
+    @pytest.mark.asyncio
+    async def test_find_by_field_in_empty_list(
+        self, repo: MemoryStoryRepository
+    ) -> None:
+        """Test finding with empty values list returns empty result."""
+        await repo.save(create_story(slug="story-1"))
+
+        result = await repo.find_by_field_in("persona", [])
+
+        assert result == []
+
+    @pytest.mark.asyncio
+    async def test_find_by_field_in_all_match(
+        self, repo: MemoryStoryRepository
+    ) -> None:
+        """Test when all entities match."""
+        await repo.save(create_story(slug="story-1", persona="Admin"))
+        await repo.save(create_story(slug="story-2", persona="User"))
+
+        result = await repo.find_by_field_in("persona", ["Admin", "User", "Guest"])
+
+        assert len(result) == 2