rora 0.0.6 → 0.4.0

data/test/rora/model/card_test.rb

@@ -1,11 +1,45 @@
 require File.expand_path("../../rora_test", File.dirname(__FILE__))
 
 class CardTest < ActiveSupport::TestCase
-
   def setup
     @card = Card.new("AS")
   end
 
+  test "should be able to sort cards by rank" do
+    cards = Card.to_cards "2H,4D,QS,JC,7D,TC,AH,KD,6H,9D,3S,5C,8C"
+    cards.sort!
+
+    assert_equal "Ace of Hearts", cards[0].value
+    assert_equal "King of Diamonds", cards[1].value
+    assert_equal "Queen of Spades", cards[2].value
+    assert_equal "Jack of Clubs", cards[3].value
+    assert_equal "Ten of Clubs", cards[4].value
+    assert_equal "Nine of Diamonds", cards[5].value
+    assert_equal "Eight of Clubs", cards[6].value
+    assert_equal "Seven of Diamonds", cards[7].value
+    assert_equal "Six of Hearts", cards[8].value
+    assert_equal "Five of Clubs", cards[9].value
+    assert_equal "Four of Diamonds", cards[10].value
+    assert_equal "Three of Spades", cards[11].value
+    assert_equal "Two of Hearts", cards[12].value
+  end
+
+  test "should be able to sort cards by suit" do
+    cards = Card.to_cards "AS,AH,AD,AC"
+    cards.sort!
+
+    assert_equal "Ace of Hearts", cards[0].value
+    assert_equal "Ace of Diamonds", cards[1].value
+    assert_equal "Ace of Spades", cards[2].value
+    assert_equal "Ace of Clubs", cards[3].value
+
+  end
+
+  test "should be able to identify duplicate cards" do
+    cards = Card.to_cards("AS,AS,KS,KS")
+    assert_equal 2, cards.uniq.size
+  end
+
   test "should be able to create a card with the specified rank and suit" do
     card = Card.new(Rank::ACE, Suit::SPADE)
     assert_equal card.rank, Rank::ACE
@@ -18,37 +52,33 @@ class CardTest < ActiveSupport::TestCase
     assert_equal card.suit, Suit::SPADE
   end
 
+  test "should have an id" do
+    assert_equal 103, @card.uid
+  end
+
   test "should raise an exception when attempting to create a card with an invalid string value" do
-    assert_raise ArgumentError do
+    assert_raise_message "A is an invalid card sequence", ArgumentError do
       card = Card.new("A")
     end
-    assert_raise ArgumentError do
+    assert_raise_message "ASK is an invalid card sequence", ArgumentError do
       card = Card.new("ASK")
     end
   end
 
-  test "a card should have an id" do
-    assert_equal 1927, @card.id
-  end
-
-  test "a card id should be equal to the product of the card suit id and rank id" do
-    assert_equal @card.id, (Rank::ACE.id * Suit::SPADE.id)
-  end
-
   test "a card should have a key" do
     assert_equal "AS", @card.key
   end
 
-  test "a card key should be equal to the concatenation of the card suit key and rank key" do
+  test "a card key should be equal to the concatenation of the cards' suit key and rank key" do
     assert_equal "AS", (Rank::ACE.key + Suit::SPADE.key)
   end
 
-  test "a card should have a name" do
-    assert_equal "Ace of Spades", Card.new("AS").name
+  test "a card should have a value" do
+    assert_equal "Ace of Spades", Card.new("AS").value
   end
 
   test "should generate a readable string representation" do
-    assert_equal "Card: Ace of Spades", Card.new("AS").to_s
+    assert_equal "Ace of Spades", Card.new("AS").to_s
   end
 
   test "should convert an arbitrarily long string of characters into an array of cards" do

data/test/rora/model/deck_test.rb

@@ -111,4 +111,28 @@ class DeckTest < ActiveSupport::TestCase
     assert_equal true, @deck.contains_any?("AH,KH,QH,JH,KS")
   end
 
+  test "should remove all spades from the deck" do
+    @deck.remove_all(Suit::SPADE)
+    assert_equal 39, @deck.cards.size
+    assert_equal 0, @deck.count_cards_with_suit(Suit::SPADE)
+  end
+
+  test "should remove all kings from the deck" do
+    @deck.remove_all(Rank::KING)
+    assert_equal 48, @deck.cards.size
+    assert_equal 0, @deck.count_cards_with_rank(Rank::KING)
+  end
+
+  test "should retain all spades in the deck" do
+    @deck.retain_all(Suit::SPADE)
+    assert_equal 13, @deck.cards.size
+    assert_equal 13, @deck.count_cards_with_suit(Suit::SPADE)
+  end
+
+  test "should retain all kings in the deck" do
+    @deck.retain_all(Rank::KING)
+    assert_equal 4, @deck.cards.size
+    assert_equal 4, @deck.count_cards_with_rank(Rank::KING)
+  end
+
 end

data/test/rora/model/hand_test.rb

@@ -7,45 +7,25 @@ class HandTest < ActiveSupport::TestCase
   end
 
   test "should raise an error when a hand is not created with 5 cards" do
-    assert_raise ArgumentError do
+    assert_raise_message "Exactly 5 cards are required to create a hand, 2 provided", ArgumentError do
       Hand.new [Card.new("AS"), Card.new("KS")]
     end
   end
 
   test "should raise an error when a hand is not created with 10 characters" do
-    assert_raise ArgumentError do
+    assert_raise_message "Exactly 5 cards are required to create a hand, 8 provided", ArgumentError do
       Hand.new "ASKSQSJS"
     end
   end
 
   test "should raise an error when creating a hand with duplicate cards" do
-    assert_raise ArgumentError do
+    assert_raise_message "The hand contains duplicate cards", ArgumentError do
       Hand.new "AS KS JS AS KS"
     end
   end
 
-  test "the hand should have an id" do
-    assert_equal 7193866898674063, @hand.id
-  end
-
-  test "the hand id should be equal to the product of each card id contained in the hand" do
-    assert_equal @hand.id, (Card.new("AS").id * Card.new("KS").id * Card.new("QS").id * Card.new("JS").id * Card.new("TS").id)
-  end
-
-  test "the hand should have a hash key" do
-    assert_equal 2101589603, @hand.hash_key
-  end
-
-  test "the hash key should be equal to the product of each card rank id in the hand times" do
-    assert_equal Hand.new("ASACAHJSTS").hash_key, (Card.new("AS").rank.id * Card.new("AC").rank.id * Card.new("AH").rank.id * Card.new("JS").rank.id * Card.new("TS").rank.id)
-  end
-
-  test "the hash key should be equal to the product of each card rank id in the hand times 67 when the hand is a flush" do
-    assert_equal @hand.hash_key, (Card.new("AS").rank.id * Card.new("KS").rank.id * Card.new("QS").rank.id * Card.new("JS").rank.id * Card.new("TS").rank.id * 67)
-  end
-
-  test "the hand should have a value" do
-    assert_equal "AS,KS,QS,JS,TS", @hand.value
+  test "the hand should have a hand key" do
+    assert_equal "ASKSQSJSTS", @hand.key
   end
 
   test "the hand should be a flush" do
@@ -60,10 +40,6 @@ class HandTest < ActiveSupport::TestCase
     assert_equal 1, @hand.score
   end
 
-  test "the hand should have a probability" do
-    assert_equal 0.0015, @hand.probability
-  end
-
   test "the hand should have a name" do
     assert_equal "Royal Flush", @hand.name
   end

data/test/rora/model/hand_type_test.rb

@@ -15,19 +15,19 @@ class HandTypeTest < ActiveSupport::TestCase
   end
 
   test "should raise an error when performing a lookup with an invalid key" do
-    assert_raise ArgumentError do
+    assert_raise_message "No hand type exists for key 'L'", ArgumentError do
       HandType.get "L"
     end
   end
 
   test "should raise an error when performing a lookup with an empty key" do
-    assert_raise ArgumentError do
+    assert_raise_message "No hand type exists for key ''", ArgumentError do
       HandType.get ""
     end
   end
 
   test "should raise an error when performing a lookup with a nil key" do
-    assert_raise TypeError do
+    assert_raise_message "can't convert nil into String", TypeError do
       HandType.get nil
     end
   end

data/test/rora/model/pot_test.rb

@@ -1,7 +1,7 @@
 require File.expand_path("../../rora_test", File.dirname(__FILE__))
 
 class PotTest < ActiveSupport::TestCase
-
+  
   def setup
     @pot = Pot.new
   end
@@ -11,7 +11,7 @@ class PotTest < ActiveSupport::TestCase
   end
 
   test "should raise an error when attempting to add a negative value to the pot" do
-    assert_raise ArgumentError do
+    assert_raise_message "Can only add positive values", ArgumentError do
       @pot.add -0.50
     end
   end

data/test/rora/model/rank_test.rb

@@ -27,7 +27,7 @@ class RankTest < ActiveSupport::TestCase
   end
 
   test "should raise an error when performing a lookup with an empty key" do
-    assert_raise_message  "No rank exists for key ''", ArgumentError do
+    assert_raise_message "No rank exists for key ''", ArgumentError do
       Rank.get ""
     end
   end
@@ -39,7 +39,15 @@ class RankTest < ActiveSupport::TestCase
   end
 
   test "should generate a readable string representation" do
-    assert_equal "Rank: Ace", Rank::ACE.to_s
+    assert_equal "Ace", Rank::ACE.to_s
+  end
+
+  test "two identical ranks should be equal" do
+    assert_equal true, Rank::ACE == Rank::ACE
+  end
+
+  test "two different ranks should not be equal" do
+    assert_equal false, Rank::EIGHT == Rank::FIVE
   end
 
 end

data/test/rora/model/seat_test.rb

@@ -7,7 +7,7 @@ class SeatTest < ActiveSupport::TestCase
   end
 
   test "should raise an error when a seat is created with a seat number less than 1" do
-    assert_raise ArgumentError do
+    assert_raise_message "Must create a seat number with a value of 1 or greater", ArgumentError do
       Seat.new 0
     end
   end

data/test/rora/model/starting_hand_test.rb

@@ -2,24 +2,20 @@ require File.expand_path("../../rora_test", File.dirname(__FILE__))
 
 class StartingHandTest < ActiveSupport::TestCase
 
-  def setup
-    @hand = StartingHand.new "ASKS"
-  end
-
   test "should raise an error when a starting hand is not created with 2 cards" do
-    assert_raise ArgumentError do
+    assert_raise_message "Exactly 2 cards are required to create a starting hand, 3 provided", ArgumentError do
       StartingHand.new [Card.new("AS"), Card.new("KS"), Card.new("QS")]
     end
   end
 
   test "should raise an error when a starting hand is not created with 4 characters" do
-    assert_raise ArgumentError do
+    assert_raise_message "Exactly 2 cards are required to create a starting hand, 4 provided", ArgumentError do
       StartingHand.new "ASKSQSJS"
     end
   end
 
   test "should raise an error when creating a starting hand with duplicate cards" do
-    assert_raise ArgumentError do
+    assert_raise_message "The starting hand contains duplicate cards", ArgumentError do
       StartingHand.new "ASAS"
     end
   end
@@ -33,7 +29,7 @@ class StartingHandTest < ActiveSupport::TestCase
   end
 
   test "the starting hand should have a value" do
-    assert_equal "AS,KS", StartingHand.new("ASKS").value
+    assert_equal "Ace of Spades, King of Spades", StartingHand.new("ASKS").value
   end
 
   test "the starting hand should have a short value" do
@@ -48,16 +44,12 @@ class StartingHandTest < ActiveSupport::TestCase
     assert_equal false, StartingHand.new("ASKH").pocket_pair?
   end
 
-  test "the starting hand should have an id that is equal to the product of the card ids" do
-    assert_equal StartingHand.new("ASKH").id, (Card.new("AS").id * Card.new("KH").id)
-  end
-
-  test "the starting hand should have a key that is equal to the product of the card rank ids when the starting hand is unsuited" do
-    assert_equal StartingHand.new("ASKH").key, (Card.new("AS").rank.id * Card.new("KH").rank.id)
+  test "the starting hand should have a key that is composed of the card keys" do
+    assert_equal "ASKH", StartingHand.new("ASKH").key
   end
 
-  test "the starting hand should have a key that is equal to 67 times the product of the card rank ids when the starting hand is suited" do
-    assert_equal StartingHand.new("ASKS").key, (Card.new("AS").rank.id * Card.new("KS").rank.id * 67)
+  test "the starting hand key should have a consistent ordering" do
+    assert_equal "ASKH", StartingHand.new("KHAS").key
   end
 
   test "should return all starting hands" do

data/test/rora/model/suit_test.rb

@@ -21,13 +21,13 @@ class SuitTest < ActiveSupport::TestCase
   end
 
   test "should raise an error when performing a lookup with an invalid key" do
-    assert_raise ArgumentError do
+    assert_raise_message "No suit exists for key 'L'", ArgumentError do
       Suit.get("L")
     end
   end
 
   test "should raise an error when performing a lookup with an empty key" do
-    assert_raise ArgumentError do
+    assert_raise_message "No suit exists for key ''",  ArgumentError do
       Suit.get("")
     end
   end
@@ -39,7 +39,7 @@ class SuitTest < ActiveSupport::TestCase
   end
 
   test "should generate a readable string representation" do
-    assert_equal "Suit: Spades", Suit::SPADE.to_s
+    assert_equal "Spades", Suit::SPADE.to_s
   end
 
 end

data/test/rora/model/table_test.rb

@@ -39,7 +39,7 @@ class TableTest < ActiveSupport::TestCase
   end
 
   test "should raise an error when a table is created with less than two seats" do
-    assert_raise ArgumentError, "A table must have at least two seats" do
+    assert_raise_message "A table must have at least two seats", ArgumentError do
       Table.new 1
     end
   end
@@ -56,19 +56,19 @@ class TableTest < ActiveSupport::TestCase
 
   test "should raise an error when attempting to seat a player at a seat that is already taken" do
     @table.add "player1", 4
-    assert_raise ArgumentError, "Seat number 4 is already taken by another player" do
+    assert_raise_message "Seat number 4 is already taken by another player", ArgumentError do
       @table.add "player2", 4
     end
   end
 
   test "should raise an error when attempting to seat a player at a seat that does not exist" do
-    assert_raise ArgumentError, "Seat number 11 does not exist at this table" do
+    assert_raise_message "Seat number 11 does not exist at this table", ArgumentError do
       @table.add "player", 11
     end
-    assert_raise ArgumentError, "Seat number 0 does not exist at this table"  do
+    assert_raise_message "Seat number 0 does not exist at this table", ArgumentError  do
       @table.add "player", 0
     end
-    assert_raise ArgumentError, "Seat number -3 does not exist at this table"  do
+    assert_raise_message "Seat number -3 does not exist at this table", ArgumentError  do
       @table.add "player", -3
     end
   end
@@ -100,7 +100,7 @@ class TableTest < ActiveSupport::TestCase
 
   test "should raise an error when attempting to seat a player at a full table" do
     (1..9).each {|x| @table.add("player#{x}")}
-    assert_raise RuntimeError do
+    assert_raise_message "Cannot add player, the table is full", RuntimeError do
       @table.add "player 10"
     end
   end
@@ -135,7 +135,7 @@ class TableTest < ActiveSupport::TestCase
 
   test "should raise an error when trying to find the next player to act when there are less than two players at the table" do
     @table.add("Player 1", 1)
-    assert_raise RuntimeError, "Cannot find the next player when there are less than two players at the table" do
+    assert_raise_message "There are fewer than two players at the table", RuntimeError do
       @table.the_seat_after @table.seat(8)
     end
   end
@@ -160,7 +160,7 @@ class TableTest < ActiveSupport::TestCase
 
   test "should raise an error when trying to find the previous player to act when there are less than two players at the table" do
     @table.add("Player 1", 1)
-    assert_raise RuntimeError, "Cannot find the previous player when there are less than two players at the table" do
+    assert_raise_message "There are fewer than two players at the table", RuntimeError do
       @table.the_seat_before @table.seat(8)
     end
   end

data/test/rora/repository/hand_repository_test.rb

@@ -1,26 +1,24 @@
 require File.expand_path("../../rora_test", File.dirname(__FILE__))
 
 class HandRepositoyTest < ActiveSupport::TestCase
-
+  
   def setup
     @repository = HandRepository.instance
   end
 
-  test "should be able to find a poker hand by id" do
-    result =  @repository.find 2101589603
+  test "should be able to evaluate a 5 card poker hand" do
+    result =  @repository.evaluate_5_card_hand Card.to_cards("AS,KS,QS,JS,TS")
     assert_equal 1, result[0]
     assert_equal "SF", result[1]
     assert_equal "Royal Flush", result[2]
-    assert_equal 0.0015, result[3]
   end
 
-  test "should raise an error when attempting to find a poker hand with an invalid id" do
-    assert_raise KeyError do
-      @repository.find 210158960345
-    end
+  test "should be able to evaluate a 7 card poker hand" do
+    result = @repository.evaluate_7_card_hand Card.to_cards("KS,3H,2S,AS,AC,AH,AD")
+    assert_equal 11, result[0]
   end
 
-  test "should return every poker hand" do
+  test "should return all 2,598,960 poker hands" do
     assert_equal 2598960, @repository.list.size
   end
 
@@ -51,33 +49,33 @@ class HandRepositoyTest < ActiveSupport::TestCase
   end
 
   test "should return every distinct poker hand" do
-    assert_equal 7462, @repository.list_unique.size
+    assert_equal 7462, @repository.list_and_group_by_hand_score.size
   end
 
   test "should return every distinct poker hand that can be made with the given starting hand" do
-    assert_equal 620, @repository.list_unique(:starting_hand => StartingHand.new("AS,KS")).size
+    assert_equal 620, @repository.list_and_group_by_hand_score(:starting_hand => StartingHand.new("AS,KS")).size
   end
 
   test "should return every distinct poker hand that can be made with the given starting hand and deck" do
     deck = Deck.new.remove "AH,KH,AD,KD"
-    assert_equal 594, @repository.list_unique(:starting_hand => StartingHand.new("AS,KS"), :deck => deck).size
+    assert_equal 594, @repository.list_and_group_by_hand_score(:starting_hand => StartingHand.new("AS,KS"), :deck => deck).size
   end
 
   test "should return every distinct poker hand that can be made with the given starting hand, flop, turn and river" do
-    assert_equal 21, @repository.list_unique(:starting_hand => StartingHand.new("AS,KS"), :board => Board.new("QS,JS,TS,4H,3H")).size
+    assert_equal 21, @repository.list_and_group_by_hand_score(:starting_hand => StartingHand.new("AS,KS"), :board => Board.new("QS,JS,TS,4H,3H")).size
   end
 
   test "should return every distinct poker hand that can be made with the given starting hand, flop and turn" do
-    assert_equal 212, @repository.list_unique(:starting_hand => StartingHand.new("AS,KS"), :board => Board.new("QS,JS,TS,4H")).size
+    assert_equal 212, @repository.list_and_group_by_hand_score(:starting_hand => StartingHand.new("AS,KS"), :board => Board.new("QS,JS,TS,4H")).size
   end
 
   test "should return every distinct poker hand that can be made with the given starting hand and flop" do
-    assert_equal 1042, @repository.list_unique(:starting_hand => StartingHand.new("AS,KS"), :board => Board.new("QS,JS,TS")).size
+    assert_equal 1042, @repository.list_and_group_by_hand_score(:starting_hand => StartingHand.new("AS,KS"), :board => Board.new("QS,JS,TS")).size
   end
 
   test "should return every distinct poker hand that can be made with the given starting hand, flop and deck" do
     deck = Deck.new.remove "AH,KH,AD,KD"
-    assert_equal 1030, @repository.list_unique(:starting_hand => StartingHand.new("AS,KS"), :board => Board.new("QS,JS,TS"), :deck => deck).size
+    assert_equal 1030, @repository.list_and_group_by_hand_score(:starting_hand => StartingHand.new("AS,KS"), :board => Board.new("QS,JS,TS"), :deck => deck).size
   end
 
 end