thinking-sphinx 2.1.0 → 3.0.0.pre

data/spec/thinking_sphinx/deltas/default_delta_spec.rb

@@ -0,0 +1,116 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::Deltas::DefaultDelta do
+  let(:delta)   { ThinkingSphinx::Deltas::DefaultDelta.new adapter }
+  let(:adapter) {
+    double('adapter', :quoted_table_name => 'articles', :quote => 'delta')
+  }
+
+  describe '#clause' do
+    context 'for a delta source' do
+      before :each do
+        adapter.stub :boolean_value => 't'
+      end
+
+      it "limits results to those flagged as deltas" do
+        delta.clause(true).should == "articles.delta = t"
+      end
+    end
+  end
+
+  describe '#delete' do
+    let(:config)     { double('config', :connection => connection) }
+    let(:connection) { double('connection', :query => nil) }
+    let(:index)      { double('index', :name => 'foo_core',
+      :document_id_for_key => 14) }
+    let(:instance)   { double('instance', :id => 7) }
+
+    before :each do
+      ThinkingSphinx::Configuration.stub :instance => config
+      Riddle::Query.stub :update => 'UPDATE STATEMENT'
+    end
+
+    it "updates the deleted flag to false" do
+      connection.should_receive(:query).with('UPDATE STATEMENT')
+
+      delta.delete 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('')
+
+      delta.delete 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('')
+
+      delta.delete 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('')
+
+      delta.delete index, instance
+    end
+
+    it "doesn't care about Sphinx errors" do
+      connection.stub(:query).and_raise(Mysql2::Error.new(''))
+
+      lambda { delta.delete index, instance }.should_not raise_error
+    end
+  end
+
+  describe '#index' do
+    let(:config)     { double('config', :controller => controller,
+      :settings => {}) }
+    let(:controller) { double('controller') }
+
+    before :each do
+      ThinkingSphinx::Configuration.stub :instance => config
+    end
+
+    it "indexes the given index" do
+      controller.should_receive(:index).with('foo_delta', :verbose => true)
+
+      delta.index double('index', :name => 'foo_delta')
+    end
+  end
+
+  describe '#reset_query' do
+    it "updates the table to set delta flags to false" do
+      adapter.stub(:boolean_value) { |value| value ? 't' : 'f' }
+      delta.reset_query.
+        should == 'UPDATE articles SET delta = f WHERE delta = t'
+    end
+  end
+
+  describe '#toggle' do
+    let(:instance) { double('instance') }
+
+    it "sets instance's delta flag to true" do
+      instance.should_receive(:delta=).with(true)
+
+      delta.toggle(instance)
+    end
+  end
+
+  describe '#toggled?' do
+    let(:instance) { double('instance') }
+
+    it "returns the delta flag value when true" do
+      instance.stub! :delta? => true
+
+      delta.toggled?(instance).should be_true
+    end
+
+    it "returns the delta flag value when false" do
+      instance.stub! :delta? => false
+
+      delta.toggled?(instance).should be_false
+    end
+  end
+end

data/spec/thinking_sphinx/deltas_spec.rb

@@ -0,0 +1,58 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::Deltas do
+  describe '.processor_for' do
+    it "returns the default processor class when given true" do
+      ThinkingSphinx::Deltas.processor_for(true).
+        should == ThinkingSphinx::Deltas::DefaultDelta
+    end
+
+    it "returns the class when given one" do
+      klass = Class.new
+      ThinkingSphinx::Deltas.processor_for(klass).should == klass
+    end
+  end
+
+  describe '.suspend' do
+    let(:config)     { double('config', :indices_for_references => [index]) }
+    let(:index)      { double('index', :name => 'user_core',
+      :delta_processor => processor) }
+    let(:processor)  { double('processor', :index => true) }
+
+    before :each do
+      ThinkingSphinx::Configuration.stub :instance => config
+    end
+
+    it "executes the given block" do
+      variable = :foo
+
+      ThinkingSphinx::Deltas.suspend :user do
+        variable = :bar
+      end
+
+      variable.should == :bar
+    end
+
+    it "suspends deltas within the block" do
+      ThinkingSphinx::Deltas.suspend :user do
+        ThinkingSphinx::Deltas.should be_suspended
+      end
+    end
+
+    it "removes the suspension after the block" do
+      ThinkingSphinx::Deltas.suspend :user do
+        #
+      end
+
+      ThinkingSphinx::Deltas.should_not be_suspended
+    end
+
+    it "processes the delta indices for the given reference" do
+      processor.should_receive(:index).with(index)
+
+      ThinkingSphinx::Deltas.suspend :user do
+        #
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/excerpter_spec.rb

@@ -1,49 +1,51 @@
 require 'spec_helper'
 
 describe ThinkingSphinx::Excerpter do
+  let(:excerpter)  { ThinkingSphinx::Excerpter.new('index', 'all words') }
+  let(:config)     { double('config', :connection => connection) }
+  let(:connection) {
+    double('connection', :query => [{'snippet' => 'some highlighted words'}])
+  }
+
   before :each do
-    @alpha      = Alpha.find(:first)
-    @search     = mock 'search', :excerpt_for => 'excerpted value'
-    @excerpter  = ThinkingSphinx::Excerpter.new(@search, @alpha)
-  end
-  
-  it "should not respond to id" do
-    @excerpter.should_not respond_to(:id)
+    ThinkingSphinx::Configuration.stub :instance => config
+    Riddle::Query.stub :snippets => 'CALL SNIPPETS'
   end
-  
-  describe '#method_missing' do
-    it "should return the excerpt from Sphinx" do
-      @excerpter.name.should == 'excerpted value'
-    end
-    
-    it "should send through the instance class to excerpt_for" do
-      @search.should_receive(:excerpt_for) do |string, model|
-        model.should == Alpha
-      end
-      
-      @excerpter.name
+
+  describe '#excerpt!' do
+    it "generates a snippets call" do
+      Riddle::Query.should_receive(:snippets).
+        with('all of the words', 'index', 'all words',
+          ThinkingSphinx::Excerpter::DefaultOptions).
+        and_return('CALL SNIPPETS')
+
+      excerpter.excerpt!('all of the words')
     end
-    
-    it "should use attribute methods for excerpts calls" do
-      @search.should_receive(:excerpt_for) do |string, model|
-        string.should == 'one'
-      end
-      
-      @excerpter.name
+
+    it "respects the provided options" do
+      excerpter = ThinkingSphinx::Excerpter.new('index', 'all words',
+        :before_match => '<b>', :chunk_separator => ' -- ')
+
+      Riddle::Query.should_receive(:snippets).
+        with('all of the words', 'index', 'all words',
+          :before_match => '<b>', :after_match => '</span>',
+          :chunk_separator => ' -- ').
+        and_return('CALL SNIPPETS')
+
+      excerpter.excerpt!('all of the words')
     end
-    
-    it "should use instance methods for excerpts calls" do
-      @search.should_receive(:excerpt_for) do |string, model|
-        string.should == 'ONE'
-      end
-      
-      @excerpter.big_name
+
+    it "sends the snippets call to Sphinx" do
+      connection.should_receive(:query).with('CALL SNIPPETS').
+        and_return([{'snippet' => ''}])
+
+      excerpter.excerpt!('all of the words')
     end
-    
-    it "should still raise an exception if no column or method exists" do
-      lambda {
-        @excerpter.foo
-      }.should raise_error(NoMethodError)
+
+    it "returns the first value returned by Sphinx" do
+      connection.stub :query => [{'snippet' => 'some highlighted words'}]
+
+      excerpter.excerpt!('all of the words').should == 'some highlighted words'
     end
   end
 end

data/spec/thinking_sphinx/facet_search_spec.rb

@@ -1,176 +1,74 @@
-require 'spec_helper'
+module ThinkingSphinx; end
+
+require 'thinking_sphinx/facet_search'
+require 'thinking_sphinx/facet'
 
 describe ThinkingSphinx::FacetSearch do
-  let(:search) { stub('search', :append_to => nil, :empty? => true) }
-  let(:config) { ThinkingSphinx::Configuration.instance }
-  let(:client) { stub('client', :run => []) }
+  let(:facet_search)  { ThinkingSphinx::FacetSearch.new '', {} }
+  let(:batch)         { double('batch', :searches => [], :populate => true) }
+  let(:index_set)     { [] }
+  let(:index)         { double('index', :facets => [property],
+    :name => 'foo_core') }
+  let(:property)      { double('property', :name => 'price_bracket',
+    :multi? => false)}
 
   before :each do
-    ThinkingSphinx::Connection.stub!(:take).and_yield(client)
-  end
-
-  describe 'populate' do
-    before :each do
-      config.configuration.searchd.max_matches = 10_000
-    end
-
-    it "should request all shared facets in a multi-model request by default" do
-      ThinkingSphinx.stub!(:search => search)
-      if Riddle.loaded_version.to_i < 2
-        ThinkingSphinx::FacetSearch.new.facet_names.should == ['class_crc']
-      else
-        ThinkingSphinx::FacetSearch.new.facet_names.should == ['sphinx_internal_class']
-      end
-    end
+    stub_const 'ThinkingSphinx::IndexSet',      double(:new => index_set)
+    stub_const 'ThinkingSphinx::BatchedSearch', double(:new => batch)
+    stub_const 'ThinkingSphinx::Search',        DumbSearch
 
-    it "should request all facets in a multi-model request if specified" do
-      ThinkingSphinx.stub!(:search => search)
-      names = ThinkingSphinx::FacetSearch.new(:all_facets => true).facet_names
+    index_set << index << double('index', :facets => [], :name => 'bar_core')
+  end
 
-      if Riddle.loaded_version.to_i < 2
-        names.should == ['class_crc', 'city_facet', 'state_facet', 'birthday']
-      else
-        names.should == ['sphinx_internal_class', 'city_facet', 'state_facet', 'birthday']
-      end
+  DumbSearch = ::Struct.new(:query, :options) do
+    def raw
+      [{
+        'sphinx_internal_class' => 'Foo',
+        'price_bracket'         => 3,
+        'tag_ids'               => '1,2',
+        '@count'                => 5,
+        '@groupby'              => 2
+      }]
     end
+  end
 
-    it "should use the system-set max_matches for limit on facet calls" do
-      ThinkingSphinx.should_receive(:search) do |options|
-        options[:max_matches].should  == 10_000
-        options[:limit].should        == 10_000
-        search
-      end
-
-      ThinkingSphinx::FacetSearch.new
+  describe '#[]' do
+    it "populates facet results" do
+      facet_search[:price_bracket].should == {3 => 5}
     end
+  end
 
-    it "should use the default max-matches if there is no explicit setting" do
-      config.configuration.searchd.max_matches = nil
-      ThinkingSphinx.should_receive(:search) do |options|
-        options[:max_matches].should  == 1000
-        options[:limit].should        == 1000
-        search
-      end
-
-      ThinkingSphinx::FacetSearch.new
-    end
+  describe '#populate' do
+    it "queries on each facet with a grouped search in a batch" do
+      facet_search.populate
 
-    it "should ignore user-provided max_matches and limit on facet calls" do
-      ThinkingSphinx.should_receive(:search) do |options|
-        options[:max_matches].should  == 10_000
-        options[:limit].should        == 10_000
-        search
-      end
-
-      ThinkingSphinx::FacetSearch.new(
-        :max_matches    => 500,
-        :limit          => 200
-      )
+      batch.searches.detect { |search|
+        search.options[:group_by] == 'price_bracket'
+      }.should_not be_nil
     end
 
-    it "should not use an explicit :page" do
-      ThinkingSphinx.should_receive(:search) do |options|
-        options[:page].should == 1
-        search
-      end
+    it "limits query for a facet to just indices that have that facet" do
+      facet_search.populate
 
-      ThinkingSphinx::FacetSearch.new(:page => 3)
+      batch.searches.detect { |search|
+        search.options[:indices] == ['foo_core']
+      }.should_not be_nil
     end
 
-    describe "conflicting facets" do
-      before :each do
-        @index = ThinkingSphinx::Index::Builder.generate(Alpha) do
-          indexes :name
-          has :value, :as => :city, :facet => true
-        end
-      end
-
-      after :each do
-        Alpha.sphinx_facets.delete_at(-1)
-      end
-
-      it "should raise an error if searching with facets of same name but different type" do
-        lambda {
-          facets = ThinkingSphinx.facets :all_facets => true
-        }.should raise_error
-      end
-    end
+    it "aliases the class facet from sphinx_internal_class" do
+      property.stub :name => 'sphinx_internal_class'
 
-    describe ':facets option' do
-      it "should limit facets to the requested set" do
-        ThinkingSphinx.should_receive(:search).once.and_return(search)
-
-        ThinkingSphinx::FacetSearch.new(
-          :classes => [Person], :facets => :state
-        )
-      end
-    end
+      facet_search.populate
 
-    describe "empty result set for attributes" do
-      before :each do
-        ThinkingSphinx.stub!(:search => search)
-        @facets = ThinkingSphinx::FacetSearch.new(
-          :classes => [Person], :facets => :state
-        )
-      end
-
-      it "should add key as attribute" do
-        @facets.should have_key(:state)
-      end
-
-      it "should return an empty hash for the facet results" do
-        @facets[:state].should be_empty
-      end
+      facet_search[:class].should == {'Foo' => 5}
     end
 
-    describe "non-empty result set" do
-      before :each do
-        @person = Person.find(:first)
-        @people = [@person]
-        search.stub!(:empty? => false)
-        search.stub!(:each_with_match).
-          and_yield(@person, {:attributes => {'@groupby' => @person.city.to_crc32, '@count' => 1}})
-        ThinkingSphinx::Search.stub!(:bundle_searches => [search])
-
-        @facets = ThinkingSphinx::FacetSearch.new(
-          :classes => [Person], :facets => :city
-        )
-      end
-
-      it "should return a hash" do
-        @facets.should be_a_kind_of(Hash)
-      end
-
-      it "should add key as attribute" do
-        @facets.keys.should include(:city)
-      end
-
-      it "should return a hash" do
-        @facets[:city].should == {@person.city => 1}
-      end
-    end
-  end
-
-  describe "#for" do
-    before do
-      @person = Person.find(:first)
-      @people = [@person]
-      search.stub!(:each_with_match).
-        and_yield(@person, {:attributes => {'@groupby' => @person.city.to_crc32, '@count' => 1}})
-      ThinkingSphinx::Search.stub!(:bundle_searches => [search])
-
-      @facets = ThinkingSphinx::FacetSearch.new(
-        :classes => [Person], :facets => :city
-      )
-    end
+    it "uses the @groupby value for MVAs" do
+      property.stub :name => 'tag_ids', :multi? => true
 
-    it "should return the search results for the attribute and key pair" do
-      ThinkingSphinx.should_receive(:search) do |options|
-        options[:with].should have_key('city_facet')
-        options[:with]['city_facet'].should == @person.city.to_crc32
-      end
+      facet_search.populate
 
-      @facets.for(:city => @person.city)
+      facet_search[:tag_ids].should == {2 => 5}
     end
   end
 end