leonardo-bridge 0.4.3

data/spec/auction_spec.rb

@@ -0,0 +1,100 @@
+require 'spec_helper'
+
+describe Auction do
+  include AuctionHelper
+  
+  let(:dealer) { Direction.north }
+  let(:calls) { 
+    [Pass.new(), Pass.new(), Bid.new(Level.one, Strain.club), Double.new(),
+    Redouble.new(), Pass.new(), Pass.new(), Bid.new(Level.one, Strain.no_trump),
+    Pass.new(), Bid.new(Level.three, Strain.no_trump), Pass.new(), Pass.new(),
+    Pass.new()]
+  }
+  
+  subject(:instance) { Auction.new(dealer) }
+  
+  it { subject.contract.should be_a(NilClass) }
+  it { subject.get_contract.should be_a(NilClass) }
+  it { subject.calls.size.should eq(0) }
+  it { subject.dealer.should eq(dealer) }
+  
+  it 'should pass out on 4 passes only' do
+    subject.passed_out?.should eq(false)
+    3.times do
+      subject.make_call(Pass.new).should eq(true)
+      subject.passed_out?.should eq(false)
+    end
+    
+    subject.make_call(Pass.new).should eq(true)
+    subject.passed_out?.should eq(true)
+  end
+  
+  describe 'when finished' do
+    before { calls.each { |call| subject.make_call(call) } }
+    
+    it { subject.calls.should eq(calls) }
+    it { subject.contract.should_not be_a(NilClass) }
+    it { subject.contract.should be_a(Contract) }
+    it { subject.get_contract.should be_a(Hash) }
+    it { subject.get_contract.should eq(subject.contract.to_hash) }
+  end
+  
+  describe 'current call' do
+    it { assert_current_calls([nil,nil,nil]) }
+    
+    it 'should set current bid' do
+      assert_current_calls [Bid.new(Level.one, Strain.diamond)]
+    end
+    
+    it 'should set current double' do
+      assert_current_calls [ Bid.new(Level.one, Strain.diamond), Double.new ]
+    end
+    
+    it 'should set current redouble' do
+      assert_current_calls [ Bid.new(Level.one, Strain.diamond), Double.new, Redouble.new ]
+    end
+  end
+  
+  it 'does not allow invalid calls' do
+    subject.make_call(Bid.new(Level.two, Strain.club))
+    expect { subject.make_call(Bid.new(Level.one, Strain.club)) }.to raise_error
+    expect { subject.make_call(Bid.new(Level.three, Strain.club)) }.to_not raise_error
+    expect { subject.make_call(Bid.new(Level.two, Strain.heart)) }.to raise_error
+    expect { subject.make_call(Bid.new(Level.three, Strain.heart)) }.to_not raise_error
+  end
+  
+  it 'knows whose turn it is' do
+    turn = dealer
+    subject.whose_turn.should eq(turn)
+    
+    calls.each_index do |i|
+      subject.make_call(calls[i])
+      if i == calls.size - 1
+        subject.whose_turn.should eq(nil)
+      else
+        turn = Direction[(turn + 1) % 4]  # Turn moves clockwise.
+        subject.whose_turn.should eq(turn)
+      end
+    end
+  end
+  
+  it 'only marks an auction as complete if it is' do
+    subject.complete?.should eq(false)
+    calls.each_index do |i|
+      subject.make_call(calls[i])
+      if i == calls.size - 1
+        subject.complete?.should eq(true)
+      else
+        subject.complete?.should eq(false)
+      end
+    end
+  end
+  
+  it 'knows if a call is valid' do
+    calls.each_index do |i|
+      subject.make_call(calls[i])
+      next_call = calls[i+1]
+      subject.valid_call?(next_call).should eq(true) unless next_call.nil?
+    end
+  end
+end

data/spec/board_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe Board do
+  subject { Board.first }
+  
+  it { subject.number.should eq(1) }
+  it { subject.vulnerability.should eq(0) }
+  it { subject.dealer.should eq(0) }
+  it { subject.deal.hands.size.should eq(4) }
+  it { subject.deal.hands.each { |h| h.size.should eq(13) } }
+  
+  describe '#next' do
+    let(:next_board) { subject.next }
+    
+    it { next_board.number.should eq(2) }
+    it { next_board.vulnerability.should eq(1) }
+    it { next_board.dealer.should eq(1) }
+  end
+end

data/spec/bridge_spec.rb

@@ -0,0 +1,25 @@
+require 'spec_helper'
+
+describe Direction do
+  it { Direction.north.should eq(0) }
+  it { Direction.east.should  eq(1) }
+  it { Direction.south.should eq(2) }
+  it { Direction.west.should  eq(3) }
+  
+  it { Direction.next(Direction.north).should eq(Direction.east) }
+  it { Direction.next(Direction.east).should  eq(Direction.south) }
+  it { Direction.next(Direction.south).should eq(Direction.west) }
+  it { Direction.next(Direction.west).should  eq(Direction.north) }
+end
+
+describe Vulnerability do
+  it { Vulnerability.none.should eq(0) }
+  it { Vulnerability.north_south.should eq(1) }
+  it { Vulnerability.east_west.should eq(2) }
+  it { Vulnerability.all.should eq(3) }
+  
+  it { Vulnerability.next(Vulnerability.none).should eq(Vulnerability.north_south) }
+  it { Vulnerability.next(Vulnerability.north_south).should eq(Vulnerability.east_west) }
+  it { Vulnerability.next(Vulnerability.east_west).should eq(Vulnerability.all) }
+  it { Vulnerability.next(Vulnerability.all).should eq(Vulnerability.none) }
+end

data/spec/call_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+describe Call do
+  it 'can create a pass from a string' do
+    Call.from_string('pass').should be_a(Pass)
+    Call.from_string('p').should be_a(Pass)
+    Call.from_string('Pass').should be_a(Pass)
+    Call.from_string('P').should be_a(Pass)
+  end
+  
+  it 'can create a double from a string' do
+    Call.from_string('double').should be_a(Double)
+    Call.from_string('d').should be_a(Double)
+  end
+  
+  it 'can create a redouble from a string' do
+    Call.from_string('redouble').should be_a(Redouble)
+    Call.from_string('r').should be_a(Redouble)
+  end
+  
+  it 'can create a bid from a string' do
+    c = Call.from_string('bid one heart')
+    c.should be_a(Bid)
+    c.strain.should eq(Strain.heart)
+    c.level.should eq(Level.one)
+    
+    c = Call.from_string('b one heart')
+    c.strain.should eq(Strain.heart)
+    c.level.should eq(Level.one)
+    
+    c = Call.from_string('b one no trump')
+    c.strain.should eq(Strain.no_trump)
+    c.level.should eq(Level.one)
+    
+    c = Call.from_string('b one no_trump')
+    c.strain.should eq(Strain.no_trump)
+    c.level.should eq(Level.one)
+  end
+  
+  it 'returns all available calls' do
+    Call.all.should be_a(Array)
+    Call.all.size.should eq(38)
+  end
+end

data/spec/card_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+describe Card do
+
+  let(:card){ Card.new('2', 'C') }
+
+  it "sets rank on initialize" do
+    card.rank.should == '2'
+  end
+
+  it "sets suit on initialize" do
+    card.suit.should == 'C'
+  end
+
+  it "returns a string with rank and suit" do
+    card.to_s.should == '2C'
+  end
+  
+  it { card.suit_i.should eq(Suit.club) }
+  
+  describe "honour" do
+    it "has an honour of 4 when rank is A" do
+      Card.new('A','H').honour.should eq(4)
+    end
+
+    it "has an honour of 3 when rank is K" do
+      Card.new('K','H').honour.should eq(3)
+    end
+
+    it "has an honour of 2 when rank is Q" do
+      Card.new('Q','H').honour.should eq(2)
+    end
+
+    it "has an honour of 1 when rank is J" do
+      Card.new('J','H').honour.should eq(1)
+    end
+
+    it "has an honour of 0 when rank is a number" do
+      Card.new('5','H').honour.should eq(0)
+    end
+  end
+  
+  describe "#from_string" do
+    it { expect { Card.from_string('2') }.to   raise_error(CardError) }
+    it { expect { Card.from_string('WAT') }.to raise_error(CardError) }
+    it { expect { Card.from_string('GT') }.to  raise_error(CardError) }
+    it { expect { Card.from_string('GC') }.to  raise_error(CardError) }
+    it { expect { Card.from_string('2F') }.to  raise_error(CardError) }
+    it { Card.from_string('10C').should eq(Card.new('10','C')) }
+    it { Card.from_string('2C').should eq(card) }
+    it { Card.from_string('2C').rank.should eq('2') }
+    it { Card.from_string('2C').suit.should eq('C') }
+  end
+  
+  describe "<=>" do
+    let(:cards) do
+      cards = []
+      for rank in Card::RANKS do
+        for suit in Card::SUITS do
+          cards << Card.new(rank, suit)
+        end
+      end
+
+      cards
+    end
+    
+    let(:other_cards) do
+      cards = []
+      for rank in Card::RANKS do
+        for suit in Card::SUITS do
+          cards << Card.new(rank, suit)
+        end
+      end
+
+      cards
+    end
+
+    it "compares to other cards" do
+      (Card.new('2','C') < Card.new('2','D')).should eq(true)
+      (Card.new('2','C') > Card.new('2','D')).should eq(false)
+      (Card.new('2','C') == Card.new('2','D')).should eq(false)
+    end
+    
+    it "compares to other cards of same suit" do
+      (Card.new('2','C') < Card.new('J','C')).should eq(true)
+      (Card.new('2','C') > Card.new('J','C')).should eq(false)
+      (Card.new('2','C') == Card.new('J','C')).should eq(false)
+    end
+
+    it "compares as equal to same card" do
+      cards.each { |c| c.should eq(c) } # same card
+      cards.each_index { |i| cards[i].should eq(other_cards[i]) } # same card, different object
+    end
+  end
+end

data/spec/db_spec.rb

@@ -0,0 +1,19 @@
+require 'spec_helper'
+
+describe DB do
+  # set up in spec_helper
+  subject { $redis }
+  it { subject.should be_a(Redis) }
+  
+  describe '#namespace' do
+    before { 
+      subject.set('server:bob','bob.bridge.com')
+      subject.set('server:dave','dave.bridge.com')
+    }
+    
+    it { subject.namespace('server').should be_a(Array) }
+    it { subject.namespace('server').size.should eq(2) }
+    it { subject.namespace('server').first.should eq('bob.bridge.com') }
+    it { subject.namespace('server').last.should eq('dave.bridge.com') }
+  end
+end

data/spec/deck_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Deck do
+
+  subject { Deck.new }
+
+  it { subject.size.should eq(52) }
+  
+  it "should be shuffleable" do
+    old_deck = subject.clone
+    subject.shuffle!
+    subject.should_not eq(old_deck)
+  end
+end

data/spec/enum_spec.rb

@@ -0,0 +1,14 @@
+require 'spec_helper'
+
+describe Enum do
+
+  subject { TestEnum }
+
+  it { subject.size.should eq(4) }
+  it { subject.first.should eq(0) }
+  it { subject.next(0).should eq(1) }
+  it { subject[0].should eq(0) }
+  it { subject.oh.should eq(0) }
+  it { subject.name(0).should eq('oh') }
+  it { subject.each.should be_a(Enumerator) }
+end

data/spec/game_spec.rb

@@ -0,0 +1,291 @@
+# ported from https://svn.code.sf.net/p/pybridge/code/trunk/pybridge/tests/bridge/test_game.py
+require 'spec_helper'
+
+describe Game do
+  subject { Game.new }
+  let(:board) {
+    Board.new(
+      :deal => Deal.new, 
+      :dealer => Direction.north, 
+      :vulnerability => Vulnerability.all
+    )
+  }
+  
+  it { subject.in_progress?.should eq(false) }
+  it { subject.state.should eq(:new) }
+  it { expect { subject.get_turn }.to raise_error(GameError) }
+  
+  describe 'in #rubber_mode' do
+    subject { Game.new(:rubber_mode => true) }
+    
+    it 'sets rubber mode' do
+      subject.rubbers.should eq([])
+    end
+    
+    it "should set vulnerability" do
+      subject.start!(board)
+      subject.board.vulnerability = Vulnerability.none
+    end
+  end
+  
+  it 'should start with the first board by default' do
+    subject.start!
+    subject.board.number.should eq(1)
+  end
+  
+  it 'should increment boards' do
+    g = Game.new(:board => Board.first)
+    g.start!
+    g.board.number.should eq(2)
+  end
+  
+  describe '#start!' do
+    before { subject.start! }
+    
+    it { subject.state.should eq(:auction) }
+    it { subject.in_progress?.should eq(true) }
+    it { subject.get_turn.should eq(subject.board.dealer) }
+  end
+  
+  describe '#start with board' do
+    before { subject.start!(board) }
+    
+    it { subject.board.should eq(board) }
+    it { subject.get_turn.should eq(board.dealer) }
+  end
+  
+  describe 'player methods' do
+    before {
+      players = []
+      Direction.each do |position|
+        players[position] = subject.add_player(position)
+      end
+    }
+    it { subject.players.size.should eq(4) }
+    it { expect { subject.add_player(Direction.north) }.to raise_error }
+    
+    it 'should be able to remove all players' do
+      Direction.each do |position|
+        expect { subject.remove_player(position) }.to_not raise_error
+      end
+      
+      expect { subject.remove_player(Direction.north) }.to raise_error
+    end
+  end
+  
+  describe 'running game' do
+    let(:players) {
+      players = []
+      Direction.each do |position|
+        players[position] = subject.add_player(position)
+      end
+      players
+    }
+    
+    describe '#get_state' do
+      let(:calls) { 
+        [Pass.new(), Pass.new(), Bid.new(Level.one, Strain.club), Double.new(),
+        Redouble.new(), Pass.new(), Pass.new(), Bid.new(Level.one, Strain.no_trump),
+        Pass.new(), Bid.new(Level.two, Strain.heart), Pass.new(), Pass.new(),
+        Pass.new()]
+      }
+      
+      context 'in auction' do
+        before { 
+          @players = []
+          Direction.each { |p| @players[p] = subject.add_player(p) }
+          subject.start!(board)
+        }
+        
+        it 'should return all available calls at start' do
+          subject.get_state[:calls].size.should eq(38)
+          subject.get_state[:available_calls].size.should eq(36)
+        end
+        
+        it 'should return available calls' do
+          @players[subject.get_turn].make_call(Call.from_string('b two heart'))
+          subject.get_state[:calls].size.should eq(38)
+          subject.get_state[:available_calls].size.should eq(29)
+        end
+      end
+      
+      context "passed out" do
+        before {
+          subject.start!(board)
+          turn = board.dealer  # Avoid calling getTurn.™
+          Direction.each do |i| # Iterate for each player.
+            players[i].make_call(Pass.new) # Each player passes.
+            turn = Direction[(turn+1) % Direction.size]
+          end
+        }
+      
+        it 'should return game state' do
+          state = subject.get_state
+          state.should be_a(Hash)
+          state[:state].should eq(:finished)
+          state[:available_calls].should eq([])
+          state[:auction].size.should eq(4)
+          state[:turn].should eq(nil)
+          state[:play].should eq(nil)
+        end
+      end
+      
+      context "auctioned" do
+        before {
+          subject.start!(board)
+          turn = board.dealer  # Avoid calling getTurn.
+          calls.each do |c|
+            players[turn].make_call(c) # Each player passes.
+            turn = Direction[(turn+1) % Direction.size]
+          end
+        }
+      
+        it 'should return game state' do
+          state = subject.get_state
+          state.should be_a(Hash)
+          state[:auction].size.should eq(13)
+          state[:available_calls].should eq([])
+          state[:play].should be_a(Hash)
+          state[:state].should eq(:playing)
+          state[:turn].should eq(2) # this is now game turn
+          Strain.name(state[:play][:trumps]).should eq('heart')
+          state[:contract][:bid].to_s.should eq('two heart')
+          Direction.name(state[:play][:declarer]).should eq('east')
+          Direction.name(state[:play][:dummy]).should eq('west')
+          state[:play][:declarer_trick_count].should eq(0)
+          state[:play][:defender_trick_count].should eq(0)
+          state[:play][:tricks].should be_a(Array)
+          state[:play][:tricks].size.should eq(0)
+        end
+        
+        it 'should return well-formed json state' do
+          state = JSON.parse(subject.get_state.to_json)
+          state['state'].should eq('playing')
+          state['auction'].size.should eq(13)
+          state['auction'].first.should eq('pass')
+        end
+        
+        context 'in play' do
+          before {
+            @turn  = subject.get_turn
+            player = players[@turn]
+            @card = player.get_hand.sample
+            player.play_card(@card) # play a random card
+          }
+          
+          it 'should include public cards' do
+            state = subject.get_state
+            # go to json and test that for sanity
+            state = JSON.parse(state.to_json)
+            dummy = state['play']['dummy']
+            dummy.should eq(3)
+            state['play']['played'][@turn.to_s].first.should eq(@card.to_s)
+            state['board']['deal'][dummy.to_s].should eq(subject.get_hand(dummy).map { |c| c.to_s })
+          end
+          
+          it 'can perform a claim issued by a defender' do
+            subject.claim(Direction.north, 9)
+            subject.results.size.should eq(1)
+            subject.state.should eq(:finished)
+            result = subject.results.first
+            result.claimed_by.should eq(Direction.north)
+            result.claimed.should eq(9)
+            result.tricks_made.should eq(4)
+            result.score.should eq(-400)
+          end
+          
+          it 'can perform a zero claim issued by a defender' do
+            subject.claim(Direction.north, 0)
+            subject.results.size.should eq(1)
+            subject.state.should eq(:finished)
+            result = subject.results.first
+            result.claimed_by.should eq(Direction.north)
+            result.claimed.should eq(0)
+            result.tricks_made.should eq(13)
+            result.score.should eq(260)
+          end
+          
+          it 'can perform a claim issued by a declarer' do
+            subject.claim(Direction.east, 9)
+            subject.results.size.should eq(1)
+            subject.state.should eq(:finished)
+            state = subject.get_state
+            result = subject.results.first
+            result.claimed_by.should eq(Direction.east)
+            result.claimed.should eq(9)
+            result.tricks_made.should eq(9)
+            result.score.should eq(140)
+          end
+          
+          it 'can perform a zero claim issued by a declarer' do
+            subject.claim(Direction.east, 0)
+            subject.results.size.should eq(1)
+            subject.state.should eq(:finished)
+            state = subject.get_state
+            result = subject.results.first
+            result.claimed_by.should eq(Direction.east)
+            result.claimed.should eq(0)
+            result.tricks_made.should eq(0)
+            result.score.should eq(-800)
+          end
+        end
+      end
+    end  
+    
+    # All players pass, game should finish without reaching play
+    it 'should finish without reaching play if passed out' do
+      subject.start!(board)
+      turn = board.dealer  # Avoid calling getTurn.
+      Direction.each do |i| # Iterate for each player.
+        players[i].make_call(Pass.new) # Each player passes.
+        turn = Direction[(turn+1) % Direction.size]
+      end
+      turn.should eq(board.dealer) # Sanity check.
+
+      # Bidding is passed out - game is over.
+      subject.in_progress?.should eq(false)
+      subject.state.should eq(:finished)
+      expect { players[turn].make_call(Bid.new(Level.one, Strain.club)) }.to raise_error
+      expect { players[turn].play_card(board.deal.hands[turn].first) }.to raise_error
+    end
+    
+    # Play through a sample game.
+    # This does not attempt to test the integrity of Bidding and Play.
+    it 'should play from start to finish' do
+      calls = Level.map do |l| # all available action bids
+        Strain.map { |s| Bid.new(l,s) }
+      end
+      
+      calls << [Pass.new, Pass.new, Pass.new] # ...plus 3 passes
+      
+      subject.start!(board)
+      
+      calls.flatten.each do |call| # make em all
+        turn = subject.get_turn
+        players[turn].make_call(call)
+      end
+      
+      subject.state.should eq(:playing)
+      subject.auction.complete?.should eq(true)
+      subject.play.should_not eq(nil)
+      
+      while not subject.play.complete?
+        subject.state.should eq(:playing)
+        turn = subject.get_turn
+        # Find a valid card.
+        board.deal[turn].each do |card|
+          if subject.play.valid_play?(card, turn, board.deal[turn])
+            if turn == subject.play.dummy
+              self.players[subject.play.declarer].play_card(card).should eq(true)
+            else
+              self.players[turn].play_card(card).should eq(true)
+            end
+            break
+          end
+        end
+      end
+      subject.state.should eq(:finished)
+      subject.in_progress?.should eq(false) # Game complete.
+    end
+  end
+end