thinking-sphinx 3.1.4 → 6.0.0

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_rf => true,
+      :rm => true
+    allow(File).to receive_messages :exist? => 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_rf).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_rf => true, :rm => true
+    allow(File).to receive_messages :exist? => 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_rf).with(["/path/to/indices/ts-foo.tmp"])
+
+    command.call
+  end
+end

data/spec/thinking_sphinx/commands/configure_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+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_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

data/spec/thinking_sphinx/commands/prepare_spec.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Commands::Prepare do
+  let(:command)       { ThinkingSphinx::Commands::Prepare.new(
+    configuration, {}, stream
+  ) }
+  let(:configuration) { double 'configuration',
+    :indices_location => '/path/to/indices', :settings => {}
+  }
+  let(:stream)        { double :puts => nil }
+
+  before :each do
+    allow(FileUtils).to receive_messages :mkdir_p => true
+  end
+
+  it "creates the directory for the index files" do
+    expect(FileUtils).to receive(:mkdir_p).with('/path/to/indices')
+
+    command.call
+  end
+
+  it "skips directory creation if flag is set" do
+    configuration.settings['skip_directory_creation'] = true
+
+    expect(FileUtils).to_not receive(:mkdir_p)
+
+    command.call
+  end
+end

data/spec/thinking_sphinx/commands/running_spec.rb

@@ -0,0 +1,30 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Commands::Running do
+  let(:command)    { ThinkingSphinx::Commands::Running.new(
+    configuration, {}, stream
+  ) }
+  let(:configuration) {
+    double 'configuration', :controller => controller, :settings => {}
+  }
+  let(:stream)        { double :puts => nil }
+  let(:controller)    { double 'controller', :running? => false }
+
+  it 'returns true when Sphinx is running' do
+    allow(controller).to receive(:running?).and_return(true)
+
+    expect(command.call).to eq(true)
+  end
+
+  it 'returns false when Sphinx is not running' do
+    expect(command.call).to eq(false)
+  end
+
+  it 'returns true if the flag is set' do
+    configuration.settings['skip_running_check'] = true
+
+    expect(command.call).to eq(true)
+  end
+end

data/spec/thinking_sphinx/commands/start_detached_spec.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Commands::StartDetached do
+  let(:command)    {
+    ThinkingSphinx::Commands::StartDetached.new(configuration, {}, stream)
+  }
+  let(:configuration) {
+    double 'configuration', :controller => controller, :settings => {}
+  }
+  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 "skips directory creation if flag is set" do
+    configuration.settings['skip_directory_creation'] = true
+
+    expect(FileUtils).to_not receive(:mkdir_p)
+
+    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,63 @@
+# frozen_string_literal: true
+
+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 }
+  let(:commander)     { double :call => nil }
+
+  before :each do
+    stub_const 'ThinkingSphinx::Commander', commander
+
+    allow(commander).to receive(:call).
+      with(:running, configuration, {}, stream).and_return(true, true, false)
+  end
+
+  it "prints a message if the daemon is not already running" do
+    allow(commander).to receive(:call).
+      with(:running, configuration, {}, stream).and_return(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(commander).to receive(:call).
+      with(:running, configuration, {}, stream).and_return(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(commander).to receive(:call).
+      with(:running, configuration, {}, stream).
+      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,60 @@
+# frozen_string_literal: true
+
+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_b, :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',
+    :table_exists? => true }
+  let(:model_b)  { double :inheritance_column => 'type',
+    :table_exists? => true }
+  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 'removes the class name fields when models have no tables' do
+    allow(model_a).to receive(:table_exists?).and_return(false)
+    allow(model_b).to receive(:table_exists?).and_return(false)
+
+    subject.reconcile
+
+    expect(index_a.sources.first.fields).to eq([field_a2])
+    expect(index_b.fields).to eq([field_b2])
+  end
+
+  it 'removes the class name fields only for the rt indices without 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_b2])
+  end
+
+  it 'removes the class name fields only for the plain indices without type column' do
+    allow(model_a).to receive(:column_names).and_return(['id', 'name'])
+    allow(model_b).to receive(:column_names).and_return(['id', 'name', 'type'])
+
+    subject.reconcile
+
+    expect(index_a.sources.first.fields).to eq([field_a2])
+    expect(index_b.fields).to eq([field_b1, field_b2])
+  end
+end