sunspot_solr 2.0.0.pre.120924 → 2.0.0.pre.120925

data/sunspot/spec/integration/field_grouping_spec.rb

@@ -1,100 +0,0 @@
-require File.expand_path("../spec_helper", File.dirname(__FILE__))
-require File.expand_path("../helpers/search_helper", File.dirname(__FILE__))
-
-describe "field grouping" do
-  before :each do
-    Sunspot.remove_all
-
-    @posts = [
-      Post.new(:title => "Title1", :ratings_average => 4),
-      Post.new(:title => "Title1", :ratings_average => 5),
-      Post.new(:title => "Title2", :ratings_average => 3)
-    ]
-
-    Sunspot.index!(*@posts)
-  end
-
-  it "allows grouping by a field" do
-    search = Sunspot.search(Post) do
-      group :title
-    end
-
-    search.group(:title).groups.should include { |g| g.value == "Title1" }
-    search.group(:title).groups.should include { |g| g.value == "Title2" }
-  end
-
-  it "returns the number of matches unique groups" do
-    search = Sunspot.search(Post) do
-      group :title
-    end
-
-    search.group(:title).total.should == 2
-  end
-
-  it "provides access to the number of matches before grouping" do
-    search = Sunspot.search(Post) do
-      group :title
-    end
-
-    search.group(:title).matches.should == @posts.length
-  end
-
-  it "allows grouping by multiple fields" do
-    search = Sunspot.search(Post) do
-      group :title, :sort_title
-    end
-
-    search.group(:title).groups.should_not be_empty
-    search.group(:sort_title).groups.should_not be_empty
-  end
-
-  it "allows specification of the number of documents per group" do
-    search = Sunspot.search(Post) do
-      group :title do
-        limit 2
-      end
-    end
-
-    title1_group = search.group(:title).groups.detect { |g| g.value == "Title1" }
-    title1_group.hits.length.should == 2
-  end
-
-  it "allows specification of the sort within groups" do
-    search = Sunspot.search(Post) do
-      group :title do
-        order_by(:average_rating, :desc)
-      end
-    end
-
-    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
-  end
-
-  it "allows pagination within groups" do
-    search = Sunspot.search(Post) do
-      group :title
-      paginate :per_page => 1, :page => 2
-    end
-
-    search.group(:title).groups.length.should eql(1)
-    search.group(:title).groups.first.results.should == [ @posts.last ]
-  end
-
-  context "returns a paginated collection" do
-    subject do
-      search = Sunspot.search(Post) do
-        group :title
-        paginate :per_page => 1, :page => 2
-      end
-      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  }
-  end
-end

data/sunspot/spec/integration/geospatial_spec.rb

@@ -1,96 +0,0 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
-
-describe "geospatial search" do
-  describe "filtering by radius" do
-    before :all do
-      Sunspot.remove_all
-
-      @post = Post.new(:title       => "Howdy",
-                       :coordinates => Sunspot::Util::Coordinates.new(32, -68))
-      Sunspot.index!(@post)
-    end
-
-    it "matches posts within the radius" do
-      results = Sunspot.search(Post) {
-        with(:coordinates_new).in_radius(32, -68, 1)
-      }.results
-
-      results.should include(@post)
-    end
-
-    it "filters out posts not in the radius" do
-      results = Sunspot.search(Post) {
-        with(:coordinates_new).in_radius(33, -68, 1)
-      }.results
-
-      results.should_not include(@post)
-    end
-
-    it "allows conjunction queries" do
-      results = Sunspot.search(Post) {
-        any_of do
-          with(:coordinates_new).in_radius(32, -68, 1)
-          with(:coordinates_new).in_radius(35, 68, 1)
-        end
-      }.results
-
-      results.should include(@post)
-    end
-  end
-
-  describe "filtering by bounding box" do
-    before :all do
-      Sunspot.remove_all
-
-      @post = Post.new(:title       => "Howdy",
-                       :coordinates => Sunspot::Util::Coordinates.new(32, -68))
-      Sunspot.index!(@post)
-    end
-
-    it "matches post within the bounding box" do
-      results = Sunspot.search(Post) {
-        with(:coordinates_new).in_bounding_box [31, -69], [33, -67]
-      }.results
-
-      results.should include(@post)
-    end
-
-    it "filters out posts not in the bounding box" do
-      results = Sunspot.search(Post) {
-        with(:coordinates_new).in_bounding_box [20, -70], [21, -69]
-      }.results
-
-      results.should_not include(@post)
-    end
-  end
-
-  describe "ordering by geodist" do
-    before :all do
-      Sunspot.remove_all
-
-      @posts = [
-        Post.new(:title => "Howdy", :coordinates => Sunspot::Util::Coordinates.new(34, -68)),
-        Post.new(:title => "Howdy", :coordinates => Sunspot::Util::Coordinates.new(33, -68)),
-        Post.new(:title => "Howdy", :coordinates => Sunspot::Util::Coordinates.new(32, -68))
-      ]
-
-      Sunspot.index!(@posts)
-    end
-
-    it "orders posts by distance ascending" do
-      results = Sunspot.search(Post) {
-        order_by_geodist(:coordinates_new, 32, -68)
-      }.results
-
-      results.should == @posts.reverse
-    end
-
-    it "orders posts by distance descending" do
-      results = Sunspot.search(Post) {
-        order_by_geodist(:coordinates_new, 32, -68, :desc)
-      }.results
-
-      results.should == @posts
-    end
-  end
-end

data/sunspot/spec/integration/highlighting_spec.rb

@@ -1,44 +0,0 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
-
-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)
-    @posts << Post.new(:body => 'Lorem ipsum dolor sit amet', :title => '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
-  
-  it "should process multiple keyword request on different fields with highlights correctly" do
-    search_results = nil
-    lambda do
-      search_results = Sunspot.search(Post) do 
-        keywords 'Lorem ipsum', :fields => [:body] do
-          highlight :body
-        end
-        keywords 'consectetur', :fields => [:title] 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)
-    # this one might be a Solr bug, therefore not related to Sunspot itself
-    # search_results.hits.first.highlights.should_not be_empty
-  end
-  
-end

data/sunspot/spec/integration/indexing_spec.rb

@@ -1,55 +0,0 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
-
-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
-  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
-  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
-  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
-      with(:title, 'birds')
-    end
-    Sunspot.search(Post).should have(2).results
-  end
-
-
-  describe "in batches" do
-    let(:post_1) { Post.new :title => 'A tittle' }
-    let(:post_2) { Post.new :title => 'Another title' }
-
-    describe "nested" do
-      let(:a_nested_batch) do
-        Sunspot.batch do
-          Sunspot.index post_1
-
-          Sunspot.batch do
-            Sunspot.index post_2
-          end
-        end
-      end
-
-      it "does not fail" do
-        expect { a_nested_batch }.to_not raise_error
-      end
-    end
-  end
-end

data/sunspot/spec/integration/keyword_search_spec.rb

@@ -1,317 +0,0 @@
-require File.expand_path('../spec_helper', File.dirname(__FILE__))
-
-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 host\'s 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
-
-    it 'matches multiple keywords on different fields using subqueries' do
-      search = Sunspot.search(Post) do
-        keywords 'moron', :fields => [:title]
-        keywords 'wind',  :fields => [:body]
-      end
-      search.results.should == []
-
-      search = Sunspot.search(Post) do
-        keywords 'moron',   :fields => [:title]
-        keywords 'buffer',  :fields => [:body]
-      end
-      search.results.should == [@posts[1]]
-    end
-
-    it 'matches multiple keywords with escaped characters' do
-      search = Sunspot.search(Post) do
-        keywords 'spirit',   :fields => [:title]
-        keywords 'host\'s',  :fields => [:body]
-      end
-      search.results.should == [@posts[2]]
-    end
-
-    it 'matches multiple keywords with phrase-based search' do
-      search = Sunspot.search(Post) do
-        keywords 'spirit', :fields => [:title]
-        keywords '"interpret the buffer"', :fields => [:body]
-        keywords '"does the"', :fields => [:body]
-      end
-      search.results.should == [@posts[2]]
-    end
-
-    it 'matches multiple keywords different options' do
-      search = Sunspot.search(Post) do
-        keywords 'insufficient nonexistent', :fields => [:title], :minimum_match => 1
-        keywords 'wind does', :fields => [:body], :minimum_match => 2
-      end
-      search.results.should == [@posts[0]]
-    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
-
-  describe 'with function queries' do
-    before :each do
-      Sunspot.remove_all
-    end
-
-    after :each do
-      @search.results.should == @posts
-      @search.hits.first.score.should > @search.hits.last.score
-    end
-
-    it 'boosts via function query with float' do
-      @posts = [Post.new(:title => 'test', :ratings_average => 4.0),
-                Post.new(:title => 'test', :ratings_average => 2.0)]
-      Sunspot.index!(@posts)
-      @search = Sunspot.search(Post) do
-        keywords('test') do
-          boost function { :average_rating }
-        end
-      end
-    end
-
-    it 'boosts via function query with date' do
-      @posts = [Post.new(:title => 'test', :published_at => Time.now),
-                Post.new(:title => 'test', :published_at => Time.now - 60*60*24*31*6)] # roughly six months ago
-      Sunspot.index!(@posts)
-      @search = Sunspot.search(Post) do
-        keywords('test') do
-          boost function { recip(ms(Time.now, :published_at), 3.16e-11, 1, 1) }
-        end
-      end
-    end
-  end
-end