thinking-sphinx 2.0.14 → 2.1.0

data/spec/spec_helper.rb

@@ -1,7 +1,4 @@
 $:.unshift File.dirname(__FILE__) + '/../lib'
-Dir[File.join(File.dirname(__FILE__), '../vendor/*/lib')].each do |path|
-  $:.unshift path
-end
 
 require 'fileutils'
 require 'logger'

data/spec/thinking_sphinx/active_record/delta_spec.rb

@@ -65,12 +65,15 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
   end
 
   describe "index_delta method" do
+    let(:index_job) { double :perform => true }
+
     before :each do
       ThinkingSphinx::Configuration.stub!(:environment => "spec")
       ThinkingSphinx.deltas_enabled   = true
       ThinkingSphinx.updates_enabled  = true
       ThinkingSphinx.stub!(:sphinx_running? => true)
       Person.delta_objects.first.stub!(:` => "", :toggled => true)
+      ThinkingSphinx::Deltas::IndexJob.stub :new => index_job
 
       @person = Person.new
       Person.stub!(:search_for_id => false)
@@ -78,7 +81,7 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
 
       @client = Riddle::Client.new
       @client.stub!(:update => true)
-      ThinkingSphinx::Configuration.instance.stub!(:client => @client)
+      ThinkingSphinx::Connection.stub(:take).and_yield @client
     end
 
     it "shouldn't index if delta indexing is disabled" do
@@ -104,10 +107,8 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
       @person.send(:index_delta)
     end
 
-    it "should call indexer for the delta index" do
-      Person.sphinx_indexes.first.delta_object.should_receive(:`).with(
-        "#{ThinkingSphinx::Configuration.instance.bin_path}indexer --config \"#{ThinkingSphinx::Configuration.instance.config_file}\" --rotate person_delta"
-      )
+    it "should run the index job" do
+      index_job.should_receive(:perform)
 
       @person.send(:index_delta)
     end

data/spec/thinking_sphinx/active_record/scopes_spec.rb

@@ -142,7 +142,8 @@ describe ThinkingSphinx::ActiveRecord::Scopes do
       @config = ThinkingSphinx::Configuration.instance
       @client = Riddle::Client.new
 
-      @config.stub!(:client => @client)
+      ThinkingSphinx::Connection.stub(:take).and_yield(@client)
+
       @client.stub!(:query => {:matches => [], :total_found => 43})
       Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
       Alpha.sphinx_scope(:ids_only) { {:ids_only => true} }

data/spec/thinking_sphinx/active_record_spec.rb

@@ -271,7 +271,7 @@ describe ThinkingSphinx::ActiveRecord do
       @client.stub!(:update => true)
       @person = Person.find(:first)
 
-      @configuration.stub!(:client => @client)
+      ThinkingSphinx::Connection.stub(:take).and_yield(@client)
       Person.sphinx_indexes.each { |index| index.stub!(:delta? => false) }
     end
 
@@ -481,7 +481,7 @@ describe ThinkingSphinx::ActiveRecord do
     before :each do
       @client = stub('client')
       ThinkingSphinx.stub!(:sphinx_running? => true)
-      ThinkingSphinx::Configuration.instance.stub!(:client => @client)
+      ThinkingSphinx::Connection.stub(:take).and_yield(@client)
     end
 
     it "should direct the update to the supplied index" do

data/spec/thinking_sphinx/adapters/abstract_adapter_spec.rb

@@ -127,6 +127,24 @@ describe ThinkingSphinx::AbstractAdapter do
         should == :postgresql
     end
 
+   it "translates a JDBC adapter with MySQL connection string to MySQL" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      connection.stub(:config => {:adapter => 'jdbc',
+                                  :url => 'jdbc:mysql://127.0.0.1:3306/sphinx'})
+
+      ThinkingSphinx::AbstractAdapter.standard_adapter_for_model(model).
+        should == :mysql
+    end
+
+    it "translates a JDBC adapter with PostgresSQL connection string to PostgresSQL" do
+      klass.stub(:name => 'ActiveRecord::ConnectionAdapters::JdbcAdapter')
+      connection.stub(:config => {:adapter => 'jdbc',
+                                  :url => 'jdbc:postgresql://127.0.0.1:3306/sphinx'})
+
+      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'})

data/spec/thinking_sphinx/configuration_spec.rb

@@ -241,74 +241,6 @@ describe ThinkingSphinx::Configuration do
     end
   end
 
-  describe '#client' do
-    before :each do
-      @config = ThinkingSphinx::Configuration.instance
-      @config.address     = 'domain.url'
-      @config.port        = 3333
-      @config.configuration.searchd.max_matches = 100
-      @config.timeout = 1
-    end
-
-    it "should return an instance of Riddle::Client" do
-      @config.client.should be_a(Riddle::Client)
-    end
-
-    it "should use the configuration address" do
-      @config.client.server.should == 'domain.url'
-    end
-
-    it "should use the configuration port" do
-      @config.client.port.should == 3333
-    end
-
-    it "should use the configuration max matches" do
-      @config.client.max_matches.should == 100
-    end
-
-    it "should use the configuration timeout" do
-      @config.client.timeout.should == 1
-    end
-
-    describe 'when shuffle is enabled' do
-      let(:client) { double('client', :max_matches= => nil, :timeout= => nil) }
-
-      before :each do
-        @config.shuffle = true
-      end
-
-      it "should shuffle client servers" do
-        @config.address = ['1.1.1.1', '2.2.2.2']
-        @config.address.stub!(:shuffle => ['2.2.2.2', '1.1.1.1'])
-
-        Riddle::Client.should_receive(:new) do |addresses, port, key|
-          addresses.should == ['2.2.2.2', '1.1.1.1']
-          client
-        end
-        @config.client
-      end
-    end
-
-    describe 'when shuffle is disabled' do
-      let(:client) { double('client', :max_matches= => nil, :timeout= => nil) }
-
-      before :each do
-        @config.shuffle = false
-      end
-
-      it "should not shuffle client servers" do
-        @config.address = ['1.1.1.1', '2.2.2.2.', '3.3.3.3', '4.4.4.4', '5.5.5.5']
-
-        @config.address.should_not_receive(:shuffle)
-        Riddle::Client.should_receive(:new) do |addresses, port, key|
-          addresses.should == ['1.1.1.1', '2.2.2.2.', '3.3.3.3', '4.4.4.4', '5.5.5.5']
-          client
-        end
-        @config.client
-      end
-    end
-  end
-
   describe '#models_by_crc' do
     before :each do
       @config = ThinkingSphinx::Configuration.instance

data/spec/thinking_sphinx/connection_spec.rb

@@ -0,0 +1,77 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::Connection do
+  describe '#client' do
+    let(:connection) { ThinkingSphinx::Connection.new }
+
+    before :each do
+      @config = ThinkingSphinx::Configuration.instance
+      @config.address     = 'domain.url'
+      @config.port        = 3333
+      @config.configuration.searchd.max_matches = 100
+      @config.timeout = 1
+
+      pending
+    end
+
+    it "should return an instance of Riddle::Client" do
+      connection.client.should be_a(Riddle::Client)
+    end
+
+    it "should use the configuration address" do
+      connection.client.server.should == 'domain.url'
+    end
+
+    it "should use the configuration port" do
+      connection.client.port.should == 3333
+    end
+
+    it "should use the configuration max matches" do
+      connection.client.max_matches.should == 100
+    end
+
+    it "should use the configuration timeout" do
+      connection.client.timeout.should == 1
+    end
+
+    describe 'when shuffle is enabled' do
+      let(:client) { double('client', :max_matches= => nil, :timeout= => nil,
+        :open => true) }
+
+      before :each do
+        @config.shuffle = true
+      end
+
+      it "should shuffle client servers" do
+        @config.address = ['1.1.1.1', '2.2.2.2']
+        @config.address.stub!(:shuffle => ['2.2.2.2', '1.1.1.1'])
+
+        Riddle::Client.should_receive(:new) do |addresses, port, key|
+          addresses.should == ['2.2.2.2', '1.1.1.1']
+          client
+        end
+        connection.client
+      end
+    end
+
+    describe 'when shuffle is disabled' do
+      let(:client) { double('client', :max_matches= => nil, :timeout= => nil,
+        :open => true) }
+
+      before :each do
+        @config.shuffle = false
+      end
+
+      it "should not shuffle client servers" do
+        @config.address = ['1.1.1.1', '2.2.2.2.', '3.3.3.3', '4.4.4.4', '5.5.5.5']
+
+        @config.address.should_not_receive(:shuffle)
+        Riddle::Client.should_receive(:new) do |addresses, port, key|
+          addresses.should == ['1.1.1.1', '2.2.2.2.', '3.3.3.3', '4.4.4.4', '5.5.5.5']
+          client
+        end
+        connection.client
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/facet_search_spec.rb

@@ -4,16 +4,16 @@ 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
-    config.stub!(:client => client)
+    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
@@ -22,28 +22,28 @@ describe ThinkingSphinx::FacetSearch do
         ThinkingSphinx::FacetSearch.new.facet_names.should == ['sphinx_internal_class']
       end
     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
-      
+
       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
     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
       ThinkingSphinx.should_receive(:search) do |options|
@@ -51,32 +51,32 @@ describe ThinkingSphinx::FacetSearch do
         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,28 +84,28 @@ 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)
@@ -113,7 +113,7 @@ describe ThinkingSphinx::FacetSearch do
           :classes => [Person], :facets => :state
         )
       end
-      
+
       it "should add key as attribute" do
         @facets.should have_key(:state)
       end
@@ -131,7 +131,7 @@ describe ThinkingSphinx::FacetSearch do
         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
         )
@@ -150,7 +150,7 @@ describe ThinkingSphinx::FacetSearch do
       end
     end
   end
-  
+
   describe "#for" do
     before do
       @person = Person.find(:first)
@@ -158,7 +158,7 @@ describe ThinkingSphinx::FacetSearch do
       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
       )
@@ -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

data/spec/thinking_sphinx/search_methods_spec.rb

@@ -4,150 +4,150 @@ describe ThinkingSphinx::SearchMethods do
   it "should be included into models with indexes" do
     Alpha.included_modules.should include(ThinkingSphinx::SearchMethods)
   end
-  
+
   it "should not be included into models that don't have indexes" do
     Gamma.included_modules.should_not include(ThinkingSphinx::SearchMethods)
   end
-  
+
   describe '.search_context' do
     it "should return nil if not within a model" do
       ThinkingSphinx.search_context.should be_nil
     end
-    
+
     it "should return the model if within one" do
       Alpha.search_context.should == Alpha
     end
   end
-  
+
   describe '.search' do
     it "should return an instance of ThinkingSphinx::Search" do
       Alpha.search.class.should == ThinkingSphinx::Search
     end
-    
+
     it "should set the classes option if not already set" do
       search = Alpha.search
       search.options[:classes].should == [Alpha]
     end
-    
+
     it "shouldn't set the classes option if already defined" do
       search = Alpha.search :classes => [Beta]
       search.options[:classes].should == [Beta]
     end
-    
+
     it "should default to nil for the classes options" do
       ThinkingSphinx.search.options[:classes].should be_nil
     end
   end
-  
+
   describe '.search_for_ids' do
     it "should return an instance of ThinkingSphinx::Search" do
       Alpha.search.class.should == ThinkingSphinx::Search
     end
-    
+
     it "should set the classes option if not already set" do
       search = Alpha.search_for_ids
       search.options[:classes].should == [Alpha]
     end
-    
+
     it "shouldn't set the classes option if already defined" do
       search = Alpha.search_for_ids :classes => [Beta]
       search.options[:classes].should == [Beta]
     end
-    
+
     it "should set ids_only to true" do
       search = Alpha.search_for_ids
       search.options[:ids_only].should be_true
     end
   end
-  
+
   describe '.search_for_id' do
     before :each do
       @config = ThinkingSphinx::Configuration.instance
       @client = Riddle::Client.new
 
-      @config.stub!(:client => @client)
+      ThinkingSphinx::Connection.stub!(:take).and_yield(@client)
       @client.stub!(:query => {:matches => [], :total_found => 0})
     end
-    
+
     it "should set the id range to the given id value" do
       ThinkingSphinx.search_for_id(101, 'alpha_core')
-      
+
       @client.id_range.should == (101..101)
     end
-    
+
     it "should not make any calls to the database" do
       Alpha.should_not_receive(:find)
-      
+
       ThinkingSphinx.search_for_id(101, 'alpha_core', :classes => [Alpha])
     end
-    
+
     it "should return true if there is a record" do
       @client.stub!(:query => {:matches => [
         {:attributes => {'sphinx_internal_id' => 100}}
       ], :total_found => 1})
-      
+
       ThinkingSphinx.search_for_id(101, 'alpha_core').should be_true
     end
-    
+
     it "should return false if there isn't a record" do
       ThinkingSphinx.search_for_id(101, 'alpha_core').should be_false
     end
   end
-  
+
   describe '.count' do
     before :each do
       @config = ThinkingSphinx::Configuration.instance
       @client = Riddle::Client.new
 
-      @config.stub!(:client => @client)
+      ThinkingSphinx::Connection.stub!(:take).and_yield(@client)
       @client.stub!(:query => {:matches => [], :total_found => 42})
     end
-    
+
     it "should fall through to ActiveRecord if called on a class" do
       @client.should_not_receive(:query)
-      
+
       Alpha.count
     end
-    
+
     it "should return the total number of results if called globally" do
       ThinkingSphinx.count.should == 42
     end
   end
-  
+
   describe '.search_count' do
     before :each do
       @config = ThinkingSphinx::Configuration.instance
       @client = Riddle::Client.new
 
-      @config.stub!(:client => @client)
+      ThinkingSphinx::Connection.stub!(:take).and_yield(@client)
       @client.stub!(:query => {:matches => [], :total_found => 42})
     end
-    
+
     it "should return the total number of results" do
       Alpha.search_count.should == 42
     end
-    
+
     it "should not make any calls to the database" do
       Alpha.should_not_receive(:find)
-      
+
       Alpha.search_count
     end
   end
-  
+
   describe '.facets' do
     before :each do
       ThinkingSphinx::Search.stub!(:bundle_searches => [])
     end
-    
+
     it "should return a FacetSearch instance" do
       Alpha.facets.should be_a(ThinkingSphinx::FacetSearch)
     end
-    
+
     it "should set the classes option if not already set" do
       facets = Alpha.facets
       facets.options[:classes].should == [Alpha]
     end
-    
+
     it "shouldn't set the classes option if already defined" do
       facets = Alpha.facets :classes => [Beta]
       facets.options[:classes].should == [Beta]