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 <lucas@habersaat.ch>
This commit is contained in:
Denisandlucas authored and GitHub committed 2026-01-11 19:33:54 +01:00
1 parent d4bb9b195f
commit 01211f6243
13 files changed
+371 -294

No files matched your search

+7
View File
@@ -3,3 +3,10 @@ A beer pong auto battler with stupid people.
## Frontend ## Frontend
To run the front-end, go into `src/frontend` and run: `npm install && npm run dev`. 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`.
+1
View File
@@ -1,2 +1,3 @@
.venv .venv
__pycache__/ __pycache__/
upgrade_toolchain.sh
+39 -4
View File
@@ -1,12 +1,47 @@
from typing import Any
ActionDict_T = dict[str, Any]
class Action: 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): 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 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)
+29 -12
View File
@@ -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): class ClientRole(Enum):
PLAYER = 0 PLAYER = auto()
SPECTATOR = 1 SPECTATOR = auto()
DISCONNECTED = auto()
class Client: class Client:
def __init__( def __init__(self, client_id: int, websocket: ServerConnection, name: str) -> None:
self,
client_id: str,
client_type: ClientType,
user_name: str,
):
self.id = client_id self.id = client_id
self.type = client_type self.websocket = websocket
self.user_name = user_name 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))
+83 -5
View File
@@ -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): 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): def add_client(self, client: Client):
self.clients[client.id] = client self.clients[client.id] = client
def change_client_type(self, client_id: str, new_client_type: ClientType): def filter_clients(self, rule: Callable[[Client], bool]) -> list[Client]:
self.clients[client_id].type = new_client_type 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
],
}
}
+27 -5
View File
@@ -1,21 +1,28 @@
from __future__ import annotations
import json import json
from itertools import count
from typing import Any
from websockets.asyncio.server import ServerConnection from websockets.asyncio.server import ServerConnection
PLAYER_IDS = count()
T_PlayerDict = dict[str, str | int] T_PlayerDict = dict[str, str | int]
class Player: class Player:
def __init__( 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: ) -> None:
self.id = next(PLAYER_IDS) self.id = player_id
self.name = name self.name = name
self.websocket: ServerConnection | None = websocket self.websocket: ServerConnection | None = websocket
self.is_spectator = is_spectator self.is_spectator = is_spectator
self.is_ready = False self.is_ready = is_ready
self.is_disconnected = False self.is_disconnected = False
def disconnect(self) -> None: def disconnect(self) -> None:
@@ -34,3 +41,18 @@ class Player:
def as_dict(self) -> T_PlayerDict: def as_dict(self) -> T_PlayerDict:
return {"id": self.id, "name": self.name} 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,
)
+24 -123
View File
@@ -1,146 +1,47 @@
import json import json
import asyncio import asyncio
from websockets.asyncio.server import ServerConnection, serve from enum import Enum, auto
from websockets import exceptions
from autobeerpong.player import Player, T_PlayerDict
T_PlayerStateDict = dict[str, T_PlayerDict | bool] from websockets.asyncio.server import serve, ServerConnection
T_SpectatorStateDict = dict[str, T_PlayerDict]
MAX_PLAYERS = 2 from autobeerpong.lobby import AutobeerpongLobby
PLAYERS: set[Player] = set()
def num_players() -> int: class ServerState(Enum):
return len(list(filter(lambda x: not x.is_spectator, PLAYERS))) LOBBY = auto()
MATCH = auto()
def is_spectator() -> bool: class AutobeerpongServer:
if num_players() < MAX_PLAYERS: def __init__(self) -> None:
return False self.server_state = ServerState.LOBBY
else: self.lobby = AutobeerpongLobby()
return True
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
async def handler(self, websocket: ServerConnection):
try: try:
async for msg in websocket: async for msg in websocket:
raw_action = json.loads(msg) action_dict = json.loads(msg)
print(raw_action)
if raw_action["action"] == "join": if self.server_state is ServerState.LOBBY:
name = raw_action["name"] await self.lobby.process(websocket, action_dict)
player = Player(websocket, name, is_spectator()) elif self.server_state is ServerState.MATCH:
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}")
pass pass
else:
player = query[0]
player.reconnect(websocket)
player.is_spectator = True
player.is_ready = False
print(f"{player.name} rejoined")
await player.send_message({"player": player.as_dict()})
else:
if player is None:
raise Exception("Player has not joined.")
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
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: except Exception as exception:
print(str(exception)) print(str(exception))
await websocket.close(1011) await websocket.close(1011)
else: else:
print("exited client polling loop") client = self.lobby.clients.get(websocket.id.int)
if client is not None:
client.disconnect()
await websocket.close(1000) await websocket.close(1000)
async def _start(self) -> None:
async def main(): async with serve(self.handler, "localhost", 8888) as server:
async with serve(handler, "localhost", 8888) as server:
await server.serve_forever() await server.serve_forever()
def start(self) -> None:
def start_server(): asyncio.run(self._start())
asyncio.run(main())
if __name__ == "__main__":
start_server()
-1
View File
@@ -1,2 +1 @@
Flask==3.1.2
websockets==15.0.1 websockets==15.0.1
+4
View File
@@ -0,0 +1,4 @@
from autobeerpong.server import AutobeerpongServer
server = AutobeerpongServer()
server.start()
+115 -144
View File
@@ -1,188 +1,159 @@
import sys
import time
import json import json
import unittest import asyncio
from multiprocessing import Process from typing import Any
from websockets.sync.client import connect from unittest import IsolatedAsyncioTestCase
from pathlib import Path from websockets.asyncio.client import connect
sys.path.extend(str(Path(__file__).parent.parent)) from autobeerpong.action import Action, JoinAction, ToggleReadyAction, ToggleRoleAction
from tests.utils.server import manage_server, SERVER_ADDRESS, SERVER_PORT
from autobeerpong.server import start_server as start_server_task
T_ActionDict = dict[str, str] SERVER_RESPONSE_TIMEOUT = 5.0
def manage_server(func): class ClientTask:
def wrapper(obj): pass
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: class SendActionToServer(ClientTask):
def __init__(self, action: str, has_direct_response: bool) -> None: def __init__(self, action: Action) -> None:
self.action = action self.action = action
self.has_direct_response = has_direct_response
def as_dict(self) -> T_ActionDict:
return {"action": self.action}
class JoinAction(Action): class GetResponseFromServer(ClientTask):
def __init__(self, name: str) -> None: pass
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): class TestClient:
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: 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): if isinstance(client_task, SendActionToServer):
def __init__(self) -> None: await websocket.send(json.dumps(client_task.action.as_dict()))
super().__init__(action="toggleReady", has_direct_response=False)
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): else:
def test_hello_world(self): raise Exception(
self.assertEqual("hello", "hello") f"Unknown type of ClientTask received: {type(ClientTask)}"
)
def send_actions(self, actions: list[Action]) -> list[dict]: self.queue_send.task_done()
responses = []
async def send_action(self, action: Action):
await self.queue_send.put(SendActionToServer(action))
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()
return response_raw
async def send_actions(self, actions: list[Action]) -> list[dict[str, Any]]:
responses: list[dict[str, Any]] = []
with connect("ws://localhost:8888") as websocket:
for action in actions: for action in actions:
websocket.send(json.dumps(action.as_dict())) await self.send_action(action)
if action.has_direct_response: if action.has_direct_response:
responses.append(json.loads(websocket.recv())) num_responses = 2
else:
num_responses = 1
responses.append(json.loads(websocket.recv())) for _ in range(num_responses):
responses.append(await self.get_response())
websocket.close()
time.sleep(4)
return responses return responses
def shutdown(self):
self.queue_send.shutdown()
self.queue_recv.shutdown()
self._task.cancel()
class TestLobby(IsolatedAsyncioTestCase):
@manage_server @manage_server
def test_join(self): async def test_join(self):
responses = self.send_actions(actions=[JoinAction(name="ruedi")]) 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] self.assertEqual(len(client_a_responses), 3)
broadcast = responses[1] self.assertEqual(len(client_b_responses), 2)
# join response response = client_a_responses[0]
self.assertIn("player", message) self.assertEqual(response["player"]["name"], "Ruedi")
self.assertIn("id", message["player"])
self.assertIn("name", message["player"])
self.assertEqual("ruedi", message["player"]["name"])
# broadcast response response = client_b_responses[0]
self.assertIn("gamestate", broadcast) self.assertEqual(response["player"]["name"], "Hansi")
self.assertIn("players", broadcast["gamestate"])
self.assertIn("spectators", broadcast["gamestate"])
# first join should be a player response = client_a_responses[1]
self.assertIn("player", broadcast["gamestate"]["players"][0]) self.assertEqual(len(response["gamestate"]["players"]), 1)
self.assertIn("name", broadcast["gamestate"]["players"][0]["player"])
self.assertEqual( response = client_b_responses[1]
"ruedi", broadcast["gamestate"]["players"][0]["player"]["name"] 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 @manage_server
def test_toggle_role(self): async def test_toggle_ready(self):
responses = self.send_actions(actions=[JoinAction("ruedi"), ToggleRoleAction()]) 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 response = client_a_responses[3]
broadcast = responses[1] players = response["gamestate"]["players"]
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 for player in players:
broadcast = responses[2] if player["player"]["name"] == "Ruedi":
self.assertIn("player", broadcast["gamestate"]["spectators"][0]) self.assertEqual(player["ready"], True)
self.assertIn("name", broadcast["gamestate"]["spectators"][0]["player"]) elif player["player"]["name"] == "Hansi":
self.assertEqual( self.assertEqual(player["ready"], False)
"ruedi", broadcast["gamestate"]["spectators"][0]["player"]["name"]
)
@manage_server self.assertEqual(client_a_responses[3], client_b_responses[2])
def test_toggle_ready(self):
responses = self.send_actions(
actions=[JoinAction("ruedi"), ToggleReadyAction()]
)
self.assertEqual(len(responses), 3) response = client_a_responses[4]
players = response["gamestate"]["players"]
# first join should be a player for player in players:
broadcast = responses[1] if player["player"]["name"] == "Ruedi":
self.assertIn("player", broadcast["gamestate"]["players"][0]) self.assertEqual(player["ready"], True)
self.assertIn("name", broadcast["gamestate"]["players"][0]["player"]) elif player["player"]["name"] == "Hansi":
self.assertEqual( self.assertEqual(player["ready"], True)
"ruedi", broadcast["gamestate"]["players"][0]["player"]["name"]
)
# should be ready self.assertEqual(client_a_responses[4], client_b_responses[3])
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 client_a.shutdown()
def test_rejoin(self): client_b.shutdown()
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()
View File
Whitespace-only changes.
+23
View File
@@ -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)
+19
View File
@@ -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