sunspot 2.0.0 → 2.5.0

data/spec/integration/field_grouping_spec.rb

@@ -19,8 +19,8 @@ describe "field grouping" do
       group :title
     end
 
-    search.group(:title).groups.should include { |g| g.value == "Title1" }
-    search.group(:title).groups.should include { |g| g.value == "Title2" }
+    expect(search.group(:title).groups).to include { |g| g.value == "Title1" }
+    expect(search.group(:title).groups).to include { |g| g.value == "Title2" }
   end
 
   it "returns the number of matches unique groups" do
@@ -28,7 +28,7 @@ describe "field grouping" do
       group :title
     end
 
-    search.group(:title).total.should == 2
+    expect(search.group(:title).total).to eq(2)
   end
 
   it "provides access to the number of matches before grouping" do
@@ -36,7 +36,7 @@ describe "field grouping" do
       group :title
     end
 
-    search.group(:title).matches.should == @posts.length
+    expect(search.group(:title).matches).to eq(@posts.length)
   end
 
   it "allows grouping by multiple fields" do
@@ -44,8 +44,8 @@ describe "field grouping" do
       group :title, :sort_title
     end
 
-    search.group(:title).groups.should_not be_empty
-    search.group(:sort_title).groups.should_not be_empty
+    expect(search.group(:title).groups).not_to be_empty
+    expect(search.group(:sort_title).groups).not_to be_empty
   end
 
   it "allows specification of the number of documents per group" do
@@ -56,7 +56,7 @@ describe "field grouping" do
     end
 
     title1_group = search.group(:title).groups.detect { |g| g.value == "Title1" }
-    title1_group.hits.length.should == 2
+    expect(title1_group.hits.length).to eq(2)
   end
 
   it "allows specification of the sort within groups" do
@@ -69,7 +69,20 @@ describe "field grouping" do
     highest_ranked_post = @posts.sort_by { |p| -p.ratings_average }.first
 
     title1_group = search.group(:title).groups.detect { |g| g.value == "Title1" }
-    title1_group.hits.first.primary_key.to_i.should == highest_ranked_post.id
+    expect(title1_group.hits.first.primary_key.to_i).to eq(highest_ranked_post.id)
+  end
+
+  it "allows specification of an ordering function within groups" do
+    search = Sunspot.search(Post) do
+      group :title do
+        order_by_function(:product, :average_rating, -2, :asc)
+      end
+    end
+
+    highest_ranked_post = @posts.sort_by { |p| -p.ratings_average }.first
+
+    title1_group = search.group(:title).groups.detect { |g| g.value == "Title1" }
+    expect(title1_group.hits.first.primary_key.to_i).to eq(highest_ranked_post.id)
   end
 
   it "allows pagination within groups" do
@@ -78,8 +91,27 @@ describe "field grouping" do
       paginate :per_page => 1, :page => 2
     end
 
-    search.group(:title).groups.length.should eql(1)
-    search.group(:title).groups.first.results.should == [ @posts.last ]
+    expect(search.group(:title).groups.length).to eql(1)
+    expect(search.group(:title).groups.first.results).to eq([ @posts.last ])
+  end
+  
+  context "returns a not paginated collection" do
+    subject do
+      search = Sunspot.search(Post) do
+        group :title do
+          ngroups false
+        end
+        paginate :per_page => 1, :page => 2
+
+      end
+      search.group(:title).groups
+    end
+
+    it { expect(subject.per_page).to      eql(1)   }
+    it { expect(subject.total_pages).to   eql(0)   }
+    it { expect(subject.current_page).to  eql(2)   }
+    it { expect(subject.first_page?).to   be(false) }
+    it { expect(subject.last_page?).to    be(true)  }
   end
 
   context "returns a paginated collection" do
@@ -91,10 +123,10 @@ describe "field grouping" do
       search.group(:title).groups
     end
 
-    it { subject.per_page.should      eql(1)   }
-    it { subject.total_pages.should   eql(2)   }
-    it { subject.current_page.should  eql(2)   }
-    it { subject.first_page?.should   be_false }
-    it { subject.last_page?.should    be_true  }
+    it { expect(subject.per_page).to      eql(1)   }
+    it { expect(subject.total_pages).to   eql(2)   }
+    it { expect(subject.current_page).to  eql(2)   }
+    it { expect(subject.first_page?).to   be(false) }
+    it { expect(subject.last_page?).to    be(true)  }
   end
 end

data/spec/integration/field_lists_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+describe 'fields lists' do
+  before :all do
+    Sunspot.remove_all
+    @post = Post.new(title: 'A Title', body: 'A Body', featured: true, tags: ['tag'])
+    Sunspot.index!(@post)
+  end
+
+  let(:stored_field_names) do
+    (Sunspot::Setup.for(Post).fields + Sunspot::Setup.for(Post).all_text_fields)
+      .select { |f| f.stored? }
+      .map { |f| f.name }
+  end
+
+  it 'loads all stored fields by dafault' do
+    hit = Sunspot.search(Post).hits.first
+
+    stored_field_names.each do |field|
+      expect(hit.stored(field)).not_to be_nil
+    end
+  end
+
+  it 'loads only filtered fields' do
+    hit = Sunspot.search(Post) { field_list(:title) }.hits.first
+
+    expect(hit.stored(:title)).to eq(@post.title)
+
+    (stored_field_names - [:title]).each do |field|
+      expect(hit.stored(field)).to be_nil
+    end
+  end
+
+  it 'does not raise Sunspot::UnrecognizedFieldError when listing existing text fields' do
+    expect do
+      Sunspot.search(Post) {
+        field_list(:body)
+      }
+    end.to_not raise_error
+  end
+
+  it 'does raise Sunspot::UnrecognizedFieldError when listing a non-existent text fields' do
+    expect do
+      Sunspot.search(Post) {
+        field_list(:bogus_body)
+      }
+    end.to raise_error(Sunspot::UnrecognizedFieldError)
+  end
+
+  it 'does not load any stored fields' do
+    hit = Sunspot.search(Post) { without_stored_fields }.hits.first
+
+    stored_field_names.each do |field|
+      expect(hit.stored(field)).to be_nil
+    end
+  end
+end

data/spec/integration/geospatial_spec.rb

@@ -15,7 +15,7 @@ describe "geospatial search" do
         with(:coordinates_new).in_radius(32, -68, 1)
       }.results
 
-      results.should include(@post)
+      expect(results).to include(@post)
     end
 
     it "filters out posts not in the radius" do
@@ -23,18 +23,44 @@ describe "geospatial search" do
         with(:coordinates_new).in_radius(33, -68, 1)
       }.results
 
-      results.should_not include(@post)
+      expect(results).not_to include(@post)
     end
 
-    it "allows conjunction queries" do
+    it "filters out posts in the radius" do
+      results = Sunspot.search(Post) {
+        without(:coordinates_new).in_radius(32, -68, 1)
+      }.results
+
+      expect(results).not_to include(@post)
+    end
+
+    it "allows conjunction queries with radius" do
+      post = Post.new(:title => "Howdy",
+                      :coordinates => Sunspot::Util::Coordinates.new(35, -68))
+
+      Sunspot.index!(post)
+
       results = Sunspot.search(Post) {
         any_of do
           with(:coordinates_new).in_radius(32, -68, 1)
           with(:coordinates_new).in_radius(35, 68, 1)
+          without(:coordinates_new).in_radius(35, -68, 1)
+        end
+      }.results
+
+      expect(results).to include(@post)
+      expect(results).not_to include(post)
+    end
+
+    it "allows conjunction queries with bounding box" do
+      results = Sunspot.search(Post) {
+        any_of do
+          with(:coordinates_new).in_bounding_box([31, -69], [33, -67])
+          with(:coordinates_new).in_bounding_box([35, 68], [36, 69])
         end
       }.results
 
-      results.should include(@post)
+      expect(results).to include(@post)
     end
   end
 
@@ -52,7 +78,7 @@ describe "geospatial search" do
         with(:coordinates_new).in_bounding_box [31, -69], [33, -67]
       }.results
 
-      results.should include(@post)
+      expect(results).to include(@post)
     end
 
     it "filters out posts not in the bounding box" do
@@ -60,7 +86,7 @@ describe "geospatial search" do
         with(:coordinates_new).in_bounding_box [20, -70], [21, -69]
       }.results
 
-      results.should_not include(@post)
+      expect(results).not_to include(@post)
     end
   end
 
@@ -82,7 +108,7 @@ describe "geospatial search" do
         order_by_geodist(:coordinates_new, 32, -68)
       }.results
 
-      results.should == @posts.reverse
+      expect(results).to eq(@posts.reverse)
     end
 
     it "orders posts by distance descending" do
@@ -90,7 +116,7 @@ describe "geospatial search" do
         order_by_geodist(:coordinates_new, 32, -68, :desc)
       }.results
 
-      results.should == @posts
+      expect(results).to eq(@posts)
     end
   end
 end

data/spec/integration/highlighting_spec.rb

@@ -11,22 +11,22 @@ describe 'keyword highlighting' do
   end
   
   it 'should include highlights in the results' do
-    @search_result.hits.first.highlights.length.should == 1
+    expect(@search_result.hits.first.highlights.length).to eq(1)
   end
   
   it 'should return formatted highlight fragments' do
-    @search_result.hits.first.highlights(:body).first.format.should == 'And the <em>fox</em> laughed'
+    expect(@search_result.hits.first.highlights(:body).first.format).to eq('And the <em>fox</em> laughed')
   end
   
   it 'should be empty for non-keyword searches' do
     search_result = Sunspot.search(Post){ with :blog_id, 1 }
-    search_result.hits.first.highlights.should be_empty
+    expect(search_result.hits.first.highlights).to be_empty
   end
   
   it "should process multiple keyword request on different fields with highlights correctly" do
     search_results = nil
-    lambda do
-      search_results = Sunspot.search(Post) do 
+    expect do
+      search_results = Sunspot.search(Post) do
         keywords 'Lorem ipsum', :fields => [:body] do
           highlight :body
         end
@@ -34,9 +34,9 @@ describe 'keyword highlighting' do
           highlight :title
         end
       end
-    end.should_not raise_error(RSolr::Error::Http)
-    search_results.results.length.should eq(1)
-    search_results.results.first.should eq(@posts.last)
+    end.to_not raise_error
+    expect(search_results.results.length).to eq(1)
+    expect(search_results.results.first).to eq(@posts.last)
     # this one might be a Solr bug, therefore not related to Sunspot itself
     # search_results.hits.first.highlights.should_not be_empty
   end

data/spec/integration/indexing_spec.rb

@@ -2,33 +2,34 @@ require File.expand_path('../spec_helper', File.dirname(__FILE__))
 
 describe 'indexing' do
   it 'should index non-multivalued field with newlines' do
-    lambda do
+    expect do
       Sunspot.index!(Post.new(:title => "A\nTitle"))
-    end.should_not raise_error
+    end.not_to raise_error
   end
 
   it 'should correctly remove by model instance' do
     post = Post.new(:title => 'test post')
     Sunspot.index!(post)
     Sunspot.remove!(post)
-    Sunspot.search(Post) { with(:title, 'test post') }.results.should be_empty
+    expect(Sunspot.search(Post) { with(:title, 'test post') }.results).to be_empty
   end
 
   it 'should correctly delete by ID' do
     post = Post.new(:title => 'test post')
     Sunspot.index!(post)
     Sunspot.remove_by_id!(Post, post.id)
-    Sunspot.search(Post) { with(:title, 'test post') }.results.should be_empty
+    expect(Sunspot.search(Post) { with(:title, 'test post') }.results).to be_empty
   end
 
   it 'removes documents by query' do
     Sunspot.remove_all!
     posts = [Post.new(:title => 'birds'), Post.new(:title => 'monkeys')]
     Sunspot.index!(posts)
-    Sunspot.remove! do
+
+    Sunspot.remove!(Post) do
       with(:title, 'birds')
     end
-    Sunspot.search(Post).should have(2).results
+    expect(Sunspot.search(Post).results.size).to eq(1)
   end
 
 

data/spec/integration/join_spec.rb

@@ -0,0 +1,45 @@
+require File.expand_path('../spec_helper', File.dirname(__FILE__))
+
+describe "searching by joined fields" do
+  before :each do
+    Sunspot.remove_all!
+
+    @container1 = PhotoContainer.new(:id => 1)
+    @container2 = PhotoContainer.new(:id => 2).tap { |c| allow(c).to receive(:id).and_return(2) }
+    @container3 = PhotoContainer.new(:id => 3).tap { |c| allow(c).to receive(:id).and_return(3) }
+
+    @picture = Picture.new(:photo_container_id => @container1.id, :description => "one")
+    @photo1  = Photo.new(:photo_container_id => @container1.id, :description => "two")
+    @photo2  = Photo.new(:photo_container_id => @container2.id, :description => "three")
+
+    Sunspot.index!(@container1, @container2, @photo1, @photo2, @picture)
+  end
+
+  it "matches by joined fields" do
+    {
+      "one"   => [],
+      "two"   => [@container1],
+      "three" => [@container2]
+    }.each do |key, res|
+      results = Sunspot.search(PhotoContainer) {
+        fulltext(key, :fields => [:photo_description])
+      }.results
+
+      expect(results).to eq res
+    end
+  end
+
+  it "doesn't match by joined fields with the same name from other collections" do
+    {
+      "one"   => [@container1],
+      "two"   => [],
+      "three" => []
+    }.each do |key, res|
+      results = Sunspot.search(PhotoContainer) {
+        fulltext(key, :fields => [:picture_description])
+      }.results
+
+      expect(results).to eq res
+    end
+  end
+end

data/spec/integration/keyword_search_spec.rb

@@ -16,36 +16,64 @@ describe 'keyword search' do
       Sunspot.index!(@comment)
     end
 
+    context 'edismax' do
+      it 'matches with wildcards' do
+        results = Sunspot.search(Post) { keywords '*oas*' }.results
+        [0,2].each { |i| expect(results).to include(@posts[i])}
+        [1].each { |i| expect(results).not_to include(@posts[i])}
+      end
+
+      it 'matches multiple keywords on different fields with wildcards using subqueries' do
+        results = Sunspot.search(Post) do
+          keywords 'insuffic*',:fields=>[:title]
+          keywords 'win*',:fields=>[:body]
+        end.results
+        [0].each {|i| expect(results).to include(@posts[i])}
+        [1,2].each {|i| expect(results).not_to include(@posts[i])}
+      end
+
+      it 'matches with proximity' do
+        results = Sunspot.search(Post) { keywords '"wind buffer"~4' }.results
+        [0,1].each {|i| expect(results).not_to include(@posts[i])}
+        [2].each {|i| expect(results).to include(@posts[i])}
+      end
+
+      it 'does not match if not within proximity' do
+        results = Sunspot.search(Post) { keywords '"wind buffer"~1' }.results
+        expect(results).to eq([])
+      end
+    end
+
     it 'matches a single keyword out of a single field' do
       results = Sunspot.search(Post) { keywords 'toast' }.results
-      [0, 2].each { |i| results.should include(@posts[i]) }
-      [1].each { |i| results.should_not include(@posts[i]) }
+      [0, 2].each { |i| expect(results).to include(@posts[i]) }
+      [1].each { |i| expect(results).not_to include(@posts[i]) }
     end
 
     it 'matches multiple words out of a single field' do
       results = Sunspot.search(Post) { keywords 'elects toast' }.results
-      results.should == [@posts[0]]
+      expect(results).to eq([@posts[0]])
     end
 
     it 'matches multiple words in multiple fields' do
       results = Sunspot.search(Post) { keywords 'toast wind' }.results
-      [0, 2].each { |i| results.should include(@posts[i]) }
-      [1].each { |i| results.should_not include(@posts[i]) }
+      [0, 2].each { |i| expect(results).to include(@posts[i]) }
+      [1].each { |i| expect(results).not_to include(@posts[i]) }
     end
 
     it 'matches multiple types' do
       results = Sunspot.search(Post, Namespaced::Comment) do
         keywords 'toast'
       end.results
-      [@posts[0], @posts[2], @comment].each  { |obj| results.should include(obj) }
-      results.should_not include(@posts[1])
+      [@posts[0], @posts[2], @comment].each  { |obj| expect(results).to include(obj) }
+      expect(results).not_to include(@posts[1])
     end
 
     it 'matches keywords from only the fields specified' do
       results = Sunspot.search(Post) do
         keywords 'moron', :fields => [:title]
       end.results
-      results.should == [@posts[1]]
+      expect(results).to eq([@posts[1]])
     end
 
     it 'matches multiple keywords on different fields using subqueries' do
@@ -53,13 +81,13 @@ describe 'keyword search' do
         keywords 'moron', :fields => [:title]
         keywords 'wind',  :fields => [:body]
       end
-      search.results.should == []
+      expect(search.results).to eq([])
 
       search = Sunspot.search(Post) do
         keywords 'moron',   :fields => [:title]
         keywords 'buffer',  :fields => [:body]
       end
-      search.results.should == [@posts[1]]
+      expect(search.results).to eq([@posts[1]])
     end
 
     it 'matches multiple keywords with escaped characters' do
@@ -67,7 +95,7 @@ describe 'keyword search' do
         keywords 'spirit',   :fields => [:title]
         keywords 'host\'s',  :fields => [:body]
       end
-      search.results.should == [@posts[2]]
+      expect(search.results).to eq([@posts[2]])
     end
 
     it 'matches multiple keywords with phrase-based search' do
@@ -76,7 +104,7 @@ describe 'keyword search' do
         keywords '"interpret the buffer"', :fields => [:body]
         keywords '"does the"', :fields => [:body]
       end
-      search.results.should == [@posts[2]]
+      expect(search.results).to eq([@posts[2]])
     end
 
     it 'matches multiple keywords different options' do
@@ -84,7 +112,7 @@ describe 'keyword search' do
         keywords 'insufficient nonexistent', :fields => [:title], :minimum_match => 1
         keywords 'wind does', :fields => [:body], :minimum_match => 2
       end
-      search.results.should == [@posts[0]]
+      expect(search.results).to eq([@posts[0]])
     end
   end
 
@@ -97,9 +125,10 @@ describe 'keyword search' do
 
     it 'should assign a higher score to the result matching the higher-boosted field' do
       search = Sunspot.search(Post) { keywords 'rhinoceros' }
-      search.hits.map { |hit| hit.primary_key }.should ==
+      expect(search.hits.map { |hit| hit.primary_key }).to eq(
         @posts.map { |post| post.id.to_s }
-      search.hits.first.score.should > search.hits.last.score
+      )
+      expect(search.hits.first.score).to be > search.hits.last.score
     end
   end
 
@@ -114,9 +143,10 @@ describe 'keyword search' do
 
     it 'should assign a higher score to the higher-boosted document' do
       search = Sunspot.search(Post) { keywords 'test' }
-      search.hits.map { |hit| hit.primary_key }.should ==
+      expect(search.hits.map { |hit| hit.primary_key }).to eq(
         @posts.map { |post| post.id.to_s }
-      search.hits.first.score.should > search.hits.last.score
+      )
+      expect(search.hits.first.score).to be > search.hits.last.score
     end
   end
 
@@ -136,8 +166,8 @@ describe 'keyword search' do
           phrase_fields :body => 2.0
         end
       end.hits
-      hits.first.instance.should == @comments.first
-      hits.first.score.should > hits.last.score
+      expect(hits.first.instance).to eq(@comments.first)
+      expect(hits.first.score).to be > hits.last.score
     end
 
     it 'assigns a higher score to documents in which the search terms appear in a boosted field' do
@@ -146,8 +176,8 @@ describe 'keyword search' do
           fields :body => 2.0, :author_name => 0.75
         end
       end.hits
-      hits.first.instance.should == @comments.first
-      hits.first.score.should > hits.last.score
+      expect(hits.first.instance).to eq(@comments.first)
+      expect(hits.first.score).to be > hits.last.score
     end
 
     it 'assigns a higher score to documents in which the search terms appear in a higher boosted phrase field' do
@@ -156,8 +186,8 @@ describe 'keyword search' do
           phrase_fields :body => 2.0, :author_name => 0.75
         end
       end.hits
-      hits.first.instance.should == @comments.first
-      hits.first.score.should > hits.last.score
+      expect(hits.first.instance).to eq(@comments.first)
+      expect(hits.first.score).to be > hits.last.score
     end
   end
 
@@ -182,8 +212,8 @@ describe 'keyword search' do
         end
         query.without(@posts[1])
       end
-      search.results.should == [@posts[0], @posts[2]]
-      search.hits[0].score.should > search.hits[1].score
+      expect(search.results).to eq([@posts[0], @posts[2]])
+      expect(search.hits[0].score).to be > search.hits[1].score
     end
 
     it 'should assign scores in order of multiple boost query match' do
@@ -193,9 +223,9 @@ describe 'keyword search' do
           boost(1.5) { with(:average_rating).greater_than(3.0) }
         end
       end
-      search.results.should == @posts
-      search.hits[0].score.should > search.hits[1].score
-      search.hits[1].score.should > search.hits[2].score
+      expect(search.results).to eq(@posts)
+      expect(search.hits[0].score).to be > search.hits[1].score
+      expect(search.hits[1].score).to be > search.hits[2].score
     end
   end
 
@@ -213,11 +243,11 @@ describe 'keyword search' do
     end
 
     it 'should match documents that contain the minimum_match number of search terms' do
-      @search.results.should include(@posts[0])
+      expect(@search.results).to include(@posts[0])
     end
 
     it 'should not match documents that do not contain the minimum_match number of search terms' do
-      @search.results.should_not include(@posts[1])
+      expect(@search.results).not_to include(@posts[1])
     end
   end
 
@@ -236,15 +266,15 @@ describe 'keyword search' do
     end
 
     it 'should match exact phrase' do
-      @search.results.should include(@posts[0])
+      expect(@search.results).to include(@posts[0])
     end
 
     it 'should match phrase divided by query phrase slop terms' do
-      @search.results.should include(@posts[1])
+      expect(@search.results).to include(@posts[1])
     end
 
     it 'should not match phrase divided by more than query phrase slop terms' do
-      @search.results.should_not include(@posts[2])
+      expect(@search.results).not_to include(@posts[2])
     end
   end
 
@@ -270,15 +300,15 @@ describe 'keyword search' do
     end
 
     it 'should give phrase field boost to exact match' do
-      @sorted_hits[0].score.should > @sorted_hits[1].score
+      expect(@sorted_hits[0].score).to be > @sorted_hits[1].score
     end
 
     it 'should give phrase field boost to match within slop' do
-      @sorted_hits[2].score.should > @sorted_hits[3].score
+      expect(@sorted_hits[2].score).to be > @sorted_hits[3].score
     end
 
     it 'should not give phrase field boost to match beyond slop' do
-      @sorted_hits[4].score.should == @sorted_hits[5].score
+      expect(@sorted_hits[4].score).to eq(@sorted_hits[5].score)
     end
   end
 
@@ -288,8 +318,8 @@ describe 'keyword search' do
     end
 
     after :each do
-      @search.results.should == @posts
-      @search.hits.first.score.should > @search.hits.last.score
+      expect(@search.results).to eq(@posts)
+      expect(@search.hits.first.score).to be > @search.hits.last.score
     end
 
     it 'boosts via function query with float' do