def test_pick_chars(game): # arrange player1 = game.add_player('Player1') player2 = game.add_player('Player2') game.crowned_player = player2 config = GamePlayConfig() config.turn_unused_faceup_chars = 2 game_controller = GameController(game, config) controller1 = SpyPlayerController() game_controller.set_player_controller(player1, controller1) controller2 = SpyPlayerController() game_controller.set_player_controller(player2, controller2) game_controller.start_game() # act game_controller.start_turn() # assert # TURN-PICK assert player1.char is not None assert player2.char is not None # TURN-PICK-FIRST assert len(controller2.possible_chars) > len(controller1.possible_chars) # TURN-PICK-FACEDOWN assert len(game.turn.unused_chars) == 6 # TURN-FACEUP assert sum(bool(char) for char in game.turn.unused_chars) == 2 # TURN-FACEUP-KING assert Character.King not in game.turn.unused_chars
def test_destroy(game): # arrange num_districts = len(game.districts) player1 = game.add_player('Player1', city=[District.Manor]) player1.cash_in(3) player2 = game.add_player('Player2', city=[District.Docks, District.Cathedral]) command = commands.Destroy() # act assert [ p.name for p in command.choices(ShadowPlayer(player1, me=True), ShadowGame(player1, game)) ] == ['Player1', 'Player2'] command.select(player2) assert command.choices(ShadowPlayer(player1, me=True), ShadowGame(player1, game)) == [District.Docks] command.select(District.Docks) assert not command.choices(ShadowPlayer(player1, me=True), ShadowGame(player1, game)) command.apply(player1, game) # assert assert player1.gold == 1 assert player2.city == (District.Cathedral, ) assert len(game.districts) == num_districts + 1 assert game.districts[-1] == District.Docks
def test_swap_hands(game): # arrange player1 = game.add_player('Player1', hand=[District.Manor]) player2 = game.add_player('Player2', hand=[District.Tavern, District.Cathedral]) command = commands.SwapHands() # act choices = command.choices(ShadowPlayer(player1, me=True), ShadowGame(player, game)) assert [p.name for p in choices] == ['Player2'] command.select(player2) assert not command.choices(ShadowPlayer(player1, me=True), ShadowGame(player, game)) command.apply(player1, game) # assert assert player1.hand == ( District.Tavern, District.Cathedral, ) assert player2.hand == (District.Manor, )
def test_thief_takes_gold_from_robbed_char(game): # arrange thief = game.add_player('Player1') victim = game.add_player('Player2') victim.cash_in(10) game_controller = GameController(game) game_controller.set_player_controller(thief, DummyPlayerController()) game_controller.set_player_controller(victim, DummyPlayerController()) game_controller.start_game() game_controller.start_turn() thief.char = Character.Thief victim.char = Character.King game.turn.robbed_char = Character.King thief_gold = thief.gold victim_gold = victim.gold # act game_controller.take_turns() # assert turn_income = 2 assert thief.gold == thief_gold + victim_gold + turn_income assert victim.gold == turn_income
def test_privates_are_not_exposed_to_bot(game): # arrange player1 = game.add_player('Player1') player2 = game.add_player('Player2') game_controller = GameController(game) spy_controller = SpyPlayerController() game_controller.set_player_controller(player1, spy_controller) game_controller.set_player_controller(player2, DummyPlayerController()) game_controller.start_game() game_controller.start_turn() # act game_controller.take_turns() # assert game = spy_controller.game assert not any(bool(district) for district in game.districts) assert game.crowned_player in game.players another_player = game.players.find_by_name('Player2') assert not any(bool(district) for district in another_player.hand) assert all(bool(district) for district in another_player.city) # TODO: not verifiable assert another_player.gold assert not hasattr(another_player, 'game')
def test_warlord_abilities(game): # arrange player = game.add_player('Player', char=Character.Warlord) victim = game.add_player('Victim', char=Character.King) victim.build_district(District.Docks) # assert sink = CommandsSink(player, game) assert not sink.possible_abilities sink.execute(sink.possible_actions[0]) assert sink.possible_abilities == (commands.Destroy(), )
def test_magician_abilities(game): # arrange player = game.add_player('Player', char=Character.Magician) player.take_card(District.Watchtower) victim = game.add_player('Victim', char=Character.King) victim.take_card(District.Docks) # act sink = CommandsSink(player, game) # assert assert sink.possible_abilities == (commands.SwapHands(), commands.ReplaceHand())
def test_winner_with_most_score(game): # arrange player1 = game.add_player('Player1', city=[District.Watchtower] * 8) player2 = game.add_player('Player2', city=[District.Watchtower] * 7) game_controller = GameController(game) game.turn.first_completer = player1 # act winner = game_controller.winner # assert assert winner == player1
def test_player_added(game, listener): # arrange added_player = None def save_added_player(player): nonlocal added_player added_player = player listener.player_added = Mock(side_effect=save_added_player) # act game.add_player('Player1') # assert assert added_player
def test_replace_hands(game): # arrange player = game.add_player( 'Player', hand=[District.Cathedral, District.Tavern, District.Cathedral]) command = commands.ReplaceHand() num_districts = len(game.districts) # act assert command.choices(ShadowPlayer(player, me=True), ShadowGame(player, game)) == [ District.Cathedral, District.Tavern, District.Cathedral ] command.select(District.Cathedral) assert command.choices(ShadowPlayer(player, me=True), ShadowGame(player, game)) == [ District.Tavern, District.Cathedral ] command.apply(player, game) # assert assert len(player.hand) == 3 assert list(player.hand)[:2] == [District.Tavern, District.Cathedral] assert player.hand[2] != District.Cathedral assert len(game.districts) == num_districts
def test_take_turns(game): # arrange player1 = game.add_player('Player1') player2 = game.add_player('Player2') game_controller = GameController(game) spy_controller = SpyPlayerController() game_controller.set_player_controller(player1, spy_controller) game_controller.set_player_controller(player2, DummyPlayerController()) game_controller.start_game() game_controller.start_turn() # act game_controller.take_turns() # assert assert len(spy_controller.possible_actions) == 2
def test_assassin_abilities(game): # arrange player = game.add_player('Player', char=Character.Assassin) # act sink = CommandsSink(player, game) # assert assert sink.possible_abilities == (commands.Kill(), )
def test_thief_abilities(game): # arrange player = game.add_player('Player', char=Character.Thief) # act sink = CommandsSink(player, game) # assert assert sink.possible_abilities == (commands.Rob(), )
def test_bonus_for_completing_city(game): # arrange player = game.add_player('Player', city=[District.Watchtower] * 8) # act score = rules.score(player, game) # assert bonus = 2 assert score == 8 + bonus
def test_possible_income(game): # arrange city = [District.Prison, District.Watchtower, District.TradingPost] player = game.add_player('Player', char=Character.Warlord, city=city) # act sink = CommandsSink(player, game) # assert assert sink.possible_income == (commands.CashIn(2), )
def test_score_is_cost_of_the_city(game): # arrange player = game.add_player('Player', city=[District.Watchtower, District.Palace]) # act score = rules.score(player, game) # assert assert score == 1 + 5
def test_winner_with_most_score_without_bonuses_if_tie(game): # arrange player1 = game.add_player('Player1', city=[District.Watchtower] * 8) player2 = game.add_player( 'Player2', city=[District.Palace, District.Cathedral, District.TradingPost]) game_controller = GameController(game) game.turn.first_completer = player1 assert rules.score(player1, game) == 12 assert rules.score(player2, game) == 12 # act winner = game_controller.winner # assert assert winner == player2
def test_possible_actions(game): # arrange player = game.add_player('Player', char=Character.King) # act sink = CommandsSink(player, game) # assert assert sink.possible_actions == (commands.CashIn(2), commands.DrawSomeCards(draw=2, keep=1))
def test_take_crown(game): # arrange player = game.add_player('Player1') command = commands.TakeCrown() # act command.apply(player, game) # assert assert game.crowned_player == player
def test_winner_with_most_gold_if_double_tie(game): # arrange player1 = game.add_player('Player1', city=[District.Watchtower] * 8) player2 = game.add_player('Player2', city=[District.Tavern] * 8) player1.cash_in(9) player2.cash_in(10) game_controller = GameController(game) assert rules.score(player1, game) == 10 assert rules.score(player1, game, with_bonuses=False) == 8 assert rules.score(player2, game) == 10 assert rules.score(player2, game, with_bonuses=False) == 8 # act winner = game_controller.winner # assert assert winner == player2
def test_income_may_be_taken_before_action(game): # arrange player = game.add_player('Player', char=Character.Warlord, city=[District.Prison]) # act sink = CommandsSink(player, game) # assert assert sink.possible_income
def test_sink_is_done_when_end_turn_called(game): # arrange player = game.add_player('Player', char=Character.Assassin) # act sink = CommandsSink(player, game) sink.execute(sink.possible_actions[0]) assert sink.can_end_turn sink.end_turn() # assert assert sink.done
def test_builds_cannot_be_made_before_action(game): # arrange player = game.add_player('Player', char=Character.Warlord, hand=[District.Watchtower]) player.cash_in(10) # act sink = CommandsSink(player, game) # assert assert not sink.possible_builds
def test_income_must_be_taken_after_action(game): # arrange player = game.add_player('Player', char=Character.Warlord, hand=[District.Watchtower]) player.cash_in(10) # act sink = CommandsSink(player, game) sink.execute(sink.possible_actions[0]) # assert assert sink.possible_builds
def test_possible_build(game): # arrange player = game.add_player('Player', char=Character.King, hand=[District.Tavern, District.Fortress]) player.cash_in(2) # assert sink = CommandsSink(player, game) assert not sink.possible_builds sink.execute(sink.possible_actions[0]) assert sink.possible_builds == (commands.Build(), )
def test_killed_char_misses_turn(game): # arrange assassing = game.add_player('Player1') victim = game.add_player('Player2') game_controller = GameController(game) game_controller.set_player_controller(assassing, DummyPlayerController()) game_controller.set_player_controller( victim, victim_controller := SpyPlayerController()) game_controller.start_game() game_controller.start_turn() assassing.char = Character.Assassin victim.char = Character.King game.turn.killed_char = Character.King # act game_controller.take_turns() # assert assert not victim_controller.possible_actions
def test_start_game(game): # arrange player1 = game.add_player('Player1') player2 = game.add_player('Player2') game_controller = GameController(game) game_controller.set_player_controller(player1, DummyPlayerController()) game_controller.set_player_controller(player2, DummyPlayerController()) # act game_controller.start_game() # assert # START-CARDS assert len(player1.hand) == 4 assert len(player2.hand) == 4 # START-GOLD assert player1.gold == 2 assert player2.gold == 2 # START-CROWN assert game.crowned_player in (player1, player2)
def test_bonus_for_all_colors(game): # arrange player = game.add_player('Player', city=[ District.Watchtower, District.Tavern, District.Temple, District.Manor ]) # act score = rules.score(player, game) # assert bonus = 3 assert score == 1 + 1 + 1 + 3 + bonus
def test_architect_ability(game): # arrange player = game.add_player('Player', char=Character.Architect, hand=[District.Watchtower]) # act sink = CommandsSink(player, game) sink.execute( next( iter(action for action in sink.possible_actions if isinstance(action, commands.CashIn)))) # assert assert len(player.hand) == 3
def test_merchant_ability(game): # arrange player = game.add_player('Player', char=Character.Merchant) player.cash_in(1) # act sink = CommandsSink(player, game) draw_cards = next( iter(action for action in sink.possible_actions if isinstance(action, commands.DrawSomeCards))) draw_cards.select(draw_cards.choices(player, game)[0]) sink.execute(draw_cards) # assert assert player.gold == 2