jaikoo-thinking-sphinx 0.9.10

data/spec/unit/thinking_sphinx/association_spec.rb

@@ -0,0 +1,247 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Association do
+  describe "class-level children method" do
+    before :each do
+      @normal_reflection = ::ActiveRecord::Reflection::AssociationReflection.stub_instance(
+        :options => {:polymorphic => false}
+      )
+      @normal_association = ThinkingSphinx::Association.stub_instance
+      @poly_reflection = ::ActiveRecord::Reflection::AssociationReflection.stub_instance(
+        :options        => {:polymorphic => true},
+        :macro          => :has_many,
+        :name           => "polly",
+        :active_record  => "AR"
+      )
+      @non_poly_reflection = ::ActiveRecord::Reflection::AssociationReflection.stub_instance
+      
+      Person.stub_method(:reflect_on_association => @normal_reflection)
+      ThinkingSphinx::Association.stub_methods(
+        :new                  => @normal_association,
+        :polymorphic_classes  => [Person, Person],
+        :casted_options       => {:casted => :options}
+      )
+      ::ActiveRecord::Reflection::AssociationReflection.stub_method(
+        :new => @non_poly_reflection
+      )
+    end
+    
+    it "should return an empty array if no association exists" do
+      Person.stub_method(: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_method(: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_method(:reflect_on_association => @poly_reflection)
+      
+      ThinkingSphinx::Association.children(Person, :assoc)
+      
+      ThinkingSphinx::Association.should have_received(:casted_options).with(
+        Person, @poly_reflection
+      ).twice
+      
+      ::ActiveRecord::Reflection::AssociationReflection.should have_received(:new).with(
+        :has_many, :polly_Person, {:casted => :options}, "AR"
+      ).twice
+      
+      ThinkingSphinx::Association.should have_received(:new).with(
+        nil, @non_poly_reflection
+      ).twice
+    end
+  end
+  
+  describe "instance-level children method" do
+    it "should return the children associations for the given association" do
+      @reflection = ::ActiveRecord::Reflection::AssociationReflection.stub_instance(
+        :klass => :klass
+      )
+      @association = ThinkingSphinx::Association.new(nil, @reflection)
+      ThinkingSphinx::Association.stub_method(:children => :result)
+      
+      @association.children(:assoc).should == :result
+      ThinkingSphinx::Association.should have_received(:children).with(:klass, :assoc, @association)
+    end
+  end
+  
+  describe "join_to method" 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)
+      @base_join = Object.stub_instance(:joins => [:a, :b, :c])
+      
+      ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub_method(:new => @join)
+    end
+    
+    it "should call the parent's join_to if parent has no join" do
+      @assoc = ThinkingSphinx::Association.new(@parent, :ref)
+      
+      @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)
+      
+      @assoc.join_to(@base_join)
+      
+      @parent.should_not have_received(:join_to)
+    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 method" do
+    before :each do
+      @reflection = ::ActiveRecord::Reflection::AssociationReflection.stub_instance(
+        :klass => Person
+      )
+      @association = ThinkingSphinx::Association.new(nil, @reflection)
+      @parent = Object.stub_instance(:aliased_table_name => "ALIAS TABLE NAME")
+      @join = ::ActiveRecord::Associations::ClassMethods::JoinDependency::JoinAssociation.stub_instance(
+        :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_method(:association_join => "text with ::ts_join_alias:: gone")
+      
+      @association.to_sql.should == "text with `ALIAS TABLE NAME` gone"
+    end
+  end
+  
+  describe "is_many? method" do
+    before :each do
+      @parent = ThinkingSphinx::Association.stub_instance(
+        :is_many? => :parent_is_many
+      )
+      @reflection = ::ActiveRecord::Reflection::AssociationReflection.stub_instance(
+        :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_method(: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_method(: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_method(:macro => :belongs_to)
+      association.is_many?.should be_false
+    end
+  end
+  
+  describe "ancestors method" do
+    it "should return an array of associations - including all parents" do
+      parent = ThinkingSphinx::Association.stub_instance(:ancestors => [:all, :ancestors])
+      association = ThinkingSphinx::Association.new(parent, @reflection)
+      association.ancestors.should == [:all, :ancestors, association]
+    end
+  end
+  
+  describe "polymorphic_classes method" do
+    it "should return all the polymorphic result types as classes" do
+      Person.connection.stub_method(:select_all => [
+        {"person_type" => "Person"},
+        {"person_type" => "Friendship"}
+      ])
+      ref = Object.stub_instance(
+        :active_record  => Person,
+        :options        => {:foreign_type => "person_type"}
+      )
+      
+      ThinkingSphinx::Association.send(:polymorphic_classes, ref).should == [Person, Friendship]
+    end
+  end
+  
+  describe "casted_options method" do
+    before :each do
+      @options = {
+        :foreign_key  => "thing_id",
+        :foreign_type => "thing_type",
+        :polymorphic  => true
+      }
+      @reflection = ::ActiveRecord::Reflection::AssociationReflection.stub_instance(
+        :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

data/spec/unit/thinking_sphinx/attribute_spec.rb

@@ -0,0 +1,360 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Attribute do
+  describe '#initialize' do
+    it 'raises if no columns are provided so that configuration errors are easier to track down' do
+      lambda {
+        ThinkingSphinx::Attribute.new([])
+      }.should raise_error(RuntimeError)
+    end
+
+    it 'raises if an element of the columns param is an integer - as happens when you use id instead of :id - so that configuration errors are easier to track down' do
+      lambda {
+        ThinkingSphinx::Attribute.new([1234])
+      }.should raise_error(RuntimeError)
+    end
+  end
+  
+  describe "to_select_sql method with MySQL" do
+    before :each do
+      @index = Person.sphinx_indexes.first
+      @index.link!
+    end
+    
+    it "should concat with spaces if there's more than one non-integer column" do
+      @index.attributes[0].to_select_sql.should match(/CONCAT_WS\(' ', /)
+    end
+    
+    it "should concat with spaces if there's more than one association for a non-integer column" do
+      @index.attributes[1].to_select_sql.should match(/CONCAT_WS\(' ', /)
+    end
+    
+    it "should concat with commas if there's multiple integer columns" do
+      @index.attributes[2].to_select_sql.should match(/CONCAT_WS\(',', /)
+    end
+    
+    it "should concat with commas if there's more than one association for an integer column" do
+      @index.attributes[3].to_select_sql.should match(/CONCAT_WS\(',', /)
+    end
+    
+    it "should group with spaces if there's string columns from a has_many or has_and_belongs_to_many association" do
+      @index.attributes[4].to_select_sql.should match(/GROUP_CONCAT\(.+ SEPARATOR ' '\)/)
+    end
+    
+    it "should group with commas if there's integer columns from a has_many or has_and_belongs_to_many association" do
+      @index.attributes[5].to_select_sql.should match(/GROUP_CONCAT\(.+ SEPARATOR ','\)/)
+    end
+    
+    it "should convert datetime values to timestamps" do
+      @index.attributes[6].to_select_sql.should match(/UNIX_TIMESTAMP/)
+    end
+  end
+  
+  describe "to_select_sql method with PostgreSQL" do
+    before :each do
+      @index = Person.sphinx_indexes.first
+      Person.connection.class.stub_method(
+        :name => "ActiveRecord::ConnectionAdapters::PostgreSQLAdapter"
+      )
+      @index.link!
+    end
+    
+    it "should concat with spaces if there's more than one non-integer column" do
+      @index.attributes[0].to_select_sql.should match(/|| ' ' ||/)
+    end
+    
+    it "should concat with spaces if there's more than one association for a non-integer column" do
+      @index.attributes[1].to_select_sql.should match(/|| ' ' ||/)
+    end
+    
+    it "should concat with commas if there's multiple integer columns" do
+      @index.attributes[2].to_select_sql.should match(/|| ',' ||/)
+    end
+    
+    it "should concat with commas if there's more than one association for an integer column" do
+      @index.attributes[3].to_select_sql.should match(/|| ',' ||/)
+    end
+    
+    it "should group with spaces if there's string columns from a has_many or has_and_belongs_to_many association" do
+      @index.attributes[4].to_select_sql.should match(/array_to_string\(array_accum\(.+, ' '\)/)
+    end
+    
+    it "should group with commas if there's integer columns from a has_many or has_and_belongs_to_many association" do
+      @index.attributes[5].to_select_sql.should match(/array_to_string\(array_accum\(.+, ','\)/)
+    end
+  end
+  
+  describe "to_group_sql method" do
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new([Object.stub_instance(:__stack => [])])
+      @attribute.stub_method(:is_many? => false, :is_string? => false)
+      
+      ThinkingSphinx.stub_method(:use_group_by_shortcut? => false)
+    end
+    
+    it "should return nil if is_many?" do
+      @attribute.stub_method(:is_many? => true)
+      
+      @attribute.to_group_sql.should be_nil
+    end
+    
+    it "should return nil if is_string?" do
+      @attribute.stub_method(:is_string? => true)
+      
+      @attribute.to_group_sql.should be_nil
+    end
+    
+    it "should return nil if group_by shortcut is allowed" do
+      ThinkingSphinx.stub_method(:use_group_by_shortcut? => true)
+      
+      @attribute.to_group_sql.should be_nil
+    end
+    
+    it "should return an array if neither is_many? or shortcut allowed" do
+      @attribute.stub_method(:column_with_prefix => 'hello')
+      @attribute.to_group_sql.should be_a_kind_of(Array)
+    end
+    
+    after :each do
+      ThinkingSphinx.unstub_method(:use_group_by_shortcut?)
+    end
+  end
+  
+  describe "to_sphinx_clause method" do
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new [Object.stub_instance(:__stack => [])]
+      @attribute.stub_method(:unique_name => "unique name")
+    end
+    
+    it "should use sql_attr_multi syntax for MVA attributes" do
+      @attribute.stub_method(:type => :multi)
+      @attribute.to_sphinx_clause.should match(/^sql_attr_multi\s+= uint unique name from field$/)
+    end
+    
+    it "should use sql_attr_timestamp syntax for datetime values" do
+      @attribute.stub_method(:type => :datetime)
+      @attribute.to_sphinx_clause.should match(/^sql_attr_timestamp\s+= unique name$/)
+    end
+    
+    it "should use sql_attr_str2ordinal for string values" do
+      @attribute.stub_method(:type => :string)
+      @attribute.to_sphinx_clause.should match(/^sql_attr_str2ordinal\s+= unique name$/)
+    end
+    
+    it "should use sql_attr_float for float values" do
+      @attribute.stub_method(:type => :float)
+      @attribute.to_sphinx_clause.should match(/^sql_attr_float\s+= unique name$/)
+    end
+    
+    it "should use sql_attr_bool for boolean values" do
+      @attribute.stub_method(:type => :boolean)
+      @attribute.to_sphinx_clause.should match(/^sql_attr_bool\s+= unique name$/)
+    end
+    
+    it "should use sql_attr_uint for integer values" do
+      @attribute.stub_method(:type => :integer)
+      @attribute.to_sphinx_clause.should match(/^sql_attr_uint\s+= unique name$/)
+    end
+    
+    it "should assume integer for any other types" do
+      @attribute.stub_method(:type => :unknown)
+      @attribute.to_sphinx_clause.should match(/^sql_attr_uint\s+= unique name$/)
+    end
+    
+  end
+  
+  describe "unique_name method" do
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new [
+        Object.stub_instance(:__stack => [], :__name => "col_name")
+      ]
+    end
+    
+    it "should use the alias if there is one" do
+      @attribute.alias = "alias"
+      @attribute.unique_name.should == "alias"
+    end
+    
+    it "should use the alias if there's multiple columns" do
+      @attribute.columns << Object.stub_instance(:__stack => [], :__name => "col_name")
+      @attribute.unique_name.should be_nil
+      
+      @attribute.alias = "alias"
+      @attribute.unique_name.should == "alias"
+    end
+    
+    it "should use the column name if there's no alias and just one column" do
+      @attribute.unique_name.should == "col_name"
+    end
+  end
+  
+  describe "column_with_prefix method" do
+    before :each do
+      @attribute = ThinkingSphinx::Attribute.new [
+        ThinkingSphinx::Index::FauxColumn.new(:col_name)
+      ]
+      @attribute.columns.each { |col| @attribute.associations[col] = [] }
+      @attribute.model = Person
+      
+      @first_join   = Object.stub_instance(:aliased_table_name => "tabular")
+      @second_join  = Object.stub_instance(:aliased_table_name => "data")
+      
+      @first_assoc  = ThinkingSphinx::Association.stub_instance(
+        :join => @first_join, :has_column? => true
+      )
+      @second_assoc = ThinkingSphinx::Association.stub_instance(
+        :join => @second_join, :has_column? => true
+      )
+    end
+    
+    it "should return the column name if the column is a string" do
+      @attribute.columns = [ThinkingSphinx::Index::FauxColumn.new("string")]
+      @attribute.send(:column_with_prefix, @attribute.columns.first).should == "string"
+    end
+    
+    it "should return the column with model's table prefix if there's no associations for the column" do
+      @attribute.send(:column_with_prefix, @attribute.columns.first).should == "`people`.`col_name`"
+    end
+    
+    it "should return the column with its join table prefix if an association exists" do
+      column = @attribute.columns.first
+      @attribute.associations[column] = [@first_assoc]
+      @attribute.send(:column_with_prefix, column).should == "`tabular`.`col_name`"
+    end
+    
+    it "should return multiple columns concatenated if more than one association exists" do
+      column = @attribute.columns.first
+      @attribute.associations[column] = [@first_assoc, @second_assoc]
+      @attribute.send(:column_with_prefix, column).should == "`tabular`.`col_name`, `data`.`col_name`"
+    end
+  end
+  
+  describe "is_many? method" do
+    before :each do
+      @assoc_a = Object.stub_instance(:is_many? => true)
+      @assoc_b = Object.stub_instance(:is_many? => true)
+      @assoc_c = Object.stub_instance(:is_many? => true)
+      
+      @attribute = ThinkingSphinx::Attribute.new(
+        [ThinkingSphinx::Index::FauxColumn.new(:col_name)]
+      )
+      @attribute.associations = {
+        :a => @assoc_a, :b => @assoc_b, :c => @assoc_c
+      }
+    end
+    
+    it "should return true if all associations return true to is_many?" do
+      @attribute.send(:is_many?).should be_true
+    end
+    
+    it "should return true if one association returns true to is_many?" do
+      @assoc_b.stub_method(:is_many? => false)
+      @assoc_c.stub_method(:is_many? => false)
+      
+      @attribute.send(:is_many?).should be_true
+    end
+    
+    it "should return false if all associations return false to is_many?" do
+      @assoc_a.stub_method(:is_many? => false)
+      @assoc_b.stub_method(:is_many? => false)
+      @assoc_c.stub_method(:is_many? => false)
+      
+      @attribute.send(:is_many?).should be_false
+    end
+  end
+  
+  describe "is_string? method" do
+    before :each do
+      @col_a = ThinkingSphinx::Index::FauxColumn.new("a")
+      @col_b = ThinkingSphinx::Index::FauxColumn.new("b")
+      @col_c = ThinkingSphinx::Index::FauxColumn.new("c")
+
+      @attribute = ThinkingSphinx::Attribute.new(
+        [@col_a, @col_b, @col_c]
+      )
+    end
+    
+    it "should return true if all columns return true to is_string?" do
+      @attribute.send(:is_string?).should be_true
+    end
+    
+    it "should return false if one column returns true to is_string?" do
+      @col_a.send(:instance_variable_set, :@name, :a)
+      @attribute.send(:is_string?).should be_false
+    end
+    
+    it "should return false if all columns return false to is_string?" do
+      @col_a.send(:instance_variable_set, :@name, :a)
+      @col_b.send(:instance_variable_set, :@name, :b)
+      @col_c.send(:instance_variable_set, :@name, :c)
+      @attribute.send(:is_string?).should be_false
+    end
+  end
+  
+  describe "type method" do
+    before :each do
+      @column = ThinkingSphinx::Index::FauxColumn.new(:col_name)
+      @attribute = ThinkingSphinx::Attribute.new([@column])
+      @attribute.model = Person
+      @attribute.stub_method(:is_many? => false)
+    end
+    
+    it "should return :multi if is_many? is true" do
+      @attribute.stub_method(:is_many? => true)
+      @attribute.send(:type).should == :multi
+    end
+    
+    it "should return :string if there's more than one association" do
+      @attribute.associations = {:a => :assoc, :b => :assoc}
+      @attribute.send(:type).should == :string
+    end
+    
+    it "should return the column type from the database if not :multi or more than one association" do
+      @column.send(:instance_variable_set, :@name, "birthday")
+      @attribute.send(:type).should == :datetime
+      
+      @attribute.send(:instance_variable_set, :@type, nil)
+      @column.send(:instance_variable_set, :@name, "first_name")
+      @attribute.send(:type).should == :string
+      
+      @attribute.send(:instance_variable_set, :@type, nil)
+      @column.send(:instance_variable_set, :@name, "id")
+      @attribute.send(:type).should == :integer
+    end
+  end
+  
+  describe "all_ints? method" do
+    it "should return true if all columns are integers" do
+      attribute = ThinkingSphinx::Attribute.new(
+        [ ThinkingSphinx::Index::FauxColumn.new(:id),
+          ThinkingSphinx::Index::FauxColumn.new(:team_id) ]
+      )
+      attribute.model = Person
+      attribute.columns.each { |col| attribute.associations[col] = [] }
+      
+      attribute.send(:all_ints?).should be_true
+    end
+    
+    it "should return false if only some columns are integers" do
+      attribute = ThinkingSphinx::Attribute.new(
+        [ ThinkingSphinx::Index::FauxColumn.new(:id),
+          ThinkingSphinx::Index::FauxColumn.new(:first_name) ]
+      )
+      attribute.model = Person
+      attribute.columns.each { |col| attribute.associations[col] = [] }
+      
+      attribute.send(:all_ints?).should be_false
+    end
+    
+    it "should return false if no columns are integers" do
+      attribute = ThinkingSphinx::Attribute.new(
+        [ ThinkingSphinx::Index::FauxColumn.new(:first_name),
+          ThinkingSphinx::Index::FauxColumn.new(:last_name) ]
+      )
+      attribute.model = Person
+      attribute.columns.each { |col| attribute.associations[col] = [] }
+      
+      attribute.send(:all_ints?).should be_false
+    end
+  end
+end