def test_bigger_flush(self):
for i in range(num_tests):
cards_a = Stack()
cards_b = Stack()
suit = random.choice(SUITS[:2])
values = random.sample(VALUES, 5)
for value in values:
cards_a.add(Card(value, suit))
if get_cards_type(cards_a) == STRAIGHT_FLUSH:
continue
if suit == "Hearts":
suit = "Spades"
else:
suit = random.choice(SUITS[(SUITS.index(suit) + 1):])
values = random.sample(VALUES, 5)
for value in values:
cards_b.add(Card(value, suit))
if get_cards_type(cards_b) == STRAIGHT_FLUSH:
continue
self.assertTrue(are_cards_bigger(cards_a, cards_b))
def test_flush(self):
for i in range(num_tests):
cards = Stack()
suit = random.choice(SUITS)
for value in random.sample(VALUES, 5):
cards.add(Card(value, suit))
if get_cards_type(cards) == STRAIGHT_FLUSH:
continue
self.assertEqual(get_cards_type(cards), FLUSH)
def test_diff_suit_dragon(self):
for i in range(num_tests):
cards = Stack(cards=[Card(VALUES[0], SUITS[0]), Card(VALUES[1], SUITS[1])])
for value in VALUES[2:]:
cards.add(Card(value, random.choice(SUITS)))
self.assertEqual(get_cards_type(cards), DRAGON)
def test_invalid(self):
cards = Stack(cards=[Card("3", SUITS[0]), Card("8", SUITS[1])])
self.assertEqual(get_cards_type(cards), -1)
cards = Stack(cards=[Card("3", SUITS[0]), Card("4", SUITS[0]), Card("8", SUITS[1])])
self.assertEqual(get_cards_type(cards), -1)
cards = Stack(cards=[Card("3", SUITS[0]), Card("4", SUITS[0]), Card("5", SUITS[0]), Card("8", SUITS[1])])
self.assertEqual(get_cards_type(cards), -1)
cards = Stack(cards=[Card("3", SUITS[0]), Card("4", SUITS[0]), Card("5", SUITS[0]), Card("6", SUITS[0]),
Card("8", SUITS[1])])
self.assertEqual(get_cards_type(cards), -1)
cards = Stack(cards=[Card("3", SUITS[0]), Card("4", SUITS[0]), Card("5", SUITS[0]), Card("6", SUITS[0]),
Card("7", SUITS[0]), Card("8", SUITS[0])])
self.assertEqual(get_cards_type(cards), -1)
def test_same_suit_dragon(self):
for i in range(num_tests):
cards = Stack()
suit = random.choice(SUITS)
for value in VALUES:
cards.add(Card(value, suit))
self.assertEqual(get_cards_type(cards), SAME_SUIT_DRAGON)
def test_pair(self):
for i in range(num_tests):
cards = Stack()
value = random.choice(VALUES)
for suit in random.sample(SUITS, 2):
cards.add(Card(value, suit))
self.assertEqual(get_cards_type(cards), PAIR)
def test_three_of_a_kind(self):
for i in range(num_tests):
cards = Stack()
value = random.choice(VALUES)
for suit in random.sample(SUITS, 3):
cards.add(Card(value, suit))
self.assertEqual(get_cards_type(cards), THREE_OF_A_KIND)
def test_straight_flush(self):
for i in range(num_tests):
suit = random.choice(SUITS)
cards = Stack(cards=[Card("Ace", suit), Card("2", suit), Card("3", suit), Card("4", suit), Card("5", suit)])
self.assertEqual(get_cards_type(cards), STRAIGHT_FLUSH)
cards = Stack(cards=[Card("2", suit), Card("3", suit), Card("4", suit), Card("5", suit), Card("6", suit)])
self.assertEqual(get_cards_type(cards), STRAIGHT_FLUSH)
cards = Stack(cards=[Card("Jack", suit), Card("Queen", suit), Card("King", suit), Card("Ace", suit),
Card("2", suit)])
self.assertEqual(get_cards_type(cards), STRAIGHT_FLUSH)
cards = Stack()
start_index = random.randint(1, 8)
for index in range(start_index, start_index + 5):
cards.add(Card(VALUES[index], suit))
self.assertEqual(get_cards_type(cards), STRAIGHT_FLUSH)
def test_straight(self):
for i in range(num_tests):
cards = Stack(cards=[Card("Ace", SUITS[0]), Card("2", SUITS[1]), Card("3", random.choice(SUITS)),
Card("4", random.choice(SUITS)), Card("5", random.choice(SUITS))])
self.assertEqual(get_cards_type(cards), STRAIGHT)
cards = Stack(cards=[Card("2", SUITS[0]), Card("3", SUITS[1]), Card("4", random.choice(SUITS)),
Card("5", random.choice(SUITS)), Card("6", random.choice(SUITS))])
self.assertEqual(get_cards_type(cards), STRAIGHT)
cards = Stack(cards=[Card("Jack", SUITS[0]), Card("Queen", SUITS[1]), Card("King", random.choice(SUITS)),
Card("Ace", random.choice(SUITS)), Card("2", random.choice(SUITS))])
self.assertEqual(get_cards_type(cards), STRAIGHT)
cards = Stack()
start_index = random.randint(1, 8)
cards.add([Card(VALUES[start_index], SUITS[0]), Card(VALUES[start_index + 1], SUITS[1])])
for index in range(start_index + 2, start_index + 5):
cards.add(Card(VALUES[index], random.choice(SUITS)))
self.assertEqual(get_cards_type(cards), STRAIGHT)
def test_four_of_a_kind(self):
for i in range(num_tests):
cards = Stack()
values = list(VALUES)
four_value = random.choice(values)
values.remove(four_value)
extra_value = random.choice(values)
for suit in SUITS:
cards.add(Card(four_value, suit))
cards.add(Card(extra_value, random.choice(SUITS)))
self.assertEqual(get_cards_type(cards), FOUR_OF_A_KIND)
def test_full_house(self):
for i in range(num_tests):
cards = Stack()
values = list(VALUES)
three_value = random.choice(values)
values.remove(three_value)
two_value = random.choice(values)
for suit in random.sample(SUITS, 3):
cards.add(Card(three_value, suit))
for suit in random.sample(SUITS, 2):
cards.add(Card(two_value, suit, ))
self.assertEqual(get_cards_type(cards), FULL_HOUSE)
def use_selected_cards(bot, player_tele_id, group_tele_id, message_id, job_queue):
install_lang(player_tele_id)
valid = True
bigger = True
session = scoped_session(session_factory)
s = session()
game, player = s.query(Game, Player). \
filter(Game.group_tele_id == group_tele_id, Player.group_tele_id == group_tele_id,
Player.player_id == Game.curr_player).first()
game_round, curr_player, biggest_player, curr_cards, prev_cards = \
game.game_round, game.curr_player, game.biggest_player, game.curr_cards, game.prev_cards
player_name, num_cards = player.player_name, player.num_cards
if curr_cards.size == 0:
return
# if get_cards_type(curr_cards) == -1 or (game_round == 1 and not curr_cards.find("3D")) or \
# (curr_player != biggest_player and prev_cards.size != 0 and prev_cards.size != curr_cards.size):
if get_cards_type(curr_cards) == -1 or \
(curr_player != biggest_player and prev_cards.size != 0 and prev_cards.size != curr_cards.size):
valid = False
if valid and curr_player != biggest_player and not are_cards_bigger(prev_cards, curr_cards):
bigger = False
if not valid or not bigger:
session.remove()
return_cards_to_deck(group_tele_id)
if not valid:
message = _("Invalid cards. Please try again\n")
else:
message = _("You cards are not bigger than the previous cards. ")
message += _("Please try again\n")
else:
message = _("These cards have been used:\n")
for card in curr_cards:
message += suit_unicode(card.suit)
message += " "
message += str(card.value)
message += "\n"
bot.editMessageText(message, player_tele_id, message_id)
new_num_cards = num_cards - curr_cards.size
if new_num_cards == 0:
finish_game(bot, group_tele_id, player_tele_id, curr_player, player_name, curr_cards, job_queue)
return
game.curr_cards = pydealer.Stack()
game.prev_cards = curr_cards
player.num_cards = new_num_cards
s.commit()
session.remove()
advance_game(bot, group_tele_id, curr_player, player_name, curr_cards)
if valid and bigger:
player_message(bot, group_tele_id, job_queue)
else:
player_message(bot, group_tele_id, job_queue, is_edit=True, message_id=message_id)
bot.send_message(player_tele_id, message)
def test_single(self):
for i in range(num_tests):
cards = Stack(cards=[Card(random.choice(VALUES), random.choice(SUITS))])
self.assertEqual(get_cards_type(cards), SINGLE)
