nxa-sunspot 0.10.7

data/spec/integration/highlighting_spec.rb

@@ -0,0 +1,22 @@
+describe 'keyword highlighting' do
+  before :all do
+    @posts = []
+    @posts << Post.new(:body => 'And the fox laughed')
+    @posts << Post.new(:body => 'Lorem ipsum dolor sit amet, consectetur adipiscing elit', :blog_id => 1)
+    Sunspot.index!(*@posts)
+    @search_result = Sunspot.search(Post) { keywords 'fox', :highlight => true }
+  end
+  
+  it 'should include highlights in the results' do
+    @search_result.hits.first.highlights.length.should == 1
+  end
+  
+  it 'should return formatted highlight fragments' do
+    @search_result.hits.first.highlights(:body).first.format.should == '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
+  end
+end

data/spec/integration/indexing_spec.rb

@@ -0,0 +1,7 @@
+describe 'indexing' do
+  it 'should index non-multivalued field with newlines' do
+    lambda do
+      Sunspot.index!(Post.new(:title => "A\nTitle"))
+    end.should_not raise_error(RSolr::RequestError)
+  end
+end

data/spec/integration/keyword_search_spec.rb

@@ -0,0 +1,245 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'keyword search' do
+  describe 'generally' do
+    before :all do
+      Sunspot.remove_all
+      @posts = []
+      @posts << Post.new(:title => 'The toast elects the insufficient spirit',
+                         :body => 'Does the wind write?')
+      @posts << Post.new(:title => 'A nail abbreviates the recovering insight outside the moron',
+                         :body => 'The interpreted strain scans the buffer around the upper temper')
+      @posts << Post.new(:title => 'The toast abbreviates the recovering spirit',
+                         :body => 'Does the wind interpret the buffer, moron?')
+      Sunspot.index!(*@posts)
+      @comment = Namespaced::Comment.new(:body => 'Hey there where ya goin, not exactly knowin, who says you have to call just one place toast.')
+      Sunspot.index!(@comment)
+    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]) }
+    end
+
+    it 'matches multiple words out of a single field' do
+      results = Sunspot.search(Post) { keywords 'elects toast' }.results
+      results.should == [@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]) }
+    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])
+    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]]
+    end
+  end
+
+  describe 'with field boost' do
+    before :all do
+      Sunspot.remove_all
+      @posts = [:title, :body].map { |field| Post.new(field => 'rhinoceros') }
+      Sunspot.index!(*@posts)
+    end
+
+    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 ==
+        @posts.map { |post| post.id.to_s }
+      search.hits.first.score.should > search.hits.last.score
+    end
+  end
+
+  describe 'with document boost' do
+    before :all do
+      Sunspot.remove_all
+      @posts = [4.0, 2.0].map do |rating|
+        Post.new(:title => 'Test', :ratings_average => rating)
+      end
+      Sunspot.index!(*@posts)
+    end
+
+    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 == 
+        @posts.map { |post| post.id.to_s }
+      search.hits.first.score.should > search.hits.last.score
+    end
+  end
+
+  describe 'with search-time boost' do
+    before :each do
+      Sunspot.remove_all
+      @comments = [
+        Namespaced::Comment.new(:body => 'test text'),
+        Namespaced::Comment.new(:author_name => 'test text')
+      ]
+      Sunspot.index!(@comments)
+    end
+
+    it 'assigns a higher score to documents in which all words appear in the phrase field' do
+      hits = Sunspot.search(Namespaced::Comment) do
+        keywords 'test text' do
+          phrase_fields :body => 2.0
+        end
+      end.hits
+      hits.first.instance.should == @comments.first
+      hits.first.score.should > hits.last.score
+    end
+
+    it 'assigns a higher score to documents in which the search terms appear in a boosted field' do
+      hits = Sunspot.search(Namespaced::Comment) do
+        keywords 'test' 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
+    end
+    
+    it 'assigns a higher score to documents in which the search terms appear in a higher boosted phrase field' do
+      hits = Sunspot.search(Namespaced::Comment) do
+        keywords 'test text' 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
+    end
+  end
+
+  describe 'boost query' do
+    before :all do
+      Sunspot.remove_all
+      Sunspot.index!(
+        @posts = [
+          Post.new(:title => 'Rhino', :featured => true),
+          Post.new(:title => 'Rhino', :ratings_average => 3.3),
+          Post.new(:title => 'Rhino')
+        ]
+      )
+    end
+
+    it 'should assign a higher score to the document matching the boost query' do
+      search = Sunspot.search(Post) do |query|
+        query.keywords('rhino') do
+          boost(2.0) do
+            with(:featured, true)
+          end
+        end
+        query.without(@posts[1])
+      end
+      search.results.should == [@posts[0], @posts[2]]
+      search.hits[0].score.should > search.hits[1].score
+    end
+
+    it 'should assign scores in order of multiple boost query match' do
+      search = Sunspot.search(Post) do
+        keywords 'rhino' do
+          boost(2.0) { with(:featured, true) }
+          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
+    end
+  end
+
+  describe 'minimum match' do
+    before do
+      Sunspot.remove_all
+      @posts = [
+        Post.new(:title => 'Pepperoni Sausage Anchovies'),
+        Post.new(:title => 'Pepperoni Tomatoes Mushrooms')
+      ]
+      Sunspot.index!(@posts)
+      @search = Sunspot.search(Post) do
+        keywords 'pepperoni sausage extra cheese', :minimum_match => 2
+      end
+    end
+
+    it 'should match documents that contain the minimum_match number of search terms' do
+      @search.results.should 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])
+    end
+  end
+
+  describe 'query phrase slop' do
+    before do
+      Sunspot.remove_all
+      @posts = [
+        Post.new(:title => 'One four'),
+        Post.new(:title => 'One three four'),
+        Post.new(:title => 'One two three four')
+      ]
+      Sunspot.index!(@posts)
+      @search = Sunspot.search(Post) do
+        keywords '"one four"', :query_phrase_slop => 1
+      end
+    end
+
+    it 'should match exact phrase' do
+      @search.results.should include(@posts[0])
+    end
+
+    it 'should match phrase divided by query phrase slop terms' do
+      @search.results.should 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])
+    end
+  end
+
+  describe 'phrase field slop' do
+    before do
+      Sunspot.remove_all
+      @comments = [
+        Namespaced::Comment.new(:author_name => 'one four'),
+        Namespaced::Comment.new(:body => 'one four'),
+        Namespaced::Comment.new(:author_name => 'one three four'),
+        Namespaced::Comment.new(:body => 'one three four'),
+        Namespaced::Comment.new(:author_name => 'one two three four'),
+        Namespaced::Comment.new(:body => 'one two three four')
+      ]
+      Sunspot.index!(@comments)
+      @search = Sunspot.search(Namespaced::Comment) do
+        keywords 'one four' do
+          phrase_fields :author_name => 3.0
+          phrase_slop 1
+        end
+      end
+      @sorted_hits = @search.hits.sort_by { |hit| @comments.index(hit.instance) }
+    end
+
+    it 'should give phrase field boost to exact match' do
+      @sorted_hits[0].score.should > @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
+    end
+
+    it 'should not give phrase field boost to match beyond slop' do
+      @sorted_hits[4].score.should == @sorted_hits[5].score
+    end
+  end
+end

data/spec/integration/local_search_spec.rb

@@ -0,0 +1,56 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'local search' do
+  ORIGIN = [40.6749113, -73.9648859]
+  before :each do
+    Sunspot.remove_all
+    @posts = [
+      Post.new(:coordinates => ORIGIN),
+      Post.new(:coordinates => [40.725304, -73.997211], :title => 'teacup'),
+      Post.new(:coordinates => [40.800069, -73.962283]),
+      Post.new(:coordinates => [43.706488, -72.292233]),
+      Post.new(:coordinates => [38.920303, -77.110934], :title => 'teacup'),
+      Post.new(:coordinates => [47.661557, -122.349938])
+    ]
+    @posts.each_with_index { |post, i| post.blog_id = @posts.length - i }
+    Sunspot.index!(@posts)
+  end
+
+  it 'should find all the posts within a given radius' do
+    search = Sunspot.search(Post) { |query| query.near(ORIGIN, 20) }
+    search.results.to_set.should == @posts[0..2].to_set
+  end
+
+  it 'should perform a radial search with fulltext matching' do
+    pending 'fix for LocalSolr facet query or subquery support'
+    search = Sunspot.search(Post) do |query|
+      query.keywords 'teacup'
+      query.near(ORIGIN, 20)
+    end
+    search.results.should == [@posts[1]]
+  end
+
+  it 'should perform a radial search with attribute scoping' do
+    search = Sunspot.search(Post) do |query|
+      query.near(ORIGIN,20)
+      query.with(:title, 'teacup')
+    end
+    search.results.should == [@posts[1]]
+  end
+  
+  it 'should order by arbitrary field' do
+    search = Sunspot.search(Post) do |query|
+      query.near(ORIGIN, 20)
+      query.order_by(:blog_id)
+    end
+    search.results.should == @posts[0..2].reverse
+  end
+
+  it 'should order by geo distance' do
+    search = Sunspot.search(Post) do |query|
+      query.near(ORIGIN, 20)
+      query.order_by(:distance)
+    end
+    search.results.should == @posts[0..2]
+  end
+end

data/spec/integration/scoped_search_spec.rb

@@ -0,0 +1,303 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'scoped_search' do
+  def self.test_field_type(name, attribute, field, *values)
+    raise(ArgumentError, 'Please supply five values') unless values.length == 5
+
+    context "with field of type #{name}" do
+      before :all do
+        Sunspot.remove_all
+        @posts = values.map do |value|
+          post = Post.new(attribute => value)
+          Sunspot.index(post)
+          post
+        end
+        Sunspot.commit
+      end
+
+      it 'should filter by exact match' do
+        Sunspot.search(Post) { with(field, values[2]) }.results.should == [@posts[2]]
+      end
+
+      it 'should reject by inexact match' do
+        results = Sunspot.search(Post) { without(field, values[2]) }.results
+        [0, 1, 3, 4].each { |i| results.should include(@posts[i]) }
+        results.should_not include(@posts[2])
+      end
+
+      it 'should filter by less than' do
+        results = Sunspot.search(Post) { with(field).less_than values[2] }.results
+        (0..2).each { |i| results.should include(@posts[i]) }
+        (3..4).each { |i| results.should_not include(@posts[i]) }
+      end
+
+      it 'should reject by less than' do
+        results = Sunspot.search(Post) { without(field).less_than values[2] }.results
+        (0..2).each { |i| results.should_not include(@posts[i]) }
+        (3..4).each { |i| results.should include(@posts[i]) }
+      end
+
+      it 'should filter by greater than' do
+        results = Sunspot.search(Post) { with(field).greater_than values[2] }.results
+        (2..4).each { |i| results.should include(@posts[i]) }
+        (0..1).each { |i| results.should_not include(@posts[i]) }
+      end
+
+      it 'should reject by greater than' do
+        results = Sunspot.search(Post) { without(field).greater_than values[2] }.results
+        (2..4).each { |i| results.should_not include(@posts[i]) }
+        (0..1).each { |i| results.should include(@posts[i]) }
+      end
+
+      it 'should filter by between' do
+        results = Sunspot.search(Post) { with(field).between(values[1]..values[3]) }.results
+        (1..3).each { |i| results.should include(@posts[i]) }
+        [0, 4].each { |i| results.should_not include(@posts[i]) }
+      end
+
+      it 'should reject by between' do
+        results = Sunspot.search(Post) { without(field).between(values[1]..values[3]) }.results
+        (1..3).each { |i| results.should_not include(@posts[i]) }
+        [0, 4].each { |i| results.should include(@posts[i]) }
+      end
+
+      it 'should filter by any of' do
+        results = Sunspot.search(Post) { with(field).any_of(values.values_at(1, 3)) }.results
+        [1, 3].each { |i| results.should include(@posts[i]) }
+        [0, 2, 4].each { |i| results.should_not include(@posts[i]) }
+      end
+
+      it 'should reject by any of' do
+        results = Sunspot.search(Post) { without(field).any_of(values.values_at(1, 3)) }.results
+        [1, 3].each { |i| results.should_not include(@posts[i]) }
+        [0, 2, 4].each { |i| results.should include(@posts[i]) }
+      end
+
+      it 'should order by field ascending' do
+        results = Sunspot.search(Post) { order_by field, :asc }.results
+        results.should == @posts
+      end
+
+      it 'should order by field descending' do
+        results = Sunspot.search(Post) { order_by field, :desc }.results
+        results.should == @posts.reverse
+      end
+    end
+  end
+
+  test_field_type 'String', :title, :title, 'apple pie', 'banana split', 'cherry tart', 'date pastry', 'eggplant a la mode'
+  test_field_type 'Integer', :blog_id, :blog_id, -2, 0, 3, 12, 20
+  test_field_type 'Float', :ratings_average, :average_rating, -2.5, 0.0, 3.2, 3.5, 16.0
+  test_field_type 'Time', :published_at, :published_at, *(['1970-01-01 00:00:00 UTC', '1983-07-08 04:00:00 UTC', '1983-07-08 02:00:00 -0500',
+                                                           '2005-11-05 10:00:00 UTC', Time.now.to_s].map { |t| Time.parse(t) })
+
+  describe 'Boolean field type' do
+    before :all do
+      Sunspot.remove_all
+      @posts = [Post.new(:featured => true), Post.new(:featured => false), Post.new]
+      Sunspot.index!(@posts)
+    end
+
+    it 'should filter by exact match for true' do
+      Sunspot.search(Post) { with(:featured, true) }.results.should == [@posts[0]]
+    end
+
+    it 'should filter for exact match for false' do
+      Sunspot.search(Post) { with(:featured, false) }.results.should == [@posts[1]]
+    end
+  end
+
+  describe 'passing nil value to equal' do
+    before :all do
+      Sunspot.remove_all
+      @posts = [Post.new(:title => 'apple'), Post.new]
+      Sunspot.index!(@posts)
+    end
+
+    it 'should filter results without value for field' do
+      Sunspot.search(Post) { with(:title, nil) }.results.should == [@posts[1]]
+    end
+
+    it 'should exclude results without value for field' do
+      Sunspot.search(Post) { without(:title, nil) }.results.should == [@posts[0]]
+    end
+  end
+
+  describe 'prefix searching' do
+    before :each do
+      Sunspot.remove_all
+      @posts = ['test', 'test post', 'some test', 'bogus'].map do |title|
+        Post.new(:title => title)
+      end
+      Sunspot.index!(@posts)
+    end
+
+    it 'should return results whose prefix matches' do
+      Sunspot.search(Post) { with(:title).starting_with('test') }.results.should == @posts[0..1]
+    end
+  end
+
+  describe 'exclusion by identity' do
+    before do
+      @posts = (1..5).map do |i|
+        post = Post.new
+        Sunspot.index(post)
+        post
+      end
+      Sunspot.commit
+    end
+
+    it 'should not return excluded object' do
+      excluded_post = @posts.shift
+      Sunspot.search(Post) { without(excluded_post) }.results.should_not include(excluded_post)
+    end
+
+    it 'should return objects not excluded' do
+      excluded_post = @posts.shift
+      for included_post in @posts
+        Sunspot.search(Post) { without(excluded_post) }.results.should include(included_post)
+      end
+    end
+
+    it 'should not return excluded objects' do
+      excluded_posts = [@posts.shift, @posts.shift]
+      for excluded_post in excluded_posts
+        Sunspot.search(Post) { without(excluded_posts) }.results.should_not include(excluded_post)
+      end
+    end
+  end
+
+  describe 'connectives' do
+    before :each do
+      Sunspot.remove_all
+    end
+
+    it 'should return results that match any restriction in a disjunction' do
+      posts = (1..3).map { |i| Post.new(:blog_id => i)}
+      Sunspot.index!(posts)
+      Sunspot.search(Post) do
+        any_of do
+          with(:blog_id, 1)
+          with(:blog_id, 2)
+        end
+      end.results.should == posts[0..1]
+    end
+
+    it 'should return results that match a nested conjunction in a disjunction' do
+      posts = [
+        Post.new(:title => 'No', :blog_id => 1),
+        Post.new(:title => 'Yes', :blog_id => 2),
+        Post.new(:title => 'Yes', :blog_id => 3),
+        Post.new(:title => 'No', :blog_id => 2)
+      ]
+      Sunspot.index!(posts)
+      Sunspot.search(Post) do
+        any_of do
+          with(:blog_id, 1)
+          all_of do
+            with(:blog_id, 2)
+            with(:title, 'Yes')
+          end
+        end
+      end.results.should == posts[0..1]
+    end
+
+    it 'should return results that match a conjunction with a negated restriction' do
+      posts = [
+        Post.new(:title => 'No', :blog_id => 1),
+        Post.new(:title => 'Yes', :blog_id => 2),
+        Post.new(:title => 'No', :blog_id => 2)
+      ]
+      Sunspot.index!(posts)
+      search = Sunspot.search(Post) do
+        any_of do
+          with(:blog_id, 1)
+          without(:title, 'No')
+        end
+      end
+      search.results.should == posts[0..1]
+    end
+
+    it 'should return results that match a conjunction with a disjunction with a conjunction with a negated restriction' do
+      posts = [
+        Post.new(:title => 'Yes', :ratings_average => 2.0),
+        Post.new(:blog_id => 1, :category_ids => [4], :ratings_average => 2.0),
+        Post.new(:blog_id => 1),
+        Post.new(:blog_id => 2),
+        Post.new(:blog_id => 1, :ratings_average => 2.0)
+      ]
+      Sunspot.index!(posts)
+      search = Sunspot.search(Post) do
+        any_of do
+          with(:title, 'Yes')
+          all_of do
+            with(:blog_id, 1)
+            any_of do
+              with(:category_ids, 4)
+              without(:average_rating, 2.0)
+            end
+          end
+        end
+      end
+      search.results.should == posts[0..2]
+    end
+
+    it 'should return results that match a disjunction with a negated restriction and a nested disjunction in a conjunction with a negated restriction' do
+      posts = [
+        Post.new,
+        Post.new(:title => 'Yes', :blog_id => 1, :category_ids => [4], :ratings_average => 2.0),
+        Post.new(:title => 'Yes', :blog_id => 1),
+        Post.new(:title => 'Yes'),
+        Post.new(:title => 'Yes', :category_ids => [4], :ratings_average => 2.0),
+        Post.new(:title => 'Yes', :blog_id => 1, :ratings_average => 2.0)
+      ]
+      Sunspot.index!(posts)
+      search = Sunspot.search(Post) do
+        any_of do
+          without(:title, 'Yes')
+          all_of do
+            with(:blog_id, 1)
+            any_of do
+              with(:category_ids, 4)
+              without(:average_rating, 2.0)
+            end
+          end
+        end
+      end
+      search.results.should == posts[0..2]
+    end
+  end
+
+  describe 'multiple column ordering' do
+    before do
+      Sunspot.remove_all
+      @posts = [
+        Post.new(:ratings_average => 2, :title => 'banana'),
+        Post.new(:ratings_average => 2, :title => 'eggplant'),
+        Post.new(:ratings_average => 1, :title => 'apple')
+      ].each { |post| Sunspot.index(post) }
+      Sunspot.commit
+    end
+
+    it 'should order with precedence given' do
+      search = Sunspot.search(Post) do
+        order_by :average_rating, :desc
+        order_by :sort_title, :asc
+      end
+      search.results.should == @posts
+    end
+  end
+
+  describe 'ordering by random' do
+    it 'should order randomly (run this test again if it fails)' do
+      Sunspot.remove_all
+      Sunspot.index!(Array.new(100) { Post.new })
+      result_sets = Array.new(2) do
+        Sunspot.search(Post) { order_by_random }.results.map do |result|
+          result.id
+        end
+      end
+      result_sets[0].should_not == result_sets[1]
+    end
+  end
+end