Merge pull request #2169 from lexicalunit/deleted-games-bug-fix

Fix lfg bug with deleted games

Author: lexicalunit

CHANGELOG.md

@@ -7,6 +7,10 @@ and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.
 
 ## [Unreleased]
 
+### Fixed
+
+- Fixed some edge case bugs with deleted games and user queues.
+
 ## [v17.10.0](https://github.com/lexicalunit/spellbot/releases/tag/v17.10.0) - 2026-01-22
 
 ### Added

src/spellbot/models/user.py

@@ -84,6 +84,7 @@ def game(self, channel_xid: int) -> Game | None:
             .filter(
                 Queue.user_xid == self.xid,
                 Post.channel_xid == channel_xid,
+                Game.deleted_at.is_(None),
             )
             .order_by(Game.updated_at.desc())
             .first()
@@ -104,10 +105,18 @@ def waiting(self, channel_xid: int) -> bool:
     def pending_games(self) -> int:
         from spellbot.database import DatabaseSession  # allow_inline
 
-        from . import Queue  # allow_inline
+        from . import Game, Queue  # allow_inline
 
         session = DatabaseSession.object_session(self)
-        return session.query(Queue).filter(Queue.user_xid == self.xid).count()
+        return (
+            session.query(Queue)
+            .join(Game)
+            .filter(
+                Queue.user_xid == self.xid,
+                Game.deleted_at.is_(None),
+            )
+            .count()
+        )
 
     def to_dict(self) -> UserDict:
         return {

src/spellbot/services/games.py

@@ -436,10 +436,15 @@ def filter_blocked_list(self, author_xid: int, other_xids: list[int]) -> list[in
     @sync_to_async()
     @tracer.wrap()
     def filter_pending_games(self, user_xids: list[int]) -> list[int]:
-        rows = DatabaseSession.query(
-            Queue.user_xid,
-            func.count(Queue.user_xid).label("pending"),
-        ).group_by(Queue.user_xid)
+        rows = (
+            DatabaseSession.query(
+                Queue.user_xid,
+                func.count(Queue.user_xid).label("pending"),
+            )
+            .join(Game)
+            .filter(Game.deleted_at.is_(None))
+            .group_by(Queue.user_xid)
+        )
         counts = {row[0]: row[1] for row in rows if row[0]}
 
         return [

src/spellbot/services/users.py

@@ -81,6 +81,7 @@ def current_game_id(self, channel_xid: int) -> int | None:
                 and_(
                     Queue.user_xid == self.user.xid,
                     Post.channel_xid == channel_xid,
+                    Game.deleted_at.is_(None),
                 ),
             )
             .first()
@@ -98,6 +99,7 @@ def leave_game(self, channel_xid: int) -> None:
                 and_(
                     Queue.user_xid == self.user.xid,
                     Post.channel_xid == channel_xid,
+                    Game.deleted_at.is_(None),
                 ),
             )
         )

tests/models/test_user.py

@@ -54,6 +54,44 @@ def test_pending_games(self, factories: Factories) -> None:
         user = factories.user.create(game=game)
         assert user.pending_games() == 1
 
+    def test_pending_games_deleted_game(self, factories: Factories) -> None:
+        guild = factories.guild.create()
+        channel = factories.channel.create(guild=guild)
+        game = factories.game.create(
+            guild=guild,
+            channel=channel,
+            deleted_at=datetime(2021, 11, 1, tzinfo=UTC),
+        )
+        user = factories.user.create(game=game)
+        # Orphaned queue entry for deleted game should not count
+        assert user.pending_games() == 0
+
+
+class TestModelUserGame:
+    def test_happy_path(self, factories: Factories) -> None:
+        guild = factories.guild.create()
+        channel = factories.channel.create(guild=guild)
+        game = factories.game.create(guild=guild, channel=channel)
+        user = factories.user.create(game=game)
+        assert user.game(channel.xid) == game
+
+    def test_no_game(self, factories: Factories) -> None:
+        guild = factories.guild.create()
+        channel = factories.channel.create(guild=guild)
+        user = factories.user.create()
+        assert user.game(channel.xid) is None
+
+    def test_deleted_game(self, factories: Factories) -> None:
+        guild = factories.guild.create()
+        channel = factories.channel.create(guild=guild)
+        game = factories.game.create(
+            guild=guild,
+            channel=channel,
+            deleted_at=datetime(2021, 11, 1, tzinfo=UTC),
+        )
+        user = factories.user.create(game=game)
+        assert user.game(channel.xid) is None
+
 
 class TestModelUserWaiting:
     def test_happy_path(self, factories: Factories) -> None:

tests/services/test_games.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING
 from unittest.mock import patch
 
 import pytest
@@ -21,6 +23,9 @@
     WatchFactory,
 )
 
+if TYPE_CHECKING:
+    from tests.fixtures import Factories
+
 pytestmark = pytest.mark.use_db
 
 
@@ -210,6 +215,24 @@ async def test_happy_path(self) -> None:
             games = GamesService()
             assert await games.filter_pending_games([user1.xid, user2.xid]) == [user2.xid]
 
+    async def test_deleted_game(self, factories: Factories) -> None:
+        guild = factories.guild.create()
+        channel = factories.channel.create(guild=guild)
+        user = factories.user.create()
+        deleted_game = factories.game.create(
+            status=GameStatus.PENDING.value,
+            guild=guild,
+            channel=channel,
+            deleted_at=datetime(2021, 11, 1, tzinfo=UTC),
+        )
+        # Orphaned queue entry for deleted game
+        QueueFactory.create(game_id=deleted_game.id, user_xid=user.xid)
+
+        with patch("spellbot.services.games.settings.MAX_PENDING_GAMES", 2):
+            games = GamesService()
+            # User should be allowed since deleted game doesn't count
+            assert await games.filter_pending_games([user.xid]) == [user.xid]
+
 
 @pytest.mark.asyncio
 class TestServiceGamesBlocked:

tests/services/test_users.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+from datetime import UTC, datetime
+from typing import TYPE_CHECKING
 from unittest.mock import ANY, MagicMock
 
 import pytest
@@ -9,6 +11,9 @@
 from spellbot.services import UsersService
 from tests.factories import UserFactory
 
+if TYPE_CHECKING:
+    from tests.fixtures import Factories
+
 pytestmark = pytest.mark.use_db
 
 
@@ -196,3 +201,53 @@ async def test_users_leave_game(self, game: Game) -> None:
         await users.leave_game(game.channel_xid)
 
         assert DatabaseSession.query(Queue).count() == 0
+
+    async def test_users_current_game_id_deleted_game(self, factories: Factories) -> None:
+        guild = factories.guild.create()
+        channel = factories.channel.create(guild=guild)
+        game = factories.game.create(
+            guild=guild,
+            channel=channel,
+            deleted_at=datetime(2021, 11, 1, tzinfo=UTC),
+        )
+        user = factories.user.create(game=game)
+
+        users = UsersService()
+        await users.select(user.xid)
+        assert await users.current_game_id(channel.xid) is None
+
+    async def test_users_is_waiting_deleted_game(self, factories: Factories) -> None:
+        guild = factories.guild.create()
+        channel = factories.channel.create(guild=guild)
+        game = factories.game.create(
+            guild=guild,
+            channel=channel,
+            deleted_at=datetime(2021, 11, 1, tzinfo=UTC),
+        )
+        user = factories.user.create(game=game)
+
+        users = UsersService()
+        await users.select(user.xid)
+        assert not await users.is_waiting(channel.xid)
+
+    async def test_users_leave_game_deleted_game(self, factories: Factories) -> None:
+        guild = factories.guild.create()
+        channel = factories.channel.create(guild=guild)
+        game = factories.game.create(
+            guild=guild,
+            channel=channel,
+            deleted_at=datetime(2021, 11, 1, tzinfo=UTC),
+        )
+        user = factories.user.create(game=game)
+
+        users = UsersService()
+        await users.select(user.xid)
+
+        # Queue entry still exists (game was soft-deleted but queue wasn't cleaned up)
+        assert DatabaseSession.query(Queue).count() == 1
+
+        # leave_game should not find the deleted game, so queue should remain
+        await users.leave_game(channel.xid)
+
+        # Queue entry should still exist since the game was deleted
+        assert DatabaseSession.query(Queue).count() == 1