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
This commit is contained in:
Denis authored and GitHub committed 2025-12-08 19:21:36 +01:00
1 parent f2ae34e490
commit 824ee0687d
13 files changed
+270 -28

No files matched your search

Whitespace-only changes.
+12
View File
@@ -0,0 +1,12 @@
class Action:
pass
class JoinAction(Action):
def __init__(self, name: str):
self.name = name
join = JoinAction("hello")
print(join.name)
@@ -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']}")
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
File renamed without changes.
@@ -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()
+41
View File
@@ -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()
+1
View File
@@ -0,0 +1 @@
+188
View File
@@ -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()