friendlyfashion-thinking-sphinx 2.0.13

data/spec/thinking_sphinx/configuration_spec.rb

@@ -0,0 +1,326 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::Configuration do
+  describe "environment class method" do
+    before :each do
+      ThinkingSphinx::Configuration.reset_environment
+
+      ENV["RAILS_ENV"] = nil
+    end
+
+    it "should use Rails.env if set" do
+      was = Rails.env
+      Rails.env = 'global_rails'
+
+      ThinkingSphinx::Configuration.environment.should == 'global_rails'
+
+      Rails.env = was
+    end
+
+    it "should use the Rails environment value if set" do
+      Rails.stub!(:env => "rails_production")
+      ThinkingSphinx::Configuration.environment.should == "rails_production"
+    end
+
+    it "should default to development" do
+      ThinkingSphinx::Configuration.environment.should == "development"
+    end
+  end
+
+  describe '#version' do
+    before :each do
+      @config = ThinkingSphinx::Configuration.instance
+      @config.reset
+    end
+
+    it "should use the given version from sphinx.yml if there is one" do
+      open("#{Rails.root}/config/sphinx.yml", "w") do |f|
+        f.write  YAML.dump({'development' => {'version' => '0.9.7'}})
+      end
+      @config.reset
+
+      @config.version.should == '0.9.7'
+
+      FileUtils.rm "#{Rails.root}/config/sphinx.yml"
+    end
+
+    it "should detect the version from Riddle otherwise" do
+      controller = @config.controller
+      controller.stub!(:sphinx_version => '0.9.6')
+
+      Riddle::Controller.stub!(:new => controller)
+      @config.reset
+
+      @config.version.should == '0.9.6'
+    end
+  end
+
+  describe "parse_config method" do
+    before :each do
+      @settings = {
+        "development" => {
+          "config_file"       => "tmp/config/development.sphinx.conf",
+          "searchd_log_file"  => "searchd_log_file.log",
+          "query_log_file"    => "query_log_file.log",
+          "pid_file"          => "pid_file.pid",
+          "searchd_file_path" => "searchd/file/path",
+          "address"           => "127.0.0.1",
+          "port"              => 3333,
+          "min_prefix_len"    => 2,
+          "min_infix_len"     => 3,
+          "mem_limit"         => "128M",
+          "max_matches"       => 1001,
+          "morphology"        => "stem_ru",
+          "charset_type"      => "latin1",
+          "charset_table"     => "table",
+          "ignore_chars"      => "e",
+          "searchd_binary_name" => "sphinx-searchd",
+          "indexer_binary_name" => "sphinx-indexer",
+          "index_exact_words" => true,
+          "indexed_models"    => ['Alpha', 'Beta']
+        }
+      }
+
+      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 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"
+
+      ThinkingSphinx::Configuration.instance.reset
+    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
+
+  it "should insert set index options into the configuration file" do
+    config = ThinkingSphinx::Configuration.instance
+
+    ThinkingSphinx::Configuration::IndexOptions.each do |option|
+      config.reset
+      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
+    config.reset
+
+    config.source_options[:sql_query_pre] = ["something"]
+    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.delete option.to_sym
+    end
+
+    config.source_options[:sql_query_pre] = []
+  end
+
+  it "should not blow away delta or utf options if sql pre is specified in config" do
+    config = ThinkingSphinx::Configuration.instance
+    config.reset
+
+    config.source_options[:sql_query_pre] = ["a pre query"]
+    config.build
+    file = open(config.config_file) { |f| f.read }
+
+    file.should match(/sql_query_pre = a pre query\n\s*sql_query_pre = UPDATE `\w+` SET `delta` = 0 WHERE `delta` = 1/im)
+    file.should match(/sql_query_pre = a pre query\n\s*sql_query_pre = \n/im)
+
+    config.source_options[:sql_query_pre] = []
+  end
+
+  it "should set any explicit prefixed or infixed fields" do
+    ThinkingSphinx::Configuration.instance.build
+
+    file = open(ThinkingSphinx::Configuration.instance.config_file) { |f|
+      f.read
+    }
+    file.should match(/prefix_fields\s+= city/)
+    file.should match(/infix_fields\s+= state/)
+  end
+
+  it "should not have prefix fields in indexes where nothing is set" do
+    ThinkingSphinx::Configuration.instance.build
+
+    file = open(ThinkingSphinx::Configuration.instance.config_file) { |f|
+      f.read
+    }
+    file.should_not match(/index alpha_core\s+\{\s+[^\}]*prefix_fields\s+=[^\}]*\}/m)
+  end
+
+  describe '#generate' do
+    let(:config) { ThinkingSphinx::Configuration.instance }
+
+    it "should set all sphinx_internal_id attributes to bigints if one is" do
+      config.reset
+      config.generate
+
+      config.configuration.indices.each do |index|
+        next if index.is_a? Riddle::Configuration::DistributedIndex
+
+        index.sources.each do |source|
+          source.sql_attr_bigint.should include(:sphinx_internal_id)
+        end
+      end
+    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
+      @config.timeout = 1
+    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
+
+    it "should use the configuration timeout" do
+      @config.client.timeout.should == 1
+    end
+
+    describe 'when shuffle is enabled' do
+      let(:client) { double('client', :max_matches= => nil, :timeout= => nil) }
+
+      before :each do
+        @config.shuffle = true
+      end
+
+      it "should shuffle client servers" do
+        @config.address = ['1.1.1.1', '2.2.2.2']
+        @config.address.stub!(:shuffle => ['2.2.2.2', '1.1.1.1'])
+
+        Riddle::Client.should_receive(:new) do |addresses, port, key|
+          addresses.should == ['2.2.2.2', '1.1.1.1']
+          client
+        end
+        @config.client
+      end
+    end
+
+    describe 'when shuffle is disabled' do
+      let(:client) { double('client', :max_matches= => nil, :timeout= => nil) }
+
+      before :each do
+        @config.shuffle = false
+      end
+
+      it "should not shuffle client servers" do
+        @config.address = ['1.1.1.1', '2.2.2.2.', '3.3.3.3', '4.4.4.4', '5.5.5.5']
+
+        @config.address.should_not_receive(:shuffle)
+        Riddle::Client.should_receive(:new) do |addresses, port, key|
+          addresses.should == ['1.1.1.1', '2.2.2.2.', '3.3.3.3', '4.4.4.4', '5.5.5.5']
+          client
+        end
+        @config.client
+      end
+    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/thinking_sphinx/context_spec.rb

@@ -0,0 +1,126 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::Context do
+  let(:ts_context) { ThinkingSphinx::Context.new }
+
+  describe '#prepare' do
+    let(:config)           { ThinkingSphinx::Configuration.instance }
+    let(:file_name)        { 'a.rb' }
+    let(:model_name_lower) { 'a' }
+    let(:class_name)       { 'A' }
+
+    before :each do
+      config.model_directories = ['']
+
+      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)
+
+      ts_context.prepare
+    end
+
+    it "should not raise errors if the model name is nil" do
+      file_name.stub!(:gsub).and_return(nil)
+
+      lambda {
+        ts_context.prepare
+      }.should_not raise_error
+    end
+
+    it "should report name errors but not raise them" do
+      class_name.stub(:constantize).and_raise(NameError)
+      STDERR.stub!(:puts => '')
+      STDERR.should_receive(:puts).with('Warning: Error loading a.rb:')
+
+      lambda {
+        ts_context.prepare
+      }.should_not raise_error
+    end
+
+    it "should retry if the first load fails and contains a directory" do
+      model_name_lower.should_receive(:gsub!).twice.and_return(true, nil)
+      class_name.stub(:constantize).and_raise(LoadError)
+
+      lambda {
+        ts_context.prepare
+      }.should_not raise_error
+    end
+
+    it "should catch database errors with a warning" do
+      class_name.should_receive(:constantize).and_raise(Mysql2::Error)
+      STDERR.stub!(:puts => '')
+      STDERR.should_receive(:puts).with('Warning: Error loading a.rb:')
+
+      lambda {
+        ts_context.prepare
+      }.should_not raise_error
+    end unless RUBY_PLATFORM == 'java'
+
+    it "should not load models if they're explicitly set in the configuration" do
+      config.indexed_models = ['Alpha', 'Beta']
+      ts_context.prepare
+
+      ts_context.indexed_models.should == ['Alpha', 'Beta']
+    end
+  end
+
+  describe '#define_indexes' do
+    it "should call define_indexes on all known indexed models" do
+      ts_context.stub!(:indexed_models => ['Alpha', 'Beta'])
+      Alpha.should_receive(:define_indexes)
+      Beta.should_receive(:define_indexes)
+
+      ts_context.define_indexes
+    end
+  end
+
+  describe '#add_indexed_model' do
+    before :each do
+      ts_context.indexed_models.clear
+    end
+
+    it "should add the model to the collection" do
+      ts_context.add_indexed_model 'Alpha'
+
+      ts_context.indexed_models.should == ['Alpha']
+    end
+
+    it "should not duplicate models in the collection" do
+      ts_context.add_indexed_model 'Alpha'
+      ts_context.add_indexed_model 'Alpha'
+
+      ts_context.indexed_models.should == ['Alpha']
+    end
+
+    it "should keep the collection in alphabetical order" do
+      ts_context.add_indexed_model 'Beta'
+      ts_context.add_indexed_model 'Alpha'
+
+      ts_context.indexed_models.should == ['Alpha', 'Beta']
+    end
+
+    it "should translate classes to their names" do
+      ts_context.add_indexed_model Alpha
+
+      ts_context.indexed_models.should == ['Alpha']
+    end
+  end
+
+  describe '#superclass_indexed_models' do
+    it "should return indexed model names" do
+      ts_context.stub!(:indexed_models => ['Alpha', 'Beta'])
+
+      ts_context.superclass_indexed_models.should == ['Alpha', 'Beta']
+    end
+
+    it "should not include classes which have indexed superclasses" do
+      ts_context.stub!(:indexed_models => ['Parent', 'Person'])
+
+      ts_context.superclass_indexed_models.should == ['Person']
+    end
+  end
+end

data/spec/thinking_sphinx/core/array_spec.rb

@@ -0,0 +1,9 @@
+require 'spec_helper'
+
+describe Array do
+  describe '.===' do
+    it "should return true if an instance of ThinkingSphinx::Search" do
+      Array.should === ThinkingSphinx::Search.new
+    end
+  end
+end

data/spec/thinking_sphinx/core/string_spec.rb

@@ -0,0 +1,9 @@
+require '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_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_helper'
+
+describe ThinkingSphinx::FacetSearch do
+  let(:search) { stub('search', :append_to => nil, :empty? => true) }
+  let(:config) { ThinkingSphinx::Configuration.instance }
+  let(:client) { stub('client', :run => []) }
+  
+  before :each do
+    config.stub!(:client => client)
+  end
+  
+  describe 'populate' do
+    before :each do
+      config.configuration.searchd.max_matches = 10_000
+    end
+        
+    it "should request all shared facets in a multi-model request by default" do
+      ThinkingSphinx.stub!(:search => search)
+      if Riddle.loaded_version.to_i < 2
+        ThinkingSphinx::FacetSearch.new.facet_names.should == ['class_crc']
+      else
+        ThinkingSphinx::FacetSearch.new.facet_names.should == ['sphinx_internal_class']
+      end
+    end
+    
+    it "should request all facets in a multi-model request if specified" do
+      ThinkingSphinx.stub!(:search => search)
+      names = ThinkingSphinx::FacetSearch.new(:all_facets => true).facet_names
+      
+      if Riddle.loaded_version.to_i < 2
+        names.should == ['class_crc', 'city_facet', 'state_facet', 'birthday']
+      else
+        names.should == ['sphinx_internal_class', 'city_facet', 'state_facet', 'birthday']
+      end
+    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
+        search
+      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
+        search
+      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
+        search
+      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
+        search
+      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
+    
+    describe ':facets option' do
+      it "should limit facets to the requested set" do
+        ThinkingSphinx.should_receive(:search).once.and_return(search)
+        
+        ThinkingSphinx::FacetSearch.new(
+          :classes => [Person], :facets => :state
+        )
+      end
+    end
+    
+    describe "empty result set for attributes" do
+      before :each do
+        ThinkingSphinx.stub!(:search => 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]
+        search.stub!(:empty? => false)
+        search.stub!(:each_with_match).
+          and_yield(@person, {:attributes => {'@groupby' => @person.city.to_crc32, '@count' => 1}})
+        ThinkingSphinx::Search.stub!(:bundle_searches => [search])
+        
+        @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
+  end
+  
+  describe "#for" do
+    before do
+      @person = Person.find(:first)
+      @people = [@person]
+      search.stub!(:each_with_match).
+        and_yield(@person, {:attributes => {'@groupby' => @person.city.to_crc32, '@count' => 1}})
+      ThinkingSphinx::Search.stub!(:bundle_searches => [search])
+      
+      @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