feat: add game cancellation (#1)

Author: emptybutton

src/ttt/application/game/cancel_game.py

@@ -0,0 +1,50 @@
+from asyncio import gather
+from dataclasses import dataclass
+
+from ttt.application.common.ports.map import Map
+from ttt.application.common.ports.transaction import Transaction
+from ttt.application.common.ports.uuids import UUIDs
+from ttt.application.game.ports.game_views import GameViews
+from ttt.application.game.ports.games import Games
+from ttt.entities.core.game.game import AlreadyCompletedGameError
+from ttt.entities.core.player.location import PlayerLocation
+from ttt.entities.tools.assertion import not_none
+from ttt.entities.tools.tracking import Tracking
+
+
+@dataclass(frozen=True, unsafe_hash=False)
+class CancelGame:
+    map_: Map
+    games: Games
+    game_views: GameViews
+    uuids: UUIDs
+    transaction: Transaction
+
+    async def __call__(self, location: PlayerLocation) -> None:
+        async with self.transaction:
+            game, game_result_id = await gather(
+                self.games.game_with_game_location(location.player_id),
+                self.uuids.random_uuid(),
+            )
+            if game is None:
+                await self.game_views.render_no_game_view(location)
+                return
+
+            locations = tuple(
+                not_none(player.game_location)
+                for player in (game.player1, game.player2)
+            )
+
+            try:
+                tracking = Tracking()
+                game.cancel(location.player_id, game_result_id, tracking)
+            except AlreadyCompletedGameError:
+                await self.game_views.render_game_already_complteted_view(
+                    location, game,
+                )
+                return
+
+            await self.map_(tracking)
+            await self.game_views.render_game_view_with_locations(
+                locations, game,
+            )

src/ttt/application/game/make_move_in_game.py

@@ -32,7 +32,7 @@ async def __call__(
         """
         :raises ttt.application.common.ports.players.NoPlayerWithIDError:
         :raises ttt.application.game.ports.games.NoGameError:
-        :raises ttt.entities.core.game.game.CompletedGameError:
+        :raises ttt.entities.core.game.game.AlreadyCompletedGameError:
         :raises ttt.entities.core.game.game.NotCurrentPlayerError:
         :raises ttt.entities.core.game.game.NoCellError:
         :raises ttt.entities.core.game.cell.AlreadyFilledCellError:

src/ttt/application/game/ports/game_views.py

@@ -2,7 +2,7 @@
 from collections.abc import Sequence
 
 from ttt.entities.core.game.game import Game
-from ttt.entities.core.player.location import PlayerGameLocation
+from ttt.entities.core.player.location import PlayerGameLocation, PlayerLocation
 
 
 class GameViews(ABC):
@@ -21,3 +21,13 @@ async def render_started_game_view_with_locations(
         game: Game,
         /,
     ) -> None: ...
+
+    @abstractmethod
+    async def render_no_game_view(
+        self, player_location: PlayerLocation, /,
+    ) -> None: ...
+
+    @abstractmethod
+    async def render_game_already_complteted_view(
+        self, player_location: PlayerLocation, game: Game, /,
+    ) -> None: ...

src/ttt/application/game/ports/games.py

@@ -13,3 +13,8 @@ async def game_with_id(self, id_: UUID | None, /) -> Game:
         """
         :raises ttt.application.game.ports.games.NoGameError:
         """
+
+    @abstractmethod
+    async def game_with_game_location(
+        self, game_location_player_id: int, /,
+    ) -> Game | None: ...

src/ttt/entities/core/game/game.py

@@ -2,6 +2,7 @@
 from dataclasses import dataclass
 from enum import Enum, auto
 from itertools import chain
+from typing import cast
 from uuid import UUID
 
 from ttt.entities.core.game.board import (
@@ -30,12 +31,22 @@ class GameState(Enum):
 
 
 @dataclass(frozen=True)
-class GameResult:
+class GameCompletionResult:
     id: UUID
     game_id: UUID
     win: Win | None
 
 
+@dataclass(frozen=True)
+class GameCancellationResult:
+    id: UUID
+    game_id: UUID
+    canceler_id: int
+
+
+type GameResult = GameCompletionResult | GameCancellationResult
+
+
 class OnePlayerError(Exception): ...
 
 
@@ -110,6 +121,29 @@ def __post_init__(self) -> None:
             else_=InvalidNumberOfUnfilledCellsError,
         )
 
+    def cancel(
+        self, player_id: int, game_result_id: UUID, tracking: Tracking,
+    ) -> None:
+        """
+        :raises ttt.entities.core.game.game.AlreadyCompletedGameError:
+        :raises ttt.entities.core.game.game.NotPlayerError:
+        """
+
+        if self.result is not None:
+            raise AlreadyCompletedGameError(self.result)
+
+        canceler = not_none(self._player(player_id), else_=NotPlayerError)
+
+        self.player1.leave_game(tracking)
+        self.player2.leave_game(tracking)
+
+        self.result = GameCancellationResult(
+            game_result_id, self.id, canceler.id,
+        )
+        tracking.register_new(self.result)
+        self.state = GameState.completed
+        tracking.register_mutated(self)
+
     def make_move(
         self,
         player_id: int,
@@ -119,7 +153,7 @@ def make_move(
         tracking: Tracking,
     ) -> GameResult | None:
         """
-        :raises ttt.entities.core.game.game.CompletedGameError:
+        :raises ttt.entities.core.game.game.AlreadyCompletedGameError:
         :raises ttt.entities.core.game.game.NotPlayerError:
         :raises ttt.entities.core.game.game.NotCurrentPlayerError:
         :raises ttt.entities.core.game.game.NoCellError:
@@ -129,7 +163,9 @@ def make_move(
         current_player = self._current_player()
 
         if current_player is None:
-            raise AlreadyCompletedGameError(not_none(self.result))
+            raise AlreadyCompletedGameError(
+                cast(GameResult, not_none(self.result)),
+            )
 
         assert_(
             player_id in {self.player1.id, self.player2.id},
@@ -220,6 +256,15 @@ def _current_player(self) -> Player | None:
             case GameState.completed:
                 return None
 
+    def _player(self, player_id: int) -> Player | None:
+        match player_id:
+            case self.player1.id:
+                return self.player1
+            case self.player2.id:
+                return self.player2
+            case _:
+                return None
+
     def _not_current_player(self) -> Player | None:
         match self.state:
             case GameState.wait_player1:
@@ -243,7 +288,8 @@ def _wait_next_move(self, tracking: Tracking) -> None:
     def _complete(
         self, win: Win | None, game_result_id: UUID, tracking: Tracking,
     ) -> None:
-        self.result = GameResult(game_result_id, self.id, win)
+        self.result = GameCompletionResult(game_result_id, self.id, win)
+        tracking.register_new(self.result)
         self.state = GameState.completed
         tracking.register_mutated(self)
 

src/ttt/entities/core/player/player.py

@@ -51,7 +51,7 @@ def lose(self, tracking: Tracking) -> None:
         :raises ttt.entities.core.player.player.PlayerNotInGameError:
         """
 
-        self._leave_game(tracking)
+        self.leave_game(tracking)
 
         self.number_of_defeats += 1
         tracking.register_mutated(self)
@@ -61,7 +61,7 @@ def win(self, random: Random, tracking: Tracking) -> Win:
         :raises ttt.entities.core.player.player.PlayerNotInGameError:
         """
 
-        self._leave_game(tracking)
+        self.leave_game(tracking)
 
         self.number_of_wins += 1
 
@@ -76,12 +76,12 @@ def be_draw(self, tracking: Tracking) -> None:
         :raises ttt.entities.core.player.player.PlayerNotInGameError:
         """
 
-        self._leave_game(tracking)
+        self.leave_game(tracking)
 
         self.number_of_draws += 1
         tracking.register_mutated(self)
 
-    def _leave_game(self, tracking: Tracking) -> None:
+    def leave_game(self, tracking: Tracking) -> None:
         """
         :raises ttt.entities.core.player.player.PlayerNotInGameError:
         """

src/ttt/infrastructure/adapters/games.py

@@ -1,11 +1,12 @@
 from dataclasses import dataclass
 from uuid import UUID
 
+from sqlalchemy import select
 from sqlalchemy.ext.asyncio import AsyncSession
 
 from ttt.application.game.ports.games import Games, NoGameError
 from ttt.entities.core.game.game import Game
-from ttt.infrastructure.sqlalchemy.tables import TableGame
+from ttt.infrastructure.sqlalchemy.tables import TableGame, TablePlayer
 
 
 @dataclass(frozen=True, unsafe_hash=False)
@@ -16,6 +17,22 @@ async def game_with_id(self, id_: UUID | None, /) -> Game:
         table_game = await self._session.get(TableGame, id_)
 
         if table_game is None:
-            raise NoGameError(id_)
+            raise NoGameError
+
+        return table_game.entity()
+
+    async def game_with_game_location(
+        self, game_location_player_id: int, /,
+    ) -> Game | None:
+        join_condition = (
+            (TablePlayer.id == game_location_player_id)
+            & (TablePlayer.game_location_game_id == TableGame.id)
+        )
+        stmt = select(TableGame).join(TablePlayer, join_condition)
+
+        table_game = await self._session.scalar(stmt)
+
+        if table_game is None:
+            return None
 
         return table_game.entity()

src/ttt/infrastructure/alembic/versions/54be98063760_add_stars.py

@@ -26,7 +26,8 @@ def upgrade() -> None:
         new_column_name="win_winner_id",
     )
     op.add_column(
-        "game_results", sa.Column("win_new_stars", sa.Integer(), nullable=True),
+        "game_results",
+        sa.Column("win_new_stars", sa.Integer(), nullable=True),
     )
 
 

src/ttt/infrastructure/alembic/versions/59f959c8e3cd_add_game_cancelation.py

@@ -0,0 +1,67 @@
+"""
+add game cancelation.
+
+Revision ID: 59f959c8e3cd
+Revises: 54be98063760
+Create Date: 2025-06-25 10:55:35.024804
+
+"""
+
+from collections.abc import Sequence
+
+import sqlalchemy as sa
+from alembic import op
+from sqlalchemy.dialects import postgresql
+
+
+revision: str = "59f959c8e3cd"
+down_revision: str | None = "54be98063760"
+branch_labels: str | Sequence[str] | None = None
+depends_on: str | Sequence[str] | None = None
+
+
+def upgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    sa.Enum("completed", "cancelled", name="game_result_type").create(
+        op.get_bind(),
+    )
+    op.add_column(
+        "game_results",
+        sa.Column(
+            "type",
+            postgresql.ENUM(
+                "completed",
+                "cancelled",
+                name="game_result_type",
+                create_type=False,
+            ),
+            nullable=False,
+        ),
+    )
+    op.add_column(
+        "game_results",
+        sa.Column("canceler_id", sa.BigInteger(), nullable=True),
+    )
+    op.create_foreign_key(
+        "game_results_canceler_id_fkey",
+        "game_results",
+        "players",
+        ["canceler_id"],
+        ["id"],
+    )
+    # ### end Alembic commands ###
+
+
+def downgrade() -> None:
+    # ### commands auto generated by Alembic - please adjust! ###
+    op.drop_constraint(
+        "game_results_canceler_id_fkey",
+        "game_results",
+        type_="foreignkey",
+    )
+    op.drop_column("game_results", "canceler_id")
+    op.drop_column("game_results", "type")
+    sa.Enum("completed", "cancelled", name="game_result_type").drop(
+        op.get_bind(),
+    )
+    # ### end Alembic commands ###