thinking-sphinx 3.2.0 → 3.3.0

data/spec/thinking_sphinx/connection_spec.rb

@@ -8,9 +8,9 @@ describe ThinkingSphinx::Connection do
     let(:translated_error) { ThinkingSphinx::SphinxError.new }
 
     before :each do
-      ThinkingSphinx::Connection.stub :pool => pool
-      ThinkingSphinx::SphinxError.stub :new_from_mysql => translated_error
-      pool.stub(:take).and_yield(connection)
+      allow(ThinkingSphinx::Connection).to receive_messages :pool => pool
+      allow(ThinkingSphinx::SphinxError).to receive_messages :new_from_mysql => translated_error
+      allow(pool).to receive(:take).and_yield(connection)
 
       error.statement            = 'SELECT * FROM article_core'
       translated_error.statement = 'SELECT * FROM article_core'
@@ -18,41 +18,41 @@ describe ThinkingSphinx::Connection do
 
     it "yields a connection from the pool" do
       ThinkingSphinx::Connection.take do |c|
-        c.should == connection
+        expect(c).to eq(connection)
       end
     end
 
     it "retries errors once" do
       tries = 0
 
-      lambda {
+      expect {
         ThinkingSphinx::Connection.take do |c|
           tries += 1
           raise error if tries < 2
         end
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     it "retries errors twice" do
       tries = 0
 
-      lambda {
+      expect {
         ThinkingSphinx::Connection.take do |c|
           tries += 1
           raise error if tries < 3
         end
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     it "raises a translated error if it fails three times" do
       tries = 0
 
-      lambda {
+      expect {
         ThinkingSphinx::Connection.take do |c|
           tries += 1
           raise error if tries < 4
         end
-      }.should raise_error(ThinkingSphinx::SphinxError)
+      }.to raise_error(ThinkingSphinx::SphinxError)
     end
 
     [ThinkingSphinx::SyntaxError, ThinkingSphinx::ParseError].each do |klass|
@@ -60,9 +60,9 @@ describe ThinkingSphinx::Connection do
         let(:translated_error) { klass.new }
 
         it "raises the error" do
-          lambda {
+          expect {
             ThinkingSphinx::Connection.take { |c| raise error }
-          }.should raise_error(klass)
+          }.to raise_error(klass)
         end
 
         it "does not yield the connection more than once" do
@@ -77,7 +77,7 @@ describe ThinkingSphinx::Connection do
             #
           end
 
-          yields.should == 1
+          expect(yields).to eq(1)
         end
       end
     end

data/spec/thinking_sphinx/deletion_spec.rb

@@ -7,13 +7,13 @@ describe ThinkingSphinx::Deletion do
       :document_id_for_key => 14, :type => 'plain', :distributed? => false) }
 
     before :each do
-      ThinkingSphinx::Connection.stub(:take).and_yield(connection)
-      Riddle::Query.stub :update => 'UPDATE STATEMENT'
+      allow(ThinkingSphinx::Connection).to receive(:take).and_yield(connection)
+      allow(Riddle::Query).to receive_messages :update => 'UPDATE STATEMENT'
     end
 
     context 'index is SQL-backed' do
       it "updates the deleted flag to false" do
-        connection.should_receive(:execute).with <<-SQL
+        expect(connection).to receive(:execute).with <<-SQL
 UPDATE foo_core
 SET sphinx_deleted = 1
 WHERE id IN (14)
@@ -23,34 +23,34 @@ WHERE id IN (14)
       end
 
       it "doesn't care about Sphinx errors" do
-        connection.stub(:execute).
+        allow(connection).to receive(:execute).
           and_raise(ThinkingSphinx::ConnectionError.new(''))
 
-        lambda {
+        expect {
           ThinkingSphinx::Deletion.perform index, 7
-        }.should_not raise_error
+        }.not_to raise_error
       end
     end
 
     context "index is real-time" do
       before :each do
-        index.stub :type => 'rt'
+        allow(index).to receive_messages :type => 'rt'
       end
 
       it "deletes the record to false" do
-        connection.should_receive(:execute).
+        expect(connection).to receive(:execute).
           with('DELETE FROM foo_core WHERE id = 14')
 
         ThinkingSphinx::Deletion.perform index, 7
       end
 
       it "doesn't care about Sphinx errors" do
-        connection.stub(:execute).
+        allow(connection).to receive(:execute).
           and_raise(ThinkingSphinx::ConnectionError.new(''))
 
-        lambda {
+        expect {
           ThinkingSphinx::Deletion.perform index, 7
-        }.should_not raise_error
+        }.not_to raise_error
       end
     end
   end

data/spec/thinking_sphinx/deltas/default_delta_spec.rb

@@ -9,11 +9,11 @@ describe ThinkingSphinx::Deltas::DefaultDelta do
   describe '#clause' do
     context 'for a delta source' do
       before :each do
-        adapter.stub :boolean_value => 't'
+        allow(adapter).to receive_messages :boolean_value => 't'
       end
 
       it "limits results to those flagged as deltas" do
-        delta.clause(true).should == "articles.delta = t"
+        expect(delta.clause(true)).to eq("articles.delta = t")
       end
     end
   end
@@ -25,42 +25,42 @@ describe ThinkingSphinx::Deltas::DefaultDelta do
     let(:instance)   { double('instance', :id => 7) }
 
     before :each do
-      ThinkingSphinx::Connection.stub(:take).and_yield(connection)
-      Riddle::Query.stub :update => 'UPDATE STATEMENT'
+      allow(ThinkingSphinx::Connection).to receive(:take).and_yield(connection)
+      allow(Riddle::Query).to receive_messages :update => 'UPDATE STATEMENT'
     end
 
     it "updates the deleted flag to false" do
-      connection.should_receive(:execute).with('UPDATE STATEMENT')
+      expect(connection).to receive(:execute).with('UPDATE STATEMENT')
 
       delta.delete index, instance
     end
 
     it "builds the update query for the given index" do
-      Riddle::Query.should_receive(:update).
+      expect(Riddle::Query).to receive(:update).
         with('foo_core', anything, anything).and_return('')
 
       delta.delete index, instance
     end
 
     it "builds the update query for the sphinx document id" do
-      Riddle::Query.should_receive(:update).
+      expect(Riddle::Query).to receive(:update).
         with(anything, 14, anything).and_return('')
 
       delta.delete index, instance
     end
 
     it "builds the update query for setting sphinx_deleted to true" do
-      Riddle::Query.should_receive(:update).
+      expect(Riddle::Query).to receive(:update).
         with(anything, anything, :sphinx_deleted => true).and_return('')
 
       delta.delete index, instance
     end
 
     it "doesn't care about Sphinx errors" do
-      connection.stub(:execute).
+      allow(connection).to receive(:execute).
         and_raise(ThinkingSphinx::ConnectionError.new(''))
 
-      lambda { delta.delete index, instance }.should_not raise_error
+      expect { delta.delete index, instance }.not_to raise_error
     end
   end
 
@@ -70,11 +70,11 @@ describe ThinkingSphinx::Deltas::DefaultDelta do
     let(:controller) { double('controller') }
 
     before :each do
-      ThinkingSphinx::Configuration.stub :instance => config
+      allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
     end
 
     it "indexes the given index" do
-      controller.should_receive(:index).with('foo_delta', :verbose => true)
+      expect(controller).to receive(:index).with('foo_delta', :verbose => false)
 
       delta.index double('index', :name => 'foo_delta')
     end
@@ -82,9 +82,9 @@ describe ThinkingSphinx::Deltas::DefaultDelta do
 
   describe '#reset_query' do
     it "updates the table to set delta flags to false" do
-      adapter.stub(:boolean_value) { |value| value ? 't' : 'f' }
-      delta.reset_query.
-        should == 'UPDATE articles SET delta = f WHERE delta = t'
+      allow(adapter).to receive(:boolean_value) { |value| value ? 't' : 'f' }
+      expect(delta.reset_query).
+        to eq('UPDATE articles SET delta = f WHERE delta = t')
     end
   end
 
@@ -92,7 +92,7 @@ describe ThinkingSphinx::Deltas::DefaultDelta do
     let(:instance) { double('instance') }
 
     it "sets instance's delta flag to true" do
-      instance.should_receive(:delta=).with(true)
+      expect(instance).to receive(:delta=).with(true)
 
       delta.toggle(instance)
     end
@@ -102,15 +102,15 @@ describe ThinkingSphinx::Deltas::DefaultDelta do
     let(:instance) { double('instance') }
 
     it "returns the delta flag value when true" do
-      instance.stub! :delta? => true
+      allow(instance).to receive_messages :delta? => true
 
-      delta.toggled?(instance).should be_true
+      expect(delta.toggled?(instance)).to be_truthy
     end
 
     it "returns the delta flag value when false" do
-      instance.stub! :delta? => false
+      allow(instance).to receive_messages :delta? => false
 
-      delta.toggled?(instance).should be_false
+      expect(delta.toggled?(instance)).to be_falsey
     end
   end
 end

data/spec/thinking_sphinx/deltas_spec.rb

@@ -3,19 +3,19 @@ require 'spec_helper'
 describe ThinkingSphinx::Deltas do
   describe '.processor_for' do
     it "returns the default processor class when given true" do
-      ThinkingSphinx::Deltas.processor_for(true).
-        should == ThinkingSphinx::Deltas::DefaultDelta
+      expect(ThinkingSphinx::Deltas.processor_for(true)).
+        to eq(ThinkingSphinx::Deltas::DefaultDelta)
     end
 
     it "returns the class when given one" do
       klass = Class.new
-      ThinkingSphinx::Deltas.processor_for(klass).should == klass
+      expect(ThinkingSphinx::Deltas.processor_for(klass)).to eq(klass)
     end
 
     it "instantiates a class from the name as a string" do
-      ThinkingSphinx::Deltas.
-        processor_for('ThinkingSphinx::Deltas::DefaultDelta').
-        should == ThinkingSphinx::Deltas::DefaultDelta
+      expect(ThinkingSphinx::Deltas.
+        processor_for('ThinkingSphinx::Deltas::DefaultDelta')).
+        to eq(ThinkingSphinx::Deltas::DefaultDelta)
     end
   end
 
@@ -29,7 +29,7 @@ describe ThinkingSphinx::Deltas do
     let(:processor)   { double('processor', :index => true) }
 
     before :each do
-      ThinkingSphinx::Configuration.stub :instance => config
+      allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
     end
 
     it "executes the given block" do
@@ -39,12 +39,12 @@ describe ThinkingSphinx::Deltas do
         variable = :bar
       end
 
-      variable.should == :bar
+      expect(variable).to eq(:bar)
     end
 
     it "suspends deltas within the block" do
       ThinkingSphinx::Deltas.suspend :user do
-        ThinkingSphinx::Deltas.should be_suspended
+        expect(ThinkingSphinx::Deltas).to be_suspended
       end
     end
 
@@ -53,11 +53,11 @@ describe ThinkingSphinx::Deltas do
         #
       end
 
-      ThinkingSphinx::Deltas.should_not be_suspended
+      expect(ThinkingSphinx::Deltas).not_to be_suspended
     end
 
     it "processes the delta indices for the given reference" do
-      processor.should_receive(:index).with(delta_index)
+      expect(processor).to receive(:index).with(delta_index)
 
       ThinkingSphinx::Deltas.suspend :user do
         #
@@ -65,7 +65,7 @@ describe ThinkingSphinx::Deltas do
     end
 
     it "does not process the core indices for the given reference" do
-      processor.should_not_receive(:index).with(core_index)
+      expect(processor).not_to receive(:index).with(core_index)
 
       ThinkingSphinx::Deltas.suspend :user do
         #

data/spec/thinking_sphinx/errors_spec.rb

@@ -6,73 +6,73 @@ describe ThinkingSphinx::SphinxError do
       :backtrace => ['foo', 'bar'] }
 
     it "translates syntax errors" do
-      error.stub :message => 'index foo: syntax error: something is wrong'
+      allow(error).to receive_messages :message => 'index foo: syntax error: something is wrong'
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).
-        should be_a(ThinkingSphinx::SyntaxError)
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::SyntaxError)
     end
 
     it "translates parse errors" do
-      error.stub :message => 'index foo: parse error: something is wrong'
+      allow(error).to receive_messages :message => 'index foo: parse error: something is wrong'
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).
-        should be_a(ThinkingSphinx::ParseError)
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::ParseError)
     end
 
     it "translates query errors" do
-      error.stub :message => 'index foo: query error: something is wrong'
+      allow(error).to receive_messages :message => 'index foo: query error: something is wrong'
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).
-        should be_a(ThinkingSphinx::QueryError)
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::QueryError)
     end
 
     it "translates connection errors" do
-      error.stub :message => "Can't connect to MySQL server on '127.0.0.1' (61)"
+      allow(error).to receive_messages :message => "Can't connect to MySQL server on '127.0.0.1' (61)"
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).
-        should be_a(ThinkingSphinx::ConnectionError)
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::ConnectionError)
     end
 
     it 'translates out-of-bounds errors' do
-      error.stub :message => "offset out of bounds (offset=1001, max_matches=1000)"
+      allow(error).to receive_messages :message => "offset out of bounds (offset=1001, max_matches=1000)"
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).
-        should be_a(ThinkingSphinx::OutOfBoundsError)
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::OutOfBoundsError)
     end
 
     it 'prefixes the connection error message' do
-      error.stub :message => "Can't connect to MySQL server on '127.0.0.1' (61)"
+      allow(error).to receive_messages :message => "Can't connect to MySQL server on '127.0.0.1' (61)"
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).message.
-        should == "Error connecting to Sphinx via the MySQL protocol. Can't connect to MySQL server on '127.0.0.1' (61)"
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error).message).
+        to eq("Error connecting to Sphinx via the MySQL protocol. Can't connect to MySQL server on '127.0.0.1' (61)")
     end
 
     it "translates jdbc connection errors" do
-      error.stub :message => "Communications link failure"
+      allow(error).to receive_messages :message => "Communications link failure"
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).
-        should be_a(ThinkingSphinx::ConnectionError)
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::ConnectionError)
     end
 
     it 'prefixes the jdbc connection error message' do
-      error.stub :message => "Communications link failure"
+      allow(error).to receive_messages :message => "Communications link failure"
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).message.
-        should == "Error connecting to Sphinx via the MySQL protocol. Communications link failure"
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error).message).
+        to eq("Error connecting to Sphinx via the MySQL protocol. Communications link failure")
     end
 
     it "defaults to sphinx errors" do
-      error.stub :message => 'index foo: unknown error: something is wrong'
+      allow(error).to receive_messages :message => 'index foo: unknown error: something is wrong'
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).
-        should be_a(ThinkingSphinx::SphinxError)
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::SphinxError)
     end
 
     it "keeps the original error's backtrace" do
-      error.stub :message => 'index foo: unknown error: something is wrong'
+      allow(error).to receive_messages :message => 'index foo: unknown error: something is wrong'
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).
-        backtrace.should == error.backtrace
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error).
+        backtrace).to eq(error.backtrace)
     end
   end
 end

data/spec/thinking_sphinx/excerpter_spec.rb

@@ -7,13 +7,13 @@ describe ThinkingSphinx::Excerpter do
   }
 
   before :each do
-    ThinkingSphinx::Connection.stub(:take).and_yield(connection)
-    Riddle::Query.stub :snippets => 'CALL SNIPPETS'
+    allow(ThinkingSphinx::Connection).to receive(:take).and_yield(connection)
+    allow(Riddle::Query).to receive_messages :snippets => 'CALL SNIPPETS'
   end
 
   describe '#excerpt!' do
     it "generates a snippets call" do
-      Riddle::Query.should_receive(:snippets).
+      expect(Riddle::Query).to receive(:snippets).
         with('all of the words', 'index', 'all words',
           ThinkingSphinx::Excerpter::DefaultOptions).
         and_return('CALL SNIPPETS')
@@ -25,7 +25,7 @@ describe ThinkingSphinx::Excerpter do
       excerpter = ThinkingSphinx::Excerpter.new('index', 'all words',
         :before_match => '<b>', :chunk_separator => ' -- ')
 
-      Riddle::Query.should_receive(:snippets).
+      expect(Riddle::Query).to receive(:snippets).
         with('all of the words', 'index', 'all words',
           :before_match => '<b>', :after_match => '</span>',
           :chunk_separator => ' -- ').
@@ -35,16 +35,16 @@ describe ThinkingSphinx::Excerpter do
     end
 
     it "sends the snippets call to Sphinx" do
-      connection.should_receive(:execute).with('CALL SNIPPETS').
+      expect(connection).to receive(:execute).with('CALL SNIPPETS').
         and_return([{'snippet' => ''}])
 
       excerpter.excerpt!('all of the words')
     end
 
     it "returns the first value returned by Sphinx" do
-      connection.stub :execute => [{'snippet' => 'some highlighted words'}]
+      allow(connection).to receive_messages :execute => [{'snippet' => 'some highlighted words'}]
 
-      excerpter.excerpt!('all of the words').should == 'some highlighted words'
+      expect(excerpter.excerpt!('all of the words')).to eq('some highlighted words')
     end
   end
 end