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

julee/docs/sphinx_hcd/tests/domain/use_cases/test_resolve_app_references.py

@@ -0,0 +1,265 @@
+"""Tests for resolve_app_references use case."""
+
+from julee.docs.sphinx_hcd.domain.models.app import App, AppType
+from julee.docs.sphinx_hcd.domain.models.epic import Epic
+from julee.docs.sphinx_hcd.domain.models.journey import Journey, JourneyStep
+from julee.docs.sphinx_hcd.domain.models.story import Story
+from julee.docs.sphinx_hcd.domain.use_cases.resolve_app_references import (
+    get_app_cross_references,
+    get_epics_for_app,
+    get_journeys_for_app,
+    get_personas_for_app,
+    get_stories_for_app,
+)
+
+
+def create_app(slug: str, name: str = "") -> App:
+    """Helper to create test apps."""
+    return App(
+        slug=slug,
+        name=name or slug.replace("-", " ").title(),
+        app_type=AppType.STAFF,
+        manifest_path=f"apps/{slug}/app.yaml",
+    )
+
+
+def create_story(
+    feature_title: str,
+    app_slug: str,
+    persona: str = "Test User",
+) -> Story:
+    """Helper to create test stories."""
+    return Story(
+        slug=feature_title.lower().replace(" ", "-"),
+        feature_title=feature_title,
+        persona=persona,
+        i_want="test",
+        so_that="verify",
+        app_slug=app_slug,
+        file_path="test.feature",
+    )
+
+
+def create_epic(slug: str, story_refs: list[str]) -> Epic:
+    """Helper to create test epics."""
+    return Epic(slug=slug, story_refs=story_refs)
+
+
+def create_journey(slug: str, story_refs: list[str]) -> Journey:
+    """Helper to create test journeys."""
+    steps = [JourneyStep.story(ref) for ref in story_refs]
+    return Journey(slug=slug, persona="User", steps=steps)
+
+
+class TestGetStoriesForApp:
+    """Test get_stories_for_app function."""
+
+    def test_find_stories(self) -> None:
+        """Test finding stories for an app."""
+        app = create_app("vocabulary-tool")
+        stories = [
+            create_story("Upload Document", "vocabulary-tool"),
+            create_story("Review Vocabulary", "vocabulary-tool"),
+            create_story("Other Feature", "other-app"),
+        ]
+
+        result = get_stories_for_app(app, stories)
+
+        assert len(result) == 2
+        titles = {s.feature_title for s in result}
+        assert titles == {"Upload Document", "Review Vocabulary"}
+
+    def test_no_stories(self) -> None:
+        """Test when app has no stories."""
+        app = create_app("empty-app")
+        stories = [create_story("Feature", "other-app")]
+
+        result = get_stories_for_app(app, stories)
+
+        assert result == []
+
+    def test_sorted_by_feature_title(self) -> None:
+        """Test results are sorted by feature title."""
+        app = create_app("test-app")
+        stories = [
+            create_story("Zebra Feature", "test-app"),
+            create_story("Alpha Feature", "test-app"),
+        ]
+
+        result = get_stories_for_app(app, stories)
+
+        titles = [s.feature_title for s in result]
+        assert titles == ["Alpha Feature", "Zebra Feature"]
+
+
+class TestGetPersonasForApp:
+    """Test get_personas_for_app function."""
+
+    def test_find_personas(self) -> None:
+        """Test finding personas that use an app."""
+        app = create_app("vocabulary-tool")
+        stories = [
+            create_story("Upload Document", "vocabulary-tool", "Knowledge Curator"),
+            create_story("Review Document", "vocabulary-tool", "Reviewer"),
+            create_story("Other Feature", "other-app", "Other User"),
+        ]
+        epics: list[Epic] = []
+
+        result = get_personas_for_app(app, stories, epics)
+
+        assert len(result) == 2
+        names = {p.name for p in result}
+        assert names == {"Knowledge Curator", "Reviewer"}
+
+    def test_single_persona_multiple_stories(self) -> None:
+        """Test persona appears once even with multiple stories."""
+        app = create_app("vocabulary-tool")
+        stories = [
+            create_story("Upload Document", "vocabulary-tool", "Curator"),
+            create_story("Review Document", "vocabulary-tool", "Curator"),
+        ]
+        epics: list[Epic] = []
+
+        result = get_personas_for_app(app, stories, epics)
+
+        assert len(result) == 1
+        assert result[0].name == "Curator"
+
+    def test_sorted_by_name(self) -> None:
+        """Test results are sorted by name."""
+        app = create_app("test-app")
+        stories = [
+            create_story("Feature Z", "test-app", "Zebra User"),
+            create_story("Feature A", "test-app", "Alpha User"),
+        ]
+        epics: list[Epic] = []
+
+        result = get_personas_for_app(app, stories, epics)
+
+        names = [p.name for p in result]
+        assert names == ["Alpha User", "Zebra User"]
+
+
+class TestGetJourneysForApp:
+    """Test get_journeys_for_app function."""
+
+    def test_find_journeys(self) -> None:
+        """Test finding journeys containing app's stories."""
+        app = create_app("vocabulary-tool")
+        stories = [
+            create_story("Upload Document", "vocabulary-tool"),
+            create_story("Other Feature", "other-app"),
+        ]
+        journeys = [
+            create_journey("build-vocabulary", ["Upload Document"]),
+            create_journey("other-journey", ["Other Feature"]),
+        ]
+
+        result = get_journeys_for_app(app, stories, journeys)
+
+        assert len(result) == 1
+        assert result[0].slug == "build-vocabulary"
+
+    def test_no_journeys(self) -> None:
+        """Test when app's stories are not in any journey."""
+        app = create_app("vocabulary-tool")
+        stories = [create_story("Lonely Feature", "vocabulary-tool")]
+        journeys = [create_journey("other-journey", ["Other Story"])]
+
+        result = get_journeys_for_app(app, stories, journeys)
+
+        assert result == []
+
+    def test_no_stories(self) -> None:
+        """Test when app has no stories."""
+        app = create_app("empty-app")
+        stories = [create_story("Feature", "other-app")]
+        journeys = [create_journey("test", ["Feature"])]
+
+        result = get_journeys_for_app(app, stories, journeys)
+
+        assert result == []
+
+
+class TestGetEpicsForApp:
+    """Test get_epics_for_app function."""
+
+    def test_find_epics(self) -> None:
+        """Test finding epics containing app's stories."""
+        app = create_app("vocabulary-tool")
+        stories = [
+            create_story("Upload Document", "vocabulary-tool"),
+            create_story("Other Feature", "other-app"),
+        ]
+        epics = [
+            create_epic("vocabulary-management", ["Upload Document"]),
+            create_epic("other-epic", ["Other Feature"]),
+        ]
+
+        result = get_epics_for_app(app, stories, epics)
+
+        assert len(result) == 1
+        assert result[0].slug == "vocabulary-management"
+
+    def test_multiple_epics(self) -> None:
+        """Test finding multiple epics."""
+        app = create_app("vocabulary-tool")
+        stories = [
+            create_story("Upload Document", "vocabulary-tool"),
+            create_story("Review Document", "vocabulary-tool"),
+        ]
+        epics = [
+            create_epic("epic-1", ["Upload Document"]),
+            create_epic("epic-2", ["Review Document"]),
+        ]
+
+        result = get_epics_for_app(app, stories, epics)
+
+        assert len(result) == 2
+
+    def test_no_stories_for_app(self) -> None:
+        """Test when app has no stories at all."""
+        app = create_app("empty-app")
+        stories = [create_story("Feature", "other-app")]
+        epics = [create_epic("some-epic", ["Feature"])]
+
+        result = get_epics_for_app(app, stories, epics)
+
+        assert result == []
+
+    def test_no_epics_contain_app_stories(self) -> None:
+        """Test when app has stories but no epics reference them."""
+        app = create_app("vocabulary-tool")
+        stories = [create_story("Lonely Feature", "vocabulary-tool")]
+        epics = [create_epic("other-epic", ["Other Feature"])]
+
+        result = get_epics_for_app(app, stories, epics)
+
+        assert result == []
+
+
+class TestGetAppCrossReferences:
+    """Test get_app_cross_references function."""
+
+    def test_cross_references(self) -> None:
+        """Test getting all cross-references for an app."""
+        app = create_app("vocabulary-tool")
+        stories = [
+            create_story("Upload Document", "vocabulary-tool", "Curator"),
+            create_story("Review Document", "vocabulary-tool", "Reviewer"),
+        ]
+        epics = [
+            create_epic(
+                "vocabulary-management", ["Upload Document", "Review Document"]
+            ),
+        ]
+        journeys = [
+            create_journey("build-vocabulary", ["Upload Document"]),
+        ]
+
+        result = get_app_cross_references(app, stories, epics, journeys)
+
+        assert len(result["stories"]) == 2
+        assert len(result["personas"]) == 2
+        assert len(result["journeys"]) == 1
+        assert len(result["epics"]) == 1

julee/docs/sphinx_hcd/tests/domain/use_cases/test_resolve_story_references.py

@@ -0,0 +1,229 @@
+"""Tests for resolve_story_references use case."""
+
+from julee.docs.sphinx_hcd.domain.models.epic import Epic
+from julee.docs.sphinx_hcd.domain.models.journey import Journey, JourneyStep
+from julee.docs.sphinx_hcd.domain.models.story import Story
+from julee.docs.sphinx_hcd.domain.use_cases.resolve_story_references import (
+    get_epics_for_story,
+    get_journeys_for_story,
+    get_related_stories,
+    get_story_cross_references,
+)
+
+
+def create_story(feature_title: str, app_slug: str = "test-app") -> Story:
+    """Helper to create test stories."""
+    return Story(
+        slug=feature_title.lower().replace(" ", "-"),
+        feature_title=feature_title,
+        persona="Test User",
+        i_want="test",
+        so_that="verify",
+        app_slug=app_slug,
+        file_path="test.feature",
+    )
+
+
+def create_epic(slug: str, story_refs: list[str]) -> Epic:
+    """Helper to create test epics."""
+    return Epic(slug=slug, story_refs=story_refs)
+
+
+def create_journey(slug: str, story_refs: list[str]) -> Journey:
+    """Helper to create test journeys."""
+    steps = [JourneyStep.story(ref) for ref in story_refs]
+    return Journey(slug=slug, persona="User", steps=steps)
+
+
+class TestGetEpicsForStory:
+    """Test get_epics_for_story function."""
+
+    def test_find_single_epic(self) -> None:
+        """Test finding a story in one epic."""
+        story = create_story("Upload Document")
+        epics = [
+            create_epic(
+                "vocabulary-management", ["Upload Document", "Review Vocabulary"]
+            ),
+            create_epic("other-epic", ["Other Story"]),
+        ]
+
+        result = get_epics_for_story(story, epics)
+
+        assert len(result) == 1
+        assert result[0].slug == "vocabulary-management"
+
+    def test_find_multiple_epics(self) -> None:
+        """Test finding a story in multiple epics."""
+        story = create_story("Upload Document")
+        epics = [
+            create_epic("vocabulary-management", ["Upload Document"]),
+            create_epic("document-processing", ["Upload Document", "Process Document"]),
+        ]
+
+        result = get_epics_for_story(story, epics)
+
+        assert len(result) == 2
+        slugs = {e.slug for e in result}
+        assert slugs == {"vocabulary-management", "document-processing"}
+
+    def test_case_insensitive_matching(self) -> None:
+        """Test that matching is case-insensitive."""
+        story = create_story("Upload Document")
+        epics = [create_epic("test-epic", ["upload document"])]  # lowercase
+
+        result = get_epics_for_story(story, epics)
+
+        assert len(result) == 1
+
+    def test_no_matching_epics(self) -> None:
+        """Test when story is not in any epic."""
+        story = create_story("Unknown Story")
+        epics = [create_epic("test-epic", ["Other Story"])]
+
+        result = get_epics_for_story(story, epics)
+
+        assert result == []
+
+    def test_sorted_by_slug(self) -> None:
+        """Test results are sorted by slug."""
+        story = create_story("Shared Story")
+        epics = [
+            create_epic("zebra-epic", ["Shared Story"]),
+            create_epic("alpha-epic", ["Shared Story"]),
+        ]
+
+        result = get_epics_for_story(story, epics)
+
+        slugs = [e.slug for e in result]
+        assert slugs == ["alpha-epic", "zebra-epic"]
+
+
+class TestGetJourneysForStory:
+    """Test get_journeys_for_story function."""
+
+    def test_find_single_journey(self) -> None:
+        """Test finding a story in one journey."""
+        story = create_story("Upload Document")
+        journeys = [
+            create_journey("build-vocabulary", ["Upload Document"]),
+            create_journey("other-journey", ["Other Story"]),
+        ]
+
+        result = get_journeys_for_story(story, journeys)
+
+        assert len(result) == 1
+        assert result[0].slug == "build-vocabulary"
+
+    def test_find_multiple_journeys(self) -> None:
+        """Test finding a story in multiple journeys."""
+        story = create_story("Upload Document")
+        journeys = [
+            create_journey("journey-1", ["Upload Document"]),
+            create_journey("journey-2", ["Upload Document", "Other Story"]),
+        ]
+
+        result = get_journeys_for_story(story, journeys)
+
+        assert len(result) == 2
+
+    def test_no_matching_journeys(self) -> None:
+        """Test when story is not in any journey."""
+        story = create_story("Unknown Story")
+        journeys = [create_journey("test", ["Other Story"])]
+
+        result = get_journeys_for_story(story, journeys)
+
+        assert result == []
+
+
+class TestGetRelatedStories:
+    """Test get_related_stories function."""
+
+    def test_find_related_stories(self) -> None:
+        """Test finding stories in same epic."""
+        stories = [
+            create_story("Upload Document"),
+            create_story("Review Vocabulary"),
+            create_story("Publish Catalog"),
+            create_story("Unrelated Story"),
+        ]
+        epics = [
+            create_epic(
+                "vocabulary-management",
+                ["Upload Document", "Review Vocabulary", "Publish Catalog"],
+            ),
+        ]
+
+        result = get_related_stories(stories[0], stories, epics)
+
+        assert len(result) == 2
+        titles = {s.feature_title for s in result}
+        assert titles == {"Review Vocabulary", "Publish Catalog"}
+
+    def test_excludes_original_story(self) -> None:
+        """Test that original story is excluded from results."""
+        stories = [create_story("Upload Document")]
+        epics = [create_epic("test-epic", ["Upload Document"])]
+
+        result = get_related_stories(stories[0], stories, epics)
+
+        assert result == []
+
+    def test_multiple_epics(self) -> None:
+        """Test finding related stories across multiple epics."""
+        stories = [
+            create_story("Shared Story"),
+            create_story("Epic1 Story"),
+            create_story("Epic2 Story"),
+        ]
+        epics = [
+            create_epic("epic-1", ["Shared Story", "Epic1 Story"]),
+            create_epic("epic-2", ["Shared Story", "Epic2 Story"]),
+        ]
+
+        result = get_related_stories(stories[0], stories, epics)
+
+        assert len(result) == 2
+        titles = {s.feature_title for s in result}
+        assert titles == {"Epic1 Story", "Epic2 Story"}
+
+    def test_sorted_by_feature_title(self) -> None:
+        """Test results are sorted by feature title."""
+        stories = [
+            create_story("Main Story"),
+            create_story("Zebra Story"),
+            create_story("Alpha Story"),
+        ]
+        epics = [create_epic("test", ["Main Story", "Zebra Story", "Alpha Story"])]
+
+        result = get_related_stories(stories[0], stories, epics)
+
+        titles = [s.feature_title for s in result]
+        assert titles == ["Alpha Story", "Zebra Story"]
+
+
+class TestGetStoryCrossReferences:
+    """Test get_story_cross_references function."""
+
+    def test_cross_references(self) -> None:
+        """Test getting all cross-references for a story."""
+        stories = [
+            create_story("Upload Document"),
+            create_story("Review Vocabulary"),
+        ]
+        epics = [
+            create_epic(
+                "vocabulary-management", ["Upload Document", "Review Vocabulary"]
+            ),
+        ]
+        journeys = [
+            create_journey("build-vocabulary", ["Upload Document"]),
+        ]
+
+        result = get_story_cross_references(stories[0], stories, epics, journeys)
+
+        assert len(result["epics"]) == 1
+        assert len(result["journeys"]) == 1
+        assert len(result["related_stories"]) == 1
+        assert result["related_stories"][0].feature_title == "Review Vocabulary"

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

@@ -0,0 +1 @@
+"""Integration tests."""

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

@@ -0,0 +1 @@
+"""Parser tests."""