DrMark-thinking-sphinx 1.1.15 → 1.2.5

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

@@ -4,32 +4,32 @@ describe ThinkingSphinx::Configuration do
   describe "environment class method" do
     before :each do
       ThinkingSphinx::Configuration.send(:class_variable_set, :@@environment, nil)
-      
+
       ENV["RAILS_ENV"] = nil
     end
-    
+
     it "should use the Merb environment value if set" do
       unless defined?(Merb)
-        module Merb; end
+        module ::Merb; end
       end
-            
+
       ThinkingSphinx::Configuration.stub_method(:defined? => true)
-      Merb.stub_method(:environment => "merb_production")
+      Merb.stub!(:environment => "merb_production")
       ThinkingSphinx::Configuration.environment.should == "merb_production"
-      
+
       Object.send(:remove_const, :Merb)
     end
-    
+
     it "should use the Rails environment value if set" do
       ENV["RAILS_ENV"] = "rails_production"
       ThinkingSphinx::Configuration.environment.should == "rails_production"
     end
-    
+
     it "should default to development" do
       ThinkingSphinx::Configuration.environment.should == "development"
     end
   end
-  
+
   describe "parse_config method" do
     before :each do
       @settings = {
@@ -48,89 +48,221 @@ describe ThinkingSphinx::Configuration do
           "morphology"        => "stem_ru",
           "charset_type"      => "latin1",
           "charset_table"     => "table",
-          "ignore_chars"      => "e"
+          "ignore_chars"      => "e",
+          "searchd_binary_name" => "sphinx-searchd",
+          "indexer_binary_name" => "sphinx-indexer"
         }
       }
-      
+
       open("#{RAILS_ROOT}/config/sphinx.yml", "w") do |f|
         f.write  YAML.dump(@settings)
       end
     end
-    
+
     it "should use the accessors to set the configuration values" do
       config = ThinkingSphinx::Configuration.instance
       config.send(:parse_config)
-      
+
       %w(config_file searchd_log_file query_log_file pid_file searchd_file_path
-        address port).each do |key|
+        address port searchd_binary_name indexer_binary_name).each do |key|
         config.send(key).should == @settings["development"][key]
       end
     end
-    
+
     after :each do
       FileUtils.rm "#{RAILS_ROOT}/config/sphinx.yml"
     end
   end
-    
+
+  describe "block configuration" do
+    it "should let the user set-up a custom app_root" do
+      ThinkingSphinx::Configuration.configure do |config|
+        config.app_root = "/here/somewhere"
+      end
+      ThinkingSphinx::Configuration.instance.app_root.should == "/here/somewhere"
+    end
+  end
+
   describe "initialisation" do
     it "should have a default bin_path of nothing" do
       ThinkingSphinx::Configuration.instance.bin_path.should == ""
     end
-    
+
     it "should append a / to bin_path if one is supplied" do
       @settings = {
         "development" => {
           "bin_path" => "path/to/somewhere"
         }
       }
-      
+
       open("#{RAILS_ROOT}/config/sphinx.yml", "w") do |f|
         f.write  YAML.dump(@settings)
       end
-      
+
       ThinkingSphinx::Configuration.instance.send(:parse_config)
       ThinkingSphinx::Configuration.instance.bin_path.should match(/\/$/)
+
+      FileUtils.rm "#{RAILS_ROOT}/config/sphinx.yml"
     end
   end
-  
+
+  describe "index options" do
+    before :each do
+      @settings = {
+        "development" => {"disable_range" => true}
+      }
+
+      open("#{RAILS_ROOT}/config/sphinx.yml", "w") do |f|
+        f.write  YAML.dump(@settings)
+      end
+
+      @config = ThinkingSphinx::Configuration.instance
+      @config.send(:parse_config)
+    end
+
+    it "should collect disable_range" do
+      @config.index_options[:disable_range].should be_true
+    end
+
+    after :each do
+      FileUtils.rm "#{RAILS_ROOT}/config/sphinx.yml"
+    end
+  end
+
+  describe "#load_models" do
+    before :each do
+      @config = ThinkingSphinx::Configuration.instance
+      @config.model_directories = ['']
+
+      @file_name        = 'a.rb'
+      @model_name_lower = 'a'
+      @class_name       = 'A'
+
+      @file_name.stub!(:gsub).and_return(@model_name_lower)
+      @model_name_lower.stub!(:camelize).and_return(@class_name)
+      Dir.stub(:[]).and_return([@file_name])
+    end
+
+    it "should load the files by guessing the file name" do
+      @class_name.should_receive(:constantize).and_return(true)
+
+      @config.load_models
+    end
+
+    it "should not raise errors if the model name is nil" do
+      @file_name.stub!(:gsub).and_return(nil)
+
+      lambda {
+        @config.load_models
+      }.should_not raise_error
+    end
+
+    it "should not raise errors if the file name does not represent a class name" do
+      @class_name.should_receive(:constantize).and_raise(NameError)
+
+      lambda {
+        @config.load_models
+      }.should_not raise_error
+    end
+
+    it "should retry if the first pass fails and contains a directory" do
+      @model_name_lower.stub!(:gsub!).and_return(true, nil)
+      @class_name.stub(:constantize).and_raise(LoadError)
+      @model_name_lower.should_receive(:camelize).twice
+
+      lambda {
+        @config.load_models
+      }.should_not raise_error
+    end
+
+    it "should catch database errors with a warning" do
+      @class_name.should_receive(:constantize).and_raise(Mysql::Error)
+      @config.should_receive(:puts).with('Warning: Error loading a.rb')
+
+      lambda {
+        @config.load_models
+      }.should_not raise_error
+    end
+  end
+
   it "should insert set index options into the configuration file" do
     config = ThinkingSphinx::Configuration.instance
     ThinkingSphinx::Configuration::IndexOptions.each do |option|
       config.index_options[option.to_sym] = "something"
       config.build
-      
+
       file = open(config.config_file) { |f| f.read }
       file.should match(/#{option}\s+= something/)
-      
+
       config.index_options[option.to_sym] = nil
     end
   end
-  
+
   it "should insert set source options into the configuration file" do
     config = ThinkingSphinx::Configuration.instance
     ThinkingSphinx::Configuration::SourceOptions.each do |option|
       config.source_options[option.to_sym] = "something"
       config.build
-      
+
       file = open(config.config_file) { |f| f.read }
       file.should match(/#{option}\s+= something/)
-      
+
       config.source_options[option.to_sym] = nil
     end
   end
-  
+
   it "should set any explicit prefixed or infixed fields" do
     file = open(ThinkingSphinx::Configuration.instance.config_file) { |f|
       f.read
     }
     file.should match(/prefix_fields\s+= city/)
-    file.should match(/infix_fields\s+= state/)    
+    file.should match(/infix_fields\s+= state/)
   end
-  
+
   it "should not have prefix fields in indexes where nothing is set" do
     file = open(ThinkingSphinx::Configuration.instance.config_file) { |f|
       f.read
     }
     file.should_not match(/index alpha_core\s+\{\s+[^\}]*prefix_fields\s+=[^\}]*\}/m)
   end
-end
+  
+  describe '#client' do
+    before :each do
+      @config = ThinkingSphinx::Configuration.instance
+      @config.address     = 'domain.url'
+      @config.port        = 3333
+      @config.configuration.searchd.max_matches = 100
+    end
+    
+    it "should return an instance of Riddle::Client" do
+      @config.client.should be_a(Riddle::Client)
+    end
+    
+    it "should use the configuration address" do
+      @config.client.server.should == 'domain.url'
+    end
+    
+    it "should use the configuration port" do
+      @config.client.port.should == 3333
+    end
+    
+    it "should use the configuration max matches" do
+      @config.client.max_matches.should == 100
+    end
+  end
+  
+  describe '#models_by_crc' do
+    before :each do
+      @config = ThinkingSphinx::Configuration.instance
+    end
+    
+    it "should return a hash" do
+      @config.models_by_crc.should be_a(Hash)
+    end
+    
+    it "should pair class names to their crc codes" do
+      @config.models_by_crc[Person.to_crc32].should == 'Person'
+      @config.models_by_crc[Alpha.to_crc32].should  == 'Alpha'
+    end
+  end
+end

data/spec/lib/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/lib/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/{unit → lib}/thinking_sphinx/facet_spec.rb

@@ -275,4 +275,28 @@ describe ThinkingSphinx::Facet do
       ThinkingSphinx::Facet.new(attribute).type.should == :anything
     end
   end
+  
+  describe "#value" 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
+  end
 end

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

@@ -85,15 +85,15 @@ describe ThinkingSphinx::Field do
       @field.columns.each { |col| @field.associations[col] = [] }
       @field.model = Person
       
-      @first_join   = Object.stub_instance(:aliased_table_name => "tabular")
-      @second_join  = Object.stub_instance(:aliased_table_name => "data")
+      @first_join   = Object.new
+      @first_join.stub!(:aliased_table_name => "tabular")
+      @second_join  = Object.new
+      @second_join.stub!(: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
-      )
+      @first_assoc  = ThinkingSphinx::Association.new nil, nil
+      @first_assoc.stub!(:join => @first_join, :has_column? => true)
+      @second_assoc = ThinkingSphinx::Association.new nil, nil
+      @second_assoc.stub!(:join => @second_join, :has_column? => true)
     end
     
     it "should return the column name if the column is a string" do

data/spec/{unit → lib}/thinking_sphinx/index/builder_spec.rb

@@ -318,13 +318,17 @@ describe ThinkingSphinx::Index::Builder do
         indexes first_name
         
         set_property :charset_type => "utf16"
+        set_property :group_concat_max_len => 1024
       end
     end
     
-    it "should store the setting for the index" do
-      @index.local_options.length.should == 1
+    it "should store the index setting for the index" do
       @index.local_options[:charset_type].should == "utf16"
     end
+    
+    it "should store non-Sphinx settings for the index" do
+      @index.local_options[:group_concat_max_len].should == 1024
+    end
   end
   
   describe "delta options" do

data/spec/lib/thinking_sphinx/index_spec.rb

@@ -0,0 +1,45 @@
+require 'spec/spec_helper'
+
+describe ThinkingSphinx::Index do
+  describe "prefix_fields method" do
+    before :each do
+      @index = ThinkingSphinx::Index.new(Person)
+      
+      @field_a = ThinkingSphinx::Field.stub_instance(:prefixes => true)
+      @field_b = ThinkingSphinx::Field.stub_instance(:prefixes => false)
+      @field_c = ThinkingSphinx::Field.stub_instance(:prefixes => true)
+      
+      @index.stub_method(:fields => [@field_a, @field_b, @field_c])
+    end
+    
+    it "should return fields that are flagged as prefixed" do
+      @index.prefix_fields.should include(@field_a)
+      @index.prefix_fields.should include(@field_c)
+    end
+    
+    it "should not return fields that aren't flagged as prefixed" do
+      @index.prefix_fields.should_not include(@field_b)
+    end
+  end
+  
+  describe "infix_fields method" do
+    before :each do
+      @index = ThinkingSphinx::Index.new(Person)
+      
+      @field_a = ThinkingSphinx::Field.stub_instance(:infixes => true)
+      @field_b = ThinkingSphinx::Field.stub_instance(:infixes => false)
+      @field_c = ThinkingSphinx::Field.stub_instance(:infixes => true)
+      
+      @index.stub_method(:fields => [@field_a, @field_b, @field_c])
+    end
+    
+    it "should return fields that are flagged as infixed" do
+      @index.infix_fields.should include(@field_a)
+      @index.infix_fields.should include(@field_c)
+    end
+    
+    it "should not return fields that aren't flagged as infixed" do
+      @index.infix_fields.should_not include(@field_b)
+    end
+  end
+end