thinking-sphinx 1.2.13 → 6.0.0

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

@@ -0,0 +1,128 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks do
+  let(:callbacks)  {
+    ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.new instance
+  }
+  let(:instance)   { double('instance', :delta? => true) }
+
+  describe '.after_destroy' do
+    let(:callbacks) { double('callbacks', :after_destroy => nil) }
+
+    before :each do
+      allow(ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks).
+        to receive_messages :new => callbacks
+    end
+
+    it "builds an object from the instance" do
+      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
+      expect(callbacks).to receive(:after_destroy)
+
+      ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
+        after_destroy(instance)
+    end
+  end
+
+  describe '#after_destroy' do
+    let(:index_set)  { double 'index set', :to_a => [index] }
+    let(:index)      { double('index', :name => 'foo_core', :primary_key => :id,
+      :document_id_for_key => 14, :type => 'plain', :distributed? => false) }
+    let(:instance)   { double('instance', :id => 7, :new_record? => false) }
+
+    before :each do
+      allow(ThinkingSphinx::IndexSet).to receive_messages :new => index_set
+    end
+
+    it "performs the deletion for the index and instance" do
+      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
+      allow(instance).to receive_messages :new_record? => true
+
+      expect(ThinkingSphinx::Deletion).not_to receive(:perform)
+
+      callbacks.after_destroy
+    end
+
+    it 'does nothing if callbacks are suspended' do
+      ThinkingSphinx::Callbacks.suspend!
+
+      expect(ThinkingSphinx::Deletion).not_to receive(:perform)
+
+      callbacks.after_destroy
+
+      ThinkingSphinx::Callbacks.resume!
+    end
+  end
+
+  describe '.after_rollback' do
+    let(:callbacks) { double('callbacks', :after_rollback => nil) }
+
+    before :each do
+      allow(ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks).
+        to receive_messages :new => callbacks
+    end
+
+    it "builds an object from the instance" do
+      expect(ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks).
+        to receive(:new).with(instance).and_return(callbacks)
+
+      ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
+        after_rollback(instance)
+    end
+
+    it "invokes after_rollback on the object" do
+      expect(callbacks).to receive(:after_rollback)
+
+      ThinkingSphinx::ActiveRecord::Callbacks::DeleteCallbacks.
+        after_rollback(instance)
+    end
+  end
+
+  describe '#after_rollback' do
+    let(:index_set)  { double 'index set', :to_a => [index] }
+    let(:index)      { double('index', :name => 'foo_core', :primary_key => :id,
+      :document_id_for_key => 14, :type => 'plain', :distributed? => false) }
+    let(:instance)   { double('instance', :id => 7, :new_record? => false) }
+
+    before :each do
+      allow(ThinkingSphinx::IndexSet).to receive_messages :new => index_set
+    end
+
+    it "performs the deletion for the index and instance" do
+      expect(ThinkingSphinx::Deletion).to receive(:perform).with(index, 7)
+
+      callbacks.after_rollback
+    end
+
+    it "doesn't do anything if the instance is a new record" do
+      allow(instance).to receive_messages :new_record? => true
+
+      expect(ThinkingSphinx::Deletion).not_to receive(:perform)
+
+      callbacks.after_rollback
+    end
+
+    it 'does nothing if callbacks are suspended' do
+      ThinkingSphinx::Callbacks.suspend!
+
+      expect(ThinkingSphinx::Deletion).not_to receive(:perform)
+
+      callbacks.after_rollback
+
+      ThinkingSphinx::Callbacks.resume!
+    end
+  end
+end

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

@@ -0,0 +1,176 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
+  let(:callbacks)  {
+    ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks.new instance
+  }
+  let(:instance)   { double('instance', :delta? => true) }
+  let(:config)     { double('config') }
+  let(:processor)  {
+    double('processor', :toggled? => true, :index => true, :delete => true)
+  }
+
+  before :each do
+    allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
+  end
+
+  [:after_commit, :before_save].each do |callback|
+    describe ".#{callback}" do
+      let(:callbacks) { double('callbacks', callback => nil) }
+
+      before :each do
+        allow(ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks).
+          to receive_messages :new => callbacks
+      end
+
+      it "builds an object from the instance" do
+        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
+        expect(callbacks).to receive(callback)
+
+        ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks.
+          send(callback, instance)
+      end
+    end
+  end
+
+  describe '#after_commit' do
+    let(:index) {
+      double('index', :delta? => false, :delta_processor => processor,
+        :type => 'plain')
+    }
+
+    before :each do
+      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
+        expect(processor).not_to receive(:index)
+
+        callbacks.after_commit
+      end
+
+      it "does not delete the instance from any index" do
+        expect(processor).not_to receive(:delete)
+
+        callbacks.after_commit
+      end
+    end
+
+    context 'with delta indices' do
+      let(:core_index) { double('index', :delta? => false, :name => 'foo_core',
+        :delta_processor => processor, :type => 'plain') }
+      let(:delta_index) { double('index', :delta? => true, :name => 'foo_delta',
+        :delta_processor => processor, :type => 'plain') }
+
+      before :each do
+        allow(ThinkingSphinx::Deltas).to receive_messages :suspended? => false
+
+        allow(config).to receive_messages :index_set_class => double(
+          :new => [core_index, delta_index]
+        )
+      end
+
+      it "only indexes delta indices" do
+        expect(processor).to receive(:index).with(delta_index)
+
+        callbacks.after_commit
+      end
+
+      it "does not process delta indices when deltas are suspended" do
+        allow(ThinkingSphinx::Deltas).to receive_messages :suspended? => true
+
+        expect(processor).not_to receive(:index)
+
+        callbacks.after_commit
+      end
+
+      it "deletes the instance from the core index" do
+        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
+        allow(processor).to receive_messages :toggled? => false
+
+        expect(processor).not_to receive(:index)
+
+        callbacks.after_commit
+      end
+
+      it "does not delete if model's delta flag is not true" do
+        allow(processor).to receive_messages :toggled? => false
+
+        expect(processor).not_to receive(:delete)
+
+        callbacks.after_commit
+      end
+
+      it "does not delete when deltas are suspended" do
+        allow(ThinkingSphinx::Deltas).to receive_messages :suspended? => true
+
+        expect(processor).not_to receive(:delete)
+
+        callbacks.after_commit
+      end
+    end
+  end
+
+  describe '#before_save' do
+    let(:index) {
+      double('index', :delta? => true, :delta_processor => processor,
+        :type => 'plain')
+    }
+
+    before :each do
+      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
+      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
+      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
+      )
+
+      expect(processor).to receive(:toggle)
+
+      callbacks.before_save
+    end
+  end
+end

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

@@ -0,0 +1,91 @@
+# frozen_string_literal: true
+
+module ThinkingSphinx
+  module ActiveRecord
+    module Callbacks; end
+  end
+end
+
+require 'active_support/core_ext/string/inflections'
+require 'thinking_sphinx/callbacks'
+require 'thinking_sphinx/errors'
+require 'thinking_sphinx/active_record/callbacks/update_callbacks'
+
+describe ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks do
+  describe '#after_update' do
+    let(:callbacks)     {
+      ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks.new instance }
+    let(:instance)      { double('instance', :class => klass, :id => 2) }
+    let(:klass)         { double(:name => 'Article') }
+    let(:configuration) { double('configuration',
+      :settings => {'attribute_updates' => true},
+      :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', :primary_key => :id}
+    let(:source)        { double('source', :attributes => []) }
+    let(:set_class)     { double(:reference_name => :article) }
+
+    before :each do
+      stub_const 'ThinkingSphinx::Configuration',
+        double(:instance => configuration)
+      stub_const 'ThinkingSphinx::Connection', double
+      stub_const 'Riddle::Query', double(:update => 'SphinxQL')
+
+      allow(ThinkingSphinx::Connection).to receive(:take).and_yield(connection)
+
+      source.attributes.replace([
+        double(:name => 'foo', :updateable? => true,
+          :columns => [double(:__name => 'foo_column')]),
+        double(:name => 'bar', :updateable? => true, :value_for => 7,
+          :columns => [double(:__name => 'bar_column')]),
+        double(:name => 'baz', :updateable? => false)
+      ])
+
+      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
+
+      expect(connection).not_to receive(:execute)
+
+      callbacks.after_update
+    end
+
+    it "builds an update query with only updateable attributes that have changed" do
+      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
+      expect(connection).to receive(:execute).with('SphinxQL')
+
+      callbacks.after_update
+    end
+
+    it "doesn't care if the update fails at Sphinx's end" do
+      allow(connection).to receive(:execute).
+        and_raise(ThinkingSphinx::ConnectionError.new(''))
+
+      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

@@ -0,0 +1,72 @@
+# 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)
+      expect(column.__name).to eq(:content)
+    end
+  end
+
+  describe '#__replace' do
+    let(:base)         { [:a, :b] }
+    let(:replacements) { [[:a, :c], [:a, :d]] }
+
+    it "returns itself when it's a string column" do
+      column = ThinkingSphinx::ActiveRecord::Column.new('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)
+      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)
+      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)
+      expect(column.__stack).to eq([:users, :posts])
+    end
+  end
+
+  describe '#method_missing' do
+    let(:column) { ThinkingSphinx::ActiveRecord::Column.new(:user) }
+
+    it "shifts the current name to the stack" do
+      column.email
+      expect(column.__stack).to eq([:user])
+    end
+
+    it "adds the new method call as the name" do
+      column.email
+      expect(column.__name).to eq(:email)
+    end
+
+    it "returns itself" do
+      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')
+      expect(column).to be_a_string
+    end
+
+    it "is false when the name is a symbol" do
+      column = ThinkingSphinx::ActiveRecord::Column.new(:content)
+      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

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::DatabaseAdapters::AbstractAdapter do
+  let(:adapter)    {
+    ThinkingSphinx::ActiveRecord::DatabaseAdapters::AbstractAdapter.new model
+  }
+  let(:model)      { double('model', :connection => connection) }
+  let(:connection) { double('connection') }
+
+  describe '#quote' do
+    it "uses the model's connection to quote columns" do
+      expect(connection).to receive(:quote_column_name).with('foo')
+
+      adapter.quote 'foo'
+    end
+
+    it "returns the quoted value" do
+      allow(connection).to receive_messages :quote_column_name => '"foo"'
+
+      expect(adapter.quote('foo')).to eq('"foo"')
+    end
+  end
+
+  describe '#quoted_table_name' do
+    it "passes the method through to the model" do
+      expect(model).to receive(:quoted_table_name).and_return('"articles"')
+
+      expect(adapter.quoted_table_name).to eq('"articles"')
+    end
+  end
+end

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

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter do
+  let(:adapter) {
+    ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter.new(model)
+  }
+  let(:model)   { double('model') }
+
+  it "returns 1 for true" do
+    expect(adapter.boolean_value(true)).to eq(1)
+  end
+
+  it "returns 0 for false" do
+    expect(adapter.boolean_value(false)).to eq(0)
+  end
+
+  describe '#cast_to_string' do
+    it "casts the clause to characters" do
+      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
+      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
+      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
+      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
+      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
+      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

@@ -0,0 +1,66 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter do
+  let(:adapter) {
+    ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter.new(model)
+  }
+  let(:model)   { double('model') }
+
+  describe '#boolean_value' do
+    it "returns 'TRUE' for true" do
+      expect(adapter.boolean_value(true)).to eq('TRUE')
+    end
+
+    it "returns 'FALSE' for false" do
+      expect(adapter.boolean_value(false)).to eq('FALSE')
+    end
+  end
+
+  describe '#cast_to_string' do
+    it "casts the clause to characters" do
+      expect(adapter.cast_to_string('foo')).to eq('foo::varchar')
+    end
+  end
+
+  describe '#cast_to_timestamp' do
+    it "converts to int unix timestamps" do
+      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
+
+      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
+      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
+      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
+      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
+      expect(adapter.group_concatenate('foo', ',')).
+        to eq("array_to_string(array_agg(DISTINCT foo), ',')")
+    end
+  end
+end