woggioni
ab4130a4ca
CI / Build and push docker image (push) Successful in 3m5s
A game-type registry (server/src/tavolo/games.py) is now the single source of truth for the games the platform can host; only scopone scientifico is registered so far. GET /api/game-types exposes it for the lobby's new game dropdown, and POST /api/games accepts a validated game_type (default scopone_scientifico) which is carried on the live GameState and onto each finished Match row (new indexed column, migration 1_20260916235833_update), so statistics can be scoped per game: /api/me/matches and /api/leaderboard take an optional game_type filter and every serialized match includes its game_type. Game states serialized before this change still load with the default game type.
114 lines
3.7 KiB
Python
114 lines
3.7 KiB
Python
"""In-memory game store behaviour (the Redis store shares this interface)."""
|
|
from __future__ import annotations
|
|
|
|
import asyncio
|
|
import unittest
|
|
|
|
from pwo import async_test
|
|
|
|
from tavolo.game import engine
|
|
from tavolo.store import InMemoryGameStore
|
|
|
|
|
|
class InMemoryGameStoreTest(unittest.TestCase):
|
|
@async_test
|
|
async def test_save_load_roundtrip(self) -> None:
|
|
store = InMemoryGameStore()
|
|
state = engine.create_game("g1", "CODE01", "alice", "alice", target_score=16)
|
|
engine.join_game(state, "bob", "bob")
|
|
await store.save(state)
|
|
|
|
loaded = await store.load("g1")
|
|
self.assertIsNotNone(loaded)
|
|
assert loaded is not None
|
|
self.assertEqual("CODE01", loaded.join_code)
|
|
self.assertEqual(16, loaded.target_score)
|
|
self.assertEqual(["alice", "bob"], [p.sub for p in loaded.players])
|
|
|
|
@async_test
|
|
async def test_game_type_roundtrip_and_default(self) -> None:
|
|
store = InMemoryGameStore()
|
|
state = engine.create_game(
|
|
"g1b", "CODE1B", "alice", "alice", game_type="scopone_scientifico"
|
|
)
|
|
await store.save(state)
|
|
loaded = await store.load("g1b")
|
|
assert loaded is not None
|
|
self.assertEqual("scopone_scientifico", loaded.game_type)
|
|
|
|
# States serialized before game types existed load with the default.
|
|
legacy = state.to_json()
|
|
del legacy["game_type"]
|
|
from tavolo.game.state import GameState
|
|
|
|
self.assertEqual("scopone_scientifico", GameState.from_json(legacy).game_type)
|
|
|
|
@async_test
|
|
async def test_load_missing_returns_none(self) -> None:
|
|
store = InMemoryGameStore()
|
|
self.assertIsNone(await store.load("nope"))
|
|
self.assertIsNone(await store.find_by_code("NOPE01"))
|
|
|
|
@async_test
|
|
async def test_find_by_code(self) -> None:
|
|
store = InMemoryGameStore()
|
|
state = engine.create_game("g2", "CODE02", "alice", "alice")
|
|
await store.save(state)
|
|
found = await store.find_by_code("code02") # case-insensitive
|
|
self.assertIsNotNone(found)
|
|
assert found is not None
|
|
self.assertEqual("g2", found.id)
|
|
|
|
@async_test
|
|
async def test_load_returns_a_copy(self) -> None:
|
|
store = InMemoryGameStore()
|
|
state = engine.create_game("g3", "CODE03", "alice", "alice")
|
|
await store.save(state)
|
|
first = await store.load("g3")
|
|
assert first is not None
|
|
first.phase = "tampered"
|
|
second = await store.load("g3")
|
|
assert second is not None
|
|
self.assertEqual("lobby", second.phase)
|
|
|
|
@async_test
|
|
async def test_publish_reaches_subscriber(self) -> None:
|
|
store = InMemoryGameStore()
|
|
state = engine.create_game("g4", "CODE04", "alice", "alice")
|
|
await store.save(state)
|
|
|
|
received = []
|
|
|
|
async with store.subscribe("g4") as events:
|
|
await store.publish("g4")
|
|
async for _ in events:
|
|
received.append(True)
|
|
break
|
|
|
|
self.assertEqual([True], received)
|
|
|
|
@async_test
|
|
async def test_lock_serializes_concurrent_mutations(self) -> None:
|
|
store = InMemoryGameStore()
|
|
order = []
|
|
|
|
async def holder() -> None:
|
|
async with store.lock("g5"):
|
|
order.append("holder-enter")
|
|
await asyncio.sleep(0.05)
|
|
order.append("holder-exit")
|
|
|
|
async def contender() -> None:
|
|
await asyncio.sleep(0.01)
|
|
async with store.lock("g5"):
|
|
order.append("contender")
|
|
|
|
await asyncio.gather(holder(), contender())
|
|
self.assertEqual(
|
|
["holder-enter", "holder-exit", "contender"], order
|
|
)
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|