thinking-sphinx 3.1.4 → 6.0.0

data/spec/thinking_sphinx/middlewares/valid_options_spec.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+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(:caution, "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/panes/attributes_pane_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   module Panes; end
 end
@@ -15,7 +17,7 @@ describe ThinkingSphinx::Panes::AttributesPane do
     it "returns the object's sphinx attributes by default" do
       raw['foo'] = 24
 
-      pane.sphinx_attributes.should == {'foo' => 24}
+      expect(pane.sphinx_attributes).to eq({'foo' => 24})
     end
   end
 end

data/spec/thinking_sphinx/panes/distance_pane_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   module Panes; end
 end
@@ -15,13 +17,13 @@ describe ThinkingSphinx::Panes::DistancePane do
     it "returns the object's geodistance attribute by default" do
       raw['geodist'] = 123.45
 
-      pane.distance.should == 123.45
+      expect(pane.distance).to eq(123.45)
     end
 
     it "converts string geodistances to floats" do
       raw['geodist'] = '123.450'
 
-      pane.distance.should == 123.45
+      expect(pane.distance).to eq(123.45)
     end
   end
 
@@ -29,13 +31,13 @@ describe ThinkingSphinx::Panes::DistancePane do
     it "returns the object's geodistance attribute by default" do
       raw['geodist'] = 123.45
 
-      pane.geodist.should == 123.45
+      expect(pane.geodist).to eq(123.45)
     end
 
     it "converts string geodistances to floats" do
       raw['geodist'] = '123.450'
 
-      pane.geodist.should == 123.45
+      expect(pane.geodist).to eq(123.45)
     end
   end
 end

data/spec/thinking_sphinx/panes/excerpts_pane_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   module Panes; end
 end
@@ -13,7 +15,7 @@ describe ThinkingSphinx::Panes::ExcerptsPane do
   let(:search)  { double('search', :query => 'foo', :options => {}) }
 
   before :each do
-    context.stub :search => search
+    allow(context).to receive_messages :search => search
   end
 
   describe '#excerpts' do
@@ -22,18 +24,18 @@ describe ThinkingSphinx::Panes::ExcerptsPane do
 
     before :each do
       stub_const 'ThinkingSphinx::Excerpter', double(:new => excerpter)
-      ThinkingSphinx::Panes::ExcerptsPane::Excerpts.stub :new => excerpts
+      allow(ThinkingSphinx::Panes::ExcerptsPane::Excerpts).to receive_messages :new => excerpts
     end
 
     it "returns an excerpt glazing" do
-      pane.excerpts.should == excerpts
+      expect(pane.excerpts).to eq(excerpts)
     end
 
     it "creates an excerpter with the first index and the query and conditions values" do
       context[:indices] = [double(:name => 'alpha'), double(:name => 'beta')]
       context.search.options[:conditions] = {:baz => 'bar'}
 
-      ThinkingSphinx::Excerpter.should_receive(:new).
+      expect(ThinkingSphinx::Excerpter).to receive(:new).
         with('alpha', 'foo bar', anything).and_return(excerpter)
 
       pane.excerpts
@@ -42,8 +44,8 @@ describe ThinkingSphinx::Panes::ExcerptsPane do
     it "passes through excerpts options" do
       search.options[:excerpts] = {:before_match => 'foo'}
 
-      ThinkingSphinx::Excerpter.should_receive(:new).
-        with(anything, anything, :before_match => 'foo').and_return(excerpter)
+      expect(ThinkingSphinx::Excerpter).to receive(:new).
+        with(anything, anything, { :before_match => 'foo' }).and_return(excerpter)
 
       pane.excerpts
     end

data/spec/thinking_sphinx/panes/weight_pane_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module ThinkingSphinx
   module Panes; end
 end
@@ -12,9 +14,9 @@ describe ThinkingSphinx::Panes::WeightPane do
 
   describe '#weight' do
     it "returns the object's weight by default" do
-      raw[ThinkingSphinx::SphinxQL.weight[:column]] = 101
+      raw["weight()"] = 101
 
-      pane.weight.should == 101
+      expect(pane.weight).to eq(101)
     end
   end
 end

data/spec/thinking_sphinx/rake_interface_spec.rb

@@ -1,257 +1,39 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::RakeInterface do
-  let(:configuration) { double('configuration', :controller => controller) }
-  let(:interface)     { ThinkingSphinx::RakeInterface.new }
+  let(:interface) { ThinkingSphinx::RakeInterface.new }
+  let(:commander) { double :call => nil }
 
   before :each do
-    ThinkingSphinx::Configuration.stub :instance => configuration
-    interface.stub(:puts => nil)
-  end
-
-  describe '#clear_all' do
-    let(:controller) { double 'controller' }
-
-    before :each do
-      configuration.stub(
-        :indices_location => '/path/to/indices',
-        :searchd          => double(:binlog_path => '/path/to/binlog')
-      )
-
-      FileUtils.stub :rm_r => true
-      File.stub :exists? => true
-    end
-
-    it "removes the directory for the index files" do
-      FileUtils.should_receive(:rm_r).with('/path/to/indices')
-
-      interface.clear_all
-    end
-
-    it "removes the directory for the binlog files" do
-      FileUtils.should_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
-      configuration.stub(
-        :indices => [double(:type => 'plain'), index],
-        :searchd => double(:binlog_path => '/path/to/binlog')
-      )
-
-      Dir.stub :[] => ['foo.a', 'foo.b']
-      FileUtils.stub :rm_r => true, :rm => true
-      File.stub :exists? => true
-    end
-
-    it 'finds each file for real-time indices' do
-      Dir.should_receive(:[]).with('/path/to/my/index.*').and_return([])
-
-      interface.clear_real_time
-    end
-
-    it "removes each file for real-time indices" do
-      FileUtils.should_receive(:rm).with('foo.a')
-      FileUtils.should_receive(:rm).with('foo.b')
-
-      interface.clear_real_time
-    end
-
-    it "removes the directory for the binlog files" do
-      FileUtils.should_receive(:rm_r).with('/path/to/binlog')
-
-      interface.clear_real_time
-    end
+    stub_const 'ThinkingSphinx::Commander', commander
   end
 
   describe '#configure' do
-    let(:controller) { double('controller') }
-
-    before :each do
-      configuration.stub(
-        :configuration_file => '/path/to/foo.conf',
-        :render_to_file     => true
-      )
-    end
-
-    it "renders the configuration to a file" do
-      configuration.should_receive(:render_to_file)
-
-      interface.configure
-    end
-
-    it "prints a message stating the file is being generated" do
-      interface.should_receive(:puts).
-        with('Generating configuration to /path/to/foo.conf')
+    it 'sends the configure command' do
+      expect(commander).to receive(:call).
+        with(:configure, anything, {:verbose => true})
 
       interface.configure
     end
   end
 
-  describe '#index' do
-    let(:controller) { double('controller', :index => true) }
-
-    before :each do
-      ThinkingSphinx.stub :before_index_hooks => []
-      configuration.stub(
-        :configuration_file => '/path/to/foo.conf',
-        :render_to_file     => true,
-        :indices_location   => '/path/to/indices'
-      )
-
-      FileUtils.stub :mkdir_p => true
-    end
-
-    it "renders the configuration to a file by default" do
-      configuration.should_receive(:render_to_file)
-
-      interface.index
-    end
-
-    it "does not render the configuration if requested" do
-      configuration.should_not_receive(:render_to_file)
-
-      interface.index false
-    end
-
-    it "creates the directory for the index files" do
-      FileUtils.should_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
-
-      called.should be_true
-    end
-
-    it "indexes all indices verbosely" do
-      controller.should_receive(:index).with(:verbose => true)
-
-      interface.index
-    end
-
-    it "does not index verbosely if requested" do
-      controller.should_receive(:index).with(:verbose => false)
-
-      interface.index true, false
-    end
-  end
-
-  describe '#start' do
-    let(:controller) { double('controller', :start => true, :pid => 101) }
-
-    before :each do
-      controller.stub(:running?).and_return(false, true)
-      configuration.stub :indices_location => 'my/index/files'
-
-      FileUtils.stub :mkdir_p => true
-    end
-
-    it "creates the index files directory" do
-      FileUtils.should_receive(:mkdir_p).with('my/index/files')
-
-      interface.start
-    end
-
-    it "starts the daemon" do
-      controller.should_receive(:start)
-
-      interface.start
-    end
-
-    it "raises an error if the daemon is already running" do
-      controller.stub :running? => true
-
-      lambda {
-        interface.start
-      }.should raise_error(RuntimeError)
-    end
-
-    it "prints a success message if the daemon has started" do
-      controller.stub(:running?).and_return(false, true)
-
-      interface.should_receive(:puts).
-        with('Started searchd successfully (pid: 101).')
-
-      interface.start
-    end
-
-    it "prints a failure message if the daemon does not start" do
-      controller.stub(:running?).and_return(false, false)
-
-      interface.should_receive(:puts).
-        with('Failed to start searchd. Check the log files for more information.')
-
-      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) }
-
-    before :each do
-      controller.stub :running? => true
-    end
-
-    it "prints a message if the daemon is not already running" do
-      controller.stub :running? => false
-
-      interface.should_receive(:puts).with('searchd is not currently running.')
-
-      interface.stop
-    end
-
-    it "stops the daemon" do
-      controller.should_receive(:stop)
-
-      interface.stop
-    end
-
-    it "prints a message informing the daemon has stopped" do
-      interface.should_receive(:puts).with('Stopped searchd daemon (pid: 101).')
-
-      interface.stop
-    end
-
-    it "should retry stopping the daemon until it stops" do
-      controller.should_receive(:stop).twice.and_return(false, true)
-
-      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
-      controller.stub :running? => true
-
-      interface.should_receive(:puts).
-        with('The Sphinx daemon searchd is currently running.')
-
-      interface.status
-    end
-
-    it "reports when the daemon is not running" do
-      controller.stub :running? => false
-
-      interface.should_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

data/spec/thinking_sphinx/real_time/attribute_spec.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::RealTime::Attribute do
@@ -7,11 +9,11 @@ describe ThinkingSphinx::RealTime::Attribute do
   describe '#name' do
     it "uses the provided option by default" do
       attribute = ThinkingSphinx::RealTime::Attribute.new column, :as => :foo
-      attribute.name.should == 'foo'
+      expect(attribute.name).to eq('foo')
     end
 
     it "falls back to the column's name" do
-      attribute.name.should == 'created_at'
+      expect(attribute.name).to eq('created_at')
     end
   end
 
@@ -21,34 +23,34 @@ describe ThinkingSphinx::RealTime::Attribute do
     let(:parent) { klass.new 'the parent name', nil }
 
     it "returns the column's name if it's a string" do
-      column.stub :__name => 'value'
+      allow(column).to receive_messages :__name => 'value'
 
-      attribute.translate(object).should == 'value'
+      expect(attribute.translate(object)).to eq('value')
     end
 
     it "returns the column's name if it's an integer" do
-      column.stub :__name => 404
+      allow(column).to receive_messages :__name => 404
 
-      attribute.translate(object).should == 404
+      expect(attribute.translate(object)).to eq(404)
     end
 
     it "returns the object's method matching the column's name" do
-      object.stub :created_at => 'a time'
+      allow(object).to receive_messages :created_at => 'a time'
 
-      attribute.translate(object).should == 'a time'
+      expect(attribute.translate(object)).to eq('a time')
     end
 
     it "uses the column's stack to navigate through the object tree" do
-      column.stub :__name => :name, :__stack => [:parent]
+      allow(column).to receive_messages :__name => :name, :__stack => [:parent]
 
-      attribute.translate(object).should == 'the parent name'
+      expect(attribute.translate(object)).to eq('the parent name')
     end
 
     it "returns zero if any element in the object tree is nil" do
-      column.stub :__name => :name, :__stack => [:parent]
+      allow(column).to receive_messages :__name => :name, :__stack => [:parent]
       object.parent = nil
 
-      attribute.translate(object).should be_zero
+      expect(attribute.translate(object)).to be_zero
     end
   end
 
@@ -56,7 +58,7 @@ describe ThinkingSphinx::RealTime::Attribute do
     it "returns the given type option" do
       attribute = ThinkingSphinx::RealTime::Attribute.new column,
         :type => :string
-      attribute.type.should == :string
+      expect(attribute.type).to eq(:string)
     end
   end
 end