dopynion 0.1.0__tar.gz

dopynion-0.1.0/LICENSE

@@ -0,0 +1,28 @@
+BSD 3-Clause License
+
+Copyright (c) 2024, Vincent Poulailleau
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

dopynion-0.1.0/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: dopynion
+Version: 0.1.0
+Summary: Dominion
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# dopynion
+Dominion in Python

dopynion-0.1.0/README.md

@@ -0,0 +1,2 @@
+# dopynion
+Dominion in Python

dopynion-0.1.0/dopynion/__main__.py

@@ -0,0 +1,41 @@
+# example of execution
+
+import random
+
+from dopynion.cards import Card, CardName
+from dopynion.game import Game
+from dopynion.player import Player
+
+game = Game()
+player1 = Player("Foo")
+player2 = Player("Bar")
+player3 = Player("Baz")
+game.add_player(player1)
+game.add_player(player2)
+game.add_player(player3)
+game.start()
+
+for turn in range(50):
+    print("#" * 80)
+    print(f"# turn {turn}")
+    print("#" * 80)
+    print(dict(game.stock._quantities))  # noqa: SLF001
+    player1.start_turn()
+    print(player1)
+
+    while player1.actions_left and player1.hand.contains_action():
+        actions = player1.hand.action_cards
+        player1.action(random.choice(actions))  # noqa: S311
+        print(player1)
+
+    while player1.purchases_left and player1.hand.contains_money():
+        money = player1.hand.money
+        buyables: list[CardName] = [
+            card_name
+            for card_name, class_ in Card.types.items()
+            if class_.cost <= money and card_name in game.stock
+        ]
+        player1.buy(random.choice(buyables))  # noqa: S311
+        print(player1)
+
+    player1.end_turn()

dopynion-0.1.0/dopynion/cards.py

@@ -0,0 +1,298 @@
+from __future__ import annotations
+
+import inspect
+import random
+import sys
+from collections import defaultdict
+from enum import StrEnum
+from typing import TYPE_CHECKING, ClassVar
+
+if TYPE_CHECKING:
+    from collections.abc import Callable
+
+    from dopynion.player import Player
+
+
+class CardName(StrEnum):  # Create with a metaclass
+    COPPER = "copper"
+    COUNCILROOM = "councilroom"
+    CURSE = "curse"
+    DUCHY = "duchy"
+    ESTATE = "estate"
+    FESTIVAL = "festival"
+    GOLD = "gold"
+    LABORATORY = "laboratory"
+    MARKET = "market"
+    PROVINCE = "province"
+    SILVER = "silver"
+    SMITHY = "smithy"
+    VILLAGE = "village"
+    WOODCUTTER = "woodcutter"
+
+    def __repr__(self) -> str:
+        return self.value.title()
+
+
+class ClassNameRepr(type):
+    def __repr__(cls) -> str:
+        return cls.__name__
+
+
+class Card(metaclass=ClassNameRepr):
+    types: ClassVar[dict[CardName, type[Card]]] = {}
+    name = "Unknown"
+    cost = 10_000
+    money = 0
+    is_action = False
+    is_kingdom = True
+    is_money = False
+
+    def __init_subclass__(cls) -> None:
+        Card.types[CardName[cls.__name__.upper()]] = cls
+
+    def __eq__(self, other: object) -> bool:
+        return isinstance(self, other) or self.__class__ is other
+
+    def __hash__(self) -> int:
+        return hash(self.name)
+
+    def __repr__(self) -> str:
+        return self.name
+
+    @classmethod
+    def action(cls, player: Player) -> None:
+        raise NotImplementedError
+
+
+class Copper(Card):
+    name = "Cuivre"
+    cost = 0
+    money = 1
+    is_kingdom = False
+    is_money = True
+
+
+class CouncilRoom(Card):
+    name = "Chambre du conseil"
+    cost = 5
+    is_action = True
+
+    @classmethod
+    def action(cls, player: Player) -> None:
+        for _ in range(4):
+            player.hand.append(player.take_one_card_from_deck())
+        player.purchases_left += 1
+
+
+class Curse(Card):
+    name = "Malédiction"
+    cost = 0
+    is_kingdom = False
+
+
+class Duchy(Card):
+    name = "Duché"
+    cost = 5
+    is_kingdom = False
+
+
+class Estate(Card):
+    name = "Domaine"
+    cost = 2
+    is_kingdom = False
+
+
+class Festival(Card):
+    name = "Festival"
+    cost = 5
+    is_action = True
+
+    @classmethod
+    def action(cls, player: Player) -> None:
+        player.actions_left += 2
+        player.purchases_left += 1
+        player.money += 2
+
+
+class Gold(Card):
+    name = "Or"
+    cost = 6
+    money = 3
+    is_kingdom = False
+    is_money = True
+
+
+class Laboratory(Card):
+    name = "Laboratoire"
+    cost = 5
+    is_action = True
+
+    @classmethod
+    def action(cls, player: Player) -> None:
+        for _ in range(2):
+            player.hand.append(player.take_one_card_from_deck())
+        player.actions_left += 1
+
+
+class Market(Card):
+    name = "Marché"
+    cost = 5
+    is_action = True
+
+    @classmethod
+    def action(cls, player: Player) -> None:
+        player.hand.append(player.take_one_card_from_deck())
+        player.actions_left += 1
+        player.purchases_left += 1
+        player.money += 1
+
+
+class Province(Card):
+    name = "Province"
+    cost = 8
+    is_kingdom = False
+
+
+class Silver(Card):
+    name = "Argent"
+    cost = 4
+    money = 2
+    is_kingdom = False
+    is_money = True
+
+
+class Smithy(Card):
+    name = "Forgeron"
+    cost = 4
+    is_action = True
+
+    @classmethod
+    def action(cls, player: Player) -> None:
+        for _ in range(3):
+            player.hand.append(player.take_one_card_from_deck())
+
+
+class Village(Card):
+    name = "Village"
+    cost = 3
+    is_action = True
+
+    @classmethod
+    def action(cls, player: Player) -> None:
+        player.hand.append(player.take_one_card_from_deck())
+        player.actions_left += 2
+
+
+class Woodcutter(Card):
+    name = "Bucheron"
+    cost = 3
+    is_action = True
+
+    @classmethod
+    def action(cls, player: Player) -> None:
+        player.purchases_left += 1
+        player.money += 2
+
+
+actions_card_name: set[CardName] = {
+    name.lower()
+    for name, class_ in inspect.getmembers(sys.modules[__name__], inspect.isclass)
+    if issubclass(class_, Card) and class_.name != "Unknown" and class_.is_action
+}
+
+money_card_name: set[CardName] = {CardName.COPPER, CardName.SILVER, CardName.GOLD}
+
+
+class CardContainer:
+    """Storage for card."""
+
+    def __init__(self) -> None:
+        self._quantities: dict[CardName, int] = defaultdict(int)
+        self._cards: list[CardName] = []
+
+    def __getattr__(self, attribute: str) -> int:
+        if attribute.endswith("_qty"):
+            card_name = attribute[:-4]
+            return self._quantities[CardName[card_name.upper()]]
+        raise AttributeError
+
+    def __repr__(self) -> str:
+        return str(self._cards)
+
+    def append(self, card_name: CardName) -> None:
+        self._cards.append(card_name)
+        self._quantities[card_name] += 1
+
+    def append_several(self, qty: int, card_name: CardName) -> None:
+        for _ in range(qty):
+            self.append(card_name)
+
+    def remove(self, card_name: CardName) -> None:
+        self._quantities[card_name] -= 1
+        self._cards.remove(card_name)
+
+    def shuffle(self) -> None:
+        random.shuffle(self._cards)
+
+    def contains_action(self) -> bool:
+        return any(
+            card_name in actions_card_name
+            for card_name, qty in self._quantities.items()
+            if qty > 0
+        )
+
+    @property
+    def action_cards(self) -> CardContainer:
+        ret = CardContainer()
+        for card_name, qty in self._quantities.items():
+            if card_name in actions_card_name:
+                ret.append_several(qty, card_name)
+        return ret
+
+    def contains_money(self) -> bool:
+        return any(
+            card_name in money_card_name
+            for card_name, qty in self._quantities.items()
+            if qty > 0
+        )
+
+    @property
+    def money_cards(self) -> CardContainer:
+        ret = CardContainer()
+        for card_name, qty in self._quantities.items():
+            if card_name in money_card_name:
+                ret.append_several(qty, card_name)
+        return ret
+
+    @property
+    def money(self) -> int:
+        return (
+            1 * self._quantities.get(CardName.COPPER, 0)
+            + 2 * self._quantities.get(CardName.SILVER, 0)
+            + 3 * self._quantities.get(CardName.GOLD, 0)
+        )
+
+    def pop(self, index: int = -1) -> CardName:
+        card_name = self._cards.pop(index)
+        self._quantities[card_name] -= 1
+        return card_name
+
+    def __contains__(self, card_name: CardName) -> bool:
+        return self._quantities.get(card_name, 0) > 0
+
+    def __len__(self) -> int:
+        return len(self._cards)
+
+    def __getitem__(self, index: int) -> CardName:
+        return self._cards[index]
+
+    def quantity(self, card_name: CardName) -> int:
+        return self._quantities.get(card_name, 0)
+
+    def sort(self, key: Callable, *, reverse: bool = False) -> None:
+        self._cards.sort(key=key, reverse=reverse)
+
+    def empty_to(self, other: CardContainer) -> None:
+        while self:
+            card_name = self.pop(0)
+            other.append(card_name)

dopynion-0.1.0/dopynion/constants.py

@@ -0,0 +1 @@
+MAX_NB_PLAYERS = 4

dopynion-0.1.0/dopynion/exceptions.py

@@ -0,0 +1,26 @@
+class InvalidCommandError(Exception):
+    pass
+
+
+class AddPlayerDuringGameError(InvalidCommandError):
+    pass
+
+
+class InvalidActionError(InvalidCommandError):
+    pass
+
+
+class ActionDuringBuyError(InvalidCommandError):
+    pass
+
+
+class MissingCardError(InvalidCommandError):
+    pass
+
+
+class InvalidBuyError(InvalidCommandError):
+    pass
+
+
+class NotEnoughMoneyError(InvalidCommandError):
+    pass

dopynion-0.1.0/dopynion/game.py

@@ -0,0 +1,65 @@
+import inspect
+import random
+
+import dopynion.cards
+from dopynion.cards import Card, CardContainer, CardName
+from dopynion.constants import MAX_NB_PLAYERS
+from dopynion.exceptions import (
+    AddPlayerDuringGameError,
+    InvalidCommandError,
+)
+from dopynion.player import Player
+
+
+class Game:
+    def __init__(self) -> None:
+        self.players: list[Player] = []
+        self.started = False
+        self.stock = CardContainer()
+        self.stock.append_several(30, CardName.GOLD)
+        self.stock.append_several(40, CardName.SILVER)
+        self.stock.append_several(60, CardName.COPPER)
+        self.stock.append_several(12, CardName.ESTATE)
+        self.stock.append_several(12, CardName.DUCHY)
+        self.stock.append_several(12, CardName.PROVINCE)
+        self.stock.append_several(30, CardName.CURSE)
+
+    def __getattr__(self, name: str) -> int:
+        if name.endswith("_qty"):
+            return getattr(self.stock, name)
+        raise AttributeError
+
+    def add_player(self, player: Player) -> None:
+        if self.started:
+            raise AddPlayerDuringGameError
+        if len(self.players) < MAX_NB_PLAYERS:
+            self.players.append(player)
+            player.game = self
+            self.copper_qty -= 7
+        else:
+            msg = f"At most {MAX_NB_PLAYERS} players"
+            raise InvalidCommandError(msg)
+
+    def start(self) -> None:
+        self.started = True
+        if len(self.players) <= 2:  # noqa: PLR2004
+            self.estate_qty = 8
+            self.duchy_qty = 8
+            self.province_qty = 8
+            self.curse_qty = 10
+        elif len(self.players) == 3:  # noqa: PLR2004
+            self.curse_qty = 20
+        possible_kingdoms: list[CardName] = [
+            name.lower()
+            for name, class_ in inspect.getmembers(dopynion.cards, inspect.isclass)
+            if issubclass(class_, Card)
+            and class_.name != "Unknown"
+            and class_.is_kingdom
+        ]
+        for _ in range(10):
+            if not possible_kingdoms:
+                break  # TODO à virer quand on aura plus de 10 possibles
+            card_name = random.choice(possible_kingdoms)  # noqa: S311
+            self.stock.append_several(10, card_name)
+            # TODO pour jardin c'est particulier, cf bas de la page 2
+            possible_kingdoms.remove(card_name)

dopynion-0.1.0/dopynion/player.py

@@ -0,0 +1,121 @@
+from typing import TYPE_CHECKING
+
+from dopynion.cards import Card, CardContainer, CardName
+from dopynion.exceptions import (
+    ActionDuringBuyError,
+    InvalidActionError,
+    InvalidBuyError,
+    NotEnoughMoneyError,
+)
+
+if TYPE_CHECKING:
+    import dopynion.game
+
+
+class State:
+    ACTION = 1
+    BUY = 2
+    ADJUST = 3
+
+
+class Player:
+    def __init__(self, name: str) -> None:
+        self.game: dopynion.game.Game = None
+        self.name = name
+        self.deck = CardContainer()
+        self.deck.append_several(7, CardName.COPPER)
+        self.deck.append_several(3, CardName.ESTATE)
+        self.deck.shuffle()
+        self.hand = CardContainer()
+        self.discard = CardContainer()
+        self.played_cards = CardContainer()
+        self.actions_left: int = 0
+        self.purchases_left: int = 0
+        self.money: int = 0
+        self.state = State.ACTION
+        self._adjust()
+
+    def __repr__(self) -> str:
+        ret = f"Player: {self.name}\n"
+        ret += f" - actions left: {self.actions_left}, "
+        ret += f"purchases left: {self.purchases_left}, "
+        ret += f"money left: {self.money + self.hand.money}\n"
+        ret += f" - hand: {self.hand}\n"
+        ret += f" - played cards: {self.played_cards}\n"
+        ret += f" - deck: {self.deck}\n"
+        ret += f" - discard: {self.discard}\n"
+        return ret
+
+    def _check_for_action_to_buy_transition(self) -> None:
+        if not self.hand.contains_action() or not self.actions_left:
+            self.actions_left = 0
+            self.state = State.BUY
+
+    def _check_for_buy_to_adjust_transition(self) -> None:
+        if not self.hand.contains_money() or not self.purchases_left:
+            self.purchases_left = 0
+            self.state = State.ADJUST
+
+    def start_turn(self) -> None:
+        self.state = State.ACTION
+        self.actions_left = 1
+        self.purchases_left = 1
+        self.money = 0
+        self._check_for_action_to_buy_transition()
+
+    def end_turn(self) -> None:
+        self._adjust()
+
+    def take_one_card_from_deck(self) -> CardName:
+        if not self.deck:
+            self.discard.empty_to(self.deck)
+            self.deck.shuffle()
+        return self.deck.pop(0)
+
+    def _adjust(self) -> None:
+        self.played_cards.empty_to(self.discard)
+        self.hand.empty_to(self.discard)
+        for _ in range(5):
+            self.hand.append(self.take_one_card_from_deck())
+        self.state = State.ADJUST
+
+    def _prepare_money(self, money: int) -> None:
+        money_cards = self.hand.money_cards
+        money_cards.sort(key=lambda card_name: Card.types[card_name].money)
+        while self.money < money:
+            if not money_cards:
+                break
+            money_card = money_cards.pop(0)
+            self.money += Card.types[money_card].money
+            self.hand.remove(money_card)
+            self.played_cards.append(money_card)
+
+    def buy(self, card_name: CardName) -> None:
+        print(f"> BUY {card_name} [{self.name}]")
+        quantity = getattr(self.game.stock, card_name + "_qty")
+        if not quantity:
+            raise InvalidBuyError(card_name)
+        card = Card.types[card_name]
+        if self.money + self.hand.money < card.cost:
+            raise NotEnoughMoneyError
+        self._prepare_money(card.cost)
+        self.money -= card.cost
+        self.game.stock.remove(card_name)
+        self.discard.append(card_name)
+        self.purchases_left -= 1
+        self._check_for_buy_to_adjust_transition()
+
+    def action(self, card_name: CardName) -> None:
+        print(f"> ACTION {card_name} [{self.name}]")
+        if self.state != State.ACTION:
+            raise ActionDuringBuyError(card_name)
+        if card_name not in self.hand:
+            raise InvalidActionError(card_name)
+        try:
+            Card.types[card_name].action(self)
+        except NotImplementedError as err:
+            raise InvalidActionError(card_name) from err
+        self.actions_left -= 1
+        self.hand.remove(card_name)
+        self.played_cards.append(card_name)
+        self._check_for_action_to_buy_transition()

dopynion-0.1.0/dopynion.egg-info/PKG-INFO

@@ -0,0 +1,10 @@
+Metadata-Version: 2.1
+Name: dopynion
+Version: 0.1.0
+Summary: Dominion
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+License-File: LICENSE
+
+# dopynion
+Dominion in Python

dopynion-0.1.0/dopynion.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+LICENSE
+README.md
+pyproject.toml
+dopynion/__init__.py
+dopynion/__main__.py
+dopynion/cards.py
+dopynion/constants.py
+dopynion/exceptions.py
+dopynion/game.py
+dopynion/player.py
+dopynion.egg-info/PKG-INFO
+dopynion.egg-info/SOURCES.txt
+dopynion.egg-info/dependency_links.txt
+dopynion.egg-info/top_level.txt
+tests/test_game.py
+tests/test_player.py

dopynion-0.1.0/dopynion.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

dopynion-0.1.0/dopynion.egg-info/top_level.txt

@@ -0,0 +1 @@
+dopynion

dopynion-0.1.0/pyproject.toml

@@ -0,0 +1,54 @@
+[project]
+name = "dopynion"
+version = "0.1.0"
+description = "Dominion"
+readme = "README.md"
+requires-python = ">=3.12"
+dependencies = []
+
+[tool.coverage.run]
+omit = ["dopynion/__main__.py"]
+
+[tool.ruff]
+target-version = "py310"
+output-format = "concise"
+fix = true
+
+[tool.ruff.lint]
+preview = true
+select = ["ALL"]
+ignore = [
+    "CPY001",
+    "D1",
+    "D203",
+    "D212",
+    "FIX002",
+    "T201",
+    "TD002",
+    "TD003",
+    "TD004",
+]
+fixable = ["ALL"]
+unfixable = []
+
+[tool.ruff.lint.extend-per-file-ignores]
+"tests/**/*.py" = [
+    "S101",    # asserts allowed in tests...
+    "ARG",     # Unused function args -> fixtures nevertheless are functionally relevant...
+    "FBT",     # Don't care about booleans as positional arguments in tests, e.g. via @pytest.mark.parametrize()
+    "PLR2004", # Magic value used in comparison, ...
+    "INP001",  #  Add an `__init__.py`
+]
+
+[tool.ruff.format]
+preview = true
+quote-style = "double"
+indent-style = "space"
+docstring-code-format = true
+
+[tool.uv]
+dev-dependencies = ["pytest-cov>=5.0.0", "pytest>=8.3.3", "ruff>=0.6.8"]
+
+[tool.pytest.ini_options]
+minversion = "8.0"
+addopts = "-vvv --cov=dopynion  --cov-report html --cov-branch"

dopynion-0.1.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+

dopynion-0.1.0/tests/test_game.py

@@ -0,0 +1,92 @@
+import pytest
+
+from dopynion.exceptions import (
+    AddPlayerDuringGameError,
+    InvalidCommandError,
+)
+from dopynion.game import Game
+from dopynion.player import Player
+
+
+def test_can_add_player() -> None:
+    game = Game()
+    game.add_player(Player("player 1"))
+    game.start()
+    assert len(game.players) == 1
+
+
+def test_cannot_add_player_on_started_game() -> None:
+    game = Game()
+    game.add_player(Player("player 1"))
+    game.start()
+    with pytest.raises(AddPlayerDuringGameError):
+        game.add_player(Player("2"))
+
+
+def test_max_nb_players() -> None:
+    game = Game()
+    game.add_player(Player("1"))
+    game.add_player(Player("2"))
+    game.add_player(Player("3"))
+    game.add_player(Player("4"))
+    with pytest.raises(InvalidCommandError):
+        game.add_player(Player("5"))
+    game.start()
+
+
+def test_initial_money() -> None:
+    game = Game()
+    game.add_player(Player("1"))
+    game.add_player(Player("2"))
+    game.start()
+    assert game.gold_qty == 30
+    assert game.silver_qty == 40
+    assert game.copper_qty == 60 - 7 * 2
+
+
+def test_initial_estates_2_players() -> None:
+    game = Game()
+    game.add_player(Player("1"))
+    game.add_player(Player("2"))
+    game.start()
+    assert game.estate_qty == 8
+    assert game.duchy_qty == 8
+    assert game.province_qty == 8
+
+
+def test_initial_estates_3_players() -> None:
+    game = Game()
+    game.add_player(Player("1"))
+    game.add_player(Player("2"))
+    game.add_player(Player("3"))
+    game.start()
+    assert game.estate_qty == 12
+    assert game.duchy_qty == 12
+    assert game.province_qty == 12
+
+
+def test_initial_malediction_2_players() -> None:
+    game = Game()
+    game.add_player(Player("1"))
+    game.add_player(Player("2"))
+    game.start()
+    assert game.curse_qty == 10
+
+
+def test_initial_malediction_3_players() -> None:
+    game = Game()
+    game.add_player(Player("1"))
+    game.add_player(Player("2"))
+    game.add_player(Player("3"))
+    game.start()
+    assert game.curse_qty == 20
+
+
+def test_initial_malediction_4_players() -> None:
+    game = Game()
+    game.add_player(Player("1"))
+    game.add_player(Player("2"))
+    game.add_player(Player("3"))
+    game.add_player(Player("4"))
+    game.start()
+    assert game.curse_qty == 30

dopynion-0.1.0/tests/test_player.py

@@ -0,0 +1,48 @@
+import pytest
+
+from dopynion.cards import CardName
+from dopynion.exceptions import (
+    ActionDuringBuyError,
+    InvalidActionError,
+)
+from dopynion.player import Player, State
+
+
+def test_initial_deck() -> None:
+    player = Player("Toto")
+    assert len(player.deck) + len(player.hand) == 10
+    assert player.deck.copper_qty + player.hand.copper_qty == 7
+    assert player.deck.estate_qty + player.hand.estate_qty == 3
+
+
+def test_make_hand_enough_cards_in_deck() -> None:
+    player = Player("toto")
+    assert len(player.hand) == 5
+    assert len(player.deck) == 5
+
+
+def test_make_hand_not_enough_cards_in_deck() -> None:
+    pass  # TODO add the test
+
+
+def test_unknown_action() -> None:
+    player = Player("toto")
+    player.start_turn()
+    player.state = State.ACTION
+    with pytest.raises(InvalidActionError):
+        player.action("FooBar")
+
+
+def test_invalid_action() -> None:
+    player = Player("toto")
+    player.start_turn()
+    with pytest.raises(ActionDuringBuyError):
+        player.action(CardName.SMITHY)
+
+
+def test_invalid_action_when_no_corresponding_card() -> None:
+    player = Player("toto")
+    player.start_turn()
+    player.state = State.ACTION
+    with pytest.raises(InvalidActionError):
+        player.action(CardName.VILLAGE)