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

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

@@ -0,0 +1,172 @@
+"""Tests for Persona domain model."""
+
+import pytest
+from pydantic import ValidationError
+
+from julee.docs.sphinx_hcd.domain.models.persona import Persona
+
+
+class TestPersonaCreation:
+    """Test Persona model creation and validation."""
+
+    def test_create_persona_minimal(self) -> None:
+        """Test creating a persona with minimum fields."""
+        persona = Persona(name="Knowledge Curator")
+        assert persona.name == "Knowledge Curator"
+        assert persona.app_slugs == []
+        assert persona.epic_slugs == []
+
+    def test_create_persona_complete(self) -> None:
+        """Test creating a persona with all fields."""
+        persona = Persona(
+            name="Knowledge Curator",
+            app_slugs=["vocabulary-tool", "admin-portal"],
+            epic_slugs=["vocabulary-management", "credential-creation"],
+        )
+
+        assert persona.name == "Knowledge Curator"
+        assert len(persona.app_slugs) == 2
+        assert len(persona.epic_slugs) == 2
+
+    def test_empty_name_raises_error(self) -> None:
+        """Test that empty name raises validation error."""
+        with pytest.raises(ValidationError, match="name cannot be empty"):
+            Persona(name="")
+
+    def test_whitespace_name_raises_error(self) -> None:
+        """Test that whitespace-only name raises validation error."""
+        with pytest.raises(ValidationError, match="name cannot be empty"):
+            Persona(name="   ")
+
+    def test_name_stripped(self) -> None:
+        """Test that name is stripped of whitespace."""
+        persona = Persona(name="  Knowledge Curator  ")
+        assert persona.name == "Knowledge Curator"
+
+
+class TestPersonaProperties:
+    """Test Persona properties."""
+
+    @pytest.fixture
+    def sample_persona(self) -> Persona:
+        """Create a sample persona for testing."""
+        return Persona(
+            name="Knowledge Curator",
+            app_slugs=["vocabulary-tool", "admin-portal"],
+            epic_slugs=["vocabulary-management", "credential-creation"],
+        )
+
+    def test_normalized_name(self, sample_persona: Persona) -> None:
+        """Test normalized_name computed field."""
+        assert sample_persona.normalized_name == "knowledge curator"
+
+    def test_display_name(self, sample_persona: Persona) -> None:
+        """Test display_name property."""
+        assert sample_persona.display_name == "Knowledge Curator"
+
+    def test_app_count(self, sample_persona: Persona) -> None:
+        """Test app_count property."""
+        assert sample_persona.app_count == 2
+
+    def test_epic_count(self, sample_persona: Persona) -> None:
+        """Test epic_count property."""
+        assert sample_persona.epic_count == 2
+
+    def test_has_apps_true(self, sample_persona: Persona) -> None:
+        """Test has_apps property when true."""
+        assert sample_persona.has_apps is True
+
+    def test_has_apps_false(self) -> None:
+        """Test has_apps property when false."""
+        persona = Persona(name="Test")
+        assert persona.has_apps is False
+
+    def test_has_epics_true(self, sample_persona: Persona) -> None:
+        """Test has_epics property when true."""
+        assert sample_persona.has_epics is True
+
+    def test_has_epics_false(self) -> None:
+        """Test has_epics property when false."""
+        persona = Persona(name="Test")
+        assert persona.has_epics is False
+
+
+class TestPersonaMethods:
+    """Test Persona methods."""
+
+    @pytest.fixture
+    def sample_persona(self) -> Persona:
+        """Create a sample persona for testing."""
+        return Persona(
+            name="Knowledge Curator",
+            app_slugs=["vocabulary-tool", "admin-portal"],
+            epic_slugs=["vocabulary-management"],
+        )
+
+    def test_uses_app_true(self, sample_persona: Persona) -> None:
+        """Test uses_app returns True for used app."""
+        assert sample_persona.uses_app("vocabulary-tool") is True
+        assert sample_persona.uses_app("admin-portal") is True
+
+    def test_uses_app_false(self, sample_persona: Persona) -> None:
+        """Test uses_app returns False for unused app."""
+        assert sample_persona.uses_app("unknown-app") is False
+
+    def test_participates_in_epic_true(self, sample_persona: Persona) -> None:
+        """Test participates_in_epic returns True."""
+        assert sample_persona.participates_in_epic("vocabulary-management") is True
+
+    def test_participates_in_epic_false(self, sample_persona: Persona) -> None:
+        """Test participates_in_epic returns False."""
+        assert sample_persona.participates_in_epic("unknown-epic") is False
+
+    def test_add_app_new(self) -> None:
+        """Test adding a new app."""
+        persona = Persona(name="Test")
+        persona.add_app("new-app")
+        assert "new-app" in persona.app_slugs
+        assert persona.app_count == 1
+
+    def test_add_app_duplicate(self, sample_persona: Persona) -> None:
+        """Test adding a duplicate app is ignored."""
+        initial_count = sample_persona.app_count
+        sample_persona.add_app("vocabulary-tool")
+        assert sample_persona.app_count == initial_count
+
+    def test_add_epic_new(self) -> None:
+        """Test adding a new epic."""
+        persona = Persona(name="Test")
+        persona.add_epic("new-epic")
+        assert "new-epic" in persona.epic_slugs
+        assert persona.epic_count == 1
+
+    def test_add_epic_duplicate(self, sample_persona: Persona) -> None:
+        """Test adding a duplicate epic is ignored."""
+        initial_count = sample_persona.epic_count
+        sample_persona.add_epic("vocabulary-management")
+        assert sample_persona.epic_count == initial_count
+
+
+class TestPersonaSerialization:
+    """Test Persona serialization."""
+
+    def test_persona_to_dict(self) -> None:
+        """Test persona can be serialized to dict."""
+        persona = Persona(
+            name="Test Persona",
+            app_slugs=["app-1"],
+            epic_slugs=["epic-1"],
+        )
+
+        data = persona.model_dump()
+        assert data["name"] == "Test Persona"
+        assert data["app_slugs"] == ["app-1"]
+        assert data["epic_slugs"] == ["epic-1"]
+        assert data["normalized_name"] == "test persona"
+
+    def test_persona_to_json(self) -> None:
+        """Test persona can be serialized to JSON."""
+        persona = Persona(name="Test Persona")
+        json_str = persona.model_dump_json()
+        assert '"name":"Test Persona"' in json_str
+        assert '"normalized_name":"test persona"' in json_str

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

@@ -0,0 +1,216 @@
+"""Tests for Story domain model."""
+
+import pytest
+from pydantic import ValidationError
+
+from julee.docs.sphinx_hcd.domain.models.story import Story
+
+
+class TestStoryCreation:
+    """Test Story model creation and validation."""
+
+    def test_create_story_with_required_fields(self) -> None:
+        """Test creating a story with minimum required fields."""
+        story = Story(
+            slug="submit-order",
+            feature_title="Submit Order",
+            persona="Customer",
+            app_slug="checkout-app",
+            file_path="tests/e2e/checkout-app/features/submit_order.feature",
+        )
+
+        assert story.slug == "submit-order"
+        assert story.feature_title == "Submit Order"
+        assert story.persona == "Customer"
+        assert story.app_slug == "checkout-app"
+        assert story.file_path == "tests/e2e/checkout-app/features/submit_order.feature"
+
+    def test_create_story_with_all_fields(self) -> None:
+        """Test creating a story with all fields."""
+        story = Story(
+            slug="submit-order",
+            feature_title="Submit Order",
+            persona="Customer",
+            persona_normalized="customer",
+            i_want="submit my order",
+            so_that="I can purchase products",
+            app_slug="checkout-app",
+            app_normalized="checkout app",
+            file_path="tests/e2e/checkout-app/features/submit.feature",
+            abs_path="/abs/path/to/submit.feature",
+            gherkin_snippet="Feature: Submit Order\n  As a Customer",
+        )
+
+        assert story.slug == "submit-order"
+        assert story.persona_normalized == "customer"
+        assert story.i_want == "submit my order"
+        assert story.so_that == "I can purchase products"
+        assert story.gherkin_snippet == "Feature: Submit Order\n  As a Customer"
+
+    def test_normalized_fields_computed_automatically(self) -> None:
+        """Test that normalized fields are computed from raw values."""
+        story = Story(
+            slug="test",
+            feature_title="Test Feature",
+            persona="Staff Member",
+            app_slug="Staff-Portal",
+            file_path="test.feature",
+        )
+
+        assert story.persona_normalized == "staff member"
+        assert story.app_normalized == "staff portal"
+
+    def test_empty_slug_raises_error(self) -> None:
+        """Test that empty slug raises validation error."""
+        with pytest.raises(ValidationError, match="slug cannot be empty"):
+            Story(
+                slug="",
+                feature_title="Test",
+                persona="User",
+                app_slug="app",
+                file_path="test.feature",
+            )
+
+    def test_empty_feature_title_raises_error(self) -> None:
+        """Test that empty feature title raises validation error."""
+        with pytest.raises(ValidationError, match="Feature title cannot be empty"):
+            Story(
+                slug="test",
+                feature_title="",
+                persona="User",
+                app_slug="app",
+                file_path="test.feature",
+            )
+
+    def test_empty_persona_defaults_to_unknown(self) -> None:
+        """Test that empty persona defaults to 'unknown'."""
+        story = Story(
+            slug="test",
+            feature_title="Test",
+            persona="",
+            app_slug="app",
+            file_path="test.feature",
+        )
+        assert story.persona == "unknown"
+
+    def test_empty_app_slug_defaults_to_unknown(self) -> None:
+        """Test that empty app slug defaults to 'unknown'."""
+        story = Story(
+            slug="test",
+            feature_title="Test",
+            persona="User",
+            app_slug="",
+            file_path="test.feature",
+        )
+        assert story.app_slug == "unknown"
+
+    def test_whitespace_only_slug_raises_error(self) -> None:
+        """Test that whitespace-only slug raises validation error."""
+        with pytest.raises(ValidationError, match="slug cannot be empty"):
+            Story(
+                slug="   ",
+                feature_title="Test",
+                persona="User",
+                app_slug="app",
+                file_path="test.feature",
+            )
+
+
+class TestStoryFromFeatureFile:
+    """Test Story.from_feature_file factory method."""
+
+    def test_from_feature_file_creates_story(self) -> None:
+        """Test creating a story from feature file data."""
+        story = Story.from_feature_file(
+            feature_title="Upload Document",
+            persona="Staff Member",
+            i_want="upload a document",
+            so_that="it can be analyzed",
+            app_slug="staff-portal",
+            file_path="tests/e2e/staff-portal/features/upload.feature",
+            abs_path="/home/project/tests/e2e/staff-portal/features/upload.feature",
+            gherkin_snippet="Feature: Upload Document",
+        )
+
+        assert (
+            story.slug == "staff-portal--upload-document"
+        )  # App prefix prevents collisions
+        assert story.feature_title == "Upload Document"
+        assert story.persona == "Staff Member"
+        assert story.persona_normalized == "staff member"
+        assert story.i_want == "upload a document"
+        assert story.so_that == "it can be analyzed"
+        assert story.app_slug == "staff-portal"
+
+
+class TestStoryMatching:
+    """Test Story matching methods."""
+
+    @pytest.fixture
+    def sample_story(self) -> Story:
+        """Create a sample story for testing."""
+        return Story(
+            slug="test-story",
+            feature_title="Test Story",
+            persona="Staff Member",
+            app_slug="staff-portal",
+            file_path="test.feature",
+        )
+
+    def test_matches_persona_exact(self, sample_story: Story) -> None:
+        """Test persona matching with exact name."""
+        assert sample_story.matches_persona("Staff Member") is True
+
+    def test_matches_persona_case_insensitive(self, sample_story: Story) -> None:
+        """Test persona matching is case-insensitive."""
+        assert sample_story.matches_persona("staff member") is True
+        assert sample_story.matches_persona("STAFF MEMBER") is True
+
+    def test_matches_persona_no_match(self, sample_story: Story) -> None:
+        """Test persona matching returns False for non-match."""
+        assert sample_story.matches_persona("Customer") is False
+
+    def test_matches_app_exact(self, sample_story: Story) -> None:
+        """Test app matching with exact name."""
+        assert sample_story.matches_app("staff-portal") is True
+
+    def test_matches_app_with_different_separators(self, sample_story: Story) -> None:
+        """Test app matching handles different separators."""
+        assert sample_story.matches_app("staff portal") is True
+        assert sample_story.matches_app("Staff Portal") is True
+
+    def test_matches_app_no_match(self, sample_story: Story) -> None:
+        """Test app matching returns False for non-match."""
+        assert sample_story.matches_app("checkout-app") is False
+
+
+class TestStorySerialization:
+    """Test Story serialization."""
+
+    def test_story_to_dict(self) -> None:
+        """Test story can be serialized to dict."""
+        story = Story(
+            slug="test",
+            feature_title="Test",
+            persona="User",
+            app_slug="app",
+            file_path="test.feature",
+        )
+
+        data = story.model_dump()
+        assert data["slug"] == "test"
+        assert data["feature_title"] == "Test"
+        assert data["persona"] == "User"
+
+    def test_story_to_json(self) -> None:
+        """Test story can be serialized to JSON."""
+        story = Story(
+            slug="test",
+            feature_title="Test",
+            persona="User",
+            app_slug="app",
+            file_path="test.feature",
+        )
+
+        json_str = story.model_dump_json()
+        assert '"slug":"test"' in json_str

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

@@ -0,0 +1 @@
+"""Tests for domain use cases."""