"""Tests for web dependencies."""

from unittest.mock import MagicMock

from app.domain.roles import Role
from app.presentation.web.deps import (
    can_create_post,
    can_delete_post,
    can_edit_post,
    can_see_draft,
    get_user_role,
)


class TestGetUserRole:
    """Test get_user_role function."""

    def test_none_returns_guest(self) -> None:
        """Test None user returns GUEST role."""
        assert get_user_role(None) == Role.GUEST

    def test_admin_roles(self) -> None:
        """Test admin role detection."""
        user = MagicMock()
        user.roles = ["admin"]
        assert get_user_role(user) == Role.ADMIN

    def test_user_roles(self) -> None:
        """Test user role detection."""
        user = MagicMock()
        user.roles = ["user"]
        assert get_user_role(user) == Role.USER

    def test_empty_roles_returns_guest(self) -> None:
        """Test empty roles list returns GUEST."""
        user = MagicMock()
        user.roles = []
        assert get_user_role(user) == Role.GUEST


class TestCanCreatePost:
    """Test can_create_post function."""

    def test_guest_cannot_create(self) -> None:
        """Test guest cannot create posts."""
        assert can_create_post(None) is False

    def test_user_can_create(self) -> None:
        """Test user can create posts."""
        user = MagicMock()
        user.roles = ["user"]
        assert can_create_post(user) is True

    def test_admin_can_create(self) -> None:
        """Test admin can create posts."""
        user = MagicMock()
        user.roles = ["admin"]
        assert can_create_post(user) is True


class TestCanEditPost:
    """Test can_edit_post function."""

    def test_guest_cannot_edit(self) -> None:
        """Test guest cannot edit any post."""
        assert can_edit_post(None, "author-1") is False

    def test_user_can_edit_own(self) -> None:
        """Test user can edit own post."""
        user = MagicMock()
        user.roles = ["user"]
        user.user_id = "author-1"
        assert can_edit_post(user, "author-1") is True

    def test_user_cannot_edit_other(self) -> None:
        """Test user cannot edit other's post."""
        user = MagicMock()
        user.roles = ["user"]
        user.user_id = "user-2"
        assert can_edit_post(user, "author-1") is False

    def test_admin_can_edit_any(self) -> None:
        """Test admin can edit any post."""
        user = MagicMock()
        user.roles = ["admin"]
        user.user_id = "admin-1"
        assert can_edit_post(user, "author-1") is True


class TestCanDeletePost:
    """Test can_delete_post function."""

    def test_delegates_to_can_edit(self) -> None:
        """Test can_delete_post delegates to can_edit_post logic."""
        user = MagicMock()
        user.roles = ["user"]
        user.user_id = "author-1"
        assert can_delete_post(user, "author-1") is True

    def test_guest_cannot_delete(self) -> None:
        """Test guest cannot delete posts."""
        assert can_delete_post(None, "author-1") is False


class TestCanSeeDraft:
    """Test can_see_draft function."""

    def test_guest_cannot_see(self) -> None:
        """Test guest cannot see drafts."""
        assert can_see_draft(None, "author-1") is False

    def test_user_can_see_own(self) -> None:
        """Test user can see own draft."""
        user = MagicMock()
        user.roles = ["user"]
        user.user_id = "author-1"
        assert can_see_draft(user, "author-1") is True

    def test_user_cannot_see_other(self) -> None:
        """Test user cannot see other's draft."""
        user = MagicMock()
        user.roles = ["user"]
        user.user_id = "user-2"
        assert can_see_draft(user, "author-1") is False

    def test_admin_can_see_any(self) -> None:
        """Test admin can see any draft."""
        user = MagicMock()
        user.roles = ["admin"]
        user.user_id = "admin-1"
        assert can_see_draft(user, "author-1") is True