bitpoker 0.1.1

data/lib/bitpoker/rules.rb

@@ -0,0 +1,16 @@
+module BitPoker
+      
+      # Module with default rules of the game
+      #
+      # @author Mckomo
+      module Rules
+
+         ROUNDS      = 1000       # Number of rounds to be played in a duel
+         MIN_STAKE   = 10
+         MAX_STAKE   = 200
+         TIMEOUT     = 1          # Timeout of bot response
+         CARD_RANGE  = 0..4
+         
+      end
+      
+end

data/test/support/glass_bot.rb

@@ -0,0 +1,46 @@
+# GlassBot makes all properties visible
+class GlassBot < BitPoker::BotInterface
+   
+   attr_reader :card, :min_card, :max_card, :max_stake, :timeout
+   
+   def introduce( rules )
+      @min_card = rules["min_card"]
+      @max_card = rules["max_card"]
+      @max_stake = rules["max_stake"]
+      @timeout = rules["timeout"]
+   end
+   
+   def get_card( card )
+      @card = card
+   end
+   
+   def bet_one( min_stake )
+      ( min_stake + @max_stake ) / 2
+   end
+   
+   def agree_one( opponent_stake )
+      true
+   end
+
+   def bet_two( min_stake, max_stake )
+      ( min_stake + @max_stake ) / 2
+   end
+
+   def agree_two( opponent_stake )
+      true
+   end
+
+   def showdown( opponent_card )
+      @opponent_card = opponent_card
+   end
+
+   def end_of_round( score )
+      @score = score
+   end
+
+   def end_of_duel( total_score, opponent_score )  
+   end
+  
+end
+
+  

data/test/support/sleepy_bot.rb

@@ -0,0 +1,14 @@
+class SleepyBot < BitPoker::BotInterface
+
+   def return_after_sleep( value, timeout )
+      sleep( timeout )
+      value
+   end
+   
+   def raise_exception
+      2 / 0
+   end
+  
+end
+
+  

data/test/test_bitpoker.rb

@@ -0,0 +1,21 @@
+require "test/unit"
+require 'shoulda'
+
+require "./lib/bitpoker"
+
+class TestBitPoker < Test::Unit::TestCase
+   
+   context "a BitPoker module" do
+   
+      should "be able to load a bot from file" do
+         
+         bot = BitPoker.load_bot( "sleepy_bot", "#{Dir.pwd}/test/support", "" )
+         
+         assert_kind_of BitPoker::BotInterface, bot
+         assert_equal "SleepyBot", bot.name
+         
+      end
+      
+   end
+   
+end

data/test/test_bot_interface.rb

@@ -0,0 +1,59 @@
+require "test/unit"
+require 'shoulda'
+require 'mocha/setup'
+
+require "./lib/bitpoker"
+
+class TestBot < Test::Unit::TestCase
+   
+   include BitPoker
+   
+   context "a bot interface" do
+      
+      setup do
+         @interface = BotInterface.new
+      end
+      
+      should "force to implement all required methods" do
+         
+         assert_raise ArgumentError do 
+            @interface.introduce
+         end
+         
+         assert_raise ArgumentError do 
+            @interface.get_card
+         end
+         
+         assert_raise ArgumentError do 
+            @interface.bet_one
+         end         
+         
+         assert_raise ArgumentError do 
+            @interface.agree_one
+         end
+         
+         assert_raise ArgumentError do 
+            @interface.bet_two
+         end
+                  
+         assert_raise ArgumentError do 
+            @interface.agree_two
+         end
+         
+         assert_raise ArgumentError do 
+            @interface.showdown
+         end
+         
+         assert_raise ArgumentError do 
+            @interface.end_of_round
+         end
+         
+         assert_raise ArgumentError do 
+            @interface.end_of_duel
+         end
+         
+      end
+      
+   end
+   
+end

data/test/test_bot_proxy.rb

@@ -0,0 +1,40 @@
+require "test/unit"
+require 'shoulda'
+require 'mocha/setup'
+
+require "./lib/bitpoker"
+
+class TestBotProxy < Test::Unit::TestCase
+   
+   include BitPoker
+   
+   context "a BotProxy" do
+      
+      should "load only a bot that implements BotInterface" do
+         
+         bot = BotInterface.new
+         
+         assert_nothing_raised do 
+            BotProxy.new( bot )
+         end
+                  
+         assert_raise ArgumentError do 
+            BotProxy.new( "not_a_bot" )
+         end
+         
+      end
+      
+      should "trigger bot action and get it's response" do
+         
+         bot = BotInterface.new
+         bot.stubs( :bet_one ).returns( 10 )
+         
+         proxy = BotProxy.new( bot )
+         
+         assert_equal 10, proxy.trigger( :bet_one, 5 )
+         
+      end
+      
+   end
+   
+end

data/test/test_croupier.rb

@@ -0,0 +1,147 @@
+require "test/unit"
+require 'shoulda'
+require "mocha/setup"
+
+require './lib/bitpoker'
+require_relative 'support/sleepy_bot'
+
+
+class TestCroupier < Test::Unit::TestCase
+   
+   include BitPoker
+   
+   context "a croupier" do
+      
+      setup do
+         @croupier = Croupier.new
+         @bot = BitPoker::BotProxy.new( SleepyBot.new )
+      end
+      
+      should "know rules" do
+         assert_not_nil @croupier.rules
+      end
+      
+      should "be able to use custom rules" do
+         
+         custom_rules = {
+            rounds:     100,
+            min_stake:  100,
+            max_stake:  1000,
+            timeout:    100,
+            card_range: 5..10
+         }
+         croupier = Croupier.new( custom_rules )
+         
+         assert_equal custom_rules, croupier.rules
+         
+      end
+      
+      should "be able to share round rules" do
+         
+         custom_rules = {
+            rounds:     100,
+            min_stake:  100,
+            max_stake:  1000,
+            timeout:    100,
+            card_range: 5..10
+         }
+         
+         croupier = Croupier.new( custom_rules )
+         
+         round_rules = {
+            "min_card"  =>  5,
+            "max_card"  =>  10,
+            "max_stake" =>  1000,
+            "timeout"   =>  100
+         }
+         
+         assert_equal round_rules, croupier.round_rules
+         
+      end
+      
+      should "follow game logic" do
+         @croupier.kind_of?( GameLogic )
+      end
+      
+      should "be able to call bot and get it's response" do
+         
+         bot = BotProxy.new( BotInterface.new )
+         
+         card = 4
+         min_stake = 10
+         max_stake = 200
+         call_stake = 100
+         
+         bot.stubs( :trigger ).with( :get_card, card ).returns( card )
+         bot.stubs( :trigger ).with( :bet_one, [min_stake, max_stake] ).returns( min_stake )
+         bot.stubs( :trigger ).with( :agree_one, call_stake ).returns( true )
+         
+         assert_equal card, @croupier.call( bot, :get_card, card )
+         assert_equal min_stake, @croupier.call( bot, :bet_one, [min_stake, max_stake] )
+         assert @croupier.call( bot, :agree_one, call_stake )
+         
+      end
+      
+      should "disqualify bot when exceeded timeout" do
+         
+         croupier = Croupier.new( {
+           timeout: 0.5
+         } )
+                  
+         assert_raise BotError do
+            croupier.call( @bot, :return_after_sleep, [true, 10] )
+         end
+         
+      end
+      
+      should "disqualify bot that does not implement one of required methods" do
+         
+         assert_raise BotError do
+            @croupier.call( @bot, :bet_one, [10, 100] )
+         end
+         
+      end
+      
+      should "disqualify bot that fails during respond" do
+         
+         assert_raise BotError do
+            @croupier.call( @bot, :raise_exception )
+         end
+         
+      end
+      
+      should "disqualify bot for unacceptable response" do
+         
+         assert_raise BotError do
+            @croupier.call( @bot, :return_after_sleep, [100, 0] ) do |bet|
+               bet < 50
+            end
+         end
+         
+      end
+      
+      should "be able to make parallel calls" do
+         
+         croupier = Croupier.new( {
+           timeout: 1.01
+         } )
+         
+         min_stake = 10
+         max_stake = 200
+                           
+         before = Time.now.to_i
+         bets = croupier.parallel_call( [@bot, @bot], :return_after_sleep, [min_stake, 1], [max_stake, 1] )
+         after = Time.now.to_i
+         
+         assert_equal min_stake, bets[0]
+         assert_equal max_stake, bets[1]
+         
+         assert_equal 1, after - before
+         
+      end
+      
+
+      
+   end
+   
+end

data/test/test_duel.rb

@@ -0,0 +1,58 @@
+require "test/unit"
+require 'shoulda'
+require "mocha/setup"
+
+require "./lib/bitpoker"
+
+class TestDuel < Test::Unit::TestCase
+   
+   include BitPoker
+   include BitPoker::Rules
+   
+   context "a duel" do
+   
+      setup do
+         @bot = BotProxy.new( BotInterface.new )
+         @croupier = Croupier.new
+         @duel = Duel.new( @croupier, @bot, @bot )  
+      end
+      
+      should "have clear score table when started" do
+         assert_equal [0, 0], duel = @duel.total_score
+      end
+      
+      should "know when finished" do
+         
+         assert ! @duel.finished?
+         
+         Round.any_instance.stubs( :state ).returns( Round::STATE_FINISHED )
+         
+         ( 0 .. @croupier.rules[:rounds] ).each do
+            @duel.play_round
+         end
+         
+         assert @duel.finished?
+         
+      end
+      
+      should "keep total score" do
+         
+         Round.any_instance.stubs( :state ).returns( Round::STATE_FINISHED )
+         Round.any_instance.stubs( :score ).returns( [-100, 100] )
+         
+         ( 0 .. @croupier.rules[:rounds] ).each do
+            @duel.play_round
+         end
+         
+         total_score = [
+            -100 * @croupier.rules[:rounds],
+            100 * @croupier.rules[:rounds]
+         ]
+         
+         assert_equal total_score, @duel.total_score
+         
+      end
+      
+   end
+   
+end

data/test/test_game_logic.rb

@@ -0,0 +1,272 @@
+require "test/unit"
+require 'shoulda'
+require "mocha/setup"
+
+require "./lib/bitpoker"
+require_relative 'support/glass_bot'
+
+class TestGameLogic < Test::Unit::TestCase
+   
+   include BitPoker
+   
+   context "a croupier that fallows game logic" do
+      
+      setup do
+         @bot_one = GlassBot.new
+         @bot_two = GlassBot.new
+         @proxy_one = BotProxy.new( @bot_one )
+         @proxy_two = BotProxy.new( @bot_two )
+         @round = Round.new( [@proxy_one, @proxy_two] )
+         @croupier = Croupier.new
+      end
+      
+      should "be able to perform rules introduction step" do
+         
+         @round.state = Round::STATE_RULES_INTRODUCTION
+                  
+         @croupier.perform_next_step( @round )
+         
+         # Test that all required rules are passed to bot
+         assert_equal @croupier.rules[:card_range].min, @bot_one.min_card 
+         assert_equal @croupier.rules[:card_range].max, @bot_one.max_card
+         assert_equal @croupier.rules[:max_stake], @bot_one.max_stake
+         assert_equal @croupier.rules[:timeout], @bot_one.timeout
+         
+         assert_equal Round::STATE_CARD_DEAL, @round.state
+         
+      end
+      
+      should "be able to perform card deal step" do
+         
+         @round.state = Round::STATE_CARD_DEAL
+         
+         @croupier.stubs( deal_cards: [4, 0] )
+         @proxy_one.stubs( :trigger ).with( :get_card, 4 ).returns( 4 )
+         @proxy_two.stubs( :trigger ).with( :get_card, 0 ).returns( 0 )
+         
+         @croupier.perform_next_step( @round )
+         
+         assert_equal [4, 0], @round.cards
+         assert_equal Round::STATE_FIRST_BETTING, @round.state
+         
+      end
+      
+      should "be able to perform first betting step when bets are not equal" do
+         
+         @round.state = Round::STATE_FIRST_BETTING
+         
+         @proxy_one.stubs( :trigger ).with( :bet_one, @croupier.rules[:min_stake] ).returns( 15 )
+         @proxy_two.stubs( :trigger ).with( :bet_one, @croupier.rules[:min_stake] ).returns( 25 )
+         
+         @croupier.perform_next_step( @round )
+         
+         assert_equal [15, 25], @round.bets
+         assert_equal Round::STATE_FIRST_CALL, @round.state
+         
+      end
+      
+      should "be able to perform first betting step when bets are equal" do
+         
+         @round.state = Round::STATE_FIRST_BETTING
+         
+         @proxy_one.stubs( :trigger ).with( :bet_one, @croupier.rules[:min_stake] ).returns( 25 )
+         @proxy_two.stubs( :trigger ).with( :bet_one, @croupier.rules[:min_stake] ).returns( 25 )
+         
+         @croupier.perform_next_step( @round )
+         
+         assert @round.bets_even?
+         assert_equal [25, 25], @round.bets
+         assert_equal Round::STATE_SECOND_BETTING, @round.state
+         
+      end
+      
+      should "be able to perform first call step when bot calls the stake" do
+         
+         @round.state = Round::STATE_FIRST_CALL
+         @round.bets = [15, 25] # Now, proxy_one is lower bidder
+         assert_equal 25, @round.stake 
+         
+         @proxy_one.stubs( :trigger ).with( :agree_one, 25 ).returns( true )
+         
+         @croupier.perform_next_step( @round )
+         
+         assert_equal [15, 25], @round.bets
+         assert_equal Round::STATE_FIRST_CALLED, @round.state
+         
+      end
+      
+      should "be able to perform first call step when bot does not call the stake" do
+         
+         @round.state = Round::STATE_FIRST_CALL
+         @round.bets = [15, 25] # Now, proxy_one is lower bidder 
+         assert_equal 25, @round.stake
+         
+         @proxy_one.stubs( :trigger ).with( :agree_one, 25 ).returns( false )
+         
+         @croupier.perform_next_step( @round )
+         
+         assert_equal [15, 25], @round.bets
+         assert_equal Round::STATE_FOLDED, @round.state
+         
+      end
+      
+      should "be able to perform first called step" do
+         
+         @round.state = Round::STATE_FIRST_CALLED
+         @round.bets = [15, 25] # Now, proxy_one is lower bidder
+         
+         @croupier.perform_next_step( @round )
+         
+         assert @round.bets_even?
+         assert_equal [25, 25], @round.bets
+         assert_equal Round::STATE_SECOND_BETTING, @round.state
+         
+      end
+      
+      should "be able to perform folded step" do
+         
+         @round.state = Round::STATE_FOLDED
+         @round.bets = [15, 25] # Now, proxy_one is folding player
+         
+         @croupier.perform_next_step( @round )
+         
+         assert_equal [-15, 15], @round.score
+         assert_equal Round::STATE_POINTS_DISTRIBUTION, @round.state 
+         
+      end
+      
+      should "be able to perform second betting step when bets are already equal to max_stake" do
+         
+         max_stake = @croupier.rules[:max_stake]
+         
+         @round.state = Round::STATE_SECOND_BETTING
+         @round.bets = [max_stake, max_stake]
+         
+         @croupier.perform_next_step( @round )
+         
+         assert_equal Round::STATE_SHOWDOWN, @round.state
+         
+      end
+      
+      should "be able to perform second betting step when bets are equal" do
+         
+         @round.bets = [25, 25]
+         
+         @round.state = Round::STATE_SECOND_BETTING
+         @round.bets = [50, 50]
+         
+         @proxy_one.stubs( :trigger ).with( :bet_two, @round.stake ).returns( 100 )
+         @proxy_two.stubs( :trigger ).with( :bet_two, @round.stake ).returns( 100 )
+         
+         @croupier.perform_next_step( @round )
+         
+         assert_equal [100, 100], @round.bets
+         assert @round.bets_even?
+         assert_equal Round::STATE_SHOWDOWN, @round.state
+         
+      end
+      
+      should "be able to perform second betting step when bets are not equal" do
+                  
+         @round.state = Round::STATE_SECOND_BETTING
+         @round.bets = [50, 50]
+         
+         @proxy_one.stubs( :trigger ).with( :bet_two, @round.stake ).returns( 75 )
+         @proxy_two.stubs( :trigger ).with( :bet_two, @round.stake ).returns( 100 )
+         
+         @croupier.perform_next_step( @round )
+         
+         assert_equal @round.bets, [75, 100]
+         assert_equal Round::STATE_SECOND_CALL, @round.state
+         
+      end
+      
+      should "be able to perform second call step when bot calls the stake" do
+         
+         @round.state = Round::STATE_SECOND_CALL
+         @round.bets = [75, 100] # Now, proxy_one is lower bidder 
+         
+         @proxy_one.stubs( :trigger ).with( :agree_two, 100 ).returns( true )
+         
+         @croupier.perform_next_step( @round )
+         
+         assert_equal [75, 100], @round.bets
+         assert_equal Round::STATE_SECOND_CALLED, @round.state
+         
+      end
+      
+      should "be able to perform second call step when bot does not call the stake" do
+         
+         @round.state = Round::STATE_SECOND_CALL
+         @round.bets = [75, 100] # Now, proxy_one is lower bidder 
+         
+         @proxy_one.stubs( :trigger ).with( :agree_two, 100 ).returns( false )
+         
+         @croupier.perform_next_step( @round )
+         
+         assert_equal [75, 100], @round.bets
+         assert_equal Round::STATE_FOLDED, @round.state
+         
+      end
+      
+      should "be able to perform second called step" do
+         
+         @round.state = Round::STATE_SECOND_CALLED
+         @round.bets = [75, 100] # Now, proxy_one is lower bidder 
+         
+         @croupier.perform_next_step( @round )
+         
+         assert @round.bets_even?
+         assert_equal [100, 100], @round.bets
+         assert_equal Round::STATE_SHOWDOWN, @round.state
+         
+      end
+      
+      should "be able to perform showdown step when it is a draw" do
+         
+         @round.state = Round::STATE_SHOWDOWN
+         @round.bets = [100, 100]
+         @round.cards = [4, 4] # It is the draw now
+         
+         @croupier.perform_next_step( @round )
+         
+         assert @round.bets_even?
+         assert @round.draw?
+         assert_equal [0, 0], @round.score
+         assert_equal Round::STATE_POINTS_DISTRIBUTION, @round.state
+         
+      end
+      
+      should "be able to perform showdown step when it is not a draw" do
+         
+         @round.state = Round::STATE_SHOWDOWN
+         @round.bets = [100, 100]
+         @round.cards = [0, 4] # It is the draw now
+         
+         @croupier.perform_next_step( @round )
+         
+         assert @round.bets_even?
+         assert ! @round.draw?
+         assert_equal 100, @round.stake
+         assert_equal [-100, 100], @round.score
+         assert_equal Round::STATE_POINTS_DISTRIBUTION, @round.state
+         
+      end
+      
+      should "be able to perform points distribution step" do
+         
+         @round.state = Round::STATE_POINTS_DISTRIBUTION
+         @round.score = [-100, 100]
+         
+         @proxy_one.stubs( :trigger ).with( :end_of_round, -100 ).returns( -100 )
+         @proxy_two.stubs( :trigger ).with( :end_of_round, 100 ).returns( 100 )
+         
+         @croupier.perform_next_step( @round )
+         
+         assert_equal Round::STATE_FINISHED, @round.state
+         
+      end
+      
+   end
+   
+end