thinking-sphinx 1.2.13 → 6.0.0

data/spec/lib/thinking_sphinx/configuration_spec.rb

@@ -1,268 +0,0 @@
-require 'spec/spec_helper'
-
-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
-      end
-
-      ThinkingSphinx::Configuration.stub!(:defined? => true)
-      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 = {
-        "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"
-        }
-      }
-
-      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"
-    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/)
-  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
-  
-  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/core/array_spec.rb

@@ -1,9 +0,0 @@
-require 'spec/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/lib/thinking_sphinx/core/string_spec.rb

@@ -1,9 +0,0 @@
-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/lib/thinking_sphinx/deltas/job_spec.rb

@@ -1,32 +0,0 @@
-require 'spec/spec_helper'
-
-describe ThinkingSphinx::Deltas::Job do
-  describe '.cancel_thinking_sphinx_jobs' do
-    before :each do
-      ThinkingSphinx::Deltas::Job.stub!(:delete_all => true)
-    end
-    
-    it "should not delete any rows if the delayed_jobs table does not exist" do
-      ThinkingSphinx::Deltas::Job.connection.stub!(:tables => [])
-      ThinkingSphinx::Deltas::Job.should_not_receive(:delete_all)
-      
-      ThinkingSphinx::Deltas::Job.cancel_thinking_sphinx_jobs
-    end
-    
-    it "should delete rows if the delayed_jobs table does exist" do
-      ThinkingSphinx::Deltas::Job.connection.stub!(:tables => ['delayed_jobs'])
-      ThinkingSphinx::Deltas::Job.should_receive(:delete_all)
-      
-      ThinkingSphinx::Deltas::Job.cancel_thinking_sphinx_jobs
-    end
-    
-    it "should delete only Thinking Sphinx jobs" do
-      ThinkingSphinx::Deltas::Job.connection.stub!(:tables => ['delayed_jobs'])
-      ThinkingSphinx::Deltas::Job.should_receive(:delete_all) do |sql|
-        sql.should match(/handler LIKE '--- !ruby\/object:ThinkingSphinx::Deltas::\%'/)
-      end
-      
-      ThinkingSphinx::Deltas::Job.cancel_thinking_sphinx_jobs
-    end
-  end
-end

data/spec/lib/thinking_sphinx/excerpter_spec.rb

@@ -1,57 +0,0 @@
-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 escape the text in the excerpt" do
-      @search.should_receive(:excerpt_for) do |string, model|
-        string.should == 'test "escaping" <characters>'
-      end
-      
-      @excerpter.string_to_escape
-    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

@@ -1,176 +0,0 @@
-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