thinking-sphinx 3.1.4 → 6.0.0

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
@@ -11,7 +13,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 +21,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)
@@ -42,22 +44,23 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
 
   describe '#after_commit' do
     let(:index) {
-      double('index', :delta? => false, :delta_processor => processor)
+      double('index', :delta? => false, :delta_processor => processor,
+        :type => 'plain')
     }
 
     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
@@ -65,58 +68,58 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
 
     context 'with delta indices' do
       let(:core_index) { double('index', :delta? => false, :name => 'foo_core',
-        :delta_processor => processor) }
+        :delta_processor => processor, :type => 'plain') }
       let(:delta_index) { double('index', :delta? => true, :name => 'foo_delta',
-        :delta_processor => processor) }
+        :delta_processor => processor, :type => 'plain') }
 
       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
@@ -125,23 +128,47 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
 
   describe '#before_save' do
     let(:index) {
-      double('index', :delta? => true, :delta_processor => processor)
+      double('index', :delta? => true, :delta_processor => processor,
+        :type => 'plain')
     }
 
     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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   module ActiveRecord
     module Callbacks; end
@@ -17,12 +19,13 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks do
     let(:klass)         { double(:name => 'Article') }
     let(:configuration) { double('configuration',
       :settings => {'attribute_updates' => true},
-      :indices_for_references => [index]) }
+      :indices_for_references => [index], :index_set_class => set_class) }
     let(:connection)    { double('connection', :execute => '') }
     let(:index)         { double 'index', :name => 'article_core',
       :sources => [source], :document_id_for_key => 3, :distributed? => false,
-      :type => 'plain'}
+      :type => 'plain', :primary_key => :id}
     let(:source)        { double('source', :attributes => []) }
+    let(:set_class)     { double(:reference_name => :article) }
 
     before :each do
       stub_const 'ThinkingSphinx::Configuration',
@@ -30,7 +33,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,35 +43,49 @@ 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,
+        :saved_changes => {'bar_column' => [1, 2], 'baz' => [3, 4]}
+      )
     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).
-        with('article_core', 3, 'bar' => 7).and_return('SphinxQL')
+      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!
+
+      expect(connection).not_to receive(:execute)
+
+      callbacks.after_update
+
+      ThinkingSphinx::Callbacks.resume!
     end
   end
 end

data/spec/thinking_sphinx/active_record/column_spec.rb

@@ -1,10 +1,12 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 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 +16,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 +45,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

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::ColumnSQLPresenter do
+  describe '#with_table' do
+    let(:model)        { double 'Model' }
+    let(:column)       { double 'Column', :__name => 'column_name',
+      :__stack => [], :string? => false }
+    let(:adapter)      { double 'Adapter' }
+    let(:associations) { double 'Associations' }
+    let(:path)         { double 'Path',
+      :model => double(:column_names => ['column_name']) }
+    let(:presenter) { ThinkingSphinx::ActiveRecord::ColumnSQLPresenter.new(
+      model, column, adapter, associations
+    ) }
+
+    before do
+      stub_const 'Joiner::Path', double(:new => path)
+      allow(adapter).to receive(:quote) { |arg| "`#{arg}`" }
+    end
+
+    context "when there's no explicit db name" do
+      before { allow(associations).to receive_messages(:alias_for => 'table_name') }
+
+      it 'returns quoted table and column names' do
+        expect(presenter.with_table).to eq('`table_name`.`column_name`')
+      end
+    end
+
+    context 'when an eplicit db name is provided' do
+      before { allow(associations).to receive_messages(:alias_for => 'db_name.table_name') }
+
+      it 'returns properly quoted table name with column name' do
+        expect(presenter.with_table).to eq('`db_name`.`table_name`.`column_name`')
+      end
+    end
+  end
+end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::DatabaseAdapters::AbstractAdapter do
@@ -9,23 +11,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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter do
@@ -7,50 +9,62 @@ 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
+
+  describe '#utf8_query_pre' do
+    it "defaults to using utf8" do
+      expect(adapter.utf8_query_pre).to eq(["SET NAMES utf8"])
+    end
+
+    it "allows custom values" do
+      ThinkingSphinx::Configuration.instance.settings['mysql_encoding'] =
+        'utf8mb4'
+
+      expect(adapter.utf8_query_pre).to eq(["SET NAMES utf8mb4"])
     end
   end
 end

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

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter do
@@ -8,57 +10,57 @@ describe ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter do
 
   describe '#boolean_value' do
     it "returns 'TRUE' for true" do
-      adapter.boolean_value(true).should == 'TRUE'
+      expect(adapter.boolean_value(true)).to eq('TRUE')
     end
 
     it "returns 'FALSE' for false" do
-      adapter.boolean_value(false).should == 'FALSE'
+      expect(adapter.boolean_value(false)).to eq('FALSE')
     end
   end
 
   describe '#cast_to_string' do
     it "casts the clause to characters" do
-      adapter.cast_to_string('foo').should == 'foo::varchar'
+      expect(adapter.cast_to_string('foo')).to eq('foo::varchar')
     end
   end
 
   describe '#cast_to_timestamp' do
     it "converts to int unix timestamps" do
-      adapter.cast_to_timestamp('created_at').
-        should == 'extract(epoch from created_at)::int'
+      expect(adapter.cast_to_timestamp('created_at')).
+        to eq('extract(epoch from created_at)::int')
     end
 
     it "converts to bigint unix timestamps" do
       ThinkingSphinx::Configuration.instance.settings['64bit_timestamps'] = true
 
-      adapter.cast_to_timestamp('created_at').
-        should == 'extract(epoch from created_at)::bigint'
+      expect(adapter.cast_to_timestamp('created_at')).
+        to eq('extract(epoch from created_at)::bigint')
     end
   end
 
   describe '#concatenate' do
     it "concatenates with the given separator" do
-      adapter.concatenate('foo, bar, baz', ',').
-        should == "COALESCE(foo, '') || ',' || COALESCE(bar, '') || ',' || COALESCE(baz, '')"
+      expect(adapter.concatenate('foo, bar, baz', ',')).
+        to eq("COALESCE(foo, '') || ',' || COALESCE(bar, '') || ',' || COALESCE(baz, '')")
     end
   end
 
   describe '#convert_nulls' do
     it "translates arguments to a COALESCE SQL call" do
-      adapter.convert_nulls('id', 5).should == 'COALESCE(id, 5)'
+      expect(adapter.convert_nulls('id', 5)).to eq('COALESCE(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 == "array_to_string(array_agg(DISTINCT foo), ',')"
+      expect(adapter.group_concatenate('foo', ',')).
+        to eq("array_to_string(array_agg(DISTINCT foo), ',')")
     end
   end
 end