thinking-sphinx 2.1.0 → 3.0.0.pre

data/spec/thinking_sphinx/middlewares/stale_id_checker_spec.rb

@@ -0,0 +1,47 @@
+module ThinkingSphinx
+  module Middlewares; end
+  class  Search; end
+end
+
+require 'thinking_sphinx/middlewares/middleware'
+require 'thinking_sphinx/middlewares/stale_id_checker'
+require 'thinking_sphinx/search/stale_ids_exception'
+
+describe ThinkingSphinx::Middlewares::StaleIdChecker do
+  let(:app)        { double('app') }
+  let(:middleware) { ThinkingSphinx::Middlewares::StaleIdChecker.new app }
+  let(:context)    { {:raw => [], :results => []} }
+  let(:model)      { double('model') }
+
+  def raw_result(id, model_name)
+    {'sphinx_internal_id' => id, 'sphinx_internal_class' => model_name}
+  end
+
+  describe '#call' do
+    it 'passes the call on if there are no nil results' do
+      context[:raw] << raw_result(24, 'Article')
+      context[:raw] << raw_result(42, 'Article')
+
+      context[:results] << double('instance', :id => 24)
+      context[:results] << double('instance', :id => 42)
+
+      app.should_receive(:call)
+
+      middleware.call [context]
+    end
+
+    it "raises a stale id exception if ActiveRecord doesn't return ids" do
+      context[:raw] << raw_result(24, 'Article')
+      context[:raw] << raw_result(42, 'Article')
+
+      context[:results] << double('instance', :id => 24)
+      context[:results] << nil
+
+      lambda {
+        middleware.call [context]
+      }.should raise_error(ThinkingSphinx::Search::StaleIdsException) { |err|
+        err.ids.should == [42]
+      }
+    end
+  end
+end

data/spec/thinking_sphinx/middlewares/stale_id_filter_spec.rb

@@ -0,0 +1,91 @@
+module ThinkingSphinx
+  module Middlewares; end
+  class  Search; end
+end
+
+require 'thinking_sphinx/middlewares/middleware'
+require 'thinking_sphinx/middlewares/stale_id_filter'
+require 'thinking_sphinx/search/stale_ids_exception'
+
+describe ThinkingSphinx::Middlewares::StaleIdFilter do
+  let(:app)        { double('app', :call => true) }
+  let(:middleware) { ThinkingSphinx::Middlewares::StaleIdFilter.new app }
+  let(:context)    { {:raw => [], :results => []} }
+  let(:search)     { double('search', :options => {}) }
+
+  describe '#call' do
+    before :each do
+      context.stub :search => search, :log => true
+    end
+
+    context 'one stale ids exception' do
+      before :each do
+        app.stub(:call) do
+          @calls ||= 0
+          @calls += 1
+          raise ThinkingSphinx::Search::StaleIdsException, [12] if @calls == 1
+        end
+      end
+
+      it "appends the ids to the without_ids filter" do
+        middleware.call [context]
+
+        search.options[:without_ids].should == [12]
+      end
+
+      it "respects existing without_ids filters" do
+        search.options[:without_ids] = [11]
+
+        middleware.call [context]
+
+        search.options[:without_ids].should == [11, 12]
+      end
+    end
+
+    context  'two stale ids exceptions' do
+      before :each do
+        app.stub(:call) do
+          @calls ||= 0
+          @calls += 1
+          raise ThinkingSphinx::Search::StaleIdsException, [12] if @calls == 1
+          raise ThinkingSphinx::Search::StaleIdsException, [13] if @calls == 2
+        end
+      end
+
+      it "appends the ids to the without_ids filter" do
+        middleware.call [context]
+
+        search.options[:without_ids].should == [12, 13]
+      end
+
+      it "respects existing without_ids filters" do
+        search.options[:without_ids] = [11]
+
+        middleware.call [context]
+
+        search.options[:without_ids].should == [11, 12, 13]
+      end
+    end
+
+    context 'three stale ids exceptions' do
+      before :each do
+        app.stub(:call) do
+          @calls ||= 0
+          @calls += 1
+
+          raise ThinkingSphinx::Search::StaleIdsException, [12] if @calls == 1
+          raise ThinkingSphinx::Search::StaleIdsException, [13] if @calls == 2
+          raise ThinkingSphinx::Search::StaleIdsException, [14] if @calls == 3
+        end
+      end
+
+      it "raises the final stale ids exceptions" do
+        lambda {
+          middleware.call [context]
+        }.should raise_error(ThinkingSphinx::Search::StaleIdsException) { |err|
+          err.ids.should == [14]
+        }
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/panes/attributes_pane_spec.rb

@@ -0,0 +1,21 @@
+module ThinkingSphinx
+  module Panes; end
+end
+
+require 'thinking_sphinx/panes/attributes_pane'
+
+describe ThinkingSphinx::Panes::AttributesPane do
+  let(:pane)    {
+    ThinkingSphinx::Panes::AttributesPane.new context, object, raw }
+  let(:context) { double('context') }
+  let(:object)  { double('object') }
+  let(:raw)     { {} }
+
+  describe '#sphinx_attributes' do
+    it "returns the object's sphinx attributes by default" do
+      raw['foo'] = 24
+
+      pane.sphinx_attributes.should == {'foo' => 24}
+    end
+  end
+end

data/spec/thinking_sphinx/panes/distance_pane_spec.rb

@@ -0,0 +1,41 @@
+module ThinkingSphinx
+  module Panes; end
+end
+
+require 'thinking_sphinx/panes/distance_pane'
+
+describe ThinkingSphinx::Panes::DistancePane do
+  let(:pane)    {
+    ThinkingSphinx::Panes::DistancePane.new context, object, raw }
+  let(:context) { double('context') }
+  let(:object)  { double('object') }
+  let(:raw)     { {} }
+
+  describe '#distance' do
+    it "returns the object's geodistance attribute by default" do
+      raw['geodist'] = 123.45
+
+      pane.distance.should == 123.45
+    end
+
+    it "converts string geodistances to floats" do
+      raw['geodist'] = '123.450'
+
+      pane.distance.should == 123.45
+    end
+  end
+
+  describe '#geodist' do
+    it "returns the object's geodistance attribute by default" do
+      raw['geodist'] = 123.45
+
+      pane.geodist.should == 123.45
+    end
+
+    it "converts string geodistances to floats" do
+      raw['geodist'] = '123.450'
+
+      pane.geodist.should == 123.45
+    end
+  end
+end

data/spec/thinking_sphinx/panes/excerpts_pane_spec.rb

@@ -0,0 +1,53 @@
+module ThinkingSphinx
+  module Panes; end
+end
+
+require 'thinking_sphinx/panes/excerpts_pane'
+
+describe ThinkingSphinx::Panes::ExcerptsPane do
+  let(:pane)    {
+    ThinkingSphinx::Panes::ExcerptsPane.new context, object, raw }
+  let(:context) { {:indices => [double(:name => 'foo_core')],
+    :meta => {}} }
+  let(:object)  { double('object') }
+  let(:raw)     { {} }
+  let(:search)  { double('search', :options => {}) }
+
+  before :each do
+    context.stub :search => search
+  end
+
+  describe '#excerpts' do
+    let(:excerpter) { double('excerpter') }
+    let(:excerpts)  { double('excerpts object') }
+
+    before :each do
+      stub_const 'ThinkingSphinx::Excerpter', double(:new => excerpter)
+      ThinkingSphinx::Panes::ExcerptsPane::Excerpts.stub :new => excerpts
+    end
+
+    it "returns an excerpt glazing" do
+      pane.excerpts.should == excerpts
+    end
+
+    it "creates an excerpter with the first index and all keywords" do
+      context[:indices] = [double(:name => 'alpha'), double(:name => 'beta')]
+      context[:meta]['keyword[0]'] = 'foo'
+      context[:meta]['keyword[1]'] = 'bar'
+
+      ThinkingSphinx::Excerpter.should_receive(:new).
+        with('alpha', 'foo bar', anything).and_return(excerpter)
+
+      pane.excerpts
+    end
+
+    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)
+
+      pane.excerpts
+    end
+  end
+end

data/spec/thinking_sphinx/panes/weight_pane_spec.rb

@@ -0,0 +1,20 @@
+module ThinkingSphinx
+  module Panes; end
+end
+
+require 'thinking_sphinx/panes/weight_pane'
+
+describe ThinkingSphinx::Panes::WeightPane do
+  let(:pane)    { ThinkingSphinx::Panes::WeightPane.new context, object, raw }
+  let(:context) { double('context') }
+  let(:object)  { double('object') }
+  let(:raw)     { {} }
+
+  describe '#weight' do
+    it "returns the object's weight by default" do
+      raw['@weight'] = 101
+
+      pane.weight.should == 101
+    end
+  end
+end

data/spec/thinking_sphinx/rake_interface_spec.rb

@@ -0,0 +1,147 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::RakeInterface do
+  let(:configuration) { double('configuration', :controller => controller) }
+  let(:interface)     { ThinkingSphinx::RakeInterface.new }
+
+  before :each do
+    ThinkingSphinx::Configuration.stub :instance => configuration
+    interface.stub(:puts => nil)
+  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')
+
+      interface.configure
+    end
+  end
+
+  describe '#index' do
+    let(:controller) { double('controller', :index => true) }
+
+    before :each do
+      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 "indexes all indices verbosely" do
+      controller.should_receive(:index).with(:verbose => true)
+
+      interface.index
+    end
+  end
+
+  describe '#start' do
+    let(:controller) { double('controller', :start => true, :pid => 101) }
+
+    before :each do
+      controller.stub(:running?).and_return(false, true)
+    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
+    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
+    end
+  end
+end

data/spec/thinking_sphinx/real_time/attribute_spec.rb

@@ -0,0 +1,62 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::RealTime::Attribute do
+  let(:attribute) { ThinkingSphinx::RealTime::Attribute.new column }
+  let(:column)    { double('column', :__name => :created_at, :__stack => []) }
+
+  describe '#name' do
+    it "uses the provided option by default" do
+      attribute = ThinkingSphinx::RealTime::Attribute.new column, :as => :foo
+      attribute.name.should == 'foo'
+    end
+
+    it "falls back to the column's name" do
+      attribute.name.should == 'created_at'
+    end
+  end
+
+  describe '#translate' do
+    let(:klass)  { Struct.new(:name, :parent) }
+    let(:object) { klass.new 'the object name', parent }
+    let(:parent) { klass.new 'the parent name', nil }
+
+    it "returns the column's name if it's a string" do
+      column.stub :__name => 'value'
+
+      attribute.translate(object).should == 'value'
+    end
+
+    it "returns the column's name if it's an integer" do
+      column.stub :__name => 404
+
+      attribute.translate(object).should == 404
+    end
+
+    it "returns the object's method matching the column's name" do
+      object.stub :created_at => 'a time'
+
+      attribute.translate(object).should == 'a time'
+    end
+
+    it "uses the column's stack to navigate through the object tree" do
+      column.stub :__name => :name, :__stack => [:parent]
+
+      attribute.translate(object).should == 'the parent name'
+    end
+
+    it "returns nil if any element in the object tree is nil" do
+      column.stub :__name => :name, :__stack => [:parent]
+      object.parent = nil
+
+      attribute.translate(object).should be_nil
+    end
+  end
+
+  describe '#type' do
+    it "returns the given type option" do
+      attribute = ThinkingSphinx::RealTime::Attribute.new column,
+        :type => :string
+      attribute.type.should == :string
+    end
+  end
+end