thinking-sphinx 1.5.0 → 2.0.0.rc1

data/spec/thinking_sphinx/active_record/delta_spec.rb

@@ -3,41 +3,41 @@ require 'spec_helper'
 describe "ThinkingSphinx::ActiveRecord::Delta" do
   it "should call the toggle_delta method after a save" do
     @beta = Beta.new(:name => 'beta')
-    @beta.should_receive(:toggle_delta).at_least(1).times.and_return(true)
-
+    @beta.should_receive(:toggle_delta).and_return(true)
+    
     @beta.save
   end
-
+  
   it "should call the toggle_delta method after a save!" do
     @beta = Beta.new(:name => 'beta')
-    @beta.should_receive(:toggle_delta).at_least(1).times.and_return(true)
-
+    @beta.should_receive(:toggle_delta).and_return(true)
+    
     @beta.save!
   end
-
+  
   describe "suspended_delta method" do
     before :each do
-      ThinkingSphinx.deltas_suspended = false
+      ThinkingSphinx.deltas_enabled = true
       Person.sphinx_indexes.first.delta_object.stub!(:` => "")
     end
 
     it "should execute the argument block with deltas disabled" do
-      ThinkingSphinx.should_receive(:deltas_suspended=).once.with(true)
-      ThinkingSphinx.should_receive(:deltas_suspended=).once.with(false)
+      ThinkingSphinx.should_receive(:deltas_enabled=).once.with(false)
+      ThinkingSphinx.should_receive(:deltas_enabled=).once.with(true)
       lambda { Person.suspended_delta { raise 'i was called' } }.should(
         raise_error(Exception)
       )
     end
 
     it "should restore deltas_enabled to its original setting" do
-      ThinkingSphinx.deltas_suspended = true
-      ThinkingSphinx.should_receive(:deltas_suspended=).twice.with(true)
+      ThinkingSphinx.deltas_enabled = false
+      ThinkingSphinx.should_receive(:deltas_enabled=).twice.with(false)
       Person.suspended_delta { 'no-op' }
     end
 
     it "should restore deltas_enabled to its original setting even if there was an exception" do
-      ThinkingSphinx.deltas_suspended = true
-      ThinkingSphinx.should_receive(:deltas_suspended=).twice.with(true)
+      ThinkingSphinx.deltas_enabled = false
+      ThinkingSphinx.should_receive(:deltas_enabled=).twice.with(false)
       lambda { Person.suspended_delta { raise 'bad error' } }.should(
         raise_error(Exception)
       )
@@ -47,76 +47,81 @@ describe "ThinkingSphinx::ActiveRecord::Delta" do
       Person.should_receive(:index_delta)
       Person.suspended_delta { 'no-op' }
     end
-
+    
     it "should not reindex after the code block if false is passed in" do
       Person.should_not_receive(:index_delta)
       Person.suspended_delta(false) { 'no-op' }
     end
   end
-
+  
   describe "toggle_delta method" do
     it "should set the delta value to true" do
       @person = Person.new
-
+      
       @person.delta.should be_false
       @person.send(:toggle_delta)
       @person.delta.should be_true
     end
   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.delta_object.stub!(:` => "", :toggled => true)
+      
       @person = Person.new
       Person.stub!(:search_for_id => false)
       @person.stub!(:sphinx_document_id => 1)
-
+      
       @client = Riddle::Client.new
       @client.stub!(:update => true)
-      ThinkingSphinx::Connection.stub(:take).and_yield @client
+      ThinkingSphinx::Configuration.instance.stub!(:client => @client)
     end
-
+    
     it "shouldn't index if delta indexing is disabled" do
       ThinkingSphinx.deltas_enabled = false
       Person.sphinx_indexes.first.delta_object.should_not_receive(:`)
       @client.should_not_receive(:update)
-
+      
       @person.send(:index_delta)
     end
-
+    
     it "shouldn't index if index updating is disabled" do
       ThinkingSphinx.updates_enabled = false
       Person.sphinx_indexes.first.delta_object.should_not_receive(:`)
-
+      
       @person.send(:index_delta)
     end
-
+    
     it "shouldn't index if the environment is 'test'" do
       ThinkingSphinx.deltas_enabled = nil
       ThinkingSphinx::Configuration.stub!(:environment => "test")
       Person.sphinx_indexes.first.delta_object.should_not_receive(:`)
-
+      
       @person.send(:index_delta)
     end
-
-    it "should run the index job" do
-      index_job.should_receive(:perform)
-
+    
+    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"
+      )
+      
       @person.send(:index_delta)
     end
-
+    
+    it "shouldn't update the deleted attribute if not in the index" do
+      @client.should_not_receive(:update)
+      
+      @person.send(:index_delta)
+    end
+    
     it "should update the deleted attribute if in the core index" do
       Person.stub!(:search_for_id => true)
       @client.should_receive(:update)
-
+      
       @person.send(:index_delta)
     end
   end

data/spec/thinking_sphinx/active_record/has_many_association_spec.rb

@@ -23,17 +23,6 @@ describe 'ThinkingSphinx::ActiveRecord::HasManyAssociation' do
       @person.friendships.search "test"
     end
     
-    it "should add a filter for an aliased attribute into a normal search call" do
-      @team = CricketTeam.new
-      @team.stub!(:id => 1)
-
-      Person.should_receive(:search).with do |query, options|
-        options[:with][:team_id].should == @team.id
-      end
-
-      @team.people.search "test"
-    end
-
     it "should define indexes for the reflection class" do
       Friendship.should_receive(:define_indexes)
       
@@ -41,46 +30,6 @@ describe 'ThinkingSphinx::ActiveRecord::HasManyAssociation' do
     end
   end
   
-  describe "facets method" do
-    before :each do
-      Friendship.stub!(:facets => true)
-
-      @person = Person.find(:first)
-      @index  = Friendship.sphinx_indexes.first
-    end
-
-    it "should raise an error if the required attribute doesn't exist" do
-      @index.stub!(:attributes => [])
-
-      lambda { @person.friendships.facets "test" }.should raise_error(RuntimeError)
-    end
-
-    it "should add a filter for the attribute into a normal facets call" do
-      Friendship.should_receive(:facets) do |query, options|
-        options[:with][:person_id].should == @person.id
-      end
-
-      @person.friendships.facets "test"
-    end
-
-    it "should add a filter for an aliased attribute into a normal facets call" do
-      @team = CricketTeam.new
-      @team.stub!(:id => 1)
-
-      Person.should_receive(:facets).with do |query, options|
-        options[:with][:team_id].should == @team.id
-      end
-
-      @team.people.facets "test"
-    end
-
-    it "should define indexes for the reflection class" do
-      Friendship.should_receive(:define_indexes)
-
-      @person.friendships.facets 'test'
-    end
-  end
-
   describe "search method for has_many :through" do
     before :each do
       Person.stub!(:search => true)
@@ -102,53 +51,8 @@ describe 'ThinkingSphinx::ActiveRecord::HasManyAssociation' do
       
       @person.friends.search "test"
     end
-
-    it "should add a filter for an aliased attribute into a normal search call" do
-      @team = FootballTeam.new
-      @team.stub!(:id => 1)
-
-      Person.should_receive(:search).with do |query, options|
-        options[:with][:football_team_id].should == @team.id
-      end
-
-      @team.people.search "test"
-    end
   end
   
-  describe "facets method for has_many :through" do
-    before :each do
-      Person.stub!(:facets => true)
-
-      @person = Person.find(:first)
-      @index  = Person.sphinx_indexes.first
-    end
-
-    it "should raise an error if the required attribute doesn't exist" do
-      @index.stub!(:attributes => [])
-
-      lambda { @person.friends.facets "test" }.should raise_error(RuntimeError)
-    end
-
-    it "should add a filter for the attribute into a normal facets call" do
-      Person.should_receive(:facets).with do |query, options|
-        options[:with][:friendly_ids].should == @person.id
-      end
-
-      @person.friends.facets "test"
-    end
-
-    it "should add a filter for an aliased attribute into a normal facets call" do
-      @team = FootballTeam.new
-      @team.stub!(:id => 1)
-
-      Person.should_receive(:facets).with do |query, options|
-        options[:with][:football_team_id].should == @team.id
-      end
-
-      @team.people.facets "test"
-    end
-  end
-
   describe 'filtering sphinx scopes' do
     before :each do
       Friendship.stub!(:search => Friendship)

data/spec/thinking_sphinx/active_record/scopes_spec.rb

@@ -4,32 +4,32 @@ describe ThinkingSphinx::ActiveRecord::Scopes do
   after :each do
     Alpha.remove_sphinx_scopes
   end
-
+  
   it "should be included into models with indexes" do
     Alpha.included_modules.should include(ThinkingSphinx::ActiveRecord::Scopes)
   end
-
+  
   it "should not be included into models without indexes" do
     Gamma.included_modules.should_not include(
       ThinkingSphinx::ActiveRecord::Scopes
     )
   end
-
+  
   describe '.sphinx_scope' do
     before :each do
       Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
     end
-
+    
     it "should define a method on the model" do
       Alpha.should respond_to(:by_name)
     end
   end
-
+  
   describe '.sphinx_scopes' do
     before :each do
       Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
     end
-
+    
     it "should return an array of defined scope names as symbols" do
       Alpha.sphinx_scopes.should == [:by_name]
     end
@@ -40,11 +40,11 @@ describe ThinkingSphinx::ActiveRecord::Scopes do
       Alpha.sphinx_scope(:scope_used_as_default_scope) { {:conditions => {:name => 'name'}} }
       Alpha.default_sphinx_scope :scope_used_as_default_scope
     end
-
+    
     it "should return an array of defined scope names as symbols" do
       Alpha.sphinx_scopes.should == [:scope_used_as_default_scope]
     end
-
+    
     it "should have a default_sphinx_scope" do
       Alpha.has_default_sphinx_scope?.should be_true
     end
@@ -55,11 +55,11 @@ describe ThinkingSphinx::ActiveRecord::Scopes do
       Alpha.sphinx_scope(:by_name) { |name| {:conditions => {:name => name}} }
       Alpha.remove_sphinx_scopes
     end
-
+    
     it "should remove sphinx scope methods" do
       Alpha.should_not respond_to(:by_name)
     end
-
+    
     it "should empty the list of sphinx scopes" do
       Alpha.sphinx_scopes.should be_empty
     end
@@ -87,9 +87,10 @@ describe ThinkingSphinx::ActiveRecord::Scopes do
       search.by_foo('foo').search.options[:conditions].should == {:foo => 'foo', :name => 'foo'}
     end
 
-    it "should apply the default scope options before other scope options to the underlying search object" do
+    # FIXME: Probably the other way around is more logical? How to do this?
+    it "should apply the default scope options after other scope options to the underlying search object" do
       search = ThinkingSphinx::Search.new(:classes => [Alpha])
-      search.by_name('bar').search.options[:conditions].should == {:name => 'bar'}
+      search.by_name('bar').search.options[:conditions].should == {:name => 'foo'}
     end
   end
 
@@ -99,73 +100,72 @@ describe ThinkingSphinx::ActiveRecord::Scopes do
       Alpha.sphinx_scope(:by_foo)  { |foo|  {:conditions => {:foo  => foo}}  }
       Alpha.sphinx_scope(:with_betas) { {:classes => [Beta]} }
     end
-
+    
     it "should return a ThinkingSphinx::Search object" do
       Alpha.by_name('foo').should be_a(ThinkingSphinx::Search)
     end
-
+    
     it "should set the classes option" do
       Alpha.by_name('foo').options[:classes].should == [Alpha]
     end
-
+    
     it "should be able to be called on a ThinkingSphinx::Search object" do
       search = ThinkingSphinx::Search.new(:classes => [Alpha])
       lambda {
         search.by_name('foo')
       }.should_not raise_error
     end
-
+    
     it "should return the search object it gets called upon" do
       search = ThinkingSphinx::Search.new(:classes => [Alpha])
-      search.by_name('foo').object_id.should == search.object_id
+      search.by_name('foo').should == search
     end
-
+    
     it "should apply the scope options to the underlying search object" do
       search = ThinkingSphinx::Search.new(:classes => [Alpha])
       search.by_name('foo').options[:conditions].should == {:name => 'foo'}
     end
-
+    
     it "should combine hash option scopes such as :conditions" do
       search = ThinkingSphinx::Search.new(:classes => [Alpha])
       search.by_name('foo').by_foo('bar').options[:conditions].
         should == {:name => 'foo', :foo => 'bar'}
     end
-
+    
     it "should combine array option scopes such as :classes" do
       search = ThinkingSphinx::Search.new(:classes => [Alpha])
       search.with_betas.options[:classes].should == [Alpha, Beta]
     end
   end
-
+  
   describe '.search_count_with_scope' do
     before :each do
       @config = ThinkingSphinx::Configuration.instance
       @client = Riddle::Client.new
 
-      ThinkingSphinx::Connection.stub(:take).and_yield(@client)
-
+      @config.stub!(:client => @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} }
     end
-
+    
     it "should return the total number of results" do
       Alpha.by_name('foo').search_count.should == 43
     end
-
+    
     it "should not make any calls to the database" do
       Alpha.should_not_receive(:find)
-
+      
       Alpha.by_name('foo').search_count
     end
-
+    
     it "should not leave the :ids_only option set and the results populated if it was not set before" do
       stored_scope = Alpha.by_name('foo')
       stored_scope.search_count
       stored_scope.options[:ids_only].should be_false
       stored_scope.populated?.should be_false
     end
-
+    
     it "should leave the :ids_only option set and the results populated if it was set before" do
       stored_scope = Alpha.by_name('foo').ids_only
       stored_scope.search_count
@@ -173,5 +173,5 @@ describe ThinkingSphinx::ActiveRecord::Scopes do
       stored_scope.populated?.should be_true
     end
   end
-
+  
 end