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:
1 parent
d4bb9b195f
commit
01211f6243
13 files changed
+371
-294
No files matched your search
@@ -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,2 +1,3 @@
|
||||
.venv
|
||||
__pycache__/
|
||||
upgrade_toolchain.sh
|
||||
@@ -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)
|
||||
@@ -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))
|
||||
@@ -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
|
||||
],
|
||||
}
|
||||
}
|
||||
@@ -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,
|
||||
)
|
||||
@@ -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
|
||||
|
||||
|
||||
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
|
||||
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:
|
||||
raw_action = json.loads(msg)
|
||||
print(raw_action)
|
||||
action_dict = json.loads(msg)
|
||||
|
||||
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")
|
||||
|
||||
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:
|
||||
print(str(exception))
|
||||
await websocket.close(1011)
|
||||
|
||||
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)
|
||||
|
||||
|
||||
async def main():
|
||||
async with serve(handler, "localhost", 8888) as server:
|
||||
async def _start(self) -> None:
|
||||
async with serve(self.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,2 +1 @@
|
||||
Flask==3.1.2
|
||||
websockets==15.0.1
|
||||
@@ -0,0 +1,4 @@
|
||||
from autobeerpong.server import AutobeerpongServer
|
||||
|
||||
server = AutobeerpongServer()
|
||||
server.start()
|
||||
+115
-144
@@ -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()
|
||||
|
||||
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:
|
||||
websocket.send(json.dumps(action.as_dict()))
|
||||
await self.send_action(action)
|
||||
|
||||
if action.has_direct_response:
|
||||
responses.append(json.loads(websocket.recv()))
|
||||
num_responses = 2
|
||||
else:
|
||||
num_responses = 1
|
||||
|
||||
responses.append(json.loads(websocket.recv()))
|
||||
|
||||
websocket.close()
|
||||
|
||||
time.sleep(4)
|
||||
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()
|
||||
Whitespace-only changes.
@@ -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)
|
||||
@@ -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
|
||||
Reference in new issue
Block a user