def test_Scout_autoselect(self):
tu.print_test_header("test Scout autoselect")
scout = intrigue.Scout(self.game, self.player1)
self.player1.deck.append(supply_cards.Copper(self.game, self.player1))
self.player1.deck.append(supply_cards.Copper(self.game, self.player1))
self.player1.deck.append(supply_cards.Estate(self.game, self.player1))
self.player1.deck.append(supply_cards.Estate(self.game, self.player1))
initial_decksize = len(self.player1.deck)
self.player1.hand.add(scout)
scout.play()
self.assertTrue(self.player1.deck[-1].title == "Copper")
self.assertTrue(self.player1.deck[-2].title == "Copper")
self.assertTrue(len(self.player1.deck) == initial_decksize - 2)
def test_Rabble(self):
tu.print_test_header("test Rabble")
rabble = prosperity.Rabble(self.game, self.player1)
copper = supply_cards.Copper(self.game, self.player2)
estate = supply_cards.Estate(self.game, self.player2)
self.player2.deck.append(estate)
self.player2.deck.append(copper)
self.player2.deck.append(estate)
duchy = supply_cards.Duchy(self.game, self.player3)
gardens = base.Gardens(self.game, self.player3)
great_hall = intrigue.Great_Hall(self.game, self.player3)
self.player3.deck.append(duchy)
self.player3.deck.append(gardens)
self.player3.deck.append(great_hall)
rabble.play()
topdeck1 = self.player2.topdeck()
topdeck2 = self.player2.topdeck()
self.assertTrue(topdeck1.title == "Estate")
self.assertTrue(topdeck2.title == "Estate")
yield tu.send_input(self.player3, "post_selection",
["Gardens", "Duchy"])
topdeck1 = self.player3.topdeck()
topdeck2 = self.player3.topdeck()
self.assertTrue(topdeck1.title == "Duchy")
self.assertTrue(topdeck2.title == "Gardens")
def test_Royal_Seal(self):
tu.print_test_header("test Royal Seal")
royal_seal = prosperity.Royal_Seal(self.game, self.player1)
workers_village = prosperity.Workers_Village(self.game, self.player1)
copper = supply_cards.Copper(self.game, self.player1)
self.player1.hand.add(royal_seal)
self.player1.hand.add(copper)
tu.add_many_to_hand(self.player1, workers_village, 3)
workers_village.play()
workers_village.play()
workers_village.play()
royal_seal.play()
yield tu.send_input(self.player1, "buyCard", "Curse")
self.assertTrue(self.player1.last_mode["mode"] == "select")
yield tu.send_input(self.player1, "post_selection", ["Yes"])
self.assertTrue(self.player1.deck[-1].title == "Curse")
yield gen.sleep(.2)
self.assertTrue(self.player1.last_mode["mode"] == "buy")
yield tu.send_input(self.player1, "buyCard", "Silver")
self.assertTrue(self.player1.last_mode["mode"] == "select")
yield tu.send_input(self.player1, "post_selection", ["No"])
self.assertTrue(self.player1.discard_pile[-1].title == "Silver")
yield gen.sleep(.2)
self.assertTrue(self.player1.last_mode["mode"] == "buy")
yield tu.send_input(self.player1, "buyCard", "Mint")
self.assertTrue(self.player1.last_mode["mode"] == "buy")
def test_Vault(self):
tu.print_test_header("testing vault")
vault = prosperity.Vault(self.game, self.player1)
self.player1.hand.add(vault)
vault.play()
yield tu.send_input(self.player1, "post_selection",
["Estate", "Estate"])
#add two coppers to player2's hand so he can use vault to discard
tu.add_many_to_hand(self.player2,
supply_cards.Copper(self.game, self.player2), 2)
self.assertTrue(self.player1.balance == 2)
self.assertTrue(self.player1.last_mode["mode"] == "wait")
#both players should be able to choose to discard at the same time
self.assertTrue(self.player2.last_mode["mode"] == "select")
self.assertTrue(self.player3.last_mode["mode"] == "select")
yield tu.send_input(self.player2, "post_selection", ["Yes"])
cards_in_hand = len(self.player2.hand.card_array())
yield tu.send_input(self.player2, "post_selection",
["Copper", "Copper"])
self.assertTrue(
len(self.player2.hand.card_array()) == cards_in_hand - 1)
yield tu.send_input(self.player3, "post_selection", ["No"])
self.assertTrue(self.player1.last_mode["mode"] == "buy")
def test_Spice_Merchant(self):
tu.print_test_header("test Spice Merchant")
spice_merchant1 = hl.Spice_Merchant(self.game, self.player1)
spice_merchant2 = hl.Spice_Merchant(self.game, self.player1)
copper = supply_cards.Copper(self.game, self.player1)
silver = supply_cards.Silver(self.game, self.player1)
self.player1.hand.add(spice_merchant1)
self.player1.hand.add(spice_merchant2)
self.player1.deck = [silver] * 5
self.player1.hand.add(copper)
yield tu.send_input(self.player1, "play", "Spice Merchant")
yield tu.send_input(self.player1, "post_selection", ["Copper"])
yield tu.send_input(self.player1, "post_selection",
["+2 cards +1 action"])
self.assertTrue(copper in self.game.trash_pile)
self.assertTrue(
len(self.player1.hand.card_array()) == 8
) # We started with 5 cards and then added 2 SMs and a copper (8 cards), then put one in
yield tu.send_input(
self.player1, "play", "Spice Merchant"
) # play and trashed the copper, then drew 2 brining us back to 8
yield tu.send_input(self.player1, "post_selection", ["Copper"])
yield tu.send_input(self.player1, "post_selection", ["+$2 +1 buy"])
self.assertTrue(len(self.game.trash_pile) == 2)
self.assertTrue(self.player1.buys == 2)
self.assertTrue(self.player1.balance == 2)
def test_Trading_Post(self):
tu.print_test_header("test Trading Post")
trading_post = intrigue.Trading_Post(self.game, self.player1)
copper = supply_cards.Copper(self.game, self.player1)
tu.clear_player_hand(self.player1)
self.player1.hand.add(copper)
self.player1.hand.add(trading_post)
self.player1.actions = 3
yield tu.send_input(self.player1, "play", "Trading Post")
self.assertTrue(len(self.player1.hand) == 0)
tu.clear_player_hand(self.player1)
self.player1.hand.add(copper)
self.player1.hand.add(copper)
self.player1.hand.add(trading_post)
trading_post.play()
self.assertTrue(self.player1.hand.get_count("Silver") == 1)
self.player1.hand.add(trading_post)
self.player1.hand.add(trading_post)
self.player1.hand.add(trading_post)
trading_post.play()
yield tu.send_input(self.player1, "post_selection", ["Trading Post", "Trading Post"])
self.assertTrue(self.player1.hand.get_count("Silver") == 2)
def test_Thief_3_players(self):
tu.print_test_header("test Thief 3 players")
thief_card = base.Thief(self.game, self.player1)
self.player1.hand.add(thief_card)
player2gold = supply_cards.Gold(self.game, self.player2)
player3copper = supply_cards.Copper(self.game, self.player3)
self.player2.deck = [
supply_cards.Estate(self.game, self.player2), player2gold
]
self.player3.deck = [
player3copper,
supply_cards.Estate(self.game, self.player3)
]
select_gain_gold_future = gen.Future()
select_gain_copper_future = gen.Future()
gain_future = gen.Future()
self.player1.select = unittest.mock.MagicMock(
side_effect=[select_gain_gold_future, select_gain_copper_future])
self.player1.gain = unittest.mock.Mock(return_value=gain_future)
thief_card.play()
self.assertTrue(player2gold in self.game.trash_pile)
select_gain_gold_future.set_result(["Yes"])
yield gen.moment
self.player1.gain.assert_called_with("Gold", False)
gain_future.set_result("finish gaining gold")
yield gen.moment
self.assertTrue(player3copper in self.game.trash_pile)
select_gain_copper_future.set_result(["Yes"])
yield gen.moment
self.player1.gain.assert_called_with("Copper", False)
def base_deck(self): deck = [] for i in range(0, 7): deck.append(supply_cards.Copper(game=self.game, played_by=self)) for i in range(0, 3): deck.append(supply_cards.Estate(game=self.game, played_by=self)) random.shuffle(deck) return deck
def test_Swindler(self):
tu.print_test_header("test Swindler")
swindler = intrigue.Swindler(self.game, self.player1)
self.player2.deck.append(supply_cards.Copper(self.game, self.player2))
self.player1.hand.add(swindler)
swindler.play()
yield tu.send_input(self.player1, "selectSupply", ["Curse"])
self.assertTrue(self.player2.discard_pile[-1].title == "Curse")
def test_Gardens(self):
tu.print_test_header("test Gardens")
gardens = base.Gardens(self.game, self.player1)
self.player1.hand.add(gardens)
self.assertTrue(gardens.get_vp() == 1)
for i in range(0, 9):
self.player1.deck.append(base.Gardens(self.game, self.player1))
# decksize = 20
self.assertTrue(self.player1.total_vp() == 23)
self.player1.deck.append(supply_cards.Copper(self.game, self.player1))
self.assertTrue(self.player1.total_vp() == 23)
def test_Warehouse(self):
tu.print_test_header("test Warehouse")
copper = supply_cards.Copper(self.game, self.player1)
self.player1.hand.add(copper)
warehouse = sea.Warehouse(self.game, self.player1)
warehouse.play()
self.assertTrue(self.player1.actions == 1)
self.assertTrue(len(self.player1.hand) == 9)
yield tu.send_input(self.player1, "post_selection", ["Copper", "Copper", "Copper"])
self.assertTrue(len(self.player1.hand) == 6)
def test_Secret_Chamber(self):
tu.print_test_header("test Secret Chamber")
secret_chamber = intrigue.Secret_Chamber(self.game, self.player1)
estate = supply_cards.Estate(self.game, self.player1)
tu.clear_player_hand(self.player1)
tu.add_many_to_hand(self.player1, estate, 4)
self.player1.hand.add(secret_chamber)
secret_chamber.play()
yield tu.send_input(self.player1, "post_selection", ["Estate", "Estate", "Estate", "Estate"])
self.assertTrue(self.player1.balance == 4)
self.player1.end_turn()
tu.clear_player_hand(self.player1)
tu.add_many_to_hand(self.player1, estate, 4)
self.player1.hand.add(secret_chamber)
#clear player3's hand no reaction
tu.clear_player_hand(self.player3)
self.player1.deck.append(supply_cards.Copper(self.game, self.player1))
self.player1.deck.append(supply_cards.Copper(self.game, self.player1))
self.player2.hand.add(base.Militia(self.game, self.player2))
self.player2.hand.play("Militia")
yield tu.send_input(self.player1, "post_selection", ["Reveal"])
self.assertTrue(self.player2.last_mode["mode"] == "wait")
#put back on top
yield tu.send_input(self.player1, "post_selection", ["Estate", "Estate"])
#second secret chamber
yield tu.send_input(self.player1, "post_selection", ["Hide"])
yield gen.sleep(.2)
#discard
yield tu.send_input(self.player1, "post_selection", ["Estate", "Estate"])
self.assertTrue(len(self.player1.hand.card_array()) == 3)
estates = self.player1.hand.get_count("Estate")
self.player1.draw(2)
self.assertTrue(self.player1.hand.get_count("Estate") == estates + 2)
self.assertTrue(self.player2.last_mode["mode"] != "wait")
def test_Coppersmith(self):
tu.print_test_header("test Coppersmith")
coppersmith = intrigue.Coppersmith(self.game, self.player1)
copper = supply_cards.Copper(self.game, self.player1)
self.player1.hand.add(coppersmith)
self.player1.hand.add(copper)
coppersmith.play()
copper.play()
self.assertTrue(self.player1.balance == 2)
#copper should be back to $1 after turn
self.player1.end_turn()
self.assertTrue(copper.value == 1)
def test_Counting_House(self):
tu.print_test_header("test Counting House")
counting_house = prosperity.Counting_House(self.game, self.player1)
copper1 = supply_cards.Copper(self.game, self.player1)
copper2 = supply_cards.Copper(self.game, self.player1)
copper3 = supply_cards.Copper(self.game, self.player1)
num_coppers = self.player1.hand.get_count('Copper')
self.player1.discard_pile = []
self.player1.discard_pile.append(copper1)
self.player1.discard_pile.append(copper2)
self.player1.discard_pile.append(copper3)
all_copper = len(
[x for x in self.player1.all_cards() if x.title == "Copper"])
counting_house.play()
yield tu.send_input(self.player1, "post_selection", ['2'])
self.assertTrue(
self.player1.hand.get_count('Copper') == num_coppers + 2)
self.assertTrue(len(self.player1.discard_pile) == 1)
self.assertTrue(
len([x for x in self.player1.all_cards()
if x.title == "Copper"]) == all_copper)
def test_Upgrade(self):
tu.print_test_header("test Upgrade")
upgrade = intrigue.Upgrade(self.game, self.player1)
tu.add_many_to_hand(self.player1, upgrade, 2)
self.player1.hand.add(supply_cards.Copper(self.game, self.player1))
self.player1.hand.add(supply_cards.Estate(self.game, self.player1))
upgrade.play()
yield tu.send_input(self.player1, "post_selection", ["Copper"])
upgrade.play()
yield tu.send_input(self.player1, "post_selection", ["Estate"])
yield tu.send_input(self.player1, "selectSupply", ["Silver"])
self.assertTrue("Silver" == self.player1.discard_pile[-1].title)
def test_Embassy(self):
tu.print_test_header("test Embassy")
self.player1.balance = 5
yield tu.send_input(self.player1, "buyCard", "Embassy")
self.assertTrue(self.player2.discard_pile[-1].title == "Silver")
self.assertTrue(self.player3.discard_pile[-1].title == "Silver")
embassy = hl.Embassy(self.game, self.player2)
copper = supply_cards.Copper(self.game, self.player2)
tu.set_player_hand(self.player2, [embassy])
tu.add_many_to_hand(self.player2, copper, 4)
embassy.play()
yield tu.send_input(self.player2, "post_selection",
["Copper", "Copper", "Copper"])
self.assertTrue(len(self.player2.hand) == 6)
def test_Develop(self):
tu.print_test_header("Test Develop")
develop = hl.Develop(self.game, self.player1)
tu.add_many_to_hand(self.player1, develop, 2)
self.player1.hand.add(supply_cards.Copper(self.game, self.player1))
self.player1.hand.add(supply_cards.Estate(self.game, self.player1))
develop.play()
yield tu.send_input(self.player1, "post_selection", ["Copper"])
develop.play()
yield tu.send_input(self.player1, "post_selection", ["Estate"])
yield tu.send_input(self.player1, "selectSupply", ["Silver"])
self.assertTrue("Silver" == self.player1.discard_pile[-1].title)
def test_Chancellor(self):
tu.print_test_header("test Chancellor")
self.player1.discard_pile.append(
supply_cards.Copper(self.game, self.player1))
chancellor = base.Chancellor(self.game, self.player1)
self.player1.hand.add(chancellor)
select_future = gen.Future()
self.player1.select = unittest.mock.Mock(return_value=select_future)
chancellor.play()
self.assertTrue(len(self.player1.discard_pile) == 1)
decksize = len(self.player1.deck)
select_future.set_result(["Yes"])
yield gen.moment
self.assertTrue(len(self.player1.discard_pile) == decksize + 1)
self.assertTrue(len(self.player1.deck) == 0)
def test_Peddler(self):
tu.print_test_header("test Peddler")
village = base.Village(self.game, self.player1)
copper = supply_cards.Copper(self.game, self.player1)
self.player1.hand.add(copper)
tu.add_many_to_hand(self.player1, village, 5)
village.play()
self.assertTrue(self.game.price_modifier["Peddler"] == 0)
village.play()
village.play()
village.play()
village.play()
copper.play()
self.assertTrue(self.game.price_modifier["Peddler"] == -10)
self.assertTrue(self.game.card_from_title("Peddler").get_price() == 0)
def test_Library(self):
tu.print_test_header("test Library")
library = base.Library(self.game, self.player1)
village = base.Village(self.game, self.player1)
copper = supply_cards.Copper(self.game, self.player1)
self.player1.deck = [copper, village, copper]
self.player1.hand.add(library)
self.player1.hand.add = unittest.mock.Mock()
select_future = gen.Future()
self.player1.select = unittest.mock.Mock(return_value=select_future)
library.play()
self.player1.hand.add.assert_called_with(copper)
select_future.set_result(["Yes"])
yield gen.moment
self.player1.hand.add.assert_called_with(copper)
self.assertTrue("Village" not in self.player1.hand)
def __init__(self, players, required_cards, excluded_cards, req_supply="default", test=False):
Game.__init__(self, players, req_supply)
if not test:
self.logger = logHandler.LogHandler(", ".join(map(lambda x: x.name, self.players)) + " " + time.ctime(time.time()))
else:
self.logger = logHandler.TestLogHandler()
# randomize turn order
random.shuffle(self.players)
self.trash_pile = []
self.empty_piles = 0
self.mat = {}
if req_supply == "default":
rand = random.randint(1, 10)
if rand < 2:
req_supply = "prosperity"
# kingdom = dictionary {card.title => [card, count]} i.e {"Copper": [card.Copper(self,None),10]}
base_supply = [supply_cards.Curse(self, None), supply_cards.Estate(self, None),
supply_cards.Duchy(self, None), supply_cards.Province(self, None), supply_cards.Copper(self, None),
supply_cards.Silver(self, None), supply_cards.Gold(self, None)]
if req_supply == "prosperity":
base_supply.append(supply_cards.Colony(self, None))
base_supply.append(supply_cards.Platinum(self, None))
self.base_supply = self.init_supply(base_supply)
generator = kg.kingdomGenerator(self, required_cards, excluded_cards)
if not test:
self.kingdom = self.init_supply(generator.gen_kingdom())
else:
self.kingdom = self.init_supply(generator.every_card_kingdom())
self.supply = cp.CardPile()
self.supply.combine(self.base_supply)
self.supply.combine(self.kingdom)
for x in self.kingdom.unique_cards():
x.on_supply_init()
#dictionary of card title => price modifier for that card
self.price_modifier = {}
for x in self.supply.unique_cards():
self.price_modifier[x.title] = 0
#record of game announcements for public viewing / archiving
self.game_log = []
def test_inn_gain(self):
tu.print_test_header("test Inn on gain")
village = base.Village(self.game, self.player1)
moat = base.Moat(self.game, self.player1)
copper = supply_cards.Copper(self.game, self.player1)
self.player1.discard_pile = [village, moat, copper]
self.player1.gain('Inn')
self.assertTrue(self.player1.last_mode["mode"] == "select")
self.assertTrue("Village" in self.player1.last_mode["select_from"])
self.assertTrue("Moat" in self.player1.last_mode["select_from"])
self.assertTrue("Inn" in self.player1.last_mode["select_from"])
self.assertTrue("Copper" not in self.player1.last_mode["select_from"])
yield tu.send_input(self.player1, "post_selection",
["Village", "Moat", "Inn"])
self.assertTrue(self.player1.discard_pile == [copper])
self.assertTrue(village in self.player1.deck)
self.assertTrue(moat in self.player1.deck)
def test_Tribute(self):
tu.print_test_header("test Tribute")
tribute = intrigue.Tribute(self.game, self.player1)
tu.add_many_to_hand(self.player1, tribute, 2)
copper = supply_cards.Copper(self.game, self.player2)
great_hall = intrigue.Great_Hall(self.game, self.player2)
swindler = intrigue.Swindler(self.game, self.player2)
self.player2.deck.append(copper)
self.player2.deck.append(copper)
self.player2.deck.append(great_hall)
self.player2.deck.append(swindler)
cards_in_hand = len(self.player1.hand.card_array())
tribute.play()
self.assertTrue(self.player1.actions == 4)
self.assertTrue(len(self.player2.discard_pile) == 2)
tribute.play()
self.assertTrue(self.player1.balance == 2)
def test_Coppersmith_Throne_Room(self):
tu.print_test_header("test Coppersmith Throne Room")
coppersmith = intrigue.Coppersmith(self.game, self.player1)
throneroom = base.Throne_Room(self.game, self.player1)
copper = supply_cards.Copper(self.game, self.player1)
self.player1.hand.add(coppersmith)
self.player1.hand.add(throneroom)
self.player1.hand.add(copper)
throneroom.play()
yield tu.send_input(self.player1, "post_selection", ["Coppersmith"])
copper.play()
self.assertTrue(self.player1.balance == 3)
#we played throne room, coppersmith, copper
self.assertTrue(len(self.player1.played_cards) == 3)
self.player1.end_turn()
self.assertTrue(copper.value == 1)
#make sure we only have 1 coppersmith in our deck
coppersmiths = [x for x in self.player1.all_cards() if x.title == "Coppersmith"]
self.assertTrue(len(coppersmiths) == 1)
def test_Torturer(self):
tu.print_test_header("test Torturer")
torturer = intrigue.Torturer(self.game, self.player1)
tu.add_many_to_hand(self.player1, torturer, 2)
copper = supply_cards.Copper(self.game, self.player2)
estate = supply_cards.Estate(self.game, self.player2)
tu.set_player_hand(self.player2, [copper, copper, copper, estate, estate])
self.player1.actions = 2
tu.send_input(self.player1, "play", "Torturer")
# choosing to discard 2
yield tu.send_input(self.player2, "post_selection", ["Discard 2 cards"])
yield tu.send_input(self.player2, "post_selection", ["Copper", "Copper"])
yield tu.send_input(self.player3, "post_selection", ["Gain a Curse"])
self.assertTrue(self.player2.last_mode["mode"] != "wait")
self.assertTrue(self.player3.last_mode["mode"] != "wait")
self.assertTrue(len(self.player2.hand) == 3)
tu.send_input(self.player1, "play", "Torturer")
yield tu.send_input(self.player2, "post_selection", ["Gain a Curse"])
yield tu.send_input(self.player3, "post_selection", ["Gain a Curse"])
self.assertTrue(self.player2.hand.get_count('Curse') == 1)
def test_Thief_2_treasures(self):
tu.print_test_header("test Thief on 2 treasures")
thief_card = base.Thief(self.game, self.player1)
self.player1.hand.add(thief_card)
self.player2.deck.append(supply_cards.Copper(self.game, self.player2))
self.player2.deck.append(supply_cards.Silver(self.game, self.player2))
select_trash_future = gen.Future()
select_gain_future = gen.Future()
self.player1.select = unittest.mock.MagicMock(
side_effect=[select_trash_future, select_gain_future])
self.player1.gain = unittest.mock.Mock(return_value=gen.Future())
thief_card.play()
self.player1.select.assert_called_with(1, 1, ["Silver", "Copper"],
unittest.mock.ANY)
select_trash_future.set_result(["Silver"])
yield gen.moment
self.assertTrue(self.game.trash_pile[-1].title == "Silver")
select_gain_future.set_result(["Yes"])
yield gen.moment
self.player1.gain.assert_called_with("Silver", False)
def test_Saboteur(self):
tu.print_test_header("test Saboteur")
saboteur = intrigue.Saboteur(self.game, self.player1)
steward = intrigue.Steward(self.game, self.player2)
copper = supply_cards.Copper(self.game, self.player2)
self.player2.deck.append(steward)
self.player2.deck.append(copper)
player3_decksize = len(self.player3.deck)
saboteur.play()
yield tu.send_input(self.player2, "selectSupply", ["Curse"])
self.assertTrue(self.player2.discard_pile.pop().title == "Curse")
self.assertTrue(self.player2.discard_pile.pop().title == "Copper")
self.assertTrue(len(self.player3.deck) == 0)
self.assertTrue(player3_decksize == len(self.player3.discard_pile))
self.player2.deck.append(steward)
saboteur.play()
yield tu.send_input(self.player2, "selectSupply", ["None"])
self.assertTrue(len(self.player2.discard_pile) == 0)
def test_Steward(self):
tu.print_test_header("test Steward")
steward = intrigue.Steward(self.game, self.player1)
steward2 = intrigue.Steward(self.game, self.player1)
steward3 = intrigue.Steward(self.game, self.player1)
copper = supply_cards.Copper(self.game, self.player1)
estate = supply_cards.Estate(self.game, self.player1)
tu.clear_player_hand(self.player1)
tu.add_many_to_hand(self.player1, steward, 3)
tu.add_many_to_hand(self.player1, copper, 3)
tu.add_many_to_hand(self.player1, estate, 2)
self.player1.actions = 5
# +$2
steward.play()
yield tu.send_input(self.player1, "post_selection", ["+$2"])
self.assertTrue(self.player1.balance == 2)
# Trash 2 with more than 2 in hand
steward2.play()
trash_size = len(self.game.trash_pile)
yield tu.send_input(self.player1, "post_selection", ["Trash 2 cards from hand"])
yield tu.send_input(self.player1, "post_selection", ["Estate", "Estate"])
self.assertTrue(len(self.game.trash_pile) == trash_size + 2)
# Trash 2 with homogeneous hand
steward3.play()
yield tu.send_input(self.player1, "post_selection", ["Trash 2 cards from hand"])
self.assertTrue(self.player1.hand.get_count("Copper") == 1)
self.player1.hand.add(steward)
# Trash 2 with 1 in hand
self.player1.hand.data["Steward"] = [intrigue.Steward(self.game, self.player1)]
steward.play()
yield tu.send_input(self.player1, "post_selection", ["Trash 2 cards from hand"])
self.assertTrue(len(self.player1.hand) == 0)
def test_Trade_Route(self):
tu.print_test_header("test Trade Route")
trade_route = prosperity.Trade_Route(self.game, self.player1)
copper = supply_cards.Copper(self.game, self.player1)
tu.set_player_hand(self.player1,
[trade_route, copper, copper, copper, copper])
trade_route2 = prosperity.Trade_Route(self.game, self.player2)
self.player2.hand.add(trade_route2)
self.assertTrue(self.player1.buys == 1)
trade_route.play()
self.assertTrue(self.player1.buys == 2)
self.assertTrue(self.player1.balance == 0)
yield tu.send_input(self.player1, "post_selection", ["Copper"])
self.player1.spend_all_money()
#buy 2 estates
tu.send_input(self.player1, "buyCard", "Estate")
tu.send_input(self.player1, "buyCard", "Estate")
self.player1.end_turn()
trade_route2.play()
yield tu.send_input(self.player2, "post_selection", ["Copper"])
self.assertTrue(self.player2.balance == 1)
self.assertTrue(self.player2.buys == 2)
def test_Scout_entire_deck(self):
tu.print_test_header("test Scout entire deck")
scout = intrigue.Scout(self.game, self.player1)
self.player1.deck = [supply_cards.Copper(self.game, self.player1) for x in range(0,3)]
scout.play()
self.assertTrue(len(self.player1.deck) == 3)
