test(unit): add roles, web deps, use cases, VO boundary tests — reach 70% coverage

tests/unit/domain/test_entities.py

@@ -1,5 +1,6 @@
 """Tests for domain entities."""
 
+from typing import Any
 from uuid import UUID
 
 from app.domain.entities import Post
@@ -126,3 +127,19 @@ class TestPost:
         assert "id" in data
         assert "created_at" in data
         assert "updated_at" in data
+
+    def test_base_entity_eq_and_hash(self) -> None:
+        """Test BaseEntity equality and hash directly."""
+        from app.domain.entities.base import BaseEntity
+
+        class ConcreteEntity(BaseEntity):
+            def to_dict(self) -> dict[str, Any]:
+                return {}
+
+        e1 = ConcreteEntity()
+        e2 = ConcreteEntity()
+        e2.id = e1.id
+
+        assert BaseEntity.__eq__(e1, e2) is True
+        assert BaseEntity.__eq__(e1, "not an entity") == NotImplemented
+        assert BaseEntity.__hash__(e1) == hash(e1.id)

tests/unit/domain/test_roles.py

@@ -1,11 +1,17 @@
 """Tests for role-based access control."""
 
+from typing import Any
+
+import pytest
+
+from app.domain.exceptions import ForbiddenException
 from app.domain.roles import (
     ROLE_PERMISSIONS,
     Permission,
     Role,
     get_effective_role,
     has_permission,
+    require_permission,
 )
 
 
@@ -121,3 +127,61 @@ class TestGetEffectiveRole:
         assert get_effective_role(["user", "admin", "guest"]) == Role.ADMIN
         # User takes precedence over guest
         assert get_effective_role(["guest", "user"]) == Role.USER
+
+
+class TestRequirePermission:
+    """Test require_permission decorator."""
+
+    async def test_admin_passes_permission_check(self) -> None:
+        """Test admin with permission succeeds."""
+
+        @require_permission(Permission.POST_CREATE)
+        async def dummy(*, token_info: Any = None) -> str:
+            return "ok"
+
+        token = type("TokenInfo", (), {"roles": ["admin"]})()
+        result = await dummy(token_info=token)
+        assert result == "ok"
+
+    async def test_user_passes_permission_check(self) -> None:
+        """Test user with permission succeeds."""
+
+        @require_permission(Permission.POST_READ)
+        async def dummy(*, token_info: Any = None) -> str:
+            return "ok"
+
+        token = type("TokenInfo", (), {"roles": ["user"]})()
+        result = await dummy(token_info=token)
+        assert result == "ok"
+
+    async def test_no_token_raises(self) -> None:
+        """Test missing token raises ForbiddenException."""
+
+        @require_permission(Permission.POST_CREATE)
+        async def dummy(*, token_info: Any = None) -> str:
+            return "ok"
+
+        with pytest.raises(ForbiddenException, match="Authentication required"):
+            await dummy()
+
+    async def test_guest_without_permission_raises(self) -> None:
+        """Test guest lacking permission raises ForbiddenException."""
+
+        @require_permission(Permission.POST_CREATE)
+        async def dummy(*, token_info: Any = None) -> str:
+            return "ok"
+
+        token = type("TokenInfo", (), {"roles": []})()
+        with pytest.raises(ForbiddenException, match="Permission 'post:create' required"):
+            await dummy(token_info=token)
+
+    async def test_user_forbidden_unpublished(self) -> None:
+        """Test user cannot read unpublished via decorator."""
+
+        @require_permission(Permission.POST_READ_UNPUBLISHED)
+        async def dummy(*, token_info: Any = None) -> str:
+            return "ok"
+
+        token = type("TokenInfo", (), {"roles": ["user"]})()
+        with pytest.raises(ForbiddenException, match="Permission 'post:read_unpublished' required"):
+            await dummy(token_info=token)

tests/unit/domain/test_value_objects.py

@@ -91,3 +91,73 @@ class TestSlug:
         slug2 = Slug("test-slug")
         assert slug1 == slug2
         assert hash(slug1) == hash(slug2)
+
+    def test_slug_str_and_primitive(self) -> None:
+        """Test slug string and primitive conversion."""
+        slug = Slug("test-slug")
+        assert str(slug) == "test-slug"
+        assert slug.to_primitive() == "test-slug"
+
+    def test_slug_eq_with_non_value_object(self) -> None:
+        """Test slug equality with non-ValueObject returns False."""
+        slug = Slug("test-slug")
+        assert slug != "test-slug"
+
+    def test_slug_not_string(self) -> None:
+        """Test non-string slug raises ValueError."""
+        with pytest.raises(ValueError, match="string"):
+            Slug(123)  # type: ignore[arg-type]
+
+    def test_slug_too_long(self) -> None:
+        """Test slug exceeding max length raises ValueError."""
+        with pytest.raises(ValueError, match="at most"):
+            Slug("a" * 201)
+
+
+class TestValueObjectBase:
+    """Test base ValueObject behavior across types."""
+
+    def test_title_eq_with_non_value_object(self) -> None:
+        """Test title equality with non-ValueObject returns False."""
+        title = Title("Test Title")
+        assert title != "Test Title"
+
+    def test_content_str_and_primitive(self) -> None:
+        """Test content string and primitive conversion."""
+        content = Content("Enough characters for valid content")
+        assert str(content) == "Enough characters for valid content"
+        assert content.to_primitive() == "Enough characters for valid content"
+
+    def test_content_not_string(self) -> None:
+        """Test non-string content raises ValueError."""
+        with pytest.raises(ValueError, match="string"):
+            Content(123)  # type: ignore[arg-type]
+
+    def test_value_object_eq_and_hash_directly(self) -> None:
+        """Test ValueObject base eq and hash via direct call."""
+        from app.domain.value_objects.base import ValueObject
+
+        class SimpleVO(ValueObject[str]):
+            def _validate(self) -> None:
+                pass
+
+        vo1 = SimpleVO("test")
+        vo2 = SimpleVO("test")
+        vo3 = SimpleVO("other")
+
+        assert ValueObject.__eq__(vo1, vo2) is True
+        assert ValueObject.__eq__(vo1, vo3) is False
+        assert ValueObject.__eq__(vo1, "test") is False
+        assert ValueObject.__hash__(vo1) == hash("test")
+
+    def test_content_exact_min_length(self) -> None:
+        """Test content at exact minimum length boundary."""
+        min_content = "a" * 10
+        content = Content(min_content)
+        assert content.value == min_content
+
+    def test_slug_exact_max_length(self) -> None:
+        """Test slug at exact maximum length boundary."""
+        max_slug = "a" * 200
+        slug = Slug(max_slug)
+        assert slug.value == max_slug