joshcutler-thinking-sphinx 1.3.18

data/spec/thinking_sphinx/core/string_spec.rb

@@ -0,0 +1,9 @@
+require 'spec/spec_helper'
+
+describe String do  
+  describe "to_crc32 instance method" do
+    it "should return an integer" do
+      'to_crc32'.to_crc32.should be_a_kind_of(Integer)
+    end
+  end
+end    

data/spec/thinking_sphinx/excerpter_spec.rb

@@ -0,0 +1,49 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Excerpter do
+  before :each do
+    @alpha      = Alpha.find(:first)
+    @search     = mock 'search', :excerpt_for => 'excerpted value'
+    @excerpter  = ThinkingSphinx::Excerpter.new(@search, @alpha)
+  end
+  
+  it "should not respond to id" do
+    @excerpter.should_not respond_to(:id)
+  end
+  
+  describe '#method_missing' do
+    it "should return the excerpt from Sphinx" do
+      @excerpter.name.should == 'excerpted value'
+    end
+    
+    it "should send through the instance class to excerpt_for" do
+      @search.should_receive(:excerpt_for) do |string, model|
+        model.should == Alpha
+      end
+      
+      @excerpter.name
+    end
+    
+    it "should use attribute methods for excerpts calls" do
+      @search.should_receive(:excerpt_for) do |string, model|
+        string.should == 'one'
+      end
+      
+      @excerpter.name
+    end
+    
+    it "should use instance methods for excerpts calls" do
+      @search.should_receive(:excerpt_for) do |string, model|
+        string.should == 'ONE'
+      end
+      
+      @excerpter.big_name
+    end
+    
+    it "should still raise an exception if no column or method exists" do
+      lambda {
+        @excerpter.foo
+      }.should raise_error(NoMethodError)
+    end
+  end
+end

data/spec/thinking_sphinx/facet_search_spec.rb

@@ -0,0 +1,176 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::FacetSearch do
+  describe 'populate' do
+    it "should make separate Sphinx queries for each facet" do
+      ThinkingSphinx.should_receive(:search).with(
+        hash_including(:group_by => 'city_facet')
+      ).and_return([])
+      ThinkingSphinx.should_receive(:search).with(
+        hash_including(:group_by => 'state_facet')
+      ).and_return([])
+      ThinkingSphinx.should_receive(:search).with(
+        hash_including(:group_by => 'birthday')
+      ).and_return([])
+      
+      ThinkingSphinx::FacetSearch.new(:classes => [Person])
+    end
+    
+    it "should request all shared facets in a multi-model request by default" do
+      ThinkingSphinx.stub!(:search => [])
+      ThinkingSphinx::FacetSearch.new.facet_names.should == ['class_crc']
+    end
+    
+    it "should request all facets in a multi-model request if specified" do
+      ThinkingSphinx.stub!(:search => [])
+      ThinkingSphinx::FacetSearch.new(
+        :all_facets => true
+      ).facet_names.should == [
+        'class_crc', 'city_facet', 'state_facet', 'birthday'
+      ]
+    end
+    
+    describe ':facets option' do
+      it "should limit facets to the requested set" do
+        ThinkingSphinx.should_receive(:search).once.and_return([])
+        
+        ThinkingSphinx::FacetSearch.new(
+          :classes => [Person], :facets => :state
+        )
+      end
+    end
+    
+    describe "empty result set for attributes" do
+      before :each do
+        ThinkingSphinx.stub!(:search => [])
+        @facets = ThinkingSphinx::FacetSearch.new(
+          :classes => [Person], :facets => :state
+        )
+      end
+      
+      it "should add key as attribute" do
+        @facets.should have_key(:state)
+      end
+
+      it "should return an empty hash for the facet results" do
+        @facets[:state].should be_empty
+      end
+    end
+
+    describe "non-empty result set" do
+      before :each do
+        @person = Person.find(:first)
+        @people = [@person]
+        @people.stub!(:each_with_groupby_and_count).
+          and_yield(@person, @person.city.to_crc32, 1)
+        ThinkingSphinx.stub!(:search => @people)
+        
+        @facets = ThinkingSphinx::FacetSearch.new(
+          :classes => [Person], :facets => :city
+        )
+      end
+
+      it "should return a hash" do
+        @facets.should be_a_kind_of(Hash)
+      end
+
+      it "should add key as attribute" do
+        @facets.keys.should include(:city)
+      end
+
+      it "should return a hash" do
+        @facets[:city].should == {@person.city => 1}
+      end
+    end
+    
+    before :each do
+      @config = ThinkingSphinx::Configuration.instance
+      @config.configuration.searchd.max_matches = 10_000
+    end
+    
+    it "should use the system-set max_matches for limit on facet calls" do
+      ThinkingSphinx.should_receive(:search) do |options|
+        options[:max_matches].should  == 10_000
+        options[:limit].should        == 10_000
+        []
+      end
+      
+      ThinkingSphinx::FacetSearch.new
+    end
+    
+    it "should use the default max-matches if there is no explicit setting" do
+      @config.configuration.searchd.max_matches = nil
+      ThinkingSphinx.should_receive(:search) do |options|
+        options[:max_matches].should  == 1000
+        options[:limit].should        == 1000
+        []
+      end
+      
+      ThinkingSphinx::FacetSearch.new
+    end
+    
+    it "should ignore user-provided max_matches and limit on facet calls" do
+      ThinkingSphinx.should_receive(:search) do |options|
+        options[:max_matches].should  == 10_000
+        options[:limit].should        == 10_000
+        []
+      end
+      
+      ThinkingSphinx::FacetSearch.new(
+        :max_matches    => 500,
+        :limit          => 200
+      )
+    end
+    
+    it "should not use an explicit :page" do
+      ThinkingSphinx.should_receive(:search) do |options|
+        options[:page].should == 1
+        []
+      end
+      
+      ThinkingSphinx::FacetSearch.new(:page => 3)
+    end
+    
+    describe "conflicting facets" do
+      before :each do
+        @index = ThinkingSphinx::Index::Builder.generate(Alpha) do
+          indexes :name
+          has :value, :as => :city, :facet => true
+        end
+      end
+      
+      after :each do
+        Alpha.sphinx_facets.delete_at(-1)
+      end
+      
+      it "should raise an error if searching with facets of same name but different type" do
+        lambda {
+          facets = ThinkingSphinx.facets :all_facets => true
+        }.should raise_error
+      end
+    end
+  end
+  
+  describe "#for" do
+    before do
+      @person = Person.find(:first)
+      @people = [@person]
+      @people.stub!(:each_with_groupby_and_count).
+        and_yield(@person, @person.city.to_crc32, 1)
+      ThinkingSphinx.stub!(:search => @people)
+      
+      @facets = ThinkingSphinx::FacetSearch.new(
+        :classes => [Person], :facets => :city
+      )
+    end
+
+    it "should return the search results for the attribute and key pair" do
+      ThinkingSphinx.should_receive(:search) do |options|
+        options[:with].should have_key('city_facet')
+        options[:with]['city_facet'].should == @person.city.to_crc32
+      end
+      
+      @facets.for(:city => @person.city)
+    end
+  end
+end

data/spec/thinking_sphinx/facet_spec.rb

@@ -0,0 +1,333 @@
+require 'spec/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, 1).should == person.first_name
+      end
+    
+      it "should return nil if the association is nil" do
+        friendship = Friendship.new(:person => nil)
+      
+        @facet.value(friendship, 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, 'buried'.to_crc32).
+          should == 'buried'
+      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, 1093140480).should == 10.5
+      end
+    end
+  end
+end