thinking-sphinx 3.1.4 → 6.0.0

data/spec/thinking_sphinx/configuration_spec.rb

@@ -1,22 +1,31 @@
+# frozen_string_literal: true
+
 require 'spec_helper'
 
 describe ThinkingSphinx::Configuration do
   let(:config) { ThinkingSphinx::Configuration.instance }
+  let(:use_load?) { ActiveRecord::VERSION::MAJOR > 5 }
+  let(:loading_object) { use_load? ? config : ActiveSupport::Dependencies }
+  let(:loading_method) { use_load? ? :load : :require_or_load }
 
   after :each do
     ThinkingSphinx::Configuration.reset
   end
 
+  def expect_loading_of(file)
+    expect(loading_object).to receive(loading_method).with(file).once
+  end
+
   describe '.instance' do
     it "returns an instance of ThinkingSphinx::Configuration" do
-      ThinkingSphinx::Configuration.instance.
-        should be_a(ThinkingSphinx::Configuration)
+      expect(ThinkingSphinx::Configuration.instance).
+        to be_a(ThinkingSphinx::Configuration)
     end
 
     it "memoizes the instance" do
       config = double('configuration')
 
-      ThinkingSphinx::Configuration.should_receive(:new).once.and_return(config)
+      expect(ThinkingSphinx::Configuration).to receive(:new).once.and_return(config)
 
       ThinkingSphinx::Configuration.instance
       ThinkingSphinx::Configuration.instance
@@ -29,8 +38,13 @@ describe ThinkingSphinx::Configuration do
     end
 
     it 'does not cache settings after reset' do
-      File.stub :exists? => true
-      File.stub :read => {
+      allow(File).to receive(:exist?).and_wrap_original do |original, path|
+        next true if path.to_s == File.absolute_path("config/thinking_sphinx.yml", Rails.root)
+
+        original.call(path)
+      end
+
+      allow(File).to receive_messages :read => {
         'test'       => {'foo' => 'bugs'},
         'production' => {'foo' => 'bar'}
       }.to_yaml
@@ -38,33 +52,33 @@ describe ThinkingSphinx::Configuration do
       ThinkingSphinx::Configuration.reset
       # Grab a new copy of the instance.
       config = ThinkingSphinx::Configuration.instance
-      config.settings['foo'].should == 'bugs'
+      expect(config.settings['foo']).to eq('bugs')
 
       config.framework = double :environment => 'production', :root => Pathname.new(__FILE__).join('..', '..', 'internal')
-      config.settings['foo'].should == 'bar'
+      expect(config.settings['foo']).to eq('bar')
     end
   end
 
   describe '#configuration_file' do
     it "uses the Rails environment in the configuration file name" do
-      config.configuration_file.
-        should == File.join(Rails.root, 'config', 'test.sphinx.conf')
+      expect(config.configuration_file).
+        to eq(File.join(Rails.root, 'config', 'test.sphinx.conf'))
     end
 
     it "respects provided settings" do
       write_configuration 'configuration_file' => '/path/to/foo.conf'
 
-      config.configuration_file.should == '/path/to/foo.conf'
+      expect(config.configuration_file).to eq('/path/to/foo.conf')
     end
   end
 
   describe '#controller' do
     it "returns an instance of Riddle::Controller" do
-      config.controller.should be_a(Riddle::Controller)
+      expect(config.controller).to be_a(Riddle::Controller)
     end
 
     it "memoizes the instance" do
-      Riddle::Controller.should_receive(:new).once.
+      expect(Riddle::Controller).to receive(:new).once.
         and_return(double('controller'))
 
       config.controller
@@ -74,19 +88,19 @@ describe ThinkingSphinx::Configuration do
     it "sets the bin path from the thinking_sphinx.yml file" do
       write_configuration('bin_path' => '/foo/bar/bin/')
 
-      config.controller.bin_path.should == '/foo/bar/bin/'
+      expect(config.controller.bin_path).to eq('/foo/bar/bin/')
     end
 
     it "appends a backslash to the bin_path if appropriate" do
       write_configuration('bin_path' => '/foo/bar/bin')
 
-      config.controller.bin_path.should == '/foo/bar/bin/'
+      expect(config.controller.bin_path).to eq('/foo/bar/bin/')
     end
   end
 
   describe '#index_paths' do
     it "uses app/indices in the Rails app by default" do
-      config.index_paths.should include(File.join(Rails.root, 'app', 'indices'))
+      expect(config.index_paths).to include(File.join(Rails.root, 'app', 'indices'))
     end
 
     it "uses app/indices in the Rails engines" do
@@ -95,22 +109,69 @@ describe ThinkingSphinx::Configuration do
       } }
       engine_class = double :instance => engine
 
-      Rails::Engine.should_receive(:subclasses).and_return([ engine_class ])
+      expect(Rails::Engine).to receive(:subclasses).and_return([ engine_class ])
 
-      config.index_paths.should include('/engine/app/indices')
+      expect(config.index_paths).to include('/engine/app/indices')
     end
   end
 
   describe '#indices_location' do
     it "stores index files in db/sphinx/ENVIRONMENT" do
-      config.indices_location.
-        should == File.join(Rails.root, 'db', 'sphinx', 'test')
+      expect(config.indices_location).
+        to eq(File.join(Rails.root, 'db', 'sphinx', 'test'))
     end
 
     it "respects provided settings" do
       write_configuration 'indices_location' => '/my/index/files'
 
-      config.indices_location.should == '/my/index/files'
+      expect(config.indices_location).to eq('/my/index/files')
+    end
+
+    it "respects relative paths" do
+      write_configuration 'indices_location' => 'my/index/files'
+
+      expect(config.indices_location).to eq('my/index/files')
+    end
+
+    it "translates relative paths to absolute if config requests it" do
+      write_configuration(
+        'indices_location' => 'my/index/files',
+        'absolute_paths'   => true
+      )
+
+      expect(config.indices_location).to eq(
+        File.join(config.framework.root, 'my/index/files')
+      )
+    end
+
+    it "respects paths that are already absolute" do
+      write_configuration(
+        'indices_location' => '/my/index/files',
+        'absolute_paths'   => true
+      )
+
+      expect(config.indices_location).to eq('/my/index/files')
+    end
+
+    it "translates linked directories" do
+      write_configuration(
+        'indices_location' => 'mine/index/files',
+        'absolute_paths'   => true
+      )
+
+      framework   = ThinkingSphinx::Frameworks.current
+      local_path  = File.join framework.root, "mine"
+      linked_path = File.join framework.root, "my"
+
+      FileUtils.mkdir_p linked_path
+      `ln -s #{linked_path} #{local_path}`
+
+      expect(config.indices_location).to eq(
+        File.join(config.framework.root, "my/index/files")
+      )
+
+      FileUtils.rm_rf local_path
+      FileUtils.rm_rf linked_path
     end
   end
 
@@ -120,30 +181,30 @@ describe ThinkingSphinx::Configuration do
     end
 
     it "sets the daemon pid file within log for the Rails app" do
-      config.searchd.pid_file.
-        should == File.join(Rails.root, 'log', 'test.sphinx.pid')
+      expect(config.searchd.pid_file).
+        to eq(File.join(Rails.root, 'log', 'test.sphinx.pid'))
     end
 
     it "sets the daemon log within log for the Rails app" do
-      config.searchd.log.
-        should == File.join(Rails.root, 'log', 'test.searchd.log')
+      expect(config.searchd.log).
+        to eq(File.join(Rails.root, 'log', 'test.searchd.log'))
     end
 
     it "sets the query log within log for the Rails app" do
-      config.searchd.query_log.
-        should == File.join(Rails.root, 'log', 'test.searchd.query.log')
+      expect(config.searchd.query_log).
+        to eq(File.join(Rails.root, 'log', 'test.searchd.query.log'))
     end
 
     it "sets indexer settings if within thinking_sphinx.yml" do
       write_configuration 'mem_limit' => '128M'
 
-      config.indexer.mem_limit.should == '128M'
+      expect(config.indexer.mem_limit).to eq('128M')
     end
 
     it "sets searchd settings if within thinking_sphinx.yml" do
       write_configuration 'workers' => 'none'
 
-      config.searchd.workers.should == 'none'
+      expect(config.searchd.workers).to eq('none')
     end
 
     it 'adds settings to indexer without common section' do
@@ -164,18 +225,18 @@ describe ThinkingSphinx::Configuration do
     let(:reference) { double('reference') }
 
     it "starts at 0" do
-      config.next_offset(reference).should == 0
+      expect(config.next_offset(reference)).to eq(0)
     end
 
     it "increments for each new reference" do
-      config.next_offset(double('reference')).should == 0
-      config.next_offset(double('reference')).should == 1
-      config.next_offset(double('reference')).should == 2
+      expect(config.next_offset(double('reference'))).to eq(0)
+      expect(config.next_offset(double('reference'))).to eq(1)
+      expect(config.next_offset(double('reference'))).to eq(2)
     end
 
     it "doesn't increment for recorded references" do
-      config.next_offset(reference).should == 0
-      config.next_offset(reference).should == 0
+      expect(config.next_offset(reference)).to eq(0)
+      expect(config.next_offset(reference)).to eq(0)
     end
   end
 
@@ -190,9 +251,9 @@ describe ThinkingSphinx::Configuration do
     it "searches each index path for ruby files" do
       config.index_paths.replace ['/path/to/indices', '/path/to/other/indices']
 
-      Dir.should_receive(:[]).with('/path/to/indices/**/*.rb').once.
+      expect(Dir).to receive(:[]).with('/path/to/indices/**/*.rb').once.
         and_return([])
-      Dir.should_receive(:[]).with('/path/to/other/indices/**/*.rb').once.
+      expect(Dir).to receive(:[]).with('/path/to/other/indices/**/*.rb').once.
         and_return([])
 
       config.preload_indices
@@ -200,37 +261,33 @@ describe ThinkingSphinx::Configuration do
 
     it "loads each file returned" do
       config.index_paths.replace ['/path/to/indices']
-      Dir.stub! :[] => [
+      allow(Dir).to receive_messages :[] => [
         '/path/to/indices/foo_index.rb',
         '/path/to/indices/bar_index.rb'
       ]
 
-      ActiveSupport::Dependencies.should_receive(:require_or_load).
-        with('/path/to/indices/foo_index.rb').once
-      ActiveSupport::Dependencies.should_receive(:require_or_load).
-        with('/path/to/indices/bar_index.rb').once
+      expect_loading_of('/path/to/indices/foo_index.rb')
+      expect_loading_of('/path/to/indices/bar_index.rb')
 
       config.preload_indices
     end
 
     it "does not double-load indices" do
       config.index_paths.replace ['/path/to/indices']
-      Dir.stub! :[] => [
+      allow(Dir).to receive_messages :[] => [
         '/path/to/indices/foo_index.rb',
         '/path/to/indices/bar_index.rb'
       ]
 
-      ActiveSupport::Dependencies.should_receive(:require_or_load).
-        with('/path/to/indices/foo_index.rb').once
-      ActiveSupport::Dependencies.should_receive(:require_or_load).
-        with('/path/to/indices/bar_index.rb').once
+      expect_loading_of('/path/to/indices/foo_index.rb')
+      expect_loading_of('/path/to/indices/bar_index.rb')
 
       config.preload_indices
       config.preload_indices
     end
 
     it 'adds distributed indices' do
-      distributor.should_receive(:reconcile)
+      expect(distributor).to receive(:reconcile)
 
       config.preload_indices
     end
@@ -238,7 +295,7 @@ describe ThinkingSphinx::Configuration do
     it 'does not add distributed indices if disabled' do
       write_configuration('distributed_indices' => false)
 
-      distributor.should_not_receive(:reconcile)
+      expect(distributor).not_to receive(:reconcile)
 
       config.preload_indices
     end
@@ -246,15 +303,15 @@ describe ThinkingSphinx::Configuration do
 
   describe '#render' do
     before :each do
-      config.searchd.stub! :render => 'searchd { }'
+      allow(config.searchd).to receive_messages :render => 'searchd { }'
     end
 
     it "searches each index path for ruby files" do
       config.index_paths.replace ['/path/to/indices', '/path/to/other/indices']
 
-      Dir.should_receive(:[]).with('/path/to/indices/**/*.rb').once.
+      expect(Dir).to receive(:[]).with('/path/to/indices/**/*.rb').once.
         and_return([])
-      Dir.should_receive(:[]).with('/path/to/other/indices/**/*.rb').once.
+      expect(Dir).to receive(:[]).with('/path/to/other/indices/**/*.rb').once.
         and_return([])
 
       config.render
@@ -262,30 +319,26 @@ describe ThinkingSphinx::Configuration do
 
     it "loads each file returned" do
       config.index_paths.replace ['/path/to/indices']
-      Dir.stub! :[] => [
+      allow(Dir).to receive_messages :[] => [
         '/path/to/indices/foo_index.rb',
         '/path/to/indices/bar_index.rb'
       ]
 
-      ActiveSupport::Dependencies.should_receive(:require_or_load).
-        with('/path/to/indices/foo_index.rb').once
-      ActiveSupport::Dependencies.should_receive(:require_or_load).
-        with('/path/to/indices/bar_index.rb').once
+      expect_loading_of('/path/to/indices/foo_index.rb')
+      expect_loading_of('/path/to/indices/bar_index.rb')
 
       config.render
     end
 
     it "does not double-load indices" do
       config.index_paths.replace ['/path/to/indices']
-      Dir.stub! :[] => [
+      allow(Dir).to receive_messages :[] => [
         '/path/to/indices/foo_index.rb',
         '/path/to/indices/bar_index.rb'
       ]
 
-      ActiveSupport::Dependencies.should_receive(:require_or_load).
-        with('/path/to/indices/foo_index.rb').once
-      ActiveSupport::Dependencies.should_receive(:require_or_load).
-        with('/path/to/indices/bar_index.rb').once
+      expect_loading_of('/path/to/indices/foo_index.rb')
+      expect_loading_of('/path/to/indices/bar_index.rb')
 
       config.preload_indices
       config.preload_indices
@@ -293,70 +346,162 @@ describe ThinkingSphinx::Configuration do
   end
 
   describe '#render_to_file' do
-    let(:file)   { double('file') }
-    let(:output) { config.render }
+    let(:file)             { double('file') }
+    let(:output)           { config.render }
+    let(:skip_directories) { false }
 
     before :each do
-      config.searchd.stub! :render => 'searchd { }'
+      write_configuration('skip_directory_creation' => skip_directories)
+
+      allow(config.searchd).to receive_messages :render => 'searchd { }'
     end
 
     it "writes the rendered configuration to the file" do
       config.configuration_file = '/path/to/file.config'
 
-      config.should_receive(:open).with('/path/to/file.config', 'w').
+      expect(config).to receive(:open).with('/path/to/file.config', 'w').
         and_yield(file)
-      file.should_receive(:write).with(output)
+      expect(file).to receive(:write).with(output)
 
       config.render_to_file
     end
 
     it "creates a directory at the binlog_path" do
-      FileUtils.stub :mkdir_p => true
-      config.stub :searchd => double(:binlog_path => '/path/to/binlog')
+      allow(FileUtils).to receive_messages :mkdir_p => true
+      allow(config).to receive_messages :searchd => double(:binlog_path => '/path/to/binlog')
 
-      FileUtils.should_receive(:mkdir_p).with('/path/to/binlog')
+      expect(FileUtils).to receive(:mkdir_p).with('/path/to/binlog')
 
       config.render_to_file
     end
 
     it "skips creating a directory when the binlog_path is blank" do
-      FileUtils.stub :mkdir_p => true
-      config.stub :searchd => double(:binlog_path => '')
+      allow(loading_object).to receive(loading_method)
+
+      allow(FileUtils).to receive_messages :mkdir_p => true
+      allow(config).to receive_messages :searchd => double(:binlog_path => '')
 
-      FileUtils.should_not_receive(:mkdir_p)
+      expect(FileUtils).not_to receive(:mkdir_p)
 
       config.render_to_file
     end
+
+    context 'skipping directory creation' do
+      let(:skip_directories) { true }
+
+      it "skips creating a directory when flag is set" do
+        expect(FileUtils).not_to receive(:mkdir_p)
+
+        config.render_to_file
+      end
+    end
   end
 
   describe '#searchd' do
     describe '#address' do
       it "defaults to 127.0.0.1" do
-        config.searchd.address.should == '127.0.0.1'
+        expect(config.searchd.address).to eq('127.0.0.1')
       end
 
       it "respects the address setting" do
         write_configuration('address' => '10.11.12.13')
 
-        config.searchd.address.should == '10.11.12.13'
+        expect(config.searchd.address).to eq('10.11.12.13')
       end
     end
 
+    describe '#log' do
+      it "defaults to an environment-specific file" do
+        expect(config.searchd.log).to eq(
+          File.join(config.framework.root, "log/test.searchd.log")
+        )
+      end
+
+      it "translates linked directories" do
+        framework   = ThinkingSphinx::Frameworks.current
+        log_path    = File.join framework.root, "log"
+        linked_path = File.join framework.root, "logging"
+        log_exists  = File.exist? log_path
+
+        FileUtils.mv log_path, "#{log_path}-tmp" if log_exists
+        FileUtils.mkdir_p linked_path
+        `ln -s #{linked_path} #{log_path}`
+
+        expect(config.searchd.log).to eq(
+          File.join(config.framework.root, "logging/test.searchd.log")
+        )
+
+        FileUtils.rm log_path
+        FileUtils.rmdir linked_path
+        FileUtils.mv "#{log_path}-tmp", log_path if log_exists
+      end unless RUBY_PLATFORM == "java"
+    end
+
     describe '#mysql41' do
       it "defaults to 9306" do
-        config.searchd.mysql41.should == 9306
+        expect(config.searchd.mysql41).to eq(9306)
       end
 
       it "respects the port setting" do
         write_configuration('port' => 9313)
 
-        config.searchd.mysql41.should == 9313
+        expect(config.searchd.mysql41).to eq(9313)
       end
 
       it "respects the mysql41 setting" do
         write_configuration('mysql41' => 9307)
 
-        config.searchd.mysql41.should == 9307
+        expect(config.searchd.mysql41).to eq(9307)
+      end
+    end
+
+    describe "#socket" do
+      it "does not set anything by default" do
+        expect(config.searchd.socket).to be_nil
+      end
+
+      it "ignores unspecified address and port when socket is set" do
+        write_configuration("socket" => "/my/socket")
+
+        expect(config.searchd.socket).to eq("/my/socket:mysql41")
+        expect(config.searchd.address).to be_nil
+        expect(config.searchd.mysql41).to be_nil
+      end
+
+      it "allows address and socket settings" do
+        write_configuration("socket" => "/my/socket", "address" => "1.1.1.1")
+
+        expect(config.searchd.socket).to eq("/my/socket:mysql41")
+        expect(config.searchd.address).to eq("1.1.1.1")
+        expect(config.searchd.mysql41).to eq(9306)
+      end
+
+      it "allows mysql41 and socket settings" do
+        write_configuration("socket" => "/my/socket", "mysql41" => 9307)
+
+        expect(config.searchd.socket).to eq("/my/socket:mysql41")
+        expect(config.searchd.address).to eq("127.0.0.1")
+        expect(config.searchd.mysql41).to eq(9307)
+      end
+
+      it "allows port and socket settings" do
+        write_configuration("socket" => "/my/socket", "port" => 9307)
+
+        expect(config.searchd.socket).to eq("/my/socket:mysql41")
+        expect(config.searchd.address).to eq("127.0.0.1")
+        expect(config.searchd.mysql41).to eq(9307)
+      end
+
+      it "allows address, mysql41 and socket settings" do
+        write_configuration(
+          "socket"  => "/my/socket",
+          "address" => "1.2.3.4",
+          "mysql41" => 9307
+        )
+
+        expect(config.searchd.socket).to eq("/my/socket:mysql41")
+        expect(config.searchd.address).to eq("1.2.3.4")
+        expect(config.searchd.mysql41).to eq(9307)
       end
     end
   end
@@ -364,66 +509,74 @@ describe ThinkingSphinx::Configuration do
   describe '#settings' do
     context 'YAML file exists' do
       before :each do
-        File.stub :exists? => true
+        allow(File).to receive(:exist?).and_wrap_original do |original, path|
+          next true if path.to_s == File.absolute_path("config/thinking_sphinx.yml", Rails.root)
+
+          original.call(path)
+        end
       end
 
       it "reads from the YAML file" do
-        File.should_receive(:read).and_return('')
+        expect(File).to receive(:read).and_return('')
 
         config.settings
       end
 
       it "uses the settings for the given environment" do
-        File.stub :read => {
+        allow(File).to receive_messages :read => {
           'test'    => {'foo' => 'bar'},
           'staging' => {'baz' => 'qux'}
         }.to_yaml
-        Rails.stub :env => 'staging'
+        allow(Rails).to receive_messages :env => 'staging'
 
-        config.settings['baz'].should == 'qux'
+        expect(config.settings['baz']).to eq('qux')
       end
 
       it "remembers the file contents" do
-        File.should_receive(:read).and_return('')
+        expect(File).to receive(:read).and_return('')
 
         config.settings
         config.settings
       end
 
-      it "returns an empty hash when no settings for the environment exist" do
-        File.stub :read => {'test' => {'foo' => 'bar'}}.to_yaml
-        Rails.stub :env => 'staging'
+      it "returns the default hash when no settings for the environment exist" do
+        allow(File).to receive_messages :read => {'test' => {'foo' => 'bar'}}.to_yaml
+        allow(Rails).to receive_messages :env => 'staging'
 
-        config.settings.should == {}
+        expect(config.settings.class).to eq(Hash)
       end
     end
 
     context 'YAML file does not exist' do
       before :each do
-        File.stub :exists? => false
+        allow(File).to receive(:exist?).and_wrap_original do |original, path|
+          next false if path.to_s == File.absolute_path("config/thinking_sphinx.yml", Rails.root)
+
+          original.call(path)
+        end
       end
 
       it "does not read the file" do
-        File.should_not_receive(:read)
+        expect(File).not_to receive(:read)
 
         config.settings
       end
 
-      it "returns an empty hash" do
-        config.settings.should == {}
+      it "returns a hash" do
+        expect(config.settings.class).to eq(Hash)
       end
     end
   end
 
   describe '#version' do
-    it "defaults to 2.1.4" do
-      config.version.should == '2.1.4'
+    it "defaults to 2.2.11" do
+      expect(config.version).to eq('2.2.11')
     end
 
     it "respects supplied YAML versions" do
       write_configuration 'version' => '2.0.4'
 
-      config.version.should == '2.0.4'
+      expect(config.version).to eq('2.0.4')
     end
   end
 end