sunspot 2.0.0 → 2.5.0

data/spec/api/search/highlighting_spec.rb

@@ -14,38 +14,38 @@ describe 'search with highlighting results', :type => :search do
   end
 
   it 'returns all highlights' do
-    @search.hits.last.should have(3).highlights
+    expect(@search.hits.last.highlights.size).to eq(3)
   end
 
   it 'returns all highlights for a specified field' do
-    @search.hits.last.should have(2).highlights(:body)
+    expect(@search.hits.last.highlights(:body).size).to eq(2)
   end
 
   it 'returns first highlight for a specified field' do
-    @search.hits.first.highlight(:title).format.should == 'one <em>two</em> three'
+    expect(@search.hits.first.highlight(:title).format).to eq('one <em>two</em> three')
   end
 
   it 'returns an empty array if a given field does not have a highlight' do
-    @search.hits.first.highlights(:body).should == []
+    expect(@search.hits.first.highlights(:body)).to eq([])
   end
 
   it 'formats hits with <em> by default' do
     highlight = @search.hits.first.highlights(:title).first.formatted
-    highlight.should == 'one <em>two</em> three'
+    expect(highlight).to eq('one <em>two</em> three')
   end
 
   it 'formats hits with provided block' do
     highlight = @search.hits.first.highlights(:title).first.format do |word|
       "<i>#{word}</i>"
     end
-    highlight.should == 'one <i>two</i> three'
+    expect(highlight).to eq('one <i>two</i> three')
   end
 
   it 'handles multiple highlighted words' do
     highlight = @search.hits.last.highlights(:body).last.format do |word|
       "<b>#{word}</b>"
     end
-    highlight.should == '<b>eight</b> nine <b>ten</b>'
+    expect(highlight).to eq('<b>eight</b> nine <b>ten</b>')
   end
 
   private

data/spec/api/search/hits_spec.rb

@@ -5,37 +5,51 @@ describe 'hits', :type => :search do
     post_1, post_2 = Array.new(2) { Post.new }
     stub_results(post_1, post_2)
     %w(load load_all).each do |message|
-      MockAdapter::DataAccessor.should_not_receive(message)
+      expect(MockAdapter::DataAccessor).not_to receive(message)
     end
-    session.search(Post).hits.map do |hit|
+    expect(session.search(Post).hits.map do |hit|
       [hit.class_name, hit.primary_key]
-    end.should == [['Post', post_1.id.to_s], ['Post', post_2.id.to_s]]
+    end).to eq([['Post', post_1.id.to_s], ['Post', post_2.id.to_s]])
+  end
+
+  it "should return ID prefix when used with compositeId shard router" do
+    Sunspot.index!(ModelWithPrefixId.new)
+
+    expect(Sunspot.search(ModelWithPrefixId).
+      hits.map { |h| h.id_prefix }.uniq).to eq ["USERDATA!"]
+  end
+
+  it "should parse nested ID prefixes" do
+    Sunspot.index!(ModelWithNestedPrefixId.new)
+
+    expect(Sunspot.search(ModelWithNestedPrefixId).
+      hits.map { |h| h.id_prefix }.uniq).to eq ["USER!USERDATA!"]
   end
 
   it 'returns search total as attribute of hits' do
     stub_results(Post.new, 4)
-    session.search(Post) do
+    expect(session.search(Post) do
       paginate(:page => 1)
-    end.hits.total_entries.should == 4
+    end.hits.total_entries).to eq(4)
   end
 
   it 'returns search total as attribute of verified hits' do
     stub_results(Post.new, 4)
-    session.search(Post) do
+    expect(session.search(Post) do
       paginate(:page => 1)
-    end.hits(:verify => true).total_entries.should == 4
+    end.hits(:verify => true).total_entries).to eq(4)
   end
 
   it 'should return instance from hit' do
     posts = Array.new(2) { Post.new }
     stub_results(*posts)
-    session.search(Post).hits.first.instance.should == posts.first
+    expect(session.search(Post).hits.first.instance).to eq(posts.first)
   end
 
   it 'should return the instance primary key when you use it as a param' do
     posts = Array.new(2) { Post.new }
     stub_results(*posts)
-    session.search(Post).hits.first.to_param.should == posts.first.id.to_s
+    expect(session.search(Post).hits.first.to_param).to eq(posts.first.id.to_s)
   end
 
   it 'should provide iterator over hits with instances' do
@@ -49,8 +63,8 @@ describe 'hits', :type => :search do
       results << result
     end
 
-    hits.should have(2).hits
-    results.should have(2).results
+    expect(hits.size).to eq(2)
+    expect(results.size).to eq(2)
   end
 
   it 'should provide an Enumerator over hits with instances' do
@@ -59,9 +73,9 @@ describe 'hits', :type => :search do
     search = session.search(Post)
     hits, results = [], []
     search.each_hit_with_result.with_index do |(hit, result), index|
-      hit.should be_kind_of(Sunspot::Search::Hit)
-      result.should be_kind_of(Post)
-      index.should be_kind_of(Integer)
+      expect(hit).to be_kind_of(Sunspot::Search::Hit)
+      expect(result).to be_kind_of(Post)
+      expect(index).to be_kind_of(Integer)
     end
   end
 
@@ -71,9 +85,9 @@ describe 'hits', :type => :search do
     search = session.search(Post)
     search.hits.first.instance
     %w(load load_all).each do |message|
-      MockAdapter::DataAccessor.should_not_receive(message)
+      expect(MockAdapter::DataAccessor).not_to receive(message)
     end
-    search.hits.last.instance.should == posts.last
+    expect(search.hits.last.instance).to eq(posts.last)
   end
 
   it 'should return only hits whose referenced object exists in the data store if :verify option passed' do
@@ -81,7 +95,7 @@ describe 'hits', :type => :search do
     posts.last.destroy
     stub_results(*posts)
     search = session.search(Post)
-    search.hits(:verify => true).map { |hit| hit.instance }.should == posts[0..0]
+    expect(search.hits(:verify => true).map { |hit| hit.instance }).to eq(posts[0..0])
   end
 
   it 'should return verified and unverified hits from the same search' do
@@ -89,59 +103,59 @@ describe 'hits', :type => :search do
     posts.last.destroy
     stub_results(*posts)
     search = session.search(Post)
-    search.hits(:verify => true).map { |hit| hit.instance }.should == posts[0..0]
-    search.hits.map { |hit| hit.instance }.should == [posts.first, nil]
+    expect(search.hits(:verify => true).map { |hit| hit.instance }).to eq(posts[0..0])
+    expect(search.hits.map { |hit| hit.instance }).to eq([posts.first, nil])
   end
 
   it 'should attach score to hits' do
     stub_full_results('instance' => Post.new, 'score' => 1.23)
-    session.search(Post).hits.first.score.should == 1.23
+    expect(session.search(Post).hits.first.score).to eq(1.23)
   end
 
   it 'should return stored field values in hits' do
     stub_full_results('instance' => Post.new, 'title_ss' => 'Title')
-    session.search(Post).hits.first.stored(:title).should == 'Title'
+    expect(session.search(Post).hits.first.stored(:title)).to eq('Title')
   end
 
   it 'should return stored field values for searches against multiple types' do
     stub_full_results('instance' => Post.new, 'title_ss' => 'Title')
-    session.search(Post, Namespaced::Comment).hits.first.stored(:title).should == 'Title'
+    expect(session.search(Post, Namespaced::Comment).hits.first.stored(:title)).to eq('Title')
   end
 
   it 'should return stored field values for searches against base type when subtype matches' do
     class SubclassedPost < Post; end;
     stub_full_results('instance' => SubclassedPost.new, 'title_ss' => 'Title')
-    session.search(Post).hits.first.stored(:title).should == 'Title'
+    expect(session.search(Post).hits.first.stored(:title)).to eq('Title')
   end
 
   it 'should return stored text fields' do
     stub_full_results('instance' => Post.new, 'body_textsv' => 'Body')
-    session.search(Post, Namespaced::Comment).hits.first.stored(:body).should == 'Body'
+    expect(session.search(Post, Namespaced::Comment).hits.first.stored(:body)).to eq('Body')
   end
 
   it 'should return stored boolean fields' do
     stub_full_results('instance' => Post.new, 'featured_bs' => true)
-    session.search(Post, Namespaced::Comment).hits.first.stored(:featured).should be_true
+    expect(session.search(Post, Namespaced::Comment).hits.first.stored(:featured)).to be(true)
   end
 
   it 'should return stored boolean fields that evaluate to false' do
     stub_full_results('instance' => Post.new, 'featured_bs' => false)
-    session.search(Post, Namespaced::Comment).hits.first.stored(:featured).should == false
+    expect(session.search(Post, Namespaced::Comment).hits.first.stored(:featured)).to eq(false)
   end
 
   it 'should return stored dynamic fields' do
     stub_full_results('instance' => Post.new, 'custom_string:test_ss' => 'Custom')
-    session.search(Post, Namespaced::Comment).hits.first.stored(:custom_string, :test).should == 'Custom'
+    expect(session.search(Post, Namespaced::Comment).hits.first.stored(:custom_string, :test)).to eq('Custom')
   end
 
   it 'should typecast stored field values in hits' do
     time = Time.utc(2008, 7, 8, 2, 45)
     stub_full_results('instance' => Post.new, 'last_indexed_at_ds' => time.xmlschema)
-    session.search(Post).hits.first.stored(:last_indexed_at).should == time
+    expect(session.search(Post).hits.first.stored(:last_indexed_at)).to eq(time)
   end
 
   it 'should return stored values for multi-valued fields' do
     stub_full_results('instance' => User.new, 'role_ids_ims' => %w(1 4 5))
-    session.search(User).hits.first.stored(:role_ids).should == [1, 4, 5]
+    expect(session.search(User).hits.first.stored(:role_ids)).to eq([1, 4, 5])
   end
 end

data/spec/api/search/paginated_collection_spec.rb

@@ -3,46 +3,47 @@ require File.expand_path('spec_helper', File.dirname(__FILE__))
 describe "PaginatedCollection" do
   subject { Sunspot::Search::PaginatedCollection.new [], 1, 10, 20 }
 
-  it { subject.should be_an(Array) }
+  it { expect(subject).to be_an(Array) }
 
   describe "#send" do
     it 'should allow send' do
-      expect { subject.send(:current_page) }.not_to raise_error(NoMethodError)
+      expect { subject.send(:current_page) }.to_not raise_error
     end
   end
 
   describe "#respond_to?" do
     it 'should return true for current_page' do
-      subject.respond_to?(:current_page).should be_true
+      expect(subject.respond_to?(:current_page)).to be(true)
     end
   end
 
   context "behaves like a WillPaginate::Collection" do
-    it { subject.total_entries.should eql(20) }
-    it { subject.total_pages.should eql(2) }
-    it { subject.current_page.should eql(1) }
-    it { subject.per_page.should eql(10) }
-    it { subject.previous_page.should be_nil }
-    it { subject.next_page.should eql(2) }
-    it { subject.out_of_bounds?.should_not be_true }
-    it { subject.offset.should eql(0) }
+    it { expect(subject.total_entries).to eql(20) }
+    it { expect(subject.total_pages).to eql(2) }
+    it { expect(subject.current_page).to eql(1) }
+    it { expect(subject.per_page).to eql(10) }
+    it { expect(subject.previous_page).to be_nil }
+    it { expect(subject.prev_page).to be_nil }
+    it { expect(subject.next_page).to eql(2) }
+    it { expect(subject.out_of_bounds?).not_to be(true) }
+    it { expect(subject.offset).to eql(0) }
 
     it 'should allow setting total_count' do
       subject.total_count = 1
-      subject.total_count.should eql(1)
+      expect(subject.total_count).to eql(1)
     end
 
     it 'should allow setting total_entries' do
       subject.total_entries = 1
-      subject.total_entries.should eql(1)
+      expect(subject.total_entries).to eql(1)
     end
   end
 
   context "behaves like Kaminari" do
-    it { subject.total_count.should eql(20) }
-    it { subject.num_pages.should eql(2) }
-    it { subject.limit_value.should eql(10) }
-    it { subject.first_page?.should be_true }
-    it { subject.last_page?.should_not be_true }
+    it { expect(subject.total_count).to eql(20) }
+    it { expect(subject.num_pages).to eql(2) }
+    it { expect(subject.limit_value).to eql(10) }
+    it { expect(subject.first_page?).to be(true) }
+    it { expect(subject.last_page?).not_to be(true) }
   end
 end

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

@@ -0,0 +1,94 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+describe 'stats', :type => :search do
+  it 'returns field name for stats field' do
+    stub_stats(:average_rating_ft, {})
+    result = session.search Post do
+      stats :average_rating
+    end
+    expect(result.stats(:average_rating).field_name).to eq(:average_rating)
+  end
+
+  it 'returns min for stats field' do
+    stub_stats(:average_rating_ft, { 'min' => 1.0 })
+    result = session.search Post do
+      stats :average_rating
+    end
+    expect(result.stats(:average_rating).min).to eq(1.0)
+  end
+
+  it 'returns max for stats field' do
+    stub_stats(:average_rating_ft, { 'max' => 5.0 })
+    result = session.search Post do
+      stats :average_rating
+    end
+    expect(result.stats(:average_rating).max).to eq(5.0)
+  end
+
+  it 'returns count for stats field' do
+    stub_stats(:average_rating_ft, { 'count' => 120 })
+    result = session.search Post do
+      stats :average_rating
+    end
+    expect(result.stats(:average_rating).count).to eq(120)
+  end
+
+  it 'returns sum for stats field' do
+    stub_stats(:average_rating_ft, { 'sum' => 2200.0 })
+    result = session.search Post do
+      stats :average_rating
+    end
+    expect(result.stats(:average_rating).sum).to eq(2200.0)
+  end
+
+  it 'returns facet rows for stats field' do
+    stub_stats_facets(:average_rating_ft, 'featured_bs' => {
+      'false' => {},
+      'true' => {}
+    })
+    result = session.search Post do
+      stats :average_rating do
+        facet :featured
+      end
+    end
+    expect(stats_facet_values(result, :average_rating, :featured)).to eq([false, true])
+  end
+
+  it 'returns facet stats for stats field' do
+    stub_stats_facets(:average_rating_ft, 'featured_bs' => {
+      'true' => { 'min' => 2.0, 'max' => 4.0 }
+    })
+    result = session.search Post do
+      stats :average_rating do
+        facet :featured
+      end
+    end
+    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
+    blogs = 2.times.map { Blog.new }
+    stub_stats_facets(:average_rating_ft, 'blog_id_i' => {
+      blogs[0].id.to_s => {}, blogs[1].id.to_s => {} })
+    search = session.search(Post) do
+      stats :average_rating do
+        facet :blog_id
+      end
+    end
+    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
+    blog = Blog.new
+    stub_stats_facets(:average_rating_ft, 'blog_id_i' => {
+      blog.id.to_s => {}, '0' => {} })
+
+    search = session.search(Post) do
+      stats :average_rating do
+        facet :blog_id
+      end
+    end
+    expect(search.stats(:average_rating).facet(:blog_id).rows(:verified => true).map { |row| row.instance }).to eq([blog])
+  end
+end