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

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

@@ -0,0 +1,258 @@
+"""Tests for App domain model."""
+
+import pytest
+from pydantic import ValidationError
+
+from julee.docs.sphinx_hcd.domain.models.app import App, AppType
+
+
+class TestAppType:
+    """Test AppType enum."""
+
+    def test_app_type_values(self) -> None:
+        """Test AppType enum values."""
+        assert AppType.STAFF.value == "staff"
+        assert AppType.EXTERNAL.value == "external"
+        assert AppType.MEMBER_TOOL.value == "member-tool"
+        assert AppType.UNKNOWN.value == "unknown"
+
+    def test_from_string_valid(self) -> None:
+        """Test from_string with valid values."""
+        assert AppType.from_string("staff") == AppType.STAFF
+        assert AppType.from_string("external") == AppType.EXTERNAL
+        assert AppType.from_string("member-tool") == AppType.MEMBER_TOOL
+
+    def test_from_string_case_insensitive(self) -> None:
+        """Test from_string is case-insensitive."""
+        assert AppType.from_string("STAFF") == AppType.STAFF
+        assert AppType.from_string("Staff") == AppType.STAFF
+
+    def test_from_string_unknown(self) -> None:
+        """Test from_string returns UNKNOWN for invalid values."""
+        assert AppType.from_string("invalid") == AppType.UNKNOWN
+        assert AppType.from_string("") == AppType.UNKNOWN
+
+
+class TestAppCreation:
+    """Test App model creation and validation."""
+
+    def test_create_app_with_required_fields(self) -> None:
+        """Test creating an app with minimum required fields."""
+        app = App(
+            slug="staff-portal",
+            name="Staff Portal",
+        )
+
+        assert app.slug == "staff-portal"
+        assert app.name == "Staff Portal"
+        assert app.app_type == AppType.UNKNOWN
+        assert app.status is None
+        assert app.description == ""
+        assert app.accelerators == []
+
+    def test_create_app_with_all_fields(self) -> None:
+        """Test creating an app with all fields."""
+        app = App(
+            slug="staff-portal",
+            name="Staff Portal",
+            app_type=AppType.STAFF,
+            status="live",
+            description="Portal for staff members",
+            accelerators=["user-auth", "doc-upload"],
+            manifest_path="/path/to/app.yaml",
+        )
+
+        assert app.slug == "staff-portal"
+        assert app.name == "Staff Portal"
+        assert app.app_type == AppType.STAFF
+        assert app.status == "live"
+        assert app.description == "Portal for staff members"
+        assert app.accelerators == ["user-auth", "doc-upload"]
+        assert app.manifest_path == "/path/to/app.yaml"
+
+    def test_name_normalized_computed_automatically(self) -> None:
+        """Test that name_normalized is computed from name."""
+        app = App(
+            slug="staff-portal",
+            name="Staff Portal",
+        )
+
+        assert app.name_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"):
+            App(
+                slug="",
+                name="Test App",
+            )
+
+    def test_empty_name_raises_error(self) -> None:
+        """Test that empty name raises validation error."""
+        with pytest.raises(ValidationError, match="name cannot be empty"):
+            App(
+                slug="test-app",
+                name="",
+            )
+
+    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"):
+            App(
+                slug="   ",
+                name="Test App",
+            )
+
+
+class TestAppFromManifest:
+    """Test App.from_manifest factory method."""
+
+    def test_from_manifest_creates_app(self) -> None:
+        """Test creating an app from manifest data."""
+        manifest = {
+            "name": "Staff Portal",
+            "type": "staff",
+            "status": "live",
+            "description": "Portal for staff members",
+            "accelerators": ["user-auth"],
+        }
+
+        app = App.from_manifest(
+            slug="staff-portal",
+            manifest=manifest,
+            manifest_path="/apps/staff-portal/app.yaml",
+        )
+
+        assert app.slug == "staff-portal"
+        assert app.name == "Staff Portal"
+        assert app.app_type == AppType.STAFF
+        assert app.status == "live"
+        assert app.description == "Portal for staff members"
+        assert app.accelerators == ["user-auth"]
+        assert app.manifest_path == "/apps/staff-portal/app.yaml"
+
+    def test_from_manifest_default_name(self) -> None:
+        """Test default name from slug when not in manifest."""
+        manifest = {}
+
+        app = App.from_manifest(
+            slug="staff-portal",
+            manifest=manifest,
+            manifest_path="/apps/staff-portal/app.yaml",
+        )
+
+        assert app.name == "Staff Portal"
+
+    def test_from_manifest_default_type(self) -> None:
+        """Test default type when not in manifest."""
+        manifest = {"name": "Test App"}
+
+        app = App.from_manifest(
+            slug="test-app",
+            manifest=manifest,
+            manifest_path="/apps/test-app/app.yaml",
+        )
+
+        assert app.app_type == AppType.UNKNOWN
+
+    def test_from_manifest_strips_description(self) -> None:
+        """Test that description whitespace is stripped."""
+        manifest = {
+            "name": "Test App",
+            "description": "  Some description  \n",
+        }
+
+        app = App.from_manifest(
+            slug="test-app",
+            manifest=manifest,
+            manifest_path="/apps/test-app/app.yaml",
+        )
+
+        assert app.description == "Some description"
+
+
+class TestAppMatching:
+    """Test App matching methods."""
+
+    @pytest.fixture
+    def sample_app(self) -> App:
+        """Create a sample app for testing."""
+        return App(
+            slug="staff-portal",
+            name="Staff Portal",
+            app_type=AppType.STAFF,
+        )
+
+    def test_matches_type_with_enum(self, sample_app: App) -> None:
+        """Test type matching with AppType enum."""
+        assert sample_app.matches_type(AppType.STAFF) is True
+        assert sample_app.matches_type(AppType.EXTERNAL) is False
+
+    def test_matches_type_with_string(self, sample_app: App) -> None:
+        """Test type matching with string."""
+        assert sample_app.matches_type("staff") is True
+        assert sample_app.matches_type("external") is False
+
+    def test_matches_name_exact(self, sample_app: App) -> None:
+        """Test name matching with exact name."""
+        assert sample_app.matches_name("Staff Portal") is True
+
+    def test_matches_name_case_insensitive(self, sample_app: App) -> None:
+        """Test name matching is case-insensitive."""
+        assert sample_app.matches_name("staff portal") is True
+        assert sample_app.matches_name("STAFF PORTAL") is True
+
+    def test_matches_name_no_match(self, sample_app: App) -> None:
+        """Test name matching returns False for non-match."""
+        assert sample_app.matches_name("External App") is False
+
+
+class TestAppTypeLabel:
+    """Test App type_label property."""
+
+    def test_type_label_staff(self) -> None:
+        """Test type label for staff app."""
+        app = App(slug="test", name="Test", app_type=AppType.STAFF)
+        assert app.type_label == "Staff Application"
+
+    def test_type_label_external(self) -> None:
+        """Test type label for external app."""
+        app = App(slug="test", name="Test", app_type=AppType.EXTERNAL)
+        assert app.type_label == "External Application"
+
+    def test_type_label_member_tool(self) -> None:
+        """Test type label for member tool."""
+        app = App(slug="test", name="Test", app_type=AppType.MEMBER_TOOL)
+        assert app.type_label == "Member Tool"
+
+    def test_type_label_unknown(self) -> None:
+        """Test type label for unknown type."""
+        app = App(slug="test", name="Test", app_type=AppType.UNKNOWN)
+        assert app.type_label == "Unknown"
+
+
+class TestAppSerialization:
+    """Test App serialization."""
+
+    def test_app_to_dict(self) -> None:
+        """Test app can be serialized to dict."""
+        app = App(
+            slug="test-app",
+            name="Test App",
+            app_type=AppType.STAFF,
+        )
+
+        data = app.model_dump()
+        assert data["slug"] == "test-app"
+        assert data["name"] == "Test App"
+        assert data["app_type"] == AppType.STAFF
+
+    def test_app_to_json(self) -> None:
+        """Test app can be serialized to JSON."""
+        app = App(
+            slug="test-app",
+            name="Test App",
+        )
+
+        json_str = app.model_dump_json()
+        assert '"slug":"test-app"' in json_str

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

@@ -0,0 +1,231 @@
+"""Tests for CodeInfo domain models."""
+
+import pytest
+from pydantic import ValidationError
+
+from julee.docs.sphinx_hcd.domain.models.code_info import (
+    BoundedContextInfo,
+    ClassInfo,
+)
+
+
+class TestClassInfo:
+    """Test ClassInfo model."""
+
+    def test_create_with_name_only(self) -> None:
+        """Test creating with just name."""
+        info = ClassInfo(name="Document")
+        assert info.name == "Document"
+        assert info.docstring == ""
+        assert info.file == ""
+
+    def test_create_with_all_fields(self) -> None:
+        """Test creating with all fields."""
+        info = ClassInfo(
+            name="Document",
+            docstring="A document entity.",
+            file="document.py",
+        )
+        assert info.name == "Document"
+        assert info.docstring == "A document entity."
+        assert info.file == "document.py"
+
+    def test_empty_name_raises_error(self) -> None:
+        """Test that empty name raises validation error."""
+        with pytest.raises(ValidationError, match="name cannot be empty"):
+            ClassInfo(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"):
+            ClassInfo(name="   ")
+
+    def test_name_stripped(self) -> None:
+        """Test that name is stripped of whitespace."""
+        info = ClassInfo(name="  Document  ")
+        assert info.name == "Document"
+
+
+class TestBoundedContextInfoCreation:
+    """Test BoundedContextInfo model creation and validation."""
+
+    def test_create_minimal(self) -> None:
+        """Test creating with minimum fields."""
+        info = BoundedContextInfo(slug="vocabulary")
+        assert info.slug == "vocabulary"
+        assert info.entities == []
+        assert info.use_cases == []
+        assert info.repository_protocols == []
+        assert info.service_protocols == []
+        assert info.has_infrastructure is False
+        assert info.code_dir == ""
+        assert info.objective is None
+        assert info.docstring is None
+
+    def test_create_complete(self) -> None:
+        """Test creating with all fields."""
+        entities = [
+            ClassInfo(
+                name="Vocabulary", docstring="A vocabulary entity", file="vocabulary.py"
+            ),
+            ClassInfo(name="Term", docstring="A term in a vocabulary", file="term.py"),
+        ]
+        use_cases = [
+            ClassInfo(
+                name="CreateVocabulary",
+                docstring="Create a vocabulary",
+                file="create.py",
+            ),
+        ]
+        repo_protocols = [
+            ClassInfo(
+                name="VocabularyRepository",
+                docstring="Repository protocol",
+                file="vocabulary.py",
+            ),
+        ]
+
+        info = BoundedContextInfo(
+            slug="vocabulary",
+            entities=entities,
+            use_cases=use_cases,
+            repository_protocols=repo_protocols,
+            service_protocols=[],
+            has_infrastructure=True,
+            code_dir="vocabulary",
+            objective="Manage vocabulary catalogs",
+            docstring="Full module documentation here.",
+        )
+
+        assert info.slug == "vocabulary"
+        assert len(info.entities) == 2
+        assert len(info.use_cases) == 1
+        assert len(info.repository_protocols) == 1
+        assert info.has_infrastructure is True
+        assert info.objective == "Manage vocabulary catalogs"
+
+    def test_empty_slug_raises_error(self) -> None:
+        """Test that empty slug raises validation error."""
+        with pytest.raises(ValidationError, match="slug cannot be empty"):
+            BoundedContextInfo(slug="")
+
+
+class TestBoundedContextInfoProperties:
+    """Test BoundedContextInfo properties."""
+
+    @pytest.fixture
+    def sample_context(self) -> BoundedContextInfo:
+        """Create a sample bounded context for testing."""
+        return BoundedContextInfo(
+            slug="vocabulary",
+            entities=[
+                ClassInfo(name="Vocabulary", file="vocabulary.py"),
+                ClassInfo(name="Term", file="term.py"),
+            ],
+            use_cases=[
+                ClassInfo(name="CreateVocabulary", file="create.py"),
+            ],
+            repository_protocols=[
+                ClassInfo(name="VocabularyRepository", file="vocabulary.py"),
+            ],
+            service_protocols=[
+                ClassInfo(name="NotificationService", file="notification.py"),
+            ],
+            has_infrastructure=True,
+        )
+
+    def test_entity_count(self, sample_context: BoundedContextInfo) -> None:
+        """Test entity_count property."""
+        assert sample_context.entity_count == 2
+
+    def test_use_case_count(self, sample_context: BoundedContextInfo) -> None:
+        """Test use_case_count property."""
+        assert sample_context.use_case_count == 1
+
+    def test_protocol_count(self, sample_context: BoundedContextInfo) -> None:
+        """Test protocol_count property."""
+        assert sample_context.protocol_count == 2  # 1 repo + 1 service
+
+    def test_has_entities(self, sample_context: BoundedContextInfo) -> None:
+        """Test has_entities property."""
+        assert sample_context.has_entities is True
+
+    def test_has_entities_empty(self) -> None:
+        """Test has_entities with empty context."""
+        info = BoundedContextInfo(slug="test")
+        assert info.has_entities is False
+
+    def test_has_use_cases(self, sample_context: BoundedContextInfo) -> None:
+        """Test has_use_cases property."""
+        assert sample_context.has_use_cases is True
+
+    def test_has_use_cases_empty(self) -> None:
+        """Test has_use_cases with empty context."""
+        info = BoundedContextInfo(slug="test")
+        assert info.has_use_cases is False
+
+    def test_has_protocols(self, sample_context: BoundedContextInfo) -> None:
+        """Test has_protocols property."""
+        assert sample_context.has_protocols is True
+
+    def test_has_protocols_empty(self) -> None:
+        """Test has_protocols with empty context."""
+        info = BoundedContextInfo(slug="test")
+        assert info.has_protocols is False
+
+    def test_get_entity_names(self, sample_context: BoundedContextInfo) -> None:
+        """Test get_entity_names method."""
+        names = sample_context.get_entity_names()
+        assert names == ["Vocabulary", "Term"]
+
+    def test_get_use_case_names(self, sample_context: BoundedContextInfo) -> None:
+        """Test get_use_case_names method."""
+        names = sample_context.get_use_case_names()
+        assert names == ["CreateVocabulary"]
+
+    def test_summary(self, sample_context: BoundedContextInfo) -> None:
+        """Test summary method."""
+        summary = sample_context.summary()
+        assert "2 entities" in summary
+        assert "1 use cases" in summary
+        assert "1 repository protocols" in summary
+        assert "1 service protocols" in summary
+
+    def test_summary_empty(self) -> None:
+        """Test summary with empty context."""
+        info = BoundedContextInfo(slug="test")
+        assert info.summary() == "empty"
+
+    def test_summary_partial(self) -> None:
+        """Test summary with partial data."""
+        info = BoundedContextInfo(
+            slug="test",
+            entities=[ClassInfo(name="Entity", file="e.py")],
+        )
+        summary = info.summary()
+        assert summary == "1 entities"
+
+
+class TestBoundedContextInfoSerialization:
+    """Test BoundedContextInfo serialization."""
+
+    def test_to_dict(self) -> None:
+        """Test serialization to dict."""
+        info = BoundedContextInfo(
+            slug="test",
+            entities=[ClassInfo(name="Entity", file="e.py")],
+            objective="Test objective",
+        )
+
+        data = info.model_dump()
+        assert data["slug"] == "test"
+        assert len(data["entities"]) == 1
+        assert data["entities"][0]["name"] == "Entity"
+        assert data["objective"] == "Test objective"
+
+    def test_to_json(self) -> None:
+        """Test serialization to JSON."""
+        info = BoundedContextInfo(slug="test", objective="Test")
+        json_str = info.model_dump_json()
+        assert '"slug":"test"' in json_str
+        assert '"objective":"Test"' in json_str

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

@@ -0,0 +1,163 @@
+"""Tests for Epic domain model."""
+
+import pytest
+from pydantic import ValidationError
+
+from julee.docs.sphinx_hcd.domain.models.epic import Epic
+
+
+class TestEpicCreation:
+    """Test Epic model creation and validation."""
+
+    def test_create_epic_minimal(self) -> None:
+        """Test creating an epic with minimum fields."""
+        epic = Epic(slug="vocabulary-management")
+        assert epic.slug == "vocabulary-management"
+        assert epic.description == ""
+        assert epic.story_refs == []
+        assert epic.docname == ""
+
+    def test_create_epic_complete(self) -> None:
+        """Test creating an epic with all fields."""
+        epic = Epic(
+            slug="vocabulary-management",
+            description="Manage terminology and vocabulary catalogs",
+            story_refs=["Upload Document", "Review Vocabulary", "Publish Catalog"],
+            docname="epics/vocabulary-management",
+        )
+
+        assert epic.slug == "vocabulary-management"
+        assert epic.description == "Manage terminology and vocabulary catalogs"
+        assert len(epic.story_refs) == 3
+        assert epic.docname == "epics/vocabulary-management"
+
+    def test_empty_slug_raises_error(self) -> None:
+        """Test that empty slug raises validation error."""
+        with pytest.raises(ValidationError, match="slug cannot be empty"):
+            Epic(slug="")
+
+    def test_whitespace_slug_raises_error(self) -> None:
+        """Test that whitespace-only slug raises validation error."""
+        with pytest.raises(ValidationError, match="slug cannot be empty"):
+            Epic(slug="   ")
+
+    def test_slug_stripped(self) -> None:
+        """Test that slug is stripped of whitespace."""
+        epic = Epic(slug="  vocabulary-management  ")
+        assert epic.slug == "vocabulary-management"
+
+
+class TestEpicStoryOperations:
+    """Test Epic story reference operations."""
+
+    @pytest.fixture
+    def sample_epic(self) -> Epic:
+        """Create a sample epic for testing."""
+        return Epic(
+            slug="vocabulary-management",
+            description="Manage terminology",
+            story_refs=["Upload Document", "Review Vocabulary"],
+            docname="epics/vocabulary-management",
+        )
+
+    def test_add_story(self) -> None:
+        """Test adding a story to an epic."""
+        epic = Epic(slug="test-epic")
+        assert epic.story_count == 0
+
+        epic.add_story("New Story")
+        assert epic.story_count == 1
+        assert "New Story" in epic.story_refs
+
+    def test_has_story_exact_match(self, sample_epic: Epic) -> None:
+        """Test has_story with exact match."""
+        assert sample_epic.has_story("Upload Document") is True
+        assert sample_epic.has_story("Review Vocabulary") is True
+
+    def test_has_story_case_insensitive(self, sample_epic: Epic) -> None:
+        """Test has_story is case-insensitive."""
+        assert sample_epic.has_story("upload document") is True
+        assert sample_epic.has_story("UPLOAD DOCUMENT") is True
+        assert sample_epic.has_story("Upload document") is True
+
+    def test_has_story_no_match(self, sample_epic: Epic) -> None:
+        """Test has_story returns False for non-match."""
+        assert sample_epic.has_story("Unknown Story") is False
+
+    def test_get_story_refs_normalized(self, sample_epic: Epic) -> None:
+        """Test getting normalized story references."""
+        normalized = sample_epic.get_story_refs_normalized()
+        assert normalized == ["upload document", "review vocabulary"]
+
+
+class TestEpicProperties:
+    """Test Epic properties."""
+
+    def test_display_title(self) -> None:
+        """Test display_title property."""
+        epic = Epic(slug="vocabulary-management")
+        assert epic.display_title == "Vocabulary Management"
+
+    def test_display_title_multiple_words(self) -> None:
+        """Test display_title with multiple hyphens."""
+        epic = Epic(slug="credential-creation-workflow")
+        assert epic.display_title == "Credential Creation Workflow"
+
+    def test_story_count_empty(self) -> None:
+        """Test story_count with no stories."""
+        epic = Epic(slug="test")
+        assert epic.story_count == 0
+
+    def test_story_count_with_stories(self) -> None:
+        """Test story_count with stories."""
+        epic = Epic(slug="test", story_refs=["Story 1", "Story 2", "Story 3"])
+        assert epic.story_count == 3
+
+    def test_has_stories_empty(self) -> None:
+        """Test has_stories with no stories."""
+        epic = Epic(slug="test")
+        assert epic.has_stories is False
+
+    def test_has_stories_with_stories(self) -> None:
+        """Test has_stories with stories."""
+        epic = Epic(slug="test", story_refs=["Story 1"])
+        assert epic.has_stories is True
+
+
+class TestEpicSerialization:
+    """Test Epic serialization."""
+
+    def test_epic_to_dict(self) -> None:
+        """Test epic can be serialized to dict."""
+        epic = Epic(
+            slug="test",
+            description="Test description",
+            story_refs=["Story 1"],
+            docname="test/doc",
+        )
+
+        data = epic.model_dump()
+        assert data["slug"] == "test"
+        assert data["description"] == "Test description"
+        assert data["story_refs"] == ["Story 1"]
+        assert data["docname"] == "test/doc"
+
+    def test_epic_to_json(self) -> None:
+        """Test epic can be serialized to JSON."""
+        epic = Epic(slug="test", description="Test")
+        json_str = epic.model_dump_json()
+        assert '"slug":"test"' in json_str
+        assert '"description":"Test"' in json_str
+
+    def test_epic_from_dict(self) -> None:
+        """Test epic can be deserialized from dict."""
+        data = {
+            "slug": "test",
+            "description": "Test description",
+            "story_refs": ["Story 1", "Story 2"],
+            "docname": "test/doc",
+        }
+        epic = Epic.model_validate(data)
+        assert epic.slug == "test"
+        assert epic.description == "Test description"
+        assert len(epic.story_refs) == 2