def test_initialize_creates_positions():
new_game = Game()
new_game.add_player(Player(name="Bernardo", deck=deepcopy(data.green_deck)))
new_game.add_player(Player(name="John", deck=deepcopy(data.black_deck)))
new_game.initialize()
assert new_game.positions
def test_initialize_created_positions_get_deep_copies_of_decks():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_deck))
john = Player(name="John", deck=deepcopy(data.black_deck))
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
assert new_game.positions[0].library is not bernardo.deck
assert new_game.positions[1].library is not john.deck
def test_playing_a_land_when_not_player_turn_raises():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_land_deck))
john = Player(name="John", deck=data.black_land_deck)
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
land_to_play = john.position.hand[0]
assert_raises(InvalidOperationError, john.play, card=land_to_play, exc_pattern=r"It's not John's turn to play.")
def test_generate_mana_and_tap_ability_raises_when_card_is_not_played():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_land_deck))
john = Player(name="John", deck=deepcopy(data.black_land_deck))
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
assert_raises(InvalidOperationError, bernardo.position.hand[0].GenerateManaAndTap, exc_pattern=r"The player can only generate mana for cards in his battlefield.")
def test_initialize_shuffles_decks_to_libraries():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_deck))
john = Player(name="John", deck=deepcopy(data.black_deck))
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
assert new_game.positions[0].library.cards[0] is not bernardo.deck.cards[0]
assert new_game.positions[1].library.cards[0] is not john.deck.cards[0]
def test_player_in_a_game_has_position_assigned():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_deck))
john = Player(name="John", deck=data.black_deck)
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
assert bernardo.position is new_game.positions[0]
assert john.position is new_game.positions[1]
def test_initialize_makes_libraries_equal_to_deck_minus_hand():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_deck))
john = Player(name="John", deck=deepcopy(data.black_deck))
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
assert len(new_game.positions[0].library.cards) == len(bernardo.deck.cards) - 7
assert len(new_game.positions[1].library.cards) == len(john.deck.cards) - 7
def test_initialize_draws_players_first_hand():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_deck))
john = Player(name="John", deck=deepcopy(data.black_deck))
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
assert len(new_game.positions[0].hand) == 7
assert len(new_game.positions[1].hand) == 7
def test_initialize_created_positions_get_empty_battlefields():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_deck))
john = Player(name="John", deck=deepcopy(data.black_deck))
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
assert not new_game.positions[0].battlefield
assert not new_game.positions[1].battlefield
def test_create_game_assigns_20_hit_points_for_each_player_on_free_for_all():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_deck))
john = Player(name="John", deck=deepcopy(data.black_deck))
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
assert new_game.positions[0].hit_points == 20
assert new_game.positions[1].hit_points == 20
def test_initialize_creates_positions_with_right_indexes():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_deck))
john = Player(name="John", deck=deepcopy(data.black_deck))
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
assert new_game.positions[0].index == 0
assert new_game.positions[1].index == 1
def test_tapping_lands_from_hand_raises():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_land_deck))
john = Player(name="John", deck=data.black_land_deck)
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
land_to_play = bernardo.position.hand[0]
assert_raises(InvalidOperationError, land_to_play.GenerateManaAndTap, exc_pattern=r"The player can only generate mana for cards in his battlefield.")
def test_playing_a_land_when_not_in_players_hand_raises():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_land_deck))
john = Player(name="John", deck=data.black_land_deck)
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
land_to_play = Land("Some Land", "green")
assert_raises(InvalidOperationError, bernardo.play, card=land_to_play, exc_pattern=r"The card must be in the player's hand in order to be played.")
def test_cards_get_initialized():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_land_deck))
john = Player(name="John", deck=data.black_land_deck)
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
land_to_play = bernardo.position.hand[0]
assert land_to_play.game is new_game
assert land_to_play.position is bernardo.position
def test_initialize_creates_positions_according_to_the_players():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_deck))
john = Player(name="John", deck=deepcopy(data.black_deck))
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
assert len(new_game.positions) == 2
assert new_game.positions[0].player is bernardo
assert new_game.positions[1].player is john
def test_passing_to_next_step_passes_automatic_steps():
global messages
messages = []
new_game = Game()
new_game.bus.subscribe('step_started', on_step_started)
cards_a = [Land("Some card", "green")] * 20
deck_a = Deck("deck a", cards_a)
bernardo = Player(name="Bernardo", deck=deck_a)
cards_b = [Land("Some card", "black")] * 20
deck_b = Deck("deck a", cards_b)
john = Player(name="John", deck=deck_b)
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
new_game.move_to_next_step()
assert 'declare_attackers_step_started' in messages
def test_can_pass_to_next_phase():
global messages
messages = []
new_game = Game()
new_game.bus.subscribe('phase_started', on_phase_started)
cards_a = [Land("Some card", "green")] * 20
deck_a = Deck("deck a", cards_a)
bernardo = Player(name="Bernardo", deck=deck_a)
cards_b = [Land("Some card", "black")] * 20
deck_b = Deck("deck a", cards_b)
john = Player(name="John", deck=deck_b)
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
new_game.move_to_next_step()
assert 'combat_phase_started' in messages
def test_game_is_at_turn_one_after_initialized():
new_game = Game()
cards_a = [Land("Some card", "green")] * 20
deck_a = Deck("deck a", cards_a)
bernardo = Player(name="Bernardo", deck=deck_a)
cards_b = [Land("Some card", "black")] * 20
deck_b = Deck("deck a", cards_b)
john = Player(name="John", deck=deck_b)
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
assert new_game.turn == 1
def test_playing_two_lands_in_the_same_turn_fails():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_land_deck))
john = Player(name="John", deck=data.black_land_deck)
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
land_to_play = bernardo.position.hand[0]
bernardo.play(land_to_play)
land_to_play = bernardo.position.hand[0]
assert_raises(InvalidOperationError, bernardo.play, card=land_to_play, exc_pattern=r"The player can only play one land per turn.")
def test_generating_mana_out_of_a_tapped_land_raises():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_land_deck))
john = Player(name="John", deck=data.black_land_deck)
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
land_to_play = bernardo.position.hand[0]
bernardo.play(land_to_play)
land_to_play.GenerateManaAndTap() #tap to generate mana
assert_raises(InvalidOperationError, land_to_play.GenerateManaAndTap, exc_pattern=r"The player can't generate mana out of a tapped card.")
def test_player_can_play_land():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_land_deck))
john = Player(name="John", deck=data.black_land_deck)
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
land_to_play = bernardo.position.hand[0]
bernardo.play(land_to_play)
assert len(bernardo.position.hand) == 6
assert len(bernardo.position.battlefield) == 1
assert bernardo.position.battlefield[0] == land_to_play
def test_game_decides_player_to_start():
new_game = Game()
cards_a = [Card("Some card", Cost(green=1))] * 20
deck_a = Deck("deck a", cards_a)
bernardo = Player(name="Bernardo", deck=deck_a)
cards_b = [Card("Some card", Cost(black=4))] * 20
deck_b = Deck("deck a", cards_b)
john = Player(name="John", deck=deck_b)
new_game.add_player(bernardo, supress_validation=True)
new_game.add_player(john, supress_validation=True)
new_game.initialize()
assert new_game.current_position == 1
def test_playing_a_card_without_having_the_cost_raises():
new_game = Game()
deck_a = Deck("some_deck", [Card("some card %d" % cnt, Cost(green=4)) for cnt in range(20)])
deck_b = Deck("some_deck_b", [Card("some card %d " % cnt, Cost(black=3)) for cnt in range(20)])
bernardo = Player(name="Bernardo", deck=deck_a)
john = Player(name="John", deck=deck_b)
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
card_to_play = bernardo.position.hand[0]
assert_raises(InvalidOperationError, bernardo.play, card=card_to_play, exc_pattern=r"The card cost must be satisfied in order for it to be played.")
def test_generate_mana_and_tap_ability_taps_card():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_land_deck))
john = Player(name="John", deck=deepcopy(data.black_land_deck))
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
land = bernardo.position.hand[0]
bernardo.play(land)
land.GenerateManaAndTap()
assert land.is_tapped
def test_generate_mana_and_tap_ability_raises_when_card_is_tapped():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_land_deck))
john = Player(name="John", deck=deepcopy(data.black_land_deck))
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
land = bernardo.position.hand[0]
bernardo.play(land)
land.GenerateManaAndTap()
assert_raises(InvalidOperationError, land.GenerateManaAndTap, exc_pattern=r"The player can't generate mana out of a tapped card.")
def test_initialized_game_passes_through_main_phase_main_step():
global messages
messages = []
new_game = Game()
new_game.bus.subscribe('step_started', on_step_started)
cards_a = [Land("Some card", "green")] * 20
deck_a = Deck("deck a", cards_a)
bernardo = Player(name="Bernardo", deck=deck_a)
cards_b = [Land("Some card", "black")] * 20
deck_b = Deck("deck a", cards_b)
john = Player(name="John", deck=deck_b)
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
assert 'main_step_started' in messages
def test_initialize_created_positions_get_zero_mana():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_deck))
john = Player(name="John", deck=data.black_deck)
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
assert new_game.positions[0].mana["green"] == 0
assert new_game.positions[0].mana["blue"] == 0
assert new_game.positions[0].mana["red"] == 0
assert new_game.positions[0].mana["black"] == 0
assert new_game.positions[0].mana["white"] == 0
assert new_game.positions[0].mana["colorless"] == 0
assert new_game.positions[1].mana["green"] == 0
assert new_game.positions[1].mana["blue"] == 0
assert new_game.positions[1].mana["red"] == 0
assert new_game.positions[1].mana["black"] == 0
assert new_game.positions[1].mana["white"] == 0
assert new_game.positions[1].mana["colorless"] == 0
def test_player_can_tap_lands_to_get_mana():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_land_deck))
john = Player(name="John", deck=data.black_land_deck)
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
land_to_play = bernardo.position.hand[0]
bernardo.play(land_to_play)
land_to_play.GenerateManaAndTap() #tap to generate mana
assert bernardo.position.mana["green"] == 1
assert bernardo.position.mana["black"] == 0
assert bernardo.position.mana["blue"] == 0
assert bernardo.position.mana["red"] == 0
assert bernardo.position.mana["white"] == 0
assert bernardo.position.mana["colorless"] == 0
assert land_to_play.is_tapped
def test_generate_mana_and_tap_ability_publishes_mana_generated_event():
new_game = Game()
messages = []
def handle_event(game, position, card):
messages.append("Card %s tapped to generate 1 %s mana" % (card.name, card.color))
new_game.bus.subscribe('mana_generated', handle_event)
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_land_deck))
john = Player(name="John", deck=deepcopy(data.black_land_deck))
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
land = bernardo.position.hand[0]
bernardo.play(land)
land.GenerateManaAndTap()
assert len(messages) == 1
assert messages[0] == "Card Forest tapped to generate 1 green mana"
def test_player_can_play_two_lands_in_different_turns():
new_game = Game()
bernardo = Player(name="Bernardo", deck=deepcopy(data.green_land_deck))
john = Player(name="John", deck=data.black_land_deck)
new_game.add_player(bernardo)
new_game.add_player(john)
new_game.initialize()
land_to_play = bernardo.position.hand[0]
bernardo.play(land_to_play)
new_game.move_to_next_step() #combat - declare_attackers
new_game.move_to_next_step() #combat - declare_blockers
new_game.move_to_next_step() #combat - damage
new_game.move_to_next_step() #main - main
new_game.move_to_next_step() #main - main (other player)
new_game.move_to_next_step() #combat - declare_attackers
new_game.move_to_next_step() #combat - declare_blockers
new_game.move_to_next_step() #combat - damage
new_game.move_to_next_step() #main - main
new_game.move_to_next_step() #main - main (other player)
land_to_play = bernardo.position.hand[0]
bernardo.play(land_to_play)
assert len(bernardo.position.hand) == 5
assert len(bernardo.position.battlefield) == 2
assert bernardo.position.battlefield[1] == land_to_play
