thinking-sphinx 3.2.0 → 3.3.0

data/spec/thinking_sphinx/real_time/attribute_spec.rb

@@ -7,11 +7,11 @@ describe ThinkingSphinx::RealTime::Attribute do
   describe '#name' do
     it "uses the provided option by default" do
       attribute = ThinkingSphinx::RealTime::Attribute.new column, :as => :foo
-      attribute.name.should == 'foo'
+      expect(attribute.name).to eq('foo')
     end
 
     it "falls back to the column's name" do
-      attribute.name.should == 'created_at'
+      expect(attribute.name).to eq('created_at')
     end
   end
 
@@ -21,34 +21,34 @@ describe ThinkingSphinx::RealTime::Attribute do
     let(:parent) { klass.new 'the parent name', nil }
 
     it "returns the column's name if it's a string" do
-      column.stub :__name => 'value'
+      allow(column).to receive_messages :__name => 'value'
 
-      attribute.translate(object).should == 'value'
+      expect(attribute.translate(object)).to eq('value')
     end
 
     it "returns the column's name if it's an integer" do
-      column.stub :__name => 404
+      allow(column).to receive_messages :__name => 404
 
-      attribute.translate(object).should == 404
+      expect(attribute.translate(object)).to eq(404)
     end
 
     it "returns the object's method matching the column's name" do
-      object.stub :created_at => 'a time'
+      allow(object).to receive_messages :created_at => 'a time'
 
-      attribute.translate(object).should == 'a time'
+      expect(attribute.translate(object)).to eq('a time')
     end
 
     it "uses the column's stack to navigate through the object tree" do
-      column.stub :__name => :name, :__stack => [:parent]
+      allow(column).to receive_messages :__name => :name, :__stack => [:parent]
 
-      attribute.translate(object).should == 'the parent name'
+      expect(attribute.translate(object)).to eq('the parent name')
     end
 
     it "returns zero if any element in the object tree is nil" do
-      column.stub :__name => :name, :__stack => [:parent]
+      allow(column).to receive_messages :__name => :name, :__stack => [:parent]
       object.parent = nil
 
-      attribute.translate(object).should be_zero
+      expect(attribute.translate(object)).to be_zero
     end
   end
 
@@ -56,7 +56,7 @@ describe ThinkingSphinx::RealTime::Attribute do
     it "returns the given type option" do
       attribute = ThinkingSphinx::RealTime::Attribute.new column,
         :type => :string
-      attribute.type.should == :string
+      expect(attribute.type).to eq(:string)
     end
   end
 end

data/spec/thinking_sphinx/real_time/callbacks/real_time_callbacks_spec.rb

@@ -13,11 +13,11 @@ describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
   let(:connection) { double('connection', :execute => true) }
 
   before :each do
-    ThinkingSphinx::Configuration.stub :instance => config
-    ThinkingSphinx::Connection.stub_chain(:pool, :take).and_yield connection
+    allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
+    allow(ThinkingSphinx::Connection).to receive_message_chain(:pool, :take).and_yield connection
   end
 
-  describe '#after_save' do
+  describe '#after_save, #after_commit' do
     let(:insert)     { double('insert', :to_sql => 'REPLACE INTO my_index') }
     let(:time)       { 1.day.ago }
     let(:field)      { double('field', :name => 'name', :translate => 'Foo') }
@@ -25,14 +25,14 @@ describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
       :translate => time) }
 
     before :each do
-      ThinkingSphinx::Configuration.stub :instance => config
-      Riddle::Query::Insert.stub :new => insert
-      insert.stub :replace! => insert
-      index.stub :fields => [field], :attributes => [attribute]
+      allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
+      allow(Riddle::Query::Insert).to receive_messages :new => insert
+      allow(insert).to receive_messages :replace! => insert
+      allow(index).to receive_messages :fields => [field], :attributes => [attribute]
     end
 
     it "creates an insert statement with all fields and attributes" do
-      Riddle::Query::Insert.should_receive(:new).
+      expect(Riddle::Query::Insert).to receive(:new).
         with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
         and_return(insert)
 
@@ -40,17 +40,37 @@ describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
     end
 
     it "switches the insert to a replace statement" do
-      insert.should_receive(:replace!).and_return(insert)
+      expect(insert).to receive(:replace!).and_return(insert)
 
       callbacks.after_save instance
     end
 
     it "sends the insert through to the server" do
-      connection.should_receive(:execute).with('REPLACE INTO my_index')
+      expect(connection).to receive(:execute).with('REPLACE INTO my_index')
 
       callbacks.after_save instance
     end
 
+    it "creates an insert statement with all fields and attributes" do
+      expect(Riddle::Query::Insert).to receive(:new).
+        with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
+        and_return(insert)
+
+      callbacks.after_commit instance
+    end
+
+    it "switches the insert to a replace statement" do
+      expect(insert).to receive(:replace!).and_return(insert)
+
+      callbacks.after_commit instance
+    end
+
+    it "sends the insert through to the server" do
+      expect(connection).to receive(:execute).with('REPLACE INTO my_index')
+
+      callbacks.after_commit instance
+    end
+
     context 'with a given path' do
       let(:callbacks)  {
         ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.new(
@@ -61,7 +81,7 @@ describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
       let(:user)       { double('user', :id => 13, :persisted? => true) }
 
       it "creates an insert statement with all fields and attributes" do
-        Riddle::Query::Insert.should_receive(:new).
+        expect(Riddle::Query::Insert).to receive(:new).
           with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
           and_return(insert)
 
@@ -69,16 +89,36 @@ describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
       end
 
       it "gets the document id for the user object" do
-        index.should_receive(:document_id_for_key).with(13).and_return(123)
+        expect(index).to receive(:document_id_for_key).with(13).and_return(123)
 
         callbacks.after_save instance
       end
 
       it "translates values for the user object" do
-        field.should_receive(:translate).with(user).and_return('Foo')
+        expect(field).to receive(:translate).with(user).and_return('Foo')
 
         callbacks.after_save instance
       end
+
+      it "creates an insert statement with all fields and attributes" do
+        expect(Riddle::Query::Insert).to receive(:new).
+          with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
+          and_return(insert)
+
+        callbacks.after_commit instance
+      end
+
+      it "gets the document id for the user object" do
+        expect(index).to receive(:document_id_for_key).with(13).and_return(123)
+
+        callbacks.after_commit instance
+      end
+
+      it "translates values for the user object" do
+        expect(field).to receive(:translate).with(user).and_return('Foo')
+
+        callbacks.after_commit instance
+      end
     end
 
     context 'with a path returning multiple objects' do
@@ -93,7 +133,7 @@ describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
       let(:user_b)     { double('user', :id => 14, :persisted? => true) }
 
       it "creates insert statements with all fields and attributes" do
-        Riddle::Query::Insert.should_receive(:new).twice.
+        expect(Riddle::Query::Insert).to receive(:new).twice.
           with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
           and_return(insert)
 
@@ -101,18 +141,40 @@ describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
       end
 
       it "gets the document id for each reader" do
-        index.should_receive(:document_id_for_key).with(13).and_return(123)
-        index.should_receive(:document_id_for_key).with(14).and_return(123)
+        expect(index).to receive(:document_id_for_key).with(13).and_return(123)
+        expect(index).to receive(:document_id_for_key).with(14).and_return(123)
 
         callbacks.after_save instance
       end
 
       it "translates values for each reader" do
-        field.should_receive(:translate).with(user_a).and_return('Foo')
-        field.should_receive(:translate).with(user_b).and_return('Foo')
+        expect(field).to receive(:translate).with(user_a).and_return('Foo')
+        expect(field).to receive(:translate).with(user_b).and_return('Foo')
 
         callbacks.after_save instance
       end
+
+      it "creates insert statements with all fields and attributes" do
+        expect(Riddle::Query::Insert).to receive(:new).twice.
+          with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
+          and_return(insert)
+
+        callbacks.after_commit instance
+      end
+
+      it "gets the document id for each reader" do
+        expect(index).to receive(:document_id_for_key).with(13).and_return(123)
+        expect(index).to receive(:document_id_for_key).with(14).and_return(123)
+
+        callbacks.after_commit instance
+      end
+
+      it "translates values for each reader" do
+        expect(field).to receive(:translate).with(user_a).and_return('Foo')
+        expect(field).to receive(:translate).with(user_b).and_return('Foo')
+
+        callbacks.after_commit instance
+      end
     end
 
     context 'with a block instead of a path' do
@@ -127,7 +189,7 @@ describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
       let(:user_b)     { double('user', :id => 14, :persisted? => true) }
 
       it "creates insert statements with all fields and attributes" do
-        Riddle::Query::Insert.should_receive(:new).twice.
+        expect(Riddle::Query::Insert).to receive(:new).twice.
           with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
           and_return(insert)
 
@@ -135,18 +197,40 @@ describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
       end
 
       it "gets the document id for each reader" do
-        index.should_receive(:document_id_for_key).with(13).and_return(123)
-        index.should_receive(:document_id_for_key).with(14).and_return(123)
+        expect(index).to receive(:document_id_for_key).with(13).and_return(123)
+        expect(index).to receive(:document_id_for_key).with(14).and_return(123)
 
         callbacks.after_save instance
       end
 
       it "translates values for each reader" do
-        field.should_receive(:translate).with(user_a).and_return('Foo')
-        field.should_receive(:translate).with(user_b).and_return('Foo')
+        expect(field).to receive(:translate).with(user_a).and_return('Foo')
+        expect(field).to receive(:translate).with(user_b).and_return('Foo')
 
         callbacks.after_save instance
       end
+
+      it "creates insert statements with all fields and attributes" do
+        expect(Riddle::Query::Insert).to receive(:new).twice.
+          with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
+          and_return(insert)
+
+        callbacks.after_commit instance
+      end
+
+      it "gets the document id for each reader" do
+        expect(index).to receive(:document_id_for_key).with(13).and_return(123)
+        expect(index).to receive(:document_id_for_key).with(14).and_return(123)
+
+        callbacks.after_commit instance
+      end
+
+      it "translates values for each reader" do
+        expect(field).to receive(:translate).with(user_a).and_return('Foo')
+        expect(field).to receive(:translate).with(user_b).and_return('Foo')
+
+        callbacks.after_commit instance
+      end
     end
   end
 end

data/spec/thinking_sphinx/real_time/field_spec.rb

@@ -6,11 +6,11 @@ describe ThinkingSphinx::RealTime::Field do
 
   describe '#column' do
     it 'returns the provided Column object' do
-      field.column.should == column
+      expect(field.column).to eq(column)
     end
 
     it 'translates symbols to Column objects' do
-      ThinkingSphinx::ActiveRecord::Column.should_receive(:new).with(:title).
+      expect(ThinkingSphinx::ActiveRecord::Column).to receive(:new).with(:title).
         and_return(column)
 
       ThinkingSphinx::RealTime::Field.new :title
@@ -20,11 +20,11 @@ describe ThinkingSphinx::RealTime::Field do
   describe '#name' do
     it "uses the provided option by default" do
       field = ThinkingSphinx::RealTime::Field.new column, :as => :foo
-      field.name.should == 'foo'
+      expect(field.name).to eq('foo')
     end
 
     it "falls back to the column's name" do
-      field.name.should == 'created_at'
+      expect(field.name).to eq('created_at')
     end
   end
 
@@ -34,34 +34,34 @@ describe ThinkingSphinx::RealTime::Field do
     let(:parent) { klass.new 'the parent name', nil }
 
     it "returns the column's name if it's a string" do
-      column.stub :__name => 'value'
+      allow(column).to receive_messages :__name => 'value'
 
-      field.translate(object).should == 'value'
+      expect(field.translate(object)).to eq('value')
     end
 
     it "returns the column's name as a string if it's an integer" do
-      column.stub :__name => 404
+      allow(column).to receive_messages :__name => 404
 
-      field.translate(object).should == '404'
+      expect(field.translate(object)).to eq('404')
     end
 
     it "returns the object's method matching the column's name" do
-      object.stub :created_at => 'a time'
+      allow(object).to receive_messages :created_at => 'a time'
 
-      field.translate(object).should == 'a time'
+      expect(field.translate(object)).to eq('a time')
     end
 
     it "uses the column's stack to navigate through the object tree" do
-      column.stub :__name => :name, :__stack => [:parent]
+      allow(column).to receive_messages :__name => :name, :__stack => [:parent]
 
-      field.translate(object).should == 'the parent name'
+      expect(field.translate(object)).to eq('the parent name')
     end
 
     it "returns a blank string if any element in the object tree is nil" do
-      column.stub :__name => :name, :__stack => [:parent]
+      allow(column).to receive_messages :__name => :name, :__stack => [:parent]
       object.parent = nil
 
-      field.translate(object).should == ''
+      expect(field.translate(object)).to eq('')
     end
   end
 end

data/spec/thinking_sphinx/real_time/index_spec.rb

@@ -2,46 +2,45 @@ require 'spec_helper'
 
 describe ThinkingSphinx::RealTime::Index do
   let(:index)        { ThinkingSphinx::RealTime::Index.new :user }
-  let(:indices_path) { double('indices path', :join => '') }
   let(:config)       { double('config', :settings => {},
-    :indices_location => indices_path, :next_offset => 8) }
+    :indices_location => 'location', :next_offset => 8) }
 
   before :each do
-    ThinkingSphinx::Configuration.stub :instance => config
+    allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
   end
 
   describe '#attributes' do
     it "has the internal id attribute by default" do
-      index.attributes.collect(&:name).should include('sphinx_internal_id')
+      expect(index.attributes.collect(&:name)).to include('sphinx_internal_id')
     end
 
     it "has the class name attribute by default" do
-      index.attributes.collect(&:name).should include('sphinx_internal_class')
+      expect(index.attributes.collect(&:name)).to include('sphinx_internal_class')
     end
 
     it "has the internal deleted attribute by default" do
-      index.attributes.collect(&:name).should include('sphinx_deleted')
+      expect(index.attributes.collect(&:name)).to include('sphinx_deleted')
     end
   end
 
   describe '#delta?' do
     it "always returns false" do
-      index.should_not be_delta
+      expect(index).not_to be_delta
     end
   end
 
   describe '#document_id_for_key' do
     it "calculates the document id based on offset and number of indices" do
-      config.stub_chain(:indices, :count).and_return(5)
-      config.stub :next_offset => 7
+      allow(config).to receive_message_chain(:indices, :count).and_return(5)
+      allow(config).to receive_messages :next_offset => 7
 
-      index.document_id_for_key(123).should == 622
+      expect(index.document_id_for_key(123)).to eq(622)
     end
   end
 
   describe '#fields' do
     it "has the internal class field by default" do
-      index.fields.collect(&:name).should include('sphinx_internal_class_name')
+      expect(index.fields.collect(&:name)).to include('sphinx_internal_class_name')
     end
   end
 
@@ -53,14 +52,14 @@ describe ThinkingSphinx::RealTime::Index do
     end
 
     it "interprets the definition block" do
-      ThinkingSphinx::RealTime::Interpreter.should_receive(:translate!).
+      expect(ThinkingSphinx::RealTime::Interpreter).to receive(:translate!).
         with(index, block)
 
       index.interpret_definition!
     end
 
     it "only interprets the definition block once" do
-      ThinkingSphinx::RealTime::Interpreter.should_receive(:translate!).
+      expect(ThinkingSphinx::RealTime::Interpreter).to receive(:translate!).
         once
 
       index.interpret_definition!
@@ -72,13 +71,13 @@ describe ThinkingSphinx::RealTime::Index do
     let(:model)  { double('model') }
 
     it "translates symbol references to model class" do
-      ActiveSupport::Inflector.stub(:constantize => model)
+      allow(ActiveSupport::Inflector).to receive_messages(:constantize => model)
 
-      index.model.should == model
+      expect(index.model).to eq(model)
     end
 
     it "memoizes the result" do
-      ActiveSupport::Inflector.should_receive(:constantize).with('User').once.
+      expect(ActiveSupport::Inflector).to receive(:constantize).with('User').once.
         and_return(model)
 
       index.model
@@ -88,7 +87,7 @@ describe ThinkingSphinx::RealTime::Index do
 
   describe '#morphology' do
     before :each do
-      pending
+      skip
     end
 
     context 'with a render' do
@@ -98,7 +97,7 @@ describe ThinkingSphinx::RealTime::Index do
         rescue Riddle::Configuration::ConfigurationError
         end
 
-        index.morphology.should be_nil
+        expect(index.morphology).to be_nil
       end
 
       it "reads from the settings file if provided" do
@@ -109,7 +108,7 @@ describe ThinkingSphinx::RealTime::Index do
         rescue Riddle::Configuration::ConfigurationError
         end
 
-        index.morphology.should == 'stem_en'
+        expect(index.morphology).to eq('stem_en')
       end
     end
   end
@@ -117,21 +116,21 @@ describe ThinkingSphinx::RealTime::Index do
   describe '#name' do
     it "always uses the core suffix" do
       index = ThinkingSphinx::RealTime::Index.new :user
-      index.name.should == 'user_core'
+      expect(index.name).to eq('user_core')
     end
   end
 
   describe '#offset' do
     before :each do
-      config.stub :next_offset => 4
+      allow(config).to receive_messages :next_offset => 4
     end
 
     it "uses the next offset value from the configuration" do
-      index.offset.should == 4
+      expect(index.offset).to eq(4)
     end
 
     it "uses the reference to get a unique offset" do
-      config.should_receive(:next_offset).with(:user).and_return(2)
+      expect(config).to receive(:next_offset).with(:user).and_return(2)
 
       index.offset
     end
@@ -139,11 +138,11 @@ describe ThinkingSphinx::RealTime::Index do
 
   describe '#render' do
     before :each do
-      FileUtils.stub :mkdir_p => true
+      allow(FileUtils).to receive_messages :mkdir_p => true
     end
 
     it "interprets the provided definition" do
-      index.should_receive(:interpret_definition!).at_least(:once)
+      expect(index).to receive(:interpret_definition!).at_least(:once)
 
       begin
         index.render
@@ -157,23 +156,23 @@ describe ThinkingSphinx::RealTime::Index do
     let(:model)  { double('model') }
 
     it "returns the model by default" do
-      ActiveSupport::Inflector.stub(:constantize => model)
+      allow(ActiveSupport::Inflector).to receive_messages(:constantize => model)
 
-      index.scope.should == model
+      expect(index.scope).to eq(model)
     end
 
     it "returns the evaluated scope if provided" do
       index.scope = lambda { :foo }
 
-      index.scope.should == :foo
+      expect(index.scope).to eq(:foo)
     end
   end
 
   describe '#unique_attribute_names' do
     it "returns all attribute names" do
-      index.unique_attribute_names.should == [
+      expect(index.unique_attribute_names).to eq([
         'sphinx_internal_id', 'sphinx_internal_class', 'sphinx_deleted'
-      ]
+      ])
     end
   end
 end