def test_SavageRoar(self):
deck1 = StackedDeck([StonetuskBoar(), StonetuskBoar(), SavageRoar()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.MAGE)
game = Game([deck1, deck2], [OneCardPlayingAgent(), OneCardPlayingAgent()])
game.current_player = 1
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
minion_increase_mock = mock.Mock()
game.other_player.minions[0].bind("attack_changed", minion_increase_mock)
game.other_player.minions[1].bind("attack_changed", minion_increase_mock)
player_increase_mock = mock.Mock()
game.other_player.hero.bind("attack_changed", player_increase_mock)
game.play_single_turn()
self.assertEqual(0, game.current_player.mana)
# Make sure the attack got increased
self.assertListEqual([mock.call(2), mock.call(2)], minion_increase_mock.call_args_list)
self.assertListEqual([mock.call(2)], player_increase_mock.call_args_list)
# And make sure that it went down again
self.assertEqual(1, game.current_player.minions[0].calculate_attack())
self.assertEqual(1, game.current_player.minions[1].calculate_attack())
self.assertEqual(0, game.current_player.hero.calculate_attack())
def test_create_game(self):
card_set1 = []
card_set2 = []
test_env = self
for cardIndex in range(0, 30):
card_set1.append(card_lookup("Stonetusk Boar"))
card_set2.append(card_lookup("Novice Engineer"))
deck1 = Deck(card_set1, Malfurion())
deck2 = Deck(card_set2, Jaina())
checked_cards = []
class MockAgent1:
def do_card_check(self, cards):
test_env.assertEqual(len(cards), 3)
checked_cards.append(list(cards))
return [False, True, True]
def set_game(self, game):
pass
class MockAgent2:
def do_card_check(self, cards):
test_env.assertEqual(len(cards), 4)
checked_cards.append(list(cards))
return [False, True, True, False]
def set_game(self, game):
pass
agent1 = mock.Mock(spec=MockAgent1(), wraps=MockAgent1())
agent2 = mock.Mock(spec=MockAgent2(), wraps=MockAgent2())
game = Game([deck1, deck2], [agent1, agent2])
game.pre_game()
self.assertEqual(agent1.method_calls[0][0], "do_card_check",
"Agent not asked to select cards")
self.assertEqual(agent2.method_calls[0][0], "do_card_check",
"Agent not asked to select cards")
self.assertTrue(game.players[0].deck == deck1,
"Deck not assigned to player")
self.assertTrue(game.players[1].deck == deck2,
"Deck not assigned to player")
self.assertTrue(game.players[0].agent == agent1,
"Agent not stored in the hearthbreaker")
self.assertTrue(game.players[1].agent == agent2,
"Agent not stored in the hearthbreaker")
self.assertListEqual(checked_cards[0][1:], game.players[0].hand[1:],
"Cards not retained after request")
self.assertListEqual(checked_cards[1][1:2], game.players[1].hand[1:2],
"Cards not retained after request")
def test_bind_once(self):
event = mock.Mock()
event2 = mock.Mock()
binder = Bindable()
binder.bind_once("test", event)
binder.bind("test", event2)
binder.trigger("test", 1, 5, 6)
event.assert_called_once_with(1, 5, 6)
event2.assert_called_once_with(1, 5, 6)
binder.trigger("test")
event.assert_called_once_with(1, 5, 6)
self.assertEqual(event2.call_count, 2)
def test_first_turn(self):
card_set1 = []
card_set2 = []
for cardIndex in range(0, 30):
card_set1.append(card_lookup("Stonetusk Boar"))
card_set2.append(card_lookup("Novice Engineer"))
deck1 = Deck(card_set1, Malfurion())
deck2 = Deck(card_set2, Jaina())
agent1 = mock.Mock(spec=DoNothingAgent(), wraps=DoNothingAgent())
agent2 = mock.Mock(spec=DoNothingAgent(), wraps=DoNothingAgent())
game = Game([deck1, deck2], [agent1, agent2])
game.start()
def test_FreezingTrap_many_cards(self):
class FreezingTrapAgent(DoNothingBot):
def do_turn(self, player):
if player.mana == 6:
game.play_card(player.hand[0])
if player.mana == 7:
player.minions[0].attack()
game = generate_game_for(FreezingTrap, BoulderfistOgre,
SpellTestingAgent, FreezingTrapAgent)
for turn in range(0, 12):
game.play_single_turn()
self.assertEqual(1, len(game.current_player.minions))
death_mock = mock.Mock()
game.players[1].minions[0].bind_once("died", death_mock)
game.play_single_turn()
game.play_single_turn()
self.assertEqual(10, len(game.current_player.hand))
self.assertEqual(0, len(game.current_player.minions))
for card in game.current_player.hand:
if card.name != "The Coin":
self.assertEqual(6, card.mana_cost(game.current_player))
self.assertEqual(30, game.other_player.hero.health)
death_mock.assert_called_once_with(None)
def test_first_turn(self):
card_set1 = []
card_set2 = []
for cardIndex in range(0, 30):
card_set1.append(card_lookup("Stonetusk Boar"))
card_set2.append(card_lookup("Novice Engineer"))
deck1 = Deck(card_set1, CHARACTER_CLASS.DRUID)
deck2 = Deck(card_set2, CHARACTER_CLASS.MAGE)
agent1 = mock.Mock(spec=DoNothingBot(), wraps=DoNothingBot())
agent2 = mock.Mock(spec=DoNothingBot(), wraps=DoNothingBot())
game = Game([deck1, deck2], [agent1, agent2])
game.start()
def test_bind(self):
event = mock.Mock()
binder = Bindable()
binder.bind("test", event)
binder.trigger("test", 1, 5, 6)
event.assert_called_once_with(1, 5, 6)
binder.unbind("test", event)
binder.trigger("test")
event.assert_called_once_with(1, 5, 6)
def test_PowerOfTheWild(self):
deck1 = StackedDeck(
[StonetuskBoar(),
StonetuskBoar(),
PowerOfTheWild()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.MAGE)
# This is a test of the +1/+1 option of the Power Of the Wild Card
game = Game([deck1, deck2],
[OneCardPlayingAgent(),
OneCardPlayingAgent()])
game.current_player = game.players[1]
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
self.assertEqual(2, game.current_player.minions[0].calculate_attack())
self.assertEqual(2, game.current_player.minions[0].health)
self.assertEqual(2,
game.current_player.minions[0].calculate_max_health())
self.assertEqual(2, game.current_player.minions[1].calculate_attack())
self.assertEqual(2,
game.current_player.minions[1].calculate_max_health())
# This is a test of the "Summon Panther" option of the Power of the Wild Card
agent = OneCardPlayingAgent()
agent.choose_option = mock.Mock(
side_effect=lambda *options: options[1])
deck1 = StackedDeck(
[StonetuskBoar(),
StonetuskBoar(),
PowerOfTheWild()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck([StonetuskBoar()], CHARACTER_CLASS.MAGE)
game = Game([deck1, deck2], [agent, OneCardPlayingAgent()])
game.current_player = game.players[1]
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
self.assertEqual(
"Panther", game.current_player.minions[2].card.__class__.__name__)
self.assertEqual(3, game.current_player.minions[2].calculate_attack())
self.assertEqual(2,
game.current_player.minions[2].calculate_max_health())
def test_WildGrowth(self):
game = generate_game_for(WildGrowth, StonetuskBoar, SelfSpellTestingAgent, DoNothingAgent)
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
self.assertEqual(3, game.current_player.max_mana)
# Make sure that the case where the player is at 10 mana works as well.
for turn in range(0, 5):
game.play_single_turn()
self.assertEqual(10, game.other_player.max_mana)
card_draw_mock = mock.Mock(side_effect=game.other_player.draw)
game.other_player.draw = card_draw_mock
game.play_single_turn()
# Each time the player draws, they will draw another wild growth, which will turn into excess mana,
# which will draw another card. However, because of the ordering of the cards, the last excess mana
# will be after a wild growth, which prevents SpellTestingAgent from playing the card, so only
# 5 draws are made instead of the possible 6
self.assertEqual(5, card_draw_mock.call_count)
def test_Swipe(self):
deck1 = StackedDeck(
[BloodfenRaptor(),
StonetuskBoar(),
StonetuskBoar()], CHARACTER_CLASS.DRUID)
deck2 = StackedDeck(
[Swipe()],
CHARACTER_CLASS.DRUID,
)
game = Game([deck1, deck2],
[OneCardPlayingAgent(),
EnemyMinionSpellTestingAgent()])
game.pre_game()
game.current_player = game.players[1]
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
game.play_single_turn()
spell_damage_mock = mock.Mock()
game.current_player.minions[0].bind('damaged_by_spell',
spell_damage_mock)
game.current_player.minions[1].bind('damaged_by_spell',
spell_damage_mock)
game.current_player.minions[2].bind('damaged_by_spell',
spell_damage_mock)
swipe_card = game.other_player.hand[0]
game.play_single_turn()
self.assertListEqual([
mock.call(4, swipe_card),
mock.call(1, swipe_card),
mock.call(1, swipe_card)
], spell_damage_mock.call_args_list)
# The bloodfen raptor should be left, with one hp
self.assertEqual(1, len(game.other_player.minions))
self.assertEqual(1, game.other_player.minions[0].health)
self.assertEqual(29, game.other_player.hero.health)
