thinking-sphinx 3.2.0 → 3.3.0

data/spec/thinking_sphinx/active_record/callbacks/delete_callbacks_spec.rb

@@ -10,20 +10,20 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks do
     let(:callbacks) { double('callbacks', :after_destroy => nil) }
 
     before :each do
-      ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
-        stub :new => callbacks
+      allow(ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks).
+        to receive_messages :new => callbacks
     end
 
     it "builds an object from the instance" do
-      ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
-        should_receive(:new).with(instance).and_return(callbacks)
+      expect(ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks).
+        to receive(:new).with(instance).and_return(callbacks)
 
       ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
         after_destroy(instance)
     end
 
     it "invokes after_destroy on the object" do
-      callbacks.should_receive(:after_destroy)
+      expect(callbacks).to receive(:after_destroy)
 
       ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
         after_destroy(instance)
@@ -37,19 +37,19 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks do
     let(:instance)   { double('instance', :id => 7, :new_record? => false) }
 
     before :each do
-      ThinkingSphinx::IndexSet.stub :new => index_set
+      allow(ThinkingSphinx::IndexSet).to receive_messages :new => index_set
     end
 
     it "performs the deletion for the index and instance" do
-      ThinkingSphinx::Deletion.should_receive(:perform).with(index, 7)
+      expect(ThinkingSphinx::Deletion).to receive(:perform).with(index, 7)
 
       callbacks.after_destroy
     end
 
     it "doesn't do anything if the instance is a new record" do
-      instance.stub :new_record? => true
+      allow(instance).to receive_messages :new_record? => true
 
-      ThinkingSphinx::Deletion.should_not_receive(:perform)
+      expect(ThinkingSphinx::Deletion).not_to receive(:perform)
 
       callbacks.after_destroy
     end
@@ -57,7 +57,7 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks do
     it 'does nothing if callbacks are suspended' do
       ThinkingSphinx::Callbacks.suspend!
 
-      ThinkingSphinx::Deletion.should_not_receive(:perform)
+      expect(ThinkingSphinx::Deletion).not_to receive(:perform)
 
       callbacks.after_destroy
 

data/spec/thinking_sphinx/active_record/callbacks/delta_callbacks_spec.rb

@@ -11,7 +11,7 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
   }
 
   before :each do
-    ThinkingSphinx::Configuration.stub :instance => config
+    allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
   end
 
   [:after_commit, :before_save].each do |callback|
@@ -19,20 +19,20 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
       let(:callbacks) { double('callbacks', callback => nil) }
 
       before :each do
-        ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks.
-          stub :new => callbacks
+        allow(ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks).
+          to receive_messages :new => callbacks
       end
 
       it "builds an object from the instance" do
-        ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks.
-          should_receive(:new).with(instance).and_return(callbacks)
+        expect(ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks).
+          to receive(:new).with(instance).and_return(callbacks)
 
         ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks.
           send(callback, instance)
       end
 
       it "invokes #{callback} on the object" do
-        callbacks.should_receive(callback)
+        expect(callbacks).to receive(callback)
 
         ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks.
           send(callback, instance)
@@ -46,18 +46,18 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
     }
 
     before :each do
-      config.stub :index_set_class => double(:new => [index])
+      allow(config).to receive_messages :index_set_class => double(:new => [index])
     end
 
     context 'without delta indices' do
       it "does not fire a delta index when no delta indices" do
-        processor.should_not_receive(:index)
+        expect(processor).not_to receive(:index)
 
         callbacks.after_commit
       end
 
       it "does not delete the instance from any index" do
-        processor.should_not_receive(:delete)
+        expect(processor).not_to receive(:delete)
 
         callbacks.after_commit
       end
@@ -70,53 +70,53 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
         :delta_processor => processor) }
 
       before :each do
-        ThinkingSphinx::Deltas.stub :suspended? => false
+        allow(ThinkingSphinx::Deltas).to receive_messages :suspended? => false
 
-        config.stub :index_set_class => double(
+        allow(config).to receive_messages :index_set_class => double(
           :new => [core_index, delta_index]
         )
       end
 
       it "only indexes delta indices" do
-        processor.should_receive(:index).with(delta_index)
+        expect(processor).to receive(:index).with(delta_index)
 
         callbacks.after_commit
       end
 
       it "does not process delta indices when deltas are suspended" do
-        ThinkingSphinx::Deltas.stub :suspended? => true
+        allow(ThinkingSphinx::Deltas).to receive_messages :suspended? => true
 
-        processor.should_not_receive(:index)
+        expect(processor).not_to receive(:index)
 
         callbacks.after_commit
       end
 
       it "deletes the instance from the core index" do
-        processor.should_receive(:delete).with(core_index, instance)
+        expect(processor).to receive(:delete).with(core_index, instance)
 
         callbacks.after_commit
       end
 
       it "does not index if model's delta flag is not true" do
-        processor.stub :toggled? => false
+        allow(processor).to receive_messages :toggled? => false
 
-        processor.should_not_receive(:index)
+        expect(processor).not_to receive(:index)
 
         callbacks.after_commit
       end
 
       it "does not delete if model's delta flag is not true" do
-        processor.stub :toggled? => false
+        allow(processor).to receive_messages :toggled? => false
 
-        processor.should_not_receive(:delete)
+        expect(processor).not_to receive(:delete)
 
         callbacks.after_commit
       end
 
       it "does not delete when deltas are suspended" do
-        ThinkingSphinx::Deltas.stub :suspended? => true
+        allow(ThinkingSphinx::Deltas).to receive_messages :suspended? => true
 
-        processor.should_not_receive(:delete)
+        expect(processor).not_to receive(:delete)
 
         callbacks.after_commit
       end
@@ -129,19 +129,42 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
     }
 
     before :each do
-      config.stub :index_set_class => double(:new => [index])
+      allow(config).to receive_messages :index_set_class => double(:new => [index])
+      allow(instance).to receive_messages(
+        :changed?    => true,
+        :new_record? => false
+      )
     end
 
     it "sets delta to true if there are delta indices" do
-      processor.should_receive(:toggle).with(instance)
+      expect(processor).to receive(:toggle).with(instance)
 
       callbacks.before_save
     end
 
     it "does not try to set delta to true if there are no delta indices" do
-      index.stub :delta? => false
+      allow(index).to receive_messages :delta? => false
+
+      expect(processor).not_to receive(:toggle)
+
+      callbacks.before_save
+    end
+
+    it "does not try to set delta to true if the instance is unchanged" do
+      allow(instance).to receive_messages :changed? => false
+
+      expect(processor).not_to receive(:toggle)
+
+      callbacks.before_save
+    end
+
+    it "does set delta to true if the instance is unchanged but new" do
+      allow(instance).to receive_messages(
+        :changed?    => false,
+        :new_record? => true
+      )
 
-      processor.should_not_receive(:toggle)
+      expect(processor).to receive(:toggle)
 
       callbacks.before_save
     end

data/spec/thinking_sphinx/active_record/callbacks/update_callbacks_spec.rb

@@ -30,7 +30,7 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks do
       stub_const 'ThinkingSphinx::Connection', double
       stub_const 'Riddle::Query', double(:update => 'SphinxQL')
 
-      ThinkingSphinx::Connection.stub(:take).and_yield(connection)
+      allow(ThinkingSphinx::Connection).to receive(:take).and_yield(connection)
 
       source.attributes.replace([
         double(:name => 'foo', :updateable? => true,
@@ -40,41 +40,41 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks do
         double(:name => 'baz', :updateable? => false)
       ])
 
-      instance.stub :changed => ['bar_column', 'baz'], :bar_column => 7
+      allow(instance).to receive_messages :changed => ['bar_column', 'baz'], :bar_column => 7
     end
 
     it "does not send any updates to Sphinx if updates are disabled" do
       configuration.settings['attribute_updates'] = false
 
-      connection.should_not_receive(:execute)
+      expect(connection).not_to receive(:execute)
 
       callbacks.after_update
     end
 
     it "builds an update query with only updateable attributes that have changed" do
-      Riddle::Query.should_receive(:update).
+      expect(Riddle::Query).to receive(:update).
         with('article_core', 3, 'bar' => 7).and_return('SphinxQL')
 
       callbacks.after_update
     end
 
     it "sends the update query through to Sphinx" do
-      connection.should_receive(:execute).with('SphinxQL')
+      expect(connection).to receive(:execute).with('SphinxQL')
 
       callbacks.after_update
     end
 
     it "doesn't care if the update fails at Sphinx's end" do
-      connection.stub(:execute).
+      allow(connection).to receive(:execute).
         and_raise(ThinkingSphinx::ConnectionError.new(''))
 
-      lambda { callbacks.after_update }.should_not raise_error
+      expect { callbacks.after_update }.not_to raise_error
     end
 
     it 'does nothing if callbacks are suspended' do
       ThinkingSphinx::Callbacks.suspend!
 
-      connection.should_not_receive(:execute)
+      expect(connection).not_to receive(:execute)
 
       callbacks.after_update
 

data/spec/thinking_sphinx/active_record/column_spec.rb

@@ -4,7 +4,7 @@ describe ThinkingSphinx::ActiveRecord::Column do
   describe '#__name' do
     it "returns the top item" do
       column = ThinkingSphinx::ActiveRecord::Column.new(:content)
-      column.__name.should == :content
+      expect(column.__name).to eq(:content)
     end
   end
 
@@ -14,27 +14,27 @@ describe ThinkingSphinx::ActiveRecord::Column do
 
     it "returns itself when it's a string column" do
       column = ThinkingSphinx::ActiveRecord::Column.new('foo')
-      column.__replace(base, replacements).collect(&:__path).
-        should == [['foo']]
+      expect(column.__replace(base, replacements).collect(&:__path)).
+        to eq([['foo']])
     end
 
     it "returns itself when the base of the stack does not match" do
       column = ThinkingSphinx::ActiveRecord::Column.new(:b, :c)
-      column.__replace(base, replacements).collect(&:__path).
-        should == [[:b, :c]]
+      expect(column.__replace(base, replacements).collect(&:__path)).
+        to eq([[:b, :c]])
     end
 
     it "returns an array of new columns " do
       column = ThinkingSphinx::ActiveRecord::Column.new(:a, :b, :e)
-      column.__replace(base, replacements).collect(&:__path).
-        should == [[:a, :c, :e], [:a, :d, :e]]
+      expect(column.__replace(base, replacements).collect(&:__path)).
+        to eq([[:a, :c, :e], [:a, :d, :e]])
     end
   end
 
   describe '#__stack' do
     it "returns all but the top item" do
       column = ThinkingSphinx::ActiveRecord::Column.new(:users, :posts, :id)
-      column.__stack.should == [:users, :posts]
+      expect(column.__stack).to eq([:users, :posts])
     end
   end
 
@@ -43,28 +43,28 @@ describe ThinkingSphinx::ActiveRecord::Column do
 
     it "shifts the current name to the stack" do
       column.email
-      column.__stack.should == [:user]
+      expect(column.__stack).to eq([:user])
     end
 
     it "adds the new method call as the name" do
       column.email
-      column.__name.should == :email
+      expect(column.__name).to eq(:email)
     end
 
     it "returns itself" do
-      column.email.should == column
+      expect(column.email).to eq(column)
     end
   end
 
   describe '#string?' do
     it "is true when the name is a string" do
       column = ThinkingSphinx::ActiveRecord::Column.new('content')
-      column.should be_a_string
+      expect(column).to be_a_string
     end
 
     it "is false when the name is a symbol" do
       column = ThinkingSphinx::ActiveRecord::Column.new(:content)
-      column.should_not be_a_string
+      expect(column).not_to be_a_string
     end
   end
 end

data/spec/thinking_sphinx/active_record/column_sql_presenter_spec.rb

@@ -15,22 +15,22 @@ describe ThinkingSphinx::ActiveRecord::ColumnSQLPresenter do
 
     before do
       stub_const 'Joiner::Path', double(:new => path)
-      adapter.stub(:quote) { |arg| "`#{arg}`" }
+      allow(adapter).to receive(:quote) { |arg| "`#{arg}`" }
     end
 
     context "when there's no explicit db name" do
-      before { associations.stub(:alias_for => 'table_name') }
+      before { allow(associations).to receive_messages(:alias_for => 'table_name') }
 
       it 'returns quoted table and column names' do
-        presenter.with_table.should == '`table_name`.`column_name`'
+        expect(presenter.with_table).to eq('`table_name`.`column_name`')
       end
     end
 
     context 'when an eplicit db name is provided' do
-      before { associations.stub(:alias_for => 'db_name.table_name') }
+      before { allow(associations).to receive_messages(:alias_for => 'db_name.table_name') }
 
       it 'returns properly quoted table name with column name' do
-        presenter.with_table.should == '`db_name`.`table_name`.`column_name`'
+        expect(presenter.with_table).to eq('`db_name`.`table_name`.`column_name`')
       end
     end
   end

data/spec/thinking_sphinx/active_record/database_adapters/abstract_adapter_spec.rb

@@ -9,23 +9,23 @@ describe ThinkingSphinx::ActiveRecord::DatabaseAdapters::AbstractAdapter do
 
   describe '#quote' do
     it "uses the model's connection to quote columns" do
-      connection.should_receive(:quote_column_name).with('foo')
+      expect(connection).to receive(:quote_column_name).with('foo')
 
       adapter.quote 'foo'
     end
 
     it "returns the quoted value" do
-      connection.stub :quote_column_name => '"foo"'
+      allow(connection).to receive_messages :quote_column_name => '"foo"'
 
-      adapter.quote('foo').should == '"foo"'
+      expect(adapter.quote('foo')).to eq('"foo"')
     end
   end
 
   describe '#quoted_table_name' do
     it "passes the method through to the model" do
-      model.should_receive(:quoted_table_name).and_return('"articles"')
+      expect(model).to receive(:quoted_table_name).and_return('"articles"')
 
-      adapter.quoted_table_name.should == '"articles"'
+      expect(adapter.quoted_table_name).to eq('"articles"')
     end
   end
 end

data/spec/thinking_sphinx/active_record/database_adapters/mysql_adapter_spec.rb

@@ -7,50 +7,50 @@ describe ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter do
   let(:model)   { double('model') }
 
   it "returns 1 for true" do
-    adapter.boolean_value(true).should == 1
+    expect(adapter.boolean_value(true)).to eq(1)
   end
 
   it "returns 0 for false" do
-    adapter.boolean_value(false).should == 0
+    expect(adapter.boolean_value(false)).to eq(0)
   end
 
   describe '#cast_to_string' do
     it "casts the clause to characters" do
-      adapter.cast_to_string('foo').should == "CAST(foo AS char)"
+      expect(adapter.cast_to_string('foo')).to eq("CAST(foo AS char)")
     end
   end
 
   describe '#cast_to_timestamp' do
     it "converts to unix timestamps" do
-      adapter.cast_to_timestamp('created_at').
-        should == 'UNIX_TIMESTAMP(created_at)'
+      expect(adapter.cast_to_timestamp('created_at')).
+        to eq('UNIX_TIMESTAMP(created_at)')
     end
   end
 
   describe '#concatenate' do
     it "concatenates with the given separator" do
-      adapter.concatenate('foo, bar, baz', ',').
-        should == "CONCAT_WS(',', foo, bar, baz)"
+      expect(adapter.concatenate('foo, bar, baz', ',')).
+        to eq("CONCAT_WS(',', foo, bar, baz)")
     end
   end
 
   describe '#convert_nulls' do
     it "translates arguments to an IFNULL SQL call" do
-      adapter.convert_nulls('id', 5).should == 'IFNULL(id, 5)'
+      expect(adapter.convert_nulls('id', 5)).to eq('IFNULL(id, 5)')
     end
   end
 
   describe '#convert_blank' do
     it "translates arguments to a COALESCE NULLIF SQL call" do
-      adapter.convert_blank('id', 5).should == "COALESCE(NULLIF(id, ''), 5)"
+      expect(adapter.convert_blank('id', 5)).to eq("COALESCE(NULLIF(id, ''), 5)")
     end
   end
 
 
   describe '#group_concatenate' do
     it "group concatenates the clause with the given separator" do
-      adapter.group_concatenate('foo', ',').
-        should == "GROUP_CONCAT(DISTINCT foo SEPARATOR ',')"
+      expect(adapter.group_concatenate('foo', ',')).
+        to eq("GROUP_CONCAT(DISTINCT foo SEPARATOR ',')")
     end
   end
 end