From 01211f62434a879794f4b276f368f78da95034f6 Mon Sep 17 00:00:00 2001 From: Denis <68426415+zoopsel@users.noreply.github.com> Date: Sun, 11 Jan 2026 19:33:54 +0100 Subject: [PATCH] add async multi-client unit tests (#25) * add class method to create player instance from dict * update server code to use changes to player interface * update gitignore * update requirements * add join action * add client class * add lobby class * add new server implementation * backup old server implementation * test for player names in join action * remove print statement * add gamestate to dict method * complete join action unit test * move actions to their own file * check if websocket is none before sending a message * only toggle ready if client is a player * remove old code * move test utiliy wrapper and classes into separate module * add toggle ready method and return correct gamestate response * fix async test methods for join and toggle ready * add script to start the autobeerpong server * remove old files * remove print statement * remove unused imports and print statements * check broadcast responses using assertEqual * update README * Add formatting to frontend (#27) * update README --------- Co-authored-by: Lucas Habersaat --- README.md | 7 + src/backend/.gitignore | 1 + src/backend/autobeerpong/action.py | 43 ++++- src/backend/autobeerpong/client.py | 41 +++-- src/backend/autobeerpong/lobby.py | 88 +++++++++- src/backend/autobeerpong/player.py | 32 +++- src/backend/autobeerpong/server.py | 159 ++++------------- src/backend/requirements.txt | 1 - src/backend/run_server.py | 4 + src/backend/tests/test_lobby.py | 259 ++++++++++++---------------- src/backend/tests/utils/__init__.py | 0 src/backend/tests/utils/response.py | 23 +++ src/backend/tests/utils/server.py | 19 ++ 13 files changed, 377 insertions(+), 300 deletions(-) create mode 100644 src/backend/run_server.py create mode 100644 src/backend/tests/utils/__init__.py create mode 100644 src/backend/tests/utils/response.py create mode 100644 src/backend/tests/utils/server.py diff --git a/README.md b/README.md index 8199221..45439a6 100644 --- a/README.md +++ b/README.md @@ -3,3 +3,10 @@ A beer pong auto battler with stupid people. ## Frontend To run the front-end, go into `src/frontend` and run: `npm install && npm run dev`. + +## Backend + +To setup the Python environment go into `src/backend` and run: `python -m venv .venv && source .venv/bin/activate && pip install -r requirements.txt` + +To start the server run `python run_server.py`. +To execute the unit tests run `python -m unittest`. diff --git a/src/backend/.gitignore b/src/backend/.gitignore index 3367433..7899d0f 100644 --- a/src/backend/.gitignore +++ b/src/backend/.gitignore @@ -1,2 +1,3 @@ .venv __pycache__/ +upgrade_toolchain.sh diff --git a/src/backend/autobeerpong/action.py b/src/backend/autobeerpong/action.py index 9eecc51..34cd5d9 100644 --- a/src/backend/autobeerpong/action.py +++ b/src/backend/autobeerpong/action.py @@ -1,12 +1,47 @@ +from typing import Any + + +ActionDict_T = dict[str, Any] + + class Action: - pass + def __init__(self, action: str, has_direct_response: bool) -> None: + self.action = action + self.has_direct_response = has_direct_response + + def as_dict(self) -> ActionDict_T: + return {"action": self.action} class JoinAction(Action): - def __init__(self, name: str): + def __init__(self, name: str) -> None: + super().__init__(action="join", has_direct_response=True) self.name = name + def as_dict(self) -> ActionDict_T: + adict = super().as_dict() + adict.update(name=self.name) -join = JoinAction("hello") + return adict -print(join.name) + +class RejoinAction(Action): + def __init__(self, client_id: int) -> None: + super().__init__(action="rejoin", has_direct_response=True) + self.client_id = client_id + + def as_dict(self) -> ActionDict_T: + adict = super().as_dict() + adict.update(client_id=self.client_id) + + return adict + + +class ToggleRoleAction(Action): + def __init__(self) -> None: + super().__init__(action="toggleRole", has_direct_response=False) + + +class ToggleReadyAction(Action): + def __init__(self) -> None: + super().__init__(action="toggleReady", has_direct_response=False) diff --git a/src/backend/autobeerpong/client.py b/src/backend/autobeerpong/client.py index e6634b8..7489c23 100644 --- a/src/backend/autobeerpong/client.py +++ b/src/backend/autobeerpong/client.py @@ -1,18 +1,35 @@ -from enum import Enum +import json + +from enum import Enum, auto +from websockets.asyncio.server import ServerConnection + +from autobeerpong.action import ActionDict_T -class ClientType(Enum): - PLAYER = 0 - SPECTATOR = 1 +class ClientRole(Enum): + PLAYER = auto() + SPECTATOR = auto() + DISCONNECTED = auto() class Client: - def __init__( - self, - client_id: str, - client_type: ClientType, - user_name: str, - ): + def __init__(self, client_id: int, websocket: ServerConnection, name: str) -> None: self.id = client_id - self.type = client_type - self.user_name = user_name + self.websocket = websocket + self.name = name + self.role = ClientRole.PLAYER + self.ready = False + + def as_dict(self) -> dict[str, int | str]: + return { + "id": self.id, + "name": self.name, + } + + def disconnect(self): + self.role = ClientRole.DISCONNECTED + self.websocket = None + + async def send(self, msg_dict: ActionDict_T) -> None: + if self.websocket is not None: + await self.websocket.send(json.dumps(msg_dict)) diff --git a/src/backend/autobeerpong/lobby.py b/src/backend/autobeerpong/lobby.py index 69e2ce3..2c7338c 100644 --- a/src/backend/autobeerpong/lobby.py +++ b/src/backend/autobeerpong/lobby.py @@ -1,12 +1,90 @@ -from client import Client, ClientType +from typing import Any, Callable +from websockets.asyncio.server import ServerConnection + +from autobeerpong.client import Client, ClientRole +from autobeerpong.action import JoinAction -class Lobby: +class AutobeerpongLobby: + MAX_PLAYERS = 2 + def __init__(self): - self.clients: dict[str, Client] = {} + self.clients: dict[int, Client] = {} + + async def broadcast(self) -> None: + for client in self.clients.values(): + await client.send(self.as_dict()) + + async def process_join( + self, websocket: ServerConnection, action: JoinAction + ) -> None: + client = Client(websocket.id.int, websocket, action.name) + self.add_client(client) + + await client.send({"player": client.as_dict()}) + + async def process_toggle_role(self, client: Client) -> None: + if ( + client.role is ClientRole.SPECTATOR + and self.get_num_players() < self.MAX_PLAYERS + ): + client.role = ClientRole.PLAYER + elif client.role is ClientRole.PLAYER: + client.role = ClientRole.SPECTATOR + + async def process_toggle_ready(self, client: Client) -> None: + if client.role is ClientRole.PLAYER: + client.ready = not client.ready + + async def process( + self, websocket: ServerConnection, action_dict: dict[str, Any] + ) -> None: + action_name = action_dict["action"] + + if action_name == "join": + await self.process_join(websocket, JoinAction(name=action_dict["name"])) + elif action_name == "rejoin": + pass + else: + client = self.clients.get(websocket.id.int) + + if client is None: + raise Exception("Client has not joined.") + + if action_name == "toggleRole": + await self.process_toggle_role(client) + elif action_name == "toggleReady": + await self.process_toggle_ready(client) + + await self.broadcast() def add_client(self, client: Client): self.clients[client.id] = client - def change_client_type(self, client_id: str, new_client_type: ClientType): - self.clients[client_id].type = new_client_type + def filter_clients(self, rule: Callable[[Client], bool]) -> list[Client]: + return list(filter(lambda x: rule(x), self.clients.values())) + + def get_players(self) -> list[Client]: + return self.filter_clients(lambda x: x.role is ClientRole.PLAYER) + + def get_num_players(self) -> int: + return len(self.get_players()) + + def get_spectators(self) -> list[Client]: + return self.filter_clients(lambda x: x.role is ClientRole.SPECTATOR) + + def as_dict(self) -> dict[str, Any]: + players = self.get_players() + spectators = self.get_spectators() + + return { + "gamestate": { + "players": [ + {"player": player.as_dict(), "ready": player.ready} + for player in players + ], + "spectators": [ + {"player": spectator.as_dict()} for spectator in spectators + ], + } + } diff --git a/src/backend/autobeerpong/player.py b/src/backend/autobeerpong/player.py index 986050b..fbaca7c 100644 --- a/src/backend/autobeerpong/player.py +++ b/src/backend/autobeerpong/player.py @@ -1,21 +1,28 @@ +from __future__ import annotations + import json -from itertools import count + +from typing import Any from websockets.asyncio.server import ServerConnection -PLAYER_IDS = count() T_PlayerDict = dict[str, str | int] class Player: def __init__( - self, websocket: ServerConnection, name: str, is_spectator: bool + self, + websocket: ServerConnection | None, + player_id: int, + name: str, + is_spectator: bool, + is_ready: bool = False, ) -> None: - self.id = next(PLAYER_IDS) + self.id = player_id self.name = name self.websocket: ServerConnection | None = websocket self.is_spectator = is_spectator - self.is_ready = False + self.is_ready = is_ready self.is_disconnected = False def disconnect(self) -> None: @@ -34,3 +41,18 @@ class Player: def as_dict(self) -> T_PlayerDict: return {"id": self.id, "name": self.name} + + @classmethod + def from_dict( + cls, player_dict: dict[str, Any], is_ready: bool, is_spectator: bool + ) -> Player: + player_id: int = player_dict["id"] + name: str = player_dict["name"] + + return Player( + websocket=None, + player_id=player_id, + name=name, + is_spectator=is_spectator, + is_ready=is_ready, + ) diff --git a/src/backend/autobeerpong/server.py b/src/backend/autobeerpong/server.py index 79d46be..55ef8e8 100644 --- a/src/backend/autobeerpong/server.py +++ b/src/backend/autobeerpong/server.py @@ -1,146 +1,47 @@ import json import asyncio -from websockets.asyncio.server import ServerConnection, serve -from websockets import exceptions -from autobeerpong.player import Player, T_PlayerDict +from enum import Enum, auto -T_PlayerStateDict = dict[str, T_PlayerDict | bool] -T_SpectatorStateDict = dict[str, T_PlayerDict] +from websockets.asyncio.server import serve, ServerConnection -MAX_PLAYERS = 2 -PLAYERS: set[Player] = set() +from autobeerpong.lobby import AutobeerpongLobby -def num_players() -> int: - return len(list(filter(lambda x: not x.is_spectator, PLAYERS))) +class ServerState(Enum): + LOBBY = auto() + MATCH = auto() -def is_spectator() -> bool: - if num_players() < MAX_PLAYERS: - return False - else: - return True +class AutobeerpongServer: + def __init__(self) -> None: + self.server_state = ServerState.LOBBY + self.lobby = AutobeerpongLobby() + async def handler(self, websocket: ServerConnection): + try: + async for msg in websocket: + action_dict = json.loads(msg) -def get_players() -> list[T_PlayerStateDict]: - query = filter(lambda x: not x.is_spectator, PLAYERS) - - players: list[T_PlayerStateDict] = [] - - for player in query: - players.append({"player": player.as_dict(), "ready": player.is_ready}) - - return players - - -def get_spectators() -> list[T_SpectatorStateDict]: - query = filter(lambda x: x.is_spectator, PLAYERS) - - players: list[T_SpectatorStateDict] = [] - - for player in query: - players.append({"player": player.as_dict()}) - - return players - - -def get_gamestate() -> dict[ - str, dict[str, list[T_PlayerStateDict] | list[T_SpectatorStateDict]] -]: - return { - "gamestate": { - "players": get_players(), - "spectators": get_spectators(), - } - } - - -async def broadcast(message): - for player in PLAYERS: - await player.send_message(message) - - -async def handler(websocket: ServerConnection): - # client_id = next(CLIENT_IDS) - # CLIENTS.add(Client(websocket)) - - player: Player | None = None - - try: - async for msg in websocket: - raw_action = json.loads(msg) - print(raw_action) - - if raw_action["action"] == "join": - name = raw_action["name"] - player = Player(websocket, name, is_spectator()) - PLAYERS.add(player) - - await player.send_message({"player": player.as_dict()}) - - elif raw_action["action"] == "rejoin": - player_id = int(raw_action["client_id"]) - query = list(filter(lambda x: x.id == player_id, PLAYERS)) - - if len(query) == 0: - print(f"player id not found: {player_id}") + if self.server_state is ServerState.LOBBY: + await self.lobby.process(websocket, action_dict) + elif self.server_state is ServerState.MATCH: pass - else: - player = query[0] - player.reconnect(websocket) - player.is_spectator = True - player.is_ready = False - print(f"{player.name} rejoined") + except Exception as exception: + print(str(exception)) + await websocket.close(1011) + else: + client = self.lobby.clients.get(websocket.id.int) - await player.send_message({"player": player.as_dict()}) + if client is not None: + client.disconnect() - else: - if player is None: - raise Exception("Player has not joined.") + await websocket.close(1000) - if raw_action["action"] == "toggleRole": - if player.is_spectator: - if num_players() < MAX_PLAYERS: - player.is_spectator = False - player.is_ready = False - else: - player.is_spectator = True + async def _start(self) -> None: + async with serve(self.handler, "localhost", 8888) as server: + await server.serve_forever() - elif raw_action["action"] == "toggleReady": - player.is_ready = not player.is_ready - - data = get_gamestate() - print("broadcasting") - await broadcast(data) - - for player in PLAYERS: - print(player.as_dict()) - - except exceptions.ConnectionClosed: - print("client has disconnected") - - if player is not None: - player.disconnect() - - except Exception as exception: - print(str(exception)) - await websocket.close(1011) - - else: - print("exited client polling loop") - await websocket.close(1000) - - -async def main(): - async with serve(handler, "localhost", 8888) as server: - await server.serve_forever() - - -def start_server(): - asyncio.run(main()) - - -if __name__ == "__main__": - start_server() + def start(self) -> None: + asyncio.run(self._start()) diff --git a/src/backend/requirements.txt b/src/backend/requirements.txt index c0e1326..7bc03d7 100644 --- a/src/backend/requirements.txt +++ b/src/backend/requirements.txt @@ -1,2 +1 @@ -Flask==3.1.2 websockets==15.0.1 diff --git a/src/backend/run_server.py b/src/backend/run_server.py new file mode 100644 index 0000000..4f0378c --- /dev/null +++ b/src/backend/run_server.py @@ -0,0 +1,4 @@ +from autobeerpong.server import AutobeerpongServer + +server = AutobeerpongServer() +server.start() diff --git a/src/backend/tests/test_lobby.py b/src/backend/tests/test_lobby.py index 979310d..e6c6117 100644 --- a/src/backend/tests/test_lobby.py +++ b/src/backend/tests/test_lobby.py @@ -1,188 +1,159 @@ -import sys -import time import json -import unittest +import asyncio -from multiprocessing import Process -from websockets.sync.client import connect -from pathlib import Path +from typing import Any +from unittest import IsolatedAsyncioTestCase +from websockets.asyncio.client import connect -sys.path.extend(str(Path(__file__).parent.parent)) - -from autobeerpong.server import start_server as start_server_task +from autobeerpong.action import Action, JoinAction, ToggleReadyAction, ToggleRoleAction +from tests.utils.server import manage_server, SERVER_ADDRESS, SERVER_PORT -T_ActionDict = dict[str, str] +SERVER_RESPONSE_TIMEOUT = 5.0 -def manage_server(func): - def wrapper(obj): - server_process = Process(target=start_server_task) - server_process.start() - # wait for server to be started - time.sleep(2) - func(obj) - server_process.terminate() - time.sleep(1) - - return wrapper +class ClientTask: + pass -class Action: - def __init__(self, action: str, has_direct_response: bool) -> None: +class SendActionToServer(ClientTask): + def __init__(self, action: Action) -> None: self.action = action - self.has_direct_response = has_direct_response - - def as_dict(self) -> T_ActionDict: - return {"action": self.action} -class JoinAction(Action): - def __init__(self, name: str) -> None: - super().__init__(action="join", has_direct_response=True) - self.name = name - - def as_dict(self) -> T_ActionDict: - adict = super().as_dict() - adict.update(name=self.name) - - return adict +class GetResponseFromServer(ClientTask): + pass -class RejoinAction(Action): - def __init__(self, client_id: str) -> None: - super().__init__(action="rejoin", has_direct_response=True) - self.client_id = client_id - - def as_dict(self) -> T_ActionDict: - adict = super().as_dict() - adict.update(client_id=self.client_id) - - return adict - - -class ToggleRoleAction(Action): +class TestClient: def __init__(self) -> None: - super().__init__(action="toggleRole", has_direct_response=False) + self.queue_send: asyncio.Queue[ClientTask] = asyncio.Queue() + self.queue_recv: asyncio.Queue[dict[str, Any]] = asyncio.Queue() + self._task = asyncio.create_task(self._client_task()) + async def _client_task(self): + async with connect(f"ws://{SERVER_ADDRESS}:{SERVER_PORT}") as websocket: + while True: + client_task = await self.queue_send.get() -class ToggleReadyAction(Action): - def __init__(self) -> None: - super().__init__(action="toggleReady", has_direct_response=False) + if isinstance(client_task, SendActionToServer): + await websocket.send(json.dumps(client_task.action.as_dict())) + elif isinstance(client_task, GetResponseFromServer): + response_raw = await asyncio.wait_for( + websocket.recv(), timeout=SERVER_RESPONSE_TIMEOUT + ) + await self.queue_recv.put(json.loads(response_raw)) -class TestLobby(unittest.TestCase): - def test_hello_world(self): - self.assertEqual("hello", "hello") + else: + raise Exception( + f"Unknown type of ClientTask received: {type(ClientTask)}" + ) - def send_actions(self, actions: list[Action]) -> list[dict]: - responses = [] + self.queue_send.task_done() - with connect("ws://localhost:8888") as websocket: - for action in actions: - websocket.send(json.dumps(action.as_dict())) + async def send_action(self, action: Action): + await self.queue_send.put(SendActionToServer(action)) - if action.has_direct_response: - responses.append(json.loads(websocket.recv())) + async def get_response(self) -> dict[str, Any]: + await self.queue_send.put(GetResponseFromServer()) + response_raw = await self.queue_recv.get() + self.queue_recv.task_done() - responses.append(json.loads(websocket.recv())) + return response_raw - websocket.close() + async def send_actions(self, actions: list[Action]) -> list[dict[str, Any]]: + responses: list[dict[str, Any]] = [] - time.sleep(4) + for action in actions: + await self.send_action(action) + + if action.has_direct_response: + num_responses = 2 + else: + num_responses = 1 + + for _ in range(num_responses): + responses.append(await self.get_response()) return responses + def shutdown(self): + self.queue_send.shutdown() + self.queue_recv.shutdown() + self._task.cancel() + + +class TestLobby(IsolatedAsyncioTestCase): @manage_server - def test_join(self): - responses = self.send_actions(actions=[JoinAction(name="ruedi")]) + async def test_join(self): + client_a = TestClient() + client_b = TestClient() - self.assertEqual(len(responses), 2) + client_a_responses = await client_a.send_actions([JoinAction("Ruedi")]) + client_b_responses = await client_b.send_actions([JoinAction("Hansi")]) + client_a_responses.append(await client_a.get_response()) - message = responses[0] - broadcast = responses[1] + self.assertEqual(len(client_a_responses), 3) + self.assertEqual(len(client_b_responses), 2) - # join response - self.assertIn("player", message) - self.assertIn("id", message["player"]) - self.assertIn("name", message["player"]) - self.assertEqual("ruedi", message["player"]["name"]) + response = client_a_responses[0] + self.assertEqual(response["player"]["name"], "Ruedi") - # broadcast response - self.assertIn("gamestate", broadcast) - self.assertIn("players", broadcast["gamestate"]) - self.assertIn("spectators", broadcast["gamestate"]) + response = client_b_responses[0] + self.assertEqual(response["player"]["name"], "Hansi") - # first join should be a player - self.assertIn("player", broadcast["gamestate"]["players"][0]) - self.assertIn("name", broadcast["gamestate"]["players"][0]["player"]) - self.assertEqual( - "ruedi", broadcast["gamestate"]["players"][0]["player"]["name"] - ) + response = client_a_responses[1] + self.assertEqual(len(response["gamestate"]["players"]), 1) + + response = client_b_responses[1] + self.assertEqual(len(response["gamestate"]["players"]), 2) + + response = client_a_responses[2] + self.assertEqual(len(response["gamestate"]["players"]), 2) + + player_names = [p["player"]["name"] for p in response["gamestate"]["players"]] + + self.assertIn("Ruedi", player_names) + self.assertIn("Hansi", player_names) + + client_a.shutdown() + client_b.shutdown() @manage_server - def test_toggle_role(self): - responses = self.send_actions(actions=[JoinAction("ruedi"), ToggleRoleAction()]) + async def test_toggle_ready(self): + client_a = TestClient() + client_b = TestClient() - self.assertEqual(len(responses), 3) + client_a_responses = await client_a.send_actions([JoinAction("Ruedi")]) + client_b_responses = await client_b.send_actions([JoinAction("Hansi")]) + client_a_responses.append(await client_a.get_response()) + client_a_responses.extend(await client_a.send_actions([ToggleReadyAction()])) + client_b_responses.append(await client_b.get_response()) + client_b_responses.extend(await client_b.send_actions([ToggleReadyAction()])) + client_a_responses.append(await client_a.get_response()) - # first join should be a player - broadcast = responses[1] - self.assertIn("player", broadcast["gamestate"]["players"][0]) - self.assertIn("name", broadcast["gamestate"]["players"][0]["player"]) - self.assertEqual( - "ruedi", broadcast["gamestate"]["players"][0]["player"]["name"] - ) + response = client_a_responses[3] + players = response["gamestate"]["players"] - # should be spectator - broadcast = responses[2] - self.assertIn("player", broadcast["gamestate"]["spectators"][0]) - self.assertIn("name", broadcast["gamestate"]["spectators"][0]["player"]) - self.assertEqual( - "ruedi", broadcast["gamestate"]["spectators"][0]["player"]["name"] - ) + for player in players: + if player["player"]["name"] == "Ruedi": + self.assertEqual(player["ready"], True) + elif player["player"]["name"] == "Hansi": + self.assertEqual(player["ready"], False) - @manage_server - def test_toggle_ready(self): - responses = self.send_actions( - actions=[JoinAction("ruedi"), ToggleReadyAction()] - ) + self.assertEqual(client_a_responses[3], client_b_responses[2]) - self.assertEqual(len(responses), 3) + response = client_a_responses[4] + players = response["gamestate"]["players"] - # first join should be a player - broadcast = responses[1] - self.assertIn("player", broadcast["gamestate"]["players"][0]) - self.assertIn("name", broadcast["gamestate"]["players"][0]["player"]) - self.assertEqual( - "ruedi", broadcast["gamestate"]["players"][0]["player"]["name"] - ) + for player in players: + if player["player"]["name"] == "Ruedi": + self.assertEqual(player["ready"], True) + elif player["player"]["name"] == "Hansi": + self.assertEqual(player["ready"], True) - # should be ready - broadcast = responses[2] - self.assertIn("player", broadcast["gamestate"]["players"][0]) - self.assertIn("name", broadcast["gamestate"]["players"][0]["player"]) - self.assertEqual( - "ruedi", broadcast["gamestate"]["players"][0]["player"]["name"] - ) - self.assertIn("ready", broadcast["gamestate"]["players"][0]) - self.assertEqual(True, broadcast["gamestate"]["players"][0]["ready"]) + self.assertEqual(client_a_responses[4], client_b_responses[3]) - @manage_server - def test_rejoin(self): - responses = self.send_actions([JoinAction("ruedi")]) - response = responses[0] - id = response["player"]["id"] - responses = self.send_actions([RejoinAction(id)]) - - response = responses[0] - self.assertEqual(response["player"]["id"], id) - - response = responses[1] - self.assertEqual(len(response["gamestate"]["players"]), 0) - self.assertEqual(len(response["gamestate"]["spectators"]), 1) - self.assertEqual(response["gamestate"]["spectators"][0]["player"]["id"], id) - - -if __name__ == "__main__": - unittest.main() + client_a.shutdown() + client_b.shutdown() diff --git a/src/backend/tests/utils/__init__.py b/src/backend/tests/utils/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/backend/tests/utils/response.py b/src/backend/tests/utils/response.py new file mode 100644 index 0000000..aee6b36 --- /dev/null +++ b/src/backend/tests/utils/response.py @@ -0,0 +1,23 @@ +import json + +from autobeerpong.player import Player + + +class Response: + def __init__(self, response_raw: str | bytes) -> None: + self._response_dict = json.loads(response_raw) + + +class PlayerDirectResponse(Response): + def __init__(self, response_raw: str | bytes) -> None: + super().__init__(response_raw) + self.player = Player.from_dict( + player_dict=self._response_dict["player"], + is_ready=False, + is_spectator=False, + ) + + +class GameStateBroadcastResponse(Response): + def __init__(self, response_raw: str | bytes) -> None: + super().__init__(response_raw) diff --git a/src/backend/tests/utils/server.py b/src/backend/tests/utils/server.py new file mode 100644 index 0000000..6efdea5 --- /dev/null +++ b/src/backend/tests/utils/server.py @@ -0,0 +1,19 @@ +import functools + +from websockets.asyncio.server import serve + +from autobeerpong.server import AutobeerpongServer + + +SERVER_ADDRESS = "localhost" +SERVER_PORT = 8888 + + +def manage_server(func): + @functools.wraps(func) + async def _wrapper(obj): + server = AutobeerpongServer() + async with serve(server.handler, SERVER_ADDRESS, SERVER_PORT): + await func(obj) + + return _wrapper