thinking-sphinx 1.5.0 → 2.0.0.rc1

data/spec/thinking_sphinx/context_spec.rb

@@ -1,126 +1,126 @@
 require 'spec_helper'
 
 describe ThinkingSphinx::Context do
-  let(:ts_context) { ThinkingSphinx::Context.new }
-
+  before :each do
+    @context = ThinkingSphinx::Context.new
+  end
+  
   describe '#prepare' do
-    let(:config)           { ThinkingSphinx::Configuration.instance }
-    let(:file_name)        { 'a.rb' }
-    let(:model_name_lower) { 'a' }
-    let(:class_name)       { 'A' }
-
     before :each do
-      config.model_directories = ['']
+      @config = ThinkingSphinx::Configuration.instance
+      @config.model_directories = ['']
 
-      file_name.stub!(:gsub).and_return(model_name_lower)
-      model_name_lower.stub!(:camelize).and_return(class_name)
-      Dir.stub(:[]).and_return([file_name])
+      @file_name        = 'a.rb'
+      @model_name_lower = 'a'
+      @class_name       = 'A'
+
+      @file_name.stub!(:gsub).and_return(@model_name_lower)
+      @model_name_lower.stub!(:camelize).and_return(@class_name)
+      Dir.stub(:[]).and_return([@file_name])
     end
 
     it "should load the files by guessing the file name" do
-      class_name.should_receive(:constantize).and_return(true)
+      @class_name.should_receive(:constantize).and_return(true)
 
-      ts_context.prepare
+      @context.prepare
     end
 
     it "should not raise errors if the model name is nil" do
-      file_name.stub!(:gsub).and_return(nil)
+      @file_name.stub!(:gsub).and_return(nil)
 
       lambda {
-        ts_context.prepare
+        @context.prepare
       }.should_not raise_error
     end
 
-    it "should report name errors but not raise them" do
-      class_name.stub(:constantize).and_raise(NameError)
-      STDERR.stub!(:puts => '')
-      STDERR.should_receive(:puts).with('Warning: Error loading a.rb:')
+    it "should not raise errors if the file name does not represent a class name" do
+      @class_name.should_receive(:constantize).and_raise(NameError)
 
       lambda {
-        ts_context.prepare
+        @context.prepare
       }.should_not raise_error
     end
 
-    it "should retry if the first load fails and contains a directory" do
-      model_name_lower.should_receive(:gsub!).twice.and_return(true, nil)
-      class_name.stub(:constantize).and_raise(LoadError)
+    it "should retry if the first pass fails and contains a directory" do
+      @model_name_lower.stub!(:gsub!).and_return(true, nil)
+      @class_name.stub(:constantize).and_raise(LoadError)
+      @model_name_lower.should_receive(:camelize).twice
 
       lambda {
-        ts_context.prepare
+        @context.prepare
       }.should_not raise_error
     end
 
     it "should catch database errors with a warning" do
-      class_name.should_receive(:constantize).and_raise(Mysql2::Error)
-      STDERR.stub!(:puts => '')
-      STDERR.should_receive(:puts).with('Warning: Error loading a.rb:')
+      @class_name.should_receive(:constantize).and_raise(Mysql::Error)
+      STDERR.should_receive(:puts).with('Warning: Error loading a.rb')
 
       lambda {
-        ts_context.prepare
+        @context.prepare
       }.should_not raise_error
-    end unless RUBY_PLATFORM == 'java'
-
+    end
+    
     it "should not load models if they're explicitly set in the configuration" do
-      config.indexed_models = ['Alpha', 'Beta']
-      ts_context.prepare
-
-      ts_context.indexed_models.should == ['Alpha', 'Beta']
+      @config.indexed_models = ['Alpha', 'Beta']
+      @context.prepare
+      
+      @context.indexed_models.should == ['Alpha', 'Beta']
     end
   end
-
+  
   describe '#define_indexes' do
     it "should call define_indexes on all known indexed models" do
-      ts_context.stub!(:indexed_models => ['Alpha', 'Beta'])
+      @context.stub!(:indexed_models => ['Alpha', 'Beta'])
       Alpha.should_receive(:define_indexes)
       Beta.should_receive(:define_indexes)
-
-      ts_context.define_indexes
+      
+      @context.define_indexes
     end
   end
-
+  
   describe '#add_indexed_model' do
     before :each do
-      ts_context.indexed_models.clear
+      @context.indexed_models.clear
     end
-
+    
     it "should add the model to the collection" do
-      ts_context.add_indexed_model 'Alpha'
-
-      ts_context.indexed_models.should == ['Alpha']
+      @context.add_indexed_model 'Alpha'
+      
+      @context.indexed_models.should == ['Alpha']
     end
-
+    
     it "should not duplicate models in the collection" do
-      ts_context.add_indexed_model 'Alpha'
-      ts_context.add_indexed_model 'Alpha'
-
-      ts_context.indexed_models.should == ['Alpha']
+      @context.add_indexed_model 'Alpha'
+      @context.add_indexed_model 'Alpha'
+      
+      @context.indexed_models.should == ['Alpha']
     end
-
+    
     it "should keep the collection in alphabetical order" do
-      ts_context.add_indexed_model 'Beta'
-      ts_context.add_indexed_model 'Alpha'
-
-      ts_context.indexed_models.should == ['Alpha', 'Beta']
+      @context.add_indexed_model 'Beta'
+      @context.add_indexed_model 'Alpha'
+      
+      @context.indexed_models.should == ['Alpha', 'Beta']
     end
-
+    
     it "should translate classes to their names" do
-      ts_context.add_indexed_model Alpha
-
-      ts_context.indexed_models.should == ['Alpha']
+      @context.add_indexed_model Alpha
+      
+      @context.indexed_models.should == ['Alpha']
     end
   end
-
+  
   describe '#superclass_indexed_models' do
     it "should return indexed model names" do
-      ts_context.stub!(:indexed_models => ['Alpha', 'Beta'])
-
-      ts_context.superclass_indexed_models.should == ['Alpha', 'Beta']
+      @context.stub!(:indexed_models => ['Alpha', 'Beta'])
+      
+      @context.superclass_indexed_models.should == ['Alpha', 'Beta']
     end
-
+    
     it "should not include classes which have indexed superclasses" do
-      ts_context.stub!(:indexed_models => ['Parent', 'Person'])
-
-      ts_context.superclass_indexed_models.should == ['Person']
+      @context.stub!(:indexed_models => ['Parent', 'Person'])
+      
+      @context.superclass_indexed_models.should == ['Person']
     end
   end
 end

data/spec/thinking_sphinx/facet_search_spec.rb

@@ -1,82 +1,136 @@
 require 'spec_helper'
 
 describe ThinkingSphinx::FacetSearch do
-  let(:search) { stub('search', :append_to => nil, :empty? => true) }
-  let(:config) { ThinkingSphinx::Configuration.instance }
-  let(:client) { stub('client', :run => []) }
-
-  before :each do
-    ThinkingSphinx::Connection.stub!(:take).and_yield(client)
-  end
-
   describe 'populate' do
-    before :each do
-      config.configuration.searchd.max_matches = 10_000
+    it "should make separate Sphinx queries for each facet" do
+      ThinkingSphinx.should_receive(:search).with(
+        hash_including(:group_by => 'city_facet')
+      ).and_return([])
+      ThinkingSphinx.should_receive(:search).with(
+        hash_including(:group_by => 'state_facet')
+      ).and_return([])
+      ThinkingSphinx.should_receive(:search).with(
+        hash_including(:group_by => 'birthday')
+      ).and_return([])
+      
+      ThinkingSphinx::FacetSearch.new(:classes => [Person])
     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
+      ThinkingSphinx.stub!(:search => [])
+      ThinkingSphinx::FacetSearch.new.facet_names.should == ['class_crc']
     end
-
+    
     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
+      ThinkingSphinx.stub!(:search => [])
+      ThinkingSphinx::FacetSearch.new(
+        :all_facets => true
+      ).facet_names.should == [
+        'class_crc', 'city_facet', 'state_facet', 'birthday'
+      ]
+    end
+    
+    describe ':facets option' do
+      it "should limit facets to the requested set" do
+        ThinkingSphinx.should_receive(:search).once.and_return([])
+        
+        ThinkingSphinx::FacetSearch.new(
+          :classes => [Person], :facets => :state
+        )
+      end
+    end
+    
+    describe "empty result set for attributes" do
+      before :each do
+        ThinkingSphinx.stub!(:search => [])
+        @facets = ThinkingSphinx::FacetSearch.new(
+          :classes => [Person], :facets => :state
+        )
+      end
+      
+      it "should add key as attribute" do
+        @facets.should have_key(:state)
+      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']
+      it "should return an empty hash for the facet results" do
+        @facets[:state].should be_empty
       end
     end
 
+    describe "non-empty result set" do
+      before :each do
+        @person = Person.find(:first)
+        @people = [@person]
+        @people.stub!(:each_with_groupby_and_count).
+          and_yield(@person, @person.city.to_crc32, 1)
+        ThinkingSphinx.stub!(:search => @people)
+        
+        @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
+    
+    before :each do
+      @config = ThinkingSphinx::Configuration.instance
+      @config.configuration.searchd.max_matches = 10_000
+    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
     end
-
+    
     it "should use the default max-matches if there is no explicit setting" do
-      config.configuration.searchd.max_matches = nil
+      @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
-
+    
     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
       )
     end
-
+    
     it "should not use an explicit :page" do
       ThinkingSphinx.should_receive(:search) do |options|
         options[:page].should == 1
-        search
+        []
       end
-
+      
       ThinkingSphinx::FacetSearch.new(:page => 3)
     end
-
+    
     describe "conflicting facets" do
       before :each do
         @index = ThinkingSphinx::Index::Builder.generate(Alpha) do
@@ -84,81 +138,27 @@ describe ThinkingSphinx::FacetSearch do
           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
-
-    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
-
-    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
-    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])
-
+      @people.stub!(:each_with_groupby_and_count).
+        and_yield(@person, @person.city.to_crc32, 1)
+      ThinkingSphinx.stub!(:search => @people)
+      
       @facets = ThinkingSphinx::FacetSearch.new(
         :classes => [Person], :facets => :city
       )
@@ -169,7 +169,7 @@ describe ThinkingSphinx::FacetSearch do
         options[:with].should have_key('city_facet')
         options[:with]['city_facet'].should == @person.city.to_crc32
       end
-
+      
       @facets.for(:city => @person.city)
     end
   end