sunspot 2.2.7 → 2.2.8

data/spec/api/indexer/attributes_spec.rb

@@ -4,151 +4,151 @@ require 'bigdecimal'
 describe 'indexing attribute fields', :type => :indexer do
   it 'should correctly index a stored string attribute field' do
     session.index(post(:title => 'A Title'))
-    connection.should have_add_with(:title_ss => 'A Title')
+    expect(connection).to have_add_with(:title_ss => 'A Title')
   end
 
   it 'should correctly index an integer attribute field' do
     session.index(post(:blog_id => 4))
-    connection.should have_add_with(:blog_id_i => '4')
+    expect(connection).to have_add_with(:blog_id_i => '4')
   end
 
   it 'should correctly index a long attribute field' do
     session.index(Namespaced::Comment.new(:hash => 2**30))
-    connection.should have_add_with(:hash_l => '1073741824')
+    expect(connection).to have_add_with(:hash_l => '1073741824')
   end
 
   it 'should correctly index a float attribute field' do
     session.index(post(:ratings_average => 2.23))
-    connection.should have_add_with(:average_rating_ft => '2.23')
+    expect(connection).to have_add_with(:average_rating_ft => '2.23')
   end
 
   it 'should correctly index a double attribute field' do
     session.index(Namespaced::Comment.new(:average_rating => 2.23))
-    connection.should have_add_with(:average_rating_e => '2.23')
+    expect(connection).to have_add_with(:average_rating_e => '2.23')
   end
 
   it 'should correctly index a trie integer attribute field' do
     session.index(Photo.new(:size => 104856))
-    connection.should have_add_with(:size_it => '104856')
+    expect(connection).to have_add_with(:size_it => '104856')
   end
 
   it 'should correctly index a trie float attribute field' do
     session.index(Photo.new(:average_rating => 2.23))
-    connection.should have_add_with(:average_rating_ft => '2.23')
+    expect(connection).to have_add_with(:average_rating_ft => '2.23')
   end
 
   it 'should correctly index a trie time attribute field' do
     session.index(Photo.new(:created_at => Time.parse('2009-12-16 15:00:00 -0400')))
-    connection.should have_add_with(:created_at_dt => '2009-12-16T19:00:00Z')
+    expect(connection).to have_add_with(:created_at_dt => '2009-12-16T19:00:00Z')
   end
 
   it 'should allow indexing by a multiple-value field' do
     session.index(post(:category_ids => [3, 14]))
-    connection.should have_add_with(:category_ids_im => ['3', '14'])
+    expect(connection).to have_add_with(:category_ids_im => ['3', '14'])
   end
 
   it 'should not index a single-value field with newlines as multiple' do
     session.index(post(:title => "Multi\nLine"))
-    connection.adds.last.first.field_by_name(:title_ss).value.should == "Multi\nLine"
+    expect(connection.adds.last.first.field_by_name(:title_ss).value).to eq("Multi\nLine")
   end
 
   it 'should correctly index a time field' do
     session.index(
       post(:published_at => Time.parse('1983-07-08 05:00:00 -0400'))
     )
-    connection.should have_add_with(:published_at_dt => '1983-07-08T09:00:00Z')
+    expect(connection).to have_add_with(:published_at_dt => '1983-07-08T09:00:00Z')
   end
 
   it 'should correctly index a time field that\'s after 32-bit Y2K' do
     session.index(
       post(:published_at => DateTime.parse('2050-07-08 05:00:00 -0400'))
     )
-    connection.should have_add_with(:published_at_dt => '2050-07-08T09:00:00Z')
+    expect(connection).to have_add_with(:published_at_dt => '2050-07-08T09:00:00Z')
   end
 
   it 'should correctly index a date field' do
     session.index(post(:expire_date => Date.new(2009, 07, 13)))
-    connection.should have_add_with(:expire_date_d => '2009-07-13T00:00:00Z')
+    expect(connection).to have_add_with(:expire_date_d => '2009-07-13T00:00:00Z')
   end
 
   it 'should correctly index a date range field' do
     session.index(post(:featured_for => Date.new(2009, 07, 13)..Date.new(2009, 12, 25)))
-    connection.should have_add_with(:featured_for_dr => '[2009-07-13T00:00:00Z TO 2009-12-25T00:00:00Z]')
+    expect(connection).to have_add_with(:featured_for_dr => '[2009-07-13T00:00:00Z TO 2009-12-25T00:00:00Z]')
   end
 
   it 'should correctly index a boolean field' do
     session.index(post(:featured => true))
-    connection.should have_add_with(:featured_bs => 'true')
+    expect(connection).to have_add_with(:featured_bs => 'true')
   end
 
   it 'should correctly index a false boolean field' do
     session.index(post(:featured => false))
-    connection.should have_add_with(:featured_bs => 'false')
+    expect(connection).to have_add_with(:featured_bs => 'false')
   end
 
   it 'should not index a nil boolean field' do
     session.index(post)
-    connection.should_not have_add_with(:featured_bs)
+    expect(connection).not_to have_add_with(:featured_bs)
   end
 
   it 'should index latitude and longitude as a pair' do
     session.index(post(:coordinates => Sunspot::Util::Coordinates.new(40.7, -73.5)))
-    connection.should have_add_with(:coordinates_s => 'dr5xx3nytvgs')
+    expect(connection).to have_add_with(:coordinates_s => 'dr5xx3nytvgs')
   end
 
   it 'should index latitude and longitude passed as non-Floats' do
     coordinates = Sunspot::Util::Coordinates.new(
       BigDecimal.new('40.7'), BigDecimal.new('-73.5'))
     session.index(post(:coordinates => coordinates))
-    connection.should have_add_with(:coordinates_s => 'dr5xx3nytvgs')
+    expect(connection).to have_add_with(:coordinates_s => 'dr5xx3nytvgs')
   end
 
   it 'should correctly index an attribute field with block access' do
     session.index(post(:title => 'The Blog Post'))
-    connection.should have_add_with(:sort_title_s => 'blog post')
+    expect(connection).to have_add_with(:sort_title_s => 'blog post')
   end
 
   it 'should correctly index an attribute field with instance-external block access' do
     session.index(post(:category_ids => [1, 2, 3]))
-    connection.should have_add_with(:primary_category_id_i => '1')
+    expect(connection).to have_add_with(:primary_category_id_i => '1')
   end
 
   it 'should correctly index a field that is defined on a superclass' do
     Sunspot.setup(SuperClass) { string :author_name }
     session.index(post(:author_name => 'Mat Brown'))
-    connection.should have_add_with(:author_name_s => 'Mat Brown')
+    expect(connection).to have_add_with(:author_name_s => 'Mat Brown')
   end
 
   it 'should throw a NoMethodError only if a nonexistent type is defined' do
-    lambda { Sunspot.setup(Post) { string :author_name }}.should_not raise_error
-    lambda { Sunspot.setup(Post) { bogus :journey }}.should raise_error(NoMethodError)
+    expect { Sunspot.setup(Post) { string :author_name }}.not_to raise_error
+    expect { Sunspot.setup(Post) { bogus :journey }}.to raise_error(NoMethodError)
   end
 
   it 'should throw a NoMethodError if a nonexistent field argument is passed' do
-    lambda { Sunspot.setup(Post) { string :author_name, :bogus => :argument }}.should raise_error(ArgumentError)
+    expect { Sunspot.setup(Post) { string :author_name, :bogus => :argument }}.to raise_error(ArgumentError)
   end
 
   it 'should throw an ArgumentError if single-value field tries to index multiple values' do
-    lambda do
+    expect do
       Sunspot.setup(Post) { string :author_name }
       session.index(post(:author_name => ['Mat Brown', 'Matthew Brown']))
-    end.should raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it 'should throw an ArgumentError if specifying more_like_this on type that does not support it' do
-    lambda do
+    expect do
       Sunspot.setup(Post) { integer :popularity, :more_like_this => true }
-    end.should raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it 'should use a specified field name when the :as option is set' do
     session.index(post(:title => 'A Title'))
-    connection.should have_add_with(:legacy_field_s => 'legacy A Title')
+    expect(connection).to have_add_with(:legacy_field_s => 'legacy A Title')
   end
 
   it 'should use a specified field name when the :as option is set for array values' do
     session.index(post(:title => 'Another Title'))
-    connection.should have_add_with(:legacy_array_field_sm => ['first string', 'second string'])
+    expect(connection).to have_add_with(:legacy_array_field_sm => ['first string', 'second string'])
  	end
 end
 

data/spec/api/indexer/batch_spec.rb

@@ -9,7 +9,7 @@ describe 'batch indexing', :type => :indexer do
         session.index(post)
       end
     end
-    connection.adds.length.should == 1
+    expect(connection.adds.length).to eq(1)
   end
 
   it 'should add all batched adds' do
@@ -19,8 +19,9 @@ describe 'batch indexing', :type => :indexer do
       end
     end
     add = connection.adds.last
-    connection.adds.first.map { |add| add.field_by_name(:id).value }.should ==
+    expect(connection.adds.first.map { |add| add.field_by_name(:id).value }).to eq(
       posts.map { |post| "Post #{post.id}" }
+    )
   end
 
   it 'should not index changes to models that happen after index call' do
@@ -29,13 +30,13 @@ describe 'batch indexing', :type => :indexer do
       session.index(post)
       post.title = 'Title'
     end
-    connection.adds.first.first.field_by_name(:title_ss).should be_nil
+    expect(connection.adds.first.first.field_by_name(:title_ss)).to be_nil
   end
 
   it 'should batch an add and a delete' do
-    pending 'batching all operations'
-    connection.should_not_receive(:add)
-    connection.should_not_receive(:remove)
+    skip 'batching all operations'
+    expect(connection).not_to receive(:add)
+    expect(connection).not_to receive(:remove)
     session.batch do
       session.index(posts[0])
       session.remove(posts[1])
@@ -64,7 +65,7 @@ describe 'batch indexing', :type => :indexer do
       a_nested_batch
       nested_batches_adds = connection.adds
 
-      nested_batches_adds.first.first.field_by_name(:title_ss).value.should eq(
+      expect(nested_batches_adds.first.first.field_by_name(:title_ss).value).to eq(
         two_sets_of_batches_adds.first.first.field_by_name(:title_ss).value
       )
     end

data/spec/api/indexer/dynamic_fields_spec.rb

@@ -3,40 +3,40 @@ require File.expand_path('spec_helper', File.dirname(__FILE__))
 describe 'indexing dynamic fields' do
   it 'indexes string data' do
     session.index(post(:custom_string => { :test => 'string' }))
-    connection.should have_add_with(:"custom_string:test_ss" => 'string')
+    expect(connection).to have_add_with(:"custom_string:test_ss" => 'string')
   end
 
   it 'indexes integer data with virtual accessor' do
     session.index(post(:category_ids => [1, 2]))
-    connection.should have_add_with(:"custom_integer:1_i" => '1', :"custom_integer:2_i" => '1')
+    expect(connection).to have_add_with(:"custom_integer:1_i" => '1', :"custom_integer:2_i" => '1')
   end
 
   it 'indexes float data' do
     session.index(post(:custom_fl => { :test => 1.5 }))
-    connection.should have_add_with(:"custom_float:test_fm" => '1.5')
+    expect(connection).to have_add_with(:"custom_float:test_fm" => '1.5')
   end
 
   it 'indexes time data' do
     session.index(post(:custom_time => { :test => Time.parse('2009-05-18 18:05:00 -0400') }))
-    connection.should have_add_with(:"custom_time:test_d" => '2009-05-18T22:05:00Z')
+    expect(connection).to have_add_with(:"custom_time:test_d" => '2009-05-18T22:05:00Z')
   end
 
   it 'indexes boolean data' do
     session.index(post(:custom_boolean => { :test => false }))
-    connection.should have_add_with(:"custom_boolean:test_b" => 'false')
+    expect(connection).to have_add_with(:"custom_boolean:test_b" => 'false')
   end
 
   it 'indexes multiple values for a field' do
     session.index(post(:custom_fl => { :test => [1.0, 2.1, 3.2] }))
-    connection.should have_add_with(:"custom_float:test_fm" => %w(1.0 2.1 3.2))
+    expect(connection).to have_add_with(:"custom_float:test_fm" => %w(1.0 2.1 3.2))
   end
 
   it 'should throw a NoMethodError if dynamic text field defined' do
-    lambda do
+    expect do
       Sunspot.setup(Post) do
         dynamic_text :custom_text
       end
-    end.should raise_error(NoMethodError)
+    end.to raise_error(NoMethodError)
   end
 end
 

data/spec/api/indexer/fixed_fields_spec.rb

@@ -3,28 +3,28 @@ require File.expand_path('spec_helper', File.dirname(__FILE__))
 describe 'indexing fixed fields', :type => :indexer do
   it 'should index id' do
     session.index post
-    connection.should have_add_with(:id => "Post #{post.id}")
+    expect(connection).to have_add_with(:id => "Post #{post.id}")
   end
 
   it 'should index type' do
     session.index post
-    connection.should have_add_with(:type => ['Post', 'SuperClass', 'MockRecord'])
+    expect(connection).to have_add_with(:type => ['Post', 'SuperClass', 'MockRecord'])
   end
 
   it 'should not index join fields' do
     session.index PhotoContainer.new
-    connection.should_not have_add_with(:photo_caption => 'blah')
+    expect(connection).not_to have_add_with(:photo_caption => 'blah')
   end
 
   it 'should index class name' do
     session.index post
-    connection.should have_add_with(:class_name => 'Post')
+    expect(connection).to have_add_with(:class_name => 'Post')
   end
 
   it 'should index the array of objects supplied' do
     posts = Array.new(2) { Post.new }
     session.index posts
-    connection.should have_add_with(
+    expect(connection).to have_add_with(
       { :id => "Post #{posts.first.id}" },
       { :id => "Post #{posts.last.id}" }
     )
@@ -33,7 +33,7 @@ describe 'indexing fixed fields', :type => :indexer do
   it 'should index an array containing more than one type of object' do
     post1, comment, post2 = objects = [Post.new, Namespaced::Comment.new, Post.new]
     session.index objects
-    connection.should have_add_with(
+    expect(connection).to have_add_with(
       { :id => "Post #{post1.id}", :type => ['Post', 'SuperClass', 'MockRecord'] },
       { :id => "Namespaced::Comment #{comment.id}", :type => ['Namespaced::Comment', 'MockRecord'] },
       { :id => "Post #{post2.id}", :type => ['Post', 'SuperClass', 'MockRecord'] }
@@ -41,22 +41,22 @@ describe 'indexing fixed fields', :type => :indexer do
   end
 
   it 'commits immediately after index! called' do
-    connection.should_receive(:add).ordered
-    connection.should_receive(:commit).ordered
+    expect(connection).to receive(:add).ordered
+    expect(connection).to receive(:commit).ordered
     session.index!(post)
   end
 
   it 'raises an ArgumentError if an attempt is made to index an object that has no configuration' do
-    lambda { session.index(Blog.new) }.should raise_error(Sunspot::NoSetupError)
+    expect { session.index(Blog.new) }.to raise_error(Sunspot::NoSetupError)
   end
 
   it 'raises a NoAdapterError if class without adapter is indexed' do
-    lambda { session.index(User.new) }.should raise_error(Sunspot::NoAdapterError)
+    expect { session.index(User.new) }.to raise_error(Sunspot::NoAdapterError)
   end
 
   it 'raises an ArgumentError if a non-word character is included in the field name' do
-    lambda do
+    expect do
       Sunspot.setup(Post) { string :"bad name" }
-    end.should raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 end

data/spec/api/indexer/fulltext_spec.rb

@@ -3,41 +3,41 @@ require File.expand_path('spec_helper', File.dirname(__FILE__))
 describe 'indexing fulltext fields' do
   it 'indexes text field' do
     session.index(post(:title => 'A Title'))
-    connection.should have_add_with(:title_text => 'A Title')
+    expect(connection).to have_add_with(:title_text => 'A Title')
   end
 
   it 'indexes stored text field' do
     session.index(post(:body => 'Test body'))
-    connection.should have_add_with(:body_textsv => 'Test body')
+    expect(connection).to have_add_with(:body_textsv => 'Test body')
   end
 
   it 'indexes text field with boost' do
     session.index(post(:title => 'A Title'))
-    connection.adds.last.first.field_by_name(:title_text).attrs[:boost].should == 2
+    expect(connection.adds.last.first.field_by_name(:title_text).attrs[:boost]).to eq(2)
   end
 
   it 'indexes multiple values for a text field' do
     session.index(post(:body => %w(some title)))
-    connection.should have_add_with(:body_textsv => %w(some title))
+    expect(connection).to have_add_with(:body_textsv => %w(some title))
   end
 
   it 'indexes text via a block accessor' do
     session.index(post(:title => 'backwards'))
-    connection.should have_add_with(:backwards_title_text => 'sdrawkcab')
+    expect(connection).to have_add_with(:backwards_title_text => 'sdrawkcab')
   end
 
   it 'indexes document level boost using block' do
     session.index(post(:ratings_average => 4.0))
-    connection.adds.last.first.attrs[:boost].should == 1.25
+    expect(connection.adds.last.first.attrs[:boost]).to eq(1.25)
   end
 
   it 'indexes document level boost using attribute' do
     session.index(Namespaced::Comment.new(:boost => 1.5))
-    connection.adds.last.first.attrs[:boost].should == 1.5
+    expect(connection.adds.last.first.attrs[:boost]).to eq(1.5)
   end
 
   it 'indexes document level boost defined statically' do
     session.index(Photo.new)
-    connection.adds.last.first.attrs[:boost].should == 0.75
+    expect(connection.adds.last.first.attrs[:boost]).to eq(0.75)
   end
 end

data/spec/api/indexer/removal_spec.rb

@@ -3,54 +3,54 @@ require File.expand_path('spec_helper', File.dirname(__FILE__))
 describe 'document removal', :type => :indexer do
   it 'removes an object from the index' do
     session.remove(post)
-    connection.should have_delete("Post #{post.id}")
+    expect(connection).to have_delete("Post #{post.id}")
   end
 
   it 'removes an object by type and id' do
     session.remove_by_id(Post, 1)
-    connection.should have_delete('Post 1')
+    expect(connection).to have_delete('Post 1')
   end
 
   it 'removes an object by type and ids' do
     session.remove_by_id(Post, 1, 2)
-    connection.should have_delete('Post 1', 'Post 2')
+    expect(connection).to have_delete('Post 1', 'Post 2')
   end
 
   it 'removes an object by type and ids array' do
     session.remove_by_id(Post, [1, 2])
-    connection.should have_delete('Post 1', 'Post 2')
+    expect(connection).to have_delete('Post 1', 'Post 2')
   end
 
   it 'removes an object by type and ids and immediately commits' do
-    connection.should_receive(:delete_by_id).with(['Post 1', 'Post 2', 'Post 3']).ordered
-    connection.should_receive(:commit).ordered
+    expect(connection).to receive(:delete_by_id).with(['Post 1', 'Post 2', 'Post 3']).ordered
+    expect(connection).to receive(:commit).ordered
     session.remove_by_id!(Post, 1, 2, 3)
   end
 
   it 'removes an object from the index and immediately commits' do
-    connection.should_receive(:delete_by_id).ordered
-    connection.should_receive(:commit).ordered
+    expect(connection).to receive(:delete_by_id).ordered
+    expect(connection).to receive(:commit).ordered
     session.remove!(post)
   end
 
   it 'removes everything from the index' do
     session.remove_all
-    connection.should have_delete_by_query("*:*")
+    expect(connection).to have_delete_by_query("*:*")
   end
 
   it 'removes everything from the index and immediately commits' do
-    connection.should_receive(:delete_by_query).ordered
-    connection.should_receive(:commit).ordered
+    expect(connection).to receive(:delete_by_query).ordered
+    expect(connection).to receive(:commit).ordered
     session.remove_all!
   end
 
   it 'removes everything of a given class from the index' do
     session.remove_all(Post)
-    connection.should have_delete_by_query("type:Post")
+    expect(connection).to have_delete_by_query("type:Post")
   end
 
   it 'correctly escapes namespaced classes when removing everything from the index' do
-    connection.should_receive(:delete_by_query).with('type:Namespaced\:\:Comment')
+    expect(connection).to receive(:delete_by_query).with('type:Namespaced\:\:Comment')
     session.remove_all(Namespaced::Comment)
   end
 
@@ -58,6 +58,6 @@ describe 'document removal', :type => :indexer do
     session.remove(Post) do
       with(:title, 'monkeys')
     end
-    connection.should have_delete_by_query("(type:Post AND title_ss:monkeys)")
+    expect(connection).to have_delete_by_query("(type:Post AND title_ss:monkeys)")
   end
 end