thinking-sphinx 3.1.2 → 3.1.3

data/spec/thinking_sphinx/active_record/callbacks/delta_callbacks_spec.rb

@@ -46,7 +46,7 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
     }
 
     before :each do
-      ThinkingSphinx::IndexSet.stub :new => [index]
+      config.stub :index_set_class => double(:new => [index])
     end
 
     context 'without delta indices' do
@@ -72,7 +72,9 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
       before :each do
         ThinkingSphinx::Deltas.stub :suspended? => false
 
-        ThinkingSphinx::IndexSet.stub :new => [core_index, delta_index]
+        config.stub :index_set_class => double(
+          :new => [core_index, delta_index]
+        )
       end
 
       it "only indexes delta indices" do
@@ -127,7 +129,7 @@ describe ThinkingSphinx::ActiveRecord::Callbacks::DeltaCallbacks do
     }
 
     before :each do
-      ThinkingSphinx::IndexSet.stub :new => [index]
+      config.stub :index_set_class => double(:new => [index])
     end
 
     it "sets delta to true if there are delta indices" do

data/spec/thinking_sphinx/active_record/filter_reflection_spec.rb

@@ -0,0 +1,172 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::FilterReflection do
+  describe '.call' do
+    let(:reflection) { double('Reflection', :macro => :has_some,
+      :options => options, :active_record => double, :name => 'baz',
+      :foreign_type => :foo_type, :class => reflection_klass) }
+    let(:options)    { {:polymorphic => true} }
+    let(:filtered_reflection) { double 'filtered reflection' }
+    let(:reflection_klass)    { double :new => filtered_reflection }
+
+    before :each do
+      reflection.active_record.stub_chain(:connection, :quote_column_name).
+        and_return('"foo_type"')
+    end
+
+    it "uses the existing reflection's macro" do
+      reflection_klass.should_receive(:new).
+        with(:has_some, anything, anything, anything)
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end unless defined?(ActiveRecord::Reflection::MacroReflection)
+
+    it "uses the supplied name" do
+      if defined?(ActiveRecord::Reflection::MacroReflection)
+        reflection_klass.should_receive(:new).
+          with('foo_bar', anything, anything, anything)
+      else
+        reflection_klass.should_receive(:new).
+          with(anything, 'foo_bar', anything, anything)
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "uses the existing reflection's parent" do
+      if defined?(ActiveRecord::Reflection::MacroReflection)
+        reflection_klass.should_receive(:new).
+          with(anything, anything, anything, reflection.active_record)
+      else
+        reflection_klass.should_receive(:new).
+          with(anything, anything, anything, reflection.active_record)
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "removes the polymorphic setting from the options" do
+      if defined?(ActiveRecord::Reflection::MacroReflection)
+        reflection_klass.should_receive(:new) do |name, scope, options, parent|
+          options[:polymorphic].should be_nil
+        end
+      else
+        reflection_klass.should_receive(:new) do |macro, name, options, parent|
+          options[:polymorphic].should be_nil
+        end
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "adds the class name option" do
+      if defined?(ActiveRecord::Reflection::MacroReflection)
+        reflection_klass.should_receive(:new) do |name, scope, options, parent|
+          options[:class_name].should == 'Bar'
+        end
+      else
+        reflection_klass.should_receive(:new) do |macro, name, options, parent|
+          options[:class_name].should == 'Bar'
+        end
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "sets the foreign key if necessary" do
+      if defined?(ActiveRecord::Reflection::MacroReflection)
+        reflection_klass.should_receive(:new) do |name, scope, options, parent|
+          options[:foreign_key].should == 'baz_id'
+        end
+      else
+        reflection_klass.should_receive(:new) do |macro, name, options, parent|
+          options[:foreign_key].should == 'baz_id'
+        end
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "respects supplied foreign keys" do
+      options[:foreign_key] = 'qux_id'
+
+      if defined?(ActiveRecord::Reflection::MacroReflection)
+        reflection_klass.should_receive(:new) do |name, scope, options, parent|
+          options[:foreign_key].should == 'qux_id'
+        end
+      else
+        reflection_klass.should_receive(:new) do |macro, name, options, parent|
+          options[:foreign_key].should == 'qux_id'
+        end
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end
+
+    it "sets conditions if there are none" do
+      reflection_klass.should_receive(:new) do |macro, name, options, parent|
+        options[:conditions].should == "::ts_join_alias::.\"foo_type\" = 'Bar'"
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end unless defined?(ActiveRecord::Reflection::MacroReflection)
+
+    it "appends to the conditions array" do
+      options[:conditions] = ['existing']
+
+      reflection_klass.should_receive(:new) do |macro, name, options, parent|
+        options[:conditions].should == ['existing', "::ts_join_alias::.\"foo_type\" = 'Bar'"]
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end unless defined?(ActiveRecord::Reflection::MacroReflection)
+
+    it "extends the conditions hash" do
+      options[:conditions] = {:x => :y}
+
+      reflection_klass.should_receive(:new) do |macro, name, options, parent|
+        options[:conditions].should == {:x => :y, :foo_type => 'Bar'}
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end unless defined?(ActiveRecord::Reflection::MacroReflection)
+
+    it "appends to the conditions string" do
+      options[:conditions] = 'existing'
+
+      reflection_klass.should_receive(:new) do |macro, name, options, parent|
+        options[:conditions].should == "existing AND ::ts_join_alias::.\"foo_type\" = 'Bar'"
+      end
+
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      )
+    end unless defined?(ActiveRecord::Reflection::MacroReflection)
+
+    it "returns the new reflection" do
+      ThinkingSphinx::ActiveRecord::FilterReflection.call(
+        reflection, 'foo_bar', 'Bar'
+      ).should == filtered_reflection
+    end
+  end
+end

data/spec/thinking_sphinx/active_record/polymorpher_spec.rb

@@ -10,9 +10,12 @@ describe ThinkingSphinx::ActiveRecord::Polymorpher do
   let(:class_names) { %w( Article Animal ) }
   let(:field)       { double :rebase => true }
   let(:attribute)   { double :rebase => true }
-  let(:outer)       { double :reflections => {:a => double(:klass => inner)} }
-  let(:inner)       { double :reflections => {:b => double(:klass => model)} }
-  let(:model)       { double 'Model', :reflections => {:foo => reflection} }
+  let(:outer)       { double(
+    :reflect_on_association => double(:klass => inner)) }
+  let(:inner)       { double(
+    :reflect_on_association => double(:klass => model)) }
+  let(:model)       { double 'Model', :reflections => {},
+    :reflect_on_association => reflection }
   let(:reflection)  { double 'Polymorphic Reflection' }
 
   describe '#morph!' do
@@ -20,25 +23,29 @@ describe ThinkingSphinx::ActiveRecord::Polymorpher do
     let(:animal_reflection)  { double 'Animal Reflection' }
 
     before :each do
-      ThinkingSphinx::ActiveRecord::FilteredReflection.
-        stub(:clone_with_filter).
+      ThinkingSphinx::ActiveRecord::FilterReflection.
+        stub(:call).
         and_return(article_reflection, animal_reflection)
 
+      model.stub(:reflect_on_association) do |name|
+        name == :foo ? reflection : nil
+      end
+
       if ActiveRecord::Reflection.respond_to?(:add_reflection)
         ActiveRecord::Reflection.stub :add_reflection
       end
     end
 
     it "creates a new reflection for each class" do
-      ThinkingSphinx::ActiveRecord::FilteredReflection.
-        unstub :clone_with_filter
+      ThinkingSphinx::ActiveRecord::FilterReflection.
+        unstub :call
 
-      ThinkingSphinx::ActiveRecord::FilteredReflection.
-        should_receive(:clone_with_filter).
+      ThinkingSphinx::ActiveRecord::FilterReflection.
+        should_receive(:call).
         with(reflection, :foo_article, 'Article').
         and_return(article_reflection)
-      ThinkingSphinx::ActiveRecord::FilteredReflection.
-        should_receive(:clone_with_filter).
+      ThinkingSphinx::ActiveRecord::FilterReflection.
+        should_receive(:call).
         with(reflection, :foo_animal, 'Animal').
         and_return(animal_reflection)
 

data/spec/thinking_sphinx/active_record/sql_builder_spec.rb

@@ -192,27 +192,6 @@ describe ThinkingSphinx::ActiveRecord::SQLBuilder do
           model.stub! :store_full_sti_class => true
         end
 
-        it "limits results to just the model" do
-          relation.should_receive(:where) do |string|
-            string.should match(/`users`.`type` = 'User'/)
-            relation
-          end
-
-          builder.sql_query
-        end
-
-        it "uses the demodulised name if that's what is stored" do
-          model.stub! :store_full_sti_class => false
-          model.name.stub! :demodulize => 'U'
-
-          relation.should_receive(:where) do |string|
-            string.should match(/`users`.`type` = 'U'/)
-            relation
-          end
-
-          builder.sql_query
-        end
-
         it "groups by the inheritance column" do
           relation.should_receive(:group) do |string|
             string.should match(/`users`.`type`/)
@@ -228,15 +207,6 @@ describe ThinkingSphinx::ActiveRecord::SQLBuilder do
             model.stub :inheritance_column => 'custom_type'
           end
 
-          it "limits results on the right column" do
-            relation.should_receive(:where) do |string|
-              string.should match(/`users`.`custom_type` = 'User'/)
-              relation
-            end
-
-            builder.sql_query
-          end
-
           it "groups by the right column" do
             relation.should_receive(:group) do |string|
               string.should match(/`users`.`custom_type`/)
@@ -452,27 +422,6 @@ describe ThinkingSphinx::ActiveRecord::SQLBuilder do
           model.stub! :store_full_sti_class => true
         end
 
-        it "limits results to just the model" do
-          relation.should_receive(:where) do |string|
-            string.should match(/"users"."type" = 'User'/)
-            relation
-          end
-
-          builder.sql_query
-        end
-
-        it "uses the demodulised name if that's what is stored" do
-          model.stub! :store_full_sti_class => false
-          model.name.stub! :demodulize => 'U'
-
-          relation.should_receive(:where) do |string|
-            string.should match(/"users"."type" = 'U'/)
-            relation
-          end
-
-          builder.sql_query
-        end
-
         it "groups by the inheritance column" do
           relation.should_receive(:group) do |string|
             string.should match(/"users"."type"/)
@@ -488,15 +437,6 @@ describe ThinkingSphinx::ActiveRecord::SQLBuilder do
             model.stub :inheritance_column => 'custom_type'
           end
 
-          it "limits results on the right column" do
-            relation.should_receive(:where) do |string|
-              string.should match(/"users"."custom_type" = 'User'/)
-              relation
-            end
-
-            builder.sql_query
-          end
-
           it "groups by the right column" do
             relation.should_receive(:group) do |string|
               string.should match(/"users"."custom_type"/)
@@ -675,51 +615,6 @@ describe ThinkingSphinx::ActiveRecord::SQLBuilder do
       builder.sql_query_range
     end
 
-    context 'STI model' do
-      before :each do
-        model.column_names << 'type'
-        model.stub! :descends_from_active_record? => false
-        model.stub! :store_full_sti_class => true
-      end
-
-      it "limits results to just the model" do
-        relation.should_receive(:where) do |string|
-          string.should match(/`users`.`type` = 'User'/)
-          relation
-        end
-
-        builder.sql_query_range
-      end
-
-      it "uses the demodulised name if that's what is stored" do
-        model.stub! :store_full_sti_class => false
-        model.name.stub! :demodulize => 'U'
-
-        relation.should_receive(:where) do |string|
-          string.should match(/`users`.`type` = 'U'/)
-          relation
-        end
-
-        builder.sql_query_range
-      end
-
-      context 'with a custom inheritance column' do
-        before :each do
-          model.column_names << 'custom_type'
-          model.stub :inheritance_column => 'custom_type'
-        end
-
-        it "limits results on the right column" do
-          relation.should_receive(:where) do |string|
-            string.should match(/`users`.`custom_type` = 'User'/)
-            relation
-          end
-
-          builder.sql_query_range
-        end
-      end
-    end
-
     context 'with a delta processor' do
       let(:processor) { double('processor') }
 

data/spec/thinking_sphinx/configuration_spec.rb

@@ -101,19 +101,6 @@ describe ThinkingSphinx::Configuration do
     end
   end
 
-  describe '#indices_for_references' do
-    it "selects from the full index set those with matching references" do
-      config.preload_indices
-      config.indices.clear
-
-      config.indices << double('index', :reference => :article)
-      config.indices << double('index', :reference => :book)
-      config.indices << double('index', :reference => :page)
-
-      config.indices_for_references(:book, :article).length.should == 2
-    end
-  end
-
   describe '#indices_location' do
     it "stores index files in db/sphinx/ENVIRONMENT" do
       config.indices_location.

data/spec/thinking_sphinx/facet_search_spec.rb

@@ -10,10 +10,9 @@ describe ThinkingSphinx::FacetSearch do
     :multi? => false) }
   let(:property_b)    { double('property', :name => 'category_id',
     :multi? => false) }
-  let(:configuration) { double 'configuration', :settings => {} }
+  let(:configuration) { double 'configuration', :settings => {}, :index_set_class => double(:new => index_set) }
 
   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

data/spec/thinking_sphinx/index_set_spec.rb

@@ -5,13 +5,11 @@ require 'active_support/core_ext/module/delegation'
 require 'thinking_sphinx/index_set'
 
 describe ThinkingSphinx::IndexSet do
-  let(:set)           { ThinkingSphinx::IndexSet.new classes, indices,
-    configuration }
-  let(:classes)       { [] }
-  let(:indices)       { [] }
+  let(:set)           { ThinkingSphinx::IndexSet.new options, configuration }
   let(:configuration) { double('configuration', :preload_indices => true,
     :indices => []) }
   let(:ar_base)       { double('ActiveRecord::Base') }
+  let(:options)       { {} }
 
   before :each do
     stub_const 'ActiveRecord::Base', ar_base
@@ -43,21 +41,29 @@ describe ThinkingSphinx::IndexSet do
     end
 
     it "uses indices for the given classes" do
-      classes << class_double('Article')
+      configuration.indices.replace [
+        double(:reference => :article,         :distributed? => false),
+        double(:reference => :opinion_article, :distributed? => false),
+        double(:reference => :page,            :distributed? => false)
+      ]
 
-      configuration.should_receive(:indices_for_references).with(:article).
-        and_return([])
+      options[:classes] = [class_double('Article')]
 
-      set.to_a
+      set.to_a.length.should == 1
     end
 
     it "requests indices for any superclasses" do
-      classes << class_double('OpinionArticle', class_double('Article'))
+      configuration.indices.replace [
+        double(:reference => :article,         :distributed? => false),
+        double(:reference => :opinion_article, :distributed? => false),
+        double(:reference => :page,            :distributed? => false)
+      ]
 
-      configuration.should_receive(:indices_for_references).
-        with(:opinion_article, :article).and_return([])
+      options[:classes] = [
+        class_double('OpinionArticle', class_double('Article'))
+      ]
 
-      set.to_a
+      set.to_a.length.should == 2
     end
 
     it "uses named indices if names are provided" do
@@ -65,9 +71,21 @@ describe ThinkingSphinx::IndexSet do
       user_core    = double('index', :name => 'user_core')
       configuration.indices.replace [article_core, user_core]
 
-      indices << 'article_core'
+      options[:indices] = ['article_core']
 
       set.to_a.should == [article_core]
     end
+
+    it "selects from the full index set those with matching references" do
+      configuration.indices.replace [
+        double('index', :reference => :article, :distributed? => false),
+        double('index', :reference => :book,    :distributed? => false),
+        double('index', :reference => :page,    :distributed? => false)
+      ]
+
+      options[:references] = [:book, :article]
+
+      set.to_a.length.should == 2
+    end
   end
 end