From 824ee0687d99dbf791f442b67c18be2defbf8555 Mon Sep 17 00:00:00 2001 From: Denis <68426415+zoopsel@users.noreply.github.com> Date: Mon, 8 Dec 2025 19:21:36 +0100 Subject: [PATCH] add unit tests (#18) * move application files into sub-folder * rename app folder to autobeerpong * fix import * add unittest for join action * add start server method * add toggle role action unit test * add toggle ready action unit test * add wrapper to start and terminate server * rename test lobby file * close websocket after sending all actions * add test rejoin test method * fix key error --- src/backend/autobeerpong/__init__.py | 0 src/backend/autobeerpong/action.py | 12 ++ src/backend/autobeerpong/action_factory.py | 9 + src/backend/{ => autobeerpong}/app.py | 0 src/backend/{ => autobeerpong}/client.py | 0 src/backend/{ => autobeerpong}/fake_client.py | 0 src/backend/{ => autobeerpong}/lobby.py | 0 src/backend/{ => autobeerpong}/player.py | 0 src/backend/{ => autobeerpong}/protocol.py | 0 src/backend/{ => autobeerpong}/server.py | 47 ++--- src/backend/autobeerpong/state.py | 41 ++++ src/backend/tests/__init__.py | 1 + src/backend/tests/test_lobby.py | 188 ++++++++++++++++++ 13 files changed, 270 insertions(+), 28 deletions(-) create mode 100644 src/backend/autobeerpong/__init__.py create mode 100644 src/backend/autobeerpong/action.py create mode 100644 src/backend/autobeerpong/action_factory.py rename src/backend/{ => autobeerpong}/app.py (100%) rename src/backend/{ => autobeerpong}/client.py (100%) rename src/backend/{ => autobeerpong}/fake_client.py (100%) rename src/backend/{ => autobeerpong}/lobby.py (100%) rename src/backend/{ => autobeerpong}/player.py (100%) rename src/backend/{ => autobeerpong}/protocol.py (100%) rename src/backend/{ => autobeerpong}/server.py (76%) create mode 100644 src/backend/autobeerpong/state.py create mode 100644 src/backend/tests/__init__.py create mode 100644 src/backend/tests/test_lobby.py diff --git a/src/backend/autobeerpong/__init__.py b/src/backend/autobeerpong/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/src/backend/autobeerpong/action.py b/src/backend/autobeerpong/action.py new file mode 100644 index 0000000..9eecc51 --- /dev/null +++ b/src/backend/autobeerpong/action.py @@ -0,0 +1,12 @@ +class Action: + pass + + +class JoinAction(Action): + def __init__(self, name: str): + self.name = name + + +join = JoinAction("hello") + +print(join.name) diff --git a/src/backend/autobeerpong/action_factory.py b/src/backend/autobeerpong/action_factory.py new file mode 100644 index 0000000..971d378 --- /dev/null +++ b/src/backend/autobeerpong/action_factory.py @@ -0,0 +1,9 @@ +from typing import Any +from action import JoinAction + + +def produce_action(raw_action: dict[Any]) -> JoinAction: + if raw_action["action"] == "join": + return JoinAction(raw_action["name"]) + else: + raise Exception(f"Unknown action: {raw_action['action']}") diff --git a/src/backend/app.py b/src/backend/autobeerpong/app.py similarity index 100% rename from src/backend/app.py rename to src/backend/autobeerpong/app.py diff --git a/src/backend/client.py b/src/backend/autobeerpong/client.py similarity index 100% rename from src/backend/client.py rename to src/backend/autobeerpong/client.py diff --git a/src/backend/fake_client.py b/src/backend/autobeerpong/fake_client.py similarity index 100% rename from src/backend/fake_client.py rename to src/backend/autobeerpong/fake_client.py diff --git a/src/backend/lobby.py b/src/backend/autobeerpong/lobby.py similarity index 100% rename from src/backend/lobby.py rename to src/backend/autobeerpong/lobby.py diff --git a/src/backend/player.py b/src/backend/autobeerpong/player.py similarity index 100% rename from src/backend/player.py rename to src/backend/autobeerpong/player.py diff --git a/src/backend/protocol.py b/src/backend/autobeerpong/protocol.py similarity index 100% rename from src/backend/protocol.py rename to src/backend/autobeerpong/protocol.py diff --git a/src/backend/server.py b/src/backend/autobeerpong/server.py similarity index 76% rename from src/backend/server.py rename to src/backend/autobeerpong/server.py index bbaf7f8..79d46be 100644 --- a/src/backend/server.py +++ b/src/backend/autobeerpong/server.py @@ -3,13 +3,13 @@ import asyncio from websockets.asyncio.server import ServerConnection, serve from websockets import exceptions -from player import Player, T_PlayerDict +from autobeerpong.player import Player, T_PlayerDict T_PlayerStateDict = dict[str, T_PlayerDict | bool] T_SpectatorStateDict = dict[str, T_PlayerDict] MAX_PLAYERS = 2 -PLAYERS: list[Player] = [] +PLAYERS: set[Player] = set() def num_players() -> int: @@ -24,7 +24,7 @@ def is_spectator() -> bool: def get_players() -> list[T_PlayerStateDict]: - query = filter(lambda x: not x.is_spectator and not x.is_disconnected, PLAYERS) + query = filter(lambda x: not x.is_spectator, PLAYERS) players: list[T_PlayerStateDict] = [] @@ -35,7 +35,7 @@ def get_players() -> list[T_PlayerStateDict]: def get_spectators() -> list[T_SpectatorStateDict]: - query = filter(lambda x: x.is_spectator and not x.is_disconnected, PLAYERS) + query = filter(lambda x: x.is_spectator, PLAYERS) players: list[T_SpectatorStateDict] = [] @@ -62,6 +62,9 @@ async def broadcast(message): async def handler(websocket: ServerConnection): + # client_id = next(CLIENT_IDS) + # CLIENTS.add(Client(websocket)) + player: Player | None = None try: @@ -72,12 +75,12 @@ async def handler(websocket: ServerConnection): if raw_action["action"] == "join": name = raw_action["name"] player = Player(websocket, name, is_spectator()) - PLAYERS.append(player) + PLAYERS.add(player) await player.send_message({"player": player.as_dict()}) elif raw_action["action"] == "rejoin": - player_id = int(raw_action["id"]) + player_id = int(raw_action["client_id"]) query = list(filter(lambda x: x.id == player_id, PLAYERS)) if len(query) == 0: @@ -94,21 +97,8 @@ async def handler(websocket: ServerConnection): await player.send_message({"player": player.as_dict()}) else: - query = list( - filter( - lambda player: player.websocket is not None - and player.websocket.id == websocket.id, - PLAYERS, - ) - ) - - if len(query) == 0: - raise Exception("Player did not join yet.") - - player = query[0] - - if player.is_disconnected: - raise Exception("Player is not connected.") + if player is None: + raise Exception("Player has not joined.") if raw_action["action"] == "toggleRole": if player.is_spectator: @@ -131,6 +121,9 @@ async def handler(websocket: ServerConnection): 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) @@ -139,17 +132,15 @@ async def handler(websocket: ServerConnection): print("exited client polling loop") await websocket.close(1000) - finally: - for player in PLAYERS: - if player.websocket is not None and player.websocket.id == websocket.id: - player.disconnect() - await broadcast(get_gamestate()) - async def main(): async with serve(handler, "localhost", 8888) as server: await server.serve_forever() -if __name__ == "__main__": +def start_server(): asyncio.run(main()) + + +if __name__ == "__main__": + start_server() diff --git a/src/backend/autobeerpong/state.py b/src/backend/autobeerpong/state.py new file mode 100644 index 0000000..d63ffa4 --- /dev/null +++ b/src/backend/autobeerpong/state.py @@ -0,0 +1,41 @@ +from enum import Enum, auto + + +class State(Enum): + ONE = auto() + TWO = auto() + THREE = auto() + FOUR = auto() + + +class StateMachine: + def __init__(self) -> None: + self.reset_state = State.ONE + self.state = self.reset_state + + def update(self) -> None: + print(self.state.name) + + if self.state is State.ONE: + self.state = State.TWO + elif self.state is State.TWO: + self.state = State.THREE + elif self.state is State.THREE: + self.state = State.FOUR + elif self.state is State.FOUR: + self.state = State.ONE + else: + raise Exception(f"Unknown state: {self.state}") + + def reset(self) -> None: + print("RESET!") + self.state = self.reset_state + + +fsm = StateMachine() + +for i in range(10): + if i == 6: + fsm.reset() + + fsm.update() diff --git a/src/backend/tests/__init__.py b/src/backend/tests/__init__.py new file mode 100644 index 0000000..8b13789 --- /dev/null +++ b/src/backend/tests/__init__.py @@ -0,0 +1 @@ + diff --git a/src/backend/tests/test_lobby.py b/src/backend/tests/test_lobby.py new file mode 100644 index 0000000..979310d --- /dev/null +++ b/src/backend/tests/test_lobby.py @@ -0,0 +1,188 @@ +import sys +import time +import json +import unittest + +from multiprocessing import Process +from websockets.sync.client import connect +from pathlib import Path + +sys.path.extend(str(Path(__file__).parent.parent)) + +from autobeerpong.server import start_server as start_server_task + + +T_ActionDict = dict[str, str] + + +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 Action: + def __init__(self, action: str, has_direct_response: bool) -> 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 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): + 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) + + +class TestLobby(unittest.TestCase): + def test_hello_world(self): + self.assertEqual("hello", "hello") + + def send_actions(self, actions: list[Action]) -> list[dict]: + responses = [] + + with connect("ws://localhost:8888") as websocket: + for action in actions: + websocket.send(json.dumps(action.as_dict())) + + if action.has_direct_response: + responses.append(json.loads(websocket.recv())) + + responses.append(json.loads(websocket.recv())) + + websocket.close() + + time.sleep(4) + + return responses + + @manage_server + def test_join(self): + responses = self.send_actions(actions=[JoinAction(name="ruedi")]) + + self.assertEqual(len(responses), 2) + + message = responses[0] + broadcast = responses[1] + + # join response + self.assertIn("player", message) + self.assertIn("id", message["player"]) + self.assertIn("name", message["player"]) + self.assertEqual("ruedi", message["player"]["name"]) + + # broadcast response + self.assertIn("gamestate", broadcast) + self.assertIn("players", broadcast["gamestate"]) + self.assertIn("spectators", broadcast["gamestate"]) + + # 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"] + ) + + @manage_server + def test_toggle_role(self): + responses = self.send_actions(actions=[JoinAction("ruedi"), ToggleRoleAction()]) + + self.assertEqual(len(responses), 3) + + # 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"] + ) + + # 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"] + ) + + @manage_server + def test_toggle_ready(self): + responses = self.send_actions( + actions=[JoinAction("ruedi"), ToggleReadyAction()] + ) + + self.assertEqual(len(responses), 3) + + # 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"] + ) + + # 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"]) + + @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()