task4

tests/test_coverage_edge_cases.py

@@ -0,0 +1,179 @@
+"""
+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