thinking-sphinx 3.1.4 → 6.0.0

data/spec/thinking_sphinx/middlewares/glazier_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   module Middlewares; end
 end
@@ -10,11 +12,12 @@ describe ThinkingSphinx::Middlewares::Glazier do
   let(:middleware)    { ThinkingSphinx::Middlewares::Glazier.new app }
   let(:context)       { {:results => [result], :indices => [index],
     :meta => {}, :raw => [raw_result], :panes => []} }
-  let(:result)        { double('result', :id => 10,
-    :class => double(:name => 'Article')) }
-  let(:index)         { double('index', :name => 'foo_core') }
-  let(:search)        { double('search', :options => {}) }
-  let(:glazed_result) { double('glazed result') }
+  let(:result)        { double 'result', :id => 10, :class => model }
+  let(:model)         { double 'model', :name => 'Article' }
+  let(:index)         { double 'index', :name => 'foo_core', :model => model,
+    :primary_key => :id }
+  let(:search)        { double 'search', :options => {} }
+  let(:glazed_result) { double 'glazed result' }
   let(:raw_result) {
     {'sphinx_internal_class' => 'Article', 'sphinx_internal_id' => 10} }
 
@@ -22,7 +25,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 +36,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 +50,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   module Middlewares; end
 end
@@ -16,7 +18,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 +26,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 +35,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 +65,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   module Middlewares; end
 end
@@ -16,7 +18,6 @@ require 'active_support/core_ext/string/inflections'
 require 'thinking_sphinx/middlewares/middleware'
 require 'thinking_sphinx/middlewares/sphinxql'
 require 'thinking_sphinx/errors'
-require 'thinking_sphinx/sphinxql'
 
 describe ThinkingSphinx::Middlewares::SphinxQL do
   let(:app)           { double('app', :call => true) }
@@ -30,13 +31,13 @@ describe ThinkingSphinx::Middlewares::SphinxQL do
   let(:query)         { double('query') }
   let(:configuration) { double('configuration', :settings => {},
     index_set_class: set_class) }
-  let(:set_class)     { double(:new => index_set) }
+  let(:set_class)     { double(:new => index_set, :reference_name => :article) }
 
   before :each 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 +47,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,10 +58,10 @@ 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).
-        with(:classes => [klass], :indices => ['user_core']).
+      expect(set_class).to receive(:new).
+        with({ :classes => [klass], :indices => ['user_core'] }).
         and_return(index_set)
 
       middleware.call [context]
@@ -75,19 +76,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 +96,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 +114,13 @@ 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
+      allow(set_class).to receive_messages(:reference_name => :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 +134,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 +160,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 +182,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 +199,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 +215,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 +224,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 +233,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 +242,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,8 +252,8 @@ 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).
-        with(:tag_ids => [1, 7]).and_return(sphinx_sql)
+      expect(sphinx_sql).to receive(:where_all).
+        with({ :tag_ids => [1, 7] }).and_return(sphinx_sql)
 
       middleware.call [context]
     end
@@ -259,8 +261,8 @@ 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).
-        with(:tag_ids => [1, 7]).and_return(sphinx_sql)
+      expect(sphinx_sql).to receive(:where_not_all).
+        with({ :tag_ids => [1, 7] }).and_return(sphinx_sql)
 
       middleware.call [context]
     end
@@ -268,7 +270,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 +279,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 +287,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 +299,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 +324,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 +333,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 +341,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 +349,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 +360,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 +370,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 +380,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 +390,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
 

data/spec/thinking_sphinx/middlewares/stale_id_checker_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   module Middlewares; end
   class  Search; end
@@ -25,7 +27,7 @@ describe ThinkingSphinx::Middlewares::StaleIdChecker do
       context[:results] << double('instance', :id => 24)
       context[:results] << double('instance', :id => 42)
 
-      app.should_receive(:call)
+      expect(app).to receive(:call)
 
       middleware.call [context]
     end
@@ -37,10 +39,11 @@ describe ThinkingSphinx::Middlewares::StaleIdChecker do
       context[:results] << double('instance', :id => 24)
       context[:results] << nil
 
-      lambda {
+      expect {
         middleware.call [context]
-      }.should raise_error(ThinkingSphinx::Search::StaleIdsException) { |err|
-        err.ids.should == [42]
+      }.to raise_error(ThinkingSphinx::Search::StaleIdsException) { |err|
+        expect(err.ids).to eq([42])
+        expect(err.context).to eq(context)
       }
     end
   end

data/spec/thinking_sphinx/middlewares/stale_id_filter_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   module Middlewares; end
   class  Search; end
@@ -15,22 +17,22 @@ describe ThinkingSphinx::Middlewares::StaleIdFilter do
 
   describe '#call' do
     before :each do
-      context.stub :search => search
+      allow(context).to receive_messages :search => search
     end
 
     context 'one stale ids exception' do
       before :each do
-        app.stub(:call) do
+        allow(app).to receive(:call) do
           @calls ||= 0
           @calls += 1
-          raise ThinkingSphinx::Search::StaleIdsException, [12] if @calls == 1
+          raise ThinkingSphinx::Search::StaleIdsException.new([12], context) if @calls == 1
         end
       end
 
       it "appends the ids to the without_ids filter" do
         middleware.call [context]
 
-        search.options[:without_ids].should == [12]
+        expect(search.options[:without_ids]).to eq([12])
       end
 
       it "respects existing without_ids filters" do
@@ -38,24 +40,24 @@ describe ThinkingSphinx::Middlewares::StaleIdFilter do
 
         middleware.call [context]
 
-        search.options[:without_ids].should == [11, 12]
+        expect(search.options[:without_ids]).to eq([11, 12])
       end
     end
 
     context  'two stale ids exceptions' do
       before :each do
-        app.stub(:call) do
+        allow(app).to receive(:call) do
           @calls ||= 0
           @calls += 1
-          raise ThinkingSphinx::Search::StaleIdsException, [12] if @calls == 1
-          raise ThinkingSphinx::Search::StaleIdsException, [13] if @calls == 2
+          raise ThinkingSphinx::Search::StaleIdsException.new([12], context) if @calls == 1
+          raise ThinkingSphinx::Search::StaleIdsException.new([13], context) if @calls == 2
         end
       end
 
       it "appends the ids to the without_ids filter" do
         middleware.call [context]
 
-        search.options[:without_ids].should == [12, 13]
+        expect(search.options[:without_ids]).to eq([12, 13])
       end
 
       it "respects existing without_ids filters" do
@@ -63,29 +65,49 @@ describe ThinkingSphinx::Middlewares::StaleIdFilter do
 
         middleware.call [context]
 
-        search.options[:without_ids].should == [11, 12, 13]
+        expect(search.options[:without_ids]).to eq([11, 12, 13])
       end
     end
 
     context 'three stale ids exceptions' do
       before :each do
-        app.stub(:call) do
+        allow(app).to receive(:call) do
           @calls ||= 0
           @calls += 1
 
-          raise ThinkingSphinx::Search::StaleIdsException, [12] if @calls == 1
-          raise ThinkingSphinx::Search::StaleIdsException, [13] if @calls == 2
-          raise ThinkingSphinx::Search::StaleIdsException, [14] if @calls == 3
+          raise ThinkingSphinx::Search::StaleIdsException.new([12], context) if @calls == 1
+          raise ThinkingSphinx::Search::StaleIdsException.new([13], context) if @calls == 2
+          raise ThinkingSphinx::Search::StaleIdsException.new([14], context) if @calls == 3
         end
       end
 
       it "raises the final stale ids exceptions" do
-        lambda {
+        expect {
           middleware.call [context]
-        }.should raise_error(ThinkingSphinx::Search::StaleIdsException) { |err|
-          err.ids.should == [14]
+        }.to raise_error(ThinkingSphinx::Search::StaleIdsException) { |err|
+          expect(err.ids).to eq([14])
         }
       end
     end
+
+    context  'stale ids exceptions with multiple contexts' do
+      let(:context2) { {:raw => [], :results => []} }
+      let(:search2) { double('search2', :options => {}) }
+      before :each do
+        allow(context2).to receive_messages :search => search2
+        allow(app).to receive(:call) do
+          @calls ||= 0
+          @calls += 1
+          raise ThinkingSphinx::Search::StaleIdsException.new([12], context2) if @calls == 1
+        end
+      end
+
+      it "appends the ids to the without_ids filter in the correct context" do
+        middleware.call [context, context2]
+        expect(search.options[:without_ids]).to eq(nil)
+        expect(search2.options[:without_ids]).to eq([12])
+      end
+    end
+
   end
 end