thinking-sphinx 1.4.6 → 1.4.7

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

@@ -44,12 +44,30 @@ describe ThinkingSphinx::Association do
     end
     
     it "should generate non-polymorphic 'casted' associations for each polymorphic possibility" do
-      Person.stub!(:reflect_on_association => @poly_reflection)
+      Person.stub!(:reflect_on_association).exactly(3).times.
+        and_return(@poly_reflection, nil, 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
+      Person.stub!(:reflect_on_association).exactly(3).times.
+        and_return(@poly_reflection, 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

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

data/spec/thinking_sphinx/search_spec.rb

@@ -636,6 +636,13 @@ describe ThinkingSphinx::Search do
         filter.attribute.should == 'sphinx_internal_id'
         filter.exclude?.should be_true
       end
+
+      it "should not filter out any ids if :without_ids is an empty array" do
+        ThinkingSphinx::Search.new(:without_ids => []).first
+
+        filter = @client.filters.last
+        filter.attribute.should_not == 'sphinx_internal_id'
+      end
     end
     
     describe 'sort mode' do

data/spec/thinking_sphinx_spec.rb

@@ -5,40 +5,40 @@ describe ThinkingSphinx do
     it "should return a Context instance" do
       ThinkingSphinx.context.should be_a(ThinkingSphinx::Context)
     end
-    
+
     it "should remember changes to the Context instance" do
-      models = ThinkingSphinx.context.indexed_models
-      
+      models = ThinkingSphinx.context.indexed_models.clone
+
       ThinkingSphinx.context.indexed_models.replace([:model])
       ThinkingSphinx.context.indexed_models.should == [:model]
-      
+
       ThinkingSphinx.context.indexed_models.replace(models)
     end
   end
-  
+
   describe '.reset_context!' do
     it "should remove the existing Context instance" do
       existing = ThinkingSphinx.context
-      
+
       ThinkingSphinx.reset_context!
       ThinkingSphinx.context.should_not == existing
-      
+
       ThinkingSphinx.reset_context! existing
     end
   end
-    
+
   describe '.define_indexes?' do
     it "should define indexes by default" do
       ThinkingSphinx.define_indexes?.should be_true
     end
   end
-  
+
   describe '.define_indexes=' do
     it "should disable index definition" do
       ThinkingSphinx.define_indexes = false
       ThinkingSphinx.define_indexes?.should be_false
     end
-  
+
     it "should enable index definition" do
       ThinkingSphinx.define_indexes = false
       ThinkingSphinx.define_indexes?.should be_false
@@ -46,19 +46,19 @@ describe ThinkingSphinx do
       ThinkingSphinx.define_indexes?.should be_true
     end
   end
-  
+
   describe '.deltas_enabled?' do
     it "should index deltas by default" do
       ThinkingSphinx.deltas_enabled?.should be_true
     end
   end
-  
+
   describe '.deltas_enabled=' do
     it "should disable delta indexing" do
       ThinkingSphinx.deltas_enabled = false
       ThinkingSphinx.deltas_enabled?.should be_false
     end
-  
+
     it "should enable delta indexing" do
       ThinkingSphinx.deltas_enabled = false
       ThinkingSphinx.deltas_enabled?.should be_false
@@ -66,20 +66,22 @@ describe ThinkingSphinx do
       ThinkingSphinx.deltas_enabled?.should be_true
     end
   end
-  
+
   describe '.updates_enabled?' do
     it "should update indexes by default" do
+      ThinkingSphinx::Configuration.stub! :environment => 'development'
+
       ThinkingSphinx.updates_enabled = nil
       ThinkingSphinx.updates_enabled?.should be_true
     end
   end
-  
+
   describe '.updates_enabled=' do
     it "should disable index updating" do
       ThinkingSphinx.updates_enabled = false
       ThinkingSphinx.updates_enabled?.should be_false
     end
-  
+
     it "should enable index updating" do
       ThinkingSphinx.updates_enabled = false
       ThinkingSphinx.updates_enabled?.should be_false
@@ -87,35 +89,25 @@ describe ThinkingSphinx do
       ThinkingSphinx.updates_enabled?.should be_true
     end
   end
-  
+
   describe '.sphinx_running?' do
     it "should always say Sphinx is running if flagged as being on a remote machine" do
       ThinkingSphinx.remote_sphinx = true
       ThinkingSphinx.stub!(:sphinx_running_by_pid? => false)
-    
+
       ThinkingSphinx.sphinx_running?.should be_true
     end
-  
+
     it "should actually pay attention to Sphinx if not on a remote machine" do
       ThinkingSphinx.remote_sphinx = false
       ThinkingSphinx.stub!(:sphinx_running_by_pid? => false)
       ThinkingSphinx.sphinx_running?.should be_false
-    
+
       ThinkingSphinx.stub!(:sphinx_running_by_pid? => true)
       ThinkingSphinx.sphinx_running?.should be_true
     end
   end
-  
-  describe '.version' do
-    it "should return the version from the stored YAML file" do
-      version = Jeweler::VersionHelper.new(
-        File.join(File.dirname(__FILE__), '..')
-      ).to_s
-      
-      ThinkingSphinx.version.should == version
-    end
-  end
-  
+
   describe "use_group_by_shortcut? method" do
     before :each do
       adapter = defined?(JRUBY_VERSION) ? :JdbcAdapter : :MysqlAdapter
@@ -123,7 +115,7 @@ describe ThinkingSphinx do
         pending "No MySQL"
         return
       end
-      
+
       @connection = stub('adapter',
         :select_all => true,
         :class      => ActiveRecord::ConnectionAdapters::MysqlAdapter,
@@ -132,34 +124,43 @@ describe ThinkingSphinx do
       ::ActiveRecord::Base.stub!(
         :connection => @connection
       )
-      
+
       ThinkingSphinx.reset_use_group_by_shortcut
     end
-    
+
     it "should return true if no ONLY_FULL_GROUP_BY" do
       @connection.stub!(
         :select_all => {:a => "OTHER SETTINGS"}
       )
-      
+
       ThinkingSphinx.use_group_by_shortcut?.should be_true
     end
-  
+
     it "should return true if NULL value" do
       @connection.stub!(
         :select_all => {:a => nil}
       )
-      
+
       ThinkingSphinx.use_group_by_shortcut?.should be_true
     end
-  
+
+    it "should return true if using mysql2 gem" do
+      @connection.stub!(
+        :class => ActiveRecord::ConnectionAdapters::Mysql2Adapter,
+        :select_all => {:a => ""}
+      )
+
+      ThinkingSphinx.use_group_by_shortcut?.should be_true
+    end unless RUBY_PLATFORM == 'java'
+
     it "should return false if ONLY_FULL_GROUP_BY is set" do
       @connection.stub!(
         :select_all => {:a => "OTHER SETTINGS,ONLY_FULL_GROUP_BY,blah"}
       )
-      
+
       ThinkingSphinx.use_group_by_shortcut?.should be_false
     end
-    
+
     it "should return false if ONLY_FULL_GROUP_BY is set in any of the values" do
       @connection.stub!(
         :select_all => {
@@ -167,10 +168,10 @@ describe ThinkingSphinx do
           :b => "ONLY_FULL_GROUP_BY"
         }
       )
-      
+
       ThinkingSphinx.use_group_by_shortcut?.should be_false
     end
-    
+
     describe "if not using MySQL" do
       before :each do
         adapter = defined?(JRUBY_VERSION) ? 'JdbcAdapter' : 'PostgreSQLAdapter'
@@ -178,7 +179,7 @@ describe ThinkingSphinx do
           pending "No PostgreSQL"
           return
         end
-        
+
         @connection = stub(adapter).as_null_object
         @connection.stub!(
           :select_all => true,
@@ -188,14 +189,14 @@ describe ThinkingSphinx do
           :connection => @connection
         )
       end
-    
+
       it "should return false" do
         ThinkingSphinx.use_group_by_shortcut?.should be_false
       end
-    
+
       it "should not call select_all" do
         @connection.should_not_receive(:select_all)
-        
+
         ThinkingSphinx.use_group_by_shortcut?
       end
     end