def test_deck_cards_amount(self):
cards = [
a2.Card(1, a2_support.CardColour.blue),
a2.Card(3, a2_support.CardColour.red),
a2.Card(2, a2_support.CardColour.green)
]
deck = a2.Deck(starting_cards=cards)
self.assertListEqual(deck.get_cards(), cards,
"starting_cards parameter should be used to populate deck")
self.assertEqual(deck.get_amount(), 3)
def test_player_has_won(self):
player = a2.Player("Test Player")
self.assertIs(player.has_won(), True)
player.get_deck().add_card(a2.Card(9, a2_support.CardColour.blue))
player.get_deck().add_card(a2.Card(8, a2_support.CardColour.red))
player.get_deck().add_card(a2.Card(7, a2_support.CardColour.black))
self.assertIs(player.has_won(), False, "Player.has_won should return False if the Player has cards")
def test_card_str(self):
card = a2.Card(90, a2_support.CardColour.red)
skip = a2.SkipCard(12, a2_support.CardColour.yellow)
reverse = a2.ReverseCard(3, a2_support.CardColour.green)
pickup2 = a2.Pickup2Card(45, a2_support.CardColour.blue)
pickup4 = a2.Pickup4Card(56, a2_support.CardColour.black)
self.assertEqual(str(card), 'Card(90, CardColour.red)',
'Card.__str__ does not return correctly')
self.assertEqual(repr(card), 'Card(90, CardColour.red)',
'Card.__repr__ does not return correctly')
self.assertEqual(str(skip), 'SkipCard(12, CardColour.yellow)',
'SkipCard.__str__ does not return correctly')
self.assertEqual(repr(skip), 'SkipCard(12, CardColour.yellow)',
'SkipCard.__repr__ does not return correctly')
self.assertEqual(str(reverse), 'ReverseCard(3, CardColour.green)',
'ReverseCard.__str__ does not return correctly')
self.assertEqual(repr(reverse), 'ReverseCard(3, CardColour.green)',
'ReverseCard.__repr__ does not return correctly')
self.assertEqual(str(pickup2), 'Pickup2Card(45, CardColour.blue)',
'Pickup2Card.__str__ does not return correctly')
self.assertEqual(repr(pickup2), 'Pickup2Card(45, CardColour.blue)',
'Pickup2Card.__repr__ does not return correctly')
self.assertEqual(str(pickup4), 'Pickup4Card(56, CardColour.black)',
'Pickup4Card.__str__ does not return correctly')
self.assertEqual(repr(pickup4), 'Pickup4Card(56, CardColour.black)',
'Pickup4Card.__repr__ does not return correctly')
def test_deck_shuffle(self):
cards = [
a2.Card(1, a2_support.CardColour.blue),
a2.Card(3, a2_support.CardColour.red),
a2.Card(2, a2_support.CardColour.green)
]
deck = a2.Deck(starting_cards=cards.copy())
found_different = False
for _ in range(30):
deck.shuffle()
if deck.get_cards() != cards:
found_different = True
break
self.assertIs(found_different, True, "Deck.shuffle should randomise order")
def test_deck_add_cards(self):
cards1 = [
a2.Card(1, a2_support.CardColour.blue),
a2.Card(3, a2_support.CardColour.red)
]
deck = a2.Deck()
deck.add_cards(cards1)
self.assertListEqual(deck.get_cards(), cards1, "Deck's cards are invalid after adding a list of cards")
cards2 = [
a2.Card(4, a2_support.CardColour.yellow),
a2.Card(6, a2_support.CardColour.yellow)
]
deck.add_cards(cards2)
self.assertListEqual(deck.get_cards(), cards1 + cards2, "Deck's cards are invalid after adding a second list of cards")
def loadGame(self):
deck = [
a2.Card(1, a2_support.CardColour.red),
a2.Card(2, a2_support.CardColour.blue),
a2.Card(3, a2_support.CardColour.green),
a2.Card(4, a2_support.CardColour.yellow),
a2.Card(5, a2_support.CardColour.red),
a2.Card(6, a2_support.CardColour.blue),
a2.Card(7, a2_support.CardColour.blue),
]
self._deck = a2.Deck(starting_cards=deck)
self._players = [
a2.HumanPlayer("Anna Truffet"),
a2.ComputerPlayer("Ashleigh Richardson"),
a2.HumanPlayer("Benjamin Martin"),
a2.ComputerPlayer("Brae Webb"),
a2.HumanPlayer("Harry Keightly"),
a2.ComputerPlayer("Henry O'Brien"),
a2.HumanPlayer("Joshua Arnold"),
a2.ComputerPlayer("Justin Luong"),
a2.HumanPlayer("Luis Woodrow"),
a2.ComputerPlayer("Mike Pham"),
a2.HumanPlayer("Rudi Scarpa"),
a2.ComputerPlayer("Sam Eadie"),
a2.HumanPlayer("Steven Summers"),
a2.ComputerPlayer("Wilson Kong"),
]
self._game = a2_support.UnoGame(self._deck, self._players)
def test_card_setters(self):
card = a2.Card(23, a2_support.CardColour.green)
self.assertIsNone(card.set_number(42), "Card.set_number returns value")
self.assertEqual(card.get_number(), 42,
"Card.set_number does not update value")
self.assertIsNone(card.set_colour(a2_support.CardColour.yellow),
"Card.set_colour returns value")
self.assertEqual(card.get_colour(), a2_support.CardColour.yellow,
"Card.set_colour does not update value")
def test_deck_constructor(self):
deck = a2.Deck()
self.assertEqual(deck.get_cards(), [],
"A Deck with no starting cards should be empty")
deck = a2.Deck(starting_cards=None)
self.assertEqual(deck.get_cards(), [],
"A Deck with no starting cards should be empty")
deck1 = a2.Deck()
deck2 = a2.Deck()
card = a2.Card(1, a2_support.CardColour.blue)
deck1.add_card(card)
self.assertEqual(deck2.get_cards(), [], "List should not be used for default value for starting_cards (should be None)")
def test_play_card(self):
self.loadGame()
self.assertEqual(self._players[0], self._game.get_turns().current(),
"Game should start with first player")
skip_card = a2.Card(21, a2_support.CardColour.blue)
skip_card.play(self._players[0], self._game)
# play should have no effect
self.assertEqual(self._players[0].get_name(),
self._game.get_turns().current().get_name(),
"Playing Card should change the player")
self.assertEqual(self._game.get_turns().peak().get_deck().get_amount(), 0,
"Playing Card should change player's deck")
def test_deck_top(self):
cards = [
a2.Card(1, a2_support.CardColour.blue),
a2.Card(3, a2_support.CardColour.red),
a2.Card(2, a2_support.CardColour.green),
a2.Card(4, a2_support.CardColour.yellow),
a2.Card(6, a2_support.CardColour.yellow),
a2.Card(10, a2_support.CardColour.blue)
]
deck = a2.Deck(starting_cards=cards.copy())
self.assertEqual(cards[-1], deck.top(), "Deck.top returns wrong card")
deck.pick()
def test_player_pick_card(self):
deck = a2.Deck()
deck.add_cards([
a2.Card(1, a2_support.CardColour.blue),
a2.Card(3, a2_support.CardColour.red),
a2.Card(2, a2_support.CardColour.green),
a2.Card(4, a2_support.CardColour.yellow),
a2.Card(6, a2_support.CardColour.yellow),
a2.Card(10, a2_support.CardColour.blue)
])
with self.assertRaises(NotImplementedError):
a2.Player("Test Player").pick_card(deck)
player = a2.HumanPlayer("Test Player")
player.get_deck().add_cards(deck.get_cards().copy())
self.assertIsNone(player.pick_card(deck), 'HumanPlayer.pick_card should return None')
def test_deck_add_card(self):
cards = [
a2.Card(1, a2_support.CardColour.blue),
a2.Card(3, a2_support.CardColour.red),
a2.Card(2, a2_support.CardColour.green),
a2.Card(4, a2_support.CardColour.yellow),
a2.Card(6, a2_support.CardColour.yellow),
a2.Card(10, a2_support.CardColour.blue)
]
deck = a2.Deck()
deck.add_card(cards[0])
deck.add_card(cards[1])
deck.add_card(cards[2])
deck.add_card(cards[3])
deck.add_card(cards[4])
deck.add_card(cards[5])
self.assertListEqual(deck.get_cards(), cards, "Deck.get_cards returns incorrectly")
def test_deck_pick(self):
cards = [
a2.Card(1, a2_support.CardColour.blue),
a2.Card(3, a2_support.CardColour.red),
a2.Card(2, a2_support.CardColour.green),
a2.Card(4, a2_support.CardColour.yellow),
a2.Card(6, a2_support.CardColour.yellow),
a2.Card(10, a2_support.CardColour.blue)
]
deck = a2.Deck(starting_cards=cards)
self.assertListEqual(cards[-1:], deck.pick())
expected_cards = cards[-3:]
actual_cards = deck.pick(amount=3)
self.assertEqual(len(expected_cards), len(actual_cards),
"Deck.pick returns incorrect amount of cards")
for card in actual_cards:
self.assertIn(card, expected_cards,
"Deck.pick returns unexpected card")
def test_player_pick_card_auto(self):
deck = a2.Deck()
deck.add_cards([
a2.Card(1, a2_support.CardColour.blue),
a2.Card(3, a2_support.CardColour.red),
a2.Card(2, a2_support.CardColour.green),
a2.Card(4, a2_support.CardColour.yellow),
a2.Card(6, a2_support.CardColour.yellow),
a2.Card(10, a2_support.CardColour.blue)
])
player = a2.ComputerPlayer("Test Player")
player.get_deck().add_card(a2.Card(6, a2_support.CardColour.yellow))
picked = player.pick_card(deck)
self.assertIsNone(
picked,
"ComputerPlayer.pick_card should return None if no card can be played"
)
cards = [
a2.Card(10, a2_support.CardColour.yellow),
a2.Card(3, a2_support.CardColour.red),
a2.Card(2, a2_support.CardColour.green),
a2.Card(4, a2_support.CardColour.blue),
a2.Card(5, a2_support.CardColour.yellow),
]
player.get_deck().add_cards(cards)
picked = player.pick_card(deck)
self.assertIsInstance(
picked, a2.Card,
"ComputerPlayer.pick_card should return an instance of Card (or a subclass) if it is possible to play a card"
)
def test_card_getters(self):
card = a2.Card(23, a2_support.CardColour.red)
self.assertEqual(card.get_number(), 23,
"Card.get_number returns incorrect value")
self.assertEqual(card.get_colour(), a2_support.CardColour.red,
"Card.get_colour returns incorrect value")
