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

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

@@ -0,0 +1,236 @@
+"""Tests for MemoryStoryRepository."""
+
+import pytest
+import pytest_asyncio
+
+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 TestMemoryStoryRepositoryBasicOperations:
+    """Test basic CRUD operations."""
+
+    @pytest.fixture
+    def repo(self) -> MemoryStoryRepository:
+        """Create a fresh repository."""
+        return MemoryStoryRepository()
+
+    @pytest.mark.asyncio
+    async def test_save_and_get(self, repo: MemoryStoryRepository) -> None:
+        """Test saving and retrieving a story."""
+        story = create_story(slug="submit-order")
+        await repo.save(story)
+
+        retrieved = await repo.get("submit-order")
+        assert retrieved is not None
+        assert retrieved.slug == "submit-order"
+
+    @pytest.mark.asyncio
+    async def test_get_nonexistent(self, repo: MemoryStoryRepository) -> None:
+        """Test getting a nonexistent story returns None."""
+        result = await repo.get("nonexistent")
+        assert result is None
+
+    @pytest.mark.asyncio
+    async def test_list_all(self, repo: MemoryStoryRepository) -> None:
+        """Test listing all stories."""
+        await repo.save(create_story(slug="story-1"))
+        await repo.save(create_story(slug="story-2"))
+        await repo.save(create_story(slug="story-3"))
+
+        all_stories = await repo.list_all()
+        assert len(all_stories) == 3
+        slugs = {s.slug for s in all_stories}
+        assert slugs == {"story-1", "story-2", "story-3"}
+
+    @pytest.mark.asyncio
+    async def test_delete(self, repo: MemoryStoryRepository) -> None:
+        """Test deleting a story."""
+        await repo.save(create_story(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: MemoryStoryRepository) -> None:
+        """Test deleting a nonexistent story."""
+        result = await repo.delete("nonexistent")
+        assert result is False
+
+    @pytest.mark.asyncio
+    async def test_clear(self, repo: MemoryStoryRepository) -> None:
+        """Test clearing all stories."""
+        await repo.save(create_story(slug="story-1"))
+        await repo.save(create_story(slug="story-2"))
+        assert len(await repo.list_all()) == 2
+
+        await repo.clear()
+        assert len(await repo.list_all()) == 0
+
+
+class TestMemoryStoryRepositoryQueries:
+    """Test story-specific query methods."""
+
+    @pytest.fixture
+    def repo(self) -> MemoryStoryRepository:
+        """Create a repository with sample data."""
+        return MemoryStoryRepository()
+
+    @pytest_asyncio.fixture
+    async def populated_repo(
+        self, repo: MemoryStoryRepository
+    ) -> MemoryStoryRepository:
+        """Create a repository with sample stories."""
+        stories = [
+            create_story(
+                slug="upload-doc",
+                feature_title="Upload Document",
+                persona="Staff Member",
+                app_slug="staff-portal",
+            ),
+            create_story(
+                slug="view-report",
+                feature_title="View Report",
+                persona="Staff Member",
+                app_slug="staff-portal",
+            ),
+            create_story(
+                slug="submit-order",
+                feature_title="Submit Order",
+                persona="Customer",
+                app_slug="checkout-app",
+            ),
+            create_story(
+                slug="track-order",
+                feature_title="Track Order",
+                persona="Customer",
+                app_slug="checkout-app",
+            ),
+            create_story(
+                slug="admin-config",
+                feature_title="Admin Configuration",
+                persona="Admin",
+                app_slug="admin-portal",
+            ),
+        ]
+        for story in stories:
+            await repo.save(story)
+        return repo
+
+    @pytest.mark.asyncio
+    async def test_get_by_app(self, populated_repo: MemoryStoryRepository) -> None:
+        """Test getting stories by app."""
+        stories = await populated_repo.get_by_app("staff-portal")
+        assert len(stories) == 2
+        assert all(s.app_slug == "staff-portal" for s in stories)
+
+    @pytest.mark.asyncio
+    async def test_get_by_app_case_insensitive(
+        self, populated_repo: MemoryStoryRepository
+    ) -> None:
+        """Test app matching is case-insensitive."""
+        stories = await populated_repo.get_by_app("Staff-Portal")
+        assert len(stories) == 2
+
+    @pytest.mark.asyncio
+    async def test_get_by_app_no_results(
+        self, populated_repo: MemoryStoryRepository
+    ) -> None:
+        """Test getting stories for app with no stories."""
+        stories = await populated_repo.get_by_app("nonexistent-app")
+        assert len(stories) == 0
+
+    @pytest.mark.asyncio
+    async def test_get_by_persona(self, populated_repo: MemoryStoryRepository) -> None:
+        """Test getting stories by persona."""
+        stories = await populated_repo.get_by_persona("Customer")
+        assert len(stories) == 2
+        assert all(s.persona == "Customer" for s in stories)
+
+    @pytest.mark.asyncio
+    async def test_get_by_persona_case_insensitive(
+        self, populated_repo: MemoryStoryRepository
+    ) -> None:
+        """Test persona matching is case-insensitive."""
+        stories = await populated_repo.get_by_persona("staff member")
+        assert len(stories) == 2
+
+    @pytest.mark.asyncio
+    async def test_get_by_feature_title(
+        self, populated_repo: MemoryStoryRepository
+    ) -> None:
+        """Test getting a story by feature title."""
+        story = await populated_repo.get_by_feature_title("Upload Document")
+        assert story is not None
+        assert story.slug == "upload-doc"
+
+    @pytest.mark.asyncio
+    async def test_get_by_feature_title_case_insensitive(
+        self, populated_repo: MemoryStoryRepository
+    ) -> None:
+        """Test feature title matching is case-insensitive."""
+        story = await populated_repo.get_by_feature_title("upload document")
+        assert story is not None
+        assert story.slug == "upload-doc"
+
+    @pytest.mark.asyncio
+    async def test_get_by_feature_title_not_found(
+        self, populated_repo: MemoryStoryRepository
+    ) -> None:
+        """Test getting story by nonexistent feature title."""
+        story = await populated_repo.get_by_feature_title("Nonexistent Feature")
+        assert story is None
+
+    @pytest.mark.asyncio
+    async def test_get_apps_with_stories(
+        self, populated_repo: MemoryStoryRepository
+    ) -> None:
+        """Test getting apps that have stories."""
+        apps = await populated_repo.get_apps_with_stories()
+        assert apps == {"staff-portal", "checkout-app", "admin-portal"}
+
+    @pytest.mark.asyncio
+    async def test_get_all_personas(
+        self, populated_repo: MemoryStoryRepository
+    ) -> None:
+        """Test getting all unique personas."""
+        personas = await populated_repo.get_all_personas()
+        assert personas == {"staff member", "customer", "admin"}
+
+    @pytest.mark.asyncio
+    async def test_get_all_personas_excludes_unknown(
+        self, repo: MemoryStoryRepository
+    ) -> None:
+        """Test that 'unknown' persona is excluded from results."""
+        await repo.save(
+            Story(
+                slug="test",
+                feature_title="Test",
+                persona="unknown",
+                app_slug="app",
+                file_path="test.feature",
+            )
+        )
+        await repo.save(create_story(slug="known", persona="Known User"))
+
+        personas = await repo.get_all_personas()
+        assert "unknown" not in personas
+        assert "known user" in personas

julee/docs/sphinx_hcd/tests/sphinx/__init__.py

@@ -0,0 +1 @@
+"""Sphinx application layer tests."""

julee/docs/sphinx_hcd/tests/sphinx/directives/__init__.py

@@ -0,0 +1 @@
+"""Tests for sphinx_hcd directives."""

julee/docs/sphinx_hcd/tests/sphinx/directives/test_base.py

@@ -0,0 +1,160 @@
+"""Tests for base directive utilities."""
+
+from julee.docs.sphinx_hcd.sphinx.directives.base import make_deprecated_directive
+
+
+class TestMakeDeprecatedDirective:
+    """Test make_deprecated_directive function."""
+
+    def test_creates_subclass(self) -> None:
+        """Test that function creates a proper subclass."""
+        from sphinx.util.docutils import SphinxDirective
+
+        # Create a simple base class
+        class TestDirective(SphinxDirective):
+            def run(self):
+                return []
+
+        DeprecatedClass = make_deprecated_directive(
+            TestDirective,
+            "old-name",
+            "new-name",
+        )
+
+        assert issubclass(DeprecatedClass, TestDirective)
+
+    def test_class_name_set(self) -> None:
+        """Test that deprecated class has appropriate name."""
+        from sphinx.util.docutils import SphinxDirective
+
+        class TestDirective(SphinxDirective):
+            def run(self):
+                return []
+
+        DeprecatedClass = make_deprecated_directive(
+            TestDirective,
+            "old-name",
+            "new-name",
+        )
+
+        assert "Deprecated" in DeprecatedClass.__name__
+
+
+class TestDirectiveImports:
+    """Test that all directives can be imported."""
+
+    def test_story_directives_import(self) -> None:
+        """Test story directive imports."""
+        from julee.docs.sphinx_hcd.sphinx.directives.story import (
+            StoriesDirective,
+            StoryAppDirective,
+            StoryIndexDirective,
+            StoryListForAppDirective,
+            StoryListForPersonaDirective,
+            StoryRefDirective,
+        )
+
+        assert StoryAppDirective is not None
+        assert StoryIndexDirective is not None
+        assert StoryListForAppDirective is not None
+        assert StoryListForPersonaDirective is not None
+        assert StoryRefDirective is not None
+        assert StoriesDirective is not None
+
+    def test_journey_directives_import(self) -> None:
+        """Test journey directive imports."""
+        from julee.docs.sphinx_hcd.sphinx.directives.journey import (
+            DefineJourneyDirective,
+            JourneyIndexDirective,
+            JourneysForPersonaDirective,
+            StepEpicDirective,
+            StepPhaseDirective,
+            StepStoryDirective,
+        )
+
+        assert DefineJourneyDirective is not None
+        assert JourneyIndexDirective is not None
+        assert JourneysForPersonaDirective is not None
+        assert StepEpicDirective is not None
+        assert StepPhaseDirective is not None
+        assert StepStoryDirective is not None
+
+    def test_epic_directives_import(self) -> None:
+        """Test epic directive imports."""
+        from julee.docs.sphinx_hcd.sphinx.directives.epic import (
+            DefineEpicDirective,
+            EpicIndexDirective,
+            EpicsForPersonaDirective,
+            EpicStoryDirective,
+        )
+
+        assert DefineEpicDirective is not None
+        assert EpicIndexDirective is not None
+        assert EpicStoryDirective is not None
+        assert EpicsForPersonaDirective is not None
+
+    def test_app_directives_import(self) -> None:
+        """Test app directive imports."""
+        from julee.docs.sphinx_hcd.sphinx.directives.app import (
+            AppIndexDirective,
+            AppsForPersonaDirective,
+            DefineAppDirective,
+        )
+
+        assert DefineAppDirective is not None
+        assert AppIndexDirective is not None
+        assert AppsForPersonaDirective is not None
+
+    def test_accelerator_directives_import(self) -> None:
+        """Test accelerator directive imports."""
+        from julee.docs.sphinx_hcd.sphinx.directives.accelerator import (
+            AcceleratorDependencyDiagramDirective,
+            AcceleratorIndexDirective,
+            AcceleratorsForAppDirective,
+            AcceleratorStatusDirective,
+            DefineAcceleratorDirective,
+        )
+
+        assert DefineAcceleratorDirective is not None
+        assert AcceleratorIndexDirective is not None
+        assert AcceleratorsForAppDirective is not None
+        assert AcceleratorDependencyDiagramDirective is not None
+        assert AcceleratorStatusDirective is not None
+
+    def test_integration_directives_import(self) -> None:
+        """Test integration directive imports."""
+        from julee.docs.sphinx_hcd.sphinx.directives.integration import (
+            DefineIntegrationDirective,
+            IntegrationIndexDirective,
+        )
+
+        assert DefineIntegrationDirective is not None
+        assert IntegrationIndexDirective is not None
+
+    def test_persona_directives_import(self) -> None:
+        """Test persona directive imports."""
+        from julee.docs.sphinx_hcd.sphinx.directives.persona import (
+            PersonaDiagramDirective,
+            PersonaIndexDiagramDirective,
+        )
+
+        assert PersonaDiagramDirective is not None
+        assert PersonaIndexDiagramDirective is not None
+
+
+class TestEventHandlerImports:
+    """Test that all event handlers can be imported."""
+
+    def test_event_handlers_import(self) -> None:
+        """Test event handler imports."""
+        from julee.docs.sphinx_hcd.sphinx.event_handlers import (
+            on_builder_inited,
+            on_doctree_read,
+            on_doctree_resolved,
+            on_env_purge_doc,
+        )
+
+        assert on_builder_inited is not None
+        assert on_doctree_read is not None
+        assert on_doctree_resolved is not None
+        assert on_env_purge_doc is not None

julee/docs/sphinx_hcd/tests/sphinx/test_adapters.py

@@ -0,0 +1,176 @@
+"""Tests for SyncRepositoryAdapter."""
+
+import pytest
+from pydantic import BaseModel
+
+from julee.docs.sphinx_hcd.repositories.memory.base import MemoryRepositoryMixin
+from julee.docs.sphinx_hcd.sphinx.adapters import SyncRepositoryAdapter
+
+
+class SampleEntity(BaseModel):
+    """Simple entity for adapter tests."""
+
+    id: str
+    name: str
+    value: int = 0
+
+
+class SampleMemoryRepository(MemoryRepositoryMixin[SampleEntity]):
+    """Sample repository implementation for testing."""
+
+    def __init__(self) -> None:
+        self.storage: dict[str, SampleEntity] = {}
+        self.entity_name = "SampleEntity"
+        self.id_field = "id"
+
+    async def find_by_name(self, name: str) -> list[SampleEntity]:
+        """Custom query method for testing run_async."""
+        return [e for e in self.storage.values() if e.name == name]
+
+
+class TestSyncRepositoryAdapter:
+    """Test suite for SyncRepositoryAdapter."""
+
+    @pytest.fixture
+    def async_repo(self) -> SampleMemoryRepository:
+        """Create a fresh test repository."""
+        return SampleMemoryRepository()
+
+    @pytest.fixture
+    def sync_repo(
+        self, async_repo: SampleMemoryRepository
+    ) -> SyncRepositoryAdapter[SampleEntity]:
+        """Create a sync adapter wrapping the async repo."""
+        return SyncRepositoryAdapter(async_repo)
+
+    @pytest.fixture
+    def sample_entity(self) -> SampleEntity:
+        """Create a sample test entity."""
+        return SampleEntity(id="test-1", name="Test One", value=42)
+
+    def test_save_and_get(
+        self,
+        sync_repo: SyncRepositoryAdapter[SampleEntity],
+        sample_entity: SampleEntity,
+    ) -> None:
+        """Test saving and retrieving an entity."""
+        # Save
+        sync_repo.save(sample_entity)
+
+        # Get
+        retrieved = sync_repo.get("test-1")
+        assert retrieved is not None
+        assert retrieved.id == "test-1"
+        assert retrieved.name == "Test One"
+        assert retrieved.value == 42
+
+    def test_get_nonexistent(
+        self,
+        sync_repo: SyncRepositoryAdapter[SampleEntity],
+    ) -> None:
+        """Test getting a nonexistent entity returns None."""
+        result = sync_repo.get("nonexistent")
+        assert result is None
+
+    def test_get_many(
+        self,
+        sync_repo: SyncRepositoryAdapter[SampleEntity],
+    ) -> None:
+        """Test retrieving multiple entities."""
+        # Save some entities
+        sync_repo.save(SampleEntity(id="a", name="A"))
+        sync_repo.save(SampleEntity(id="b", name="B"))
+        sync_repo.save(SampleEntity(id="c", name="C"))
+
+        # Get many
+        result = sync_repo.get_many(["a", "c", "nonexistent"])
+        assert result["a"] is not None
+        assert result["a"].name == "A"
+        assert result["c"] is not None
+        assert result["c"].name == "C"
+        assert result["nonexistent"] is None
+
+    def test_list_all(
+        self,
+        sync_repo: SyncRepositoryAdapter[SampleEntity],
+    ) -> None:
+        """Test listing all entities."""
+        # Initially empty
+        assert sync_repo.list_all() == []
+
+        # Add some entities
+        sync_repo.save(SampleEntity(id="1", name="First"))
+        sync_repo.save(SampleEntity(id="2", name="Second"))
+
+        # List all
+        all_entities = sync_repo.list_all()
+        assert len(all_entities) == 2
+        names = {e.name for e in all_entities}
+        assert names == {"First", "Second"}
+
+    def test_delete(
+        self,
+        sync_repo: SyncRepositoryAdapter[SampleEntity],
+        sample_entity: SampleEntity,
+    ) -> None:
+        """Test deleting an entity."""
+        sync_repo.save(sample_entity)
+        assert sync_repo.get("test-1") is not None
+
+        # Delete
+        result = sync_repo.delete("test-1")
+        assert result is True
+        assert sync_repo.get("test-1") is None
+
+        # Delete nonexistent
+        result = sync_repo.delete("test-1")
+        assert result is False
+
+    def test_clear(
+        self,
+        sync_repo: SyncRepositoryAdapter[SampleEntity],
+    ) -> None:
+        """Test clearing all entities."""
+        sync_repo.save(SampleEntity(id="1", name="One"))
+        sync_repo.save(SampleEntity(id="2", name="Two"))
+        assert len(sync_repo.list_all()) == 2
+
+        sync_repo.clear()
+        assert len(sync_repo.list_all()) == 0
+
+    def test_async_repo_property(
+        self,
+        sync_repo: SyncRepositoryAdapter[SampleEntity],
+        async_repo: SampleMemoryRepository,
+    ) -> None:
+        """Test accessing the underlying async repo."""
+        assert sync_repo.async_repo is async_repo
+
+    def test_run_async_custom_method(
+        self,
+        sync_repo: SyncRepositoryAdapter[SampleEntity],
+        async_repo: SampleMemoryRepository,
+    ) -> None:
+        """Test running a custom async method via run_async."""
+        sync_repo.save(SampleEntity(id="1", name="Alice", value=1))
+        sync_repo.save(SampleEntity(id="2", name="Bob", value=2))
+        sync_repo.save(SampleEntity(id="3", name="Alice", value=3))
+
+        # Use run_async for custom query
+        result = sync_repo.run_async(async_repo.find_by_name("Alice"))
+        assert len(result) == 2
+        assert all(e.name == "Alice" for e in result)
+
+    def test_save_overwrites_existing(
+        self,
+        sync_repo: SyncRepositoryAdapter[SampleEntity],
+    ) -> None:
+        """Test that saving with same ID overwrites."""
+        sync_repo.save(SampleEntity(id="x", name="Original", value=1))
+        sync_repo.save(SampleEntity(id="x", name="Updated", value=2))
+
+        retrieved = sync_repo.get("x")
+        assert retrieved is not None
+        assert retrieved.name == "Updated"
+        assert retrieved.value == 2
+        assert len(sync_repo.list_all()) == 1