pixeltrix-thinking-sphinx 1.1.5 → 1.2.1

data/spec/{unit → lib}/thinking_sphinx/active_record_spec.rb

@@ -3,7 +3,7 @@ require 'spec/spec_helper'
 describe "ThinkingSphinx::ActiveRecord" do
   describe "define_index method" do
     before :each do
-      module TestModule
+      module ::TestModule
         class TestModel < ActiveRecord::Base; end
       end
       
@@ -14,7 +14,7 @@ describe "ThinkingSphinx::ActiveRecord" do
       )
       
       @index = ThinkingSphinx::Index.stub_instance(:delta? => false)
-      ThinkingSphinx::Index.stub_method(:new => @index)
+      ThinkingSphinx::Index::Builder.stub_method(:generate => @index)
     end
     
     after :each do
@@ -24,17 +24,17 @@ describe "ThinkingSphinx::ActiveRecord" do
       ThinkingSphinx.indexed_models.delete "TestModule::TestModel"
     end
     
-    it "should return nil and do nothing if indexes are disabled" do
+    it "should do nothing if indexes are disabled" do
       ThinkingSphinx.stub_method(:define_indexes? => false)
       
-      TestModule::TestModel.define_index {}.should be_nil
+      TestModule::TestModel.define_index {}
       ThinkingSphinx::Index.should_not have_received(:new)
       
       ThinkingSphinx.unstub_method(:define_indexes?)
     end
     
     it "should add a new index to the model" do
-      TestModule::TestModel.define_index do; end
+      TestModule::TestModel.define_index {}
       
       TestModule::TestModel.sphinx_indexes.length.should == 1
     end
@@ -64,15 +64,15 @@ describe "ThinkingSphinx::ActiveRecord" do
       
       TestModule::TestModel.define_index do; end
       
-      TestModule::TestModel.should have_received(:before_save)
-      TestModule::TestModel.should have_received(:after_commit)
+      TestModule::TestModel.should have_received(:before_save).with(:toggle_delta)
+      TestModule::TestModel.should have_received(:after_commit).with(:index_delta)
     end
     
     it "should not add before_save and after_commit hooks to the model if delta indexing is disabled" do
       TestModule::TestModel.define_index do; end
       
-      TestModule::TestModel.should_not have_received(:before_save)
-      TestModule::TestModel.should_not have_received(:after_commit)
+      TestModule::TestModel.should_not have_received(:before_save).with(:toggle_delta)
+      TestModule::TestModel.should_not have_received(:after_commit).with(:index_delta)
     end
     
     it "should add an after_destroy hook with delta indexing enabled" do
@@ -92,6 +92,76 @@ describe "ThinkingSphinx::ActiveRecord" do
     it "should return the new index" do
       TestModule::TestModel.define_index.should == @index
     end
+    
+    it "should die quietly if there is a database error" do
+      ThinkingSphinx::Index::Builder.stub_method_to_raise(:generate => Mysql::Error)
+      
+      lambda {
+        TestModule::TestModel.define_index
+      }.should_not raise_error
+    end
+    
+    it "should die noisily if there is a non-database error" do
+      ThinkingSphinx::Index::Builder.stub_method_to_raise(:generate => StandardError)
+      
+      lambda {
+        TestModule::TestModel.define_index
+      }.should raise_error
+    end
+  end
+
+  describe "index methods" do
+    before(:all) do
+      @person = Person.find(:first)
+    end
+
+    describe "in_both_indexes?" do
+      it "should return true if in core and delta indexes" do
+        @person.should_receive(:in_core_index?).and_return(true)
+        @person.should_receive(:in_delta_index?).and_return(true)
+        @person.in_both_indexes?.should be_true
+      end
+      
+      it "should return false if in one index and not the other" do
+        @person.should_receive(:in_core_index?).and_return(true)
+        @person.should_receive(:in_delta_index?).and_return(false)
+        @person.in_both_indexes?.should be_false
+      end
+    end
+
+    describe "in_core_index?" do
+      it "should call in_index? with core" do
+        @person.should_receive(:in_index?).with('core')
+        @person.in_core_index?
+      end
+    end
+
+    describe "in_delta_index?" do
+      it "should call in_index? with delta" do
+        @person.should_receive(:in_index?).with('delta')
+        @person.in_delta_index?
+      end
+    end
+
+    describe "in_index?" do
+      it "should return true if in the specified index" do
+        @person.should_receive(:sphinx_document_id).and_return(1)
+        @person.should_receive(:sphinx_index_name).and_return('person_core')
+        Person.should_receive(:search_for_id).with(1, 'person_core').and_return(true)
+      
+        @person.in_index?('core').should be_true
+      end
+    end
+  end
+
+  describe "source_of_sphinx_index method" do
+    it "should return self if model defines an index" do
+      Person.source_of_sphinx_index.should == Person
+    end
+
+    it "should return the parent if model inherits an index" do
+      Admin::Person.source_of_sphinx_index.should == Person
+    end
   end
   
   describe "to_crc32 method" do
@@ -100,6 +170,12 @@ describe "ThinkingSphinx::ActiveRecord" do
     end
   end
     
+  describe "to_crc32s method" do
+    it "should return an array" do
+      Person.to_crc32s.should be_a_kind_of(Array)
+    end
+  end
+    
   describe "toggle_deleted method" do
     before :each do
       ThinkingSphinx.stub_method(:sphinx_running? => true)
@@ -109,7 +185,8 @@ describe "ThinkingSphinx::ActiveRecord" do
         :address  => "an address",
         :port     => 123
       )
-      @client = Riddle::Client.stub_instance(:update => true)
+      @client = Riddle::Client.new
+      @client.stub!(:update => true)
       @person = Person.find(:first)
       
       Riddle::Client.stub_method(:new => @client)
@@ -126,87 +203,82 @@ describe "ThinkingSphinx::ActiveRecord" do
     end
     
     it "should update the core index's deleted flag if in core index" do
-      @person.toggle_deleted
-      
-      @client.should have_received(:update).with(
+      @client.should_receive(:update).with(
         "person_core", ["sphinx_deleted"], {@person.sphinx_document_id => 1}
       )
+      
+      @person.toggle_deleted
     end
     
     it "shouldn't update the core index's deleted flag if the record isn't in it" do
       @person.stub_method(:in_core_index? => false)
-      
-      @person.toggle_deleted
-      
-      @client.should_not have_received(:update).with(
+      @client.should_not_receive(:update).with(
         "person_core", ["sphinx_deleted"], {@person.sphinx_document_id => 1}
       )
+      
+      @person.toggle_deleted
     end
     
     it "shouldn't attempt to update the deleted flag if sphinx isn't running" do
       ThinkingSphinx.stub_method(:sphinx_running? => false)
+      @client.should_not_receive(:update)
       
       @person.toggle_deleted
       
       @person.should_not have_received(:in_core_index?)
-      @client.should_not have_received(:update)
     end
     
     it "should update the delta index's deleted flag if delta indexes are enabled and the instance's delta is true" do
       ThinkingSphinx.stub_method(:deltas_enabled? => true)
       Person.sphinx_indexes.each { |index| index.stub_method(:delta? => true) }
       @person.delta = true
-      
-      @person.toggle_deleted
-      
-      @client.should have_received(:update).with(
+      @client.should_receive(:update).with(
         "person_delta", ["sphinx_deleted"], {@person.sphinx_document_id => 1}
       )
+      
+      @person.toggle_deleted
     end
     
     it "should not update the delta index's deleted flag if delta indexes are enabled and the instance's delta is false" do
       ThinkingSphinx.stub_method(:deltas_enabled? => true)
       Person.sphinx_indexes.each { |index| index.stub_method(:delta? => true) }
       @person.delta = false
-      
-      @person.toggle_deleted
-      
-      @client.should_not have_received(:update).with(
+      @client.should_not_receive(:update).with(
         "person_delta", ["sphinx_deleted"], {@person.sphinx_document_id => 1}
       )
+      
+      @person.toggle_deleted
     end
     
     it "should not update the delta index's deleted flag if delta indexes are enabled and the instance's delta is equivalent to false" do
       ThinkingSphinx.stub_method(:deltas_enabled? => true)
       Person.sphinx_indexes.each { |index| index.stub_method(:delta? => true) }
       @person.delta = 0
-
-      @person.toggle_deleted
-
-      @client.should_not have_received(:update).with(
+      @client.should_not_receive(:update).with(
         "person_delta", ["sphinx_deleted"], {@person.sphinx_document_id => 1}
       )
+
+      @person.toggle_deleted
     end
 
     it "shouldn't update the delta index if delta indexes are disabled" do
       ThinkingSphinx.stub_method(:deltas_enabled? => true)
-      @person.toggle_deleted
-      
-      @client.should_not have_received(:update).with(
+      @client.should_not_receive(:update).with(
         "person_delta", ["sphinx_deleted"], {@person.sphinx_document_id => 1}
       )
+      
+      @person.toggle_deleted
     end
     
     it "should not update the delta index if delta indexing is disabled" do
       ThinkingSphinx.stub_method(:deltas_enabled? => false)
       Person.sphinx_indexes.each { |index| index.stub_method(:delta? => true) }
       @person.delta = true
-      
-      @person.toggle_deleted
-      
-      @client.should_not have_received(:update).with(
+      @client.should_not_receive(:update).with(
         "person_delta", ["sphinx_deleted"], {@person.sphinx_document_id => 1}
       )
+      
+      @person.toggle_deleted
     end
     
     it "should not update either index if updates are disabled" do
@@ -216,10 +288,9 @@ describe "ThinkingSphinx::ActiveRecord" do
       )
       Person.sphinx_indexes.each { |index| index.stub_method(:delta? => true) }
       @person.delta = true
+      @client.should_not_receive(:update)
       
       @person.toggle_deleted
-      
-      @client.should_not have_received(:update)
     end
   end
 
@@ -229,10 +300,12 @@ describe "ThinkingSphinx::ActiveRecord" do
     end
 
     it "should allow associations to other STI models" do
-      Child.sphinx_indexes.last.link!
-      sql = Child.sphinx_indexes.last.to_riddle_for_core(0, 0).sql_query
+      source = Child.sphinx_indexes.last.sources.first
+      sql = source.to_riddle_for_core(0, 0).sql_query
       sql.gsub!('$start', '0').gsub!('$end', '100')
-      lambda { Child.connection.execute(sql) }.should_not raise_error(ActiveRecord::StatementInvalid)
+      lambda {
+        Child.connection.execute(sql)
+      }.should_not raise_error(ActiveRecord::StatementInvalid)
     end
   end
   

data/spec/{unit → lib}/thinking_sphinx/association_spec.rb

@@ -79,7 +79,8 @@ describe ThinkingSphinx::Association do
     before :each do
       @parent_join = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub_instance
       @join = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub_instance
-      @parent = ThinkingSphinx::Association.stub_instance(:join_to => true, :join => nil)
+      @parent = ThinkingSphinx::Association.new(nil, nil)
+      @parent.stub!(:join_to => true, :join => nil)
       @base_join = Object.stub_instance(:joins => [:a, :b, :c])
       
       ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub_method(:new => @join)
@@ -87,19 +88,17 @@ describe ThinkingSphinx::Association do
     
     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)
-      
-      @parent.should have_received(:join_to).with(@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_method(:join => @parent_join)
+      @parent.should_not_receive(:join_to)
       
       @assoc.join_to(@base_join)
-      
-      @parent.should_not have_received(:join_to)
     end
     
     it "should define the join association with a JoinAssociation instance" do