From 3feab1d469f9d42ec3bc6c861cfe5349aca76fd3 Mon Sep 17 00:00:00 2001
From: shokollm <270575765+shokollm@users.noreply.github.com>
Date: Fri, 3 Apr 2026 11:36:07 +0000
Subject: [PATCH] test(services): add unit tests for BountyService and
 TrackingService

- Test BountyService: add_bounty, list_bounties, get_bounty, update_bounty, delete_bounty
- Test TrackingService: track_bounty, untrack_bounty, get_tracked_bounties
- Test edge cases: permission errors, not found, duplicate tracking
---
 tests/test_services.py | 289 +++++++++++++++++++++++++++++++++++++++++
 1 file changed, 289 insertions(+)
 create mode 100644 tests/test_services.py

diff --git a/tests/test_services.py b/tests/test_services.py
new file mode 100644
index 0000000..8be148a
--- /dev/null
+++ b/tests/test_services.py
@@ -0,0 +1,289 @@
+"""Tests for core/services.py — business logic services."""
+
+import pytest
+from unittest.mock import MagicMock
+
+from core.models import Bounty, RoomData, TrackingData, TrackedBounty
+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)
+
+    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,
+            text="Fix bug",
+            link="https://github.com/issue/1",
+        )
+        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, text="First")
+        b2 = self.service.add_bounty(room_id=-1001, user_id=123, text="Second")
+        b3 = self.service.add_bounty(room_id=-1001, user_id=123, text="Third")
+
+        assert b1.id == 1
+        assert b2.id == 2
+        assert b3.id == 3
+
+    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, text="First")
+        self.service.add_bounty(room_id=-1001, user_id=123, text="Second")
+        self.service.add_bounty(room_id=-999, user_id=123, 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, 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, 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 creator updates their bounty."""
+        bounty = self.service.add_bounty(room_id=-1001, user_id=123, text="Original")
+        result = self.service.update_bounty(
+            room_id=-1001,
+            bounty_id=bounty.id,
+            user_id=123,
+            text="Updated",
+        )
+        assert result is True
+        updated = self.service.get_bounty(-1001, bounty.id)
+        assert updated.text == "Updated"
+
+    def test_update_bounty_not_creator_raises_permission_error(self):
+        """Test update_bounty raises PermissionError when non-creator tries to update."""
+        bounty = self.service.add_bounty(room_id=-1001, user_id=123, text="Original")
+        with pytest.raises(PermissionError, match="Only the creator can edit"):
+            self.service.update_bounty(
+                room_id=-1001,
+                bounty_id=bounty.id,
+                user_id=999,  # different user
+                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,
+            user_id=123,
+            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,
+            text="Original",
+            link="https://original.link",
+        )
+        self.service.update_bounty(
+            room_id=-1001,
+            bounty_id=bounty.id,
+            user_id=123,
+            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,
+            text="Test",
+            link="https://original.link",
+        )
+        self.service.update_bounty(
+            room_id=-1001,
+            bounty_id=bounty.id,
+            user_id=123,
+            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 succeeds when creator deletes their bounty."""
+        bounty = self.service.add_bounty(room_id=-1001, user_id=123, text="To delete")
+        result = self.service.delete_bounty(-1001, bounty.id, 123)
+        assert result is True
+        assert self.service.get_bounty(-1001, bounty.id) is None
+
+    def test_delete_bounty_not_creator_raises_permission_error(self):
+        """Test delete_bounty raises PermissionError when non-creator tries to delete."""
+        bounty = self.service.add_bounty(room_id=-1001, user_id=123, text="To delete")
+        with pytest.raises(PermissionError, match="Only the creator can delete"):
+            self.service.delete_bounty(-1001, bounty.id, 999)  # different user
+
+    def test_delete_bounty_not_found(self):
+        """Test delete_bounty returns False when bounty doesn't exist."""
+        result = self.service.delete_bounty(-1001, 999, 123)
+        assert result is False
+
+
+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)
+
+    def _add_bounty(self, room_id=-1001, user_id=123, text="Test bounty"):
+        """Helper to add a bounty for tracking tests."""
+        bounty_service = BountyService(self.room_storage)
+        return bounty_service.add_bounty(room_id=room_id, user_id=user_id, 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, text="To delete")
+        self.service.track_bounty(-1001, 123456, bounty.id)
+
+        # Delete the bounty
+        bounty_service.delete_bounty(-1001, bounty.id, 123)
+
+        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"