thinking-sphinx 3.2.0 → 3.3.0

data/spec/thinking_sphinx/middlewares/active_record_translator_spec.rb

@@ -22,21 +22,21 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
 
   describe '#call' do
     before :each do
-      context.stub :search => search
-      context.stub :configuration => configuration
-      model.stub :unscoped => model
+      allow(context).to receive_messages :search => search
+      allow(context).to receive_messages :configuration => configuration
+      allow(model).to receive_messages :unscoped => model
     end
 
     it "translates records to ActiveRecord objects" do
       model_name = double('article', :constantize => model)
       instance   = double('instance', :id => 24)
-      model.stub :where => [instance]
+      allow(model).to receive_messages :where => [instance]
 
       context[:results] << raw_result(24, model_name)
 
       middleware.call [context]
 
-      context[:results].should == [instance]
+      expect(context[:results]).to eq([instance])
     end
 
     it "only queries the model once for the given search results" do
@@ -46,7 +46,7 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       context[:results] << raw_result(24, model_name)
       context[:results] << raw_result(42, model_name)
 
-      model.should_receive(:where).once.and_return([instance_a, instance_b])
+      expect(model).to receive(:where).once.and_return([instance_a, instance_b])
 
       middleware.call [context]
     end
@@ -60,14 +60,14 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       user_name     = double('user name', :constantize => user_model)
       user          = double('user instance', :id => 12)
 
-      article_model.stub :unscoped => article_model
-      user_model.stub :unscoped => user_model
+      allow(article_model).to receive_messages :unscoped => article_model
+      allow(user_model).to receive_messages :unscoped => user_model
 
       context[:results] << raw_result(24, article_name)
       context[:results] << raw_result(12, user_name)
 
-      article_model.should_receive(:where).once.and_return([article])
-      user_model.should_receive(:where).once.and_return([user])
+      expect(article_model).to receive(:where).once.and_return([article])
+      expect(user_model).to receive(:where).once.and_return([user])
 
       middleware.call [context]
     end
@@ -80,11 +80,11 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       context[:results] << raw_result(2, model_name)
       context[:results] << raw_result(1, model_name)
 
-      model.stub(:where => [instance_1, instance_2])
+      allow(model).to receive_messages(:where => [instance_1, instance_2])
 
       middleware.call [context]
 
-      context[:results].should == [instance_2, instance_1]
+      expect(context[:results]).to eq([instance_2, instance_1])
     end
 
     it "returns objects in database order if a SQL order clause is supplied" do
@@ -95,20 +95,20 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       context[:results] << raw_result(2, model_name)
       context[:results] << raw_result(1, model_name)
 
-      model.stub(:order => model, :where => [instance_1, instance_2])
+      allow(model).to receive_messages(:order => model, :where => [instance_1, instance_2])
       search.options[:sql] = {:order => 'name DESC'}
 
       middleware.call [context]
 
-      context[:results].should == [instance_1, instance_2]
+      expect(context[:results]).to eq([instance_1, instance_2])
     end
 
     it "handles model without primary key" do
       no_primary_key_model = double('no primary key model')
-      no_primary_key_model.stub :unscoped => no_primary_key_model
+      allow(no_primary_key_model).to receive_messages :unscoped => no_primary_key_model
       model_name = double('article', :constantize => no_primary_key_model)
       instance   = double('instance', :id => 1)
-      no_primary_key_model.stub :where => [instance]
+      allow(no_primary_key_model).to receive_messages :where => [instance]
 
       context[:results] << raw_result(1, model_name)
 
@@ -119,7 +119,7 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       let(:relation) { double('relation', :where => []) }
 
       before :each do
-        model.stub :unscoped => relation
+        allow(model).to receive_messages :unscoped => relation
 
         model_name = double('article', :constantize => model)
         context[:results] << raw_result(1, model_name)
@@ -128,7 +128,7 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       it "passes through SQL include options to the relation" do
         search.options[:sql] = {:include => :association}
 
-        relation.should_receive(:includes).with(:association).
+        expect(relation).to receive(:includes).with(:association).
           and_return(relation)
 
         middleware.call [context]
@@ -137,7 +137,7 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       it "passes through SQL join options to the relation" do
         search.options[:sql] = {:joins => :association}
 
-        relation.should_receive(:joins).with(:association).and_return(relation)
+        expect(relation).to receive(:joins).with(:association).and_return(relation)
 
         middleware.call [context]
       end
@@ -145,7 +145,7 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       it "passes through SQL order options to the relation" do
         search.options[:sql] = {:order => 'name DESC'}
 
-        relation.should_receive(:order).with('name DESC').and_return(relation)
+        expect(relation).to receive(:order).with('name DESC').and_return(relation)
 
         middleware.call [context]
       end
@@ -153,7 +153,7 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       it "passes through SQL select options to the relation" do
         search.options[:sql] = {:select => :column}
 
-        relation.should_receive(:select).with(:column).and_return(relation)
+        expect(relation).to receive(:select).with(:column).and_return(relation)
 
         middleware.call [context]
       end
@@ -161,7 +161,7 @@ describe ThinkingSphinx::Middlewares::ActiveRecordTranslator do
       it "passes through SQL group options to the relation" do
         search.options[:sql] = {:group => :column}
 
-        relation.should_receive(:group).with(:column).and_return(relation)
+        expect(relation).to receive(:group).with(:column).and_return(relation)
 
         middleware.call [context]
       end

data/spec/thinking_sphinx/middlewares/geographer_spec.rb

@@ -16,7 +16,7 @@ describe ThinkingSphinx::Middlewares::Geographer do
   before :each do
     stub_const 'ThinkingSphinx::Panes::DistancePane', double
 
-    context.stub :search => search
+    allow(context).to receive_messages :search => search
   end
 
   describe '#call' do
@@ -26,7 +26,7 @@ describe ThinkingSphinx::Middlewares::Geographer do
       end
 
       it "doesn't add anything if :geo is nil" do
-        sphinx_sql.should_not_receive(:prepend_values)
+        expect(sphinx_sql).not_to receive(:prepend_values)
 
         middleware.call [context]
       end
@@ -38,7 +38,7 @@ describe ThinkingSphinx::Middlewares::Geographer do
       end
 
       it "adds the geodist function when given a :geo option" do
-        sphinx_sql.should_receive(:prepend_values).
+        expect(sphinx_sql).to receive(:prepend_values).
           with('GEODIST(0.1, 0.2, lat, lng) AS geodist').
           and_return(sphinx_sql)
 
@@ -46,18 +46,18 @@ describe ThinkingSphinx::Middlewares::Geographer do
       end
 
       it "adds the distance pane" do
-        sphinx_sql.stub :prepend_values => sphinx_sql
+        allow(sphinx_sql).to receive_messages :prepend_values => sphinx_sql
 
         middleware.call [context]
 
-        context[:panes].should include(ThinkingSphinx::Panes::DistancePane)
+        expect(context[:panes]).to include(ThinkingSphinx::Panes::DistancePane)
       end
 
       it "respects :latitude_attr and :longitude_attr options" do
         search.options[:latitude_attr]  = 'side_to_side'
         search.options[:longitude_attr] = 'up_or_down'
 
-        sphinx_sql.should_receive(:prepend_values).
+        expect(sphinx_sql).to receive(:prepend_values).
           with('GEODIST(0.1, 0.2, side_to_side, up_or_down) AS geodist').
           and_return(sphinx_sql)
 
@@ -68,7 +68,7 @@ describe ThinkingSphinx::Middlewares::Geographer do
         context[:indices] << double('index',
           :unique_attribute_names => ['latitude'], :name => 'an_index')
 
-        sphinx_sql.should_receive(:prepend_values).
+        expect(sphinx_sql).to receive(:prepend_values).
           with('GEODIST(0.1, 0.2, latitude, lng) AS geodist').
           and_return(sphinx_sql)
 
@@ -79,7 +79,7 @@ describe ThinkingSphinx::Middlewares::Geographer do
         context[:indices] << double('index',
           :unique_attribute_names => ['longitude'], :name => 'an_index')
 
-        sphinx_sql.should_receive(:prepend_values).
+        expect(sphinx_sql).to receive(:prepend_values).
           with('GEODIST(0.1, 0.2, lat, longitude) AS geodist').
           and_return(sphinx_sql)
 
@@ -89,7 +89,7 @@ describe ThinkingSphinx::Middlewares::Geographer do
       it "handles very small values" do
         search.options[:geo] = [0.0000001, 0.00000000002]
 
-        sphinx_sql.should_receive(:prepend_values).
+        expect(sphinx_sql).to receive(:prepend_values).
           with('GEODIST(0.0000001, 0.00000000002, lat, lng) AS geodist').
           and_return(sphinx_sql)
 

data/spec/thinking_sphinx/middlewares/glazier_spec.rb

@@ -22,7 +22,7 @@ describe ThinkingSphinx::Middlewares::Glazier do
     before :each do
       stub_const 'ThinkingSphinx::Search::Glaze', double(:new => glazed_result)
 
-      context.stub :search => search
+      allow(context).to receive_messages :search => search
     end
 
     context 'No panes provided' do
@@ -33,7 +33,7 @@ describe ThinkingSphinx::Middlewares::Glazier do
       it "leaves the results as they are" do
         middleware.call [context]
 
-        context[:results].should == [result]
+        expect(context[:results]).to eq([result])
       end
     end
 
@@ -47,11 +47,11 @@ describe ThinkingSphinx::Middlewares::Glazier do
       it "replaces each result with a glazed version" do
         middleware.call [context]
 
-        context[:results].should == [glazed_result]
+        expect(context[:results]).to eq([glazed_result])
       end
 
       it "creates a glazed result for each result" do
-        ThinkingSphinx::Search::Glaze.should_receive(:new).
+        expect(ThinkingSphinx::Search::Glaze).to receive(:new).
           with(context, result, raw_result, [pane_class]).
           and_return(glazed_result)
 

data/spec/thinking_sphinx/middlewares/inquirer_spec.rb

@@ -16,7 +16,7 @@ describe ThinkingSphinx::Middlewares::Inquirer do
 
   before :each do
     batch_class = double
-    batch_class.stub(:new).and_return(batch_inquirer)
+    allow(batch_class).to receive(:new).and_return(batch_inquirer)
 
     stub_const 'Riddle::Query', double(:meta => 'SHOW META')
     stub_const 'ThinkingSphinx::Search::BatchInquirer', batch_class
@@ -24,8 +24,8 @@ describe ThinkingSphinx::Middlewares::Inquirer do
 
   describe '#call' do
     it "passes through the SphinxQL from a Riddle::Query::Select object" do
-      batch_inquirer.should_receive(:append_query).with('SELECT * FROM index')
-      batch_inquirer.should_receive(:append_query).with('SHOW META')
+      expect(batch_inquirer).to receive(:append_query).with('SELECT * FROM index')
+      expect(batch_inquirer).to receive(:append_query).with('SHOW META')
 
       middleware.call [context]
     end
@@ -33,19 +33,19 @@ describe ThinkingSphinx::Middlewares::Inquirer do
     it "sets up the raw results" do
       middleware.call [context]
 
-      context[:raw].should == [:raw]
+      expect(context[:raw]).to eq([:raw])
     end
 
     it "sets up the meta results as a hash" do
       middleware.call [context]
 
-      context[:meta].should == {'meta' => 'value'}
+      expect(context[:meta]).to eq({'meta' => 'value'})
     end
 
     it "uses the raw values as the initial results" do
       middleware.call [context]
 
-      context[:results].should == [:raw]
+      expect(context[:results]).to eq([:raw])
     end
 
     context "with mysql2 result" do
@@ -63,7 +63,7 @@ describe ThinkingSphinx::Middlewares::Inquirer do
       it "converts the results into an array" do
         middleware.call [context]
 
-        context[:results].should be_a Array
+        expect(context[:results]).to be_a Array
       end
     end
   end

data/spec/thinking_sphinx/middlewares/sphinxql_spec.rb

@@ -36,7 +36,7 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     stub_const 'Riddle::Query::Select', double(:new => sphinx_sql)
     stub_const 'ThinkingSphinx::Search::Query', double(:new => query)
 
-    context.stub :search => search, :configuration => configuration
+    allow(context).to receive_messages :search => search, :configuration => configuration
   end
 
   describe '#call' do
@@ -46,7 +46,7 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
         double('index', :name => 'user_core', :options => {})
       ]
 
-      sphinx_sql.should_receive(:from).with('`article_core`', '`user_core`').
+      expect(sphinx_sql).to receive(:from).with('`article_core`', '`user_core`').
         and_return(sphinx_sql)
 
       middleware.call [context]
@@ -57,9 +57,9 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
         :name => 'User')
       search.options[:classes] = [klass]
       search.options[:indices] = ['user_core']
-      index_set.first.stub :reference => :user
+      allow(index_set.first).to receive_messages :reference => :user
 
-      set_class.should_receive(:new).
+      expect(set_class).to receive(:new).
         with(:classes => [klass], :indices => ['user_core']).
         and_return(index_set)
 
@@ -75,19 +75,19 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     end
 
     it "generates a Sphinx query from the provided keyword and conditions" do
-      search.stub :query => 'tasty'
+      allow(search).to receive_messages :query => 'tasty'
       search.options[:conditions] = {:title => 'pancakes'}
 
-      ThinkingSphinx::Search::Query.should_receive(:new).
+      expect(ThinkingSphinx::Search::Query).to receive(:new).
         with('tasty', {:title => 'pancakes'}, anything).and_return(query)
 
       middleware.call [context]
     end
 
     it "matches on the generated query" do
-      query.stub :to_s => 'waffles'
+      allow(query).to receive_messages :to_s => 'waffles'
 
-      sphinx_sql.should_receive(:matching).with('waffles')
+      expect(sphinx_sql).to receive(:matching).with('waffles')
 
       middleware.call [context]
     end
@@ -95,15 +95,15 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "requests a starred query if the :star option is set to true" do
       search.options[:star] = true
 
-      ThinkingSphinx::Search::Query.should_receive(:new).
+      expect(ThinkingSphinx::Search::Query).to receive(:new).
         with(anything, anything, true).and_return(query)
 
       middleware.call [context]
     end
 
     it "doesn't append a field condition by default" do
-      ThinkingSphinx::Search::Query.should_receive(:new) do |query, conditions, star|
-        conditions[:sphinx_internal_class_name].should be_nil
+      expect(ThinkingSphinx::Search::Query).to receive(:new) do |query, conditions, star|
+        expect(conditions[:sphinx_internal_class_name]).to be_nil
         query
       end
 
@@ -113,12 +113,12 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "doesn't append a field condition if all classes match index references" do
       model = double('model', :connection => double,
         :ancestors => [ActiveRecord::Base], :name => 'Animal')
-      index_set.first.stub :reference => :animal
+      allow(index_set.first).to receive_messages :reference => :animal
 
       search.options[:classes] = [model]
 
-      ThinkingSphinx::Search::Query.should_receive(:new) do |query, conditions, star|
-        conditions[:sphinx_internal_class_name].should be_nil
+      expect(ThinkingSphinx::Search::Query).to receive(:new) do |query, conditions, star|
+        expect(conditions[:sphinx_internal_class_name]).to be_nil
         query
       end
 
@@ -132,19 +132,19 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
         def self.name; 'Cat'; end
         def self.inheritance_column; 'type'; end
       end
-      supermodel.stub :connection => db_connection, :column_names => ['type']
+      allow(supermodel).to receive_messages :connection => db_connection, :column_names => ['type']
       submodel   = Class.new(supermodel) do
         def self.name; 'Lion'; end
         def self.inheritance_column; 'type'; end
         def self.table_name; 'cats'; end
       end
-      submodel.stub :connection => db_connection, :column_names => ['type'],
+      allow(submodel).to receive_messages :connection => db_connection, :column_names => ['type'],
         :descendants => []
-      index_set.first.stub :reference => :cat
+      allow(index_set.first).to receive_messages :reference => :cat
 
       search.options[:classes] = [submodel]
 
-      ThinkingSphinx::Search::Query.should_receive(:new).with(anything,
+      expect(ThinkingSphinx::Search::Query).to receive(:new).with(anything,
         hash_including(:sphinx_internal_class_name => '(Lion)'), anything).
         and_return(query)
 
@@ -158,19 +158,19 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
         def self.name; 'Animals::Cat'; end
         def self.inheritance_column; 'type'; end
       end
-      supermodel.stub :connection => db_connection, :column_names => ['type']
+      allow(supermodel).to receive_messages :connection => db_connection, :column_names => ['type']
       submodel   = Class.new(supermodel) do
         def self.name; 'Animals::Lion'; end
         def self.inheritance_column; 'type'; end
         def self.table_name; 'cats'; end
       end
-      submodel.stub :connection => db_connection, :column_names => ['type'],
+      allow(submodel).to receive_messages :connection => db_connection, :column_names => ['type'],
         :descendants => []
-      index_set.first.stub :reference => :"animals/cat"
+      allow(index_set.first).to receive_messages :reference => :"animals/cat"
 
       search.options[:classes] = [submodel]
 
-      ThinkingSphinx::Search::Query.should_receive(:new).with(anything,
+      expect(ThinkingSphinx::Search::Query).to receive(:new).with(anything,
         hash_including(:sphinx_internal_class_name => '("Animals::Lion")'), anything).
         and_return(query)
 
@@ -180,12 +180,12 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "does not query the database for subclasses if :skip_sti is set to true" do
       model = double('model', :connection => double,
         :ancestors => [ActiveRecord::Base], :name => 'Animal')
-      index_set.first.stub :reference => :animal
+      allow(index_set.first).to receive_messages :reference => :animal
 
       search.options[:classes]  = [model]
       search.options[:skip_sti] = true
 
-      model.connection.should_not_receive(:select_values)
+      expect(model.connection).not_to receive(:select_values)
 
       middleware.call [context]
     end
@@ -197,15 +197,15 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
         def self.name; 'Cat'; end
         def self.inheritance_column; 'type'; end
       end
-      supermodel.stub :connection => db_connection, :column_names => ['type']
+      allow(supermodel).to receive_messages :connection => db_connection, :column_names => ['type']
       submodel   = Class.new(supermodel) do
         def self.name; 'Lion'; end
         def self.inheritance_column; 'type'; end
         def self.table_name; 'cats'; end
       end
-      submodel.stub :connection => db_connection, :column_names => ['type'],
+      allow(submodel).to receive_messages :connection => db_connection, :column_names => ['type'],
         :descendants => []
-      index_set.first.stub :reference => :cat
+      allow(index_set.first).to receive_messages :reference => :cat
 
       search.options[:classes] = [submodel]
 
@@ -213,7 +213,7 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     end
 
     it "filters out deleted values by default" do
-      sphinx_sql.should_receive(:where).with(:sphinx_deleted => false).
+      expect(sphinx_sql).to receive(:where).with(:sphinx_deleted => false).
         and_return(sphinx_sql)
 
       middleware.call [context]
@@ -222,7 +222,7 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "appends boolean attribute filters to the query" do
       search.options[:with] = {:visible => true}
 
-      sphinx_sql.should_receive(:where).with(hash_including(:visible => true)).
+      expect(sphinx_sql).to receive(:where).with(hash_including(:visible => true)).
         and_return(sphinx_sql)
 
       middleware.call [context]
@@ -231,7 +231,7 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "appends exclusive filters to the query" do
       search.options[:without] = {:tag_ids => [2, 4, 8]}
 
-      sphinx_sql.should_receive(:where_not).
+      expect(sphinx_sql).to receive(:where_not).
         with(hash_including(:tag_ids => [2, 4, 8])).and_return(sphinx_sql)
 
       middleware.call [context]
@@ -240,7 +240,7 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "appends the without_ids option as an exclusive filter" do
       search.options[:without_ids] = [1, 4, 9]
 
-      sphinx_sql.should_receive(:where_not).
+      expect(sphinx_sql).to receive(:where_not).
         with(hash_including(:sphinx_internal_id => [1, 4, 9])).
         and_return(sphinx_sql)
 
@@ -250,7 +250,7 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "appends MVA matches with all values" do
       search.options[:with_all] = {:tag_ids => [1, 7]}
 
-      sphinx_sql.should_receive(:where_all).
+      expect(sphinx_sql).to receive(:where_all).
         with(:tag_ids => [1, 7]).and_return(sphinx_sql)
 
       middleware.call [context]
@@ -259,7 +259,7 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "appends MVA matches without all of the given values" do
       search.options[:without_all] = {:tag_ids => [1, 7]}
 
-      sphinx_sql.should_receive(:where_not_all).
+      expect(sphinx_sql).to receive(:where_not_all).
         with(:tag_ids => [1, 7]).and_return(sphinx_sql)
 
       middleware.call [context]
@@ -268,7 +268,7 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "appends order clauses to the query" do
       search.options[:order] = 'created_at ASC'
 
-      sphinx_sql.should_receive(:order_by).with('created_at ASC').
+      expect(sphinx_sql).to receive(:order_by).with('created_at ASC').
         and_return(sphinx_sql)
 
       middleware.call [context]
@@ -277,7 +277,7 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "presumes attributes given as symbols should be sorted ascendingly" do
       search.options[:order] = :updated_at
 
-      sphinx_sql.should_receive(:order_by).with('updated_at ASC').
+      expect(sphinx_sql).to receive(:order_by).with('updated_at ASC').
         and_return(sphinx_sql)
 
       middleware.call [context]
@@ -285,10 +285,10 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
 
     it "appends a group by clause to the query" do
       search.options[:group_by] = :foreign_id
-      search.stub :masks => []
-      sphinx_sql.stub :values => sphinx_sql
+      allow(search).to receive_messages :masks => []
+      allow(sphinx_sql).to receive_messages :values => sphinx_sql
 
-      sphinx_sql.should_receive(:group_by).with('foreign_id').
+      expect(sphinx_sql).to receive(:group_by).with('foreign_id').
         and_return(sphinx_sql)
 
       middleware.call [context]
@@ -297,24 +297,24 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "appends a sort within group clause to the query" do
       search.options[:order_group_by] = :title
 
-      sphinx_sql.should_receive(:order_within_group_by).with('title ASC').
+      expect(sphinx_sql).to receive(:order_within_group_by).with('title ASC').
         and_return(sphinx_sql)
 
       middleware.call [context]
     end
 
     it "uses the provided offset" do
-      search.stub :offset => 50
+      allow(search).to receive_messages :offset => 50
 
-      sphinx_sql.should_receive(:offset).with(50).and_return(sphinx_sql)
+      expect(sphinx_sql).to receive(:offset).with(50).and_return(sphinx_sql)
 
       middleware.call [context]
     end
 
     it "uses the provided limit" do
-      search.stub :per_page => 24
+      allow(search).to receive_messages :per_page => 24
 
-      sphinx_sql.should_receive(:limit).with(24).and_return(sphinx_sql)
+      expect(sphinx_sql).to receive(:limit).with(24).and_return(sphinx_sql)
 
       middleware.call [context]
     end
@@ -322,7 +322,7 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "adds the provided select statement" do
       search.options[:select] = 'foo as bar'
 
-      sphinx_sql.should_receive(:values).with('foo as bar').
+      expect(sphinx_sql).to receive(:values).with('foo as bar').
         and_return(sphinx_sql)
 
       middleware.call [context]
@@ -331,7 +331,7 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "adds the provided group-best count" do
       search.options[:group_best] = 5
 
-      sphinx_sql.should_receive(:group_best).with(5).and_return(sphinx_sql)
+      expect(sphinx_sql).to receive(:group_best).with(5).and_return(sphinx_sql)
 
       middleware.call [context]
     end
@@ -339,7 +339,7 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "adds the provided having clause" do
       search.options[:having] = 'foo > 1'
 
-      sphinx_sql.should_receive(:having).with('foo > 1').and_return(sphinx_sql)
+      expect(sphinx_sql).to receive(:having).with('foo > 1').and_return(sphinx_sql)
 
       middleware.call [context]
     end
@@ -347,8 +347,8 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "uses any provided field weights" do
       search.options[:field_weights] = {:title => 3}
 
-      sphinx_sql.should_receive(:with_options) do |options|
-        options[:field_weights].should == {:title => 3}
+      expect(sphinx_sql).to receive(:with_options) do |options|
+        expect(options[:field_weights]).to eq({:title => 3})
         sphinx_sql
       end
 
@@ -358,7 +358,7 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "uses index-defined field weights if they're available" do
       index_set.first.options[:field_weights] = {:title => 3}
 
-      sphinx_sql.should_receive(:with_options).with(
+      expect(sphinx_sql).to receive(:with_options).with(
         hash_including(:field_weights => {:title => 3})
       ).and_return(sphinx_sql)
 
@@ -368,7 +368,7 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "uses index-defined max matches if it's available" do
       index_set.first.options[:max_matches] = 100
 
-      sphinx_sql.should_receive(:with_options).with(
+      expect(sphinx_sql).to receive(:with_options).with(
         hash_including(:max_matches => 100)
       ).and_return(sphinx_sql)
 
@@ -378,7 +378,7 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "uses configuration-level max matches if set" do
       configuration.settings['max_matches'] = 120
 
-      sphinx_sql.should_receive(:with_options).with(
+      expect(sphinx_sql).to receive(:with_options).with(
         hash_including(:max_matches => 120)
       ).and_return(sphinx_sql)
 
@@ -388,8 +388,8 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
     it "uses any given ranker option" do
       search.options[:ranker] = 'proximity'
 
-      sphinx_sql.should_receive(:with_options) do |options|
-        options[:ranker].should == 'proximity'
+      expect(sphinx_sql).to receive(:with_options) do |options|
+        expect(options[:ranker]).to eq('proximity')
         sphinx_sql
       end