thinking-sphinx 3.1.4 → 6.0.0

data/spec/thinking_sphinx/connection/mri_spec.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+RSpec.describe ThinkingSphinx::Connection::MRI do
+  subject { described_class.new :host => "127.0.0.1", :port => 9306 }
+
+  let(:client) { double :client, :query => "result", :next_result => false }
+
+  before :each do
+    allow(Mysql2::Client).to receive(:new).and_return(client)
+  end
+
+  after :each do
+    ThinkingSphinx::Configuration.reset
+  end
+
+  describe "#execute" do
+    it "sends the query to the client" do
+      subject.execute "SELECT QUERY"
+
+      expect(client).to have_received(:query).with("SELECT QUERY")
+    end
+
+    it "returns a result" do
+      expect(subject.execute("SELECT QUERY")).to eq("result")
+    end
+
+    context "with long queries" do
+      let(:maximum)    { (2 ** 23) - 5 }
+      let(:query)      { String.new "SELECT * FROM book_core WHERE MATCH('')" }
+      let(:difference) { maximum - query.length }
+
+      it 'does not allow overly long queries' do
+        expect {
+          subject.execute(query.insert(-3, 'a' * (difference + 5)))
+        }.to raise_error(ThinkingSphinx::QueryLengthError)
+      end
+
+      it 'does not allow queries longer than specified in the settings' do
+        ThinkingSphinx::Configuration.reset
+
+        write_configuration('maximum_statement_length' => maximum - 5)
+
+        expect {
+          subject.execute(query.insert(-3, 'a' * (difference)))
+        }.to raise_error(ThinkingSphinx::QueryLengthError)
+      end
+    end
+  end
+end if RUBY_PLATFORM != 'java'

data/spec/thinking_sphinx/connection_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::Connection do
@@ -8,9 +10,9 @@ describe ThinkingSphinx::Connection do
     let(:translated_error) { ThinkingSphinx::SphinxError.new }
 
     before :each do
-      ThinkingSphinx::Connection.stub :pool => pool
-      ThinkingSphinx::SphinxError.stub :new_from_mysql => translated_error
-      pool.stub(:take).and_yield(connection)
+      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'
@@ -18,41 +20,41 @@ describe ThinkingSphinx::Connection do
 
     it "yields a connection from the pool" do
       ThinkingSphinx::Connection.take do |c|
-        c.should == connection
+        expect(c).to eq(connection)
       end
     end
 
     it "retries errors once" do
       tries = 0
 
-      lambda {
+      expect {
         ThinkingSphinx::Connection.take do |c|
           tries += 1
           raise error if tries < 2
         end
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     it "retries errors twice" do
       tries = 0
 
-      lambda {
+      expect {
         ThinkingSphinx::Connection.take do |c|
           tries += 1
           raise error if tries < 3
         end
-      }.should_not raise_error
+      }.not_to raise_error
     end
 
     it "raises a translated error if it fails three times" do
       tries = 0
 
-      lambda {
+      expect {
         ThinkingSphinx::Connection.take do |c|
           tries += 1
           raise error if tries < 4
         end
-      }.should raise_error(ThinkingSphinx::SphinxError)
+      }.to raise_error(ThinkingSphinx::SphinxError)
     end
 
     [ThinkingSphinx::SyntaxError, ThinkingSphinx::ParseError].each do |klass|
@@ -60,9 +62,9 @@ describe ThinkingSphinx::Connection do
         let(:translated_error) { klass.new }
 
         it "raises the error" do
-          lambda {
+          expect {
             ThinkingSphinx::Connection.take { |c| raise error }
-          }.should raise_error(klass)
+          }.to raise_error(klass)
         end
 
         it "does not yield the connection more than once" do
@@ -77,7 +79,7 @@ describe ThinkingSphinx::Connection do
             #
           end
 
-          yields.should == 1
+          expect(yields).to eq(1)
         end
       end
     end

data/spec/thinking_sphinx/deletion_spec.rb

@@ -1,56 +1,56 @@
+# 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',
-      :document_id_for_key => 14, :type => 'plain', :distributed? => false) }
+      :type => 'plain', :distributed? => false) }
 
     before :each do
-      ThinkingSphinx::Connection.stub(:take).and_yield(connection)
-      Riddle::Query.stub :update => 'UPDATE STATEMENT'
+      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
-        connection.should_receive(:execute).with <<-SQL
-UPDATE foo_core
-SET sphinx_deleted = 1
-WHERE id IN (14)
-        SQL
+        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
-        connection.stub(:execute).
+        allow(connection).to receive(:execute).
           and_raise(ThinkingSphinx::ConnectionError.new(''))
 
-        lambda {
+        expect {
           ThinkingSphinx::Deletion.perform index, 7
-        }.should_not raise_error
+        }.not_to raise_error
       end
     end
 
     context "index is real-time" do
       before :each do
-        index.stub :type => 'rt'
+        allow(index).to receive_messages :type => 'rt'
       end
 
       it "deletes the record to false" do
-        connection.should_receive(:execute).
-          with('DELETE FROM foo_core WHERE id = 14')
+        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
-        connection.stub(:execute).
+        allow(connection).to receive(:execute).
           and_raise(ThinkingSphinx::ConnectionError.new(''))
 
-        lambda {
+        expect {
           ThinkingSphinx::Deletion.perform index, 7
-        }.should_not raise_error
+        }.not_to raise_error
       end
     end
   end

data/spec/thinking_sphinx/deltas/default_delta_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::Deltas::DefaultDelta do
@@ -9,11 +11,11 @@ describe ThinkingSphinx::Deltas::DefaultDelta do
   describe '#clause' do
     context 'for a delta source' do
       before :each do
-        adapter.stub :boolean_value => 't'
+        allow(adapter).to receive_messages :boolean_value => 't'
       end
 
       it "limits results to those flagged as deltas" do
-        delta.clause(true).should == "articles.delta = t"
+        expect(delta.clause(true)).to eq("articles.delta = t")
       end
     end
   end
@@ -21,46 +23,46 @@ describe ThinkingSphinx::Deltas::DefaultDelta do
   describe '#delete' do
     let(:connection) { double('connection', :execute => nil) }
     let(:index)      { double('index', :name => 'foo_core',
-      :document_id_for_key => 14) }
+      :document_id_for_instance => 14) }
     let(:instance)   { double('instance', :id => 7) }
 
     before :each do
-      ThinkingSphinx::Connection.stub(:take).and_yield(connection)
-      Riddle::Query.stub :update => 'UPDATE STATEMENT'
+      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
-      connection.should_receive(:execute).with('UPDATE STATEMENT')
+      expect(connection).to receive(:execute).with('UPDATE STATEMENT')
 
       delta.delete index, instance
     end
 
     it "builds the update query for the given index" do
-      Riddle::Query.should_receive(:update).
+      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
-      Riddle::Query.should_receive(:update).
+      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
-      Riddle::Query.should_receive(:update).
+      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
-      connection.stub(:execute).
+      allow(connection).to receive(:execute).
         and_raise(ThinkingSphinx::ConnectionError.new(''))
 
-      lambda { delta.delete index, instance }.should_not raise_error
+      expect { delta.delete index, instance }.not_to raise_error
     end
   end
 
@@ -68,13 +70,18 @@ describe ThinkingSphinx::Deltas::DefaultDelta do
     let(:config)     { double('config', :controller => controller,
       :settings => {}) }
     let(:controller) { double('controller') }
+    let(:commander)  { double('commander', :call => true) }
 
     before :each do
-      ThinkingSphinx::Configuration.stub :instance => config
+      stub_const 'ThinkingSphinx::Commander', commander
+
+      allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
     end
 
     it "indexes the given index" do
-      controller.should_receive(:index).with('foo_delta', :verbose => true)
+      expect(commander).to receive(:call).with(
+        :index_sql, config, :indices => ['foo_delta'], :verbose => false
+      )
 
       delta.index double('index', :name => 'foo_delta')
     end
@@ -82,9 +89,9 @@ describe ThinkingSphinx::Deltas::DefaultDelta do
 
   describe '#reset_query' do
     it "updates the table to set delta flags to false" do
-      adapter.stub(:boolean_value) { |value| value ? 't' : 'f' }
-      delta.reset_query.
-        should == 'UPDATE articles SET delta = f WHERE delta = t'
+      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
 
@@ -92,7 +99,7 @@ describe ThinkingSphinx::Deltas::DefaultDelta do
     let(:instance) { double('instance') }
 
     it "sets instance's delta flag to true" do
-      instance.should_receive(:delta=).with(true)
+      expect(instance).to receive(:delta=).with(true)
 
       delta.toggle(instance)
     end
@@ -102,15 +109,15 @@ describe ThinkingSphinx::Deltas::DefaultDelta do
     let(:instance) { double('instance') }
 
     it "returns the delta flag value when true" do
-      instance.stub! :delta? => true
+      allow(instance).to receive_messages :delta? => true
 
-      delta.toggled?(instance).should be_true
+      expect(delta.toggled?(instance)).to be_truthy
     end
 
     it "returns the delta flag value when false" do
-      instance.stub! :delta? => false
+      allow(instance).to receive_messages :delta? => false
 
-      delta.toggled?(instance).should be_false
+      expect(delta.toggled?(instance)).to be_falsey
     end
   end
 end

data/spec/thinking_sphinx/deltas_spec.rb

@@ -1,21 +1,23 @@
+# 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
-      ThinkingSphinx::Deltas.processor_for(true).
-        should == ThinkingSphinx::Deltas::DefaultDelta
+      expect(ThinkingSphinx::Deltas.processor_for(true)).
+        to eq(ThinkingSphinx::Deltas::DefaultDelta)
     end
 
     it "returns the class when given one" do
       klass = Class.new
-      ThinkingSphinx::Deltas.processor_for(klass).should == klass
+      expect(ThinkingSphinx::Deltas.processor_for(klass)).to eq(klass)
     end
 
     it "instantiates a class from the name as a string" do
-      ThinkingSphinx::Deltas.
-        processor_for('ThinkingSphinx::Deltas::DefaultDelta').
-        should == ThinkingSphinx::Deltas::DefaultDelta
+      expect(ThinkingSphinx::Deltas.
+        processor_for('ThinkingSphinx::Deltas::DefaultDelta')).
+        to eq(ThinkingSphinx::Deltas::DefaultDelta)
     end
   end
 
@@ -29,7 +31,7 @@ describe ThinkingSphinx::Deltas do
     let(:processor)   { double('processor', :index => true) }
 
     before :each do
-      ThinkingSphinx::Configuration.stub :instance => config
+      allow(ThinkingSphinx::Configuration).to receive_messages :instance => config
     end
 
     it "executes the given block" do
@@ -39,12 +41,12 @@ describe ThinkingSphinx::Deltas do
         variable = :bar
       end
 
-      variable.should == :bar
+      expect(variable).to eq(:bar)
     end
 
     it "suspends deltas within the block" do
       ThinkingSphinx::Deltas.suspend :user do
-        ThinkingSphinx::Deltas.should be_suspended
+        expect(ThinkingSphinx::Deltas).to be_suspended
       end
     end
 
@@ -53,11 +55,11 @@ describe ThinkingSphinx::Deltas do
         #
       end
 
-      ThinkingSphinx::Deltas.should_not be_suspended
+      expect(ThinkingSphinx::Deltas).not_to be_suspended
     end
 
     it "processes the delta indices for the given reference" do
-      processor.should_receive(:index).with(delta_index)
+      expect(processor).to receive(:index).with(delta_index)
 
       ThinkingSphinx::Deltas.suspend :user do
         #
@@ -65,7 +67,7 @@ describe ThinkingSphinx::Deltas do
     end
 
     it "does not process the core indices for the given reference" do
-      processor.should_not_receive(:index).with(core_index)
+      expect(processor).not_to receive(:index).with(core_index)
 
       ThinkingSphinx::Deltas.suspend :user do
         #

data/spec/thinking_sphinx/errors_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::SphinxError do
@@ -6,66 +8,96 @@ describe ThinkingSphinx::SphinxError do
       :backtrace => ['foo', 'bar'] }
 
     it "translates syntax errors" do
-      error.stub :message => 'index foo: syntax error: something is wrong'
+      allow(error).to receive_messages :message => 'index foo: syntax error: something is wrong'
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).
-        should be_a(ThinkingSphinx::SyntaxError)
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::SyntaxError)
     end
 
     it "translates parse errors" do
-      error.stub :message => 'index foo: parse error: something is wrong'
+      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
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).
-        should be_a(ThinkingSphinx::ParseError)
+    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
-      error.stub :message => 'index foo: query error: something is wrong'
+      allow(error).to receive_messages :message => 'index foo: query error: something is wrong'
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).
-        should be_a(ThinkingSphinx::QueryError)
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::QueryError)
     end
 
     it "translates connection errors" do
-      error.stub :message => "Can't connect to MySQL server on '127.0.0.1' (61)"
+      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)"
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).
-        should be_a(ThinkingSphinx::ConnectionError)
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::OutOfBoundsError)
     end
 
     it 'prefixes the connection error message' do
-      error.stub :message => "Can't connect to MySQL server on '127.0.0.1' (61)"
+      allow(error).to receive_messages :message => "Can't connect to MySQL server on '127.0.0.1' (61)"
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).message.
-        should == "Error connecting to Sphinx via the MySQL protocol. 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
-      error.stub :message => "Communications link failure"
+      allow(error).to receive_messages :message => "Communications link failure"
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).
-        should be_a(ThinkingSphinx::ConnectionError)
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::ConnectionError)
     end
 
     it 'prefixes the jdbc connection error message' do
-      error.stub :message => "Communications link failure"
+      allow(error).to receive_messages :message => "Communications link failure"
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).message.
-        should == "Error connecting to Sphinx via the MySQL protocol. 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
-      error.stub :message => 'index foo: unknown error: something is wrong'
+      allow(error).to receive_messages :message => 'index foo: unknown error: something is wrong'
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).
-        should be_a(ThinkingSphinx::SphinxError)
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error)).
+        to be_a(ThinkingSphinx::SphinxError)
     end
 
     it "keeps the original error's backtrace" do
-      error.stub :message => 'index foo: unknown error: something is wrong'
+      allow(error).to receive_messages :message => 'index foo: unknown error: something is wrong'
 
-      ThinkingSphinx::SphinxError.new_from_mysql(error).
-        backtrace.should == error.backtrace
+      expect(ThinkingSphinx::SphinxError.new_from_mysql(error).
+        backtrace).to eq(error.backtrace)
     end
   end
 end

data/spec/thinking_sphinx/excerpter_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::Excerpter do
@@ -7,13 +9,13 @@ describe ThinkingSphinx::Excerpter do
   }
 
   before :each do
-    ThinkingSphinx::Connection.stub(:take).and_yield(connection)
-    Riddle::Query.stub :snippets => 'CALL SNIPPETS'
+    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
-      Riddle::Query.should_receive(:snippets).
+      expect(Riddle::Query).to receive(:snippets).
         with('all of the words', 'index', 'all words',
           ThinkingSphinx::Excerpter::DefaultOptions).
         and_return('CALL SNIPPETS')
@@ -25,26 +27,27 @@ describe ThinkingSphinx::Excerpter do
       excerpter = ThinkingSphinx::Excerpter.new('index', 'all words',
         :before_match => '<b>', :chunk_separator => ' -- ')
 
-      Riddle::Query.should_receive(:snippets).
-        with('all of the words', 'index', 'all words',
+      expect(Riddle::Query).to receive(:snippets).
+        with('all of the words', 'index', 'all words', {
           :before_match => '<b>', :after_match => '</span>',
-          :chunk_separator => ' -- ').
+          :chunk_separator => ' -- '
+        }).
         and_return('CALL SNIPPETS')
 
       excerpter.excerpt!('all of the words')
     end
 
     it "sends the snippets call to Sphinx" do
-      connection.should_receive(:execute).with('CALL SNIPPETS').
+      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
-      connection.stub :execute => [{'snippet' => 'some highlighted words'}]
+      allow(connection).to receive_messages :execute => [{'snippet' => 'some highlighted words'}]
 
-      excerpter.excerpt!('all of the words').should == 'some highlighted words'
+      expect(excerpter.excerpt!('all of the words')).to eq('some highlighted words')
     end
   end
 end