thinking-sphinx 3.4.2 → 4.0.0

data/spec/thinking_sphinx/active_record/index_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::Index do
@@ -10,7 +12,8 @@ describe ThinkingSphinx::ActiveRecord::Index do
   end
 
   describe '#append_source' do
-    let(:model)  { double('model', :primary_key => :id) }
+    let(:model)  { double('model', :primary_key => :id,
+      :table_exists? => true) }
     let(:source) { double('source') }
 
     before :each do
@@ -91,6 +94,18 @@ describe ThinkingSphinx::ActiveRecord::Index do
     end
   end
 
+  describe '#docinfo' do
+    it "defaults to extern" do
+      expect(index.docinfo).to eq(:extern)
+    end
+
+    it "can be disabled" do
+      config.settings["skip_docinfo"] = true
+
+      expect(index.docinfo).to be_nil
+    end
+  end
+
   describe '#document_id_for_key' do
     it "calculates the document id based on offset and number of indices" do
       allow(config).to receive_message_chain(:indices, :count).and_return(5)

data/spec/thinking_sphinx/active_record/interpreter_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::Interpreter do

data/spec/thinking_sphinx/active_record/polymorpher_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::Polymorpher do

data/spec/thinking_sphinx/active_record/property_sql_presenter_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::PropertySQLPresenter do

data/spec/thinking_sphinx/active_record/sql_builder_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::SQLBuilder do

data/spec/thinking_sphinx/active_record/sql_source_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::ActiveRecord::SQLSource do

data/spec/thinking_sphinx/attribute_types_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe ThinkingSphinx::AttributeTypes do

data/spec/thinking_sphinx/commands/clear_real_time_spec.rb

@@ -0,0 +1,46 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Commands::ClearRealTime do
+  let(:command)       { ThinkingSphinx::Commands::ClearRealTime.new(
+    configuration, {:indices => [users_index, parts_index]}, stream
+  ) }
+  let(:configuration) { double 'configuration', :searchd => double(:binlog_path => '/path/to/binlog') }
+  let(:stream)        { double :puts => nil }
+  let(:users_index)   { double :path => '/path/to/my/index/users', :render => true }
+  let(:parts_index)   { double :path => '/path/to/my/index/parts', :render => true }
+
+  before :each do
+    allow(Dir).to receive(:[]).with('/path/to/my/index/users.*').
+      and_return(['users.a', 'users.b'])
+    allow(Dir).to receive(:[]).with('/path/to/my/index/parts.*').
+      and_return(['parts.a', 'parts.b'])
+
+    allow(FileUtils).to receive_messages :rm_r => true,
+      :rm => true
+    allow(File).to receive_messages :exists? => true
+  end
+
+  it 'finds each file for real-time indices' do
+    expect(Dir).to receive(:[]).with('/path/to/my/index/users.*').
+      and_return([])
+
+    command.call
+  end
+
+  it "removes the directory for the binlog files" do
+    expect(FileUtils).to receive(:rm_r).with('/path/to/binlog')
+
+    command.call
+  end
+
+  it "removes each file for real-time indices" do
+    expect(FileUtils).to receive(:rm).with('users.a')
+    expect(FileUtils).to receive(:rm).with('users.b')
+    expect(FileUtils).to receive(:rm).with('parts.a')
+    expect(FileUtils).to receive(:rm).with('parts.b')
+
+    command.call
+  end
+end

data/spec/thinking_sphinx/commands/clear_sql_spec.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Commands::ClearSQL do
+  let(:command)       { ThinkingSphinx::Commands::ClearSQL.new(
+    configuration, {:indices => [users_index, parts_index]}, stream
+  ) }
+  let(:configuration) { double 'configuration', :preload_indices => true,
+    :render => true, :indices => [users_index, parts_index],
+    :indices_location => '/path/to/indices' }
+  let(:stream)        { double :puts => nil }
+
+  let(:users_index) { double(:name => 'users', :type => 'plain',
+    :render => true, :path => '/path/to/my/index/users') }
+  let(:parts_index) { double(:name => 'users', :type => 'plain',
+    :render => true, :path => '/path/to/my/index/parts') }
+
+  before :each do
+    allow(Dir).to receive(:[]).with('/path/to/my/index/users.*').
+      and_return(['users.a', 'users.b'])
+    allow(Dir).to receive(:[]).with('/path/to/my/index/parts.*').
+      and_return(['parts.a', 'parts.b'])
+    allow(Dir).to receive(:[]).with('/path/to/indices/ts-*.tmp').
+      and_return(['/path/to/indices/ts-foo.tmp'])
+
+    allow(FileUtils).to receive_messages :rm_r => true, :rm => true
+    allow(File).to receive_messages :exists? => true
+  end
+
+  it 'finds each file for sql-backed indices' do
+    expect(Dir).to receive(:[]).with('/path/to/my/index/users.*').
+      and_return([])
+
+    command.call
+  end
+
+  it "removes each file for real-time indices" do
+    expect(FileUtils).to receive(:rm).with('users.a')
+    expect(FileUtils).to receive(:rm).with('users.b')
+    expect(FileUtils).to receive(:rm).with('parts.a')
+    expect(FileUtils).to receive(:rm).with('parts.b')
+
+    command.call
+  end
+
+  it "removes any indexing guard files" do
+    expect(FileUtils).to receive(:rm_r).with(["/path/to/indices/ts-foo.tmp"])
+
+    command.call
+  end
+end

data/spec/thinking_sphinx/commands/configure_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 RSpec.describe ThinkingSphinx::Commands::Configure do

data/spec/thinking_sphinx/commands/index_real_time_spec.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Commands::IndexRealTime do
+  let(:command)       { ThinkingSphinx::Commands::IndexRealTime.new(
+    configuration, {:indices => [users_index, parts_index]}, stream
+  ) }
+  let(:configuration) { double 'configuration', :controller => controller }
+  let(:controller)    { double 'controller', :rotate => nil }
+  let(:stream)        { double :puts => nil }
+  let(:users_index)   { double(name: 'users') }
+  let(:parts_index)   { double(name: 'parts') }
+
+  before :each do
+    allow(ThinkingSphinx::RealTime::Populator).to receive(:populate)
+  end
+
+  it 'populates each real-index' do
+    expect(ThinkingSphinx::RealTime::Populator).to receive(:populate).
+      with(users_index)
+    expect(ThinkingSphinx::RealTime::Populator).to receive(:populate).
+      with(parts_index)
+
+    command.call
+  end
+
+  it "rotates the daemon for each index" do
+    expect(controller).to receive(:rotate).twice
+
+    command.call
+  end
+end

data/spec/thinking_sphinx/commands/index_sql_spec.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Commands::IndexSQL do
+  let(:command)    { ThinkingSphinx::Commands::IndexSQL.new(
+    configuration, {:verbose => true}, stream
+  ) }
+  let(:configuration)     { double 'configuration', :controller => controller,
+    :indexing_strategy => indexing_strategy,
+    :guarding_strategy => guarding_strategy }
+  let(:controller)        { double 'controller', :index => true }
+  let(:stream)            { double :puts => nil }
+  let(:indexing_strategy) { Proc.new { |names, &block| block.call names } }
+  let(:guarding_strategy) { Proc.new { |names, &block| block.call names } }
+
+  before :each do
+    allow(ThinkingSphinx).to receive_messages :before_index_hooks => []
+  end
+
+  it "calls all registered hooks" do
+    called = false
+    ThinkingSphinx.before_index_hooks << Proc.new { called = true }
+
+    command.call
+
+    expect(called).to eq(true)
+  end
+
+  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::IndexSQL.new(
+      configuration, {:verbose => false}, stream
+    )
+
+    expect(controller).to receive(:index).with(:verbose => false)
+
+    command.call
+  end
+
+  it "ignores a nil indices filter" do
+    command = ThinkingSphinx::Commands::IndexSQL.new(
+      configuration, {:verbose => false, :indices => nil}, stream
+    )
+
+    expect(controller).to receive(:index).with(:verbose => false)
+
+    command.call
+  end
+
+  it "ignores an empty indices filter" do
+    command = ThinkingSphinx::Commands::IndexSQL.new(
+      configuration, {:verbose => false, :indices => []}, stream
+    )
+
+    expect(controller).to receive(:index).with(:verbose => false)
+
+    command.call
+  end
+
+  it "uses filtered index names" do
+    command = ThinkingSphinx::Commands::IndexSQL.new(
+      configuration, {:verbose => false, :indices => ['foo_bar']}, stream
+    )
+
+    expect(controller).to receive(:index).with('foo_bar', :verbose => false)
+
+    command.call
+  end
+
+  it "does not call hooks when filtering by index" do
+    called = false
+    ThinkingSphinx.before_index_hooks << Proc.new { called = true }
+
+    ThinkingSphinx::Commands::IndexSQL.new(
+      configuration, {:verbose => false, :indices => ['foo_bar']}, stream
+    ).call
+
+    expect(called).to eq(false)
+  end
+end

data/spec/thinking_sphinx/commands/merge_and_update_spec.rb

@@ -0,0 +1,106 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Commands::MergeAndUpdate do
+  let(:command)       { ThinkingSphinx::Commands::MergeAndUpdate.new(
+    configuration, {}, stream
+  ) }
+  let(:configuration) { double "configuration", :preload_indices => nil,
+    :render => "", :indices => [core_index_a, delta_index_a, rt_index,
+      plain_index, core_index_b, delta_index_b] }
+  let(:stream)        { double :puts => nil }
+  let(:commander)     { double :call => true }
+  let(:core_index_a)  { double "index", :type => "plain", :options => {:delta_processor => true}, :delta? => false, :name => "index_a_core", :model => model_a, :path => "index_a_core" }
+  let(:delta_index_a) { double "index", :type => "plain", :options => {:delta_processor => true}, :delta? => true, :name => "index_a_delta", :path => "index_a_delta" }
+  let(:core_index_b)  { double "index", :type => "plain", :options => {:delta_processor => true}, :delta? => false, :name => "index_b_core", :model => model_b, :path => "index_b_core" }
+  let(:delta_index_b) { double "index", :type => "plain", :options => {:delta_processor => true}, :delta? => true, :name => "index_b_delta", :path => "index_b_delta" }
+  let(:rt_index)      { double "index", :type => "rt", :name => "rt_index" }
+  let(:plain_index)   { double "index", :type => "plain", :name => "plain_index", :options => {:delta_processor => nil} }
+  let(:model_a)       { double "model", :where => where_a }
+  let(:model_b)       { double "model", :where => where_b }
+  let(:where_a)       { double "where", :update_all => nil }
+  let(:where_b)       { double "where", :update_all => nil }
+
+  before :each do
+    stub_const 'ThinkingSphinx::Commander', commander
+  end
+
+  it "merges core/delta pairs" do
+    expect(commander).to receive(:call).with(
+      :merge, configuration, hash_including(
+        :core_index  => core_index_a,
+        :delta_index => delta_index_a,
+        :filters => {:sphinx_deleted => 0}
+      ), stream
+    )
+    expect(commander).to receive(:call).with(
+      :merge, configuration, hash_including(
+        :core_index  => core_index_b,
+        :delta_index => delta_index_b,
+        :filters => {:sphinx_deleted => 0}
+      ), stream
+    )
+
+    command.call
+  end
+
+  it "unflags delta records" do
+    expect(model_a).to receive(:where).with(:delta => true).and_return(where_a)
+    expect(where_a).to receive(:update_all).with(:delta => false)
+
+    expect(model_b).to receive(:where).with(:delta => true).and_return(where_b)
+    expect(where_b).to receive(:update_all).with(:delta => false)
+
+    command.call
+  end
+
+  it "ignores real-time indices" do
+    expect(commander).to_not receive(:call).with(
+      :merge, configuration, hash_including(:core_index => rt_index), stream
+    )
+    expect(commander).to_not receive(:call).with(
+      :merge, configuration, hash_including(:delta_index => rt_index), stream
+    )
+
+    command.call
+  end
+
+  it "ignores non-delta SQL indices" do
+    expect(commander).to_not receive(:call).with(
+      :merge, configuration, hash_including(:core_index => plain_index),
+      stream
+    )
+    expect(commander).to_not receive(:call).with(
+      :merge, configuration, hash_including(:delta_index => plain_index),
+      stream
+    )
+
+    command.call
+  end
+
+  context "with index name filter" do
+    let(:command) { ThinkingSphinx::Commands::MergeAndUpdate.new(
+      configuration, {:index_names => ["index_a"]}, stream
+    ) }
+
+    it "only processes matching indices" do
+      expect(commander).to receive(:call).with(
+        :merge, configuration, hash_including(
+          :core_index  => core_index_a,
+          :delta_index => delta_index_a,
+          :filters => {:sphinx_deleted => 0}
+        ), stream
+      )
+      expect(commander).to_not receive(:call).with(
+        :merge, configuration, hash_including(
+          :core_index  => core_index_b,
+          :delta_index => delta_index_b,
+          :filters => {:sphinx_deleted => 0}
+        ), stream
+      )
+
+      command.call
+    end
+  end
+end

data/spec/thinking_sphinx/commands/merge_spec.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Commands::Merge do
+  let(:command)       { ThinkingSphinx::Commands::Merge.new(
+    configuration, {:core_index => core_index, :delta_index => delta_index,
+      :filters => {:sphinx_deleted => 0}}, stream
+  ) }
+  let(:configuration) { double "configuration", :controller => controller }
+  let(:stream)        { double :puts => nil }
+  let(:controller)    { double "controller", :merge => nil }
+  let(:core_index)    { double "index", :path => "index_a_core",
+    :name => "index_a_core" }
+  let(:delta_index)   { double "index", :path => "index_a_delta",
+    :name => "index_a_delta" }
+
+  before :each do
+    allow(File).to receive(:exist?).and_return(true)
+  end
+
+  it "merges core/delta pairs" do
+    expect(controller).to receive(:merge).with(
+      "index_a_core",
+      "index_a_delta",
+      :filters => {:sphinx_deleted => 0},
+      :verbose => nil
+    )
+
+    command.call
+  end
+
+  it "does not merge if just the core does not exist" do
+    allow(File).to receive(:exist?).with("index_a_core.spi").and_return(false)
+
+    expect(controller).to_not receive(:merge)
+
+    command.call
+  end
+
+  it "does not merge if just the delta does not exist" do
+    allow(File).to receive(:exist?).with("index_a_delta.spi").and_return(false)
+
+    expect(controller).to_not receive(:merge)
+
+    command.call
+  end
+end