sunspot 2.0.0 → 2.5.0

data/spec/api/query/join_spec.rb

@@ -0,0 +1,19 @@
+require File.expand_path('spec_helper', File.dirname(__FILE__))
+
+describe 'join' do
+  it 'should search by join' do
+    session.search PhotoContainer do
+      with(:caption, 'blah')
+    end
+    expect(connection).to have_last_search_including(
+      :fq, "{!join from=photo_container_id_i to=id_i}caption_s:blah")
+  end
+
+  it 'should greater_than search by join' do
+    session.search PhotoContainer do
+      with(:photo_rating).greater_than(3)
+    end
+    expect(connection).to have_last_search_including(
+      :fq, "{!join from=photo_container_id_i to=id_i}average_rating_ft:{3\\.0 TO *}")
+  end
+end

data/spec/api/query/more_like_this_spec.rb

@@ -16,42 +16,42 @@ describe 'more_like_this' do
   it 'should query passed in object' do
     p = Post.new
     session.more_like_this(p)
-    connection.should have_last_search_with(:q => "id:Post\\ #{p.id}")
+    expect(connection).to have_last_search_with(:q => "id:Post\\ #{p.id}")
   end
 
   it 'should use more_like_this fields if no fields specified' do
     session.more_like_this(Post.new)
-    connection.searches.last[:"mlt.fl"].split(',').sort.should == %w(body_textsv tags_textv)
+    expect(connection.searches.last[:"mlt.fl"].split(',').sort).to eq(%w(body_textsv tags_textv))
   end
 
   it 'should use more_like_this fields if specified' do
     session.more_like_this(Post.new) do
       fields :body
     end
-    connection.should have_last_search_with(:"mlt.fl" => "body_textsv")
+    expect(connection).to have_last_search_with(:"mlt.fl" => "body_textsv")
   end
 
   it 'assigns boosts to fields when specified' do
     session.more_like_this(Post.new) do
       fields :body, :tags => 8
     end
-    connection.searches.last[:"mlt.fl"].split(',').sort.should == %w(body_textsv tags_textv)
-    connection.should have_last_search_with(:qf => "tags_textv^8")
+    expect(connection.searches.last[:"mlt.fl"].split(',').sort).to eq(%w(body_textsv tags_textv))
+    expect(connection).to have_last_search_with(:"mlt.qf" => "tags_textv^8")
   end
 
   it 'doesn\'t assign boosts to fields when not specified' do
     session.more_like_this(Post.new) do
       fields :body
     end
-    connection.should_not have_last_search_with(:qf)
+    expect(connection).not_to have_last_search_with(:qf)
   end
 
   it 'should raise ArgumentError if a field is not setup for more_like_this' do
-    lambda do
+    expect do
       session.more_like_this(Post.new) do
         fields :title
       end
-    end.should raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it 'should accept options' do
@@ -63,12 +63,12 @@ describe 'more_like_this' do
       maximum_query_terms 5
       boost_by_relevance false
     end
-    connection.should have_last_search_with(:"mlt.mintf" => 1)
-    connection.should have_last_search_with(:"mlt.mindf" => 2)
-    connection.should have_last_search_with(:"mlt.minwl" => 3)
-    connection.should have_last_search_with(:"mlt.maxwl" => 4)
-    connection.should have_last_search_with(:"mlt.maxqt" => 5)
-    connection.should have_last_search_with(:"mlt.boost" => false)
+    expect(connection).to have_last_search_with(:"mlt.mintf" => 1)
+    expect(connection).to have_last_search_with(:"mlt.mindf" => 2)
+    expect(connection).to have_last_search_with(:"mlt.minwl" => 3)
+    expect(connection).to have_last_search_with(:"mlt.maxwl" => 4)
+    expect(connection).to have_last_search_with(:"mlt.maxqt" => 5)
+    expect(connection).to have_last_search_with(:"mlt.boost" => false)
   end
 
   it 'should accept short options' do
@@ -80,45 +80,45 @@ describe 'more_like_this' do
       maxqt 5
       boost true
     end
-    connection.should have_last_search_with(:"mlt.mintf" => 1)
-    connection.should have_last_search_with(:"mlt.mindf" => 2)
-    connection.should have_last_search_with(:"mlt.minwl" => 3)
-    connection.should have_last_search_with(:"mlt.maxwl" => 4)
-    connection.should have_last_search_with(:"mlt.maxqt" => 5)
-    connection.should have_last_search_with(:"mlt.boost" => true)
+    expect(connection).to have_last_search_with(:"mlt.mintf" => 1)
+    expect(connection).to have_last_search_with(:"mlt.mindf" => 2)
+    expect(connection).to have_last_search_with(:"mlt.minwl" => 3)
+    expect(connection).to have_last_search_with(:"mlt.maxwl" => 4)
+    expect(connection).to have_last_search_with(:"mlt.maxqt" => 5)
+    expect(connection).to have_last_search_with(:"mlt.boost" => true)
   end
 
   it 'paginates using default per_page when page not provided' do
     session.more_like_this(Post.new)
-    connection.should have_last_search_with(:rows => 30)
+    expect(connection).to have_last_search_with(:rows => 30)
   end
 
   it 'paginates using default per_page when page provided' do
     session.more_like_this(Post.new) do
       paginate :page => 2
     end
-    connection.should have_last_search_with(:rows => 30, :start => 30)
+    expect(connection).to have_last_search_with(:rows => 30, :start => 30)
   end
 
   it 'paginates using provided per_page' do
     session.more_like_this(Post.new) do
       paginate :page => 4, :per_page => 15
     end
-    connection.should have_last_search_with(:rows => 15, :start => 45)
+    expect(connection).to have_last_search_with(:rows => 15, :start => 45)
   end
 
   it 'defaults to page 1 if no :page argument given' do
     session.more_like_this(Post.new) do
       paginate :per_page => 15
     end
-    connection.should have_last_search_with(:rows => 15, :start => 0)
+    expect(connection).to have_last_search_with(:rows => 15, :start => 0)
   end
 
   it 'paginates from string argument' do
     session.more_like_this(Post.new) do
       paginate :page => '3', :per_page => '15'
     end
-    connection.should have_last_search_with(:rows => 15, :start => 30)
+    expect(connection).to have_last_search_with(:rows => 15, :start => 30)
   end
 
   it "should send query to solr with adjusted parameters (keyword example)" do
@@ -128,8 +128,21 @@ describe 'more_like_this' do
         params[:some] = 'param'
       end
     end
-    connection.should have_last_search_with(:q    => 'new search')
-    connection.should have_last_search_with(:some => 'param')
+    expect(connection).to have_last_search_with(:q    => 'new search')
+    expect(connection).to have_last_search_with(:some => 'param')
+  end
+
+  it "should send query to solr with adjusted parameters in multiple blocks" do
+    session.more_like_this(Post.new) do
+      adjust_solr_params do |params|
+        params[:q]    = 'new search'
+      end
+      adjust_solr_params do |params|
+        params[:some] = 'param'
+      end
+    end
+    expect(connection).to have_last_search_with(:q    => 'new search')
+    expect(connection).to have_last_search_with(:some => 'param')
   end
 
   private

data/spec/api/query/ordering_pagination_examples.rb

@@ -1,56 +1,70 @@
 shared_examples_for 'sortable query' do
   it 'paginates using default per_page when page not provided' do
     search
-    connection.should have_last_search_with(:rows => 30)
+    expect(connection).to have_last_search_with(:rows => 30)
   end
 
   it 'paginates using default per_page when page provided' do
     search do
       paginate :page => 2
     end
-    connection.should have_last_search_with(:rows => 30, :start => 30)
+    expect(connection).to have_last_search_with(:rows => 30, :start => 30)
   end
 
   it 'paginates using provided per_page' do
     search do
       paginate :page => 4, :per_page => 15
     end
-    connection.should have_last_search_with(:rows => 15, :start => 45)
+    expect(connection).to have_last_search_with(:rows => 15, :start => 45)
   end
 
   it 'defaults to page 1 if no :page argument given' do
     search do
       paginate :per_page => 15
     end
-    connection.should have_last_search_with(:rows => 15, :start => 0)
+    expect(connection).to have_last_search_with(:rows => 15, :start => 0)
   end
 
   it 'paginates with an offset' do
     search do
       paginate :per_page => 15, :offset => 3
     end
-    connection.should have_last_search_with(:rows => 15, :start => 3)
+    expect(connection).to have_last_search_with(:rows => 15, :start => 3)
   end
 
   it 'paginates with an offset as a string' do
     search do
       paginate :per_page => 15, :offset => '3'
     end
-    connection.should have_last_search_with(:rows => 15, :start => 3)
+    expect(connection).to have_last_search_with(:rows => 15, :start => 3)
   end
 
   it 'paginates from string argument' do
     search do
       paginate :page => '3', :per_page => '15'
     end
-    connection.should have_last_search_with(:rows => 15, :start => 30)
+    expect(connection).to have_last_search_with(:rows => 15, :start => 30)
+  end
+
+  it 'paginates with initial cursor' do
+    search do
+      paginate :cursor => '*', :per_page => 15
+    end
+    expect(connection).to have_last_search_with(:rows => 15, :cursorMark => '*')
+  end
+
+  it 'paginates with given cursor' do
+    search do
+      paginate :cursor => 'AoIIP4AAACxQcm9maWxlIDEwMTk='
+    end
+    expect(connection).to have_last_search_with(:cursorMark => 'AoIIP4AAACxQcm9maWxlIDEwMTk=')
   end
 
   it 'orders by a single field' do
     search do
       order_by :average_rating, :desc
     end
-    connection.should have_last_search_with(:sort => 'average_rating_ft desc')
+    expect(connection).to have_last_search_with(:sort => 'average_rating_ft desc')
   end
 
   it 'orders by multiple fields' do
@@ -58,80 +72,80 @@ shared_examples_for 'sortable query' do
       order_by :average_rating, :desc
       order_by :sort_title, :asc
     end
-    connection.should have_last_search_with(:sort => 'average_rating_ft desc, sort_title_s asc')
+    expect(connection).to have_last_search_with(:sort => 'average_rating_ft desc, sort_title_s asc')
   end
 
   it 'orders by random' do
     search do
       order_by :random
     end
-    connection.searches.last[:sort].should =~ /^random_\d+ asc$/
+    expect(connection.searches.last[:sort]).to match(/^random_\d+ asc$/)
   end
 
   it 'orders by random with declared direction' do
     search do
       order_by :random, :desc
     end
-    connection.searches.last[:sort].should =~ /^random_\d+ desc$/
+    expect(connection.searches.last[:sort]).to match(/^random_\d+ desc$/)
   end
 
   it 'orders by random with provided seed value' do
     search do
       order_by :random, :seed => 9001
     end
-    connection.searches.last[:sort].should =~ /^random_9001 asc$/
+    expect(connection.searches.last[:sort]).to match(/^random_9001 asc$/)
   end
 
   it 'orders by random with provided seed value and direction' do
     search do
       order_by :random, :seed => 12345, :direction => :desc
     end
-    connection.searches.last[:sort].should =~ /^random_12345 desc$/
+    expect(connection.searches.last[:sort]).to match(/^random_12345 desc$/)
   end
 
   it 'orders by score' do
     search do
       order_by :score, :desc
     end
-    connection.should have_last_search_with(:sort => 'score desc')
+    expect(connection).to have_last_search_with(:sort => 'score desc')
   end
 
   it 'orders by geodist' do
     search do
       order_by_geodist :coordinates_new, 32, -68, :desc
     end
-    connection.should have_last_search_with(:sort => 'geodist(coordinates_new_ll,32,-68) desc')
+    expect(connection).to have_last_search_with(:sort => 'geodist(coordinates_new_ll,32,-68) desc')
   end
 
   it 'throws an ArgumentError if a bogus order direction is given' do
-    lambda do
+    expect do
       search do
         order_by :sort_title, :sideways
       end
-    end.should raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it 'throws an UnrecognizedFieldError if :distance is given for sort' do
-    lambda do
+    expect do
       search do
         order_by :distance, :asc
       end
-    end.should raise_error(Sunspot::UnrecognizedFieldError)
+    end.to raise_error(Sunspot::UnrecognizedFieldError)
   end
 
   it 'does not allow ordering by multiple-value fields' do
-    lambda do
+    expect do
       search do
         order_by :category_ids
       end
-    end.should raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 
   it 'raises ArgumentError if bogus argument given to paginate' do
-    lambda do
+    expect do
       search do
         paginate :page => 4, :ugly => :puppy
       end
-    end.should raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 end

data/spec/api/query/scope_examples.rb

@@ -3,14 +3,14 @@ shared_examples_for "scoped query" do
     search do
       with :title, 'My Pet Post'
     end
-    connection.should have_last_search_including(:fq, 'title_ss:My\ Pet\ Post')
+    expect(connection).to have_last_search_including(:fq, 'title_ss:My\ Pet\ Post')
   end
 
   it 'scopes by exact match with a special string' do
     search do
       with :title, 'OR'
     end
-    connection.should have_last_search_including(:fq, 'title_ss:"OR"')
+    expect(connection).to have_last_search_including(:fq, 'title_ss:"OR"')
   end
 
   it 'scopes by exact match with time' do
@@ -18,7 +18,7 @@ shared_examples_for "scoped query" do
     search do
       with :published_at, time
     end
-    connection.should have_last_search_including(
+    expect(connection).to have_last_search_including(
       :fq,
       'published_at_dt:1983\-07\-08T09\:00\:00Z'
     )
@@ -29,7 +29,7 @@ shared_examples_for "scoped query" do
     search do
       with :expire_date, date
     end
-    connection.should have_last_search_including(
+    expect(connection).to have_last_search_including(
       :fq,
       'expire_date_d:1983\-07\-08T00\:00\:00Z'
     )
@@ -39,133 +39,133 @@ shared_examples_for "scoped query" do
     search do
       with :featured, false
     end
-    connection.should have_last_search_including(:fq, 'featured_bs:false')
+    expect(connection).to have_last_search_including(:fq, 'featured_bs:false')
   end
 
   it 'scopes by less than match with float' do
     search do
       with(:average_rating).less_than 3.0
     end
-    connection.should have_last_search_including(:fq, 'average_rating_ft:{* TO 3\.0}')
+    expect(connection).to have_last_search_including(:fq, 'average_rating_ft:{* TO 3\.0}')
   end
 
   it 'should quote string with space in a less than match' do
     search do
       with(:title).less_than('test value')
     end
-    connection.should have_last_search_including(:fq, 'title_ss:{* TO "test\ value"}')
+    expect(connection).to have_last_search_including(:fq, 'title_ss:{* TO "test\ value"}')
   end
 
   it 'scopes by greater than match with float' do
     search do
       with(:average_rating).greater_than 3.0
     end
-    connection.should have_last_search_including(:fq, 'average_rating_ft:{3\.0 TO *}')
+    expect(connection).to have_last_search_including(:fq, 'average_rating_ft:{3\.0 TO *}')
   end
 
   it 'scopes by short-form between match with integers' do
     search do
       with :blog_id, 2..4
     end
-    connection.should have_last_search_including(:fq, 'blog_id_i:[2 TO 4]')
+    expect(connection).to have_last_search_including(:fq, 'blog_id_i:[2 TO 4]')
   end
 
   it 'scopes by between match with float' do
     search do
       with(:average_rating).between 2.0..4.0
     end
-    connection.should have_last_search_including(:fq, 'average_rating_ft:[2\.0 TO 4\.0]')
+    expect(connection).to have_last_search_including(:fq, 'average_rating_ft:[2\.0 TO 4\.0]')
   end
 
   it 'scopes by any match with integer' do
     search do
       with(:category_ids).any_of [2, 7, 12]
     end
-    connection.should have_last_search_including(:fq, 'category_ids_im:(2 OR 7 OR 12)')
+    expect(connection).to have_last_search_including(:fq, 'category_ids_im:(2 OR 7 OR 12)')
   end
 
   it 'scopes by short-form any-of match with integers' do
     search do
       with :category_ids, [2, 7, 12]
     end
-    connection.should have_last_search_including(:fq, 'category_ids_im:(2 OR 7 OR 12)')
+    expect(connection).to have_last_search_including(:fq, 'category_ids_im:(2 OR 7 OR 12)')
   end
 
   it 'scopes by all match with integer' do
     search do
       with(:category_ids).all_of [2, 7, 12]
     end
-    connection.should have_last_search_including(:fq, 'category_ids_im:(2 AND 7 AND 12)')
+    expect(connection).to have_last_search_including(:fq, 'category_ids_im:(2 AND 7 AND 12)')
   end
 
   it 'scopes by prefix match with string' do
     search do
       with(:title).starting_with('tes')
     end
-    connection.should have_last_search_including(:fq, 'title_ss:tes*')
+    expect(connection).to have_last_search_including(:fq, 'title_ss:tes*')
   end
 
   it 'scopes by not equal match with string' do
     search do
       without :title, 'Bad Post'
     end
-    connection.should have_last_search_including(:fq, '-title_ss:Bad\ Post')
+    expect(connection).to have_last_search_including(:fq, '-title_ss:Bad\ Post')
   end
 
   it 'scopes by not less than match with float' do
     search do
       without(:average_rating).less_than 3.0
     end
-    connection.should have_last_search_including(:fq, '-average_rating_ft:{* TO 3\.0}')
+    expect(connection).to have_last_search_including(:fq, '-average_rating_ft:{* TO 3\.0}')
   end
 
   it 'scopes by not greater than match with float' do
     search do
       without(:average_rating).greater_than 3.0
     end
-    connection.should have_last_search_including(:fq, '-average_rating_ft:{3\.0 TO *}')
+    expect(connection).to have_last_search_including(:fq, '-average_rating_ft:{3\.0 TO *}')
   end
   
   it 'scopes by not between match with shorthand' do
     search do
       without(:blog_id, 2..4)
     end
-    connection.should have_last_search_including(:fq, '-blog_id_i:[2 TO 4]')
+    expect(connection).to have_last_search_including(:fq, '-blog_id_i:[2 TO 4]')
   end
 
   it 'scopes by not between match with float' do
     search do
       without(:average_rating).between 2.0..4.0
     end
-    connection.should have_last_search_including(:fq, '-average_rating_ft:[2\.0 TO 4\.0]')
+    expect(connection).to have_last_search_including(:fq, '-average_rating_ft:[2\.0 TO 4\.0]')
   end
 
   it 'scopes by not any match with integer' do
     search do
       without(:category_ids).any_of [2, 7, 12]
     end
-    connection.should have_last_search_including(:fq, '-category_ids_im:(2 OR 7 OR 12)')
+    expect(connection).to have_last_search_including(:fq, '-category_ids_im:(2 OR 7 OR 12)')
   end
 
   it 'scopes by not all match with integer' do
     search do
       without(:category_ids).all_of [2, 7, 12]
     end
-    connection.should have_last_search_including(:fq, '-category_ids_im:(2 AND 7 AND 12)')
+    expect(connection).to have_last_search_including(:fq, '-category_ids_im:(2 AND 7 AND 12)')
   end
 
   it 'scopes by empty field' do
     search do
       with :average_rating, nil
     end
-    connection.should have_last_search_including(:fq, '-average_rating_ft:[* TO *]')
+    expect(connection).to have_last_search_including(:fq, '-average_rating_ft:[* TO *]')
   end
 
   it 'scopes by non-empty field' do
     search do
       without :average_rating, nil
     end
-    connection.should have_last_search_including(:fq, 'average_rating_ft:[* TO *]')
+    expect(connection).to have_last_search_including(:fq, 'average_rating_ft:[* TO *]')
   end
 
   it 'includes by object identity' do
@@ -173,7 +173,7 @@ shared_examples_for "scoped query" do
     search do
       with post
     end
-    connection.should have_last_search_including(:fq, "id:(Post\\ #{post.id})")
+    expect(connection).to have_last_search_including(:fq, "id:(Post\\ #{post.id})")
   end
 
   it 'includes multiple objects passed as varargs by object identity' do
@@ -181,7 +181,7 @@ shared_examples_for "scoped query" do
     search do
       with post1, post2
     end
-    connection.should have_last_search_including(
+    expect(connection).to have_last_search_including(
       :fq, "id:(Post\\ #{post1.id} OR Post\\ #{post2.id})"
     )
   end
@@ -191,7 +191,7 @@ shared_examples_for "scoped query" do
     search do
       with posts
     end
-    connection.should have_last_search_including(
+    expect(connection).to have_last_search_including(
       :fq, "id:(Post\\ #{posts.first.id} OR Post\\ #{posts.last.id})"
     )
   end
@@ -201,7 +201,7 @@ shared_examples_for "scoped query" do
     search do
       without post
     end
-    connection.should have_last_search_including(:fq, "-id:(Post\\ #{post.id})")
+    expect(connection).to have_last_search_including(:fq, "-id:(Post\\ #{post.id})")
   end
 
   it 'excludes multiple objects passed as varargs by object identity' do
@@ -209,7 +209,7 @@ shared_examples_for "scoped query" do
     search do
       without post1, post2
     end
-    connection.should have_last_search_including(
+    expect(connection).to have_last_search_including(
       :fq,
       "-id:(Post\\ #{post1.id} OR Post\\ #{post2.id})"
     )
@@ -220,7 +220,7 @@ shared_examples_for "scoped query" do
     search do
       without posts
     end
-    connection.should have_last_search_including(
+    expect(connection).to have_last_search_including(
       :fq,
       "-id:(Post\\ #{posts.first.id} OR Post\\ #{posts.last.id})"
     )
@@ -231,45 +231,45 @@ shared_examples_for "scoped query" do
     search Post, Namespaced::Comment do
       with :published_at, time
     end
-    connection.should have_last_search_including(:fq, 'published_at_dt:1983\-07\-08T09\:00\:00Z')
+    expect(connection).to have_last_search_including(:fq, 'published_at_dt:1983\-07\-08T09\:00\:00Z')
   end
 
   it 'allows scoping on field not common to all types' do
     search Post, Namespaced::Comment do
       with :blog_id, 1
     end
-    connection.should have_last_search_including(:fq, 'blog_id_i:1')
+    expect(connection).to have_last_search_including(:fq, 'blog_id_i:1')
   end
 
   it 'raises Sunspot::UnrecognizedFieldError if search scoped to field configured differently between types' do
-    lambda do
+    expect do
       search Post, Namespaced::Comment do
         with :average_rating, 2.2 # this is a float in Post but an integer in Comment
       end
-    end.should raise_error(Sunspot::UnrecognizedFieldError)
+    end.to raise_error(Sunspot::UnrecognizedFieldError)
   end
 
   it 'raises Sunspot::UnrecognizedFieldError for nonexistant fields in block scope' do
-    lambda do
+    expect do
       search do
         with :bogus, 'Field'
       end
-    end.should raise_error(Sunspot::UnrecognizedFieldError)
+    end.to raise_error(Sunspot::UnrecognizedFieldError)
   end
 
   it 'raises NoMethodError if bogus operator referenced' do
-    lambda do
+    expect do
       search do
         with(:category_ids).resembling :bogus_condition
       end
-    end.should raise_error(NoMethodError)
+    end.to raise_error(NoMethodError)
   end
 
   it 'should raise ArgumentError if more than two arguments passed to scope method' do
-    lambda do
+    expect do
       search do
         with(:category_ids, 4, 5)
       end
-    end.should raise_error(ArgumentError)
+    end.to raise_error(ArgumentError)
   end
 end