thinking-sphinx 3.0.3 → 3.0.4

data/spec/thinking_sphinx/connection_spec.rb

@@ -4,13 +4,16 @@ describe ThinkingSphinx::Connection do
   describe '.take' do
     let(:pool)             { double 'pool' }
     let(:connection)       { double 'connection' }
-    let(:error)            { Mysql2::Error.new '' }
+    let(:error)            { ThinkingSphinx::QueryExecutionError.new 'failed' }
     let(:translated_error) { ThinkingSphinx::SphinxError.new }
 
     before :each do
       ThinkingSphinx::Connection.stub :pool => pool
       ThinkingSphinx::SphinxError.stub :new_from_mysql => translated_error
       pool.stub(:take).and_yield(connection)
+
+      error.statement            = 'SELECT * FROM article_core'
+      translated_error.statement = 'SELECT * FROM article_core'
     end
 
     it "yields a connection from the pool" do

data/spec/thinking_sphinx/deletion_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::Deletion do
+  describe '.perform' do
+    let(:connection) { double('connection', :execute => nil) }
+    let(:index)      { double('index', :name => 'foo_core',
+      :document_id_for_key => 14, :type => 'plain') }
+    let(:instance)   { double('instance', :id => 7) }
+    let(:pool)       { double 'pool' }
+
+    before :each do
+      ThinkingSphinx::Connection.stub :pool => pool
+      Riddle::Query.stub :update => 'UPDATE STATEMENT'
+
+      pool.stub(:take).and_yield(connection)
+    end
+
+    context 'index is SQL-backed' do
+      it "updates the deleted flag to false" do
+        connection.should_receive(:execute).with('UPDATE STATEMENT')
+
+        ThinkingSphinx::Deletion.perform index, instance
+      end
+
+      it "builds the update query for the given index" do
+        Riddle::Query.should_receive(:update).
+          with('foo_core', anything, anything).and_return('')
+
+        ThinkingSphinx::Deletion.perform index, instance
+      end
+
+      it "builds the update query for the sphinx document id" do
+        Riddle::Query.should_receive(:update).
+          with(anything, 14, anything).and_return('')
+
+        ThinkingSphinx::Deletion.perform index, instance
+      end
+
+      it "builds the update query for setting sphinx_deleted to true" do
+        Riddle::Query.should_receive(:update).
+          with(anything, anything, :sphinx_deleted => true).and_return('')
+
+        ThinkingSphinx::Deletion.perform index, instance
+      end
+
+      it "doesn't care about Sphinx errors" do
+        connection.stub(:execute).and_raise(Mysql2::Error.new(''))
+
+        lambda {
+          ThinkingSphinx::Deletion.perform index, instance
+        }.should_not raise_error
+      end
+    end
+
+    context "index is real-time" do
+      before :each do
+        index.stub :type => 'rt'
+      end
+
+      it "deletes the record to false" do
+        connection.should_receive(:execute).
+          with('DELETE FROM foo_core WHERE id = 14')
+
+        ThinkingSphinx::Deletion.perform index, instance
+      end
+
+      it "doesn't care about Sphinx errors" do
+        connection.stub(:execute).and_raise(Mysql2::Error.new(''))
+
+        lambda {
+          ThinkingSphinx::Deletion.perform index, instance
+        }.should_not raise_error
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/facet_search_spec.rb

@@ -7,15 +7,21 @@ describe ThinkingSphinx::FacetSearch do
   let(:facet_search)  { ThinkingSphinx::FacetSearch.new '', {} }
   let(:batch)         { double('batch', :searches => [], :populate => true) }
   let(:index_set)     { [] }
-  let(:index)         { double('index', :facets => [property],
+  let(:index)         { double('index', :facets => [property_a, property_b],
     :name => 'foo_core') }
-  let(:property)      { double('property', :name => 'price_bracket',
-    :multi? => false)}
+  let(:property_a)    { double('property', :name => 'price_bracket',
+    :multi? => false) }
+  let(:property_b)    { double('property', :name => 'category_id',
+    :multi? => false) }
+  let(:configuration) { double 'configuration', :settings => {} }
 
   before :each do
     stub_const 'ThinkingSphinx::IndexSet',      double(:new => index_set)
     stub_const 'ThinkingSphinx::BatchedSearch', double(:new => batch)
     stub_const 'ThinkingSphinx::Search',        DumbSearch
+    stub_const 'ThinkingSphinx::Middlewares::RAW_ONLY', double
+    stub_const 'ThinkingSphinx::Configuration',
+      double(:instance => configuration)
 
     index_set << index << double('index', :facets => [], :name => 'bar_core')
   end
@@ -26,6 +32,7 @@ describe ThinkingSphinx::FacetSearch do
         'sphinx_internal_class' => 'Foo',
         'price_bracket'         => 3,
         'tag_ids'               => '1,2',
+        'category_id'           => 11,
         '@count'                => 5,
         '@groupby'              => 2
       }]
@@ -55,8 +62,18 @@ describe ThinkingSphinx::FacetSearch do
       }.should_not be_nil
     end
 
+    it "limits facets to the specified set" do
+      facet_search.options[:facets] = [:category_id]
+
+      facet_search.populate
+
+      batch.searches.collect { |search|
+        search.options[:group_by]
+      }.should == ['category_id']
+    end
+
     it "aliases the class facet from sphinx_internal_class" do
-      property.stub :name => 'sphinx_internal_class'
+      property_a.stub :name => 'sphinx_internal_class'
 
       facet_search.populate
 
@@ -64,11 +81,43 @@ describe ThinkingSphinx::FacetSearch do
     end
 
     it "uses the @groupby value for MVAs" do
-      property.stub :name => 'tag_ids', :multi? => true
+      property_a.stub :name => 'tag_ids', :multi? => true
 
       facet_search.populate
 
       facet_search[:tag_ids].should == {2 => 5}
     end
+
+    [:max_matches, :limit].each do |setting|
+      it "sets #{setting} in each search" do
+        facet_search.populate
+
+        batch.searches.each { |search|
+          search.options[setting].should == 1000
+        }
+      end
+
+      it "respects configured max_matches values for #{setting}" do
+        configuration.settings['max_matches'] = 1234
+
+        facet_search.populate
+
+        batch.searches.each { |search|
+          search.options[setting].should == 1234
+        }
+      end
+    end
+
+    [:limit, :per_page].each do |setting|
+      it "respects #{setting} option if set" do
+        facet_search = ThinkingSphinx::FacetSearch.new '', {setting => 42}
+
+        facet_search.populate
+
+        batch.searches.each { |search|
+          search.options[setting].should == 42
+        }
+      end
+    end
   end
 end

data/spec/thinking_sphinx/panes/excerpts_pane_spec.rb

@@ -7,11 +7,10 @@ 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(:context) { {:indices => [double(:name => 'foo_core')]} }
   let(:object)  { double('object') }
   let(:raw)     { {} }
-  let(:search)  { double('search', :options => {}) }
+  let(:search)  { double('search', :query => 'foo', :options => {}) }
 
   before :each do
     context.stub :search => search
@@ -30,10 +29,9 @@ describe ThinkingSphinx::Panes::ExcerptsPane do
       pane.excerpts.should == excerpts
     end
 
-    it "creates an excerpter with the first index and all keywords" do
+    it "creates an excerpter with the first index and the query and conditions values" do
       context[:indices] = [double(:name => 'alpha'), double(:name => 'beta')]
-      context[:meta]['keyword[0]'] = 'foo'
-      context[:meta]['keyword[1]'] = 'bar'
+      context.search.options[:conditions] = {:baz => 'bar'}
 
       ThinkingSphinx::Excerpter.should_receive(:new).
         with('alpha', 'foo bar', anything).and_return(excerpter)

data/spec/thinking_sphinx/rake_interface_spec.rb

@@ -9,6 +9,32 @@ describe ThinkingSphinx::RakeInterface do
     interface.stub(:puts => nil)
   end
 
+  describe '#clear' 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
+    end
+
+    it "removes the directory for the binlog files" do
+      FileUtils.should_receive(:rm_r).with('/path/to/binlog')
+
+      interface.clear
+    end
+  end
+
   describe '#configure' do
     let(:controller) { double('controller') }
 
@@ -86,6 +112,15 @@ describe ThinkingSphinx::RakeInterface do
 
     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

data/spec/thinking_sphinx/real_time/callbacks/real_time_callbacks_spec.rb

@@ -2,7 +2,7 @@ require 'spec_helper'
 
 describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
   let(:callbacks)  {
-    ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.new instance
+    ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.new :article
   }
   let(:instance)   { double('instance', :id => 12) }
   let(:config)     { double('config', :indices_for_references => [index]) }
@@ -16,30 +16,6 @@ describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
     ThinkingSphinx::Connection.stub_chain(:pool, :take).and_yield connection
   end
 
-  describe '.after_save' do
-    let(:callbacks) { double('callbacks', :after_save => nil) }
-
-    before :each do
-      ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.
-        stub :new => callbacks
-    end
-
-    it "builds an object from the instance" do
-      ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.
-        should_receive(:new).with(instance).and_return(callbacks)
-
-      ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.
-        after_save(instance)
-    end
-
-    it "invokes after_save on the object" do
-      callbacks.should_receive(:after_save)
-
-      ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.
-        after_save(instance)
-    end
-  end
-
   describe '#after_save' do
     let(:insert)     { double('insert', :to_sql => 'REPLACE INTO my_index') }
     let(:time)       { 1.day.ago }
@@ -59,19 +35,83 @@ describe ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks do
         with('my_index', ['id', 'name', 'created_at'], [123, 'Foo', time]).
         and_return(insert)
 
-      callbacks.after_save
+      callbacks.after_save instance
     end
 
     it "switches the insert to a replace statement" do
       insert.should_receive(:replace!).and_return(insert)
 
-      callbacks.after_save
+      callbacks.after_save instance
     end
 
     it "sends the insert through to the server" do
       connection.should_receive(:execute).with('REPLACE INTO my_index')
 
-      callbacks.after_save
+      callbacks.after_save instance
+    end
+
+    context 'with a given path' do
+      let(:callbacks)  {
+        ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.new(
+          :article, [:user]
+        )
+      }
+      let(:instance)   { double('instance', :id => 12, :user => user) }
+      let(:user)       { double('user', :id => 13) }
+
+      it "creates an insert statement with all fields and attributes" do
+        Riddle::Query::Insert.should_receive(:new).
+          with('my_index', ['id', 'name', 'created_at'], [123, 'Foo', time]).
+          and_return(insert)
+
+        callbacks.after_save instance
+      end
+
+      it "gets the document id for the user object" do
+        index.should_receive(:document_id_for_key).with(13).and_return(123)
+
+        callbacks.after_save instance
+      end
+
+      it "translates values for the user object" do
+        field.should_receive(:translate).with(user).and_return('Foo')
+
+        callbacks.after_save instance
+      end
+    end
+
+    context 'with a path returning multiple objects' do
+      let(:callbacks)  {
+        ThinkingSphinx::RealTime::Callbacks::RealTimeCallbacks.new(
+          :article, [:readers]
+        )
+      }
+      let(:instance)   { double('instance', :id => 12,
+        :readers => [user_a, user_b]) }
+      let(:user_a)     { double('user', :id => 13) }
+      let(:user_b)     { double('user', :id => 14) }
+
+      it "creates insert statements with all fields and attributes" do
+        Riddle::Query::Insert.should_receive(:new).twice.
+          with('my_index', ['id', 'name', 'created_at'], [123, 'Foo', time]).
+          and_return(insert)
+
+        callbacks.after_save instance
+      end
+
+      it "gets the document id for each reader" do
+        index.should_receive(:document_id_for_key).with(13).and_return(123)
+        index.should_receive(:document_id_for_key).with(14).and_return(123)
+
+        callbacks.after_save instance
+      end
+
+      it "translates values for each reader" do
+        field.should_receive(:translate).with(user_a).and_return('Foo')
+        field.should_receive(:translate).with(user_b).and_return('Foo')
+
+        callbacks.after_save instance
+      end
     end
   end
 end

data/spec/thinking_sphinx/search/glaze_spec.rb

@@ -50,6 +50,25 @@ describe ThinkingSphinx::Search::Glaze do
     end
   end
 
+  describe '#respond_to?' do
+    it "responds to underlying object methods" do
+      object.stub :foo => true
+
+      glaze.respond_to?(:foo).should be_true
+    end
+
+    it "responds to underlying pane methods" do
+      pane  = double('Pane Class', :new => double('pane', :bar => true))
+      glaze = ThinkingSphinx::Search::Glaze.new context, object, raw, [pane]
+
+      glaze.respond_to?(:bar).should be_true
+    end
+
+    it "does not to respond to methods that don't exist" do
+      glaze.respond_to?(:something).should be_false
+    end
+  end
+
   describe '#unglazed' do
     it "returns the original object" do
       glaze.unglazed.should == object

data/spec/thinking_sphinx/search/query_spec.rb

@@ -39,9 +39,34 @@ describe ThinkingSphinx::Search::Query do
 
     it "does not star the sphinx_internal_class field keyword" do
       query = ThinkingSphinx::Search::Query.new '',
-        {:sphinx_internal_class => 'article'}, true
+        {:sphinx_internal_class_name => 'article'}, true
 
-      query.to_s.should == '@sphinx_internal_class article'
+      query.to_s.should == '@sphinx_internal_class_name article'
+    end
+
+    it "treats escapes as word characters" do
+      query = ThinkingSphinx::Search::Query.new '', {:title => 'sauce\\@pan'},
+        true
+
+      query.to_s.should == '@title *sauce\\@pan*'
+    end
+
+    it "does not star manually provided field tags" do
+      query = ThinkingSphinx::Search::Query.new "@title pan", {}, true
+
+      query.to_s.should == "@title *pan*"
+    end
+
+    it "does not star manually provided arrays of field tags" do
+      query = ThinkingSphinx::Search::Query.new "@(title, body) pan", {}, true
+
+      query.to_s.should == "@(title, body) *pan*"
+    end
+
+    it "stars keywords that begin with an escaped @" do
+      query = ThinkingSphinx::Search::Query.new "\\@pan", {}, true
+
+      query.to_s.should == "*\\@pan*"
     end
 
     it "handles null values by removing them from the conditions hash" do
@@ -56,6 +81,18 @@ describe ThinkingSphinx::Search::Query do
       query.to_s.should == ''
     end
 
+    it "handles nil queries" do
+      query = ThinkingSphinx::Search::Query.new nil, {}
+
+      query.to_s.should == ''
+    end
+
+    it "handles nil queries when starring" do
+      query = ThinkingSphinx::Search::Query.new nil, {}, true
+
+      query.to_s.should == ''
+    end
+
     it "allows mixing of blank and non-blank conditions" do
       query = ThinkingSphinx::Search::Query.new 'tasty', :title => 'pancakes',
         :ingredients => nil