acpc_poker_match_state 0.0.2 → 0.0.3

data/spec/players_at_the_table_integ_spec.rb

@@ -1,240 +0,0 @@
-
-require File.expand_path('../support/spec_helper', __FILE__)
-
-require 'acpc_dealer'
-require 'acpc_dealer_data'
-
-require File.expand_path('../../lib/acpc_poker_match_state/players_at_the_table', __FILE__)
-
-describe PlayersAtTheTable do
-  describe '#update!' do
-    it "keeps track of state for a sequence of match states and actions in Doyle's game" do
-      num_hands = 15
-      match_logs.each do |log_description|
-        @match = PokerMatchData.parse_files(
-          log_description.actions_file_path,
-          log_description.results_file_path,
-          log_description.player_names,
-          AcpcDealer::DEALER_DIRECTORY,
-          num_hands
-        )
-        @match.for_every_seat! do |users_seat|
-
-          @patient = PlayersAtTheTable.seat_players(
-            @match.match_def.game_def,
-            (@match.players.map{ |player| player.name }),
-            users_seat,
-            num_hands
-          )
-
-          check_patient
-
-          @match.for_every_hand! do
-            @match.for_every_turn! do
-              @patient.update! @match.current_hand.current_match_state
-
-              check_patient
-            end
-          end
-        end
-      end
-    end
-  end
-
-  def check_patient(patient=@patient)
-    patient.player_acting_sequence.should == @match.player_acting_sequence
-    patient.number_of_players.should == @match.players.length
-    if @match.current_hand && @match.current_hand.last_action
-      patient.player_who_acted_last.seat.should == @match.current_hand.last_action.seat
-    else
-      patient.player_who_acted_last.should be nil
-    end
-    if @match.current_hand && @match.current_hand.next_action
-      patient.next_player_to_act.seat.should == @match.current_hand.next_action.seat
-    else
-      patient.next_player_to_act.should be nil
-    end
-    if @match.current_hand && @match.current_hand.final_turn?
-      patient.players.players_close_enough?(@match.players).should == true
-      patient.user_player.close_enough?(@match.player).should == true
-      patient.opponents.players_close_enough?(@match.opponents).should == true
-      patient.non_folded_players.players_close_enough?(@match.non_folded_players).should == true
-      patient.active_players.players_close_enough?(@match.active_players).should == true
-      patient.player_with_dealer_button.close_enough?(@match.player_with_dealer_button).should == true
-      check_player_blind_relation(patient)
-      patient.chip_stacks.should == @match.chip_stacks
-      patient.chip_balances.should == @match.chip_balances
-      patient.chip_contributions.sum.should == @match.chip_contributions.sum
-    end
-    patient.opponents_cards_visible?.should == @match.opponents_cards_visible?
-    patient.reached_showdown?.should == @match.opponents_cards_visible?
-    patient.less_than_two_non_folded_players?.should == @match.non_folded_players.length < 2
-    if @match.current_hand
-      patient.hand_ended?.should == @match.current_hand.final_turn?
-      patient.match_ended?.should == (@match.final_hand? && @match.current_hand.final_turn?)
-    end
-    patient.last_hand?.should == if @match.final_hand?.nil?
-      false
-    else
-      @match.final_hand?
-    end
-    patient.player_acting_sequence_string.should == @match.player_acting_sequence_string
-    patient.users_turn_to_act?.should == @match.users_turn_to_act?
-    check_betting_sequence(patient)
-    # @todo Test this eventually
-    # patient.min_wager.to_i.should == @min_wager.to_i
-  end
-
-  def check_player_blind_relation(patient)
-    expected_player_blind_relation = @match.player_blind_relation
-    patient.player_blind_relation.each do |player, blind|
-      expected_player_and_blind = expected_player_blind_relation.to_a.find do |player_and_blind| 
-        player_and_blind.first.seat == player.seat
-      end
-
-      expected_player = expected_player_and_blind.first
-      expected_blind = expected_player_and_blind.last
-
-      player.close_enough?(expected_player).should == true
-      blind.should == expected_blind
-    end
-  end
-  def check_betting_sequence(patient)
-    patient_betting_sequence = patient.betting_sequence.map do |actions| 
-        actions.map { |action| action.to_low_res_acpc }
-    end
-    expected_betting_sequence = @match.betting_sequence.map do |actions| 
-      actions.map { |action| action.to_low_res_acpc }
-    end
-    patient_betting_sequence.should == expected_betting_sequence
-    
-    patient.betting_sequence_string.scan(/([a-z]\d*|\/)/).flatten.map do |action| 
-      if action.match(/\//)
-        action
-      else
-        PokerAction.new(action).to_low_res_acpc
-      end
-    end.join('').should == @match.betting_sequence_string
-  end
-end
-
-
-# @todo Move these into utils
-
-require 'awesome_print'
- 
-# @param [#to_s] message The message to log.
-def log_message(message)
-  puts message.to_s
-end
-
-def debug(variables)
-  log_message variables.awesome_inspect
-end
-
-############
-
-class Array
-  def players_close_enough?(other_players)
-    # puts "length: #{length}, other: #{other_players.length}"
-
-    return false if other_players.length != length
-    each_with_index do |player, index|
-      return false unless player.close_enough?(other_players[index])
-    end
-    true
-  end
-  def reject_empty_elements
-    reject do |elem|
-      elem.empty?
-    end
-  end
-end
-
-# @todo Move these into their respective classes
-class PokerMatchData
-  # @todo Untested
-  # @return [String] player acting sequence as a string.
-  def player_acting_sequence_string
-    (player_acting_sequence.map { |per_round| per_round.join('') }).join('/')
-  end
-  def users_turn_to_act?
-    return false unless current_hand && current_hand.next_action
-    current_hand.next_action.seat == @seat
-  end
-  def betting_sequence
-    sequence = [[]]
-    
-    if (
-      @hand_number.nil? || 
-      current_hand.turn_number.nil? || 
-      current_hand.turn_number < 1
-    )
-      return sequence
-    end
-      
-    turns_taken = current_hand.data[0..current_hand.turn_number-1]
-    turns_taken.each_with_index do |turn, turn_index|
-      next unless turn.action_message
-
-      sequence[turn.action_message.state.round] << turn.action_message.action
-
-      if (
-        new_round?(sequence.length - 1 , turn_index) ||
-        players_all_in?(sequence.length - 1, turn_index, turns_taken)
-      )
-        sequence << []
-      end
-    end
-
-    sequence
-  end
-  def betting_sequence_string
-    (betting_sequence.map do |per_round|
-       (per_round.map{|action| action.to_acpc}).join('')
-    end).join('/')
-  end
-  # @todo Test and implement this
-  # def min_wager
-  #   return nil unless current_hand
-
-  #   @match_def.game_def.min_wagers[current_hand.next_state.round]
-  #   ChipStack.new [@min_wager.to_i, action_with_context.amount_to_put_in_pot.to_i].max
-  # end
-end
-class PokerAction
-  # @return [Hash] Map of specific to general actions to more specific actions (e.g. check to call and bet to raise).
-  LOW_RESOLUTION_ACTION_CONVERSION = {call: :call, raise: :raise, fold: :fold, check: :call, bet: :raise}
-
-  def to_low_res_acpc
-    LEGAL_ACTIONS[LOW_RESOLUTION_ACTION_CONVERSION[@symbol]] + @modifier.to_s
-  end
-end
-class Player
-  def acpc_actions_taken_this_hand
-    acpc_actions = @actions_taken_this_hand.map do |actions_per_turn| 
-      actions_per_turn.map { |action| action.to_low_res_acpc }
-    end
-    if acpc_actions.first.empty?
-      acpc_actions
-    else
-      acpc_actions.reject_empty_elements
-    end
-  end
-
-  def close_enough?(other)
-    # puts "name: #{name == other.name}"
-    # puts "seat: #{seat == other.seat}"
-    # puts "chip_stack: #{chip_stack}, other: #{other.chip_stack}"
-    # puts "chip balances: #{chip_balance}, other: #{other.chip_balance}"
-    # puts "actions_taken_this_hand: #{acpc_actions_taken_this_hand}, other: #{other.acpc_actions_taken_this_hand}"
-    # puts "all_in: #{all_in?}, other: #{other.all_in?}"
-
-
-    @name == other.name &&
-    @seat == other.seat && 
-    @chip_stack == other.chip_stack &&
-    @chip_balance == other.chip_balance &&
-    acpc_actions_taken_this_hand == other.acpc_actions_taken_this_hand
-  end
-end

data/spec/support/model_test_helper.rb

@@ -1,56 +0,0 @@
-
-# Gems
-require 'acpc_poker_types'
-
-# Assortment of methods to support model tests
-module ModelTestHelper
-   
-   # Initialization methods ---------------------------------------------------      
-   def create_players(big_blind, small_blind)
-      player_who_submitted_big_blind = mock('Player')
-      player_who_submitted_big_blind.stubs(:current_wager_faced=).with(0)
-      player_who_submitted_big_blind.stubs(:current_wager_faced).returns(0)
-      player_who_submitted_big_blind.stubs(:name).returns('big_blind_player')
-      
-      player_who_submitted_small_blind = mock('Player')
-      player_who_submitted_small_blind.stubs(:current_wager_faced=).with(big_blind - small_blind)
-      player_who_submitted_small_blind.stubs(:current_wager_faced).returns(big_blind - small_blind)
-      player_who_submitted_small_blind.stubs(:name).returns('small_blind_player')
-      
-      other_player = mock('Player')
-      other_player.stubs(:current_wager_faced=).with(big_blind)
-      other_player.stubs(:current_wager_faced).returns(big_blind)
-      other_player.stubs(:name).returns('other_player')
-      
-      [player_who_submitted_big_blind, player_who_submitted_small_blind, other_player]
-   end
-      
-   def setup_action_test(match_state, action_type, action_argument = '')
-      action = action_argument + action_type
-      expected_string = raw_match_state match_state, action
-      
-      expected_string
-   end
-   
-   
-   # Helper methods -----------------------------------------------------------
-
-   def raw_match_state(match_state, action)
-      "#{match_state}:#{action}"
-   end
-   
-   # Construct an arbitrary hole card hand.
-   #
-   # @return [Mock Hand] An arbitrary hole card hand.
-   def arbitrary_hole_card_hand
-      hand = mock('Hand')
-      hand_as_string = AcpcPokerTypes::CARD_RANKS[:two]
-         + AcpcPokerTypes::CARD_SUITS[:spades][:acpc_character]
-         + AcpcPokerTypes::CARD_RANKS[:three]
-         + AcpcPokerTypes::CARD_SUITS[:hearts][:acpc_character]
-      hand.stubs(:to_str).returns(hand_as_string)
-      hand.stubs(:to_s).returns(hand_as_string)
-      
-      hand
-   end
-end

data/spec/support/test_example.rb

@@ -1,74 +0,0 @@
-
-class Symbol
-   def to_setter_signature
-      "#{self}=".to_sym
-   end
-end
-
-require 'dmorrill10-utils'
-
-# @todo This was an attempt at organizing tests better but it didn't make tests any nicer.
-#  I would get rid of it, but it's still being used, so it will stay for now.
-class TestExample
-   
-   exceptions :no_properties_for_given, :no_properties_for_then
-   
-   attr_reader :description, :given, :then
-   
-   def initialize(example_description, example_data_catagories)
-      @description = example_description
-      
-      @given = {}
-      @then = {}
-      
-      given_properties = example_data_catagories[:given]
-      
-      raise NoPropertiesForGiven unless given_properties
-      
-      then_properties = example_data_catagories[:then]
-      
-      raise NoPropertiesForThen unless then_properties
-      
-      given_properties.each do |property|
-         define_getter_and_setter @given, property
-      end
-      
-      then_properties.each do |property|
-         define_getter_and_setter @then, property
-      end
-   end
-   
-   def to_s
-      given_as_string = partition_to_string @given
-      then_as_string = partition_to_string @then
-      
-      "#{@description}: given: #{given_as_string}, then: #{then_as_string}"
-   end
-   
-   private
-   
-   def partition_to_string(partition)
-      partition.map do |key_value_pair|
-         key_value_pair.join(' is ')
-      end.join(', and')
-   end
-   
-   def define_getter_and_setter(instance_on_which_to_define, property)
-      define_getter instance_on_which_to_define, property
-      define_setter instance_on_which_to_define, property
-   end
-   
-   def define_getter(instance_on_which_to_define, property)
-      signature = property.to_sym
-      instance_on_which_to_define.singleton_class.send(:define_method, signature) do
-         instance_on_which_to_define[property.to_sym]
-      end
-   end
-   
-   def define_setter(instance_on_which_to_define, property)
-      signature = property.to_sym.to_setter_signature
-      instance_on_which_to_define.singleton_class.send(:define_method, signature) do |to_set|
-         store(property.to_sym, to_set)
-      end
-   end
-end