sunspot 2.2.7 → 2.5.0

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

data/spec/api/sunspot_spec.rb

@@ -7,8 +7,8 @@ describe Sunspot do
       Sunspot.setup(User) do
         text :name
       end
-      Sunspot.searchable.should_not be_empty
-      Sunspot.searchable.should include(User)
+      expect(Sunspot.searchable).not_to be_empty
+      expect(Sunspot.searchable).to include(User)
     end
   end
 
@@ -16,14 +16,17 @@ describe Sunspot do
     it "should reset current session" do
       old_session = Sunspot.send(:session)
       Sunspot.reset!(true)
-      Sunspot.send(:session).should_not == old_session
+      expect(Sunspot.send(:session)).not_to eq(old_session)
     end
 
     it "should keep keep configuration if specified" do
       Sunspot.config.solr.url = "http://localhost:9999/path/solr"
       config_before_reset = Sunspot.config
       Sunspot.reset!(true)
-      Sunspot.config.should == config_before_reset
+      expect(Sunspot.config).to eq(config_before_reset)
+
+      # Restore sunspot config after test
+      Sunspot.reset!(false)
     end
   end
 end

data/spec/helpers/integration_helper.rb

@@ -2,6 +2,7 @@ module IntegrationHelper
   def self.included(base)
     base.before(:all) do
       Sunspot.config.solr.url = ENV['SOLR_URL'] || 'http://localhost:8983/solr/default'
+      Sunspot.config.solr.update_format = ENV['UPDATE_FORMAT'].to_sym if ENV['UPDATE_FORMAT']
       Sunspot.reset!(true)
     end
   end

data/spec/integration/atomic_updates_spec.rb

@@ -5,14 +5,16 @@ describe 'atomic updates' do
     Sunspot.remove_all
   end
 
-  def validate_hit(hit, title, featured)
-    hit.stored(:title).should == title
-    hit.stored(:featured).should == featured
+  def validate_hit(hit, values = {})
+    values.each do |field, value|
+      stored = hit.stored(field)
+      expect(stored).to eq(value), "expected #{value.inspect}, but got #{stored.inspect} for field '#{field}'"
+    end
   end
 
   def find_indexed_post(id)
     hit = Sunspot.search(Post).hits.find{ |h| h.primary_key.to_i == id }
-    hit.should_not be_nil
+    expect(hit).not_to be_nil
     hit
   end
 
@@ -20,13 +22,13 @@ describe 'atomic updates' do
     post = Post.new(title: 'A Title', featured: true)
     Sunspot.index!(post)
     
-    validate_hit(find_indexed_post(post.id), post.title, post.featured)
+    validate_hit(find_indexed_post(post.id), title: post.title, featured: post.featured)
 
     Sunspot.atomic_update!(Post, post.id => {title: 'A New Title'})
-    validate_hit(find_indexed_post(post.id), 'A New Title', true)
+    validate_hit(find_indexed_post(post.id), title: 'A New Title', featured: true)
 
     Sunspot.atomic_update!(Post, post.id => {featured: false})
-    validate_hit(find_indexed_post(post.id), 'A New Title', false)
+    validate_hit(find_indexed_post(post.id), title: 'A New Title', featured: false)
   end
 
   it 'should update fields for multiple records' do
@@ -34,11 +36,23 @@ describe 'atomic updates' do
     post2 = Post.new(title: 'A Second Title', featured: false)
     Sunspot.index!(post1, post2)
 
-    validate_hit(find_indexed_post(post1.id), post1.title, post1.featured)
-    validate_hit(find_indexed_post(post2.id), post2.title, post2.featured)
+    validate_hit(find_indexed_post(post1.id), title: post1.title, featured: post1.featured)
+    validate_hit(find_indexed_post(post2.id), title: post2.title, featured: post2.featured)
 
     Sunspot.atomic_update!(Post, post1.id => {title: 'A New Title'}, post2.id => {featured: true})
-    validate_hit(find_indexed_post(post1.id), 'A New Title', true)
-    validate_hit(find_indexed_post(post2.id), 'A Second Title', true)
+    validate_hit(find_indexed_post(post1.id), title: 'A New Title', featured: true)
+    validate_hit(find_indexed_post(post2.id), title: 'A Second Title', featured: true)
+  end
+
+  it 'should clear field value properly' do
+    post = Post.new(title: 'A Title', tags: %w(tag1 tag2), featured: true)
+    Sunspot.index!(post)
+    validate_hit(find_indexed_post(post.id), title: post.title, tag_list: post.tags, featured: true)
+
+    Sunspot.atomic_update!(Post, post.id => {tag_list: []})
+    validate_hit(find_indexed_post(post.id), title: post.title, tag_list: nil, featured: true)
+
+    Sunspot.atomic_update!(Post, post.id => {featured: nil})
+    validate_hit(find_indexed_post(post.id), title: post.title, tag_list: nil, featured: nil)
   end
 end

data/spec/integration/dynamic_fields_spec.rb

@@ -10,11 +10,11 @@ shared_examples 'dynamic fields' do
   end
 
   it 'should search for dynamic string field' do
-    Sunspot.search(Post) do
+    expect(Sunspot.search(Post) do
       dynamic(field_name) do
         with(:cuisine, 'Pizza')
       end
-    end.results.should == [@posts.first]
+    end.results).to eq([@posts.first])
   end
 
   describe 'faceting' do
@@ -28,31 +28,31 @@ shared_examples 'dynamic fields' do
 
     it 'should return value "value" with count 2' do
       row = @search.dynamic_facet(field_name, :cuisine).rows[0]
-      row.value.should == 'Greek'
-      row.count.should == 2
+      expect(row.value).to eq('Greek')
+      expect(row.count).to eq(2)
     end
 
     it 'should return value "other" with count 1' do
       row = @search.dynamic_facet(field_name, :cuisine).rows[1]
-      row.value.should == 'Pizza'
-      row.count.should == 1
+      expect(row.value).to eq('Pizza')
+      expect(row.count).to eq(1)
     end
   end
 
   it 'should order by dynamic string field ascending' do
-    Sunspot.search(Post) do
+    expect(Sunspot.search(Post) do
       dynamic field_name do
         order_by :cuisine, :asc
       end
-    end.results.last.should == @posts.first
+    end.results.last).to eq(@posts.first)
   end
 
   it 'should order by dynamic string field descending' do
-    Sunspot.search(Post) do
+    expect(Sunspot.search(Post) do
       dynamic field_name do
         order_by :cuisine, :desc
       end
-    end.results.first.should == @posts.first
+    end.results.first).to eq(@posts.first)
   end
 end