thinking-sphinx 3.3.0 → 3.4.0

data/spec/acceptance/sql_deltas_spec.rb

@@ -41,6 +41,18 @@ describe 'SQL delta indexing', :live => true do
     expect(Book.search('Harry')).to be_empty
   end
 
+  it "does not match on old values with alternative ids" do
+    album = Album.create :name => 'Eternal Nightcap', :artist => 'The Whitloms'
+    index
+
+    expect(Album.search('Whitloms').to_a).to eq([album])
+
+    album.reload.update_attributes(:artist => 'The Whitlams')
+    sleep 0.25
+
+    expect(Book.search('Whitloms')).to be_empty
+  end
+
   it "automatically indexes new records of subclasses" do
     book = Hardcover.create(
       :title => 'American Gods', :author => 'Neil Gaiman'

data/spec/internal/app/indices/album_index.rb

@@ -0,0 +1,3 @@
+ThinkingSphinx::Index.define :album, :with => :active_record, :primary_key => :integer_id, :delta => true do
+  indexes name, artist
+end

data/spec/internal/app/models/album.rb

@@ -0,0 +1,19 @@
+class Album < ActiveRecord::Base
+  self.primary_key = :id
+
+  before_validation :set_id, :on => :create
+  before_validation :set_integer_id, :on => :create
+
+  validates :id,         :presence => true, :uniqueness => true
+  validates :integer_id, :presence => true, :uniqueness => true
+
+  private
+
+  def set_id
+    self.id = (Album.maximum(:id) || "a").next
+  end
+
+  def set_integer_id
+    self.integer_id = (Album.maximum(:integer_id) || 0) + 1
+  end
+end

data/spec/internal/db/schema.rb

@@ -4,6 +4,14 @@ ActiveRecord::Schema.define do
     t.timestamps null: false
   end
 
+  create_table(:albums, :force => true, :id => false) do |t|
+    t.string :id
+    t.integer :integer_id
+    t.string :name
+    t.string :artist
+    t.boolean :delta, :default => true, :null => false
+  end
+
   create_table(:animals, :force => true) do |t|
     t.string :name
     t.string :type

data/spec/spec_helper.rb

@@ -18,4 +18,8 @@ RSpec.configure do |config|
   # enable filtering for examples
   config.filter_run :wip => nil
   config.run_all_when_everything_filtered = true
+
+  config.around :each, :live do |example|
+    example.run_with_retry :retry => 3
+  end
 end

data/spec/support/json_column.rb

@@ -6,7 +6,7 @@ class JSONColumn
   end
 
   def call
-    sphinx? && postgresql? && column?
+    ruby? && sphinx? && postgresql? && column?
   end
 
   private
@@ -27,6 +27,10 @@ class JSONColumn
     ENV['DATABASE'] == 'postgresql'
   end
 
+  def ruby?
+    RUBY_PLATFORM != 'java'
+  end
+
   def sphinx?
     ENV['SPHINX_VERSION'].nil? || ENV['SPHINX_VERSION'].to_f > 2.0
   end

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

@@ -40,7 +40,11 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::UpdateCallbacks do
         double(:name => 'baz', :updateable? => false)
       ])
 
-      allow(instance).to receive_messages :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

data/spec/thinking_sphinx/active_record/sql_source_spec.rb

@@ -159,6 +159,12 @@ describe ThinkingSphinx::ActiveRecord::SQLSource do
       expect(source.options[:utf8?]).to be_truthy
     end
 
+    it "sets utf8? to true if the database encoding starts with utf8" do
+      db_config[:encoding] = 'utf8mb4'
+
+      expect(source.options[:utf8?]).to be_truthy
+    end
+
     describe "#primary key" do
       let(:model)  { double('model', :connection => connection,
                            :name => 'User', :column_names => [], :inheritance_column => 'type') }

data/spec/thinking_sphinx/attribute_types_spec.rb

@@ -0,0 +1,50 @@
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::AttributeTypes do
+  let(:configuration) {
+    double('configuration', :configuration_file => 'sphinx.conf')
+  }
+
+  before :each do
+    allow(ThinkingSphinx::Configuration).to receive(:instance).
+      and_return(configuration)
+
+    allow(File).to receive(:exist?).with('sphinx.conf').and_return(true)
+    allow(File).to receive(:read).with('sphinx.conf').and_return(<<-CONF)
+index plain_index
+{
+  source = plain_source
+}
+
+source plain_source
+{
+  type = mysql
+  sql_attr_uint = customer_id
+  sql_attr_float = price
+  sql_attr_multi = uint comment_ids from field
+}
+
+index rt_index
+{
+  type = rt
+  rt_attr_uint = user_id
+  rt_attr_multi = comment_ids
+}
+    CONF
+  end
+
+  it 'returns an empty hash if no configuration file exists' do
+    allow(File).to receive(:exist?).with('sphinx.conf').and_return(false)
+
+    expect(ThinkingSphinx::AttributeTypes.new.call).to eq({})
+  end
+
+  it 'returns all known attributes' do
+    expect(ThinkingSphinx::AttributeTypes.new.call).to eq({
+      'customer_id' => [:uint],
+      'price'       => [:float],
+      'comment_ids' => [:uint],
+      'user_id'     => [:uint]
+    })
+  end
+end

data/spec/thinking_sphinx/commands/configure_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Commands::Configure do
+  let(:command)    { ThinkingSphinx::Commands::Configure.new(
+    configuration, {}, stream
+  ) }
+  let(:configuration) { double 'configuration' }
+  let(:stream)        { double :puts => nil }
+
+  before :each do
+    allow(configuration).to receive_messages(
+      :configuration_file => '/path/to/foo.conf',
+      :render_to_file     => true
+    )
+  end
+
+  it "renders the configuration to a file" do
+    expect(configuration).to receive(:render_to_file)
+
+    command.call
+  end
+
+  it "prints a message stating the file is being generated" do
+    expect(stream).to receive(:puts).
+      with('Generating configuration to /path/to/foo.conf')
+
+    command.call
+  end
+end

data/spec/thinking_sphinx/commands/index_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Commands::Index do
+  let(:command)    { ThinkingSphinx::Commands::Index.new(
+    configuration, {:verbose => true}, stream
+  ) }
+  let(:configuration) { double 'configuration', :controller => controller }
+  let(:controller)    { double 'controller', :index => true }
+  let(:stream)        { double :puts => nil }
+
+  it "indexes all indices verbosely" do
+    expect(controller).to receive(:index).with(:verbose => true)
+
+    command.call
+  end
+
+  it "does not index verbosely if requested" do
+    command = ThinkingSphinx::Commands::Index.new(
+      configuration, {:verbose => false}, stream
+    )
+
+    expect(controller).to receive(:index).with(:verbose => false)
+
+    command.call
+  end
+end

data/spec/thinking_sphinx/commands/start_detached_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Commands::StartDetached do
+  let(:command)    {
+    ThinkingSphinx::Commands::StartDetached.new(configuration, {}, stream)
+  }
+  let(:configuration) { double 'configuration', :controller => controller }
+  let(:controller)    { double 'controller', :start => result, :pid => 101 }
+  let(:result)        { double 'result', :command => 'start', :status => 1,
+    :output => '' }
+  let(:stream)        { double :puts => nil }
+
+  before :each do
+    allow(controller).to receive(:running?).and_return(true)
+    allow(configuration).to receive_messages(
+      :indices_location => 'my/index/files',
+      :searchd          => double(:log => '/path/to/log')
+    )
+    allow(command).to receive(:exit).and_return(true)
+
+    allow(FileUtils).to receive_messages :mkdir_p => true
+  end
+
+  it "creates the index files directory" do
+    expect(FileUtils).to receive(:mkdir_p).with('my/index/files')
+
+    command.call
+  end
+
+  it "starts the daemon" do
+    expect(controller).to receive(:start)
+
+    command.call
+  end
+
+  it "prints a success message if the daemon has started" do
+    allow(controller).to receive(:running?).and_return(true)
+
+    expect(stream).to receive(:puts).
+      with('Started searchd successfully (pid: 101).')
+
+    command.call
+  end
+
+  it "prints a failure message if the daemon does not start" do
+    allow(controller).to receive(:running?).and_return(false)
+    allow(command).to receive(:exit)
+
+    expect(stream).to receive(:puts) do |string|
+      expect(string).to match('The Sphinx start command failed')
+    end
+
+    command.call
+  end
+end

data/spec/thinking_sphinx/commands/stop_spec.rb

@@ -0,0 +1,54 @@
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Commands::Stop do
+  let(:command)    {
+    ThinkingSphinx::Commands::Stop.new(configuration, {}, stream)
+  }
+  let(:configuration) { double 'configuration', :controller => controller }
+  let(:controller)    { double 'controller', :stop => true, :pid => 101 }
+  let(:stream)        { double :puts => nil }
+
+  before :each do
+    allow(controller).to receive(:running?).and_return(true, true, false)
+  end
+
+  it "prints a message if the daemon is not already running" do
+    allow(controller).to receive_messages :running? => false
+
+    expect(stream).to receive(:puts).with('searchd is not currently running.').
+      and_return(nil)
+    expect(stream).to_not receive(:puts).
+      with('"Stopped searchd daemon (pid: ).')
+
+    command.call
+  end
+
+  it "does not try to stop the daemon if it's not running" do
+    allow(controller).to receive_messages :running? => false
+
+    expect(controller).to_not receive(:stop)
+
+    command.call
+  end
+
+  it "stops the daemon" do
+    expect(controller).to receive(:stop)
+
+    command.call
+  end
+
+  it "prints a message informing the daemon has stopped" do
+    expect(stream).to receive(:puts).with('Stopped searchd daemon (pid: 101).')
+
+    command.call
+  end
+
+  it "should retry stopping the daemon until it stops" do
+    allow(controller).to receive(:running?).
+      and_return(true, true, true, false)
+
+    expect(controller).to receive(:stop).twice
+
+    command.call
+  end
+end

data/spec/thinking_sphinx/configuration/minimum_fields_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Configuration::MinimumFields do
+  let(:indices) { [index_a, index_b] }
+  let(:index_a) { double 'Index A', :model => model_a, :type => 'plain',
+    :sources => [double(:fields => [field_a1, field_a2])] }
+  let(:index_b) { double 'Index B', :model => model_a, :type => 'rt',
+    :fields => [field_b1, field_b2] }
+  let(:field_a1) { double :name => 'sphinx_internal_class_name' }
+  let(:field_a2) { double :name => 'name' }
+  let(:field_b1) { double :name => 'sphinx_internal_class_name' }
+  let(:field_b2) { double :name => 'name' }
+  let(:model_a)  { double :inheritance_column => 'type' }
+  let(:model_b)  { double :inheritance_column => 'type' }
+  let(:subject)  { ThinkingSphinx::Configuration::MinimumFields.new indices }
+
+  it 'removes the class name fields when no index models have type columns' do
+    allow(model_a).to receive(:column_names).and_return(['id', 'name'])
+    allow(model_b).to receive(:column_names).and_return(['id', 'name'])
+
+    subject.reconcile
+
+    expect(index_a.sources.first.fields).to eq([field_a2])
+    expect(index_b.fields).to eq([field_b2])
+  end
+
+  it 'keeps the class name fields when one index model has a type column' do
+    allow(model_a).to receive(:column_names).and_return(['id', 'name', 'type'])
+    allow(model_b).to receive(:column_names).and_return(['id', 'name'])
+
+    subject.reconcile
+
+    expect(index_a.sources.first.fields).to eq([field_a1, field_a2])
+    expect(index_b.fields).to eq([field_b1, field_b2])
+  end
+end

data/spec/thinking_sphinx/deletion_spec.rb

@@ -13,11 +13,8 @@ describe ThinkingSphinx::Deletion do
 
     context 'index is SQL-backed' do
       it "updates the deleted flag to false" do
-        expect(connection).to 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 id IN (14)')
 
         ThinkingSphinx::Deletion.perform index, 7
       end

data/spec/thinking_sphinx/deltas/default_delta_spec.rb

@@ -21,7 +21,7 @@ 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

data/spec/thinking_sphinx/errors_spec.rb

@@ -19,6 +19,13 @@ describe ThinkingSphinx::SphinxError do
         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'
 

data/spec/thinking_sphinx/index_set_spec.rb

@@ -15,9 +15,15 @@ describe ThinkingSphinx::IndexSet do
     stub_const 'ActiveRecord::Base', ar_base
   end
 
-  def class_double(name, *superclasses)
+  def class_double(name, methods = {}, *superclasses)
     klass = double 'class', :name => name, :class => Class
-    allow(klass).to receive_messages :ancestors => ([klass] + superclasses + [ar_base])
+
+    allow(klass).to receive_messages(
+      :ancestors          => ([klass] + superclasses + [ar_base]),
+      :inheritance_column => :type
+    )
+    allow(klass).to receive_messages(methods)
+
     klass
   end
 
@@ -47,25 +53,42 @@ describe ThinkingSphinx::IndexSet do
         double(:reference => :page,            :distributed? => false)
       ]
 
-      options[:classes] = [class_double('Article')]
+      options[:classes] = [class_double('Article', :column_names => [])]
 
       expect(set.to_a.length).to eq(1)
     end
 
-    it "requests indices for any superclasses" do
+    it "requests indices for any STI superclasses" do
       configuration.indices.replace [
         double(:reference => :article,         :distributed? => false),
         double(:reference => :opinion_article, :distributed? => false),
         double(:reference => :page,            :distributed? => false)
       ]
 
-      options[:classes] = [
-        class_double('OpinionArticle', class_double('Article'))
-      ]
+      article = class_double('Article', :column_names => [:type])
+      opinion = class_double('OpinionArticle', {:column_names => [:type]},
+        article)
+
+      options[:classes] = [opinion]
 
       expect(set.to_a.length).to eq(2)
     end
 
+    it "does not use MTI superclasses" do
+      configuration.indices.replace [
+        double(:reference => :article,         :distributed? => false),
+        double(:reference => :opinion_article, :distributed? => false),
+        double(:reference => :page,            :distributed? => false)
+      ]
+
+      article = class_double('Article', :column_names => [])
+      opinion = class_double('OpinionArticle', {:column_names => []}, article)
+
+      options[:classes] = [opinion]
+
+      expect(set.to_a.length).to eq(1)
+    end
+
     it "uses named indices if names are provided" do
       article_core = double('index', :name => 'article_core')
       user_core    = double('index', :name => 'user_core')