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
+377 -300

No files matched your search

+7
View File
@@ -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`.
+1
View File
@@ -1,2 +1,3 @@
.venv
__pycache__/
upgrade_toolchain.sh
+39 -4
View File
@@ -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)
+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):
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))
+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):
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
],
}
}
+27 -5
View File
@@ -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,
)
+30 -129
View File
@@ -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())
-1
View File
@@ -1,2 +1 @@
Flask==3.1.2
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 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()
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