sunspot 2.2.7 → 2.5.0

data/spec/api/search/results_spec.rb

@@ -4,15 +4,15 @@ describe 'search results', :type => :search do
   it 'loads single result' do
     post = Post.new
     stub_results(post)
-    session.search(Post).results.should == [post]
+    expect(session.search(Post).results).to eq([post])
   end
 
   it 'loads multiple results in order' do
     post_1, post_2 = Post.new, Post.new
     stub_results(post_1, post_2)
-    session.search(Post).results.should == [post_1, post_2]
+    expect(session.search(Post).results).to eq([post_1, post_2])
     stub_results(post_2, post_1)
-    session.search(Post).results.should == [post_2, post_1]
+    expect(session.search(Post).results).to eq([post_2, post_1])
   end
 
   # This is a reduction of a crazy bug I found in production where some hits
@@ -22,42 +22,42 @@ describe 'search results', :type => :search do
     Namespaced::Comment.reset!
     results = [Post.new, Namespaced::Comment.new]
     stub_results(*results)
-    session.search(Post, Namespaced::Comment).results.should == results
+    expect(session.search(Post, Namespaced::Comment).results).to eq(results)
   end
 
   it 'gracefully returns empty results when response is nil' do
     stub_nil_results
-    session.search(Post).results.should == []
+    expect(session.search(Post).results).to eq([])
   end
 
   it 'returns search total as attribute of results' do
     stub_results(Post.new, 4)
-    session.search(Post) do
+    expect(session.search(Post) do
       paginate(:page => 1)
-    end.results.total_entries.should == 4
+    end.results.total_entries).to eq(4)
   end
 
   it 'returns total' do
     stub_results(Post.new, Post.new, 4)
-    session.search(Post) { paginate(:page => 1) }.total.should == 4
+    expect(session.search(Post) { paginate(:page => 1) }.total).to eq(4)
   end
 
   it 'returns query time' do
     stub_nil_results
     connection.response['responseHeader'] = { 'QTime' => 42 }
-    session.search(Post) { paginate(:page => 1) }.query_time.should == 42
+    expect(session.search(Post) { paginate(:page => 1) }.query_time).to eq(42)
   end
 
   it 'returns total for nil search' do
     stub_nil_results
-    session.search(Post).total.should == 0
+    expect(session.search(Post).total).to eq(0)
   end
 
   it 'returns available results if some results are not available from data store' do
     posts = [Post.new, Post.new]
     posts.last.destroy
     stub_results(*posts)
-    session.search(Post).results.should == posts[0..0]
+    expect(session.search(Post).results).to eq(posts[0..0])
   end
 
   it 'does not attempt to query the data store more than once when results are unavailable' do
@@ -65,8 +65,8 @@ describe 'search results', :type => :search do
     posts.each { |post| post.destroy }
     stub_results(*posts)
     search = session.search(Post) do
-      data_accessor_for(Post).should_receive(:load_all).once.and_return([])
+      expect(data_accessor_for(Post)).to receive(:load_all).once.and_return([])
     end
-    search.results.should == []
+    expect(search.results).to eq([])
   end
 end

data/spec/api/search/search_spec.rb

@@ -6,7 +6,7 @@ describe Sunspot::Search do
     search = session.search Post do
       data_accessor_for(Post).custom_title = 'custom title'
     end
-    search.results.first.title.should == 'custom title'
+    expect(search.results.first.title).to eq('custom title')
   end
   
   it 'should re-execute search' do
@@ -14,10 +14,10 @@ describe Sunspot::Search do
     
     stub_results(post_1)
     search = session.search Post
-    search.results.should == [post_1]
+    expect(search.results).to eq([post_1])
     
     stub_results(post_2)
     search.execute!
-    search.results.should == [post_2]
+    expect(search.results).to eq([post_2])
   end
 end

data/spec/api/search/stats_spec.rb

@@ -6,7 +6,7 @@ describe 'stats', :type => :search do
     result = session.search Post do
       stats :average_rating
     end
-    result.stats(:average_rating).field_name.should == :average_rating
+    expect(result.stats(:average_rating).field_name).to eq(:average_rating)
   end
 
   it 'returns min for stats field' do
@@ -14,7 +14,7 @@ describe 'stats', :type => :search do
     result = session.search Post do
       stats :average_rating
     end
-    result.stats(:average_rating).min.should == 1.0
+    expect(result.stats(:average_rating).min).to eq(1.0)
   end
 
   it 'returns max for stats field' do
@@ -22,7 +22,7 @@ describe 'stats', :type => :search do
     result = session.search Post do
       stats :average_rating
     end
-    result.stats(:average_rating).max.should == 5.0
+    expect(result.stats(:average_rating).max).to eq(5.0)
   end
 
   it 'returns count for stats field' do
@@ -30,7 +30,7 @@ describe 'stats', :type => :search do
     result = session.search Post do
       stats :average_rating
     end
-    result.stats(:average_rating).count.should == 120
+    expect(result.stats(:average_rating).count).to eq(120)
   end
 
   it 'returns sum for stats field' do
@@ -38,7 +38,7 @@ describe 'stats', :type => :search do
     result = session.search Post do
       stats :average_rating
     end
-    result.stats(:average_rating).sum.should == 2200.0
+    expect(result.stats(:average_rating).sum).to eq(2200.0)
   end
 
   it 'returns facet rows for stats field' do
@@ -51,7 +51,7 @@ describe 'stats', :type => :search do
         facet :featured
       end
     end
-    stats_facet_values(result, :average_rating, :featured).should == [false, true]
+    expect(stats_facet_values(result, :average_rating, :featured)).to eq([false, true])
   end
 
   it 'returns facet stats for stats field' do
@@ -63,8 +63,8 @@ describe 'stats', :type => :search do
         facet :featured
       end
     end
-    stats_facet_stats(result, :average_rating, :featured, true).min.should == 2.0
-    stats_facet_stats(result, :average_rating, :featured, true).max.should == 4.0
+    expect(stats_facet_stats(result, :average_rating, :featured, true).min).to eq(2.0)
+    expect(stats_facet_stats(result, :average_rating, :featured, true).max).to eq(4.0)
   end
 
   it 'returns instantiated stats facet values' do
@@ -76,7 +76,7 @@ describe 'stats', :type => :search do
         facet :blog_id
       end
     end
-    search.stats(:average_rating).facet(:blog_id).rows.map { |row| row.instance }.should == blogs
+    expect(search.stats(:average_rating).facet(:blog_id).rows.map { |row| row.instance }).to eq(blogs)
   end
 
   it 'only returns verified instances when requested' do
@@ -89,6 +89,6 @@ describe 'stats', :type => :search do
         facet :blog_id
       end
     end
-    search.stats(:average_rating).facet(:blog_id).rows(:verified => true).map { |row| row.instance }.should == [blog]
+    expect(search.stats(:average_rating).facet(:blog_id).rows(:verified => true).map { |row| row.instance }).to eq([blog])
   end
 end

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