rholdem 0.0.1

data/spec/game_spec.rb

@@ -0,0 +1,565 @@
+require File.dirname(__FILE__) + "/../lib/game"
+include Holdem
+
+describe Game do
+  before(:each) do
+    @g = Game.new(5.0)
+  end
+  
+  it "should be creatable with small bet size (5 in a 5/10 game)" do
+    @g.should_not be_nil
+  end
+  
+  it "should set the small blind correctly" do
+    @g.sb.should == 2.5
+  end
+
+  it "should set the big blind correctly" do
+    @g.bb.should == 5.0
+  end
+  
+  it "should be the pre-flop round" do
+    @g.round.should == :preflop
+  end
+  
+  it "should get a new Deck to play with (pre-shuffled)" do
+    @g.deck.is_a?(Deck).should be_true
+  end
+  
+  it "should have no known winners" do
+    @g.winners.should == []
+  end
+  
+  it "should not have any cards on the board" do
+    @g.board.should == []
+  end
+  
+  it "should create ten players by default" do
+    @g.players.each { |p| p.is_a?(Player).should be_true }
+  end
+  
+  it "should allow a flexible number of players under 10" do
+    game = Game.new(5.0, 8)
+    game.players.length.should == 8
+  end
+  
+  it "should not allow more than 11 players" do
+    lambda { Game.new(5.0, 12) }.should raise_error
+  end
+  
+  it "should require at least 2 players" do
+    lambda { Game.new(5.0, 1) }.should raise_error
+  end
+  
+  it "should collect small blind from first position" do
+    @g.players[0].in_round.should == 2.5
+  end
+  
+  it "should collect big blind from second position" do
+    @g.players[1].in_round.should == 5.0
+  end
+  
+  it "should increment the bets after the blinds are posted" do
+    @g.bets_in_round.should == 1
+  end
+  
+  it "should increment the pot size when a bet is required" do
+    @g.pot.should == 7.5
+  end
+  
+  it "should declare a winner if only one player is left" do
+    @g.players[0..8].each { |p| p.should_receive(:act).at_least(1).and_return(:weak) }
+    @g.players[9].should_receive(:act).once.and_return(:aggressive)
+    @g.run    
+    @g.winners[0].should == @g.players[9]
+  end
+  
+  it "should go straight to the showdown if one player is left" do
+    @g.players[0..8].each { |p| p.should_receive(:act).at_least(1).and_return(:weak) }
+    @g.players[9].should_receive(:act).once.and_return(:aggressive)
+    @g.run
+    @g.round.should == :showdown
+  end
+end
+
+describe Game, "accepting customized players" do
+  module Holdem
+    class CustomPlayer < Holdem::Player
+      attr_reader :position
+      
+      def initialize(position=nil)
+        super() # should call this to init variables, need () so no args are passed
+        @position = position
+      end
+    end
+  end
+  
+  it "should allow the Player class to be overridden" do
+    @g = Game.new(5.0) do
+      CustomPlayer.new
+    end
+    @g.players.each { |p| p.is_a?(CustomPlayer).should be_true }
+  end
+  
+  it "should yield the current player's position if there is a block" do
+    @g = Game.new(5.0) do |position|
+      CustomPlayer.new(position)
+    end
+    (0..9).each do |i|
+      @g.players[i].position.should == i
+    end
+  end
+end
+
+describe Game, "determining when action settled" do
+  before(:each) do
+    @g = Game.new(5.0)
+  end
+    
+  it "should know how much a player owes to continue" do
+    @g.players[2..9].each { |p| @g.owed(p).should == 5.0 }
+    @g.owed(@g.players[0]).should == 2.5
+    @g.owed(@g.players[1]).should == 0.0
+  end
+
+  it "should report betting as settled when all players have acted and there are no open bets" do
+    @g.players.each { |p| p.should_receive(:act).once.with(@g).and_return(:neutral) }
+    @g.run    
+    @g.settled?.should be_true
+  end
+  
+  it "should report 0.0 owed for folded players" do
+    @g.owed(@g.players[5]).should == 5.0
+    @g.players[5].fold
+    @g.owed(@g.players[5]).should == 0.0
+  end
+end
+
+describe Game, "player actions" do
+  before(:each) do
+    @g = Game.new(5.0)
+  end
+  
+  it "should take amount owed plus bet size when betting" do
+    @g.players[0..8].each { |p| p.should_receive(:act).at_least(1).and_return(:neutral) }
+    @g.players[9].should_receive(:act).once.and_return(:aggressive)
+    @g.run
+    @g.pot.should == 100.0
+  end
+  
+  it "should ask each player to act in a round" do
+    @g.players.each { |p| p.should_receive(:act).once.with(@g).and_return(:neutral) }
+    @g.run
+  end
+  
+  it "should increment the bets in round when a bet / raise is made" do
+    @g.players[4].should_receive(:act).once.and_return(:aggressive)
+    [(0..3), (5..9)].each do |range|
+      @g.players[range].each { |p| p.should_receive(:act).at_least(1).and_return(:neutral) }
+    end
+    
+    @g.run
+    @g.bets_in_round.should == 2
+  end
+  
+  it "should stop the round when calling a raiser" do
+    @g.players[4].should_receive(:act).once.and_return(:aggressive)
+    [(0..3), (5..9)].each do |range|
+      @g.players[range].each { |p| p.should_receive(:act).at_least(1).and_return(:neutral) }
+    end
+    @g.run
+    @g.pot.should == 100.0
+  end
+  
+  it "should not increment the bets in round if they are capped" do
+    @g.players.each { |p| p.should_receive(:act).at_least(1).and_return(:aggressive) }
+    @g.run
+    @g.bets_in_round.should == 4
+  end
+  
+  it "should record a players 'true' action" do
+    @g.players.each { |p| p.should_receive(:act).at_least(1).and_return(:aggressive) }
+    @g.run
+    @g.players[8].actions.should_not include(:aggressive)
+  end
+  
+  it "should skip a player if they've folded" do
+    @g.players[5].fold
+    [(0..4), (6..9)].each do |range|
+      @g.players[range].each { |p| p.should_receive(:act).once.and_return(:neutral) }
+    end
+    @g.players[5].should_not_receive(:act)
+    
+    @g.run
+  end
+  
+  it "should not allow a check if a bet is needed" do
+    @g.players.each { |p| p.should_receive(:act).once.and_return(:neutral) }
+    @g.run
+    
+    @g.pot.should == 50.0
+  end
+  
+  it "should fold for a weak action if a call is required" do
+    @g.players[4].should_receive(:act).once.and_return(:weak)
+    @g.run
+    @g.players[4].folded.should be_true
+  end
+  
+  it "should raise an error if an invalid action is given" do
+    @g.players[0].should_receive(:act).once.and_return(:fugazi)
+    lambda { @g.run }.should raise_error
+  end
+  
+  it "should run an entire game if run_game is called" do
+    @g.players.each { |p| p.should_receive(:act).exactly(4).and_return(:neutral) }
+    @g.run_game
+    @g.round.should == :showdown
+  end
+  
+  it "should select the winners" do
+    @g.run_game
+    (@g.winners.length >= 1).should be_true
+  end
+end
+
+describe Game, "pre-flop round" do
+  before(:each) do
+    @g = Game.new(5.0)
+  end
+  
+  it "should set the bet size correctly for first round" do
+    @g.bet_size.should == 5.0
+  end
+  
+  it "should deal two hole cards to each player" do
+    @g.players.each { |p| p.hole_cards.length.should == 2 }
+  end
+  
+  it "should start with the player after the big blind and move around" do
+    (2..5).each do |i|
+      @g.players[i].should_receive(:act).once.and_return(:neutral)
+    end
+    
+    @g.players[6].should_receive(:act).and_raise('Fake Error')
+    
+    [7, 8, 9, 0, 1].each do |i|
+      @g.players[i].should_not_receive(:act)
+    end
+    
+    lambda { @g.run }.should raise_error
+  end
+  
+  it "should allow up to 3 raises" do
+    @g.players.each { |p| p.should_receive(:act).at_least(1).and_return(:aggressive) }
+    @g.run
+    @g.pot.should == 200.0
+  end
+
+  it "should have the player after big blind act first" do
+    @g.should_receive(:do_betting).with(2)
+    @g.run
+  end
+  
+  it "should allow the big blind the option in the pre-flop stage rather than just settling" do
+    [(0..0), (2..9)].each do |range|
+      @g.players[range].each { |p| p.should_receive(:act).twice.and_return(:neutral) }
+    end
+    @g.players[1].should_receive(:act).once.and_return(:aggressive)
+    @g.run
+    @g.pot.should == 100.0
+  end
+  
+  it "should calculate bet size correctly for small blind when first to raise" do
+    @g.players[1..9].each { |p| p.should_receive(:act).at_least(1).and_return(:neutral) }
+    @g.players[0].should_receive(:act).once.and_return(:aggressive)
+    @g.run
+    @g.pot.should == 100.0
+  end
+  
+  it "should increment the round to flop once finished" do
+    @g.run
+    @g.round.should == :flop
+  end
+end
+
+describe Game, "flop round" do
+  before(:each) do
+    @g = Game.new(5.0)
+    @g.run
+  end
+  
+  it "should burn a card before betting starts" do
+    @g.should_receive(:burn).once
+    @g.run
+  end
+  
+  it "should deal 3 cards to the board before betting starts" do
+    @g.run
+    @g.board.length.should == 3
+  end
+  
+  it "should let players find their best hand" do
+    @g.players.each { |p| p.should_receive(:find_hand).once.with(@g.board) }
+    @g.run
+  end
+  
+  it "should have 0 bets in this round before doing betting" do
+    @g.run
+    @g.bets_in_round.should == 0 #checking is default action
+  end
+  
+  it "should reset players amount in round to zero before doing betting" do
+    @g.run
+    @g.players.each { |p| p.in_round.should == 0.0 }
+  end
+  
+  it "should not reset players amount in pot to zero before round" do
+    @g.players.each { |p| p.in_pot.should == 5.0 }
+  end
+  
+  it "should allow 1 bet and 3 raises" do
+    @g.players.each { |p| p.should_receive(:act).at_least(1).and_return(:aggressive) }
+    @g.run    
+    @g.pot.should == 250.0
+  end
+
+  it "should have the player in the small blind act first" do
+    @g.should_receive(:do_betting).with(0)
+    @g.run
+  end
+  
+  it "should have a bet size equal to the big blind" do
+    @g.bet_size.should == 5.0
+  end
+    
+  it "should increment the round to turn when finished" do
+    @g.run
+    @g.round.should == :turn
+  end
+end
+
+describe Game, "turn round" do
+  before(:each) do
+    @g = Game.new(5.0)
+    @g.run
+    @g.run
+  end
+  
+  it "should burn a card before betting starts" do
+    @g.should_receive(:burn).once
+    @g.run
+  end
+  
+  it "should deal 1 card to the board before betting starts" do
+    @g.run
+    @g.board.length.should == 4
+  end
+  
+  it "should let players find their best hand" do
+    @g.players.each { |p| p.should_receive(:find_hand).once.with(@g.board) }
+    @g.run
+  end
+  
+  it "should have 0 bets in this round before doing betting" do
+    @g.run
+    @g.bets_in_round.should == 0 #checking is default action
+  end
+  
+  it "should reset players amount in round to zero before doing betting" do
+    @g.run
+    @g.players.each { |p| p.in_round.should == 0.0 }
+  end
+  
+  it "should not reset players amount in pot to zero before round" do
+    @g.players.each { |p| p.in_pot.should == 5.0 }
+  end
+  
+  it "should allow 1 bet and 3 raises" do
+    @g.players.each { |p| p.should_receive(:act).at_least(1).and_return(:aggressive) }
+    @g.run    
+    @g.pot.should == 450.0
+  end
+
+  it "should have the player in the small blind act first" do
+    @g.should_receive(:do_betting).with(0)
+    @g.run
+  end
+  
+  it "should have a bet size equal to double the big blind" do
+    @g.bet_size.should == 10.0
+  end
+    
+  it "should increment the round to river when finished" do
+    @g.run
+    @g.round.should == :river
+  end
+end
+
+describe Game, "river round" do
+  before(:each) do
+    @g = Game.new(5.0)
+    @g.run
+    @g.run
+    @g.run
+  end
+  
+  it "should burn a card before betting starts" do
+    @g.should_receive(:burn).once
+    @g.run
+  end
+  
+  it "should deal 1 card to the board before betting starts" do
+    @g.run
+    @g.board.length.should == 5
+  end
+  
+  it "should let players find their best hand" do
+    @g.players.each { |p| p.should_receive(:find_hand).once.with(@g.board) }
+    @g.run
+  end
+  
+  it "should have 0 bets in this round before doing betting" do
+    @g.run
+    @g.bets_in_round.should == 0 #checking is default action
+  end
+  
+  it "should reset players amount in round to zero before doing betting" do
+    @g.run
+    @g.players.each { |p| p.in_round.should == 0.0 }
+  end
+  
+  it "should not reset players amount in pot to zero before round" do
+    @g.players.each { |p| p.in_pot.should == 5.0 }
+  end
+  
+  it "should allow 1 bet and 3 raises" do
+    @g.players.each { |p| p.should_receive(:act).at_least(1).and_return(:aggressive) }
+    @g.run    
+    @g.pot.should == 450.0
+  end
+
+  it "should have the player in the small blind act first" do
+    @g.should_receive(:do_betting).with(0)
+    @g.run
+  end
+  
+  it "should have a bet size equal to double the big blind" do
+    @g.bet_size.should == 10.0
+  end
+    
+  it "should increment the round to showdown when finished" do
+    @g.run
+    @g.round.should == :showdown
+  end
+end
+
+describe Game, "showdown round" do
+  
+  before(:each) do
+    @g = Game.new(5.0)
+    @g.run
+    @g.run
+    @g.run
+  end
+  
+  it "should not allow a folded player to win" do
+    @g.players[0].should_receive(:act).once.and_return(:aggressive)
+    @g.players[1..9].each { |p| p.should_receive(:act).once.and_return(:weak) }
+    @g.players[1..9].each { |p| p.should_not_receive(:hand) }
+    
+    @g.run
+    @g.winners.should == [ @g.players[0] ]
+  end
+  
+  it "should pick the player with the highest hand" do
+    @g.run
+    sorted_players = @g.players.sort { |a,b| a.hand <=> b.hand }
+    @g.winners.should include(sorted_players[9])
+  end
+  
+  it "should allow there to be multiple winners" do
+    winning_hand = Hand.new('As Ks Qs Js Ts')
+    @g.players[0].should_receive(:hand).at_least(1).and_return(winning_hand)
+    @g.players[1].should_receive(:hand).at_least(1).and_return(winning_hand)
+    
+    @g.run
+    @g.winners.should include(@g.players[0])
+    @g.winners.should include(@g.players[1])    
+  end
+  
+  it "should award the entire pot to the winner" do
+    @g.players[0].should_receive(:act).once.and_return(:aggressive)
+    @g.players[1..9].each { |p| p.should_receive(:act).once.and_return(:weak) }
+    
+    @g.run
+    @g.players[0].delta.should == (@g.pot - @g.players[0].in_pot)
+  end   
+  
+  it "should split the pot evenly if there are multiple winners" do
+    winning_hand = Hand.new('As Ks Qs Js Ts')
+    @g.players[0].should_receive(:hand).at_least(1).and_return(winning_hand)
+    @g.players[1].should_receive(:hand).at_least(1).and_return(winning_hand)
+    
+    @g.run
+    num_winners = @g.winners.length # in case someone is delt a royal flush
+    @g.players[0].delta.should == ( (@g.pot/num_winners) - @g.players[0].in_pot)
+    @g.players[1].delta.should == ( (@g.pot/num_winners) - @g.players[1].in_pot)
+  end
+  
+  it "should not award anything to players without winning hands" do
+    @g.players[0].should_receive(:act).once.and_return(:aggressive)
+    @g.players[1..9].each { |p| p.should_receive(:act).once.and_return(:weak) }
+    
+    @g.run
+    @g.players[1..9].each { |p| p.delta.should == (0-p.in_pot)}
+  end
+end
+
+describe Game, "heads-up play" do
+  
+  before(:each) do
+    @g = Game.new(5.0, 2)
+  end
+  
+  it "should have the dealer post the small blind" do
+    @g.players[1].in_round.should == 2.5
+  end
+  
+  it "should have the non-dealer post the big blind" do
+    @g.players[0].in_round.should == 5.0
+  end
+  
+  it "should have the dealer act first pre-flop" do
+    @g.players[1].should_receive(:act).and_return(:weak)
+    @g.players[0].should_not_receive(:act).and_return(:neutral)
+    @g.run
+  end
+  
+  it "should have the non-dealer act first on the flop" do
+    @g.run
+    
+    @g.players[0].should_receive(:act).once.and_return(:aggressive)
+    @g.players[1].should_receive(:act).once.and_return(:weak)
+    @g.run
+  end
+
+  it "should have the non-dealer act first on the turn" do
+    @g.run
+    @g.run
+    
+    @g.players[0].should_receive(:act).once.and_return(:aggressive)
+    @g.players[1].should_receive(:act).once.and_return(:weak)
+    @g.run
+  end
+
+  it "should have the non-dealer act first on the river" do
+    @g.run
+    @g.run
+    @g.run
+    
+    @g.players[0].should_receive(:act).once.and_return(:aggressive)
+    @g.players[1].should_receive(:act).once.and_return(:weak)
+    @g.run
+  end
+end