test_lobby.py 4.14 KB
Newer Older
1
from typing import Optional, List, Any, Tuple
2 3 4 5
from unittest import TestCase

from server.game.manager import ClientManager
from server.game.message import MessageToPlayer
6
from server.model.value import Value
7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25
from server.model.deck import Deck
from server.model.game import Game
from server.model.hand import Hand
from server.model.hands import pair, brelan
from server.model.known import CARRE_ACE
from server.model.players import Announce, Player


class MockPlayer(Player):

    def __init__(self,
                 name: str = None,
                 bets: List[Optional[Hand]] = None
                 ):
        super().__init__(name)

        if bets is None:
            bets = []
        self.bets: List[Optional[Hand]] = bets
26
        self.messages: List[Tuple[MessageToPlayer, Any]] = []
27 28

    def count(self, msg: MessageToPlayer) -> int:
29
        return len([m for (m, e) in self.messages if m is msg])
30

31
    async def announce(self, current_bet: Optional[Hand]) -> Announce:
32
        return Announce(bet=self.bets.pop() if self.bets else CARRE_ACE)
33

34 35
    def receive(self, message: MessageToPlayer, extra: Optional[Any] = None):
        self.messages.append((message, extra))
36 37

    def print_msgs(self) -> str:
38
        return '|'.join([f"{m}[{e}]" if e else str(m) for (m, e) in self.messages])
39 40 41 42 43 44 45 46 47


class MockManager(ClientManager):
    def __init__(self, players: List[MockPlayer]):
        super().__init__()
        self.players = players

    def send(self, to: Player, message: MessageToPlayer, extra=None):
        if isinstance(to, MockPlayer):
48 49
            to.receive(message, extra)
            print(f"Sent {message} {'(' + str(extra) + ') ' if extra else ''}to {to}")
50 51 52 53 54 55 56 57 58 59 60 61 62 63 64


class TestManager(TestCase):

    def setUp(self) -> None:
        self.j1 = MockPlayer("j1", [pair(Value.Ace)])
        self.j2 = MockPlayer("j2", [brelan(Value.Two)])
        self.manager = MockManager([self.j1, self.j2])
        cards = []
        cards.extend(self.j1.bets[0].cards)
        cards.extend(self.j2.bets[0].cards)
        self.game = Game(players=[self.j1, self.j2],
                         deck=Deck(cards=cards),
                         manager=self.manager)

65 66
    async def test_turn_messages(self):
        await self.game.new_turn()
67 68
        self.assertGot(self.j1, MessageToPlayer.LoseRound, extra=self.j1.name, msg=f"J1 should hear round lost.")
        self.assertGot(self.j2, MessageToPlayer.LoseRound, extra=self.j1.name, msg=f"J2 should hear round lost by j1.")
69
        for player in [self.j1, self.j2]:
70
            self.assertGot(player, MessageToPlayer.LoseRound, msg="End of round not announced")
71

72 73
    async def test_game_messages(self):
        await self.game.new_game()
74 75 76 77 78 79 80 81 82 83 84 85 86 87
        self.assertEqual(len([m for m in self.j1.messages if m is MessageToPlayer.LoseRound]), 5,
                         f"{self.j1} should lose 5 rounds: {'|'.join([str(m) for m in self.j1.messages])}")

        self.assertEqual(self.j1.count(MessageToPlayer.YourTurn), 6,
                         f"{self.j1} should play 6 rounds: {self.j1.print_msgs()}")

        self.assertEqual(self.j2.count(MessageToPlayer.YourTurn), 1,
                         f"{self.j2} should play 1 rounds: {self.j2.print_msgs()}")

        self.assertEqual(len([m for m in self.j2.messages if m is MessageToPlayer.LoseRound]), 0,
                         f"{self.j2} should lose 0 rounds: {'|'.join([str(m) for m in self.j2.messages])}")
        for player in [self.j1, self.j2]:
            self.assertEqual(player.count(MessageToPlayer.Announce), 7,
                             f"{player} should see 7 announces: {player.print_msgs()}")
88 89 90 91
            self.assertGot(player, MessageToPlayer.WinnerIs, self.j1, "Winner J1 not announced")
        self.assertIn(MessageToPlayer.Win, self.j1.messages, "Win not told")
        self.assertIn(MessageToPlayer.Lose, self.j2.messages, "Lose not told")

92 93
    def assertGot(self, player: MockPlayer, message: MessageToPlayer, extra=None, msg: str = "message not received"):
        self.assertIn(message, [t for (t, _) in player.messages], msg)
94
        if extra:
95 96
            matching = [m for (m, e) in player.messages if e == extra and m == message]
            self.assertTrue(matching, f"No message {message} with extra {extra}")