def test_quads_to_quads_comparison(self):
player = Player("player", ManualActionCollector())
player2 = Player("Player2", ManualActionCollector())
suit = Suit.DIAMONDS
suit1 = Suit.CLUBS
hand1 = [
Card(Number.THREE, suit1),
Card(Number.THREE, Suit.HEARTS),
Card(Number.THREE, suit),
Card(Number.THREE, Suit.SPADES),
Card(Number.KING, suit1)
]
hand2 = [
Card(Number.TWO, suit1),
Card(Number.TWO, Suit.HEARTS),
Card(Number.TWO, suit),
Card(Number.TWO, Suit.SPADES),
Card(Number.KING, suit)
]
round_result = RoundResult(
[HandResult(hand1, player),
HandResult(hand2, player2)])
winning_hand = round_result.find_winning_hands()[0].cards
self.assertTrue(set(hand1).issubset(winning_hand))
def test_high_card_pair_comparison(self):
player = Player("player", ManualActionCollector())
player2 = Player("Player2", ManualActionCollector())
suit = Suit.DIAMONDS
suit1 = Suit.CLUBS
hand1 = [
Card(Number.TWO, suit),
Card(Number.TWO, suit1),
Card(Number.THREE, suit),
Card(Number.FOUR, suit),
Card(Number.FIVE, suit1)
]
hand2 = [
Card(Number.ACE, suit),
Card(Number.KING, suit),
Card(Number.QUEEN, suit),
Card(Number.JACK, suit),
Card(Number.NINE, suit1)
]
round_result = RoundResult(
[HandResult(hand1, player),
HandResult(hand2, player2)])
winning_hand = round_result.find_winning_hands()[0].cards
self.assertTrue(set(hand1).issubset(winning_hand))
def test_sort(self):
hand = [
Card('KING', 'SPADES'),
Card('QUEEN', 'HEARTS'),
Card('JACK', 'HEARTS'),
Card('ACE', 'DIAMONDS'),
Card(10, 'DIAMONDS'),
Card('QUEEN', 'DIAMONDS'),
Card('JACK', 'SPADES')
]
self.print_hand(hand)
hand = sorted(
hand
) #, key=lambda card: card.suit) a lambda is not needed now that __lt__() has been implemented
print()
self.print_hand(hand)
def __init__(self):
self.cards_storage = []
db_file_path = os.path.join("data", "cards - main cards.csv")
with open(db_file_path) as cards_db:
cards_db_reader = csv.reader(cards_db, delimiter=",")
header_line_skipped = False
for row in cards_db_reader:
if not header_line_skipped:
header_line_skipped = True
continue
card = Card(row[1], row[2], row[3], row[4], row[5],
CardsStorage.parseLevel(row[6]), row[7],
CardsStorage.parseCoinType(row[8]))
self.cards_storage.append(card)
def test_cards_storage(self):
self.assertEqual(
self.cards.getCard(6),
Card(white_cost=2,
green_cost=2,
level=CardLevel.ONE,
discount=CoinTypes.BLACK))
self.assertEqual(
self.cards.getCard(21),
Card(blue_cost=1,
red_cost=2,
black_cost=2,
level=CardLevel.ONE,
discount=CoinTypes.GREEN))
self.assertEqual(
self.cards.getCard(36),
Card(white_cost=1,
blue_cost=1,
red_cost=1,
black_cost=1,
level=CardLevel.ONE,
discount=CoinTypes.GREEN))
self.assertEqual(
self.cards.getCard(41),
Card(blue_cost=5,
level=CardLevel.TWO,
points=2,
discount=CoinTypes.BLUE))
self.assertEqual(
self.cards.getCard(70),
Card(red_cost=6,
level=CardLevel.TWO,
points=3,
discount=CoinTypes.RED))
self.assertEqual(
self.cards.getCard(90),
Card(white_cost=3,
black_cost=7,
level=CardLevel.THREE,
points=5,
discount=CoinTypes.WHITE))
def __init__(self):
self.unused = Deck((Card(n, s) for n, s in itertools.product(
constants.STANDARD_CARDS, constants.STANDARD_SUITS)))
self.discard, self.active = Deck(), Deck()
self.Reset()
def _create_suit(self, suit):
for number in Number:
self.cards.append(Card(number, suit))
random.seed(5)
def get_cards(deck, number):
return [deck.deal() for i in range(number)]
if __name__ == '__main__':
d = Deck(jokers=2)
print(unicode(d))
#Shuffle the deck again
d.shuffle()
print("\nPost shuffling again:")
print(unicode(d))
#Get a hand of cards from the deck
print('\nDealt Hand:')
hand = get_cards(d, 5)
for c in hand:
print(unicode(c))
#Make sure one of the cards dealt is no longer in the deck
check_card = hand[1]
print('\n{} in deck? {}'.format(unicode(check_card),\
d.contains(check_card)))
#Check if a card is still in the deck
print('\nJoker in deck? {}'.format(d.contains(Card('Wild', 'Joker'))))
def test_is_sorted(self):
hand = [
Card('KING', 'SPADES'),
Card('QUEEN', 'HEARTS'),
Card('JACK', 'HEARTS'),
Card('ACE', 'DIAMONDS'),
Card(10, 'DIAMONDS'),
Card('QUEEN', 'DIAMONDS'),
Card('JACK', 'SPADES')
]
#self.assertFalse(self.is_sorted(hand))
hand = [
Card(10, 'DIAMONDS'),
Card('JACK', 'HEARTS'),
Card('JACK', 'SPADES'),
Card('QUEEN', 'DIAMONDS'),
Card('QUEEN', 'HEARTS'),
Card('KING', 'SPADES'),
Card('ACE', 'DIAMONDS')
]
self.assertTrue(self.is_sorted(hand))
def test_equality_jokers(self):
x = Card('Wild', 'Joker')
y = Card('Wild', 'Joker')
self.assertEqual(x, y)
def _get_deck(self):
result = []
for rank in self.ranks:
for suit in self.suits:
result.append(Card(rank, suit))
return result
import pytest
from cards.card import Card
@pytest.mark.parametrize("card,expected",
[(Card('hearts', 2), "2 of Hearts"),
(Card('hearts', 11), "Jack of Hearts"),
(Card('hearts', 12), "Quin of Hearts"),
(Card('hearts', 13), "King of Hearts"),
(Card('hearts', 14), "Ace of Hearts")])
def cards_names_test(card, expected):
assert card.display_name == expected
assert card.__str__() == expected
assert card.__repr__() == expected
def test_is_legit_with_legit_5_card_hands(self):
hand = [
Card(2, 'DIAMONDS'),
Card(3, 'DIAMONDS'),
Card(4, 'DIAMONDS'),
Card(4, 'SPADES'),
Card(5, 'DIAMONDS')
]
self.assertFalse(Cards.is_legit_hand(hand))
self.assertFalse(
Cards.is_legit_hand([
Card(2, 'DIAMONDS'),
Card(3, 'DIAMONDS'),
Card(4, 'DIAMONDS'),
Card(4, 'DIAMONDS'),
Card(5, 'DIAMONDS')
]))
self.assertFalse(
Cards.is_legit_hand([
Card(2, 'SPADES'),
Card(3, 'DIAMONDS'),
Card(4, 'DIAMONDS'),
Card(4, 'DIAMONDS'),
Card(5, 'DIAMONDS')
]))
self.assertFalse(
Cards.is_legit_hand([
Card(2, 'DIAMONDS'),
Card(3, 'DIAMONDS'),
Card(4, 'DIAMONDS'),
Card(4, 'DIAMONDS'),
Card('KING', 'DIAMONDS')
]))
#TODO: repeated cards (should fail)
self.assertFalse(
Cards.is_legit_hand([
Card(2, 'DIAMONDS'),
Card(3, 'DIAMONDS'),
Card(2, 'DIAMONDS'),
Card(4, 'DIAMONDS'),
Card('KING', 'DIAMONDS')
]))
def test_contains_duplidate(self):
self.assertEqual(
False,
Cards.contains_duplicate([
Card(2, 'DIAMONDS'),
Card(3, 'DIAMONDS'),
Card(8, 'DIAMONDS'),
Card(4, 'DIAMONDS'),
Card(5, 'DIAMONDS')
]))
self.assertEqual(
True,
Cards.contains_duplicate([
Card(2, 'DIAMONDS'),
Card(3, 'DIAMONDS'),
Card(8, 'DIAMONDS'),
Card(2, 'DIAMONDS'),
Card(5, 'DIAMONDS')
]))
self.assertEqual(
True,
Cards.contains_duplicate([
Card(2, 'DIAMONDS'),
Card(3, 'DIAMONDS'),
Card(8, 'DIAMONDS'),
Card(2, 'DIAMONDS'),
Card(2, 'DIAMONDS')
]))
self.assertEqual(
True,
Cards.contains_duplicate([
Card(2, 'DIAMONDS'),
Card(3, 'DIAMONDS'),
Card(2, 'DIAMONDS'),
Card(2, 'DIAMONDS'),
Card(3, 'DIAMONDS')
]))
def test_construction(self):
six_oF_diamonds = Card(6, "DIAMONDS")
self.assertEqual(six_oF_diamonds.__str__(), '6 DIAMONDS')
def test_contains_three_of_a_kind(self):
self.assertFalse(
Cards.contains_three_of_a_kind([
Card(10, 'HEARTS'),
Card('JACK', 'DIAMONDS'),
Card('ACE', 'DIAMONDS'),
Card('KING', 'DIAMONDS'),
Card('QUEEN', 'DIAMONDS')
]))
self.assertFalse(
Cards.contains_three_of_a_kind([
Card(10, 'HEARTS'),
Card('JACK', 'DIAMONDS'),
Card('ACE', 'DIAMONDS'),
Card('KING', 'DIAMONDS'),
Card('QUEEN', 'HEARTS')
]))
self.assertTrue(
Cards.contains_three_of_a_kind([
Card(4, 'DIAMONDS'),
Card(4, 'CLUBS'),
Card(5, 'HEARTS'),
Card(5, 'CLUBS'),
Card(5, 'SPADES')
]))
def test_is_straight_flush(self):
self.assertFalse(
Cards.is_straight_flush([
Card(10, 'HEARTS'),
Card('JACK', 'DIAMONDS'),
Card('ACE', 'DIAMONDS'),
Card('KING', 'DIAMONDS'),
Card('QUEEN', 'DIAMONDS')
]))
self.assertFalse(
Cards.is_straight_flush([
Card(5, 'DIAMONDS'),
Card(7, 'SPADES'),
Card(3, 'DIAMONDS'),
Card(6, 'DIAMONDS'),
Card(4, 'DIAMONDS')
]))
self.assertTrue(
Cards.is_straight_flush([
Card(5, 'DIAMONDS'),
Card(7, 'DIAMONDS'),
Card(3, 'DIAMONDS'),
Card(6, 'DIAMONDS'),
Card(4, 'DIAMONDS')
]))
self.assertTrue(
Cards.is_straight_flush([
Card(5, 'HEARTS'),
Card(7, 'HEARTS'),
Card(3, 'HEARTS'),
Card(6, 'HEARTS'),
Card(4, 'HEARTS')
]))
self.assertTrue(
Cards.is_straight_flush([
Card(5, 'SPADES'),
Card(7, 'SPADES'),
Card(3, 'SPADES'),
Card(6, 'SPADES'),
Card(4, 'SPADES')
]))
self.assertTrue(
Cards.is_straight_flush([
Card(5, 'CLUBS'),
Card(7, 'CLUBS'),
Card(3, 'CLUBS'),
Card(6, 'CLUBS'),
Card(4, 'CLUBS')
]))
self.assertTrue(
Cards.is_straight_flush([
Card(10, 'DIAMONDS'),
Card('JACK', 'DIAMONDS'),
Card('ACE', 'DIAMONDS'),
Card('KING', 'DIAMONDS'),
Card('QUEEN', 'DIAMONDS')
]))
def test_is_flush(self):
self.assertFalse(
Cards.is_flush([
Card(1, 'HEARTS'),
Card(3, 'DIAMONDS'),
Card(4, 'DIAMONDS'),
Card(4, 'DIAMONDS'),
Card(5, 'DIAMONDS')
]))
self.assertFalse(
Cards.is_flush([
Card(1, 'DIAMONDS'),
Card(3, 'DIAMONDS'),
Card(4, 'SPADES'),
Card(4, 'DIAMONDS'),
Card(5, 'DIAMONDS')
]))
self.assertFalse(
Cards.is_flush([
Card(1, 'DIAMONDS'),
Card(3, 'DIAMONDS'),
Card(4, 'SPADES'),
Card(4, 'DIAMONDS'),
Card(5, 'DIAMONDS')
]))
#self.assertFalse(Cards.is_flush([Card(1, 'DIAMONDS'), Card(3, 'DIAMONDS'), Card(4, 'DIAMONDS'), Card(5, 'DIAMONDS'), Card(5, 'DIAMONDS')])) will be correct once we check for duplicates
#some valid flush hands
self.assertTrue(
Cards.is_flush([
Card(2, 'DIAMONDS'),
Card(3, 'DIAMONDS'),
Card(8, 'DIAMONDS'),
Card(4, 'DIAMONDS'),
Card(5, 'DIAMONDS')
]))
#randomly generate some valid flushes
for suit in Cards.SUITS:
#hand = Cards.random_cards(Cards.RANKS, [suit], 5)
#for card in hand:
# print(card)
#self.assertTrue(Cards.is_flush(hand))
self.assertTrue(
Cards.is_flush(Cards.random_cards(Cards.RANKS, [suit], 5)))
def setUp(self):
self.cards = CardsStorage()
self.level1_stack = CardsStack(1, self.cards.cards_storage)
self.level2_stack = CardsStack(2, self.cards.cards_storage)
self.level3_stack = CardsStack(3, self.cards.cards_storage)
self.level1_cumulative_cost = 33
self.level2_cumulative_cost = 41
self.level3_cumulative_cost = 43
self.level1_cards_count = 40
self.level2_cards_count = 30
self.level3_cards_count = 20
self.cards_db = [
Card(blue_cost=3, level=CardLevel.ONE, discount=CoinTypes.WHITE),
Card(red_cost=3, level=CardLevel.ONE, discount=CoinTypes.BLUE),
Card(white_cost=3, level=CardLevel.ONE, discount=CoinTypes.WHITE),
Card(green_cost=3, level=CardLevel.ONE, discount=CoinTypes.BLUE),
Card(green_cost=3, level=CardLevel.ONE, discount=CoinTypes.GREEN),
Card(red_cost=3, level=CardLevel.ONE, discount=CoinTypes.RED),
Card(black_cost=3, level=CardLevel.ONE, discount=CoinTypes.BLACK),
Card(black_cost=3, level=CardLevel.ONE, discount=CoinTypes.GREEN),
Card(blue_cost=2,
green_cost=2,
level=CardLevel.TWO,
discount=CoinTypes.WHITE),
Card(white_cost=2,
green_cost=2,
level=CardLevel.TWO,
discount=CoinTypes.BLUE),
Card(red_cost=2,
black_cost=2,
level=CardLevel.TWO,
discount=CoinTypes.GREEN),
Card(white_cost=2,
blue_cost=2,
level=CardLevel.TWO,
discount=CoinTypes.BLACK),
Card(blue_cost=2,
red_cost=2,
level=CardLevel.TWO,
discount=CoinTypes.RED),
Card(white_cost=2,
red_cost=2,
level=CardLevel.TWO,
discount=CoinTypes.WHITE),
Card(green_cost=2,
black_cost=2,
level=CardLevel.TWO,
discount=CoinTypes.GREEN),
Card(white_cost=2,
black_cost=2,
level=CardLevel.TWO,
discount=CoinTypes.BLACK),
Card(white_cost=2,
blue_cost=4,
level=CardLevel.THREE,
discount=CoinTypes.WHITE),
Card(white_cost=2,
green_cost=4,
level=CardLevel.THREE,
discount=CoinTypes.BLUE),
Card(white_cost=2,
red_cost=4,
level=CardLevel.THREE,
discount=CoinTypes.GREEN),
Card(white_cost=2,
black_cost=4,
level=CardLevel.THREE,
discount=CoinTypes.RED),
Card(blue_cost=2,
green_cost=4,
level=CardLevel.THREE,
discount=CoinTypes.WHITE),
Card(blue_cost=2,
red_cost=4,
level=CardLevel.THREE,
discount=CoinTypes.BLACK),
Card(blue_cost=2,
black_cost=4,
level=CardLevel.THREE,
discount=CoinTypes.BLUE),
Card(red_cost=2,
green_cost=4,
level=CardLevel.THREE,
discount=CoinTypes.GREEN)
]
self.cards_stack_lvl1 = CardsStack(1, self.cards_db)
self.cards_stack_lvl2 = CardsStack(2, self.cards_db)
self.cards_stack_lvl3 = CardsStack(3, self.cards_db)
def test_init_jokers(self):
d = Deck(jokers=2)
self.assertEqual(len(d.cards), 54)
self.assertTrue(d.contains(Card('Wild', 'Joker')))
def setUp(self):
self.cards_db = [Card(blue_cost=3, level=CardLevel.ONE, discount=CoinTypes.WHITE), Card(red_cost=3, level=CardLevel.ONE, discount=CoinTypes.BLUE),
Card(white_cost=3, level=CardLevel.ONE, discount=CoinTypes.WHITE), Card(green_cost=3, level=CardLevel.ONE, discount=CoinTypes.BLUE),
Card(green_cost=3, level=CardLevel.ONE, discount=CoinTypes.GREEN), Card(red_cost=3, level=CardLevel.ONE, discount=CoinTypes.RED),
Card(black_cost=3, level=CardLevel.ONE, discount=CoinTypes.BLACK), Card(black_cost=3, level=CardLevel.ONE, discount=CoinTypes.GREEN),
Card(blue_cost=2, green_cost=2, level=CardLevel.TWO, discount=CoinTypes.WHITE), Card(white_cost=2, green_cost=2, level=CardLevel.TWO, discount=CoinTypes.BLUE),
Card(red_cost=2, black_cost=2, level=CardLevel.TWO, discount=CoinTypes.GREEN), Card(white_cost=2, blue_cost=2, level=CardLevel.TWO, discount=CoinTypes.BLACK),
Card(blue_cost=2, red_cost=2, level=CardLevel.TWO, discount=CoinTypes.RED), Card(white_cost=2, red_cost=2, level=CardLevel.TWO, discount=CoinTypes.WHITE),
Card(green_cost=2, black_cost=2, level=CardLevel.TWO, discount=CoinTypes.GREEN), Card(white_cost=2, black_cost=2, level=CardLevel.TWO, discount=CoinTypes.BLACK),
Card(white_cost=2, blue_cost=4, level=CardLevel.THREE, discount=CoinTypes.WHITE), Card(white_cost=2, green_cost=4, level=CardLevel.THREE, discount=CoinTypes.BLUE),
Card(white_cost=2, red_cost=4, level=CardLevel.THREE, discount=CoinTypes.GREEN), Card(white_cost=2, black_cost=4, level=CardLevel.THREE, discount=CoinTypes.RED),
Card(blue_cost=2, green_cost=4, level=CardLevel.THREE, discount=CoinTypes.WHITE), Card(blue_cost=2, red_cost=4, level=CardLevel.THREE, discount=CoinTypes.BLACK),
Card(blue_cost=2, black_cost=4, level=CardLevel.THREE, discount=CoinTypes.BLUE), Card(red_cost=2, green_cost=4, level=CardLevel.THREE, discount=CoinTypes.GREEN)]
def test_count_duplicates_sort(self):
self.assertEqual(
0,
Cards.count_duplicates_sort([
Card(2, 'DIAMONDS'),
Card(3, 'DIAMONDS'),
Card(8, 'DIAMONDS'),
Card(4, 'DIAMONDS'),
Card(5, 'DIAMONDS')
]))
self.assertEqual(
1,
Cards.count_duplicates_sort([
Card(2, 'DIAMONDS'),
Card(3, 'DIAMONDS'),
Card(8, 'DIAMONDS'),
Card(2, 'DIAMONDS'),
Card(5, 'DIAMONDS')
]))
self.assertEqual(
2,
Cards.count_duplicates_sort([
Card(2, 'DIAMONDS'),
Card(3, 'DIAMONDS'),
Card(8, 'DIAMONDS'),
Card(2, 'DIAMONDS'),
Card(2, 'DIAMONDS')
]))
self.assertEqual(
3,
Cards.count_duplicates_sort([
Card(2, 'DIAMONDS'),
Card(3, 'DIAMONDS'),
Card(2, 'DIAMONDS'),
Card(2, 'DIAMONDS'),
Card(3, 'DIAMONDS')
]))
def __init__(self, suits: List[str], values: List[int]):
self.cards = deque(
[Card(suit, value) for suit, value in product(suits, values)])
import pytest
from cards.card import Card
from games.wargame.main import WarGame
from games.wargame.players import Player
card_1 = Card('A', 3)
card_2 = Card('B', 6)
card_3 = Card('B', 6)
@pytest.fixture()
def game():
return WarGame([Player(), Player()])
@pytest.mark.parametrize("cards,expected", [([card_1, card_2], card_2),
([card_1, card_1], None),
([card_3, card_3], None)])
def compare_cards_test(cards, expected, game):
bigger_card = game.compare_cards(*cards)
assert bigger_card == expected
def deal_all_cards_test(game):
amount_of_cards_per_player = len(game.deck.cards) / len(game.players)
game.deal_cards()
assert not game.deck.cards
def test_init(self):
d = Deck(jokers=False)
self.assertEqual(len(d.cards), 52)
self.assertFalse(d.contains(Card('Wild', 'Joker')))
def _from_hours_to_cards(self, tracked_hours):
cards = []
for hours in tracked_hours:
cards.append(Card(hours))
return cards
def test_deck_contains_ace_of_hearts(self):
d = Deck()
c = Card('Hearts', 'Ace')
self.assertTrue(d.contains(c))
def _change_contract_for_hourly_to_fixed(self, staff):
employee = staff.employees()[1] # Getting an hourly
employee.change_contract(Fixed(2500), FixedCalculator())
employee.add_card(Card(10))
def test_eq(self):
card1 = Card('ACE', 'SPADES')
card2 = Card('ACE', 'SPADES')
self.assertFalse(card1 is card2)
self.assertTrue(card1 == card2)
self.assertTrue(card1.__eq__(card2))
def __init__(self):
CardStack.__init__(self)
self.cards = [Card(i, j) for i in Card.suit_names
for j in Card.value_names]