thinking-sphinx 2.0.5 → 2.0.6

data/spec/thinking_sphinx/adapters/abstract_adapter_spec.rb

@@ -7,137 +7,137 @@ end
 describe ThinkingSphinx::AbstractAdapter do
   describe '.detect' do
     let(:model) { stub('model') }
-    
+
     it "returns a MysqlAdapter object for :mysql" do
       ThinkingSphinx::AbstractAdapter.stub(:adapter_for_model => :mysql)
-      
+
       adapter = ThinkingSphinx::AbstractAdapter.detect(model)
       adapter.should be_a(ThinkingSphinx::MysqlAdapter)
     end
-    
+
     it "returns a PostgreSQLAdapter object for :postgresql" do
       ThinkingSphinx::AbstractAdapter.stub(:adapter_for_model => :postgresql)
-      
+
       adapter = ThinkingSphinx::AbstractAdapter.detect(model)
       adapter.should be_a(ThinkingSphinx::PostgreSQLAdapter)
     end
-    
+
     it "instantiates the provided class if one is provided" do
       ThinkingSphinx::AbstractAdapter.stub(:adapter_for_model => CustomAdapter)
       CustomAdapter.should_receive(:new).and_return(stub('adapter'))
-      
+
       ThinkingSphinx::AbstractAdapter.detect(model)
     end
-    
+
     it "raises an exception for other responses" do
       ThinkingSphinx::AbstractAdapter.stub(:adapter_for_model => :sqlite)
-      
+
       lambda {
         ThinkingSphinx::AbstractAdapter.detect(model)
       }.should raise_error
     end
   end
-  
+
   describe '.adapter_for_model' do
     let(:model) { stub('model') }
-    
+
     after :each do
       ThinkingSphinx.database_adapter = nil
     end
-    
+
     it "translates strings to symbols" do
       ThinkingSphinx.database_adapter = 'foo'
-      
+
       ThinkingSphinx::AbstractAdapter.adapter_for_model(model).should == :foo
     end
-    
+
     it "passes through symbols unchanged" do
       ThinkingSphinx.database_adapter = :bar
-      
+
       ThinkingSphinx::AbstractAdapter.adapter_for_model(model).should == :bar
     end
-    
+
     it "returns standard_adapter_for_model if database_adapter is not set" do
       ThinkingSphinx.database_adapter = nil
       ThinkingSphinx::AbstractAdapter.stub!(:standard_adapter_for_model => :baz)
-      
+
       ThinkingSphinx::AbstractAdapter.adapter_for_model(model).should == :baz
     end
-    
+
     it "calls the lambda and returns it if one is provided" do
       ThinkingSphinx.database_adapter = lambda { |model| :foo }
-      
+
       ThinkingSphinx::AbstractAdapter.adapter_for_model(model).should == :foo
     end
   end
-  
+
   describe '.standard_adapter_for_model' do
     let(:klass)      { stub('connection class') }
     let(:connection) { stub('connection', :class => klass) }
     let(:model)      { stub('model', :connection => connection) }
-    
+
     it "translates a normal MySQL adapter" do
       klass.stub(:name => 'ActiveRecord::ConnectionAdapters::MysqlAdapter')
-      
+
       ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
         should == :mysql
     end
-    
+
     it "translates a MySQL plus adapter" do
       klass.stub(:name => 'ActiveRecord::ConnectionAdapters::MysqlplusAdapter')
-      
+
       ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
         should == :mysql
     end
-    
+
     it "translates a MySQL2 adapter" do
       klass.stub(:name => 'ActiveRecord::ConnectionAdapters::Mysql2Adapter')
-      
+
       ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
         should == :mysql
     end
-    
+
     it "translates a NullDB adapter to MySQL" do
       klass.stub(:name => 'ActiveRecord::ConnectionAdapters::NullDBAdapter')
-      
+
       ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
         should == :mysql
     end
-    
+
     it "translates a normal PostgreSQL adapter" do
       klass.stub(:name => 'ActiveRecord::ConnectionAdapters::PostgreSQLAdapter')
-      
+
       ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
         should == :postgresql
     end
-    
+
     it "translates a JDBC MySQL adapter to MySQL" do
       klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
       connection.stub(:config => {:adapter => 'jdbcmysql'})
-      
+
       ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
         should == :mysql
     end
-    
+
     it "translates a JDBC PostgreSQL adapter to PostgreSQL" do
       klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
       connection.stub(:config => {:adapter => 'jdbcpostgresql'})
-      
+
       ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
         should == :postgresql
     end
-    
+
     it "returns other JDBC adapters without translation" do
       klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
       connection.stub(:config => {:adapter => 'jdbcmssql'})
-      
+
       ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
-        should == 'jdbcmssql'
+        should == :jdbcmssql
     end
-    
+
     it "returns other unknown adapters without translation" do
       klass.stub(:name => 'ActiveRecord::ConnectionAdapters::FooAdapter')
-      
+
       ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
         should == 'ActiveRecord::ConnectionAdapters::FooAdapter'
     end

data/spec/thinking_sphinx/association_spec.rb

@@ -14,7 +14,7 @@ describe ThinkingSphinx::Association do
         :active_record  => 'AR'
       )
       @non_poly_reflection = stub('reflection', :name => 'non_polly')
-      
+
       Person.stub!(:reflect_on_association => @normal_reflection)
       ThinkingSphinx::Association.stub!(
         :new                  => @normal_association,
@@ -25,58 +25,85 @@ describe ThinkingSphinx::Association do
         :new => @non_poly_reflection
       )
     end
-    
+
     it "should return an empty array if no association exists" do
       Person.stub!(:reflect_on_association => nil)
-      
+
       ThinkingSphinx::Association.children(Person, :assoc).should == []
     end
-    
+
     it "should return a single association instance in an array if assocation isn't polymorphic" do
       ThinkingSphinx::Association.children(Person, :assoc).should == [@normal_association]
     end
-    
+
     it "should return multiple association instances for polymorphic associations" do
       Person.stub!(:reflect_on_association => @poly_reflection)
-      
+
       ThinkingSphinx::Association.children(Person, :assoc).should ==
         [@normal_association, @normal_association]
     end
-    
+
     it "should generate non-polymorphic 'casted' associations for each polymorphic possibility" do
-      Person.stub!(:reflect_on_association => @poly_reflection)
+      reflections = double('reflections', :[]= => nil)
+      Person.stub!(:reflections => reflections)
+
+      Person.should_receive(:reflect_on_association).once.
+        and_return(@poly_reflection)
+      reflections.should_receive(:[]).with(:polly_Person).twice.and_return(nil)
       ThinkingSphinx::Association.should_receive(:casted_options).with(
         Person, @poly_reflection
       ).twice
       ::ActiveRecord::Reflection::AssociationReflection.should_receive(:new).
-        with(:has_many, :polly_Person, {:casted => :options}, "AR").twice
+        with(:has_many, :polly_Person, {:casted => :options}, "AR").twice.
+        and_return(@non_poly_reflection)
       ThinkingSphinx::Association.should_receive(:new).with(
         nil, @non_poly_reflection
       ).twice
-      
+
+      ThinkingSphinx::Association.children(Person, :assoc)
+    end
+
+    it "should use existing non-polymorphic 'casted' associations" do
+      reflections = double('reflections', :[]= => nil)
+      Person.stub!(:reflections => reflections)
+
+      Person.stub!(:reflect_on_association).once.
+        and_return(@poly_reflection)
+      reflections.should_receive(:[]).with(:polly_Person).twice.
+        and_return(nil, @non_poly_reflection)
+      ThinkingSphinx::Association.should_receive(:casted_options).with(
+        Person, @poly_reflection
+      ).once
+      ::ActiveRecord::Reflection::AssociationReflection.should_receive(:new).
+        with(:has_many, :polly_Person, {:casted => :options}, "AR").once.
+        and_return(@non_poly_reflection)
+      ThinkingSphinx::Association.should_receive(:new).with(
+        nil, @non_poly_reflection
+      ).twice
+
       ThinkingSphinx::Association.children(Person, :assoc)
     end
   end
-  
+
   describe '#children' do
     before :each do
       @reflection   = stub('reflection', :klass => :klass)
       @association  = ThinkingSphinx::Association.new(nil, @reflection)
       ThinkingSphinx::Association.stub!(:children => :result)
     end
-    
+
     it "should return the children associations for the given association" do
       @association.children(:assoc).should == :result
     end
-    
+
     it "should request children for the reflection klass" do
       ThinkingSphinx::Association.should_receive(:children).
         with(:klass, :assoc, @association)
-      
+
       @association.children(:assoc)
     end
   end
-  
+
   describe '#join_to' do
     before :each do
       @parent_join = stub('join assoc').as_null_object
@@ -84,59 +111,64 @@ describe ThinkingSphinx::Association do
       @parent = ThinkingSphinx::Association.new(nil, nil)
       @parent.stub!(:join_to => true, :join => nil)
       @base_join = stub('base join', :joins => [:a, :b, :c])
-       ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub!(:new => @join)
+
+      if ThinkingSphinx.rails_3_1?
+        ::ActiveRecord::Associations::JoinDependency::JoinAssociation.stub!(:new => @join)
+      else
+        ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub!(:new => @join)
+      end
     end
-    
+
     it "should call the parent's join_to if parent has no join" do
       @assoc = ThinkingSphinx::Association.new(@parent, :ref)
       @parent.should_receive(:join_to).with(@base_join)
-      
+
       @assoc.join_to(@base_join)
     end
-    
+
     it "should not call the parent's join_to if it already has a join" do
       @assoc = ThinkingSphinx::Association.new(@parent, :ref)
       @parent.stub!(:join => @parent_join)
       @parent.should_not_receive(:join_to)
-      
+
       @assoc.join_to(@base_join)
     end
-    
+
     it "should define the join association with a JoinAssociation instance" do
       @assoc = ThinkingSphinx::Association.new(@parent, :ref)
-      
+
       @assoc.join_to(@base_join).should == @join
       @assoc.join.should == @join
     end
   end
-  
+
   describe '#is_many?' do
     before :each do
       @parent = stub('assoc', :is_many? => :parent_is_many)
       @reflection = stub('reflection', :macro => :has_many)
     end
-    
+
     it "should return true if association is either a has_many or a habtm" do
       association = ThinkingSphinx::Association.new(@parent, @reflection)
       association.is_many?.should be_true
-      
+
       @reflection.stub!(:macro => :has_and_belongs_to_many)
       association.is_many?.should be_true
     end
-    
+
     it "should return the parent value if not a has many or habtm and there is a parent" do
       association = ThinkingSphinx::Association.new(@parent, @reflection)
       @reflection.stub!(:macro => :belongs_to)
       association.is_many?.should == :parent_is_many
     end
-    
+
     it "should return false if no parent and not a has many or habtm" do
       association = ThinkingSphinx::Association.new(nil, @reflection)
       @reflection.stub!(:macro => :belongs_to)
       association.is_many?.should be_false
     end
   end
-  
+
   describe '#ancestors' do
     it "should return an array of associations - including all parents" do
       parent = stub('assoc', :ancestors => [:all, :ancestors])
@@ -144,7 +176,7 @@ describe ThinkingSphinx::Association do
       association.ancestors.should == [:all, :ancestors, association]
     end
   end
-  
+
   describe '.polymorphic_classes' do
     it "should return all the polymorphic result types as classes" do
       Person.connection.stub!(:select_all => [
@@ -155,11 +187,12 @@ describe ThinkingSphinx::Association do
         :active_record  => Person,
         :options        => {:foreign_type => "person_type"}
       )
-      
+      ref.stub!(:foreign_type => "person_type") if ThinkingSphinx.rails_3_1?
+
       ThinkingSphinx::Association.send(:polymorphic_classes, ref).should == [Person, Friendship]
     end
   end
-  
+
   describe '.casted_options' do
     before :each do
       @options = {
@@ -168,8 +201,9 @@ describe ThinkingSphinx::Association do
         :polymorphic  => true
       }
       @reflection = stub('assoc reflection', :options => @options)
+      @reflection.stub!(:foreign_type => "thing_type") if ThinkingSphinx.rails_3_1?
     end
-    
+
     it "should return a new options set for a specific class" do
       ThinkingSphinx::Association.send(:casted_options, Person, @reflection).should == {
         :polymorphic  => nil,
@@ -179,7 +213,7 @@ describe ThinkingSphinx::Association do
         :conditions   => "::ts_join_alias::.`thing_type` = 'Person'"
       }
     end
-        
+
     it "should append to existing Array of conditions" do
       @options[:conditions] = ["first condition"]
       ThinkingSphinx::Association.send(:casted_options, Person, @reflection).should == {
@@ -190,7 +224,7 @@ describe ThinkingSphinx::Association do
         :conditions   => ["first condition", "::ts_join_alias::.`thing_type` = 'Person'"]
       }
     end
-    
+
     it "should merge to an existing Hash of conditions" do
       @options[:conditions] = {"field" => "value"}
       ThinkingSphinx::Association.send(:casted_options, Person, @reflection).should == {
@@ -201,7 +235,7 @@ describe ThinkingSphinx::Association do
         :conditions   => {"field" => "value", "thing_type" => "Person"}
       }
     end
-    
+
     it "should append to an existing String of conditions" do
       @options[:conditions] = "first condition"
       ThinkingSphinx::Association.send(:casted_options, Person, @reflection).should == {

data/spec/thinking_sphinx/context_spec.rb

@@ -1,128 +1,125 @@
 require 'spec_helper'
 
 describe ThinkingSphinx::Context do
-  before :each do
-    @context = ThinkingSphinx::Context.new
-  end
-  
+  let(:ts_context) { ThinkingSphinx::Context.new }
+
   describe '#prepare' do
-    before :each do
-      @config = ThinkingSphinx::Configuration.instance
-      @config.model_directories = ['']
+    let(:config)           { ThinkingSphinx::Configuration.instance }
+    let(:file_name)        { 'a.rb' }
+    let(:model_name_lower) { 'a' }
+    let(:class_name)       { 'A' }
 
-      @file_name        = 'a.rb'
-      @model_name_lower = 'a'
-      @class_name       = 'A'
+    before :each do
+      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.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)
 
-      @context.prepare
+      ts_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 {
-        @context.prepare
+        ts_context.prepare
       }.should_not raise_error
     end
 
     it "should not raise errors if the file name does not represent a class name" do
-      @class_name.should_receive(:constantize).and_raise(NameError)
+      class_name.should_receive(:constantize).and_raise(NameError)
 
       lambda {
-        @context.prepare
+        ts_context.prepare
       }.should_not raise_error
     end
 
     # Fails in Ruby 1.9 (or maybe it's an RSpec update). Not sure why.
     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
+      class_name.stub(:constantize).and_raise(LoadError)
+      model_name_lower.should_receive(:gsub!).twice.and_return(true, nil)
 
       lambda {
-        @context.prepare
+        ts_context.prepare
       }.should_not raise_error
     end
 
     it "should catch database errors with a warning" do
-      @class_name.should_receive(:constantize).and_raise(Mysql::Error)
+      class_name.should_receive(:constantize).and_raise(Mysql2::Error)
       STDERR.stub!(:puts => '')
       STDERR.should_receive(:puts).with('Warning: Error loading a.rb:')
-      
+
       lambda {
-        @context.prepare
+        ts_context.prepare
       }.should_not raise_error
-    end
-    
+    end unless RUBY_PLATFORM == 'java'
+
     it "should not load models if they're explicitly set in the configuration" do
-      @config.indexed_models = ['Alpha', 'Beta']
-      @context.prepare
-      
-      @context.indexed_models.should == ['Alpha', 'Beta']
+      config.indexed_models = ['Alpha', 'Beta']
+      ts_context.prepare
+
+      ts_context.indexed_models.should == ['Alpha', 'Beta']
     end
   end
-  
+
   describe '#define_indexes' do
     it "should call define_indexes on all known indexed models" do
-      @context.stub!(:indexed_models => ['Alpha', 'Beta'])
+      ts_context.stub!(:indexed_models => ['Alpha', 'Beta'])
       Alpha.should_receive(:define_indexes)
       Beta.should_receive(:define_indexes)
-      
-      @context.define_indexes
+
+      ts_context.define_indexes
     end
   end
-  
+
   describe '#add_indexed_model' do
     before :each do
-      @context.indexed_models.clear
+      ts_context.indexed_models.clear
     end
-    
+
     it "should add the model to the collection" do
-      @context.add_indexed_model 'Alpha'
-      
-      @context.indexed_models.should == ['Alpha']
+      ts_context.add_indexed_model 'Alpha'
+
+      ts_context.indexed_models.should == ['Alpha']
     end
-    
+
     it "should not duplicate models in the collection" do
-      @context.add_indexed_model 'Alpha'
-      @context.add_indexed_model 'Alpha'
-      
-      @context.indexed_models.should == ['Alpha']
+      ts_context.add_indexed_model 'Alpha'
+      ts_context.add_indexed_model 'Alpha'
+
+      ts_context.indexed_models.should == ['Alpha']
     end
-    
+
     it "should keep the collection in alphabetical order" do
-      @context.add_indexed_model 'Beta'
-      @context.add_indexed_model 'Alpha'
-      
-      @context.indexed_models.should == ['Alpha', 'Beta']
+      ts_context.add_indexed_model 'Beta'
+      ts_context.add_indexed_model 'Alpha'
+
+      ts_context.indexed_models.should == ['Alpha', 'Beta']
     end
-    
+
     it "should translate classes to their names" do
-      @context.add_indexed_model Alpha
-      
-      @context.indexed_models.should == ['Alpha']
+      ts_context.add_indexed_model Alpha
+
+      ts_context.indexed_models.should == ['Alpha']
     end
   end
-  
+
   describe '#superclass_indexed_models' do
     it "should return indexed model names" do
-      @context.stub!(:indexed_models => ['Alpha', 'Beta'])
-      
-      @context.superclass_indexed_models.should == ['Alpha', 'Beta']
+      ts_context.stub!(:indexed_models => ['Alpha', 'Beta'])
+
+      ts_context.superclass_indexed_models.should == ['Alpha', 'Beta']
     end
-    
+
     it "should not include classes which have indexed superclasses" do
-      @context.stub!(:indexed_models => ['Parent', 'Person'])
-      
-      @context.superclass_indexed_models.should == ['Person']
+      ts_context.stub!(:indexed_models => ['Parent', 'Person'])
+
+      ts_context.superclass_indexed_models.should == ['Person']
     end
   end
 end