friendlyfashion-thinking-sphinx 2.0.13

data/spec/thinking_sphinx/facet_spec.rb

@@ -0,0 +1,359 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::Facet do
+  describe ".name_for" do
+    it "should remove '_facet' from provided string and return a symbol" do
+      ThinkingSphinx::Facet.name_for('attribute_facet').should == :attribute
+    end
+
+    it "should remove '_facet' from provided symbol" do
+      ThinkingSphinx::Facet.name_for(:attribute_facet).should == :attribute
+    end
+
+    it "should return the name of the facet if a Facet is passed" do
+      facet = ThinkingSphinx::Facet.new(
+        stub('attribute', :unique_name => :attribute, :columns => ['attribute'])
+      )
+      ThinkingSphinx::Facet.name_for(facet).should == :attribute
+    end
+
+    it "should return 'class' for special case name 'class_crc'" do
+      ThinkingSphinx::Facet.name_for(:class_crc).should == :class
+    end
+
+    it "should cycle" do
+      ThinkingSphinx::Facet.name_for(ThinkingSphinx::Facet.attribute_name_for(:attribute)).should == :attribute
+    end
+  end
+
+  describe ".attribute_name_for" do
+    it "should append '_facet' to provided string" do
+      ThinkingSphinx::Facet.attribute_name_for('attribute').should == 'attribute_facet'
+    end
+
+    it "should append '_facet' to provided symbol and return a string" do
+      ThinkingSphinx::Facet.attribute_name_for(:attribute).should == 'attribute_facet'
+    end
+
+    it "should return 'class_crc' for special case attribute 'class'" do
+      ThinkingSphinx::Facet.attribute_name_for(:class).should == 'class_crc'
+    end
+
+    it "should cycle" do
+      ThinkingSphinx::Facet.attribute_name_for(ThinkingSphinx::Facet.name_for('attribute_facet')).should == 'attribute_facet'
+    end
+  end
+  
+  describe ".attribute_name_from_value" do
+    it "should append _facet if the value is a string" do
+      ThinkingSphinx::Facet.attribute_name_from_value('attribute', 'string').
+        should == 'attribute_facet'
+    end
+    
+    it "should not append _facet if the value isn't a string" do
+      ThinkingSphinx::Facet.attribute_name_from_value('attribute', 1).
+        should == 'attribute'
+      ThinkingSphinx::Facet.attribute_name_from_value('attribute', Time.now).
+        should == 'attribute'
+      ThinkingSphinx::Facet.attribute_name_from_value('attribute', true).
+        should == 'attribute'
+      ThinkingSphinx::Facet.attribute_name_from_value('attribute', 1.23).
+        should == 'attribute'
+    end
+    
+    it "should append _facet is the value is an array of strings" do
+      ThinkingSphinx::Facet.attribute_name_from_value('attribute', ['a', 'b']).
+        should == 'attribute_facet'
+    end
+    
+    it "should not append _facet if the value is an array of integers" do
+      ThinkingSphinx::Facet.attribute_name_from_value('attribute', [1, 2]).
+        should == 'attribute'
+    end
+  end
+  
+  describe ".translate?" do
+    before :each do
+      @index     = ThinkingSphinx::Index.new(Alpha)
+      @source    = ThinkingSphinx::Source.new(@index)
+      @attribute = ThinkingSphinx::Attribute.new(
+        @source, ThinkingSphinx::Index::FauxColumn.new(:name)
+      )
+    end
+    
+    it "should return true if the property is a field" do
+      field = ThinkingSphinx::Field.new(
+        @source, ThinkingSphinx::Index::FauxColumn.new(:name)
+      )
+      
+      ThinkingSphinx::Facet.translate?(field).should be_true
+    end
+    
+    it "should return true if the property is a string attribute" do
+      @attribute.stub!(:type => :string)
+      
+      ThinkingSphinx::Facet.translate?(@attribute).should be_true
+    end
+    
+    it "should return false if the property is an integer attribute" do
+      @attribute.stub!(:type => :integer)
+      
+      ThinkingSphinx::Facet.translate?(@attribute).should be_false
+    end
+    
+    it "should return false if the property is a boolean attribute" do
+      @attribute.stub!(:type => :boolean)
+      
+      ThinkingSphinx::Facet.translate?(@attribute).should be_false
+    end
+    
+    it "should return false if the property is a timestamp attribute" do
+      @attribute.stub!(:type => :datetime)
+      
+      ThinkingSphinx::Facet.translate?(@attribute).should be_false
+    end
+    
+    it "should return false if the property is a float attribute" do
+      @attribute.stub!(:type => :float)
+      
+      ThinkingSphinx::Facet.translate?(@attribute).should be_false
+    end
+    
+    it "should return false if the property is an MVA of integer values" do
+      @attribute.stub!(:type => :multi, :all_ints? => true)
+      
+      ThinkingSphinx::Facet.translate?(@attribute).should be_false
+    end
+    
+    it "should return true if the property is an MVA of string values" do
+      @attribute.stub!(:type => :multi, :all_ints? => false)
+      
+      ThinkingSphinx::Facet.translate?(@attribute).should be_true
+    end
+  end
+  
+  describe "#translate?" do
+    before :each do
+      @index     = ThinkingSphinx::Index.new(Alpha)
+      @source    = ThinkingSphinx::Source.new(@index)
+      @attribute = ThinkingSphinx::Attribute.new(
+        @source, ThinkingSphinx::Index::FauxColumn.new(:name)
+      )
+    end
+    
+    it "should return true if the property is a field" do
+      field = ThinkingSphinx::Field.new(
+        @source, ThinkingSphinx::Index::FauxColumn.new(:name)
+      )
+      
+      ThinkingSphinx::Facet.new(field).translate?.should be_true
+    end
+    
+    it "should return true if the property is a string attribute" do
+      @attribute.stub!(:type => :string)
+      
+      ThinkingSphinx::Facet.new(@attribute).translate?.should be_true
+    end
+    
+    it "should return false if the property is an integer attribute" do
+      @attribute.stub!(:type => :integer)
+      
+      ThinkingSphinx::Facet.new(@attribute).translate?.should be_false
+    end
+    
+    it "should return false if the property is a boolean attribute" do
+      @attribute.stub!(:type => :boolean)
+      
+      ThinkingSphinx::Facet.new(@attribute).translate?.should be_false
+    end
+    
+    it "should return false if the property is a timestamp attribute" do
+      @attribute.stub!(:type => :datetime)
+      
+      ThinkingSphinx::Facet.new(@attribute).translate?.should be_false
+    end
+    
+    it "should return false if the property is a float attribute" do
+      @attribute.stub!(:type => :float)
+      
+      ThinkingSphinx::Facet.new(@attribute).translate?.should be_false
+    end
+    
+    it "should return false if the property is an MVA of integer values" do
+      @attribute.stub!(:type => :multi, :all_ints? => true)
+      
+      ThinkingSphinx::Facet.new(@attribute).translate?.should be_false
+    end
+    
+    it "should return true if the property is an MVA of string values" do
+      @attribute.stub!(:type => :multi, :all_ints? => false)
+      
+      ThinkingSphinx::Facet.new(@attribute).translate?.should be_true
+    end
+  end
+  
+  describe "#attribute_name" do
+    before :each do
+      @index     = ThinkingSphinx::Index.new(Alpha)
+      @source    = ThinkingSphinx::Source.new(@index)
+      @attribute = ThinkingSphinx::Attribute.new(
+        @source, ThinkingSphinx::Index::FauxColumn.new(:name)
+      )
+    end
+    
+    it "should return the attribute name if built off an integer attribute" do
+      @attribute.stub!(:type => :integer)
+      
+      ThinkingSphinx::Facet.new(@attribute).attribute_name.should == "name"
+    end
+    
+    it "should return the attribute name if built off a boolean attribute" do
+      @attribute.stub!(:type => :boolean)
+      
+      ThinkingSphinx::Facet.new(@attribute).attribute_name.should == "name"
+    end
+    
+    it "should return the attribute name if built off a float attribute" do
+      @attribute.stub!(:type => :float)
+      
+      ThinkingSphinx::Facet.new(@attribute).attribute_name.should == "name"
+    end
+    
+    it "should return the attribute name if built off a timestamp attribute" do
+      @attribute.stub!(:type => :datetime)
+      
+      ThinkingSphinx::Facet.new(@attribute).attribute_name.should == "name"
+    end
+    
+    it "should return the attribute name with _facet suffix if built off a string attribute" do
+      @attribute.stub!(:type => :string)
+      
+      ThinkingSphinx::Facet.new(@attribute).attribute_name.should == "name_facet"
+    end
+    
+    it "should return the attribute name with _facet suffix if built off a field" do
+      field = ThinkingSphinx::Field.new(
+        @source, ThinkingSphinx::Index::FauxColumn.new(:name)
+      )
+      
+      ThinkingSphinx::Facet.new(field).attribute_name.should == "name_facet"
+    end
+    
+    it "should return the attribute name if build off an integer MVA" do
+      @attribute.stub!(:type => :multi, :all_ints? => true)
+      
+      ThinkingSphinx::Facet.new(@attribute).attribute_name.should == "name"
+    end
+    
+    it "should return the attribute name with the _facet suffix if build off an non-integer MVA" do
+      @attribute.stub!(:type => :multi, :all_ints? => false)
+      
+      ThinkingSphinx::Facet.new(@attribute).attribute_name.should == "name_facet"
+    end
+  end
+  
+  describe "#type" do
+    before :each do
+      @index     = ThinkingSphinx::Index.new(Alpha)
+      @source    = ThinkingSphinx::Source.new(@index)
+    end
+    
+    it "should return :string if the property is a field" do
+      field = ThinkingSphinx::Field.new(
+        @source, ThinkingSphinx::Index::FauxColumn.new(:name)
+      )
+      
+      ThinkingSphinx::Facet.new(field).type.should == :string
+    end
+    
+    it "should return the attribute type if the property is an attribute" do
+      attribute = ThinkingSphinx::Attribute.new(
+        @source, ThinkingSphinx::Index::FauxColumn.new(:name)
+      )
+      attribute.stub!(:type => :anything)
+      
+      ThinkingSphinx::Facet.new(attribute).type.should == :anything
+    end
+  end
+  
+  describe "#value" do
+    describe 'for fields from associations' do
+      before :each do
+        @index  = ThinkingSphinx::Index.new(Friendship)
+        @source = ThinkingSphinx::Source.new(@index)
+        @field  = ThinkingSphinx::Field.new(
+          @source, ThinkingSphinx::Index::FauxColumn.new(:person, :first_name)
+        )
+        @facet  = ThinkingSphinx::Facet.new(@field)
+      end
+    
+      it "should return association values" do
+        person      = Person.find(:first)
+        friendship  = Friendship.new(:person => person)
+      
+        @facet.value(friendship, {'first_name_facet' => 1}).should == person.first_name
+      end
+    
+      it "should return nil if the association is nil" do
+        friendship = Friendship.new(:person => nil)
+      
+        @facet.value(friendship, {'first_name_facet' => 1}).should be_nil
+      end
+      
+      it "should return multi-level association values" do
+        person      = Person.find(:first)
+        tag         = person.tags.build(:name => 'buried')
+        friendship  = Friendship.new(:person => person)
+        
+        field  = ThinkingSphinx::Field.new(
+          @source, ThinkingSphinx::Index::FauxColumn.new(:person, :tags, :name)
+        )
+        ThinkingSphinx::Facet.new(field).value(friendship, {'name_facet' => 'buried'.to_crc32}).
+          should == 'buried'
+      end
+      
+      it "should not error with multi-level association values containing a nil value" do
+        person      = Person.find(:first)
+        tag         = person.tags.build(:name => nil)
+        tag         = person.tags.build(:name => "buried")
+        friendship  = Friendship.new(:person => person)
+        
+        field  = ThinkingSphinx::Field.new(
+          @source, ThinkingSphinx::Index::FauxColumn.new(:person, :tags, :name)
+        )
+        lambda{ThinkingSphinx::Facet.new(field).value(friendship, {'name_facet' => 'buried'.to_crc32})}.should_not raise_error
+      end
+    end
+    
+    describe 'for float attributes' do
+      before :each do
+        @index     = ThinkingSphinx::Index.new(Alpha)
+        @source    = ThinkingSphinx::Source.new(@index)
+        @attribute = ThinkingSphinx::Attribute.new(
+          @source, ThinkingSphinx::Index::FauxColumn.new(:cost)
+        )
+        @facet     = ThinkingSphinx::Facet.new(@attribute)
+      end
+      
+      it "should translate using the given model" do
+        alpha = Alpha.new(:cost => 10.5)
+      
+        @facet.value(alpha, {'cost' => 1093140480}).should == 10.5
+      end
+    end
+    
+    context 'manual value source' do
+      let(:index)  { ThinkingSphinx::Index.new(Alpha) }
+      let(:source) { ThinkingSphinx::Source.new(index) }
+      let(:column) { ThinkingSphinx::Index::FauxColumn.new('LOWER(name)') }
+      let(:field)  { ThinkingSphinx::Field.new(source, column) }
+      let(:facet)  { ThinkingSphinx::Facet.new(field, :name) }
+      
+      it "should use the given value source to figure out the value" do
+        alpha = Alpha.new(:name => 'Foo')
+        
+        facet.value(alpha, {'foo_facet' => 'foo'.to_crc32}).should == 'Foo'
+      end
+    end
+  end
+end

data/spec/thinking_sphinx/field_spec.rb

@@ -0,0 +1,127 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::Field do
+  before :each do
+    @index     = ThinkingSphinx::Index.new(Alpha)
+    @source    = ThinkingSphinx::Source.new(@index)
+  end
+  
+  describe '#initialize' do
+    it 'raises if no columns are provided so that configuration errors are easier to track down' do
+      lambda {
+        ThinkingSphinx::Field.new(@source, [])
+      }.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::Field.new(@source, [1234])
+      }.should raise_error(RuntimeError)
+    end
+  end
+  
+  describe "unique_name method" do
+    before :each do
+      @field = ThinkingSphinx::Field.new @source, [
+        stub('column', :__stack => [], :__name => "col_name")
+      ]
+    end
+    
+    it "should use the alias if there is one" do
+      @field.alias = "alias"
+      @field.unique_name.should == "alias"
+    end
+    
+    it "should use the alias if there's multiple columns" do
+      @field.columns << stub('column', :__stack => [], :__name => "col_name")
+      @field.unique_name.should be_nil
+      
+      @field.alias = "alias"
+      @field.unique_name.should == "alias"
+    end
+    
+    it "should use the column name if there's no alias and just one column" do
+      @field.unique_name.should == "col_name"
+    end
+  end
+  
+  describe '#to_select_sql' do
+    it "should return nil if polymorphic association data does not exist" do
+      field = ThinkingSphinx::Field.new(@source,
+        [ThinkingSphinx::Index::FauxColumn.new(:source, :name)],
+        :as => :source_name
+      )
+      
+      field.to_select_sql.should be_nil
+    end
+  end
+
+  describe "prefixes method" do
+    it "should default to false" do
+      @field = ThinkingSphinx::Field.new(
+        @source, [stub('column', :__stack => [])]
+      )
+      @field.prefixes.should be_false
+    end
+    
+    it "should be true if the corresponding option is set" do
+      @field = ThinkingSphinx::Field.new(
+        @source, [stub('column', :__stack => [])], :prefixes => true
+      )
+      @field.prefixes.should be_true
+    end
+  end
+  
+  describe "infixes method" do
+    it "should default to false" do
+      @field = ThinkingSphinx::Field.new(
+        @source, [stub('column', :__stack => [])]
+      )
+      @field.infixes.should be_false
+    end
+    
+    it "should be true if the corresponding option is set" do
+      @field = ThinkingSphinx::Field.new(
+        @source, [stub('column', :__stack => [])], :infixes => true
+      )
+      @field.infixes.should be_true
+    end
+  end
+  
+  describe "is_many? method" do
+    before :each do
+      @assoc_a = ThinkingSphinx::Association.new(nil, nil)
+      @assoc_b = ThinkingSphinx::Association.new(nil, nil)
+      @assoc_c = ThinkingSphinx::Association.new(nil, nil)
+      
+      @field = ThinkingSphinx::Field.new(
+        @source, [ThinkingSphinx::Index::FauxColumn.new(:col_name)]
+      )
+      @field.associations = {
+        :a => @assoc_a, :b => @assoc_b, :c => @assoc_c
+      }
+      @field.associations.values.each { |assoc|
+        assoc.stub!(:is_many? => true)
+      }
+    end
+    
+    it "should return true if all associations return true to is_many?" do
+      @field.send(:is_many?).should be_true
+    end
+    
+    it "should return true if one association returns true to is_many?" do
+      @assoc_b.stub!(:is_many? => false)
+      @assoc_c.stub!(:is_many? => false)
+      
+      @field.send(:is_many?).should be_true
+    end
+    
+    it "should return false if all associations return false to is_many?" do
+      @assoc_a.stub!(:is_many? => false)
+      @assoc_b.stub!(:is_many? => false)
+      @assoc_c.stub!(:is_many? => false)
+      
+      @field.send(:is_many?).should be_false
+    end
+  end
+end