thinking-sphinx 3.1.4 → 6.0.0

data/spec/thinking_sphinx/active_record/index_spec.rb

@@ -1,46 +1,50 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::Index do
   let(:index)        { ThinkingSphinx::ActiveRecord::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 :reference_name => :user }
 
   before :each do
-    ThinkingSphinx::Configuration.stub :instance => config
+    allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
   end
 
   describe '#append_source' do
-    let(:model)  { double('model', :primary_key => :id) }
+    let(:model)  { double('model', :primary_key => :id,
+      :table_exists? => true) }
     let(:source) { double('source') }
 
     before :each do
-      ActiveSupport::Inflector.stub(:constantize => model)
-      ThinkingSphinx::ActiveRecord::SQLSource.stub :new => source
-      config.stub :next_offset => 17
+      allow(ActiveSupport::Inflector).to receive_messages(:constantize => model)
+      allow(ThinkingSphinx::ActiveRecord::SQLSource).to receive_messages :new => source
+      allow(config).to receive_messages :next_offset => 17
     end
 
     it "adds a source to the index" do
-      index.sources.should_receive(:<<).with(source)
+      expect(index.sources).to receive(:<<).with(source)
 
       index.append_source
     end
 
     it "creates the source with the index's offset" do
-      ThinkingSphinx::ActiveRecord::SQLSource.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::SQLSource).to receive(:new).
         with(model, hash_including(:offset => 17)).and_return(source)
 
       index.append_source
     end
 
     it "returns the new source" do
-      index.append_source.should == source
+      expect(index.append_source).to eq(source)
     end
 
     it "defaults to the model's primary key" do
-      model.stub :primary_key => :sphinx_id
+      allow(model).to receive_messages :primary_key => :sphinx_id
 
-      ThinkingSphinx::ActiveRecord::SQLSource.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::SQLSource).to receive(:new).
         with(model, hash_including(:primary_key => :sphinx_id)).
         and_return(source)
 
@@ -48,9 +52,9 @@ describe ThinkingSphinx::ActiveRecord::Index do
     end
 
     it "uses a custom column when set" do
-      model.stub :primary_key => :sphinx_id
+      allow(model).to receive_messages :primary_key => :sphinx_id
 
-      ThinkingSphinx::ActiveRecord::SQLSource.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::SQLSource).to receive(:new).
         with(model, hash_including(:primary_key => :custom_sphinx_id)).
         and_return(source)
 
@@ -60,9 +64,9 @@ describe ThinkingSphinx::ActiveRecord::Index do
     end
 
     it "defaults to id if no primary key is set" do
-      model.stub :primary_key => nil
+      allow(model).to receive_messages :primary_key => nil
 
-      ThinkingSphinx::ActiveRecord::SQLSource.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::SQLSource).to receive(:new).
         with(model, hash_including(:primary_key => :id)).
         and_return(source)
 
@@ -72,12 +76,12 @@ describe ThinkingSphinx::ActiveRecord::Index do
 
   describe '#delta?' do
     it "defaults to false" do
-      index.should_not be_delta
+      expect(index).not_to be_delta
     end
 
     it "reflects the delta? option" do
       index = ThinkingSphinx::ActiveRecord::Index.new :user, :delta? => true
-      index.should be_delta
+      expect(index).to be_delta
     end
   end
 
@@ -88,16 +92,16 @@ describe ThinkingSphinx::ActiveRecord::Index do
       index = ThinkingSphinx::ActiveRecord::Index.new :user,
         :delta_processor => processor_class
 
-      index.delta_processor.should == processor
+      expect(index.delta_processor).to eq(processor)
     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
 
@@ -109,14 +113,14 @@ describe ThinkingSphinx::ActiveRecord::Index do
     end
 
     it "interprets the definition block" do
-      ThinkingSphinx::ActiveRecord::Interpreter.should_receive(:translate!).
+      expect(ThinkingSphinx::ActiveRecord::Interpreter).to receive(:translate!).
         with(index, block)
 
       index.interpret_definition!
     end
 
     it "only interprets the definition block once" do
-      ThinkingSphinx::ActiveRecord::Interpreter.should_receive(:translate!).
+      expect(ThinkingSphinx::ActiveRecord::Interpreter).to receive(:translate!).
         once
 
       index.interpret_definition!
@@ -128,13 +132,13 @@ describe ThinkingSphinx::ActiveRecord::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
@@ -145,7 +149,7 @@ describe ThinkingSphinx::ActiveRecord::Index do
   describe '#morphology' do
     context 'with a render' do
       before :each do
-        FileUtils.stub :mkdir_p => true
+        allow(FileUtils).to receive_messages :mkdir_p => true
       end
 
       it "defaults to nil" do
@@ -154,7 +158,7 @@ describe ThinkingSphinx::ActiveRecord::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
@@ -165,7 +169,7 @@ describe ThinkingSphinx::ActiveRecord::Index do
         rescue Riddle::Configuration::ConfigurationError
         end
 
-        index.morphology.should == 'stem_en'
+        expect(index.morphology).to eq('stem_en')
       end
     end
   end
@@ -173,26 +177,26 @@ describe ThinkingSphinx::ActiveRecord::Index do
   describe '#name' do
     it "uses the core suffix by default" do
       index = ThinkingSphinx::ActiveRecord::Index.new :user
-      index.name.should == 'user_core'
+      expect(index.name).to eq('user_core')
     end
 
     it "uses the delta suffix when delta? is true" do
       index = ThinkingSphinx::ActiveRecord::Index.new :user, :delta? => true
-      index.name.should == 'user_delta'
+      expect(index.name).to eq('user_delta')
     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
@@ -200,11 +204,11 @@ describe ThinkingSphinx::ActiveRecord::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

data/spec/thinking_sphinx/active_record/interpreter_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::Interpreter do
@@ -13,23 +15,28 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
   let(:block)   { Proc.new { } }
 
   before :each do
-    ThinkingSphinx::ActiveRecord::SQLSource.stub! :new => source
-    source.stub :model => model
+    allow(ThinkingSphinx::ActiveRecord::SQLSource).to receive_messages(
+      :new => source
+    )
+
+    allow(source).to receive_messages(
+      :model => model, :add_attribute => nil, :add_field => nil
+    )
   end
 
   describe '.translate!' do
     let(:instance) { double('interpreter', :translate! => true) }
 
     it "creates a new interpreter instance with the given block and index" do
-      ThinkingSphinx::ActiveRecord::Interpreter.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::Interpreter).to receive(:new).
         with(index, block).and_return(instance)
 
       ThinkingSphinx::ActiveRecord::Interpreter.translate! index, block
     end
 
     it "calls translate! on the instance" do
-      ThinkingSphinx::ActiveRecord::Interpreter.stub!(:new => instance)
-      instance.should_receive(:translate!)
+      allow(ThinkingSphinx::ActiveRecord::Interpreter).to receive_messages(:new => instance)
+      expect(instance).to receive(:translate!)
 
       ThinkingSphinx::ActiveRecord::Interpreter.translate! index, block
     end
@@ -37,13 +44,13 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
 
   describe '#group_by' do
     it "adds a source to the index" do
-      index.should_receive(:append_source).and_return(source)
+      expect(index).to receive(:append_source).and_return(source)
 
       instance.group_by 'lat'
     end
 
     it "only adds a single source for the given context" do
-      index.should_receive(:append_source).once.and_return(source)
+      expect(index).to receive(:append_source).once.and_return(source)
 
       instance.group_by 'lat'
       instance.group_by 'lng'
@@ -52,7 +59,7 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
     it "appends a new grouping statement to the source" do
       instance.group_by 'lat'
 
-      source.groupings.should include('lat')
+      expect(source.groupings).to include('lat')
     end
   end
 
@@ -61,48 +68,46 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
     let(:attribute) { double('attribute') }
 
     before :each do
-      ThinkingSphinx::ActiveRecord::Attribute.stub! :new => attribute
+      allow(ThinkingSphinx::ActiveRecord::Attribute).to receive_messages :new => attribute
     end
 
     it "adds a source to the index" do
-      index.should_receive(:append_source).and_return(source)
+      expect(index).to receive(:append_source).and_return(source)
 
       instance.has column
     end
 
     it "only adds a single source for the given context" do
-      index.should_receive(:append_source).once.and_return(source)
+      expect(index).to receive(:append_source).once.and_return(source)
 
       instance.has column
       instance.has column
     end
 
     it "creates a new attribute with the provided column" do
-      ThinkingSphinx::ActiveRecord::Attribute.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::Attribute).to receive(:new).
         with(model, column, {}).and_return(attribute)
 
       instance.has column
     end
 
     it "passes through options to the attribute" do
-      ThinkingSphinx::ActiveRecord::Attribute.should_receive(:new).
-        with(model, column, :as => :other_name).and_return(attribute)
+      expect(ThinkingSphinx::ActiveRecord::Attribute).to receive(:new).
+        with(model, column, { :as => :other_name }).and_return(attribute)
 
       instance.has column, :as => :other_name
     end
 
     it "adds an attribute to the source" do
-      instance.has column
+      expect(source).to receive(:add_attribute).with(attribute)
 
-      source.attributes.should include(attribute)
+      instance.has column
     end
 
     it "adds multiple attributes when passed multiple columns" do
-      instance.has column, column
+      expect(source).to receive(:add_attribute).with(attribute).twice
 
-      source.attributes.select { |saved_attribute|
-        saved_attribute == attribute
-      }.length.should == 2
+      instance.has column, column
     end
   end
 
@@ -111,48 +116,46 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
     let(:field)  { double('field') }
 
     before :each do
-      ThinkingSphinx::ActiveRecord::Field.stub! :new => field
+      allow(ThinkingSphinx::ActiveRecord::Field).to receive_messages :new => field
     end
 
     it "adds a source to the index" do
-      index.should_receive(:append_source).and_return(source)
+      expect(index).to receive(:append_source).and_return(source)
 
       instance.indexes column
     end
 
     it "only adds a single source for the given context" do
-      index.should_receive(:append_source).once.and_return(source)
+      expect(index).to receive(:append_source).once.and_return(source)
 
       instance.indexes column
       instance.indexes column
     end
 
     it "creates a new field with the provided column" do
-      ThinkingSphinx::ActiveRecord::Field.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::Field).to receive(:new).
         with(model, column, {}).and_return(field)
 
       instance.indexes column
     end
 
     it "passes through options to the field" do
-      ThinkingSphinx::ActiveRecord::Field.should_receive(:new).
-        with(model, column, :as => :other_name).and_return(field)
+      expect(ThinkingSphinx::ActiveRecord::Field).to receive(:new).
+        with(model, column, { :as => :other_name }).and_return(field)
 
       instance.indexes column, :as => :other_name
     end
 
     it "adds a field to the source" do
-      instance.indexes column
+      expect(source).to receive(:add_field).with(field)
 
-      source.fields.should include(field)
+      instance.indexes column
     end
 
     it "adds multiple fields when passed multiple columns" do
-      instance.indexes column, column
+      expect(source).to receive(:add_field).with(field).twice
 
-      source.fields.select { |saved_field|
-        saved_field == field
-      }.length.should == 2
+      instance.indexes column, column
     end
   end
 
@@ -161,24 +164,24 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
     let(:association) { double('association') }
 
     before :each do
-      ThinkingSphinx::ActiveRecord::Association.stub! :new => association
+      allow(ThinkingSphinx::ActiveRecord::Association).to receive_messages :new => association
     end
 
     it "adds a source to the index" do
-      index.should_receive(:append_source).and_return(source)
+      expect(index).to receive(:append_source).and_return(source)
 
       instance.join column
     end
 
     it "only adds a single source for the given context" do
-      index.should_receive(:append_source).once.and_return(source)
+      expect(index).to receive(:append_source).once.and_return(source)
 
       instance.join column
       instance.join column
     end
 
     it "creates a new association with the provided column" do
-      ThinkingSphinx::ActiveRecord::Association.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::Association).to receive(:new).
         with(column).and_return(association)
 
       instance.join column
@@ -187,15 +190,15 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
     it "adds an association to the source" do
       instance.join column
 
-      source.associations.should include(association)
+      expect(source.associations).to include(association)
     end
 
     it "adds multiple fields when passed multiple columns" do
       instance.join column, column
 
-      source.associations.select { |saved_assoc|
+      expect(source.associations.select { |saved_assoc|
         saved_assoc == association
-      }.length.should == 2
+      }.length).to eq(2)
     end
   end
 
@@ -203,15 +206,15 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
     let(:column) { double('column') }
 
     before :each do
-      ThinkingSphinx::ActiveRecord::Column.stub!(:new => column)
+      allow(ThinkingSphinx::ActiveRecord::Column).to receive_messages(:new => column)
     end
 
     it "returns a new column for the given method" do
-      instance.id.should == column
+      expect(instance.id).to eq(column)
     end
 
     it "should initialise the column with the method name and arguments" do
-      ThinkingSphinx::ActiveRecord::Column.should_receive(:new).
+      expect(ThinkingSphinx::ActiveRecord::Column).to receive(:new).
         with(:users, :posts, :subject).and_return(column)
 
       instance.users(:posts, :subject)
@@ -220,26 +223,26 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
 
   describe '#set_database' do
     before :each do
-      source.stub :set_database_settings => true
+      allow(source).to receive_messages :set_database_settings => true
 
       stub_const 'ActiveRecord::Base',
         double(:configurations => {'other' => {'baz' => 'qux'}})
     end
 
     it "sends through a hash if provided" do
-      source.should_receive(:set_database_settings).with(:foo => :bar)
+      expect(source).to receive(:set_database_settings).with({ :foo => :bar })
 
       instance.set_database :foo => :bar
     end
 
     it "finds the environment settings if given a string key" do
-      source.should_receive(:set_database_settings).with(:baz => 'qux')
+      expect(source).to receive(:set_database_settings).with({ :baz => 'qux' })
 
       instance.set_database 'other'
     end
 
     it "finds the environment settings if given a symbol key" do
-      source.should_receive(:set_database_settings).with(:baz => 'qux')
+      expect(source).to receive(:set_database_settings).with({ :baz => 'qux' })
 
       instance.set_database :other
     end
@@ -247,19 +250,19 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
 
   describe '#set_property' do
     before :each do
-      index.class.stub  :settings => [:morphology]
-      source.class.stub :settings => [:mysql_ssl_cert]
+      allow(index.class).to receive_messages  :settings => [:morphology]
+      allow(source.class).to receive_messages :settings => [:mysql_ssl_cert]
     end
 
     it 'saves other settings as index options' do
       instance.set_property :field_weights => {:name => 10}
 
-      index.options[:field_weights].should == {:name => 10}
+      expect(index.options[:field_weights]).to eq({:name => 10})
     end
 
     context 'index settings' do
       it "sets the provided setting" do
-        index.should_receive(:morphology=).with('stem_en')
+        expect(index).to receive(:morphology=).with('stem_en')
 
         instance.set_property :morphology => 'stem_en'
       end
@@ -267,24 +270,24 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
 
     context 'source settings' do
       before :each do
-        source.stub :mysql_ssl_cert= => true
+        allow(source).to receive_messages :mysql_ssl_cert= => true
       end
 
       it "adds a source to the index" do
-        index.should_receive(:append_source).and_return(source)
+        expect(index).to receive(:append_source).and_return(source)
 
         instance.set_property :mysql_ssl_cert => 'private.cert'
       end
 
       it "only adds a single source for the given context" do
-        index.should_receive(:append_source).once.and_return(source)
+        expect(index).to receive(:append_source).once.and_return(source)
 
         instance.set_property :mysql_ssl_cert => 'private.cert'
         instance.set_property :mysql_ssl_cert => 'private.cert'
       end
 
       it "sets the provided setting" do
-        source.should_receive(:mysql_ssl_cert=).with('private.cert')
+        expect(source).to receive(:mysql_ssl_cert=).with('private.cert')
 
         instance.set_property :mysql_ssl_cert => 'private.cert'
       end
@@ -298,20 +301,20 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
       }
 
       interpreter = ThinkingSphinx::ActiveRecord::Interpreter.new index, block
-      interpreter.translate!.
-        should == interpreter.__id__
+      expect(interpreter.translate!).
+        to eq(interpreter.__id__)
     end
   end
 
   describe '#where' do
     it "adds a source to the index" do
-      index.should_receive(:append_source).and_return(source)
+      expect(index).to receive(:append_source).and_return(source)
 
       instance.where 'id > 100'
     end
 
     it "only adds a single source for the given context" do
-      index.should_receive(:append_source).once.and_return(source)
+      expect(index).to receive(:append_source).once.and_return(source)
 
       instance.where 'id > 100'
       instance.where 'id < 150'
@@ -320,7 +323,7 @@ describe ThinkingSphinx::ActiveRecord::Interpreter do
     it "appends a new grouping statement to the source" do
       instance.where 'id > 100'
 
-      source.conditions.should include('id > 100')
+      expect(source.conditions).to include('id > 100')
     end
   end
 end

data/spec/thinking_sphinx/active_record/polymorpher_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::Polymorpher do
@@ -23,29 +25,29 @@ describe ThinkingSphinx::ActiveRecord::Polymorpher do
     let(:animal_reflection)  { double 'Animal Reflection' }
 
     before :each do
-      ThinkingSphinx::ActiveRecord::FilterReflection.
-        stub(:call).
+      allow(ThinkingSphinx::ActiveRecord::FilterReflection).
+        to receive(:call).
         and_return(article_reflection, animal_reflection)
 
-      model.stub(:reflect_on_association) do |name|
+      allow(model).to receive(:reflect_on_association) do |name|
         name == :foo ? reflection : nil
       end
 
       if ActiveRecord::Reflection.respond_to?(:add_reflection)
-        ActiveRecord::Reflection.stub :add_reflection
+        allow(ActiveRecord::Reflection).to receive :add_reflection
       end
     end
 
     it "creates a new reflection for each class" do
-      ThinkingSphinx::ActiveRecord::FilterReflection.
-        unstub :call
+      allow(ThinkingSphinx::ActiveRecord::FilterReflection).
+        to receive(:call).and_call_original
 
-      ThinkingSphinx::ActiveRecord::FilterReflection.
-        should_receive(:call).
+      expect(ThinkingSphinx::ActiveRecord::FilterReflection).
+        to receive(:call).
         with(reflection, :foo_article, 'Article').
         and_return(article_reflection)
-      ThinkingSphinx::ActiveRecord::FilterReflection.
-        should_receive(:call).
+      expect(ThinkingSphinx::ActiveRecord::FilterReflection).
+        to receive(:call).
         with(reflection, :foo_animal, 'Animal').
         and_return(animal_reflection)
 
@@ -54,9 +56,9 @@ describe ThinkingSphinx::ActiveRecord::Polymorpher do
 
     it "adds the new reflections to the end-of-stack model" do
       if ActiveRecord::Reflection.respond_to?(:add_reflection)
-        ActiveRecord::Reflection.should_receive(:add_reflection).
+        expect(ActiveRecord::Reflection).to receive(:add_reflection).
           with(model, :foo_article, article_reflection)
-        ActiveRecord::Reflection.should_receive(:add_reflection).
+        expect(ActiveRecord::Reflection).to receive(:add_reflection).
           with(model, :foo_animal, animal_reflection)
 
         polymorpher.morph!
@@ -69,14 +71,14 @@ describe ThinkingSphinx::ActiveRecord::Polymorpher do
     end
 
     it "rebases each field" do
-      field.should_receive(:rebase).with([:a, :b, :foo],
+      expect(field).to receive(:rebase).with([:a, :b, :foo],
         :to => [[:a, :b, :foo_article], [:a, :b, :foo_animal]])
 
       polymorpher.morph!
     end
 
     it "rebases each attribute" do
-      attribute.should_receive(:rebase).with([:a, :b, :foo],
+      expect(attribute).to receive(:rebase).with([:a, :b, :foo],
         :to => [[:a, :b, :foo_article], [:a, :b, :foo_animal]])
 
       polymorpher.morph!