8069ed6465
- Add delete_bounties method to BountyService that returns individual results per bounty ID (deleted, not_found, permission_denied) - Update cmd_delete to accept multiple IDs and show per-ID messages - Add tests for delete_bounties Example output: /delete 1 2 3 ✅ Bounty #1 deleted. ✅ Bounty #2 deleted. ⛔ Bounty #3 not found. Fixes #47
403 lines
16 KiB
Python
403 lines
16 KiB
Python
"""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)
|
|
self.admin_user_id = 123
|
|
self._make_admin(-1001, self.admin_user_id)
|
|
|
|
def _make_admin(self, room_id: int, user_id: int):
|
|
"""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_user_ids=[]
|
|
)
|
|
if user_id not in (room_data.admin_user_ids or []):
|
|
room_data.admin_user_ids = room_data.admin_user_ids or []
|
|
room_data.admin_user_ids.append(user_id)
|
|
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=self.admin_user_id,
|
|
text="Fix bug",
|
|
link="https://github.com/issue/1",
|
|
)
|
|
assert bounty.id == 1
|
|
assert bounty.text == "Fix bug"
|
|
assert bounty.created_by_user_id == self.admin_user_id
|
|
|
|
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=self.admin_user_id, text="First"
|
|
)
|
|
b2 = self.service.add_bounty(
|
|
room_id=-1001, user_id=self.admin_user_id, text="Second"
|
|
)
|
|
b3 = self.service.add_bounty(
|
|
room_id=-1001, user_id=self.admin_user_id, 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, 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=self.admin_user_id, text="First")
|
|
self.service.add_bounty(
|
|
room_id=-1001, user_id=self.admin_user_id, text="Second"
|
|
)
|
|
# Add bounty to different room to verify isolation
|
|
self._make_admin(-999, self.admin_user_id)
|
|
self.service.add_bounty(
|
|
room_id=-999, user_id=self.admin_user_id, 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=self.admin_user_id, 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=self.admin_user_id, 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=self.admin_user_id, text="Original"
|
|
)
|
|
result = self.service.update_bounty(
|
|
room_id=-1001,
|
|
bounty_id=bounty.id,
|
|
user_id=self.admin_user_id,
|
|
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=self.admin_user_id, text="Original"
|
|
)
|
|
with pytest.raises(PermissionError, match="Only admins can edit bounties"):
|
|
self.service.update_bounty(
|
|
room_id=-1001,
|
|
bounty_id=bounty.id,
|
|
user_id=999, # 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,
|
|
user_id=self.admin_user_id,
|
|
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=self.admin_user_id,
|
|
text="Original",
|
|
link="https://original.link",
|
|
)
|
|
self.service.update_bounty(
|
|
room_id=-1001,
|
|
bounty_id=bounty.id,
|
|
user_id=self.admin_user_id,
|
|
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=self.admin_user_id,
|
|
text="Test",
|
|
link="https://original.link",
|
|
)
|
|
self.service.update_bounty(
|
|
room_id=-1001,
|
|
bounty_id=bounty.id,
|
|
user_id=self.admin_user_id,
|
|
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=self.admin_user_id, text="To delete"
|
|
)
|
|
result = self.service.delete_bounty(-1001, bounty.id, self.admin_user_id)
|
|
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=self.admin_user_id, text="To delete"
|
|
)
|
|
with pytest.raises(PermissionError, match="Only admins can delete bounties"):
|
|
self.service.delete_bounty(
|
|
-1001, bounty.id, 999
|
|
) # different user, not admin
|
|
|
|
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_user_id)
|
|
assert result is False
|
|
|
|
def test_delete_bounties_multiple_success(self):
|
|
"""Test delete_bounties soft deletes multiple bounties."""
|
|
b1 = self.service.add_bounty(
|
|
room_id=-1001, user_id=self.admin_user_id, text="First"
|
|
)
|
|
b2 = self.service.add_bounty(
|
|
room_id=-1001, user_id=self.admin_user_id, text="Second"
|
|
)
|
|
b3 = self.service.add_bounty(
|
|
room_id=-1001, user_id=self.admin_user_id, text="Third"
|
|
)
|
|
results = self.service.delete_bounties(
|
|
-1001, [b1.id, b2.id, b3.id], self.admin_user_id
|
|
)
|
|
assert results == {b1.id: "deleted", b2.id: "deleted", b3.id: "deleted"}
|
|
assert self.service.get_bounty(-1001, b1.id) is None
|
|
assert self.service.get_bounty(-1001, b2.id) is None
|
|
assert self.service.get_bounty(-1001, b3.id) is None
|
|
|
|
def test_delete_bounties_mixed_results(self):
|
|
"""Test delete_bounties returns individual results per ID."""
|
|
b1 = self.service.add_bounty(
|
|
room_id=-1001, user_id=self.admin_user_id, text="Exists"
|
|
)
|
|
results = self.service.delete_bounties(
|
|
-1001, [b1.id, 999, 888], self.admin_user_id
|
|
)
|
|
assert results == {b1.id: "deleted", 999: "not_found", 888: "not_found"}
|
|
|
|
def test_delete_bounties_permission_denied(self):
|
|
"""Test delete_bounties returns permission_denied for non-admin."""
|
|
b1 = self.service.add_bounty(
|
|
room_id=-1001, user_id=self.admin_user_id, text="First"
|
|
)
|
|
b2 = self.service.add_bounty(
|
|
room_id=-1001, user_id=self.admin_user_id, text="Second"
|
|
)
|
|
results = self.service.delete_bounties(
|
|
-1001,
|
|
[b1.id, b2.id],
|
|
999, # non-admin user
|
|
)
|
|
assert results == {b1.id: "permission_denied", b2.id: "permission_denied"}
|
|
# Bounties should not be deleted
|
|
assert self.service.get_bounty(-1001, b1.id) is not None
|
|
assert self.service.get_bounty(-1001, b2.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_user_id = 123
|
|
self._make_admin(-1001, self.admin_user_id)
|
|
|
|
def _make_admin(self, room_id: int, user_id: int):
|
|
"""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_user_ids=[]
|
|
)
|
|
if user_id not in (room_data.admin_user_ids or []):
|
|
room_data.admin_user_ids = room_data.admin_user_ids or []
|
|
room_data.admin_user_ids.append(user_id)
|
|
self.room_storage.save(room_data)
|
|
|
|
def _add_bounty(self, room_id=-1001, user_id=123, text="Test bounty"):
|
|
"""Helper to add a bounty for tracking tests."""
|
|
if self.room_storage.load(room_id) is None or user_id not in (
|
|
self.room_storage.load(room_id).admin_user_ids or []
|
|
):
|
|
self._make_admin(room_id, user_id)
|
|
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"
|