thinking-sphinx 1.2.13 → 6.0.0

data/spec/thinking_sphinx/connection_spec.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::Connection do
+  describe '.take' do
+    let(:pool)             { double 'pool' }
+    let(:connection)       { double 'connection', :base_error => StandardError }
+    let(:error)            { ThinkingSphinx::QueryExecutionError.new 'failed' }
+    let(:translated_error) { ThinkingSphinx::SphinxError.new }
+
+    before :each do
+      allow(ThinkingSphinx::Connection).to receive_messages :pool => pool
+      allow(ThinkingSphinx::SphinxError).to receive_messages :new_from_mysql => translated_error
+      allow(pool).to receive(:take).and_yield(connection)
+
+      error.statement            = 'SELECT * FROM article_core'
+      translated_error.statement = 'SELECT * FROM article_core'
+    end
+
+    it "yields a connection from the pool" do
+      ThinkingSphinx::Connection.take do |c|
+        expect(c).to eq(connection)
+      end
+    end
+
+    it "retries errors once" do
+      tries = 0
+
+      expect {
+        ThinkingSphinx::Connection.take do |c|
+          tries += 1
+          raise error if tries < 2
+        end
+      }.not_to raise_error
+    end
+
+    it "retries errors twice" do
+      tries = 0
+
+      expect {
+        ThinkingSphinx::Connection.take do |c|
+          tries += 1
+          raise error if tries < 3
+        end
+      }.not_to raise_error
+    end
+
+    it "raises a translated error if it fails three times" do
+      tries = 0
+
+      expect {
+        ThinkingSphinx::Connection.take do |c|
+          tries += 1
+          raise error if tries < 4
+        end
+      }.to raise_error(ThinkingSphinx::SphinxError)
+    end
+
+    [ThinkingSphinx::SyntaxError, ThinkingSphinx::ParseError].each do |klass|
+      context klass.name do
+        let(:translated_error) { klass.new }
+
+        it "raises the error" do
+          expect {
+            ThinkingSphinx::Connection.take { |c| raise error }
+          }.to raise_error(klass)
+        end
+
+        it "does not yield the connection more than once" do
+          yields = 0
+
+          begin
+            ThinkingSphinx::Connection.take do |c|
+              yields += 1
+              raise error
+            end
+          rescue klass
+            #
+          end
+
+          expect(yields).to eq(1)
+        end
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/deletion_spec.rb

@@ -0,0 +1,57 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::Deletion do
+  describe '.perform' do
+    let(:connection) { double('connection', :execute => nil) }
+    let(:index)      { double('index', :name => 'foo_core',
+      :type => 'plain', :distributed? => false) }
+
+    before :each do
+      allow(ThinkingSphinx::Connection).to receive(:take).and_yield(connection)
+      allow(Riddle::Query).to receive_messages :update => 'UPDATE STATEMENT'
+    end
+
+    context 'index is SQL-backed' do
+      it "updates the deleted flag to false" do
+        expect(connection).to receive(:execute).with(
+          'UPDATE foo_core SET sphinx_deleted = 1 WHERE sphinx_internal_id IN (7)'
+        )
+
+        ThinkingSphinx::Deletion.perform index, 7
+      end
+
+      it "doesn't care about Sphinx errors" do
+        allow(connection).to receive(:execute).
+          and_raise(ThinkingSphinx::ConnectionError.new(''))
+
+        expect {
+          ThinkingSphinx::Deletion.perform index, 7
+        }.not_to raise_error
+      end
+    end
+
+    context "index is real-time" do
+      before :each do
+        allow(index).to receive_messages :type => 'rt'
+      end
+
+      it "deletes the record to false" do
+        expect(connection).to receive(:execute).
+          with('DELETE FROM foo_core WHERE sphinx_internal_id IN (7)')
+
+        ThinkingSphinx::Deletion.perform index, 7
+      end
+
+      it "doesn't care about Sphinx errors" do
+        allow(connection).to receive(:execute).
+          and_raise(ThinkingSphinx::ConnectionError.new(''))
+
+        expect {
+          ThinkingSphinx::Deletion.perform index, 7
+        }.not_to raise_error
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/deltas/default_delta_spec.rb

@@ -0,0 +1,123 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::Deltas::DefaultDelta do
+  let(:delta)   { ThinkingSphinx::Deltas::DefaultDelta.new adapter }
+  let(:adapter) {
+    double('adapter', :quoted_table_name => 'articles', :quote => 'delta')
+  }
+
+  describe '#clause' do
+    context 'for a delta source' do
+      before :each do
+        allow(adapter).to receive_messages :boolean_value => 't'
+      end
+
+      it "limits results to those flagged as deltas" do
+        expect(delta.clause(true)).to eq("articles.delta = t")
+      end
+    end
+  end
+
+  describe '#delete' do
+    let(:connection) { double('connection', :execute => nil) }
+    let(:index)      { double('index', :name => 'foo_core',
+      :document_id_for_instance => 14) }
+    let(:instance)   { double('instance', :id => 7) }
+
+    before :each do
+      allow(ThinkingSphinx::Connection).to receive(:take).and_yield(connection)
+      allow(Riddle::Query).to receive_messages :update => 'UPDATE STATEMENT'
+    end
+
+    it "updates the deleted flag to false" do
+      expect(connection).to receive(:execute).with('UPDATE STATEMENT')
+
+      delta.delete index, instance
+    end
+
+    it "builds the update query for the given index" do
+      expect(Riddle::Query).to receive(:update).
+        with('foo_core', anything, anything).and_return('')
+
+      delta.delete index, instance
+    end
+
+    it "builds the update query for the sphinx document id" do
+      expect(Riddle::Query).to receive(:update).
+        with(anything, 14, anything).and_return('')
+
+      delta.delete index, instance
+    end
+
+    it "builds the update query for setting sphinx_deleted to true" do
+      expect(Riddle::Query).to receive(:update).
+        with(anything, anything, :sphinx_deleted => true).and_return('')
+
+      delta.delete index, instance
+    end
+
+    it "doesn't care about Sphinx errors" do
+      allow(connection).to receive(:execute).
+        and_raise(ThinkingSphinx::ConnectionError.new(''))
+
+      expect { delta.delete index, instance }.not_to raise_error
+    end
+  end
+
+  describe '#index' do
+    let(:config)     { double('config', :controller => controller,
+      :settings => {}) }
+    let(:controller) { double('controller') }
+    let(:commander)  { double('commander', :call => true) }
+
+    before :each do
+      stub_const 'ThinkingSphinx::Commander', commander
+
+      allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
+    end
+
+    it "indexes the given index" do
+      expect(commander).to receive(:call).with(
+        :index_sql, config, :indices => ['foo_delta'], :verbose => false
+      )
+
+      delta.index double('index', :name => 'foo_delta')
+    end
+  end
+
+  describe '#reset_query' do
+    it "updates the table to set delta flags to false" do
+      allow(adapter).to receive(:boolean_value) { |value| value ? 't' : 'f' }
+      expect(delta.reset_query).
+        to eq('UPDATE articles SET delta = f WHERE delta = t')
+    end
+  end
+
+  describe '#toggle' do
+    let(:instance) { double('instance') }
+
+    it "sets instance's delta flag to true" do
+      expect(instance).to receive(:delta=).with(true)
+
+      delta.toggle(instance)
+    end
+  end
+
+  describe '#toggled?' do
+    let(:instance) { double('instance') }
+
+    it "returns the delta flag value when true" do
+      allow(instance).to receive_messages :delta? => true
+
+      expect(delta.toggled?(instance)).to be_truthy
+    end
+
+    it "returns the delta flag value when false" do
+      allow(instance).to receive_messages :delta? => false
+
+      expect(delta.toggled?(instance)).to be_falsey
+    end
+  end
+end

data/spec/thinking_sphinx/deltas_spec.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::Deltas do
+  describe '.processor_for' do
+    it "returns the default processor class when given true" do
+      expect(ThinkingSphinx::Deltas.processor_for(true)).
+        to eq(ThinkingSphinx::Deltas::DefaultDelta)
+    end
+
+    it "returns the class when given one" do
+      klass = Class.new
+      expect(ThinkingSphinx::Deltas.processor_for(klass)).to eq(klass)
+    end
+
+    it "instantiates a class from the name as a string" do
+      expect(ThinkingSphinx::Deltas.
+        processor_for('ThinkingSphinx::Deltas::DefaultDelta')).
+        to eq(ThinkingSphinx::Deltas::DefaultDelta)
+    end
+  end
+
+  describe '.suspend' do
+    let(:config)      { double('config',
+      :indices_for_references => [core_index, delta_index]) }
+    let(:core_index)  { double('index', :name => 'user_core',
+      :delta_processor => processor, :delta? => false) }
+    let(:delta_index) { double('index', :name => 'user_core',
+      :delta_processor => processor, :delta? => true) }
+    let(:processor)   { double('processor', :index => true) }
+
+    before :each do
+      allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
+    end
+
+    it "executes the given block" do
+      variable = :foo
+
+      ThinkingSphinx::Deltas.suspend :user do
+        variable = :bar
+      end
+
+      expect(variable).to eq(:bar)
+    end
+
+    it "suspends deltas within the block" do
+      ThinkingSphinx::Deltas.suspend :user do
+        expect(ThinkingSphinx::Deltas).to be_suspended
+      end
+    end
+
+    it "removes the suspension after the block" do
+      ThinkingSphinx::Deltas.suspend :user do
+        #
+      end
+
+      expect(ThinkingSphinx::Deltas).not_to be_suspended
+    end
+
+    it "processes the delta indices for the given reference" do
+      expect(processor).to receive(:index).with(delta_index)
+
+      ThinkingSphinx::Deltas.suspend :user do
+        #
+      end
+    end
+
+    it "does not process the core indices for the given reference" do
+      expect(processor).not_to receive(:index).with(core_index)
+
+      ThinkingSphinx::Deltas.suspend :user do
+        #
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/errors_spec.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::SphinxError do
+  describe '.new_from_mysql' do
+    let(:error) { double 'error', :message => 'index foo: unknown error',
+      :backtrace => ['foo', 'bar'] }
+
+    it "translates syntax errors" do
+      allow(error).to receive_messages :message => 'index foo: syntax error: something is wrong'
+
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::SyntaxError)
+    end
+
+    it "translates parse errors" do
+      allow(error).to receive_messages :message => 'index foo: parse error: something is wrong'
+
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::ParseError)
+    end
+
+    it "translates 'query is non-computable' errors" do
+      allow(error).to receive_messages :message => 'index model_core: query is non-computable (single NOT operator)'
+
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::ParseError)
+    end
+
+    it "translates query errors" do
+      allow(error).to receive_messages :message => 'index foo: query error: something is wrong'
+
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::QueryError)
+    end
+
+    it "translates connection errors" do
+      allow(error).to receive_messages :message => "Can't connect to MySQL server on '127.0.0.1' (61)"
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::ConnectionError)
+
+      allow(error).to receive_messages :message => "Communications link failure"
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::ConnectionError)
+
+      allow(error).to receive_messages :message => "Lost connection to MySQL server"
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::ConnectionError)
+
+      # MariaDB has removed mention of MySQL in error messages:
+      allow(error).to receive_messages :message => "Can't connect to server on '127.0.0.1' (61)"
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::ConnectionError)
+
+      allow(error).to receive_messages :message => "Lost connection to server"
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::ConnectionError)
+    end
+
+    it 'translates out-of-bounds errors' do
+      allow(error).to receive_messages :message => "offset out of bounds (offset=1001, max_matches=1000)"
+
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::OutOfBoundsError)
+    end
+
+    it 'prefixes the connection error message' do
+      allow(error).to receive_messages :message => "Can't connect to MySQL server on '127.0.0.1' (61)"
+
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error).message).
+        to eq("Error connecting to Sphinx via the MySQL protocol. Can't connect to MySQL server on '127.0.0.1' (61)")
+    end
+
+    it "translates jdbc connection errors" do
+      allow(error).to receive_messages :message => "Communications link failure"
+
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::ConnectionError)
+    end
+
+    it 'prefixes the jdbc connection error message' do
+      allow(error).to receive_messages :message => "Communications link failure"
+
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error).message).
+        to eq("Error connecting to Sphinx via the MySQL protocol. Communications link failure")
+    end
+
+    it "defaults to sphinx errors" do
+      allow(error).to receive_messages :message => 'index foo: unknown error: something is wrong'
+
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::SphinxError)
+    end
+
+    it "keeps the original error's backtrace" do
+      allow(error).to receive_messages :message => 'index foo: unknown error: something is wrong'
+
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error).
+        backtrace).to eq(error.backtrace)
+    end
+  end
+end

data/spec/thinking_sphinx/excerpter_spec.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::Excerpter do
+  let(:excerpter)  { ThinkingSphinx::Excerpter.new('index', 'all words') }
+  let(:connection) {
+    double('connection', :execute => [{'snippet' => 'some highlighted words'}])
+  }
+
+  before :each do
+    allow(ThinkingSphinx::Connection).to receive(:take).and_yield(connection)
+    allow(Riddle::Query).to receive_messages :snippets => 'CALL SNIPPETS'
+  end
+
+  describe '#excerpt!' do
+    it "generates a snippets call" do
+      expect(Riddle::Query).to receive(:snippets).
+        with('all of the words', 'index', 'all words',
+          ThinkingSphinx::Excerpter::DefaultOptions).
+        and_return('CALL SNIPPETS')
+
+      excerpter.excerpt!('all of the words')
+    end
+
+    it "respects the provided options" do
+      excerpter = ThinkingSphinx::Excerpter.new('index', 'all words',
+        :before_match => '<b>', :chunk_separator => ' -- ')
+
+      expect(Riddle::Query).to receive(:snippets).
+        with('all of the words', 'index', 'all words', {
+          :before_match => '<b>', :after_match => '</span>',
+          :chunk_separator => ' -- '
+        }).
+        and_return('CALL SNIPPETS')
+
+      excerpter.excerpt!('all of the words')
+    end
+
+    it "sends the snippets call to Sphinx" do
+      expect(connection).to receive(:execute).with('CALL SNIPPETS').
+        and_return([{'snippet' => ''}])
+
+      excerpter.excerpt!('all of the words')
+    end
+
+    it "returns the first value returned by Sphinx" do
+      allow(connection).to receive_messages :execute => [{'snippet' => 'some highlighted words'}]
+
+      expect(excerpter.excerpt!('all of the words')).to eq('some highlighted words')
+    end
+  end
+end

data/spec/thinking_sphinx/facet_search_spec.rb

@@ -0,0 +1,133 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+describe ThinkingSphinx::FacetSearch do
+  let(:facet_search)  { ThinkingSphinx::FacetSearch.new '', {} }
+  let(:batch)         { double('batch', :searches => [], :populate => true) }
+  let(:index_set)     { [] }
+  let(:index)         { double('index', :facets => [property_a, property_b],
+    :name => 'foo_core') }
+  let(:property_a)    { double('property', :name => 'price_bracket',
+    :multi? => false) }
+  let(:property_b)    { double('property', :name => 'category_id',
+    :multi? => false) }
+  let(:configuration) { double 'configuration', :settings => {}, :index_set_class => double(:new => index_set) }
+
+  before :each do
+    stub_const 'ThinkingSphinx::BatchedSearch', double(:new => batch)
+    stub_const 'ThinkingSphinx::Search',        DumbSearch
+    stub_const 'ThinkingSphinx::Middlewares::RAW_ONLY', double
+    stub_const 'ThinkingSphinx::Configuration',
+      double(:instance => configuration)
+
+    index_set << index << double('index', :facets => [], :name => 'bar_core')
+  end
+
+  DumbSearch = ::Struct.new(:query, :options) do
+    def raw
+      [{
+        'sphinx_internal_class' => 'Foo',
+        'price_bracket'         => 3,
+        'tag_ids'               => '1,2',
+        'category_id'           => 11,
+        "sphinx_internal_count" => 5,
+        "sphinx_internal_group" => 2
+      }]
+    end
+  end
+
+  describe '#[]' do
+    it "populates facet results" do
+      expect(facet_search[:price_bracket]).to eq({3 => 5})
+    end
+  end
+
+  describe '#populate' do
+    it "queries on each facet with a grouped search in a batch" do
+      facet_search.populate
+
+      expect(batch.searches.detect { |search|
+        search.options[:group_by] == 'price_bracket'
+      }).not_to be_nil
+    end
+
+    it "limits query for a facet to just indices that have that facet" do
+      facet_search.populate
+
+      expect(batch.searches.detect { |search|
+        search.options[:indices] == ['foo_core']
+      }).not_to be_nil
+    end
+
+    it "limits facets to the specified set" do
+      facet_search.options[:facets] = [:category_id]
+
+      facet_search.populate
+
+      expect(batch.searches.collect { |search|
+        search.options[:group_by]
+      }).to eq(['category_id'])
+    end
+
+    it "aliases the class facet from sphinx_internal_class" do
+      allow(property_a).to receive_messages :name => 'sphinx_internal_class'
+
+      facet_search.populate
+
+      expect(facet_search[:class]).to eq({'Foo' => 5})
+    end
+
+    it "uses the @groupby value for MVAs" do
+      allow(property_a).to receive_messages :name => 'tag_ids', :multi? => true
+
+      facet_search.populate
+
+      expect(facet_search[:tag_ids]).to eq({2 => 5})
+    end
+
+    [:max_matches, :limit].each do |setting|
+      it "sets #{setting} in each search" do
+        facet_search.populate
+
+        batch.searches.each { |search|
+          expect(search.options[setting]).to eq(1000)
+        }
+      end
+
+      it "respects configured max_matches values for #{setting}" do
+        configuration.settings['max_matches'] = 1234
+
+        facet_search.populate
+
+        batch.searches.each { |search|
+          expect(search.options[setting]).to eq(1234)
+        }
+      end
+    end
+
+    [:limit, :per_page].each do |setting|
+      it "respects #{setting} option if set" do
+        facet_search = ThinkingSphinx::FacetSearch.new '', {setting => 42}
+
+        facet_search.populate
+
+        batch.searches.each { |search|
+          expect(search.options[setting]).to eq(42)
+        }
+      end
+
+      it "allows separate #{setting} and max_matches settings to support pagination" do
+        configuration.settings['max_matches'] = 500
+        facet_search = ThinkingSphinx::FacetSearch.new '', {setting => 10}
+
+        facet_search.populate
+
+        batch.searches.each do |search|
+          expect(search.options[setting]).to eq(10)
+          expect(search.options[:max_matches]).to eq(500)
+        end
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/hooks/guard_presence_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require "spec_helper"
+
+RSpec.describe ThinkingSphinx::Hooks::GuardPresence do
+  let(:subject) do
+    ThinkingSphinx::Hooks::GuardPresence.new configuration, stream
+  end
+  let(:configuration) { double "configuration", :indices_location => "/path" }
+  let(:stream)        { double "stream", :puts => nil }
+
+  describe "#call" do
+    it "outputs nothing if no guard files exist" do
+      allow(Dir).to receive(:[]).with('/path/ts-*.tmp').and_return([])
+
+      expect(stream).not_to receive(:puts)
+
+      subject.call
+    end
+
+    it "outputs a warning if a guard file exists" do
+      allow(Dir).to receive(:[]).with('/path/ts-*.tmp').
+        and_return(['/path/ts-foo.tmp'])
+
+      expect(stream).to receive(:puts)
+
+      subject.call
+    end
+  end
+end