thinking-sphinx 3.1.4 → 6.0.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
@@ -9,15 +11,15 @@ describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
     :settings => {}) }
   let(:index)      { double('index', :name => 'my_index', :is_a? => true,
     :document_id_for_key => 123, :fields => [], :attributes => [],
-    :conditions => []) }
+    :conditions => [], :primary_key => :id) }
   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,32 +27,52 @@ 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).
-        with('my_index', ['id', 'name', 'created_at'], [123, 'Foo', time]).
+      expect(Riddle::Query::Insert).to receive(:new).
+        with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
         and_return(insert)
 
       callbacks.after_save instance
     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,24 +83,44 @@ 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).
-          with('my_index', ['id', 'name', 'created_at'], [123, 'Foo', time]).
+        expect(Riddle::Query::Insert).to receive(:new).
+          with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
           and_return(insert)
 
         callbacks.after_save instance
       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,26 +135,48 @@ 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.
-          with('my_index', ['id', 'name', 'created_at'], [123, 'Foo', time]).
+        expect(Riddle::Query::Insert).to receive(:new).twice.
+          with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
           and_return(insert)
 
         callbacks.after_save instance
       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,26 +191,48 @@ 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.
-          with('my_index', ['id', 'name', 'created_at'], [123, 'Foo', time]).
+        expect(Riddle::Query::Insert).to receive(:new).twice.
+          with('my_index', ['id', 'name', 'created_at'], [[123, 'Foo', time]]).
           and_return(insert)
 
         callbacks.after_save instance
       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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::RealTime::Field do
@@ -6,11 +8,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 +22,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 +36,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

@@ -1,47 +1,98 @@
+# frozen_string_literal: true
+
 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,
+    :index_set_class => index_set_class) }
+  let(:index_set_class) { double(:index_set_class, :reference_name => :user) }
 
   before :each do
-    ThinkingSphinx::Configuration.stub :instance => config
+    allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
+  end
+
+  describe '#add_attribute' do
+    let(:attribute) { double('attribute', name: 'my_attribute') }
+
+    it "appends attributes to the collection" do
+      index.add_attribute attribute
+
+      expect(index.attributes.collect(&:name)).to include('my_attribute')
+    end
+
+    it "replaces attributes with the same name" do
+      index.add_attribute double('attribute', name: 'my_attribute')
+      index.add_attribute attribute
+
+      matching = index.attributes.select { |attr| attr.name == attribute.name }
+
+      expect(matching).to eq([attribute])
+    end
+  end
+
+  describe '#add_field' do
+    let(:field) { double('field', name: 'my_field') }
+
+    it "appends fields to the collection" do
+      index.add_field field
+
+      expect(index.fields.collect(&:name)).to include('my_field')
+    end
+
+    it "replaces fields with the same name" do
+      index.add_field double('field', name: 'my_field')
+      index.add_field field
+
+      matching = index.fields.select { |fld| fld.name == field.name }
+
+      expect(matching).to eq([field])
+    end
   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
+
+    it "does not have an internal updated_at attribute by default" do
+      expect(index.attributes.collect(&:name)).to_not include('sphinx_updated_at')
+    end
+
+    it "has an internal updated_at attribute if real_time_tidy is true" do
+      config.settings["real_time_tidy"] = true
+
+      expect(index.attributes.collect(&:name)).to include('sphinx_updated_at')
     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 +104,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!
@@ -69,16 +120,16 @@ describe ThinkingSphinx::RealTime::Index do
   end
 
   describe '#model' do
-    let(:model)  { double('model') }
+    let(:model)  { double('model', :primary_key => :id) }
 
     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 +139,7 @@ describe ThinkingSphinx::RealTime::Index do
 
   describe '#morphology' do
     before :each do
-      pending
+      skip
     end
 
     context 'with a render' do
@@ -98,7 +149,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 +160,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 +168,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 +190,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
@@ -154,26 +205,26 @@ describe ThinkingSphinx::RealTime::Index do
   end
 
   describe '#scope' do
-    let(:model)  { double('model') }
+    let(:model)  { double('model', :primary_key => :id) }
 
     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