UnderpantsGnome-sunspot 0.9.1.1

data/spec/api/spec_helper.rb

@@ -0,0 +1 @@
+require File.join(File.dirname(__FILE__), '..', 'spec_helper')

data/spec/api/sunspot_spec.rb

@@ -0,0 +1,18 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe Sunspot do
+  describe "reset!" do
+    it "should reset current session" do
+      old_session = Sunspot.send(:session)
+      Sunspot.reset!(true)
+      Sunspot.send(:session).should_not == old_session
+    end
+
+    it "should keep keep configuration if specified" do
+      Sunspot.config.solr.url = "http://localhost:9999/path/solr"
+      config_before_reset = Sunspot.config
+      Sunspot.reset!(true)
+      Sunspot.config.should == config_before_reset
+    end
+  end
+end

data/spec/integration/dynamic_fields_spec.rb

@@ -0,0 +1,55 @@
+describe 'dynamic fields' do
+  before :each do
+    Sunspot.remove_all
+    @posts = Post.new(:custom_string => { :cuisine => 'Pizza' }),
+             Post.new(:custom_string => { :cuisine => 'Greek' }),
+             Post.new(:custom_string => { :cuisine => 'Greek' })
+    Sunspot.index!(@posts)
+  end
+
+  it 'should search for dynamic string field' do
+    Sunspot.search(Post) do
+      dynamic(:custom_string) do
+        with(:cuisine, 'Pizza')
+      end
+    end.results.should == [@posts.first]
+  end
+
+  describe 'faceting' do
+    before :each do
+      @search = Sunspot.search(Post) do
+        dynamic :custom_string do
+          facet :cuisine
+        end
+      end
+    end
+
+    it 'should return value "value" with count 2' do
+      row = @search.dynamic_facet(:custom_string, :cuisine).rows[0]
+      row.value.should == 'Greek'
+      row.count.should == 2
+    end
+
+    it 'should return value "other" with count 1' do
+      row = @search.dynamic_facet(:custom_string, :cuisine).rows[1]
+      row.value.should == 'Pizza'
+      row.count.should == 1
+    end
+  end
+
+  it 'should order by dynamic string field ascending' do
+    Sunspot.search(Post) do
+      dynamic :custom_string do
+        order_by :cuisine, :asc
+      end
+    end.results.last.should == @posts.first
+  end
+
+  it 'should order by dynamic string field descending' do
+    Sunspot.search(Post) do
+      dynamic :custom_string do
+        order_by :cuisine, :desc
+      end
+    end.results.first.should == @posts.first
+  end
+end

data/spec/integration/faceting_spec.rb

@@ -0,0 +1,169 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+
+describe 'search faceting' do
+  def self.test_field_type(name, attribute, field, value1, value2)
+    context "with field of type #{name}" do
+      before :all do
+        Sunspot.remove_all
+        2.times do
+          Sunspot.index(Post.new(attribute => value1))
+        end
+        Sunspot.index(Post.new(attribute => value2))
+        Sunspot.commit
+      end
+
+      before :each do
+        @search = Sunspot.search(Post) do
+          facet(field)
+        end
+      end
+
+      it "should return value #{value1.inspect} with count 2" do
+        row = @search.facet(field).rows[0]
+        row.value.should == value1
+        row.count.should == 2
+      end
+
+      it "should return value #{value2.inspect} with count 1" do
+        row = @search.facet(field).rows[1]
+        row.value.should == value2
+        row.count.should == 1
+      end
+    end
+  end
+
+  test_field_type('String', :title, :title, 'Title 1', 'Title 2')
+  test_field_type('Integer', :blog_id, :blog_id, 3, 4)
+  test_field_type('Float', :ratings_average, :average_rating, 2.2, 1.1)
+  test_field_type('Time', :published_at, :published_at, Time.mktime(2008, 02, 17, 17, 45, 04),
+                                                        Time.mktime(2008, 07, 02, 03, 56, 22))
+  test_field_type('Boolean', :featured, :featured, true, false)
+
+  context 'facet options' do
+    before :all do
+      Sunspot.remove_all
+      facet_values = %w(zero one two three four)
+      facet_values.each_with_index do |value, i|
+        i.times { Sunspot.index(Post.new(:title => value, :blog_id => 1)) }
+      end
+      Sunspot.index(Post.new(:title => 'zero', :blog_id => 2))
+      Sunspot.commit
+    end
+
+    it 'should limit the number of facet rows' do
+      search = Sunspot.search(Post) do
+        facet :title, :limit => 3
+      end
+      search.facet(:title).should have(3).rows
+    end
+
+    it 'should not return zeros by default' do
+      search = Sunspot.search(Post) do
+        with :blog_id, 1
+        facet :title
+      end
+      search.facet(:title).rows.map { |row| row.value }.should_not include('zero')
+    end
+
+    it 'should return zeros when specified' do
+      search = Sunspot.search(Post) do
+        with :blog_id, 1
+        facet :title, :zeros => true
+      end
+      search.facet(:title).rows.map { |row| row.value }.should include('zero')
+    end
+
+    it 'should return a specified minimum count' do
+      search = Sunspot.search(Post) do
+        with :blog_id, 1
+        facet :title, :minimum_count => 2
+      end
+      search.facet(:title).rows.map { |row| row.value }.should == %w(four three two)
+    end
+
+    it 'should order facets lexically' do
+      search = Sunspot.search(Post) do
+        with :blog_id, 1
+        facet :title, :sort => :index
+      end
+      search.facet(:title).rows.map { |row| row.value }.should == %w(four one three two)
+    end
+
+    it 'should order facets by count' do
+      search = Sunspot.search(Post) do
+        with :blog_id, 1
+        facet :title, :sort => :count
+      end
+      search.facet(:title).rows.map { |row| row.value }.should == %w(four three two one)
+    end
+  end
+
+  context 'date facets' do
+    before :all do
+      Sunspot.remove_all
+      time = Time.utc(2009, 7, 8)
+      Sunspot.index!(
+        (0..2).map { |i| Post.new(:published_at => time + i*60*60*16) }
+      )
+    end
+
+    it 'should return time ranges' do
+      time = Time.utc(2009, 7, 8)
+      search = Sunspot.search(Post) do
+        facet :published_at, :time_range => time..(time + 60*60*24*2), :sort => :count
+      end
+      search.facet(:published_at).rows.first.value.should == (time..(time + 60*60*24))
+      search.facet(:published_at).rows.first.count.should == 2
+      search.facet(:published_at).rows.last.value.should == ((time + 60*60*24)..(time + 60*60*24*2))
+      search.facet(:published_at).rows.last.count.should == 1
+    end
+  end
+
+  context 'class facets' do
+    before :all do
+      Sunspot.remove_all
+      Sunspot.index!(Post.new, Post.new, Namespaced::Comment.new)
+    end
+
+    it 'should return classes' do
+      search = Sunspot.search(Post, Namespaced::Comment) do
+        facet(:class, :sort => :count)
+      end
+      search.facet(:class).rows.first.value.should == Post
+      search.facet(:class).rows.first.count.should == 2
+      search.facet(:class).rows.last.value.should == Namespaced::Comment
+      search.facet(:class).rows.last.count.should == 1
+    end
+  end
+
+  context 'query facets' do
+    before :all do
+      Sunspot.remove_all
+      Sunspot.index!(
+        [1.1, 1.2, 3.2, 3.4, 3.9, 4.1].map do |rating|
+          Post.new(:ratings_average => rating)
+        end
+      )
+    end
+
+    it 'should return specified facets' do
+      search = Sunspot.search(Post) do
+        facet :rating_range do
+          for rating in [1.0, 2.0, 3.0, 4.0]
+            range = rating..(rating + 1.0)
+            row range do
+              with :average_rating, rating..(rating + 1.0)
+            end
+          end
+        end
+      end
+      facet = search.facet(:rating_range)
+      facet.rows[0].value.should == (3.0..4.0)
+      facet.rows[0].count.should == 3
+      facet.rows[1].value.should == (1.0..2.0)
+      facet.rows[1].count.should == 2
+      facet.rows[2].value.should == (4.0..5.0)
+      facet.rows[2].count.should == 1
+    end
+  end
+end

data/spec/integration/keyword_search_spec.rb

@@ -0,0 +1,83 @@
+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
+end

data/spec/integration/scoped_search_spec.rb

@@ -0,0 +1,188 @@
+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', 'banana', 'cherry', 'date', 'eggplant'
+  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 '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 '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