acpc_poker_types 0.0.10 → 1.0.0

data/spec/pile_of_cards_spec.rb

@@ -3,21 +3,21 @@
 require File.expand_path('../support/spec_helper', __FILE__)
 
 require 'hand_evaluator'
+require 'acpc_poker_types/card'
+require 'acpc_poker_types/pile_of_cards'
+require 'acpc_poker_types/rank'
+require 'acpc_poker_types/suit'
 
-require File.expand_path("#{LIB_ACPC_POKER_TYPES_PATH}/card", __FILE__)
-
-require File.expand_path("#{LIB_ACPC_POKER_TYPES_PATH}/pile_of_cards", __FILE__)
-
-describe PileOfCards do
+describe AcpcPokerTypes::PileOfCards do
   describe '#to_poker_hand_strength' do
     it 'attributes zero hand strength to an empty hand' do
-      patient = PileOfCards.new
+      patient = AcpcPokerTypes::PileOfCards.new
       hand_strength = 0
 
-      patient.to_poker_hand_strength.to_i.should be == hand_strength
+      patient.to_poker_hand_strength.to_i.must_equal hand_strength
     end
     it "can calculate the Texas hold'em poker hand strength for itself for a seven card set" do
-      patient = PileOfCards.new
+      patient = AcpcPokerTypes::PileOfCards.new
       cards = []
       for_every_card do |card|
         patient << card
@@ -26,10 +26,10 @@ describe PileOfCards do
       end
       hand_strength = HandEvaluator.rank_hand cards.map { |card| card.to_i }
 
-      patient.to_poker_hand_strength.should be == hand_strength
+      patient.to_poker_hand_strength.must_equal hand_strength
     end
     it 'attributes the maximum hand strength to a hand with all the cards in the deck' do
-      patient = PileOfCards.new
+      patient = AcpcPokerTypes::PileOfCards.new
       cards = []
       for_every_card do |card|
         patient << card
@@ -37,13 +37,13 @@ describe PileOfCards do
       end
       hand_strength = HandEvaluator.rank_hand cards.map { |card| card.to_i }
 
-      patient.to_poker_hand_strength.should be == hand_strength
+      patient.to_poker_hand_strength.must_equal hand_strength
     end
 
     def for_every_card
-      Rank::DOMAIN.map do |rank, rank_properties|
-        Suit::DOMAIN.map do |suit, suit_properties|
-          yield Card.from_components(rank, suit)
+      AcpcPokerTypes::Rank::DOMAIN.map do |rank, rank_properties|
+        AcpcPokerTypes::Suit::DOMAIN.map do |suit, suit_properties|
+          yield AcpcPokerTypes::Card.from_components(rank, suit)
         end
       end
     end

data/spec/player_spec.rb

@@ -5,15 +5,15 @@ require File.expand_path('../support/spec_helper', __FILE__)
 require 'celluloid'
 
 require 'acpc_dealer'
-require 'acpc_dealer_data'
+require 'acpc_poker_types/acpc_dealer_data/poker_match_data'
 require 'dmorrill10-utils'
 
-require File.expand_path("#{LIB_ACPC_POKER_TYPES_PATH}/player", __FILE__)
-require File.expand_path("#{LIB_ACPC_POKER_TYPES_PATH}/poker_action", __FILE__)
-require File.expand_path("#{LIB_ACPC_POKER_TYPES_PATH}/hand", __FILE__)
-require File.expand_path("#{LIB_ACPC_POKER_TYPES_PATH}/match_state", __FILE__)
+require 'acpc_poker_types/player'
+require 'acpc_poker_types/poker_action'
+require 'acpc_poker_types/hand'
+require 'acpc_poker_types/match_state'
 
-describe Player do
+describe AcpcPokerTypes::Player do
   NAME = 'p1'
   SEAT = '1'
   INITIAL_CHIP_STACK = 100000
@@ -41,24 +41,24 @@ describe Player do
       various_numbers_of_players do |number_of_players|
         game_def.stubs(:number_of_players).returns(number_of_players)
 
-        expect do
-          Player.create_players(
+        -> do
+          AcpcPokerTypes::Player.create_players(
             ((number_of_players-1).times.inject([]) do |names, i|
                names << "p#{i}"
              end
              ),
             game_def
           )
-        end.to raise_exception(Player::IncorrectNumberOfPlayerNames)
-        expect do
-          Player.create_players(
+        end.must_raise(AcpcPokerTypes::Player::IncorrectNumberOfPlayerNames)
+        -> do
+          AcpcPokerTypes::Player.create_players(
             ((number_of_players+1).times.inject([]) do |names, i|
                names << "p#{i}"
              end
              ),
             game_def
           )
-        end.to raise_exception(Player::IncorrectNumberOfPlayerNames)
+        end.must_raise(AcpcPokerTypes::Player::IncorrectNumberOfPlayerNames)
       end
     end
     it 'works properly' do
@@ -67,16 +67,16 @@ describe Player do
         game_def.stubs(:number_of_players).returns(number_of_players)
         game_def.expects(:chip_stacks).times(number_of_players).returns(INITIAL_CHIP_STACK)
 
-        patients = Player.create_players(
+        patients = AcpcPokerTypes::Player.create_players(
           (number_of_players.times.inject([]) do |names, i|
              names << "p#{i}"
           end),
           game_def
         )
 
-        patients.length.should == number_of_players
+        patients.length.must_equal number_of_players
         patients.each do |patient|
-          patient.class.should == Player
+          patient.class.must_equal AcpcPokerTypes::Player
         end
       end
     end
@@ -121,7 +121,7 @@ describe Player do
   end
   describe 'reports it is not active if' do
     it 'it has folded' do
-      action = PokerAction.new :fold, {amount_to_put_in_pot: 0}
+      action = AcpcPokerTypes::PokerAction.new :fold, {amount_to_put_in_pot: 0}
 
       @patient.start_new_hand! BLIND, INITIAL_CHIP_STACK
       @patient.take_action! action
@@ -129,7 +129,7 @@ describe Player do
       @chip_stack = INITIAL_CHIP_STACK - BLIND
       @chip_balance = -BLIND
       @chip_contributions = [BLIND]
-      @hole_cards = Hand.new
+      @hole_cards = AcpcPokerTypes::Hand.new
       @actions_taken_this_hand = [[action]]
       @has_folded = true
       @is_all_in = false
@@ -139,7 +139,7 @@ describe Player do
       check_patient
     end
     it 'it is all-in' do
-      action = PokerAction.new :raise, {amount_to_put_in_pot: INITIAL_CHIP_STACK - BLIND}
+      action = AcpcPokerTypes::PokerAction.new :raise, {amount_to_put_in_pot: INITIAL_CHIP_STACK - BLIND}
 
       hand = default_hand
       @patient.start_new_hand! BLIND, INITIAL_CHIP_STACK, hand
@@ -160,30 +160,30 @@ describe Player do
   end
   describe 'properly changes its state when it wins chips' do
     it 'when the number of chips is an integer' do
-      @patient.chip_balance.should be == 0
+      @patient.chip_balance.must_equal 0
 
       pot_size = 22
       @patient.take_winnings! pot_size
 
-      @patient.chip_stack.should be == INITIAL_CHIP_STACK + pot_size
-      @patient.chip_balance.should be == pot_size
-      @patient.chip_contributions.should be == [0, -pot_size]
+      @patient.chip_stack.must_equal INITIAL_CHIP_STACK + pot_size
+      @patient.chip_balance.must_equal pot_size
+      @patient.chip_contributions.must_equal [0, -pot_size]
     end
     it 'when the number of chips is a rational' do
-      @patient.chip_balance.should be == 0
+      @patient.chip_balance.must_equal 0
 
       pot_size = 22/3.to_r
       @patient.take_winnings! pot_size
 
-      @patient.chip_stack.should be == INITIAL_CHIP_STACK + pot_size
-      @patient.chip_balance.should be == pot_size
-      @patient.chip_contributions.should be == [0, -pot_size]
+      @patient.chip_stack.must_equal INITIAL_CHIP_STACK + pot_size
+      @patient.chip_balance.must_equal pot_size
+      @patient.chip_contributions.must_equal [0, -pot_size]
     end
   end
   it 'works properly over samples of data from the ACPC Dealer' do
     dealer_log_directory = File.expand_path('../support/dealer_logs', __FILE__)
     match_logs.each do |log_description|
-      match = AcpcDealerData::PokerMatchData.parse_files(
+      match =  AcpcPokerTypes::AcpcDealerData::PokerMatchData.parse_files(
         "#{dealer_log_directory}/#{log_description.actions_file_name}",
         "#{dealer_log_directory}/#{log_description.results_file_name}",
         log_description.player_names,
@@ -191,7 +191,7 @@ describe Player do
         40
       )
       match.for_every_seat! do |seat|
-        @patient = Player.join_match(
+        @patient = AcpcPokerTypes::Player.join_match(
           match.match_def.player_names[seat],
           seat,
           match.match_def.game_def.chip_stacks[seat]
@@ -222,40 +222,40 @@ describe Player do
               @patient.take_winnings!(match.current_hand.chip_distribution[seat] + match.match_def.game_def.blinds[seat])
             end
 
-            @patient.name.should == match.player.name
-            @patient.seat.should == seat
-            @patient.hole_cards.should == match.player.hole_cards
-            @patient.actions_taken_this_hand.reject_empty_elements.should == match.player.actions_taken_this_hand.reject_empty_elements
+            @patient.name.must_equal match.player.name
+            @patient.seat.must_equal seat
+            @patient.hole_cards.must_equal match.player.hole_cards
+            @patient.actions_taken_this_hand.reject_empty_elements.must_equal match.player.actions_taken_this_hand.reject_empty_elements
 
-            @patient.folded?.should == match.player.folded?
-            @patient.all_in?.should == match.player.all_in?
-            @patient.active?.should == match.player.active?
-            @patient.round.should == match.current_hand.current_match_state.round
+            @patient.folded?.must_equal match.player.folded?
+            @patient.all_in?.must_equal match.player.all_in?
+            @patient.active?.must_equal match.player.active?
+            @patient.round.must_equal match.current_hand.current_match_state.round
           end
 
-          @patient.chip_balance.should == match.player.chip_balance
+          @patient.chip_balance.must_equal match.player.chip_balance
         end
       end
     end
   end
 
   def check_patient
-    @patient.name.should == @name
-    @patient.seat.should == @seat
-    @patient.chip_stack.should == @chip_stack
-    @patient.chip_contributions.should == @chip_contributions
-    @patient.chip_balance.should == @chip_balance
+    @patient.name.must_equal @name
+    @patient.seat.must_equal @seat
+    @patient.chip_stack.must_equal @chip_stack
+    @patient.chip_contributions.must_equal @chip_contributions
+    @patient.chip_balance.must_equal @chip_balance
     if @hole_cards
-      (@patient.hole_cards.map { |card| card.to_s} ).should == @hole_cards.map { |card| card.to_s }
+      (@patient.hole_cards.map { |card| card.to_s} ).must_equal @hole_cards.map { |card| card.to_s }
     else
-      @patient.hole_cards.should be nil
+      @patient.hole_cards.must_be_nil
     end
 
-    @patient.actions_taken_this_hand.should == @actions_taken_this_hand
-    @patient.folded?.should == @has_folded
-    @patient.all_in?.should == @is_all_in
-    @patient.active?.should == @is_active
-    @patient.round.should == @round
+    @patient.actions_taken_this_hand.must_equal @actions_taken_this_hand
+    @patient.folded?.must_equal @has_folded
+    @patient.all_in?.must_equal @is_all_in
+    @patient.active?.must_equal @is_active
+    @patient.round.must_equal @round
   end
   def various_numbers_of_players
     (1..100).each do |number_of_players|
@@ -329,18 +329,18 @@ end
   end
   def instantiate_each_action_from_symbols(amount_to_put_in_pot=0,
                                            modifier=nil)
-    PokerAction::LEGAL_SYMBOLS.each do |sym|
-      modifier = if PokerAction::MODIFIABLE_ACTIONS.keys.include? sym
+    AcpcPokerTypes::PokerAction::LEGAL_SYMBOLS.each do |sym|
+      modifier = if AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.keys.include? sym
         modifier
       else
         nil
       end
 
-      action = mock 'PokerAction'
+      action = mock 'AcpcPokerTypes::PokerAction'
       action.stubs(:to_sym).returns(sym)
       action.stubs(:to_s).returns(sym.to_s + modifier.to_s)
-      action.stubs(:to_acpc).returns(PokerAction::LEGAL_ACTIONS[sym] + modifier.to_s)
-      action.stubs(:to_acpc_character).returns(PokerAction::LEGAL_ACTIONS[sym])
+      action.stubs(:to_acpc).returns(AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[sym] + modifier.to_s)
+      action.stubs(:to_acpc_character).returns(AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[sym])
       action.stubs(:amount_to_put_in_pot).returns(amount_to_put_in_pot)
       action.stubs(:modifier).returns(modifier)
 
@@ -393,21 +393,21 @@ end
     end
   end
   def default_hand
-    hidden_cards = Hand.new
+    hidden_cards = AcpcPokerTypes::Hand.new
 
     hidden_cards
   end
   def init_patient!
-    @patient = Player.join_match @name, @seat, @chip_stack
+    @patient = AcpcPokerTypes::Player.join_match @name, @seat, @chip_stack
   end
-  def init_new_hand_data!(type=nil)
+  def init_new_hand_data!
     @actions_taken_this_hand = [[]]
-    init_new_hand_chip_data! type
+    init_new_hand_chip_data!
   end
-  def init_new_hand_chip_data!(type=nil)
+  def init_new_hand_chip_data!
     # @todo Assumes Doyle's Game
-    @chip_contributions = [if type then @blinds[@seat] else BLIND end]
+    @chip_contributions = [BLIND]
     @chip_balance = -@chip_contributions.first
-    @chip_stack = (if type then DealerData::GAME_DEFS[type][:stack_size] else INITIAL_CHIP_STACK end) - @chip_contributions.first
+    @chip_stack = INITIAL_CHIP_STACK - @chip_contributions.first
   end
 end

data/spec/poker_action_spec.rb

@@ -2,50 +2,50 @@
 # Spec helper (must include first to track code coverage with SimpleCov)
 require File.expand_path('../support/spec_helper', __FILE__)
 
-require File.expand_path("#{LIB_ACPC_POKER_TYPES_PATH}/poker_action", __FILE__)
+require 'acpc_poker_types/poker_action'
 
-describe PokerAction do
+describe AcpcPokerTypes::PokerAction do
   describe 'legal actions can be retrieved' do
     it 'with ::LEGAL_ACTIONS' do
-      PokerAction::LEGAL_ACTIONS.should_not be_empty
+      AcpcPokerTypes::PokerAction::LEGAL_ACTIONS.wont_be_empty
     end
 
     it 'in symbol format' do
-      PokerAction::LEGAL_SYMBOLS.should_not be_empty
+      AcpcPokerTypes::PokerAction::LEGAL_SYMBOLS.wont_be_empty
     end
 
     it 'in string format' do
-      PokerAction::LEGAL_STRINGS.should_not be_empty
+      AcpcPokerTypes::PokerAction::LEGAL_STRINGS.wont_be_empty
     end
 
     it 'in acpc format' do
-      PokerAction::LEGAL_ACPC_CHARACTERS.should_not be_empty
+      AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.wont_be_empty
     end
   end
 
   describe '#new' do
     it 'raises an exception if the given action is invalid' do
-      expect{PokerAction.new(:not_an_action)}.to raise_exception(PokerAction::IllegalPokerAction)
+      ->{AcpcPokerTypes::PokerAction.new(:not_an_action)}.must_raise(AcpcPokerTypes::PokerAction::IllegalPokerAction)
     end
     it 'raises an exception if a modifier accompanies an unmodifiable action' do
-      unmodifiable_actions = PokerAction::LEGAL_SYMBOLS - PokerAction::MODIFIABLE_ACTIONS.keys
+      unmodifiable_actions = AcpcPokerTypes::PokerAction::LEGAL_SYMBOLS - AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.keys
       unmodifiable_actions.each do |sym|
-        expect{PokerAction.new(sym, {modifier: default_modifier})}.to raise_exception(PokerAction::IllegalPokerActionModification)
+        ->{AcpcPokerTypes::PokerAction.new(sym, {modifier: default_modifier})}.must_raise(AcpcPokerTypes::PokerAction::IllegalPokerActionModification)
       end
     end
     it 'raise an exception if a modifier is given both implicitly and explicitly' do
-      expect{PokerAction.new('r9001', {modifier: default_modifier})}.to raise_exception(PokerAction::IllegalPokerActionModification)
+      ->{AcpcPokerTypes::PokerAction.new('r9001', {modifier: default_modifier})}.must_raise(AcpcPokerTypes::PokerAction::IllegalPokerActionModification)
     end
     it 'raise an exception if a fold action is given when no wager is seen by the acting player' do
-      expect{PokerAction.new('f', {acting_player_sees_wager: false})}.to raise_exception(PokerAction::IllegalPokerAction)
+      ->{AcpcPokerTypes::PokerAction.new('f', {acting_player_sees_wager: false})}.must_raise(AcpcPokerTypes::PokerAction::IllegalPokerAction)
     end
     describe 'creates actions properly' do
       it 'from various forms' do
         various_amounts_to_put_in_pot do |amount|
           with_and_without_a_modifier do |modifier|
             instantiate_each_action_from_acpc_characters(amount, modifier) do |char, actual_modifier|
-              check_patient_data PokerAction::LEGAL_ACTIONS.key(char),
-                PokerAction::LEGAL_ACTIONS.key(char).to_s + actual_modifier.to_s,
+              check_patient_data AcpcPokerTypes::PokerAction::LEGAL_ACTIONS.key(char),
+                AcpcPokerTypes::PokerAction::LEGAL_ACTIONS.key(char).to_s + actual_modifier.to_s,
                 char + actual_modifier.to_s,
                 char,
                 amount,
@@ -54,22 +54,22 @@ describe PokerAction do
             instantiate_each_action_from_strings(amount, modifier) do |string, actual_modifier|
               check_patient_data string.to_sym,
                 string + actual_modifier.to_s,
-                PokerAction::LEGAL_ACTIONS[string.to_sym] + actual_modifier.to_s,
-                PokerAction::LEGAL_ACTIONS[string.to_sym],
+                AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[string.to_sym] + actual_modifier.to_s,
+                AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[string.to_sym],
                 amount,
                 actual_modifier
             end
             instantiate_each_action_from_symbols(amount, modifier) do |sym, actual_modifier|
               check_patient_data sym,
                 sym.to_s + actual_modifier.to_s,
-                PokerAction::LEGAL_ACTIONS[sym] + actual_modifier.to_s,
-                PokerAction::LEGAL_ACTIONS[sym],
+                AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[sym] + actual_modifier.to_s,
+                AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[sym],
                 amount,
                 actual_modifier
             end
             instantiate_each_action_from_modified_acpc_characters(amount, modifier) do |char, actual_modifier|
-              check_patient_data PokerAction::LEGAL_ACTIONS.key(char),
-                PokerAction::LEGAL_ACTIONS.key(char).to_s + actual_modifier.to_s,
+              check_patient_data AcpcPokerTypes::PokerAction::LEGAL_ACTIONS.key(char),
+                AcpcPokerTypes::PokerAction::LEGAL_ACTIONS.key(char).to_s + actual_modifier.to_s,
                 char + actual_modifier.to_s,
                 char,
                 amount,
@@ -78,8 +78,8 @@ describe PokerAction do
             instantiate_each_action_from_modified_strings(amount, modifier) do |string, actual_modifier|
               check_patient_data string.to_sym,
                 string + actual_modifier.to_s,
-                PokerAction::LEGAL_ACTIONS[string.to_sym] + actual_modifier.to_s,
-                PokerAction::LEGAL_ACTIONS[string.to_sym],
+                AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[string.to_sym] + actual_modifier.to_s,
+                AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[string.to_sym],
                 amount,
                 actual_modifier
             end
@@ -90,25 +90,25 @@ describe PokerAction do
   end
   describe 'given knowledge that the acting player does not see a wager' do
     it 'properly changes the given action to its more precise form' do
-      PokerAction::HIGH_RESOLUTION_ACTION_CONVERSION.each do |imprecise_action, precise_action|
+      AcpcPokerTypes::PokerAction::HIGH_RESOLUTION_ACTION_CONVERSION.each do |imprecise_action, precise_action|
         next if :fold == imprecise_action
-        imprecise_action_character = PokerAction::LEGAL_ACTIONS[imprecise_action]
-        precise_action_character = PokerAction::LEGAL_ACTIONS[precise_action]
-        if PokerAction::MODIFIABLE_ACTIONS.values.include? imprecise_action_character
+        imprecise_action_character = AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[imprecise_action]
+        precise_action_character = AcpcPokerTypes::PokerAction::LEGAL_ACTIONS[precise_action]
+        if AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.values.include? imprecise_action_character
           modifier = default_modifier
           expected_acpc_form = precise_action_character + modifier.to_s
         else
           modifier = nil
           expected_acpc_form = precise_action_character
         end
-        PokerAction.new(imprecise_action_character, {modifier: modifier, acting_player_sees_wager: false}).to_acpc.should ==(expected_acpc_form)
+        AcpcPokerTypes::PokerAction.new(imprecise_action_character, {modifier: modifier, acting_player_sees_wager: false}).to_acpc.must_equal(expected_acpc_form)
       end
     end
   end
 
   def default_modifier
     modifier_amount = 9001
-    modifier = mock 'ChipStack'
+    modifier = mock 'AcpcPokerTypes::ChipStack'
     modifier.stubs(:to_s).returns(modifier_amount.to_s)
     modifier
   end
@@ -128,78 +128,78 @@ describe PokerAction do
                          expected_acpc_character,
                          amount_to_put_in_pot=0,
                          modifier=nil)
-    @patient.to_sym.should be == expected_sym
-    @patient.to_s.should be == expected_string
-    @patient.to_acpc.should be == expected_acpc
-    @patient.to_acpc_character.should be == expected_acpc_character
-    @patient.amount_to_put_in_pot.should be == amount_to_put_in_pot
+    @patient.to_sym.must_equal expected_sym
+    @patient.to_s.must_equal expected_string
+    @patient.to_acpc.must_equal expected_acpc
+    @patient.to_acpc_character.must_equal expected_acpc_character
+    @patient.amount_to_put_in_pot.must_equal amount_to_put_in_pot
 
     has_modifier = !modifier.nil?
-    @patient.has_modifier?.should be == has_modifier
+    @patient.has_modifier?.must_equal has_modifier
   end
   def instantiate_each_action_from_symbols(amount_to_put_in_pot=0,
                                            modifier=nil)
-    PokerAction::LEGAL_SYMBOLS.each do |sym|
-      modifier = if PokerAction::MODIFIABLE_ACTIONS.keys.include? sym
+    AcpcPokerTypes::PokerAction::LEGAL_SYMBOLS.each do |sym|
+      modifier = if AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.keys.include? sym
         modifier
       else
         nil
       end
 
-      @patient = PokerAction.new(sym, {amount_to_put_in_pot: amount_to_put_in_pot, modifier: modifier})
+      @patient = AcpcPokerTypes::PokerAction.new(sym, {amount_to_put_in_pot: amount_to_put_in_pot, modifier: modifier})
       yield sym, modifier
     end
   end
   def instantiate_each_action_from_strings(amount_to_put_in_pot=0,
                                            modifier=nil)
-    PokerAction::LEGAL_STRINGS.each do |string|
-      modifier = if PokerAction::MODIFIABLE_ACTIONS.keys.include? string.to_sym
+    AcpcPokerTypes::PokerAction::LEGAL_STRINGS.each do |string|
+      modifier = if AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.keys.include? string.to_sym
         modifier
       else
         nil
       end
 
-      @patient = PokerAction.new(string, {amount_to_put_in_pot: amount_to_put_in_pot, modifier: modifier})
+      @patient = AcpcPokerTypes::PokerAction.new(string, {amount_to_put_in_pot: amount_to_put_in_pot, modifier: modifier})
       yield string, modifier
     end
   end
   def instantiate_each_action_from_modified_strings(amount_to_put_in_pot=0,
                                                     modifier=nil)
     unless modifier
-      modifier = mock('ChipStack')
+      modifier = mock('AcpcPokerTypes::ChipStack')
       modifier.stubs(:to_s).returns('9001')
     end
-    PokerAction::MODIFIABLE_ACTIONS.values.each do |char|
-      string = PokerAction::LEGAL_ACTIONS.key(char).to_s
+    AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.values.each do |char|
+      string = AcpcPokerTypes::PokerAction::LEGAL_ACTIONS.key(char).to_s
       modified_action = string + modifier.to_s
 
-      @patient = PokerAction.new(modified_action, {amount_to_put_in_pot: amount_to_put_in_pot})
+      @patient = AcpcPokerTypes::PokerAction.new(modified_action, {amount_to_put_in_pot: amount_to_put_in_pot})
       yield string, modifier
     end
   end
   def instantiate_each_action_from_acpc_characters(amount_to_put_in_pot=0,
                                                    modifier=nil)
-    PokerAction::LEGAL_ACPC_CHARACTERS.each do |char|
-      modifier = if PokerAction::MODIFIABLE_ACTIONS.values.include? char
+    AcpcPokerTypes::PokerAction::LEGAL_ACPC_CHARACTERS.each do |char|
+      modifier = if AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.values.include? char
         modifier
       else
         nil
       end
 
-      @patient = PokerAction.new(char, {amount_to_put_in_pot: amount_to_put_in_pot, modifier: modifier})
+      @patient = AcpcPokerTypes::PokerAction.new(char, {amount_to_put_in_pot: amount_to_put_in_pot, modifier: modifier})
       yield char, modifier
     end
   end
   def instantiate_each_action_from_modified_acpc_characters(amount_to_put_in_pot=0,
                                                             modifier=nil)
     unless modifier
-      modifier = mock('ChipStack')
+      modifier = mock('AcpcPokerTypes::ChipStack')
       modifier.stubs(:to_s).returns('9001')
     end
-    PokerAction::MODIFIABLE_ACTIONS.values.each do |char|
+    AcpcPokerTypes::PokerAction::MODIFIABLE_ACTIONS.values.each do |char|
       modified_action = char + modifier.to_s
 
-      @patient = PokerAction.new(modified_action, {amount_to_put_in_pot: amount_to_put_in_pot})
+      @patient = AcpcPokerTypes::PokerAction.new(modified_action, {amount_to_put_in_pot: amount_to_put_in_pot})
       yield char, modifier
     end
   end