179 lines
6.3 KiB
Python
179 lines
6.3 KiB
Python
"""
|
|
Edge case tests to achieve 100% code coverage
|
|
"""
|
|
|
|
import pytest
|
|
from poker.card import Card, Rank, ShortDeckRank, Suit
|
|
from poker.hand_evaluator import HandEvaluator
|
|
from poker.hand_ranking import HandType, HandRanking
|
|
from shortdeck.hand_ranking import ShortDeckHandType, ShortDeckHandRanking
|
|
|
|
|
|
class TestCoverageEdgeCases:
|
|
"""Tests for edge cases to improve code coverage"""
|
|
|
|
def test_rank_comparison_with_invalid_types(self):
|
|
"""Test rank comparisons with invalid types"""
|
|
rank = Rank.ACE
|
|
|
|
# Test __eq__ with non-Rank object
|
|
result = rank.__eq__("invalid")
|
|
assert result is NotImplemented
|
|
|
|
# Test __lt__ with non-Rank object
|
|
result = rank.__lt__("invalid")
|
|
assert result is NotImplemented
|
|
|
|
def test_shortdeck_rank_comparison_with_invalid_types(self):
|
|
"""Test short deck rank comparisons with invalid types"""
|
|
rank = ShortDeckRank.ACE
|
|
|
|
# Test __eq__ with non-ShortDeckRank object
|
|
result = rank.__eq__("invalid")
|
|
assert result is NotImplemented
|
|
|
|
# Test __lt__ with non-ShortDeckRank object
|
|
result = rank.__lt__("invalid")
|
|
assert result is NotImplemented
|
|
|
|
def test_card_creation_with_valid_ranks(self):
|
|
"""Test Card creation with valid ranks"""
|
|
# Standard deck card
|
|
card1 = Card(Rank.ACE, Suit.HEARTS)
|
|
assert card1.rank == Rank.ACE
|
|
assert card1.suit == Suit.HEARTS
|
|
assert not card1.is_short_deck()
|
|
|
|
# Short deck card
|
|
card2 = Card(ShortDeckRank.ACE, Suit.HEARTS)
|
|
assert card2.rank == ShortDeckRank.ACE
|
|
assert card2.suit == Suit.HEARTS
|
|
assert card2.is_short_deck()
|
|
|
|
def test_hand_evaluator_exactly_5_cards_error(self):
|
|
"""Test HandEvaluator with wrong number of cards"""
|
|
cards = [Card(Rank.ACE, Suit.HEARTS)] # Only 1 card
|
|
|
|
with pytest.raises(ValueError, match="Expected 5 cards, got 1"):
|
|
HandEvaluator.evaluate_5_cards(cards)
|
|
|
|
def test_hand_ranking_comparison_with_invalid_types(self):
|
|
"""Test HandRanking comparisons with invalid types"""
|
|
cards = [
|
|
Card(Rank.ACE, Suit.HEARTS),
|
|
Card(Rank.KING, Suit.HEARTS),
|
|
Card(Rank.QUEEN, Suit.HEARTS),
|
|
Card(Rank.JACK, Suit.HEARTS),
|
|
Card(Rank.TEN, Suit.HEARTS)
|
|
]
|
|
|
|
ranking = HandRanking(HandType.ROYAL_FLUSH, [Rank.ACE], cards)
|
|
|
|
# Test comparisons with non-HandRanking objects should return False, not NotImplemented
|
|
assert ranking != "invalid"
|
|
assert not (ranking == "invalid")
|
|
|
|
# These should not raise exceptions
|
|
try:
|
|
ranking < "invalid"
|
|
ranking <= "invalid"
|
|
ranking > "invalid"
|
|
ranking >= "invalid"
|
|
except TypeError:
|
|
pass # Expected behavior
|
|
|
|
def test_shortdeck_hand_ranking_comparison_with_invalid_types(self):
|
|
"""Test ShortDeckHandRanking comparisons with invalid types"""
|
|
cards = [
|
|
Card(ShortDeckRank.ACE, Suit.HEARTS),
|
|
Card(ShortDeckRank.KING, Suit.HEARTS),
|
|
Card(ShortDeckRank.QUEEN, Suit.HEARTS),
|
|
Card(ShortDeckRank.JACK, Suit.HEARTS),
|
|
Card(ShortDeckRank.TEN, Suit.HEARTS)
|
|
]
|
|
|
|
ranking = ShortDeckHandRanking(ShortDeckHandType.ROYAL_FLUSH, [ShortDeckRank.ACE], cards)
|
|
|
|
# Test comparisons with non-ShortDeckHandRanking objects
|
|
assert ranking != "invalid"
|
|
assert not (ranking == "invalid")
|
|
|
|
def test_card_comparison_and_equality(self):
|
|
"""Test Card comparison and equality edge cases"""
|
|
card1 = Card(Rank.ACE, Suit.HEARTS)
|
|
card2 = Card(Rank.ACE, Suit.HEARTS)
|
|
card3 = Card(Rank.KING, Suit.HEARTS)
|
|
|
|
# Test equality
|
|
assert card1 == card2
|
|
assert card1 != card3
|
|
|
|
# Test comparison
|
|
assert card1 > card3 # Ace > King
|
|
|
|
# Test inequality with non-Card object
|
|
result = card1.__eq__("not a card")
|
|
assert result is NotImplemented
|
|
|
|
result = card1.__lt__("not a card")
|
|
assert result is NotImplemented
|
|
|
|
def test_rank_hash_consistency(self):
|
|
"""Test rank hash consistency"""
|
|
rank1 = Rank.ACE
|
|
rank2 = Rank.ACE
|
|
rank3 = Rank.KING
|
|
|
|
assert hash(rank1) == hash(rank2)
|
|
assert hash(rank1) != hash(rank3)
|
|
|
|
def test_shortdeck_rank_hash_consistency(self):
|
|
"""Test short deck rank hash consistency"""
|
|
rank1 = ShortDeckRank.ACE
|
|
rank2 = ShortDeckRank.ACE
|
|
rank3 = ShortDeckRank.KING
|
|
|
|
assert hash(rank1) == hash(rank2)
|
|
assert hash(rank1) != hash(rank3)
|
|
|
|
def test_card_string_parsing_valid_cases(self):
|
|
"""Test valid card string parsing cases"""
|
|
# Test valid input
|
|
cards = Card.parse_cards("As Kh")
|
|
assert len(cards) == 2
|
|
assert cards[0].rank == Rank.ACE
|
|
assert cards[0].suit == Suit.SPADES
|
|
assert cards[1].rank == Rank.KING
|
|
assert cards[1].suit == Suit.HEARTS
|
|
|
|
# Test empty string returns empty list
|
|
cards = Card.parse_cards("")
|
|
assert len(cards) == 0
|
|
|
|
def test_card_getter_methods(self):
|
|
"""Test Card getter methods for coverage"""
|
|
card = Card(Rank.ACE, Suit.HEARTS)
|
|
assert card.get_rank() == Rank.ACE
|
|
assert card.get_suit() == Suit.HEARTS
|
|
|
|
def test_card_legacy_parse_methods(self):
|
|
"""Test legacy parsing methods"""
|
|
# Test parseLongCards method
|
|
cards = Card.parseLongCards("As Kh")
|
|
assert len(cards) == 2
|
|
|
|
# Test parse_short_deck_cards method
|
|
cards = Card.parse_short_deck_cards("As Kh")
|
|
assert len(cards) == 2
|
|
|
|
def test_hand_type_comparisons_with_invalid_types(self):
|
|
"""Test HandType comparisons with invalid types"""
|
|
hand_type = HandType.ROYAL_FLUSH
|
|
|
|
# Test __lt__ with invalid type
|
|
result = hand_type.__lt__("invalid")
|
|
assert result is NotImplemented
|
|
|
|
# Test __eq__ with invalid type
|
|
result = hand_type.__eq__("invalid")
|
|
assert result is NotImplemented |