修改

tests/__init__.py

@@ -0,0 +1,3 @@
+"""
+Test module initialization
+"""

tests/test_card.py

@@ -0,0 +1,155 @@
+"""
+Tests for Card, Rank, and Suit classes
+"""
+
+import pytest
+from poker.card import Card, Rank, Suit
+
+
+class TestRank:
+    """Test cases for Rank enum"""
+    
+    def test_rank_values(self):
+        """Test rank numeric values"""
+        assert Rank.TWO.numeric_value == 2
+        assert Rank.ACE.numeric_value == 14
+        assert Rank.KING.numeric_value == 13
+        assert Rank.JACK.numeric_value == 11
+    
+    def test_rank_symbols(self):
+        """Test rank symbols"""
+        assert Rank.TWO.symbol == '2'
+        assert Rank.ACE.symbol == 'A'
+        assert Rank.KING.symbol == 'K'
+        assert Rank.TEN.symbol == 'T'
+    
+    def test_rank_comparison(self):
+        """Test rank comparison operations"""
+        assert Rank.TWO < Rank.THREE
+        assert Rank.KING < Rank.ACE
+        assert Rank.JACK > Rank.TEN
+        assert Rank.ACE >= Rank.KING
+        assert Rank.TWO <= Rank.TWO
+    
+    def test_rank_str(self):
+        """Test string representation"""
+        assert str(Rank.ACE) == 'A'
+        assert str(Rank.KING) == 'K'
+        assert str(Rank.TWO) == '2'
+
+
+class TestSuit:
+    """Test cases for Suit enum"""
+    
+    def test_suit_values(self):
+        """Test suit values"""
+        assert Suit.SPADES.value == 's'
+        assert Suit.HEARTS.value == 'h'
+        assert Suit.DIAMONDS.value == 'd'
+        assert Suit.CLUBS.value == 'c'
+    
+    def test_suit_str(self):
+        """Test string representation"""
+        assert str(Suit.SPADES) == 's'
+        assert str(Suit.HEARTS) == 'h'
+
+
+class TestCard:
+    """Test cases for Card class"""
+    
+    def test_card_creation(self):
+        """Test card creation"""
+        card = Card(Rank.ACE, Suit.SPADES)
+        assert card.rank == Rank.ACE
+        assert card.suit == Suit.SPADES
+    
+    def test_card_str(self):
+        """Test string representation"""
+        card = Card(Rank.ACE, Suit.SPADES)
+        assert str(card) == 'As'
+        
+        card2 = Card(Rank.KING, Suit.HEARTS)
+        assert str(card2) == 'Kh'
+    
+    def test_card_equality(self):
+        """Test card equality"""
+        card1 = Card(Rank.ACE, Suit.SPADES)
+        card2 = Card(Rank.ACE, Suit.SPADES)
+        card3 = Card(Rank.ACE, Suit.HEARTS)
+        
+        assert card1 == card2
+        assert card1 != card3
+    
+    def test_card_comparison(self):
+        """Test card comparison (by rank)"""
+        ace_spades = Card(Rank.ACE, Suit.SPADES)
+        king_hearts = Card(Rank.KING, Suit.HEARTS)
+        two_clubs = Card(Rank.TWO, Suit.CLUBS)
+        
+        assert two_clubs < king_hearts
+        assert king_hearts < ace_spades
+        assert not (ace_spades < king_hearts)
+    
+    def test_from_string_valid(self):
+        """Test creating card from valid string"""
+        card = Card.from_string("As")
+        assert card.rank == Rank.ACE
+        assert card.suit == Suit.SPADES
+        
+        card2 = Card.from_string("Kh")
+        assert card2.rank == Rank.KING
+        assert card2.suit == Suit.HEARTS
+        
+        card3 = Card.from_string("2c")
+        assert card3.rank == Rank.TWO
+        assert card3.suit == Suit.CLUBS
+        
+        card4 = Card.from_string("Td")
+        assert card4.rank == Rank.TEN
+        assert card4.suit == Suit.DIAMONDS
+    
+    def test_from_string_invalid(self):
+        """Test creating card from invalid string"""
+        with pytest.raises(ValueError):
+            Card.from_string("A")  # Too short
+        
+        with pytest.raises(ValueError):
+            Card.from_string("Asx")  # Too long
+        
+        with pytest.raises(ValueError):
+            Card.from_string("Xs")  # Invalid rank
+        
+        with pytest.raises(ValueError):
+            Card.from_string("Ax")  # Invalid suit
+    
+    def test_parse_cards_valid(self):
+        """Test parsing multiple cards from string"""
+        cards = Card.parse_cards("AsKs AhAdAc6s7s")
+        assert len(cards) == 7
+        assert str(cards[0]) == "As"
+        assert str(cards[1]) == "Ks"
+        assert str(cards[2]) == "Ah"
+        assert str(cards[6]) == "7s"
+    
+    def test_parse_cards_with_spaces(self):
+        """Test parsing cards with various spacing"""
+        cards = Card.parse_cards("As Ks  Ah   Ad Ac 6s 7s")
+        assert len(cards) == 7
+        assert str(cards[0]) == "As"
+        assert str(cards[6]) == "7s"
+    
+    def test_parse_cards_empty(self):
+        """Test parsing empty string"""
+        cards = Card.parse_cards("")
+        assert len(cards) == 0
+        
+        cards = Card.parse_cards("   ")
+        assert len(cards) == 0
+    
+    def test_parse_cards_invalid(self):
+        """Test parsing invalid card strings"""
+        with pytest.raises(ValueError):
+            Card.parse_cards("AsKs A")  # Incomplete card
+        
+        with pytest.raises(ValueError):
+            Card.parse_cards("AsKs Ax")  # Invalid suit

tests/test_hand_evaluator.py

@@ -0,0 +1,161 @@
+"""
+Tests for HandEvaluator class
+"""
+
+import pytest
+from poker.hand_evaluator import HandEvaluator
+from poker.hand_ranking import HandType
+from poker.card import Card, Rank, Suit
+
+
+class TestHandEvaluator:
+    """Test cases for HandEvaluator class"""
+    
+    def test_royal_flush(self):
+        """Test royal flush detection"""
+        cards_str = "AhKhQhJhTh2c3c"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert ranking.hand_type == HandType.ROYAL_FLUSH
+        assert str(ranking) == "Royal Flush"
+    
+    def test_straight_flush(self):
+        """Test straight flush detection"""
+        cards_str = "2h3h4h5h6h7s8s"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert ranking.hand_type == HandType.STRAIGHT_FLUSH
+        assert str(ranking) == "Straight Flush(6 high)"
+    
+    def test_four_of_a_kind(self):
+        """Test four of a kind detection"""
+        cards_str = "AsKs AhAdAc6s7s"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert ranking.hand_type == HandType.FOUR_OF_A_KIND
+        assert str(ranking) == "Quad(A)"
+    
+    def test_full_house(self):
+        """Test full house detection"""
+        cards_str = "AsAhAd KsKh6s7s"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert ranking.hand_type == HandType.FULL_HOUSE
+        assert "Full House(A over K)" in str(ranking)
+    
+    def test_flush(self):
+        """Test flush detection"""
+        cards_str = "AhKh6h4h2h7s8s"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert ranking.hand_type == HandType.FLUSH
+        assert "Flush(A high)" in str(ranking)
+    
+    def test_straight(self):
+        """Test straight detection"""
+        cards_str = "As2h3d4c5h7s8s"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert ranking.hand_type == HandType.STRAIGHT
+        assert str(ranking) == "Straight(5 high)"  # A-2-3-4-5 wheel
+    
+    def test_straight_ace_high(self):
+        """Test straight with ace high"""
+        cards_str = "AsTsJhQdKh7s8s"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert ranking.hand_type == HandType.STRAIGHT
+        assert str(ranking) == "Straight(A high)"
+    
+    def test_three_of_a_kind(self):
+        """Test three of a kind detection"""
+        cards_str = "AsAhAd6s7h8s9s"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert ranking.hand_type == HandType.THREE_OF_A_KIND
+        assert str(ranking) == "Three of a Kind(A)"
+    
+    def test_two_pair(self):
+        """Test two pair detection"""
+        cards_str = "AsAh6d6s7h8s9s"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert ranking.hand_type == HandType.TWO_PAIR
+        assert "Two Pair(A and 6)" in str(ranking)
+    
+    def test_one_pair(self):
+        """Test one pair detection"""
+        cards_str = "AsAh6d4s2h3cJd"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert ranking.hand_type == HandType.ONE_PAIR
+        assert str(ranking) == "Pair(A)"
+    
+    def test_high_card(self):
+        """Test high card detection"""
+        cards_str = "As6h4d8s9hJdKc"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert ranking.hand_type == HandType.HIGH_CARD
+        assert str(ranking) == "High Card(A)"
+    
+    def test_wheel_straight(self):
+        """Test A-2-3-4-5 straight (wheel)"""
+        cards_str = "As2h3d4c5h7s8s"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert ranking.hand_type == HandType.STRAIGHT
+        assert ranking.key_ranks[0] == Rank.FIVE  # 5 is high in wheel
+    
+    def test_invalid_input_not_seven_cards(self):
+        """Test error handling for wrong number of cards"""
+        with pytest.raises(ValueError):
+            HandEvaluator.evaluate_from_input("AsKh")
+        
+        with pytest.raises(ValueError):
+            HandEvaluator.evaluate_from_input("AsKhQdJc9h8s7d6c")
+    
+    def test_invalid_card_format(self):
+        """Test error handling for invalid card format"""
+        with pytest.raises(ValueError):
+            HandEvaluator.evaluate_from_input("AsKhQdJcXh8s7d")
+    
+    def test_seven_cards_best_five_selected(self):
+        """Test that best 5 cards are selected from 7"""
+        # Should pick the straight flush over the pair
+        cards_str = "2h3h4h5h6hAsAd"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert ranking.hand_type == HandType.STRAIGHT_FLUSH
+        assert str(ranking) == "Straight Flush(6 high)"
+    
+    def test_multiple_possible_straights(self):
+        """Test selecting highest straight from multiple possibilities"""
+        cards_str = "As2h3d4c5h6s7s"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert ranking.hand_type == HandType.STRAIGHT
+        # Should pick 3-4-5-6-7 over A-2-3-4-5
+        assert ranking.key_ranks[0] == Rank.SEVEN
+    
+    def test_multiple_possible_flushes(self):
+        """Test selecting best flush from multiple suits"""
+        cards_str = "AhKh6h4h2h7s8s"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert ranking.hand_type == HandType.FLUSH
+        assert ranking.key_ranks[0] == Rank.ACE
+    
+    def test_evaluate_five_cards_directly(self):
+        """Test evaluating exactly 5 cards"""
+        cards = [
+            Card(Rank.ACE, Suit.SPADES),
+            Card(Rank.ACE, Suit.HEARTS), 
+            Card(Rank.ACE, Suit.DIAMONDS),
+            Card(Rank.ACE, Suit.CLUBS),
+            Card(Rank.KING, Suit.SPADES)
+        ]
+        ranking = HandEvaluator._evaluate_five_cards(cards)
+        
+        assert ranking.hand_type == HandType.FOUR_OF_A_KIND
+        assert ranking.key_ranks[0] == Rank.ACE

tests/test_hand_ranking.py

@@ -0,0 +1,137 @@
+"""
+Tests for HandRanking and HandType classes
+"""
+
+import pytest
+from poker.hand_ranking import HandRanking, HandType
+from poker.card import Card, Rank, Suit
+
+
+class TestHandType:
+    """Test cases for HandType enum"""
+    
+    def test_hand_type_values(self):
+        """Test hand type strength values"""
+        assert HandType.HIGH_CARD.strength == 1
+        assert HandType.ONE_PAIR.strength == 2
+        assert HandType.ROYAL_FLUSH.strength == 10
+    
+    def test_hand_type_names(self):
+        """Test hand type names"""
+        assert HandType.HIGH_CARD.type_name == "High Card"
+        assert HandType.FOUR_OF_A_KIND.type_name == "Four of a Kind"
+        assert str(HandType.ROYAL_FLUSH) == "Royal Flush"
+    
+    def test_hand_type_comparison(self):
+        """Test hand type comparison"""
+        assert HandType.HIGH_CARD < HandType.ONE_PAIR
+        assert HandType.FULL_HOUSE > HandType.FLUSH
+        assert HandType.ROYAL_FLUSH >= HandType.STRAIGHT_FLUSH
+        assert HandType.TWO_PAIR <= HandType.THREE_OF_A_KIND
+
+
+class TestHandRanking:
+    """Test cases for HandRanking class"""
+    
+    def test_hand_ranking_creation(self):
+        """Test hand ranking creation"""
+        cards = [
+            Card(Rank.ACE, Suit.SPADES),
+            Card(Rank.ACE, Suit.HEARTS),
+            Card(Rank.ACE, Suit.DIAMONDS),
+            Card(Rank.ACE, Suit.CLUBS),
+            Card(Rank.KING, Suit.SPADES)
+        ]
+        ranking = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.ACE, Rank.KING], cards)
+        
+        assert ranking.hand_type == HandType.FOUR_OF_A_KIND
+        assert ranking.key_ranks == [Rank.ACE, Rank.KING]
+        assert ranking.cards == cards
+    
+    def test_quad_string_representation(self):
+        """Test string representation for four of a kind"""
+        cards = [Card(Rank.ACE, Suit.SPADES)] * 5  # Dummy cards
+        ranking = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.ACE, Rank.KING], cards)
+        assert str(ranking) == "Quad(A)"
+    
+    def test_full_house_string_representation(self):
+        """Test string representation for full house"""
+        cards = [Card(Rank.ACE, Suit.SPADES)] * 5  # Dummy cards
+        ranking = HandRanking(HandType.FULL_HOUSE, [Rank.ACE, Rank.KING], cards)
+        assert str(ranking) == "Full House(A over K)"
+    
+    def test_flush_string_representation(self):
+        """Test string representation for flush"""
+        cards = [Card(Rank.ACE, Suit.SPADES)] * 5  # Dummy cards
+        ranking = HandRanking(HandType.FLUSH, [Rank.ACE], cards)
+        assert str(ranking) == "Flush(A high)"
+    
+    def test_straight_string_representation(self):
+        """Test string representation for straight"""
+        cards = [Card(Rank.ACE, Suit.SPADES)] * 5  # Dummy cards
+        ranking = HandRanking(HandType.STRAIGHT, [Rank.ACE], cards)
+        assert str(ranking) == "Straight(A high)"
+    
+    def test_straight_flush_string_representation(self):
+        """Test string representation for straight flush"""
+        cards = [Card(Rank.KING, Suit.SPADES)] * 5  # Dummy cards
+        ranking = HandRanking(HandType.STRAIGHT_FLUSH, [Rank.KING], cards)
+        assert str(ranking) == "Straight Flush(K high)"
+    
+    def test_royal_flush_string_representation(self):
+        """Test string representation for royal flush"""
+        cards = [Card(Rank.ACE, Suit.SPADES)] * 5  # Dummy cards
+        ranking1 = HandRanking(HandType.ROYAL_FLUSH, [Rank.ACE], cards)
+        assert str(ranking1) == "Royal Flush"
+        
+        # Also test straight flush with Ace high
+        ranking2 = HandRanking(HandType.STRAIGHT_FLUSH, [Rank.ACE], cards)
+        assert str(ranking2) == "Royal Flush"
+    
+    def test_three_of_a_kind_string_representation(self):
+        """Test string representation for three of a kind"""
+        cards = [Card(Rank.ACE, Suit.SPADES)] * 5  # Dummy cards
+        ranking = HandRanking(HandType.THREE_OF_A_KIND, [Rank.ACE], cards)
+        assert str(ranking) == "Three of a Kind(A)"
+    
+    def test_two_pair_string_representation(self):
+        """Test string representation for two pair"""
+        cards = [Card(Rank.ACE, Suit.SPADES)] * 5  # Dummy cards
+        ranking = HandRanking(HandType.TWO_PAIR, [Rank.ACE, Rank.KING], cards)
+        assert str(ranking) == "Two Pair(A and K)"
+    
+    def test_one_pair_string_representation(self):
+        """Test string representation for one pair"""
+        cards = [Card(Rank.ACE, Suit.SPADES)] * 5  # Dummy cards
+        ranking = HandRanking(HandType.ONE_PAIR, [Rank.ACE], cards)
+        assert str(ranking) == "Pair(A)"
+    
+    def test_high_card_string_representation(self):
+        """Test string representation for high card"""
+        cards = [Card(Rank.ACE, Suit.SPADES)] * 5  # Dummy cards
+        ranking = HandRanking(HandType.HIGH_CARD, [Rank.ACE], cards)
+        assert str(ranking) == "High Card(A)"
+    
+    def test_hand_ranking_equality(self):
+        """Test hand ranking equality"""
+        cards = [Card(Rank.ACE, Suit.SPADES)] * 5  # Dummy cards
+        ranking1 = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.ACE, Rank.KING], cards)
+        ranking2 = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.ACE, Rank.KING], cards)
+        ranking3 = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.KING, Rank.ACE], cards)
+        
+        assert ranking1 == ranking2
+        assert ranking1 != ranking3
+    
+    def test_hand_ranking_comparison(self):
+        """Test hand ranking comparison"""
+        cards = [Card(Rank.ACE, Suit.SPADES)] * 5  # Dummy cards
+        
+        # Different hand types
+        quad_aces = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.ACE], cards)
+        full_house = HandRanking(HandType.FULL_HOUSE, [Rank.ACE], cards)
+        assert full_house < quad_aces
+        
+        # Same hand type, different ranks
+        quad_aces = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.ACE], cards)
+        quad_kings = HandRanking(HandType.FOUR_OF_A_KIND, [Rank.KING], cards)
+        assert quad_kings < quad_aces

tests/test_integration.py

@@ -0,0 +1,86 @@
+"""
+Integration tests for the main program
+"""
+
+import pytest
+import sys
+import io
+from unittest.mock import patch
+from poker.hand_evaluator import HandEvaluator
+
+
+class TestMainProgram:
+    """Integration tests for main program functionality"""
+    
+    def test_example_input(self):
+        """Test the example input from the requirements"""
+        cards_str = "AsKs AhAdAc6s7s"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert str(ranking) == "Quad(A)"
+    
+    def test_various_hand_types(self):
+        """Test various hand types work correctly end-to-end"""
+        test_cases = [
+            ("AhKhQhJhTh2c3c", "Royal Flush"),
+            ("2h3h4h5h6h7s8s", "Straight Flush(6 high)"),
+            ("AsKs AhAdAc6s7s", "Quad(A)"),
+            ("AsAhAd KsKh6s7s", "Full House(A over K)"),
+            ("AhKh6h4h2h7s8s", "Flush(A high)"),
+            ("AsTsJhQdKh7s8s", "Straight(A high)"),
+            ("AsAhAd6s7h8s9s", "Three of a Kind(A)"),
+            ("AsAh6d6s7h8s9s", "Two Pair(A and 6)"),
+            ("AsAh6d4s2h3cJd", "Pair(A)"),
+            ("As6h4d8s9hJdKc", "High Card(A)"),
+        ]
+        
+        for cards_str, expected_result in test_cases:
+            ranking = HandEvaluator.evaluate_from_input(cards_str)
+            assert str(ranking) == expected_result, f"Failed for {cards_str}"
+    
+    def test_wheel_straight(self):
+        """Test A-2-3-4-5 straight (wheel)"""
+        cards_str = "As2h3d4c5h7s8s"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert str(ranking) == "Straight(5 high)"
+    
+    def test_different_card_formats(self):
+        """Test different ways of writing the same cards"""
+        # These should all represent the same hand
+        formats = [
+            "AsKsAhAdAc6s7s",
+            "As Ks Ah Ad Ac 6s 7s",
+            "As  Ks   Ah    Ad     Ac      6s       7s",
+        ]
+        
+        expected_result = "Quad(A)"
+        
+        for cards_str in formats:
+            ranking = HandEvaluator.evaluate_from_input(cards_str)
+            assert str(ranking) == expected_result
+    
+    def test_case_insensitive_suits(self):
+        """Test that suits are case insensitive"""
+        cards_str = "AsKsAhAdAc6s7s"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        
+        assert str(ranking) == "Quad(A)"
+    
+    def test_edge_cases(self):
+        """Test edge cases and boundary conditions"""
+        # All same rank except one
+        cards_str = "2s2h2d2c3s4h5d"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        assert str(ranking) == "Quad(2)"
+        
+        # Minimum straight
+        cards_str = "As2h3d4c5h6s7s"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        # Should pick 3-4-5-6-7 over A-2-3-4-5
+        assert "Straight(7 high)" in str(ranking)
+        
+        # Maximum straight  
+        cards_str = "9sTsJhQdKhAsAd"
+        ranking = HandEvaluator.evaluate_from_input(cards_str)
+        assert str(ranking) == "Straight(A high)"