thinking-sphinx 1.2.13 → 6.0.0

data/spec/lib/thinking_sphinx/active_record_spec.rb

@@ -1,353 +0,0 @@
-require 'spec/spec_helper'
-
-describe ThinkingSphinx::ActiveRecord do
-  describe '.define_index' do
-    before :each do
-      module ::TestModule
-        class TestModel < ActiveRecord::Base; end
-      end
-      
-      TestModule::TestModel.stub!(
-        :before_save    => true,
-        :after_commit   => true,
-        :after_destroy  => true
-      )
-      
-      @index = ThinkingSphinx::Index.new(TestModule::TestModel)
-      @index.stub!(:delta? => false)
-      ThinkingSphinx::Index::Builder.stub!(:generate => @index)
-    end
-    
-    after :each do
-      # Remove the class so we can redefine it
-      TestModule.send(:remove_const, :TestModel)
-      
-      ThinkingSphinx.indexed_models.delete "TestModule::TestModel"
-    end
-    
-    it "should do nothing if indexes are disabled" do
-      ThinkingSphinx.define_indexes = false
-      ThinkingSphinx::Index.should_not_receive(:new)
-      
-      TestModule::TestModel.define_index {}
-      
-      ThinkingSphinx.define_indexes = true
-    end
-    
-    it "should add a new index to the model" do
-      TestModule::TestModel.define_index {}
-      
-      TestModule::TestModel.sphinx_indexes.length.should == 1
-    end
-    
-    it "should add to ThinkingSphinx.indexed_models if the model doesn't already exist in the array" do
-      TestModule::TestModel.define_index do; end
-      
-      ThinkingSphinx.indexed_models.should include("TestModule::TestModel")
-    end
-    
-    it "shouldn't add to ThinkingSphinx.indexed_models if the model already exists in the array" do
-      TestModule::TestModel.define_index do; end
-      
-      ThinkingSphinx.indexed_models.select { |model|
-        model == "TestModule::TestModel"
-      }.length.should == 1
-      
-      TestModule::TestModel.define_index do; end
-      
-      ThinkingSphinx.indexed_models.select { |model|
-        model == "TestModule::TestModel"
-      }.length.should == 1
-    end
-    
-    it "should add before_save and after_commit hooks to the model if delta indexing is enabled" do
-      @index.stub!(:delta? => true)
-      TestModule::TestModel.should_receive(:before_save).with(:toggle_delta)
-      TestModule::TestModel.should_receive(:after_commit).with(:index_delta)
-      
-      TestModule::TestModel.define_index do; end
-    end
-    
-    it "should not add before_save and after_commit hooks to the model if delta indexing is disabled" do
-      TestModule::TestModel.should_not_receive(:before_save).with(:toggle_delta)
-      TestModule::TestModel.should_not_receive(:after_commit).with(:index_delta)
-      
-      TestModule::TestModel.define_index do; end
-    end
-    
-    it "should add an after_destroy hook with delta indexing enabled" do
-      @index.stub!(:delta? => true)
-      TestModule::TestModel.should_receive(:after_destroy).with(:toggle_deleted)
-      
-      TestModule::TestModel.define_index do; end
-    end
-    
-    it "should add an after_destroy hook with delta indexing disabled" do
-      TestModule::TestModel.should_receive(:after_destroy).with(:toggle_deleted)
-      
-      TestModule::TestModel.define_index do; end
-    end
-    
-    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(:generate) { raise 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(:generate) { raise 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' 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' do
-    it "should return an integer" do
-      Person.to_crc32.should be_a_kind_of(Integer)
-    end
-  end
-    
-  describe '.to_crc32s' 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!(:sphinx_running? => true)
-      
-      @configuration = ThinkingSphinx::Configuration.instance
-      @configuration.stub!(
-        :address  => "an address",
-        :port     => 123
-      )
-      @client = Riddle::Client.new
-      @client.stub!(:update => true)
-      @person = Person.find(:first)
-      
-      Riddle::Client.stub!(:new => @client)
-      Person.sphinx_indexes.each { |index| index.stub!(:delta? => false) }
-      @person.stub!(:in_core_index? => true)
-    end
-    
-    it "should create a client using the Configuration's address and port" do
-      Riddle::Client.should_receive(:new).with(
-        @configuration.address, @configuration.port
-      )
-      
-      @person.toggle_deleted
-    end
-    
-    it "should update the core index's deleted flag if in core index" do
-      @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!(:in_core_index? => false)
-      @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!(:sphinx_running? => false)
-      @client.should_not_receive(:update)
-      @person.should_not_receive(:in_core_index?)
-      
-      @person.toggle_deleted
-    end
-    
-    it "should update the delta index's deleted flag if delta indexes are enabled and the instance's delta is true" do
-      ThinkingSphinx.deltas_enabled = true
-      Person.sphinx_indexes.each { |index| index.stub!(:delta? => true) }
-      @person.delta = true
-      @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.deltas_enabled = true
-      Person.sphinx_indexes.each { |index| index.stub!(:delta? => true) }
-      @person.delta = false
-      @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.deltas_enabled = true
-      Person.sphinx_indexes.each { |index| index.stub!(:delta? => true) }
-      @person.delta = 0
-      @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.deltas_enabled = true
-      @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
-      ThinkingSphinx.updates_enabled = false
-      ThinkingSphinx.deltas_enabled  = true
-      Person.sphinx_indexes.each { |index| index.stub!(:delta? => true) }
-      @person.delta = true
-      @client.should_not_receive(:update)
-      
-      @person.toggle_deleted
-    end
-  end
-
-  describe "sphinx_indexes in the inheritance chain (STI)" do
-    it "should hand defined indexes on a class down to its child classes" do
-      Child.sphinx_indexes.should include(*Person.sphinx_indexes)
-    end
-
-    it "should allow associations to other STI models" do
-      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)
-    end
-  end
-  
-  it "should return the sphinx document id as expected" do
-    person      = Person.find(:first)
-    model_count = ThinkingSphinx.indexed_models.length
-    offset      = ThinkingSphinx.indexed_models.index("Person")
-    
-    (person.id * model_count + offset).should == person.sphinx_document_id
-    
-    alpha       = Alpha.find(:first)
-    offset      = ThinkingSphinx.indexed_models.index("Alpha")
-    
-    (alpha.id * model_count + offset).should == alpha.sphinx_document_id
-    
-    beta        = Beta.find(:first)
-    offset      = ThinkingSphinx.indexed_models.index("Beta")
-    
-    (beta.id * model_count + offset).should == beta.sphinx_document_id
-  end
-  
-  describe '#primary_key_for_sphinx' do
-    before :each do
-      @person = Person.find(:first)
-    end
-    
-    after :each do
-      Person.set_sphinx_primary_key nil
-    end
-    
-    it "should return the id by default" do
-      @person.primary_key_for_sphinx.should == @person.id
-    end
-    
-    it "should use the sphinx primary key to determine the value" do
-      Person.set_sphinx_primary_key :first_name
-      @person.primary_key_for_sphinx.should == @person.first_name
-    end
-    
-    it "should not use accessor methods but the attributes hash" do
-      id = @person.id
-      @person.stub!(:id => 'unique_hash')
-      @person.primary_key_for_sphinx.should == id
-    end
-  end
-  
-  describe '.sphinx_index_names' do
-    it "should return the core index" do
-      Alpha.sphinx_index_names.should == ['alpha_core']
-    end
-    
-    it "should return the delta index if enabled" do
-      Beta.sphinx_index_names.should == ['beta_core', 'beta_delta']
-    end
-    
-    it "should return the superclass with an index definition" do
-      Parent.sphinx_index_names.should == ['person_core', 'person_delta']
-    end
-  end
-end

data/spec/lib/thinking_sphinx/association_spec.rb

@@ -1,239 +0,0 @@
-require 'spec/spec_helper'
-
-describe ThinkingSphinx::Association do
-  describe '.children' do
-    before :each do
-      @normal_reflection = stub('reflection', :options => {
-        :polymorphic => false
-      })
-      @normal_association = ThinkingSphinx::Association.new(nil, nil)
-      @poly_reflection = stub('reflection',
-        :options        => {:polymorphic => true},
-        :macro          => :has_many,
-        :name           => 'polly',
-        :active_record  => 'AR'
-      )
-      @non_poly_reflection = stub('reflection')
-      
-      Person.stub!(:reflect_on_association => @normal_reflection)
-      ThinkingSphinx::Association.stub!(
-        :new                  => @normal_association,
-        :polymorphic_classes  => [Person, Person],
-        :casted_options       => {:casted => :options}
-      )
-      ::ActiveRecord::Reflection::AssociationReflection.stub!(
-        :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)
-      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
-      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
-      @join = stub('join assoc').as_null_object
-      @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)
-    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 '#to_sql' do
-    before :each do
-      @reflection = stub('reflection', :klass => Person)
-      @association = ThinkingSphinx::Association.new(nil, @reflection)
-      @parent = stub('parent', :aliased_table_name => "ALIAS TABLE NAME")
-      @join = stub('join assoc',
-        :association_join => "full association join SQL",
-        :parent           => @parent
-      )
-      @association.join = @join
-    end
-    
-    it "should return the join's association join value" do
-      @association.to_sql.should == "full association join SQL"
-    end
-    
-    it "should replace ::ts_join_alias:: with the aliased table name" do
-      @join.stub!(:association_join => "text with ::ts_join_alias:: gone")
-      
-      @association.to_sql.should == "text with `ALIAS TABLE NAME` gone"
-    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])
-      association = ThinkingSphinx::Association.new(parent, @reflection)
-      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 => [
-        {"person_type" => "Person"},
-        {"person_type" => "Friendship"}
-      ])
-      ref = stub('ref',
-        :active_record  => Person,
-        :options        => {:foreign_type => "person_type"}
-      )
-      
-      ThinkingSphinx::Association.send(:polymorphic_classes, ref).should == [Person, Friendship]
-    end
-  end
-  
-  describe '.casted_options' do
-    before :each do
-      @options = {
-        :foreign_key  => "thing_id",
-        :foreign_type => "thing_type",
-        :polymorphic  => true
-      }
-      @reflection = stub('assoc reflection', :options => @options)
-    end
-    
-    it "should return a new options set for a specific class" do
-      ThinkingSphinx::Association.send(:casted_options, Person, @reflection).should == {
-        :polymorphic  => nil,
-        :class_name   => "Person",
-        :foreign_key  => "thing_id",
-        :foreign_type => "thing_type",
-        :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 == {
-        :polymorphic  => nil,
-        :class_name   => "Person",
-        :foreign_key  => "thing_id",
-        :foreign_type => "thing_type",
-        :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 == {
-        :polymorphic  => nil,
-        :class_name   => "Person",
-        :foreign_key  => "thing_id",
-        :foreign_type => "thing_type",
-        :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 == {
-        :polymorphic  => nil,
-        :class_name   => "Person",
-        :foreign_key  => "thing_id",
-        :foreign_type => "thing_type",
-        :conditions   => "first condition AND ::ts_join_alias::.`thing_type` = 'Person'"
-      }
-    end
-  end
-end