jigaido/tests/test_services.py

"""Tests for core/services.py — business logic services."""

import pytest

from core.models import RoomData
from core.services import BountyService, TrackingService
from tests.test_ports import MockRoomStorage, MockTrackingStorage


class TestBountyService:
    """Unit tests for BountyService."""

    def setup_method(self):
        """Set up fresh storage and service for each test."""
        self.storage = MockRoomStorage()
        self.service = BountyService(self.storage)
        self.admin_username = "admin"
        self._make_admin(-1001, self.admin_username)

    def _make_admin(self, room_id: int, username: str):
        """Helper to set up a room with an admin user."""
        room_data = self.storage.load(room_id)
        if room_data is None:
            room_data = RoomData(
                room_id=room_id, bounties=[], next_id=0, admin_usernames=[]
            )
        if username not in (room_data.admin_usernames or []):
            room_data.admin_usernames = room_data.admin_usernames or []
            room_data.admin_usernames.append(username)
        self.storage.save(room_data)

    def test_add_bounty_creates_room_if_not_exists(self):
        """Test that add_bounty creates a new room if it doesn't exist."""
        bounty = self.service.add_bounty(
            room_id=-1001,
            user_id=123,
            username=self.admin_username,
            text="Fix bug",
            link="https://github.com/issue/1",
            created_by_username=self.admin_username,
        )
        assert bounty.id == 1
        assert bounty.text == "Fix bug"
        assert bounty.created_by_user_id == 123

        room = self.storage.load(-1001)
        assert room is not None
        assert len(room.bounties) == 1

    def test_add_bounty_increments_id(self):
        """Test that add_bounty increments bounty ID for each new bounty."""
        b1 = self.service.add_bounty(
            room_id=-1001, user_id=123, username=self.admin_username, text="First"
        )
        b2 = self.service.add_bounty(
            room_id=-1001, user_id=123, username=self.admin_username, text="Second"
        )
        b3 = self.service.add_bounty(
            room_id=-1001, user_id=123, username=self.admin_username, text="Third"
        )

        assert b1.id == 1
        assert b2.id == 2
        assert b3.id == 3

    def test_add_bounty_requires_admin(self):
        """Test that add_bounty raises PermissionError when non-admin tries to add."""
        with pytest.raises(PermissionError, match="Only admins can add bounties"):
            self.service.add_bounty(
                room_id=-1001, user_id=999, username="nonadmin", text="Not admin"
            )

    def test_list_bounties_empty_room(self):
        """Test list_bounties returns empty list for non-existent room."""
        bounties = self.service.list_bounties(-1001)
        assert bounties == []

    def test_list_bounties_returns_all_bounties(self):
        """Test list_bounties returns all bounties in a room."""
        self.service.add_bounty(
            room_id=-1001, user_id=123, username=self.admin_username, text="First"
        )
        self.service.add_bounty(
            room_id=-1001, user_id=123, username=self.admin_username, text="Second"
        )
        # Add bounty to different room to verify isolation
        self._make_admin(-999, "otheradmin")
        self.service.add_bounty(
            room_id=-999, user_id=456, username="otheradmin", text="Other room"
        )

        bounties = self.service.list_bounties(-1001)
        assert len(bounties) == 2
        assert all(b.text in ["First", "Second"] for b in bounties)

    def test_get_bounty_found(self):
        """Test get_bounty returns bounty when it exists."""
        created = self.service.add_bounty(
            room_id=-1001, user_id=123, username=self.admin_username, text="Test"
        )
        found = self.service.get_bounty(-1001, created.id)
        assert found is not None
        assert found.text == "Test"

    def test_get_bounty_not_found(self):
        """Test get_bounty returns None when bounty doesn't exist."""
        found = self.service.get_bounty(-1001, 999)
        assert found is None

    def test_get_bounty_wrong_room(self):
        """Test get_bounty returns None when bounty is in different room."""
        self.service.add_bounty(
            room_id=-1001, user_id=123, username=self.admin_username, text="Test"
        )
        found = self.service.get_bounty(-999, 1)  # room -999 doesn't have bounty 1
        assert found is None

    def test_update_bounty_success(self):
        """Test update_bounty succeeds when admin updates their bounty."""
        bounty = self.service.add_bounty(
            room_id=-1001, user_id=123, username=self.admin_username, text="Original"
        )
        result = self.service.update_bounty(
            room_id=-1001,
            bounty_id=bounty.id,
            username=self.admin_username,
            text="Updated",
        )
        assert result is True
        updated = self.service.get_bounty(-1001, bounty.id)
        assert updated.text == "Updated"

    def test_update_bounty_not_admin_raises_permission_error(self):
        """Test update_bounty raises PermissionError when non-admin tries to update."""
        bounty = self.service.add_bounty(
            room_id=-1001, user_id=123, username=self.admin_username, text="Original"
        )
        with pytest.raises(PermissionError, match="Only admins can edit bounties"):
            self.service.update_bounty(
                room_id=-1001,
                bounty_id=bounty.id,
                username="nonadmin",  # different user, not admin
                text="Hacked",
            )

    def test_update_bounty_not_found(self):
        """Test update_bounty returns False when bounty doesn't exist."""
        result = self.service.update_bounty(
            room_id=-1001,
            bounty_id=999,
            username=self.admin_username,
            text="Updated",
        )
        assert result is False

    def test_update_bounty_partial_update(self):
        """Test update_bounty only updates provided fields."""
        bounty = self.service.add_bounty(
            room_id=-1001,
            user_id=123,
            username=self.admin_username,
            text="Original",
            link="https://original.link",
        )
        self.service.update_bounty(
            room_id=-1001,
            bounty_id=bounty.id,
            username=self.admin_username,
            text="Updated only text",
        )
        updated = self.service.get_bounty(-1001, bounty.id)
        assert updated.text == "Updated only text"
        assert updated.link == "https://original.link"  # link unchanged

    def test_update_bounty_clear_link(self):
        """Test update_bounty can clear link."""
        bounty = self.service.add_bounty(
            room_id=-1001,
            user_id=123,
            username=self.admin_username,
            text="Test",
            link="https://original.link",
        )
        self.service.update_bounty(
            room_id=-1001,
            bounty_id=bounty.id,
            username=self.admin_username,
            clear_link=True,
        )
        updated = self.service.get_bounty(-1001, bounty.id)
        assert updated.link is None

    def test_delete_bounty_success(self):
        """Test delete_bounty soft deletes when admin deletes their bounty."""
        bounty = self.service.add_bounty(
            room_id=-1001, user_id=123, username=self.admin_username, text="To delete"
        )
        result = self.service.delete_bounty(-1001, bounty.id, self.admin_username)
        assert result is True
        # Soft delete - bounty should not be found via get_bounty
        assert self.service.get_bounty(-1001, bounty.id) is None
        # But still exists in list_deleted_bounties
        deleted = self.service.list_deleted_bounties(-1001)
        assert len(deleted) == 1
        assert deleted[0].id == bounty.id

    def test_delete_bounty_not_admin_raises_permission_error(self):
        """Test delete_bounty raises PermissionError when non-admin tries to delete."""
        bounty = self.service.add_bounty(
            room_id=-1001, user_id=123, username=self.admin_username, text="To delete"
        )
        with pytest.raises(PermissionError, match="Only admins can delete bounties"):
            self.service.delete_bounty(-1001, bounty.id, "nonadmin")

    def test_delete_bounty_not_found(self):
        """Test delete_bounty returns False when bounty doesn't exist."""
        result = self.service.delete_bounty(-1001, 999, self.admin_username)
        assert result is False

    def test_delete_bounties_multi_id_success(self):
        """Test delete_bounties returns individual results for multiple bounties."""
        bounty1 = self.service.add_bounty(
            room_id=-1001, user_id=123, username=self.admin_username, text="To delete 1"
        )
        bounty2 = self.service.add_bounty(
            room_id=-1001, user_id=123, username=self.admin_username, text="To delete 2"
        )
        results = self.service.delete_bounties(
            -1001, [bounty1.id, bounty2.id], self.admin_username
        )
        assert results == {bounty1.id: "deleted", bounty2.id: "deleted"}
        # Verify both are soft deleted
        assert self.service.get_bounty(-1001, bounty1.id) is None
        assert self.service.get_bounty(-1001, bounty2.id) is None

    def test_delete_bounties_mixed_results(self):
        """Test delete_bounties returns not_found for non-existent bounties."""
        bounty = self.service.add_bounty(
            room_id=-1001, user_id=123, username=self.admin_username, text="To delete"
        )
        results = self.service.delete_bounties(
            -1001, [bounty.id, 999, 888], self.admin_username
        )
        assert results == {bounty.id: "deleted", 999: "not_found", 888: "not_found"}

    def test_delete_bounties_permission_denied(self):
        """Test delete_bounties returns permission_denied for non-admin users."""
        bounty = self.service.add_bounty(
            room_id=-1001, user_id=123, username=self.admin_username, text="To delete"
        )
        results = self.service.delete_bounties(
            -1001,
            [bounty.id],
            "nonadmin",  # non-admin user
        )
        assert results == {bounty.id: "permission_denied"}
        # Verify bounty was NOT deleted
        assert self.service.get_bounty(-1001, bounty.id) is not None


class TestTrackingService:
    """Unit tests for TrackingService."""

    def setup_method(self):
        """Set up fresh storage and service for each test."""
        self.room_storage = MockRoomStorage()
        self.tracking_storage = MockTrackingStorage()
        self.service = TrackingService(self.tracking_storage, self.room_storage)
        self.admin_username = "admin"
        self._make_admin(-1001, self.admin_username)

    def _make_admin(self, room_id: int, username: str):
        """Helper to set up a room with an admin user."""
        room_data = self.room_storage.load(room_id)
        if room_data is None:
            room_data = RoomData(
                room_id=room_id, bounties=[], next_id=0, admin_usernames=[]
            )
        if username not in (room_data.admin_usernames or []):
            room_data.admin_usernames = room_data.admin_usernames or []
            room_data.admin_usernames.append(username)
        self.room_storage.save(room_data)

    def _add_bounty(self, room_id=-1001, username="admin", text="Test bounty"):
        """Helper to add a bounty for tracking tests."""
        if self.room_storage.load(room_id) is None or username not in (
            self.room_storage.load(room_id).admin_usernames or []
        ):
            self._make_admin(room_id, username)
        bounty_service = BountyService(self.room_storage)
        return bounty_service.add_bounty(
            room_id=room_id, user_id=123, username=username, text=text
        )

    def test_track_bounty_success(self):
        """Test track_bounty successfully tracks a bounty."""
        bounty = self._add_bounty()
        result = self.service.track_bounty(-1001, 123456, bounty.id)
        assert result is True

        tracked = self.service.get_tracked_bounties(-1001, 123456)
        assert len(tracked) == 1
        assert tracked[0].id == bounty.id

    def test_track_bounty_returns_false_if_already_tracking(self):
        """Test track_bounty returns False if bounty is already tracked."""
        bounty = self._add_bounty()
        self.service.track_bounty(-1001, 123456, bounty.id)
        result = self.service.track_bounty(-1001, 123456, bounty.id)
        assert result is False

    def test_track_bounty_raises_value_error_if_bounty_not_found(self):
        """Test track_bounty raises ValueError if bounty doesn't exist."""
        with pytest.raises(ValueError, match="Bounty not found"):
            self.service.track_bounty(-1001, 123456, 999)

    def test_track_bounty_different_users_can_track_same_bounty(self):
        """Test that different users can track the same bounty."""
        bounty = self._add_bounty()
        self.service.track_bounty(-1001, 111, bounty.id)
        self.service.track_bounty(-1001, 222, bounty.id)

        tracked_by_111 = self.service.get_tracked_bounties(-1001, 111)
        tracked_by_222 = self.service.get_tracked_bounties(-1001, 222)

        assert len(tracked_by_111) == 1
        assert len(tracked_by_222) == 1
        assert tracked_by_111[0].id == bounty.id
        assert tracked_by_222[0].id == bounty.id

    def test_untrack_bounty_success(self):
        """Test untrack_bounty successfully untracks a bounty."""
        bounty = self._add_bounty()
        self.service.track_bounty(-1001, 123456, bounty.id)

        result = self.service.untrack_bounty(-1001, 123456, bounty.id)
        assert result is True

        tracked = self.service.get_tracked_bounties(-1001, 123456)
        assert len(tracked) == 0

    def test_untrack_bounty_returns_false_if_not_tracking(self):
        """Test untrack_bounty returns False if bounty was not being tracked."""
        bounty = self._add_bounty()
        result = self.service.untrack_bounty(-1001, 123456, bounty.id)
        assert result is False

    def test_untrack_bounty_returns_false_if_tracking_different_bounty(self):
        """Test untrack_bounty returns False if tracking different bounty."""
        b1 = self._add_bounty(text="Bounty 1")
        b2 = self._add_bounty(text="Bounty 2")
        self.service.track_bounty(-1001, 123456, b1.id)

        result = self.service.untrack_bounty(-1001, 123456, b2.id)
        assert result is False

        # b1 should still be tracked
        tracked = self.service.get_tracked_bounties(-1001, 123456)
        assert len(tracked) == 1
        assert tracked[0].id == b1.id

    def test_get_tracked_bounties_empty(self):
        """Test get_tracked_bounties returns empty list when nothing tracked."""
        tracked = self.service.get_tracked_bounties(-1001, 123456)
        assert tracked == []

    def test_get_tracked_bounties_returns_tracked_bounties(self):
        """Test get_tracked_bounties returns all bounties tracked by user."""
        b1 = self._add_bounty(text="First")
        b2 = self._add_bounty(text="Second")
        self.service.track_bounty(-1001, 123456, b1.id)
        self.service.track_bounty(-1001, 123456, b2.id)

        tracked = self.service.get_tracked_bounties(-1001, 123456)
        assert len(tracked) == 2
        assert all(t.text in ["First", "Second"] for t in tracked)

    def test_get_tracked_bounties_ignores_deleted_bounties(self):
        """Test get_tracked_bounties ignores bounties that were deleted."""
        bounty_service = BountyService(self.room_storage)
        bounty = bounty_service.add_bounty(
            room_id=-1001, user_id=123, username="admin", text="To delete"
        )
        self.service.track_bounty(-1001, 123456, bounty.id)

        # Delete the bounty
        bounty_service.delete_bounty(-1001, bounty.id, "admin")

        tracked = self.service.get_tracked_bounties(-1001, 123456)
        assert len(tracked) == 0  # deleted bounty not returned

    def test_get_tracked_bounties_different_rooms_independent(self):
        """Test that tracking in different rooms is independent."""
        b1 = self._add_bounty(room_id=-1001, text="Room 1")
        b2 = self._add_bounty(room_id=-999, text="Room 2")

        self.service.track_bounty(-1001, 123456, b1.id)
        self.service.track_bounty(-999, 123456, b2.id)

        tracked_room1 = self.service.get_tracked_bounties(-1001, 123456)
        tracked_room2 = self.service.get_tracked_bounties(-999, 123456)

        assert len(tracked_room1) == 1
        assert len(tracked_room2) == 1
        assert tracked_room1[0].text == "Room 1"
        assert tracked_room2[0].text == "Room 2"


class TestCategoryService:
    """Unit tests for category management."""

    def setup_method(self):
        """Set up fresh storage and service for each test."""
        self.storage = MockRoomStorage()
        self.service = BountyService(self.storage)
        self.admin_username = "admin"
        self._make_admin(-1001, self.admin_username)

    def _make_admin(self, room_id: int, username: str):
        """Helper to set up a room with an admin user."""
        room_data = self.storage.load(room_id)
        if room_data is None:
            room_data = RoomData(
                room_id=room_id, bounties=[], next_id=0, admin_usernames=[]
            )
        if username not in (room_data.admin_usernames or []):
            room_data.admin_usernames = room_data.admin_usernames or []
            room_data.admin_usernames.append(username)
        self.storage.save(room_data)

    def _add_bounty(self, text="Test bounty"):
        """Helper to add a bounty for category tests."""
        return self.service.add_bounty(
            room_id=-1001, user_id=123, username=self.admin_username, text=text
        )

    # Category Management Tests

    def test_add_category_requires_admin(self):
        """Test that add_category raises PermissionError for non-admin."""
        with pytest.raises(PermissionError, match="Only admins can add categories"):
            self.service.add_category(-1001, "bug", "Bug Report", "nonadmin")

    def test_add_category_duplicate_slug_fails(self):
        """Test that adding a duplicate category slug raises ValueError."""
        self.service.add_category(-1001, "bug", "Bug Report", self.admin_username)
        with pytest.raises(ValueError, match="already exists"):
            self.service.add_category(-1001, "bug", "Bug Report 2", self.admin_username)

    def test_add_category_invalid_slug_fails_uppercase(self):
        """Test that uppercase slug raises ValueError."""
        with pytest.raises(ValueError, match="lowercase alphabetic only"):
            self.service.add_category(-1001, "Bug", "Bug Report", self.admin_username)

    def test_add_category_invalid_slug_fails_with_numbers(self):
        """Test that slug with numbers raises ValueError."""
        with pytest.raises(ValueError, match="lowercase alphabetic only"):
            self.service.add_category(-1001, "bug1", "Bug 1", self.admin_username)

    def test_add_category_invalid_slug_fails_with_symbols(self):
        """Test that slug with symbols raises ValueError."""
        with pytest.raises(ValueError, match="lowercase alphabetic only"):
            self.service.add_category(-1001, "bug-fix", "Bug Fix", self.admin_username)

    def test_add_category_invalid_slug_fails_empty(self):
        """Test that empty slug raises ValueError."""
        with pytest.raises(ValueError, match="lowercase alphabetic only"):
            self.service.add_category(-1001, "", "Empty", self.admin_username)

    def test_add_category_valid(self):
        """Test that valid category can be created."""
        category = self.service.add_category(
            -1001, "bug", "Bug Report", self.admin_username
        )
        assert category.id == "bug"
        assert category.name == "Bug Report"
        assert category.created_at > 0
        assert category.deleted_at is None

    def test_delete_category_soft_deletes(self):
        """Test that delete_category performs soft delete."""
        self.service.add_category(-1001, "bug", "Bug Report", self.admin_username)
        result = self.service.delete_category(-1001, "bug", self.admin_username)
        assert result is True

        # Category should not be found via get_category
        assert self.service.get_category(-1001, "bug") is None

        # But should still be in raw room data (soft delete)
        room_data = self.storage.load(-1001)
        for cat in room_data.categories:
            if cat.id == "bug":
                assert cat.deleted_at is not None
                return
        assert False, "Category should still exist in storage"

    def test_deleted_category_not_listed(self):
        """Test that list_categories excludes soft-deleted categories."""
        self.service.add_category(-1001, "bug", "Bug Report", self.admin_username)
        self.service.delete_category(-1001, "bug", self.admin_username)

        categories = self.service.list_categories(-1001)
        assert len(categories) == 0
        assert not any(cat.id == "bug" for cat in categories)

    def test_list_categories_empty(self):
        """Test that list_categories returns empty list for room with no categories."""
        categories = self.service.list_categories(-1001)
        assert categories == []

    def test_list_categories_returns_active(self):
        """Test that list_categories returns only active categories."""
        self.service.add_category(-1001, "bug", "Bug Report", self.admin_username)
        self.service.add_category(-1001, "feature", "Feature Request", self.admin_username)
        self.service.add_category(-1001, "docs", "Documentation", self.admin_username)
        self.service.delete_category(-1001, "bug", self.admin_username)

        categories = self.service.list_categories(-1001)
        assert len(categories) == 2
        category_ids = [c.id for c in categories]
        assert "feature" in category_ids
        assert "docs" in category_ids
        assert "bug" not in category_ids

    def test_get_category_not_found(self):
        """Test that get_category returns None for non-existent category."""
        category = self.service.get_category(-1001, "nonexistent")
        assert category is None

    def test_get_category_deleted_returns_none(self):
        """Test that get_category returns None for soft-deleted category."""
        self.service.add_category(-1001, "bug", "Bug Report", self.admin_username)
        self.service.delete_category(-1001, "bug", self.admin_username)

        category = self.service.get_category(-1001, "bug")
        assert category is None

    def test_add_category_requires_admin_non_existent_room(self):
        """Test that add_category works for non-existent room (creates it)."""
        self._make_admin(-9999, self.admin_username)
        category = self.service.add_category(
            -9999, "bug", "Bug Report", self.admin_username
        )
        assert category.id == "bug"

    # Category-to-Bounty Association Tests

    def test_add_category_to_bounty(self):
        """Test adding category to a bounty."""
        self.service.add_category(-1001, "bug", "Bug Report", self.admin_username)
        bounty = self._add_bounty()

        result = self.service.add_category_to_bounty(
            -1001, bounty.id, "bug", self.admin_username
        )
        assert result is True

        updated_bounty = self.service.get_bounty(-1001, bounty.id)
        assert "bug" in updated_bounty.category_ids

    def test_add_duplicate_category_to_bounty_noop(self):
        """Test that adding duplicate category returns False."""
        self.service.add_category(-1001, "bug", "Bug Report", self.admin_username)
        bounty = self._add_bounty()

        self.service.add_category_to_bounty(-1001, bounty.id, "bug", self.admin_username)
        result = self.service.add_category_to_bounty(
            -1001, bounty.id, "bug", self.admin_username
        )
        assert result is False

    def test_add_category_to_bounty_invalid_bounty(self):
        """Test that adding category to non-existent bounty raises ValueError."""
        self.service.add_category(-1001, "bug", "Bug Report", self.admin_username)

        with pytest.raises(ValueError, match="Bounty not found"):
            self.service.add_category_to_bounty(-1001, 999, "bug", self.admin_username)

    def test_add_category_to_bounty_invalid_category(self):
        """Test that adding non-existent category raises ValueError."""
        bounty = self._add_bounty()

        with pytest.raises(ValueError, match="not found"):
            self.service.add_category_to_bounty(
                -1001, bounty.id, "nonexistent", self.admin_username
            )

    def test_remove_category_from_bounty(self):
        """Test removing category from a bounty."""
        self.service.add_category(-1001, "bug", "Bug Report", self.admin_username)
        bounty = self._add_bounty()
        self.service.add_category_to_bounty(-1001, bounty.id, "bug", self.admin_username)

        result = self.service.remove_category_from_bounty(
            -1001, bounty.id, "bug", self.admin_username
        )
        assert result is True

        updated_bounty = self.service.get_bounty(-1001, bounty.id)
        assert "bug" not in updated_bounty.category_ids

    def test_remove_category_not_on_bounty_returns_false(self):
        """Test that removing category not on bounty returns False."""
        self.service.add_category(-1001, "bug", "Bug Report", self.admin_username)
        bounty = self._add_bounty()

        result = self.service.remove_category_from_bounty(
            -1001, bounty.id, "bug", self.admin_username
        )
        assert result is False

    def test_update_bounty_categories_replace_all(self):
        """Test that update_bounty_categories replaces all categories."""
        self.service.add_category(-1001, "bug", "Bug Report", self.admin_username)
        self.service.add_category(-1001, "feature", "Feature Request", self.admin_username)
        self.service.add_category(-1001, "docs", "Documentation", self.admin_username)
        bounty = self._add_bounty()

        # Add initial categories
        self.service.add_category_to_bounty(-1001, bounty.id, "bug", self.admin_username)

        # Replace with different categories
        self.service.update_bounty_categories(
            -1001, bounty.id, ["feature", "docs"], self.admin_username
        )

        updated_bounty = self.service.get_bounty(-1001, bounty.id)
        assert updated_bounty.category_ids == ["feature", "docs"]

    def test_update_bounty_categories_clear_all(self):
        """Test that update_bounty_categories can clear all categories."""
        self.service.add_category(-1001, "bug", "Bug Report", self.admin_username)
        bounty = self._add_bounty()
        self.service.add_category_to_bounty(-1001, bounty.id, "bug", self.admin_username)

        self.service.update_bounty_categories(-1001, bounty.id, [], self.admin_username)

        updated_bounty = self.service.get_bounty(-1001, bounty.id)
        assert updated_bounty.category_ids == []

    def test_update_bounty_categories_validates(self):
        """Test that update_bounty_categories validates all slugs."""
        self.service.add_category(-1001, "bug", "Bug Report", self.admin_username)
        bounty = self._add_bounty()

        with pytest.raises(ValueError, match="not found"):
            self.service.update_bounty_categories(
                -1001, bounty.id, ["bug", "nonexistent"], self.admin_username
            )

    def test_add_category_to_bounty_requires_admin(self):
        """Test that adding category to bounty requires admin."""
        self.service.add_category(-1001, "bug", "Bug Report", self.admin_username)
        bounty = self._add_bounty()

        with pytest.raises(PermissionError, match="Only admins"):
            self.service.add_category_to_bounty(
                -1001, bounty.id, "bug", "nonadmin"
            )

    def test_remove_category_from_bounty_requires_admin(self):
        """Test that removing category from bounty requires admin."""
        self.service.add_category(-1001, "bug", "Bug Report", self.admin_username)
        bounty = self._add_bounty()
        self.service.add_category_to_bounty(-1001, bounty.id, "bug", self.admin_username)

        with pytest.raises(PermissionError, match="Only admins"):
            self.service.remove_category_from_bounty(
                -1001, bounty.id, "bug", "nonadmin"
            )

    def test_update_bounty_categories_requires_admin(self):
        """Test that updating bounty categories requires admin."""
        bounty = self._add_bounty()

        with pytest.raises(PermissionError, match="Only admins"):
            self.service.update_bounty_categories(
                -1001, bounty.id, ["bug"], "nonadmin"
            )

    def test_delete_category_requires_admin(self):
        """Test that deleting category requires admin."""
        self.service.add_category(-1001, "bug", "Bug Report", self.admin_username)

        with pytest.raises(PermissionError, match="Only admins"):
            self.service.delete_category(-1001, "bug", "nonadmin")