def get_supply(box, num_players, nC, nV):
"""
:param box: dictionary containing starting lists of action cards
:param num_players: number of players
:param nC: starting number of curse cards
:param nV: starting number of each victory card
:return: dictionary of 10 randomly selected action cards and a
prescribed amount of coin, victory, and curse cards (according
to this function)
"""
boxlist = [k for k in box]
random.shuffle(boxlist)
random10 = boxlist[:10]
supply = defaultdict(list, [(k, box[k]) for k in random10])
# The supply always has these cards
supply["Copper"] = [Dominion.Copper()] * (60 - num_players * 7)
supply["Silver"] = [Dominion.Silver()] * 40
supply["Gold"] = [Dominion.Gold()] * 30
supply["Estate"] = [Dominion.Estate()] * nV
supply["Duchy"] = [Dominion.Duchy()] * nV
supply["Province"] = [Dominion.Province()] * nV
supply["Curse"] = [Dominion.Curse()] * nC
return supply
def initSupply(box, player_names):
nC, nV = getCursesAndVictories(player_names)
#Pick 10 cards from box to be in the supply.
boxlist = [k for k in box]
random.shuffle(boxlist)
random10 = boxlist[:10]
supply = defaultdict(list, [(k, box[k]) for k in random10])
#The supply always has these cards
supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7)
supply["Silver"] = [Dominion.Silver()] * 40
supply["Gold"] = [Dominion.Gold()] * 30
supply["Estate"] = [Dominion.Estate()] * nV
supply["Duchy"] = [Dominion.Duchy()] * nV
supply["Province"] = [Dominion.Province()] * nV
supply["Curse"] = [Dominion.Curse()] * nC
supply_order = {
0: ['Curse', 'Copper'],
2: ['Estate', 'Cellar', 'Chapel', 'Moat'],
3: ['Silver', 'Chancellor', 'Village', 'Woodcutter', 'Workshop'],
4: [
'Gardens', 'Bureaucrat', 'Feast', 'Militia', 'Moneylender',
'Remodel', 'Smithy', 'Spy', 'Thief', 'Throne Room'
],
5: [
'Duchy', 'Market', 'Council Room', 'Festival', 'Laboratory',
'Library', 'Mine', 'Witch'
],
6: ['Gold', 'Adventurer'],
8: ['Province']
}
return supply, supply_order
def setUp(self):
# Get player names
# player_names = ["Annie","*Ben","*Carla"]
self.player_names = testUtility.GetPlayers()
# number of curses and victory cards
if len(self.player_names) > 2:
self.nV = 12
else:
self.nV = 8
self.nC = -10 + 10 * len(self.player_names)
# Refactored Get boxs
self.box = testUtility.GetBoxes(self.nV)
# refactored supplu order
self.supply_order = testUtility.SupplyOrder()
# Pick 10 cards from box to be in the supply.
self.supply = defaultdict(list)
# The supply always has these cards
self.supply["Copper"] = [Dominion.Copper()]
self.supply["Silver"] = [Dominion.Silver()]
self.supply["Gold"] = [Dominion.Gold()]
self.supply["Estate"] = [Dominion.Estate()]
self.supply["Duchy"] = [Dominion.Duchy()]
self.supply["Province"] = [Dominion.Province()]
self.supply["Curse"] = [Dominion.Curse()]
# initialize the trash
self.trash = []
self.player = Dominion.Player('Annie')
def test_cardSummary(self):
# init data
self.dataSetUp()
# get summary after setup
summary = self.player.cardsummary()
# test
self.assertEqual(3, summary['VICTORY POINTS']) # Test for 3 victory points
self.assertEqual(7, summary['Copper']) # Test for 7 copper cards
self.assertEqual(3, summary['Estate']) # Test for 3 Estate cards
# add some cards to the deck
self.player.deck += [Dominion.Smithy()] * 2
self.player.deck += [Dominion.Duchy()] * 5
self.player.deck += [Dominion.Bureaucrat()] * 9
# get new summary
summary = self.player.cardsummary()
# test for the added card plus the old ones
self.assertEqual(7, summary['Copper']) # Test for 7 copper cards
self.assertEqual(3, summary['Estate']) # Test for 3 Estate cards
self.assertEqual(2, summary['Smithy'])
self.assertEqual(5, summary['Duchy'])
self.assertEqual(9, summary['Bureaucrat'])
def SetSupply(supply):
supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7)
supply["Silver"] = [Dominion.Silver()] * 40
supply["Gold"] = [Dominion.Gold()] * 30
supply["Estate"] = [Dominion.Estate()] * nV
supply["Duchy"] = [Dominion.Duchy()] * nV
supply["Province"] = [Dominion.Province()] * nV
supply["Curse"] = [Dominion.Curse()] * nC
def addDefaultSupplyCards(supply, nV, nC, player_names):
supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7)
supply["Silver"] = [Dominion.Silver()] * 40
supply["Gold"] = [Dominion.Gold()] * 30
supply["Estate"] = [Dominion.Estate()] * nV
supply["Duchy"] = [Dominion.Duchy()] * nV
supply["Province"] = [Dominion.Province()] * nV
supply["Curse"] = [Dominion.Curse()] * nC
def updateSupplyWithoutTreasure(supply, player_names, nV, nC):
supply["Copper"] = []
supply["Silver"] = []
supply["Gold"] = []
supply["Estate"] = [Dominion.Estate()] * nV
supply["Duchy"] = [Dominion.Duchy()] * nV
supply["Province"] = [Dominion.Province()] * nV
supply["Curse"] = [Dominion.Curse()] * nC
def add_required_supplies(supply, nV, nC, player_names):
# The supply always has these cards
supply["Copper"]=[Dominion.Copper()]*(60-len(player_names)*7)
supply["Silver"]=[Dominion.Silver()]*40
supply["Gold"]=[Dominion.Gold()]*30
supply["Estate"]=[Dominion.Estate()]*nV
supply["Duchy"]=[Dominion.Duchy()]*nV
supply["Province"]=[Dominion.Province()]*nV
supply["Curse"]=[Dominion.Curse()]*nC
def SupplyBaseStart(supply, player_names, nV, nC):
supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7)
supply["Silver"] = [Dominion.Silver()] * 40
supply["Gold"] = [Dominion.Gold()] * 30
supply["Estate"] = [Dominion.Estate()] * nV
supply["Duchy"] = [Dominion.Duchy()] * nV
supply["Province"] = [Dominion.Province()] * nV
supply["Curse"] = [Dominion.Curse()] * nC
return supply
def supplyCards(nC, nV, player_names, supply):
#The supply always has these cards
supply["Copper"]=[Dominion.Copper()]*(60-len(player_names)*7)
supply["Silver"]=[Dominion.Silver()]*40
supply["Gold"]=[Dominion.Gold()]*30
supply["Estate"]=[Dominion.Estate()]*nV
supply["Duchy"]=[Dominion.Duchy()]*nV
supply["Province"]=[Dominion.Province()]*nV
supply["Curse"]=[Dominion.Curse()]*nC
def generateSupplies(nV, nC, supply, player_names):
supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7)
supply["Silver"] = [Dominion.Silver()] * 40
supply["Gold"] = [Dominion.Gold()] * 30
supply["Estate"] = [Dominion.Estate()] * nV
supply["Duchy"] = [Dominion.Duchy()] * nV
supply["Province"] = [Dominion.Province()] * nV
supply["Curse"] = [Dominion.Curse()] * nC
return supply
def addStandardCards(supply, numPlayers, nC, nV):
supply["Copper"] = [Dominion.Copper()] * (60 - numPlayers * 7)
supply["Silver"] = [Dominion.Silver()] * 40
supply["Gold"] = [Dominion.Gold()] * 30
supply["Estate"] = [Dominion.Estate()] * nV
supply["Duchy"] = [Dominion.Duchy()] * nV
supply["Province"] = [Dominion.Province()] * nV
supply["Curse"] = [Dominion.Curse()] * nC
return supply
def GetStandardSupply(supply, player_names, nV, nC):
#The supply always has these cards
supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7)
supply["Silver"] = [Dominion.Silver()] * 40
supply["Gold"] = [Dominion.Gold()] * 30
supply["Estate"] = [Dominion.Estate()] * nV
supply["Duchy"] = [Dominion.Duchy()] * nV
supply["Province"] = [Dominion.Province()] * nV
supply["Curse"] = [Dominion.Curse()] * nC
return supply
def GetSupply(box, random10, player_names, nV, nC):
supply = defaultdict(list, [(k, box[k]) for k in random10])
# The supply always has these cards
supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7)
supply["Silver"] = [Dominion.Silver()] * 40
supply["Gold"] = [Dominion.Gold()] * 30
supply["Estate"] = [Dominion.Estate()] * nV
supply["Duchy"] = [Dominion.Duchy()] * nV
supply["Province"] = [Dominion.Province()] * nV
supply["Curse"] = [Dominion.Curse()] * nC
return supply
def update_supply(supply, num_victory, num_curses, num_players): """ Sets the supply of some of the items Modifies the given supply dict Nothing returned """ supply["Copper"] = [Dominion.Copper()] * (60 - num_players * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * num_victory supply["Duchy"] = [Dominion.Duchy()] * num_victory supply["Province"] = [Dominion.Province()] * num_victory supply["Curse"] = [Dominion.Curse()] * num_curses
def get_supply(box, player_names, nV, nC):
boxlist = [k for k in box]
random.shuffle(boxlist)
random10 = boxlist[:10]
supply = defaultdict(list, [(k, box[k]) for k in random10])
supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7)
supply["Silver"] = [Dominion.Silver()] * 40
supply["Gold"] = [Dominion.Gold()] * 30
supply["Estate"] = [Dominion.Estate()] * nV
supply["Duchy"] = [Dominion.Duchy()] * nV
supply["Province"] = [Dominion.Province()] * nV
supply["Curse"] = [Dominion.Curse()] * nC
return supply
def getSupply(nV, nC, player_names, box): # Pick 10 cards from box to be in the supply. boxlist = [k for k in box] random.shuffle(boxlist) random10 = boxlist[:10] supply = defaultdict(list, [(k, box[k]) for k in random10]) # The supply always has these cards supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7) supply["Silver"] = [Dominion.Silver()] * 40 supply["Gold"] = [Dominion.Gold()] * 30 supply["Estate"] = [Dominion.Estate()] * nV supply["Duchy"] = [Dominion.Duchy()] * nV supply["Province"] = [Dominion.Province()] * nV supply["Curse"] = [Dominion.Curse()] * nC
def init_supply(box, nV, nC, num_players):
boxlist = [k for k in box]
random.shuffle(boxlist)
random10 = boxlist[:10]
supply = defaultdict(list, [(k, box[k]) for k in random10])
#The supply always has these cards
supply["Copper"] = [Dominion.Copper()] * (60 - num_players * 7)
supply["Silver"] = [Dominion.Silver()] * 40
supply["Gold"] = [Dominion.Gold()] * 30
supply["Estate"] = [Dominion.Estate()] * nV
supply["Duchy"] = [Dominion.Duchy()] * nV
supply["Province"] = [Dominion.Province()] * nV
supply["Curse"] = [Dominion.Curse()] * nC
return supply
def getSupply(box, player_names):
boxlist = [k for k in box]
random.shuffle(boxlist)
random10 = boxlist[:10]
supply = defaultdict(list, [(k, box[k]) for k in random10])
#determine the victory and curse cards based on the number of players
nV = _getVictoryNum(player_names)
nC = _getCurseNum(player_names)
#add the treasure, victory and curse cards, the supply always has these cards
supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7)
supply["Silver"] = [Dominion.Silver()] * 40
supply["Gold"] = [Dominion.Gold()] * 30
supply["Estate"] = [Dominion.Estate()] * nV
supply["Duchy"] = [Dominion.Duchy()] * nV
supply["Province"] = [Dominion.Province()] * nV
supply["Curse"] = [Dominion.Curse()] * nC
return supply
def test_cardsummary(self):
player = Dominion.Player('Tony')
self.assertEqual(10, len(player.stack()))
# making sure initial deck is correct
self.assertEqual(3, player.cardsummary()['Estate'])
self.assertEqual(7, player.cardsummary()['Copper'])
self.assertEqual(3, player.cardsummary()['VICTORY POINTS'])
# adding some cards to deck
player.deck += [Dominion.Silver()] * 3 + [Dominion.Duchy()] * 2
# making sure correct amounts in deck
self.assertEqual(3, player.cardsummary()['Estate'])
self.assertEqual(2, player.cardsummary()['Duchy'])
self.assertEqual(7, player.cardsummary()['Copper'])
self.assertEqual(3, player.cardsummary()['Silver'])
self.assertEqual(9, player.cardsummary()['VICTORY POINTS'])
def test_calcpoints(self):
#used to calculate Victory Points.
#variables
player = Dominion.Player("Duke")
#empty card collections
player.hand = []
player.deck = []
assert len(player.stack()) == 0
# add additional cards to change the expected points to be different
# original from deck and stack == 3
player.deck = [Dominion.Province()] * 10 + [Dominion.Duchy(
)] * 10 + [Dominion.Gardens()] * 10
# 60 + 30 = 90 + ( 3*10) = 120; 30 Cards
#call function
playPoints = player.calcpoints()
#assert
assert playPoints == 120
def test_gameover(self):
# set up data
self.set_up()
game_over = Dominion.gameover(self.supply)
self.assertEqual(False, game_over)
# set province cards to 0 sets gameover to true
self.supply["Province"] = [Dominion.Province()] * 0
game_over = Dominion.gameover(self.supply)
self.assertEqual(True, game_over)
# set three supply piles to empty sets gameover to true
self.supply = testUtility.getSupply(self.nV, self.nC,
self.player_names, self.box)
self.supply["Gold"] = [Dominion.Gold()] * 0
self.supply["Estate"] = [Dominion.Estate()] * 0
self.supply["Duchy"] = [Dominion.Duchy()] * 0
game_over = Dominion.gameover(self.supply)
self.assertEqual(True, game_over)
def create_supply(player_count):
box = create_box(player_count)
#Pick 10 cards from box to be in the supply.
boxlist = [k for k in box]
random.shuffle(boxlist)
random10 = boxlist[:10]
supply = defaultdict(list,[(k,box[k]) for k in random10])
#The supply always has these cards
supply["Copper"]=[Dominion.Copper()]*(60-player_count*7)
supply["Silver"]=[Dominion.Silver()]*40
supply["Gold"]=[Dominion.Gold()]*30
supply["Estate"]=[Dominion.Estate()]*number_of_victory_cards(player_count)
supply["Duchy"]=[Dominion.Duchy()]*number_of_victory_cards(player_count)
supply["Province"]=[Dominion.Province()]*number_of_victory_cards(player_count)
supply["Curse"]=[Dominion.Curse()]*number_of_curse_cards(player_count)
return supply
def setUp(self):
self.player_names = testUtility.GetPlayers()
# number of curses and victory cards
if len(self.player_names) > 2:
self.nV = 12
else:
self.nV = 8
self.nC = -10 + 10 * len(self.player_names)
# Refactored Get boxs
self.box = testUtility.GetBoxes(self.nV)
# refactored supplu order
self.supply_order = testUtility.SupplyOrder()
# Pick 10 cards from box to be in the supply.
self.boxlist = [k for k in self.box]
random.shuffle(self.boxlist)
self.random10 = self.boxlist[:10]
self.supply = defaultdict(list,
[(k, self.box[k]) for k in self.random10])
# The supply always has these cards
self.supply["Copper"] = [Dominion.Copper()
] * (60 - len(self.player_names) * 7)
self.supply["Silver"] = [Dominion.Silver()] * 40
self.supply["Gold"] = [Dominion.Gold()] * 30
self.supply["Estate"] = [Dominion.Estate()] * self.nV
self.supply["Duchy"] = [Dominion.Duchy()] * self.nV
self.supply["Province"] = [Dominion.Province()] * self.nV
self.supply["Curse"] = [Dominion.Curse()] * self.nC
# initialize the trash
self.trash = []
self.name = "Blueberry"
self.actions = 3
self.coins = 10
self.player = Dominion.Player('Annie')
self.player2 = Dominion.Player('Carla')
def getSupply(box, player_names, nV, nC):
"""
Returns a randomized supply for the current game.
Takes in arguments the current box object, supply order,
and the number of Victory Cards and Curses in play.
"""
#Pick 10 cards from box to be in the supply.
boxlist = [k for k in box]
random.shuffle(boxlist)
random10 = boxlist[:10]
supply = defaultdict(list, [(k, box[k]) for k in random10])
#The supply always has these cards
supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7)
supply["Silver"] = [Dominion.Silver()] * 40
supply["Gold"] = [Dominion.Gold()] * 30
supply["Estate"] = [Dominion.Estate()] * nV
supply["Duchy"] = [Dominion.Duchy()] * nV
supply["Province"] = [Dominion.Province()] * nV
supply["Curse"] = [Dominion.Curse()] * nC
return supply
def test_calcPoints(self):
# init data
self.dataSetUp()
# test before adding action cards
self.assertEqual(3, self.player.calcpoints()) # should be 3 from 3 estates
# add 2 provinces (6 points each)
self.player.deck += [Dominion.Province()] * 2
# test calcPoints
self.assertEqual(15, self.player.calcpoints())
# add 2 Duchies (3 points each)
self.player.deck += [Dominion.Duchy()] * 2
# test calcPoints
self.assertEqual(21, self.player.calcpoints())
# add 6 gardens (2 points each)
self.player.deck += [Dominion.Gardens()] * 6
# test calcPoints
self.assertEqual(33, self.player.calcpoints())
def test_draw(self):
# setup the player
# this test if none of the branches were hit
self.setUp()
self.player.deck = []
self.player.discard = []
self.player.hand = []
#check
self.assertEqual(0, len(self.player.deck))
self.assertEqual(0, len(self.player.discard))
self.assertEqual(0, len(self.player.hand))
self.player.draw(self.player.hand)
self.assertEqual(0, len(self.player.deck))
self.assertEqual(0, len(self.player.discard))
self.assertEqual(0, len(self.player.hand))
#new setup of user
self.setUp()
self.player.discard = []
#asset empty discard pile
self.assertEqual(0, len(self.player.discard))
# test scenario where only deck >0 0 in the draw function if statments is executed
self.assertNotEqual(0, len(self.player.deck))
# check if 5 cards are present in the deck
self.assertEqual(5, len(self.player.deck))
# check if player's hand already constains 5 cards
self.assertEqual(5, len(self.player.hand))
self.player.draw(self.player.discard)
# check if 1 card was removed from the deck
self.assertEqual(4, len(self.player.deck))
# check if 1 card was added to the discard pile
self.assertEqual(1, len(self.player.discard))
# check the branch where the dest == NONE
self.player.draw()
# check if 1 card was removed from the deck
self.assertEqual(3, len(self.player.deck))
# check if 1 card was added to the player's hand pile
self.assertEqual(6, len(self.player.hand))
# test scenario where only deck == 0 in the draw function if statments is executed
#setup the player again
self.setUp()
estateCard = Dominion.Estate()
duchyCard = Dominion.Duchy()
# add only 2 cards to the discard pile
self.player.discard = [estateCard, duchyCard]
#empty the deck
self.player.deck = []
drawnCard = self.player.draw()
# check if player's discard pile is empty
self.assertEqual(0, len(self.player.discard))
# check if player's deck has increased by 1
self.assertEqual(1, len(self.player.deck))
if drawnCard == estateCard:
self.assertEqual(estateCard, drawnCard)
elif drawnCard == duchyCard:
self.assertEqual(duchyCard, drawnCard)
else: #case where card drawn is none of the 2
self.fail()
6: ['Gold', 'Adventurer'],
8: ['Province']
}
#Pick 10 cards from box to be in the supply.
boxlist = [k for k in box]
random.shuffle(boxlist)
random10 = boxlist[:10]
supply = defaultdict(list, [(k, box[k]) for k in random10])
#The supply always has these cards
supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7)
supply["Silver"] = [Dominion.Silver()] * 40
supply["Gold"] = [Dominion.Gold()] * 30
supply["Estate"] = [Dominion.Estate()] * nV
supply["Duchy"] = [Dominion.Duchy()] * nV
supply["Province"] = [Dominion.Province()] * nV
supply["Curse"] = [Dominion.Curse()] * nC
#initialize the trash
trash = []
#Costruct the Player objects
players = []
for name in player_names:
if name[0] == "*":
players.append(Dominion.ComputerPlayer(name[1:]))
elif name[0] == "^":
players.append(Dominion.TablePlayer(name[1:]))
else:
players.append(Dominion.Player(name))
],
6: ['Gold', 'Adventurer'],
8: ['Province']
}
#Pick 10 cards from box to be in the supply.
boxlist = [k for k in box]
random.shuffle(boxlist)
random10 = boxlist[:10]
supply = defaultdict(list, [(k, box[k]) for k in random10])
#The supply always has these cards
supply["Copper"] = [Dominion.Copper()] * (60 - len(player_names) * 7)
supply["Silver"] = [Dominion.Silver()] * 40
supply["Gold"] = [Dominion.Gold()] * 30
supply["Estate"] = [Dominion.Duchy()] * nV
supply["Duchy"] = [Dominion.Duchy()] * nV
supply["Province"] = [Dominion.Province()] * nV
supply["Curse"] = [Dominion.Curse()] * nC
#initialize the trash
trash = []
players = testUtility.makePlayers(player_names)
#Play the game
turn = 0
while not Dominion.gameover(supply):
turn += 1
print("\r")
for value in supply_order:
def test_cardsummary(self):
#create the player
self.setUp()
# clear the deck
self.player.deck = []
# clear the hand
self.player.hand = []
summary = self.player.cardsummary()
# check case when there is a no card
self.assertEqual(0, summary["VICTORY POINTS"])
# check case when there is only 1 copper card in the stack
#add one copper card to the hand
self.player.hand = [Dominion.Copper()]
summary = self.player.cardsummary()
# no victory card therefore should only have 0 victory points
self.assertEqual(0, summary["VICTORY POINTS"])
# only 1 copper card so should have only 1 copper card shown in summary
self.assertEqual(1, summary["Copper"])
# check case where you have 2 copper cards and no victory cards
self.player.hand.append(Dominion.Copper())
summary = self.player.cardsummary()
# no victory card therefore should only have 0 victory points
self.assertEqual(0, summary["VICTORY POINTS"])
# 2 copper card so should show 2 copper card shown in summary
self.assertEqual(2, summary["Copper"])
# check case where you add 1 victory card
#add an estate card
self.player.hand.append(Dominion.Estate())
summary = self.player.cardsummary()
# no victory card therefore should only have 1 victory points
self.assertEqual(1, summary["VICTORY POINTS"])
# 2 copper card so should show 2 copper card shown in summary
self.assertEqual(1, summary["Estate"])
# 2 copper card so should show 2 copper card shown in summary
self.assertEqual(2, summary["Copper"])
# check case where you add 1 victory card
# add a duchy card to see if another type of victory card is checked
self.player.hand.append(Dominion.Duchy())
summary = self.player.cardsummary()
# no victory card therefore should only have 4 victory points
self.assertEqual(4, summary["VICTORY POINTS"])
# 1 estate card so should show 1 estate card shown in summary
self.assertEqual(1, summary["Estate"])
# 1 duchy card so should show 1 duchy card shown in summary
self.assertEqual(1, summary["Duchy"])
# 2 copper card so should show 2 copper card shown in summary
self.assertEqual(2, summary["Copper"])
# check case where you add another of the same card victory card
# add a duchy card to see if another type of victory card is checked
self.player.hand.append(Dominion.Duchy())
summary = self.player.cardsummary()
# no victory card therefore should only have 4 victory points
self.assertEqual(7, summary["VICTORY POINTS"])
# 1 estate card so should show 1 estate card shown in summary
self.assertEqual(1, summary["Estate"])
# 2 duchy cards so should show 2 duchy cards shown in summary
self.assertEqual(2, summary["Duchy"])
# 2 copper card so should show 2 copper card shown in summary
self.assertEqual(2, summary["Copper"])
