thinking-sphinx 3.3.0 → 3.4.0

data/spec/thinking_sphinx/interfaces/daemon_spec.rb

@@ -0,0 +1,52 @@
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Interfaces::Daemon do
+  let(:configuration) { double 'configuration', :controller => controller }
+  let(:controller)    { double 'controller', :running? => false }
+  let(:stream)        { double 'stream', :puts => true }
+  let(:interface)     {
+    ThinkingSphinx::Interfaces::Daemon.new(configuration, {}, stream)
+  }
+
+  describe '#start' do
+    let(:command) { double 'command', :call => true }
+
+    before :each do
+      stub_const 'ThinkingSphinx::Commands::StartDetached', command
+    end
+
+    it "starts the daemon" do
+      expect(command).to receive(:call)
+
+      interface.start
+    end
+
+    it "raises an error if the daemon is already running" do
+      allow(controller).to receive_messages :running? => true
+
+      expect {
+        interface.start
+      }.to raise_error(ThinkingSphinx::SphinxAlreadyRunning)
+    end
+  end
+
+  describe '#status' do
+    it "reports when the daemon is running" do
+      allow(controller).to receive_messages :running? => true
+
+      expect(stream).to receive(:puts).
+        with('The Sphinx daemon searchd is currently running.')
+
+      interface.status
+    end
+
+    it "reports when the daemon is not running" do
+      allow(controller).to receive_messages :running? => false
+
+      expect(stream).to receive(:puts).
+        with('The Sphinx daemon searchd is not currently running.')
+
+      interface.status
+    end
+  end
+end

data/spec/thinking_sphinx/interfaces/real_time_spec.rb

@@ -0,0 +1,109 @@
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Interfaces::SQL do
+  let(:interface)     { ThinkingSphinx::Interfaces::RealTime.new(
+    configuration, {}, stream
+  ) }
+  let(:configuration) { double 'configuration', :controller => controller,
+    :render => true, :indices_location => '/path/to/indices',
+    :preload_indices => true }
+  let(:controller)    { double 'controller', :running? => true }
+  let(:stream)        { double :puts => nil }
+
+  describe '#clear' do
+    let(:plain_index) { double(:type => 'plain') }
+    let(:users_index) { double(:name => 'users', :type => 'rt', :render => true,
+      :path => '/path/to/my/index/users') }
+    let(:parts_index) { double(:name => 'parts', :type => 'rt', :render => true,
+      :path => '/path/to/my/index/parts') }
+
+    before :each do
+      allow(configuration).to receive_messages(
+        :indices => [plain_index, users_index, parts_index],
+        :searchd => double(:binlog_path => '/path/to/binlog')
+      )
+
+      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 :mkdir_p => true, :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([])
+
+      interface.clear
+    end
+
+    it "removes the directory for the binlog files" do
+      expect(FileUtils).to receive(:rm_r).with('/path/to/binlog')
+
+      interface.clear
+    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')
+
+      interface.clear
+    end
+
+    context "with options[:index_filter]" do
+      let(:interface) { ThinkingSphinx::Interfaces::RealTime.new(
+        configuration, {:index_filter => 'users'}, stream
+      ) }
+
+      it "removes each file for real-time indices that match :index_filter" do
+        expect(FileUtils).to receive(:rm).with('users.a')
+        expect(FileUtils).to receive(:rm).with('users.b')
+        expect(FileUtils).not_to receive(:rm).with('parts.a')
+        expect(FileUtils).not_to receive(:rm).with('parts.b')
+
+        interface.clear
+      end
+    end
+  end
+
+  describe '#index' do
+    let(:plain_index) { double(:type => 'plain') }
+    let(:users_index) { double(name: 'users', :type => 'rt') }
+    let(:parts_index) { double(name: 'parts', :type => 'rt') }
+
+    before :each do
+      allow(configuration).to receive_messages(
+        :indices => [plain_index, users_index, parts_index]
+      )
+
+      allow(FileUtils).to receive_messages :mkdir_p => true
+    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)
+      expect(ThinkingSphinx::RealTime::Populator).not_to receive(:populate).with(plain_index)
+
+      interface.index
+    end
+
+    context "with options[:index_filter]" do
+      let(:interface) { ThinkingSphinx::Interfaces::RealTime.new(
+        configuration, {:index_filter => 'users'}, stream
+      ) }
+
+      it 'populates each real-index that matches :index_filter' do
+        expect(ThinkingSphinx::RealTime::Populator).to receive(:populate).with(users_index)
+        expect(ThinkingSphinx::RealTime::Populator).not_to receive(:populate).with(parts_index)
+        expect(ThinkingSphinx::RealTime::Populator).not_to receive(:populate).with(plain_index)
+
+        interface.index
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/interfaces/sql_spec.rb

@@ -0,0 +1,98 @@
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Interfaces::SQL do
+  let(:interface)     { ThinkingSphinx::Interfaces::SQL.new(
+    configuration, {:verbose => true}, stream
+  ) }
+  let(:configuration) { double 'configuration', :preload_indices => true,
+    :render => true, :indices => [double(:index, :type => 'plain')],
+    :indices_location   => '/path/to/indices' }
+  let(:stream)        { double :puts => nil }
+
+  describe '#clear' do
+    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') }
+    let(:rt_index)    { double(:type => 'rt') }
+
+    before :each do
+      allow(configuration).to receive_messages(
+        :indices => [users_index, parts_index, rt_index]
+      )
+
+      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 :mkdir_p => true, :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([])
+
+      interface.clear
+    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')
+
+      interface.clear
+    end
+  end
+
+  describe '#index' do
+    let(:index_command)     { double :call => true }
+    let(:configure_command) { double :call => true }
+
+    before :each do
+      stub_const 'ThinkingSphinx::Commands::Index', index_command
+      stub_const 'ThinkingSphinx::Commands::Configure', configure_command
+
+      allow(ThinkingSphinx).to receive_messages :before_index_hooks => []
+      allow(FileUtils).to receive_messages :mkdir_p => true
+    end
+
+    it "renders the configuration to a file by default" do
+      expect(configure_command).to receive(:call)
+
+      interface.index
+    end
+
+    it "does not render the configuration if requested" do
+      expect(configure_command).not_to receive(:call)
+
+      interface.index false
+    end
+
+    it "creates the directory for the index files" do
+      expect(FileUtils).to receive(:mkdir_p).with('/path/to/indices')
+
+      interface.index
+    end
+
+    it "calls all registered hooks" do
+      called = false
+      ThinkingSphinx.before_index_hooks << Proc.new { called = true }
+
+      interface.index
+
+      expect(called).to be_truthy
+    end
+
+    it "executes the index command" do
+      expect(index_command).to receive(:call).with(
+        configuration, {:verbose => true}, stream
+      )
+
+      interface.index
+    end
+  end
+end

data/spec/thinking_sphinx/middlewares/attribute_typer_spec.rb

@@ -0,0 +1,42 @@
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Middlewares::AttributeTyper do
+  let(:app)        { double('app', :call => true) }
+  let(:middleware) { ThinkingSphinx::Middlewares::AttributeTyper.new app }
+  let(:attributes) { {} }
+  let(:context)    { double('context', :search => search) }
+  let(:search)     { double('search', :options => {}) }
+
+  before :each do
+    allow(ThinkingSphinx::AttributeTypes).to receive(:call).
+      and_return(attributes)
+    allow(ActiveSupport::Deprecation).to receive(:warn)
+  end
+
+  it 'warns when providing a string value for an integer attribute' do
+    attributes['user_id'] = [:uint]
+    search.options[:with] = {:user_id => '1'}
+
+    expect(ActiveSupport::Deprecation).to receive(:warn)
+
+    middleware.call [context]
+  end
+
+  it 'warns when providing a string value for a float attribute' do
+    attributes['price'] = [:float]
+    search.options[:without] = {:price => '1.0'}
+
+    expect(ActiveSupport::Deprecation).to receive(:warn)
+
+    middleware.call [context]
+  end
+
+  it 'proceeds when providing a string value for a string attribute' do
+    attributes['status'] = [:string]
+    search.options[:with] = {:status => 'completed'}
+
+    expect(ActiveSupport::Deprecation).not_to receive(:warn)
+
+    middleware.call [context]
+  end
+end

data/spec/thinking_sphinx/middlewares/valid_options_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+
+RSpec.describe ThinkingSphinx::Middlewares::ValidOptions do
+  let(:app)        { double 'app', :call => true }
+  let(:middleware) { ThinkingSphinx::Middlewares::ValidOptions.new app }
+  let(:context)    { double 'context', :search => search }
+  let(:search)     { double 'search', :options => {} }
+
+  before :each do
+    allow(ThinkingSphinx::Logger).to receive(:log)
+  end
+
+  context 'with unknown options' do
+    before :each do
+      search.options[:foo] = :bar
+    end
+
+    it "adds a warning" do
+      expect(ThinkingSphinx::Logger).to receive(:log).
+        with(:warn, "Unexpected search options: [:foo]")
+
+      middleware.call [context]
+    end
+
+    it 'continues on' do
+      expect(app).to receive(:call).with([context])
+
+      middleware.call [context]
+    end
+  end
+
+  context "with known options" do
+    before :each do
+      search.options[:ids_only] = true
+    end
+
+    it "is silent" do
+      expect(ThinkingSphinx::Logger).to_not receive(:log)
+
+      middleware.call [context]
+    end
+
+    it 'continues on' do
+      expect(app).to receive(:call).with([context])
+
+      middleware.call [context]
+    end
+  end
+end

data/spec/thinking_sphinx/rake_interface_spec.rb

@@ -1,270 +1,37 @@
 require 'spec_helper'
 
 describe ThinkingSphinx::RakeInterface do
-  let(:configuration) { double('configuration', :controller => controller) }
   let(:interface)     { ThinkingSphinx::RakeInterface.new }
 
-  before :each do
-    allow(ThinkingSphinx::Configuration).to receive_messages :instance => configuration
-    allow(interface).to receive_messages(:puts => nil)
-  end
-
-  describe '#clear_all' do
-    let(:controller) { double 'controller' }
-
-    before :each do
-      allow(configuration).to receive_messages(
-        :indices_location => '/path/to/indices',
-        :searchd          => double(:binlog_path => '/path/to/binlog')
-      )
-
-      allow(FileUtils).to receive_messages :rm_r => true
-      allow(File).to receive_messages :exists? => true
-    end
-
-    it "removes the directory for the index files" do
-      expect(FileUtils).to receive(:rm_r).with('/path/to/indices')
-
-      interface.clear_all
-    end
-
-    it "removes the directory for the binlog files" do
-      expect(FileUtils).to receive(:rm_r).with('/path/to/binlog')
-
-      interface.clear_all
-    end
-  end
-
-  describe '#clear_real_time' do
-    let(:controller) { double 'controller' }
-    let(:index)      {
-      double(:type => 'rt', :render => true, :path => '/path/to/my/index')
-    }
-
-    before :each do
-      allow(configuration).to receive_messages(
-        :indices         => [double(:type => 'plain'), index],
-        :searchd         => double(:binlog_path => '/path/to/binlog'),
-        :preload_indices => true
-      )
-
-      allow(Dir).to receive_messages :[] => ['foo.a', 'foo.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.*').and_return([])
-
-      interface.clear_real_time
-    end
-
-    it "removes each file for real-time indices" do
-      expect(FileUtils).to receive(:rm).with('foo.a')
-      expect(FileUtils).to receive(:rm).with('foo.b')
-
-      interface.clear_real_time
-    end
-
-    it "removes the directory for the binlog files" do
-      expect(FileUtils).to receive(:rm_r).with('/path/to/binlog')
-
-      interface.clear_real_time
-    end
-  end
-
   describe '#configure' do
-    let(:controller) { double('controller') }
+    let(:command) { double 'command', :call => true }
 
     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)
-
-      interface.configure
+      stub_const 'ThinkingSphinx::Commands::Configure', command
     end
 
-    it "prints a message stating the file is being generated" do
-      expect(interface).to receive(:puts).
-        with('Generating configuration to /path/to/foo.conf')
+    it 'sends the configure command' do
+      expect(command).to receive(:call)
 
       interface.configure
     end
   end
 
-  describe '#index' do
-    let(:controller) { double('controller', :index => true) }
-
-    before :each do
-      allow(ThinkingSphinx).to receive_messages :before_index_hooks => []
-      allow(configuration).to receive_messages(
-        :configuration_file => '/path/to/foo.conf',
-        :render_to_file     => true,
-        :indices_location   => '/path/to/indices'
-      )
-
-      allow(FileUtils).to receive_messages :mkdir_p => true
-    end
-
-    it "renders the configuration to a file by default" do
-      expect(configuration).to receive(:render_to_file)
-
-      interface.index
-    end
-
-    it "does not render the configuration if requested" do
-      expect(configuration).not_to receive(:render_to_file)
-
-      interface.index false
-    end
-
-    it "creates the directory for the index files" do
-      expect(FileUtils).to receive(:mkdir_p).with('/path/to/indices')
-
-      interface.index
-    end
-
-    it "calls all registered hooks" do
-      called = false
-      ThinkingSphinx.before_index_hooks << Proc.new { called = true }
-
-      interface.index
-
-      expect(called).to be_truthy
-    end
-
-    it "indexes all indices verbosely" do
-      expect(controller).to receive(:index).with(:verbose => true)
-
-      interface.index
-    end
-
-    it "does not index verbosely if requested" do
-      expect(controller).to receive(:index).with(:verbose => false)
-
-      interface.index true, false
-    end
-  end
-
-  describe '#start' do
-    let(:controller) { double('controller', :start => result, :pid => 101) }
-    let(:result)     { double 'result', :command => 'start', :status => 1,
-      :output => '' }
-
-    before :each do
-      allow(controller).to receive(:running?).and_return(false, true)
-      allow(configuration).to receive_messages(
-        :indices_location => 'my/index/files',
-        :searchd          => double(:log => '/path/to/log')
-      )
-
-      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')
-
-      interface.start
-    end
-
-    it "starts the daemon" do
-      expect(controller).to receive(:start)
-
-      interface.start
-    end
-
-    it "raises an error if the daemon is already running" do
-      allow(controller).to receive_messages :running? => true
-
-      expect {
-        interface.start
-      }.to raise_error(ThinkingSphinx::SphinxAlreadyRunning)
-    end
-
-    it "prints a success message if the daemon has started" do
-      allow(controller).to receive(:running?).and_return(false, true)
-
-      expect(interface).to receive(:puts).
-        with('Started searchd successfully (pid: 101).')
-
-      interface.start
-    end
-
-    it "prints a failure message if the daemon does not start" do
-      allow(controller).to receive(:running?).and_return(false, false)
-      allow(interface).to receive(:exit)
-
-      expect(interface).to receive(:puts) do |string|
-        expect(string).to match('The Sphinx start command failed')
-      end
-
-      interface.start
+  describe '#daemon' do
+    it 'returns a daemon interface' do
+      expect(interface.daemon.class).to eq(ThinkingSphinx::Interfaces::Daemon)
     end
   end
 
-  describe '#stop' do
-    let(:controller) { double('controller', :stop => true, :pid => 101) }
-    let(:result)     { double 'result', :command => 'start', :status => 1,
-      :output => '' }
-
-    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(interface).to receive(:puts).with('searchd is not currently running.')
-
-      interface.stop
-    end
-
-    it "stops the daemon" do
-      expect(controller).to receive(:stop)
-
-      interface.stop
-    end
-
-    it "prints a message informing the daemon has stopped" do
-      expect(interface).to receive(:puts).with('Stopped searchd daemon (pid: 101).')
-
-      interface.stop
-    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
-
-      interface.stop
+  describe '#rt' do
+    it 'returns a real-time interface' do
+      expect(interface.rt.class).to eq(ThinkingSphinx::Interfaces::RealTime)
     end
   end
 
-  describe '#status' do
-    let(:controller) { double('controller') }
-
-    it "reports when the daemon is running" do
-      allow(controller).to receive_messages :running? => true
-
-      expect(interface).to receive(:puts).
-        with('The Sphinx daemon searchd is currently running.')
-
-      interface.status
-    end
-
-    it "reports when the daemon is not running" do
-      allow(controller).to receive_messages :running? => false
-
-      expect(interface).to receive(:puts).
-        with('The Sphinx daemon searchd is not currently running.')
-
-      interface.status
+  describe '#sql' do
+    it 'returns an SQL interface' do
+      expect(interface.sql.class).to eq(ThinkingSphinx::Interfaces::SQL)
     end
   end
 end