sunspot 2.0.0 → 2.5.0

data/spec/api/data_extractor_spec.rb

@@ -0,0 +1,39 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+describe Sunspot::DataExtractor do
+  it "removes special characters from strings" do
+    extractor = Sunspot::DataExtractor::AttributeExtractor.new(:name)
+    blog      = Blog.new(:name => "Te\x0\x1\x7\x6\x8st\xB\xC\xE Bl\x1Fo\x7fg")
+
+    expect(extractor.value_for(blog)).to eq "Test Blog"
+  end
+
+  it "removes special characters from arrays" do
+    extractor = Sunspot::DataExtractor::BlockExtractor.new { tags }
+    post      = Post.new(:tags => ["Te\x0\x1\x7\x6\x8st Ta\x1Fg\x7f 1", "Test\xB\xC\xE Tag 2"])
+
+    expect(extractor.value_for(post)).to eq ["Test Tag 1", "Test Tag 2"]
+  end
+
+  it "removes special characters from hashes" do
+    extractor = Sunspot::DataExtractor::Constant.new({ "Te\x0\x1\x7\x6\x8st" => "Ta\x1Fg\x7f" })
+
+    expect(extractor.value_for(Post.new)).to eq({ "Test" => "Tag" })
+  end
+
+  it "skips other data types" do
+    [
+      :"Te\x0\x1\x7\x6\x8st",
+      123,
+      123.0,
+      nil,
+      false,
+      true,
+      Sunspot::Util::Coordinates.new(40.7, -73.5)
+    ].each do |value|
+      extractor = Sunspot::DataExtractor::Constant.new(value)
+
+      expect(extractor.value_for(Post.new)).to eq value
+    end
+  end
+end

data/spec/api/hit_enumerable_spec.rb

@@ -9,37 +9,60 @@ describe Sunspot::Search::HitEnumerable do
 
   describe "#hits" do
     before do
-      subject.stub(:solr_docs).and_return([{"id" => "Post 1", "score" => 3.14}])
-      subject.stub(:highlights_for)
+      allow(subject).to receive(:solr_docs).and_return([{"id" => "Post 1", "score" => 3.14}])
+      allow(subject).to receive(:highlights_for)
     end
 
     it "retrieves the raw Solr response from #solr_docs and constructs Hit objects" do
-      Sunspot::Search::Hit.should_receive(:new).
+      expect(Sunspot::Search::Hit).to receive(:new).
                            with({"id" => "Post 1", "score" => 3.14}, anything, anything)
 
       subject.hits
     end
 
     it "constructs Hit objects with highlights" do
-      subject.should_receive(:highlights_for).with({"id" => "Post 1", "score" => 3.14})
+      expect(subject).to receive(:highlights_for).with({"id" => "Post 1", "score" => 3.14})
 
       subject.hits
     end
 
     it "returns only verified hits if :verify => true is passed" do
-      Sunspot::Search::Hit.any_instance.stub(:result).and_return(nil)
+      allow_any_instance_of(Sunspot::Search::Hit).to receive(:result).and_return(nil)
 
-      subject.hits(:verify => true).should be_empty
+      expect(subject.hits(:verify => true)).to be_empty
     end
 
     it "returns an empty array if no results are available from Solr" do
-      subject.stub(:solr_docs).and_return(nil)
+      allow(subject).to receive(:solr_docs).and_return(nil)
 
-      subject.hits.should == []
+      expect(subject.hits).to eq([])
     end
 
     it "provides #populate_hits so that querying for one hit result will eager load the rest" do
-      Sunspot::Search::Hit.any_instance.should_receive(:result=)
+      expect_any_instance_of(Sunspot::Search::Hit).to receive(:result=)
+
+      subject.populate_hits
+    end
+  end
+
+  describe "#populate_hits" do
+    let(:post_1) { Post.new(id: "1", title: "Title 1") }
+
+    before do
+      allow(subject).to receive(:solr_docs).and_return([{ "id" => "Post 1", "score" => 3.14 }])
+      allow(subject).to receive(:highlights_for)
+    end
+
+    it "populates the hit object with the result from the data accessor" do
+      allow_any_instance_of(MockAdapter::DataAccessor).to receive(:load_all).and_return([post_1])
+      expect_any_instance_of(Sunspot::Search::Hit).to receive(:result=).with(post_1)
+
+      subject.populate_hits
+    end
+
+    it "populates the hit object only once if there are duplicate entries in the database (ex: db missing unique constraints)" do
+      allow_any_instance_of(MockAdapter::DataAccessor).to receive(:load_all).and_return([post_1, post_1])
+      expect_any_instance_of(Sunspot::Search::Hit).to receive(:result=).with(post_1)
 
       subject.populate_hits
     end

data/spec/api/indexer/attributes_spec.rb

@@ -4,146 +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)))
+    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,23 +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
+    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}" }
     )
@@ -28,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'] }
@@ -36,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