leonardo-bridge 0.4.3 → 0.6.5

data/spec/board_spec.rb

@@ -3,17 +3,17 @@ 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) } }
+  it { expect(subject.number).to eq(1) }
+  it { expect(subject.vulnerability).to eq(0) }
+  it { expect(subject.dealer).to eq(0) }
+  it { expect(subject.deal.hands.size).to eq(4) }
+  it { subject.deal.hands.each { |h| expect(h.size).to 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) }
+    it { expect(next_board.number).to eq(2) }
+    it { expect(next_board.vulnerability).to eq(1) }
+    it { expect(next_board.dealer).to eq(1) }
   end
 end

data/spec/bridge_spec.rb

@@ -1,25 +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 { expect(Direction.north).to eq(0) }
+  it { expect(Direction.east).to  eq(1) }
+  it { expect(Direction.south).to eq(2) }
+  it { expect(Direction.west).to  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) }
+  it { expect(Direction.next(Direction.north)).to eq(Direction.east) }
+  it { expect(Direction.next(Direction.east)).to  eq(Direction.south) }
+  it { expect(Direction.next(Direction.south)).to eq(Direction.west) }
+  it { expect(Direction.next(Direction.west)).to  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 { expect(Vulnerability.none).to eq(0) }
+  it { expect(Vulnerability.north_south).to eq(1) }
+  it { expect(Vulnerability.east_west).to eq(2) }
+  it { expect(Vulnerability.all).to 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) }
+  it { expect(Vulnerability.next(Vulnerability.none)).to eq(Vulnerability.north_south) }
+  it { expect(Vulnerability.next(Vulnerability.north_south)).to eq(Vulnerability.east_west) }
+  it { expect(Vulnerability.next(Vulnerability.east_west)).to eq(Vulnerability.all) }
+  it { expect(Vulnerability.next(Vulnerability.all)).to eq(Vulnerability.none) }
 end

data/spec/call_spec.rb

@@ -2,43 +2,43 @@ 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)
+    expect(Call.from_string('pass')).to be_a(Pass)
+    expect(Call.from_string('p')).to be_a(Pass)
+    expect(Call.from_string('Pass')).to be_a(Pass)
+    expect(Call.from_string('P')).to 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)
+    expect(Call.from_string('double')).to be_a(Double)
+    expect(Call.from_string('d')).to 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)
+    expect(Call.from_string('redouble')).to be_a(Redouble)
+    expect(Call.from_string('r')).to 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)
+    expect(c).to be_a(Bid)
+    expect(c.strain).to eq(Strain.heart)
+    expect(c.level).to eq(Level.one)
     
     c = Call.from_string('b one heart')
-    c.strain.should eq(Strain.heart)
-    c.level.should eq(Level.one)
+    expect(c.strain).to eq(Strain.heart)
+    expect(c.level).to eq(Level.one)
     
     c = Call.from_string('b one no trump')
-    c.strain.should eq(Strain.no_trump)
-    c.level.should eq(Level.one)
+    expect(c.strain).to eq(Strain.no_trump)
+    expect(c.level).to eq(Level.one)
     
     c = Call.from_string('b one no_trump')
-    c.strain.should eq(Strain.no_trump)
-    c.level.should eq(Level.one)
+    expect(c.strain).to eq(Strain.no_trump)
+    expect(c.level).to eq(Level.one)
   end
   
   it 'returns all available calls' do
-    Call.all.should be_a(Array)
-    Call.all.size.should eq(38)
+    expect(Call.all).to be_a(Array)
+    expect(Call.all.size).to eq(38)
   end
 end

data/spec/card_spec.rb

@@ -5,38 +5,38 @@ describe Card do
   let(:card){ Card.new('2', 'C') }
 
   it "sets rank on initialize" do
-    card.rank.should == '2'
+    expect(card.rank).to eq('2')
   end
 
   it "sets suit on initialize" do
-    card.suit.should == 'C'
+    expect(card.suit).to eq('C')
   end
 
   it "returns a string with rank and suit" do
-    card.to_s.should == '2C'
+    expect(card.to_s).to eq('2C')
   end
   
-  it { card.suit_i.should eq(Suit.club) }
+  it { expect(card.suit_i).to 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)
+      expect(Card.new('A','H').honour).to eq(4)
     end
 
     it "has an honour of 3 when rank is K" do
-      Card.new('K','H').honour.should eq(3)
+      expect(Card.new('K','H').honour).to eq(3)
     end
 
     it "has an honour of 2 when rank is Q" do
-      Card.new('Q','H').honour.should eq(2)
+      expect(Card.new('Q','H').honour).to eq(2)
     end
 
     it "has an honour of 1 when rank is J" do
-      Card.new('J','H').honour.should eq(1)
+      expect(Card.new('J','H').honour).to eq(1)
     end
 
     it "has an honour of 0 when rank is a number" do
-      Card.new('5','H').honour.should eq(0)
+      expect(Card.new('5','H').honour).to eq(0)
     end
   end
   
@@ -46,10 +46,10 @@ describe Card do
     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') }
+    it { expect(Card.from_string('10C')).to eq(Card.new('10','C')) }
+    it { expect(Card.from_string('2C')).to eq(card) }
+    it { expect(Card.from_string('2C').rank).to eq('2') }
+    it { expect(Card.from_string('2C').suit).to eq('C') }
   end
   
   describe "<=>" do
@@ -76,20 +76,20 @@ describe Card do
     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)
+      expect(Card.new('2','C') < Card.new('2','D')).to eq(true)
+      expect(Card.new('2','C') > Card.new('2','D')).to eq(false)
+      expect(Card.new('2','C') == Card.new('2','D')).to 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)
+      expect(Card.new('2','C') < Card.new('J','C')).to eq(true)
+      expect(Card.new('2','C') > Card.new('J','C')).to eq(false)
+      expect(Card.new('2','C') == Card.new('J','C')).to 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
+      cards.each { |c| expect(c).to eq(c) } # same card
+      cards.each_index { |i| expect(cards[i]).to eq(other_cards[i]) } # same card, different object
     end
   end
 end

data/spec/deck_spec.rb

@@ -4,11 +4,11 @@ describe Deck do
 
   subject { Deck.new }
 
-  it { subject.size.should eq(52) }
+  it { expect(subject.size).to eq(52) }
   
   it "should be shuffleable" do
     old_deck = subject.clone
     subject.shuffle!
-    subject.should_not eq(old_deck)
+    expect(subject).to_not eq(old_deck)
   end
 end

data/spec/enum_spec.rb

@@ -4,11 +4,11 @@ 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) }
+  it { expect(subject.size).to eq(4) }
+  it { expect(subject.first).to eq(0) }
+  it { expect(subject.next(0)).to eq(1) }
+  it { expect(subject[0]).to eq(0) }
+  it { expect(subject.oh).to eq(0) }
+  it { expect(subject.name(0)).to eq('oh') }
+  it { expect(subject.each).to be_a(Enumerator) }
 end

data/spec/game_spec.rb

@@ -11,18 +11,18 @@ describe Game do
     )
   }
   
-  it { subject.in_progress?.should eq(false) }
-  it { subject.state.should eq(:new) }
+  it { expect(subject.in_progress?).to eq(false) }
+  it { expect(subject.state).to 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([])
+      expect(subject.rubbers).to eq([])
     end
     
-    it "should set vulnerability" do
+    it ").to set vulnerability" do
       subject.start!(board)
       subject.board.vulnerability = Vulnerability.none
     end
@@ -30,28 +30,28 @@ describe Game do
   
   it 'should start with the first board by default' do
     subject.start!
-    subject.board.number.should eq(1)
+    expect(subject.board.number).to eq(1)
   end
   
   it 'should increment boards' do
     g = Game.new(:board => Board.first)
     g.start!
-    g.board.number.should eq(2)
+    expect(g.board.number).to 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) }
+    it { expect(subject.state).to eq(:auction) }
+    it { expect(subject.in_progress?).to eq(true) }
+    it { expect(subject.get_turn).to 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) }
+    it { expect(subject.board).to eq(board) }
+    it { expect(subject.get_turn).to eq(board.dealer) }
   end
   
   describe 'player methods' do
@@ -61,15 +61,15 @@ describe Game do
         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 { expect(subject.players.size).to eq(4) }
+    it { expect { subject.add_player(Direction.north) }.to raise_error(GameError) }
     
     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
+      expect { subject.remove_player(Direction.north) }.to raise_error(GameError)
     end
   end
   
@@ -97,15 +97,15 @@ describe Game do
           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)
+        it 'to return all available calls at start' do
+          expect(subject.get_state[:calls].size).to eq(38)
+          expect(subject.get_state[:available_calls].size).to 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)
+          expect(subject.get_state[:calls].size).to eq(38)
+          expect(subject.get_state[:available_calls].size).to eq(29)
         end
       end
       
@@ -121,12 +121,98 @@ describe Game do
       
         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)
+          expect(state).to be_a(Hash)
+          expect(state[:state]).to eq(:finished)
+          expect(state[:available_calls]).to eq([])
+          expect(state[:auction].size).to eq(4)
+          expect(state[:turn]).to eq(nil)
+          expect(state[:play]).to eq(nil)
+        end
+      end
+      
+      context '#undo' do
+        before { subject.start!(board) }
+        
+        it 'should work during auction' do
+          turn = board.dealer
+          calls.first(3).each do |c|
+            players[turn].make_call(c) # Each player passes.
+            turn = Direction[(turn+1) % Direction.size]
+          end
+          call_size = subject.auction.calls.size
+          
+          expect(subject.undo!).to eq(true)
+          expect(subject.auction.calls.size).to eq(call_size-1)
+          expect(subject.get_turn).to eq(turn-1)
+        end
+        
+        it 'should not work with a completed auction and no cards' do
+          turn = board.dealer
+          calls.each do |c|
+            players[turn].make_call(c) # Each player passes.
+            turn = Direction[(turn+1) % Direction.size]
+          end
+          call_size = subject.auction.calls.size
+          turn = subject.get_turn
+          expect(subject.undo!).to eq(false)
+          expect(subject.auction.calls.size).to eq(call_size)
+          expect(subject.get_turn).to eq(turn)
+        end
+        
+        context 'with complete auction' do
+          before {
+            turn = board.dealer
+            calls.each do |c|
+              players[turn].make_call(c) # Each player passes.
+              turn = Direction[(turn+1) % Direction.size]
+            end
+          }
+          
+          it 'should work while in play' do
+            5.times do # play 3 cards
+              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)
+                  else
+                    self.players[turn].play_card(card)
+                  end
+                  break
+                end
+              end
+            end
+            
+            turn = subject.get_turn
+            
+            # We can undo all the way to the bank baby
+            expect(subject.undo!).to eq(true)
+            expect(subject.play.get_current_trick.cards.compact.size).to eq(4)
+            expect(subject.get_turn).to eq(turn-1 % 4)
+            
+            p1 = subject.play.whose_turn
+            expect(subject.undo!).to eq(true)
+            p2 = subject.play.whose_turn
+            
+            expect(p1).to_not eq(p2)
+            count = subject.board.deal.hands[p2].size
+            
+            expect(subject.play.get_current_trick.cards.compact.size).to eq(3)
+            expect(subject.board.deal.hands[p2].size).to eq(count+1)
+            
+            expect(subject.undo!).to eq(true)
+            expect(subject.play.get_current_trick.cards.compact.size).to eq(2)
+            
+            expect(subject.undo!).to eq(true)
+            expect(subject.play.get_current_trick.cards.compact.size).to eq(1)
+            
+            expect(subject.undo!).to eq(true)
+            expect(subject.play.get_current_trick.cards.compact.size).to eq(0)
+            
+            expect(subject.undo!).to eq(false)
+            expect(subject.play.get_current_trick.cards.compact.size).to eq(0)
+          end
         end
       end
       
@@ -142,27 +228,27 @@ describe Game do
       
         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)
+          expect(state).to be_a(Hash)
+          expect(state[:auction].size).to eq(13)
+          expect(state[:available_calls]).to eq([])
+          expect(state[:play]).to be_a(Hash)
+          expect(state[:state]).to eq(:playing)
+          expect(state[:turn]).to eq(2) # this is now game turn
+          expect(Strain.name(state[:play][:trumps])).to eq('heart')
+          expect(state[:contract][:bid].to_s).to eq('two heart')
+          expect(Direction.name(state[:play][:declarer])).to eq('east')
+          expect(Direction.name(state[:play][:dummy])).to eq('west')
+          expect(state[:play][:declarer_trick_count]).to eq(0)
+          expect(state[:play][:defender_trick_count]).to eq(0)
+          expect(state[:play][:tricks]).to be_a(Array)
+          expect(state[:play][:tricks].size).to 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')
+          expect(state['state']).to eq('playing')
+          expect(state['auction'].size).to eq(13)
+          expect(state['auction'].first).to eq('pass')
         end
         
         context 'in play' do
@@ -178,61 +264,59 @@ describe Game do
             # 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 })
+            expect(dummy).to eq(3)
+            expect(state['play']['played'][@turn.to_s].first).to eq(@card.to_s)
+            expect(state['board']['deal'][dummy.to_s]).to 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)
+            expect(subject.results.size).to eq(1)
+            expect(subject.state).to 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)
+            expect(result.claimed_by).to eq(Direction.north)
+            expect(result.claimed).to eq(9)
+            expect(result.tricks_made).to eq(4)
+            expect(result.score).to 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)
+            expect(subject.results.size).to eq(1)
+            expect(subject.state).to 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)
+            expect(result.claimed_by).to eq(Direction.north)
+            expect(result.claimed).to eq(0)
+            expect(result.tricks_made).to eq(13)
+            expect(result.score).to 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
+            expect(subject.results.size).to eq(1)
+            expect(subject.state).to eq(:finished)
             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)
+            expect(result.claimed_by).to eq(Direction.east)
+            expect(result.claimed).to eq(9)
+            expect(result.tricks_made).to eq(9)
+            expect(result.score).to 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
+            expect(subject.results.size).to eq(1)
+            expect(subject.state).to eq(:finished)
             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)
+            expect(result.claimed_by).to eq(Direction.east)
+            expect(result.claimed).to eq(0)
+            expect(result.tricks_made).to eq(0)
+            expect(result.score).to eq(-800)
           end
         end
       end
     end  
     
-    # All players pass, game should finish without reaching play
+    # All players pass, game ).to finish without reaching play
     it 'should finish without reaching play if passed out' do
       subject.start!(board)
       turn = board.dealer  # Avoid calling getTurn.
@@ -240,13 +324,13 @@ describe Game do
         players[i].make_call(Pass.new) # Each player passes.
         turn = Direction[(turn+1) % Direction.size]
       end
-      turn.should eq(board.dealer) # Sanity check.
+      expect(turn).to 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
+      expect(subject.in_progress?).to eq(false)
+      expect(subject.state).to eq(:finished)
+      expect { players[turn].make_call(Bid.new(Level.one, Strain.club)) }.to raise_error(Bridge::GameError)
+      expect { players[turn].play_card(board.deal.hands[turn].first) }.to raise_error(Bridge::GameError)
     end
     
     # Play through a sample game.
@@ -265,27 +349,27 @@ describe Game do
         players[turn].make_call(call)
       end
       
-      subject.state.should eq(:playing)
-      subject.auction.complete?.should eq(true)
-      subject.play.should_not eq(nil)
+      expect(subject.state).to eq(:playing)
+      expect(subject.auction.complete?).to eq(true)
+      expect(subject.play).to_not eq(nil)
       
       while not subject.play.complete?
-        subject.state.should eq(:playing)
+        expect(subject.state).to 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)
+              expect(self.players[subject.play.declarer].play_card(card)).to eq(true)
             else
-              self.players[turn].play_card(card).should eq(true)
+              expect(self.players[turn].play_card(card)).to eq(true)
             end
             break
           end
         end
       end
-      subject.state.should eq(:finished)
-      subject.in_progress?.should eq(false) # Game complete.
+      expect(subject.state).to eq(:finished)
+      expect(subject.in_progress?).to eq(false) # Game complete.
     end
   end
 end