sunspot 2.2.7 → 2.2.8

data/spec/api/query/ordering_pagination_examples.rb

@@ -1,70 +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
-    connection.should have_last_search_with(:rows => 15, :cursorMark => '*')
+    expect(connection).to have_last_search_with(:rows => 15, :cursorMark => '*')
   end
 
   it 'paginates with given cursor' do
     search do
       paginate :cursor => 'AoIIP4AAACxQcm9maWxlIDEwMTk='
     end
-    connection.should have_last_search_with(:cursorMark => 'AoIIP4AAACxQcm9maWxlIDEwMTk=')
+    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
@@ -72,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