sunspot 2.2.7 → 2.2.8

data/spec/api/session_proxy/class_sharding_session_proxy_spec.rb

@@ -9,8 +9,8 @@ describe Sunspot::SessionProxy::ClassShardingSessionProxy do
     it "should delegate #{method} to appropriate shard" do
       post = Post.new
       photo = Photo.new
-      @proxy.post_session.should_receive(method).with([post])
-      @proxy.photo_session.should_receive(method).with([photo])
+      expect(@proxy.post_session).to receive(method).with([post])
+      expect(@proxy.photo_session).to receive(method).with([photo])
       @proxy.send(method, post)
       @proxy.send(method, photo)
     end
@@ -18,14 +18,14 @@ describe Sunspot::SessionProxy::ClassShardingSessionProxy do
 
   [:remove_by_id, :remove_by_id!].each do |method|
     it "should delegate #{method} to appropriate shard" do
-      @proxy.post_session.should_receive(method).with(Post, [1])
-      @proxy.photo_session.should_receive(method).with(Photo, [1])
+      expect(@proxy.post_session).to receive(method).with(Post, [1])
+      expect(@proxy.photo_session).to receive(method).with(Photo, [1])
       @proxy.send(method, Post, 1)
       @proxy.send(method, Photo, 1)
     end
     it "should delegate #{method} to appropriate shard given ids" do
-      @proxy.post_session.should_receive(method).with(Post, [1, 2])
-      @proxy.photo_session.should_receive(method).with(Photo, [1, 2])
+      expect(@proxy.post_session).to receive(method).with(Post, [1, 2])
+      expect(@proxy.photo_session).to receive(method).with(Photo, [1, 2])
       @proxy.send(method, Post, 1, 2)
       @proxy.send(method, Photo, [1, 2])
     end
@@ -33,15 +33,15 @@ describe Sunspot::SessionProxy::ClassShardingSessionProxy do
 
   [:remove_all, :remove_all!].each do |method|
     it "should delegate #{method} with argument to appropriate shard" do
-      @proxy.post_session.should_receive(method).with(Post)
-      @proxy.photo_session.should_receive(method).with(Photo)
+      expect(@proxy.post_session).to receive(method).with(Post)
+      expect(@proxy.photo_session).to receive(method).with(Photo)
       @proxy.send(method, Post)
       @proxy.send(method, Photo)
     end
 
     it "should delegate #{method} without argument to all shards" do
-      @proxy.post_session.should_receive(method)
-      @proxy.photo_session.should_receive(method)
+      expect(@proxy.post_session).to receive(method)
+      expect(@proxy.photo_session).to receive(method)
       @proxy.send(method)
     end
   end
@@ -49,42 +49,43 @@ describe Sunspot::SessionProxy::ClassShardingSessionProxy do
   [:commit, :commit_if_dirty, :commit_if_delete_dirty, :optimize].each do |method|
     it "should delegate #{method} to all sessions" do
       [@proxy.post_session, @proxy.photo_session].each do |session|
-        session.should_receive(method)
+        expect(session).to receive(method)
       end
       @proxy.send(method)
     end
   end
 
   it "should not support the :batch method" do
-    lambda { @proxy.batch }.should raise_error(Sunspot::SessionProxy::NotSupportedError)
+    expect { @proxy.batch }.to raise_error(Sunspot::SessionProxy::NotSupportedError)
   end
 
   it "should delegate new_search to search session, adding in shards parameter" do
     search = @proxy.new_search(Post)
-    search.query[:shards].should ==
+    expect(search.query[:shards]).to eq(
       'http://photos.solr.local/solr,http://posts.solr.local/solr'
+    )
   end
 
   it "should delegate search to search session, adding in shards parameter" do
     @proxy.search(Post)
-    connection.should have_last_search_with(
+    expect(connection).to have_last_search_with(
       :shards => 'http://photos.solr.local/solr,http://posts.solr.local/solr'
     )
   end
 
   [:dirty, :delete_dirty].each do |method|
     it "should be dirty if any of the sessions are dirty" do
-      @proxy.post_session.stub(:"#{method}?").and_return(true)
-      @proxy.should send("be_#{method}")
+      allow(@proxy.post_session).to receive(:"#{method}?").and_return(true)
+      expect(@proxy).to send("be_#{method}")
     end
 
     it "should not be dirty if none of the sessions are dirty" do
-      @proxy.should_not send("be_#{method}")
+      expect(@proxy).not_to send("be_#{method}")
     end
   end
 
   it "should raise a NotSupportedError when :config is called" do
-    lambda { @proxy.config }.should raise_error(Sunspot::SessionProxy::NotSupportedError)
+    expect { @proxy.config }.to raise_error(Sunspot::SessionProxy::NotSupportedError)
   end
 
   it_should_behave_like 'session proxy'

data/spec/api/session_proxy/id_sharding_session_proxy_spec.rb

@@ -10,8 +10,8 @@ describe Sunspot::SessionProxy::ShardingSessionProxy do
   [:index, :index!, :remove, :remove!].each do |method|
     it "should delegate #{method} to appropriate shard" do
       posts = [Post.new(:id => 2), Post.new(:id => 1)]
-      @proxy.sessions[0].should_receive(method).with([posts[0]])
-      @proxy.sessions[1].should_receive(method).with([posts[1]])
+      expect(@proxy.sessions[0]).to receive(method).with([posts[0]])
+      expect(@proxy.sessions[1]).to receive(method).with([posts[1]])
       @proxy.send(method, posts[0])
       @proxy.send(method, posts[1])
     end
@@ -19,21 +19,21 @@ describe Sunspot::SessionProxy::ShardingSessionProxy do
 
   [:remove_by_id, :remove_by_id!].each do |method|
     it "should delegate #{method} to appropriate session" do
-      @proxy.sessions[1].should_receive(method).with(Post, [3])
-      @proxy.sessions[0].should_receive(method).with(Post, [2])
-      @proxy.sessions[1].should_receive(method).with(Post, [1])
+      expect(@proxy.sessions[1]).to receive(method).with(Post, [3])
+      expect(@proxy.sessions[0]).to receive(method).with(Post, [2])
+      expect(@proxy.sessions[1]).to receive(method).with(Post, [1])
       @proxy.send(method, Post, 1)
       @proxy.send(method, Post, 2)
       @proxy.send(method, Post, 3)
     end
     it "should delegate #{method} to appropriate session given splatted index ids" do
-      @proxy.sessions[0].should_receive(method).with(Post, [2])
-      @proxy.sessions[1].should_receive(method).with(Post, [1, 3])
+      expect(@proxy.sessions[0]).to receive(method).with(Post, [2])
+      expect(@proxy.sessions[1]).to receive(method).with(Post, [1, 3])
       @proxy.send(method, Post, 1, 2, 3)
     end
     it "should delegate #{method} to appropriate session given array of index ids" do
-      @proxy.sessions[0].should_receive(method).with(Post, [2])
-      @proxy.sessions[1].should_receive(method).with(Post, [1, 3])
+      expect(@proxy.sessions[0]).to receive(method).with(Post, [2])
+      expect(@proxy.sessions[1]).to receive(method).with(Post, [1, 3])
       @proxy.send(method, Post, [1, 2, 3])
     end
   end

data/spec/api/session_proxy/master_slave_session_proxy_spec.rb

@@ -13,28 +13,32 @@ describe Sunspot::SessionProxy::MasterSlaveSessionProxy do
     methods.each do |method|
       it "should delegate #{method} to #{delegate}" do
         args = Array.new(Sunspot::Session.instance_method(method).arity.abs) do
-          stub('arg')
+          double('arg')
+        end
+        if args.empty?
+          expect(instance_variable_get(:"@#{delegate}")).to receive(method).with(no_args)
+        else
+          expect(instance_variable_get(:"@#{delegate}")).to receive(method).with(*args)
         end
-        instance_variable_get(:"@#{delegate}").should_receive(method).with(*args)
         @proxy.send(method, *args)
       end
     end
   end
 
   it 'should return master session config by default' do
-    @proxy.config.should eql(@master_session.config)
+    expect(@proxy.config).to eql(@master_session.config)
   end
 
   it 'should return master session config when specified' do
-    @proxy.config(:master).should eql(@master_session.config)
+    expect(@proxy.config(:master)).to eql(@master_session.config)
   end
 
   it 'should return slave session config when specified' do
-    @proxy.config(:slave).should eql(@slave_session.config)
+    expect(@proxy.config(:slave)).to eql(@slave_session.config)
   end
 
   it 'should raise ArgumentError when bogus config specified' do
-    lambda { @proxy.config(:bogus) }.should raise_error
+    expect { @proxy.config(:bogus) }.to raise_error
   end
 
   it_should_behave_like 'session proxy'

data/spec/api/session_proxy/retry_5xx_session_proxy_spec.rb

@@ -33,14 +33,14 @@ describe Sunspot::SessionProxy::Retry5xxSessionProxy do
   end
 
   it "should behave normally without a stubbed exception" do
-    @sunspot_session.should_receive(:index).and_return(double)
+    expect(@sunspot_session).to receive(:index).and_return(double)
     Sunspot.index(post)
   end
 
   it "should be successful with a single exception followed by a sucess" do
     e = FakeRSolrErrorHttp.new(fake_rsolr_request, fake_rsolr_response(503))
-    @sunspot_session.should_receive(:index).and_return do
-      @sunspot_session.should_receive(:index).and_return(double)
+    expect(@sunspot_session).to receive(:index) do
+      expect(@sunspot_session).to receive(:index).and_return(double)
       raise e
     end
     Sunspot.index(post)
@@ -51,23 +51,23 @@ describe Sunspot::SessionProxy::Retry5xxSessionProxy do
     e = FakeRSolrErrorHttp.new(fake_rsolr_request, fake_response)
     fake_success = double('success')
 
-    @sunspot_session.should_receive(:index).and_return do
-      @sunspot_session.should_receive(:index).and_return do
-        @sunspot_session.stub(:index).and_return(fake_success)
+    expect(@sunspot_session).to receive(:index) do
+      expect(@sunspot_session).to receive(:index) do
+        allow(@sunspot_session).to receive(:index).and_return(fake_success)
         raise e
       end
       raise e
     end
 
     response = Sunspot.index(post)
-    response.should_not == fake_success
-    response.should == fake_response
+    expect(response).not_to eq(fake_success)
+    expect(response).to eq(fake_response)
   end
 
   it "should not retry a 4xx" do
     e = FakeRSolrErrorHttp.new(fake_rsolr_request, fake_rsolr_response(400))
-    @sunspot_session.should_receive(:index).and_raise(e)
-    lambda { Sunspot.index(post) }.should raise_error
+    expect(@sunspot_session).to receive(:index).and_raise(e)
+    expect { Sunspot.index(post) }.to raise_error
   end
 
   # TODO: try against more than just Sunspot.index? but that's just testing the

data/spec/api/session_proxy/sharding_session_proxy_spec.rb

@@ -8,8 +8,8 @@ describe Sunspot::SessionProxy::ShardingSessionProxy do
   [:index, :index!, :remove, :remove!].each do |method|
     it "should delegate #{method} to appropriate shard" do
       posts = [Post.new(:blog_id => 2), Post.new(:blog_id => 3)]
-      @proxy.sessions[0].should_receive(method).with([posts[0]])
-      @proxy.sessions[1].should_receive(method).with([posts[1]])
+      expect(@proxy.sessions[0]).to receive(method).with([posts[0]])
+      expect(@proxy.sessions[1]).to receive(method).with([posts[1]])
       @proxy.send(method, posts[0])
       @proxy.send(method, posts[1])
     end
@@ -17,17 +17,17 @@ describe Sunspot::SessionProxy::ShardingSessionProxy do
 
   [:remove_by_id, :remove_by_id!, :atomic_update, :atomic_update!].each do |method|
     it "should raise NotSupportedError when #{method} called" do
-      lambda { @proxy.send(method, Post, 1) }.should raise_error(Sunspot::SessionProxy::NotSupportedError)
+      expect { @proxy.send(method, Post, 1) }.to raise_error(Sunspot::SessionProxy::NotSupportedError)
     end
   end
 
   [:remove_all, :remove_all!].each do |method|
     it "should raise NotSupportedError when #{method} called with argument" do
-      lambda { @proxy.send(method, Post) }.should raise_error(Sunspot::SessionProxy::NotSupportedError)
+      expect { @proxy.send(method, Post) }.to raise_error(Sunspot::SessionProxy::NotSupportedError)
     end
 
     it "should delegate #{method} without argument to all shards" do
-      @proxy.sessions.each { |session| session.should_receive(method) }
+      @proxy.sessions.each { |session| expect(session).to receive(method) }
       @proxy.send(method)
     end
   end
@@ -35,42 +35,43 @@ describe Sunspot::SessionProxy::ShardingSessionProxy do
   [:commit, :commit_if_dirty, :commit_if_delete_dirty, :optimize].each do |method|
     it "should delegate #{method} to all sessions" do
       @proxy.sessions.each do |session|
-        session.should_receive(method)
+        expect(session).to receive(method)
       end
       @proxy.send(method)
     end
   end
 
   it "should not support the :batch method" do
-    lambda { @proxy.batch }.should raise_error(Sunspot::SessionProxy::NotSupportedError)
+    expect { @proxy.batch }.to raise_error(Sunspot::SessionProxy::NotSupportedError)
   end
 
   it "should delegate new_search to search session, adding in shards parameter" do
     search = @proxy.new_search(Post)
-    search.query[:shards].should ==
+    expect(search.query[:shards]).to eq(
       'http://localhost:8980/solr,http://localhost:8981/solr'
+    )
   end
 
   it "should delegate search to search session, adding in shards parameter" do
     @proxy.search(Post)
-    connection.should have_last_search_with(
+    expect(connection).to have_last_search_with(
       :shards => 'http://localhost:8980/solr,http://localhost:8981/solr'
     )
   end
 
   [:dirty, :delete_dirty].each do |method|
     it "should be dirty if any of the sessions are dirty" do
-      @proxy.sessions[0].stub(:"#{method}?").and_return(true)
-      @proxy.should send("be_#{method}")
+      allow(@proxy.sessions[0]).to receive(:"#{method}?").and_return(true)
+      expect(@proxy).to send("be_#{method}")
     end
 
     it "should not be dirty if none of the sessions are dirty" do
-      @proxy.should_not send("be_#{method}")
+      expect(@proxy).not_to send("be_#{method}")
     end
   end
 
   it "should raise a NotSupportedError when :config is called" do
-    lambda { @proxy.config }.should raise_error(Sunspot::SessionProxy::NotSupportedError)
+    expect { @proxy.config }.to raise_error(Sunspot::SessionProxy::NotSupportedError)
   end
 
   it_should_behave_like 'session proxy'

data/spec/api/session_proxy/silent_fail_session_proxy_spec.rb

@@ -13,8 +13,8 @@ describe Sunspot::SessionProxy::ShardingSessionProxy do
   it "should call rescued_exception when an exception is caught" do
     SUPPORTED_METHODS.each do |method|
       e = FakeException.new(method)
-      @search_session.stub(method).and_raise(e)
-      @proxy.should_receive(:rescued_exception).with(method, e)
+      allow(@search_session).to receive(method).and_raise(e)
+      expect(@proxy).to receive(:rescued_exception).with(method, e)
       @proxy.send(method)
     end
   end

data/spec/api/session_proxy/spec_helper.rb

@@ -3,7 +3,7 @@ require File.expand_path('spec_helper', File.join(File.dirname(__FILE__), '..'))
 shared_examples_for 'session proxy' do
   Sunspot::Session.public_instance_methods(false).each do |method|
     it "should respond to #{method.inspect}" do
-      @proxy.should respond_to(method)
+      expect(@proxy).to respond_to(method)
     end
   end
 end

data/spec/api/session_proxy/thread_local_session_proxy_spec.rb

@@ -17,7 +17,7 @@ describe Sunspot::SessionProxy::ThreadLocalSessionProxy do
     end
 
     it 'should have the same session for the same thread' do
-      @proxy.session.should eql(@proxy.session)
+      expect(@proxy.session).to eql(@proxy.session)
     end
 
     it 'should not have the same session for different threads' do
@@ -26,20 +26,24 @@ describe Sunspot::SessionProxy::ThreadLocalSessionProxy do
       Thread.new do
         session2 = @proxy.session
       end.join
-      session1.should_not eql(session2)
+      expect(session1).not_to eql(session2)
     end
 
     it 'should not have the same session for the same thread in different proxy instances' do
       proxy2 = Sunspot::SessionProxy::ThreadLocalSessionProxy.new(@config)
-      @proxy.session.should_not eql(proxy2.session)
+      expect(@proxy.session).not_to eql(proxy2.session)
     end
 
     (Sunspot::Session.public_instance_methods(false) - ['config', :config]).each do |method|
       it "should delegate #{method.inspect} to its session" do
         args = Array.new(Sunspot::Session.instance_method(method).arity.abs) do
-          stub('arg')
+          double('arg')
+        end
+        if args.empty?
+          expect(@proxy.session).to receive(method).with(no_args)
+        else
+          expect(@proxy.session).to receive(method).with(*args)
         end
-        @proxy.session.should_receive(method).with(*args)
         @proxy.send(method, *args)
       end
     end

data/spec/api/session_spec.rb

@@ -7,7 +7,7 @@ shared_examples_for 'all sessions' do
     end
 
     it 'should add document to connection' do
-      connection.should have(1).adds
+      expect(connection.adds.size).to eq(1)
     end
   end
 
@@ -17,11 +17,11 @@ shared_examples_for 'all sessions' do
     end
 
     it 'should add document to connection' do
-      connection.should have(1).adds
+      expect(connection.adds.size).to eq(1)
     end
 
     it 'should commit' do
-      connection.should have(1).commits
+      expect(connection.commits.size).to eq(1)
     end
   end
 
@@ -31,27 +31,27 @@ shared_examples_for 'all sessions' do
     end
 
     it 'should commit' do
-      connection.should have(1).commits
+      expect(connection.commits.size).to eq(1)
     end
   end
 
   context '#commit(bool)' do
     it 'should soft-commit if bool=true' do
       @session.commit(true)
-      connection.should have(1).commits
-      connection.should have(1).soft_commits
+      expect(connection.commits.size).to eq(1)
+      expect(connection.soft_commits.size).to eq(1)
     end
 
     it 'should hard-commit if bool=false' do
       @session.commit(false)
-      connection.should have(1).commits
-      connection.should have(0).soft_commits
+      expect(connection.commits.size).to eq(1)
+      expect(connection.soft_commits.size).to eq(0)
     end
 
     it 'should hard-commit if bool is not specified' do
       @session.commit
-      connection.should have(1).commits
-      connection.should have(0).soft_commits
+      expect(connection.commits.size).to eq(1)
+      expect(connection.soft_commits.size).to eq(0)
     end
   end
 
@@ -61,7 +61,7 @@ shared_examples_for 'all sessions' do
     end
 
     it 'should optimize' do
-      connection.should have(1).optims
+      expect(connection.optims.size).to eq(1)
     end
   end
 
@@ -71,7 +71,7 @@ shared_examples_for 'all sessions' do
     end
 
     it 'should search' do
-      connection.should have(1).searches
+      expect(connection.searches.size).to eq(1)
     end
   end
 end
@@ -97,31 +97,31 @@ describe 'Session' do
 
     it 'should open connection with defaults if nothing specified' do
       Sunspot.commit
-      connection.opts[:url].should == 'http://127.0.0.1:8983/solr/default'
+      expect(connection.opts[:url]).to eq('http://127.0.0.1:8983/solr/default')
     end
 
     it 'should open a connection with custom host' do
       Sunspot.config.solr.url = 'http://127.0.0.1:8981/solr'
       Sunspot.commit
-      connection.opts[:url].should == 'http://127.0.0.1:8981/solr'
+      expect(connection.opts[:url]).to eq('http://127.0.0.1:8981/solr')
     end
 
     it 'should open a connection with custom read timeout' do
       Sunspot.config.solr.read_timeout = 0.5
       Sunspot.commit
-      connection.opts[:read_timeout].should == 0.5
+      expect(connection.opts[:read_timeout]).to eq(0.5)
     end
 
     it 'should open a connection with custom open timeout' do
       Sunspot.config.solr.open_timeout = 0.5
       Sunspot.commit
-      connection.opts[:open_timeout].should == 0.5
+      expect(connection.opts[:open_timeout]).to eq(0.5)
     end
 
     it 'should open a connection through a provided proxy' do
       Sunspot.config.solr.proxy = 'http://proxy.com:1234'
       Sunspot.commit
-      connection.opts[:proxy].should == 'http://proxy.com:1234'
+      expect(connection.opts[:proxy]).to eq('http://proxy.com:1234')
     end
   end
 
@@ -137,7 +137,7 @@ describe 'Session' do
         config.solr.url = 'http://127.0.0.1:8982/solr'
       end
       session.commit
-      connection.opts[:url].should == 'http://127.0.0.1:8982/solr'
+      expect(connection.opts[:url]).to eq('http://127.0.0.1:8982/solr')
     end
   end
 
@@ -147,120 +147,120 @@ describe 'Session' do
     end
 
     it 'should start out not dirty' do
-      @session.dirty?.should be_false
+      expect(@session.dirty?).to be(false)
     end
 
     it 'should start out not delete_dirty' do
-      @session.delete_dirty?.should be_false
+      expect(@session.delete_dirty?).to be(false)
     end
 
     it 'should be dirty after adding an item' do
       @session.index(Post.new)
-      @session.dirty?.should be_true
+      expect(@session.dirty?).to be(true)
     end
 
     it 'should be not be delete_dirty after adding an item' do
       @session.index(Post.new)
-      @session.delete_dirty?.should be_false
+      expect(@session.delete_dirty?).to be(false)
     end
 
     it 'should be dirty after deleting an item' do
       @session.remove(Post.new)
-      @session.dirty?.should be_true
+      expect(@session.dirty?).to be(true)
     end
 
     it 'should be delete_dirty after deleting an item' do
       @session.remove(Post.new)
-      @session.delete_dirty?.should be_true
+      expect(@session.delete_dirty?).to be(true)
     end
 
     it 'should be dirty after a remove_all for a class' do
       @session.remove_all(Post)
-      @session.dirty?.should be_true
+      expect(@session.dirty?).to be(true)
     end
 
     it 'should be delete_dirty after a remove_all for a class' do
       @session.remove_all(Post)
-      @session.delete_dirty?.should be_true
+      expect(@session.delete_dirty?).to be(true)
     end
 
     it 'should be dirty after a global remove_all' do
       @session.remove_all
-      @session.dirty?.should be_true
+      expect(@session.dirty?).to be(true)
     end
 
     it 'should be delete_dirty after a global remove_all' do
       @session.remove_all
-      @session.delete_dirty?.should be_true
+      expect(@session.delete_dirty?).to be(true)
     end
 
     it 'should not be dirty after a commit' do
       @session.index(Post.new)
       @session.commit
-      @session.dirty?.should be_false
+      expect(@session.dirty?).to be(false)
     end
 
     it 'should not be dirty after an optimize' do
       @session.index(Post.new)
       @session.optimize
-      @session.dirty?.should be_false
+      expect(@session.dirty?).to be(false)
     end
 
     it 'should not be delete_dirty after a commit' do
       @session.remove(Post.new)
       @session.commit
-      @session.delete_dirty?.should be_false
+      expect(@session.delete_dirty?).to be(false)
     end
 
     it 'should not be delete_dirty after an optimize' do
       @session.remove(Post.new)
       @session.optimize
-      @session.delete_dirty?.should be_false
+      expect(@session.delete_dirty?).to be(false)
     end
 
     it 'should not commit when commit_if_dirty called on clean session' do
       @session.commit_if_dirty
-      connection.should have(0).commits
+      expect(connection.commits.size).to eq(0)
     end
 
     it 'should not commit when commit_if_delete_dirty called on clean session' do
       @session.commit_if_delete_dirty
-      connection.should have(0).commits
+      expect(connection.commits.size).to eq(0)
     end
 
     it 'should hard commit when commit_if_dirty called on dirty session' do
       @session.index(Post.new)
       @session.commit_if_dirty
-      connection.should have(1).commits
+      expect(connection.commits.size).to eq(1)
     end
 
     it 'should soft commit when commit_if_dirty called on dirty session' do
       @session.index(Post.new)
       @session.commit_if_dirty(true)
-      connection.should have(1).commits
-      connection.should have(1).soft_commits
+      expect(connection.commits.size).to eq(1)
+      expect(connection.soft_commits.size).to eq(1)
     end
 
     it 'should hard commit when commit_if_delete_dirty called on delete_dirty session' do
       @session.remove(Post.new)
       @session.commit_if_delete_dirty
-      connection.should have(1).commits
+      expect(connection.commits.size).to eq(1)
     end
 
     it 'should soft commit when commit_if_delete_dirty called on delete_dirty session' do
       @session.remove(Post.new)
       @session.commit_if_delete_dirty(true)
-      connection.should have(1).commits
-      connection.should have(1).soft_commits
+      expect(connection.commits.size).to eq(1)
+      expect(connection.soft_commits.size).to eq(1)
     end
   end
 
   context 'session proxy' do
     it 'should send messages to manually assigned session proxy' do
-      stub_session = stub('session')
+      stub_session = double('session')
       Sunspot.session = stub_session
       post = Post.new
-      stub_session.should_receive(:index).with(post)
+      expect(stub_session).to receive(:index).with(post)
       Sunspot.index(post)
       Sunspot.reset!
     end