thinking-sphinx 2.1.0 → 3.0.0.pre

data/spec/thinking_sphinx/active_record/sql_source_spec.rb

@@ -0,0 +1,401 @@
+require 'spec_helper'
+
+describe ThinkingSphinx::ActiveRecord::SQLSource do
+  let(:model)      { double('model', :connection => connection,
+    :name => 'User', :column_names => [], :inheritance_column => 'type') }
+  let(:connection) {
+    double('connection', :instance_variable_get => db_config) }
+  let(:db_config)  { {:host => 'localhost', :user => 'root',
+    :database => 'default'} }
+  let(:source)     { ThinkingSphinx::ActiveRecord::SQLSource.new(model) }
+  let(:adapter)    { double('adapter') }
+
+  before :each do
+    ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter.
+      stub!(:=== => true)
+    ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+      stub!(:adapter_for => adapter)
+  end
+
+  describe '#adapter' do
+    it "returns a database adapter for the model" do
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters.
+        should_receive(:adapter_for).with(model).and_return(adapter)
+
+      source.adapter.should == adapter
+    end
+  end
+
+  describe '#attributes' do
+    it "has the internal id attribute by default" do
+      source.attributes.collect(&:name).should include('sphinx_internal_id')
+    end
+
+    it "has the internal deleted attribute by default" do
+      source.attributes.collect(&:name).should include('sphinx_deleted')
+    end
+  end
+
+  describe '#delta_processor' do
+    let(:processor_class) { double('processor class', :try => processor) }
+    let(:processor)       { double('processor') }
+    let(:source)          {
+      ThinkingSphinx::ActiveRecord::SQLSource.new model,
+        :delta_processor => processor_class
+    }
+
+    it "loads the processor with the adapter" do
+      processor_class.should_receive(:try).with(:new, adapter).
+        and_return processor
+
+      source.delta_processor
+    end
+
+    it "returns the given processor" do
+      source.delta_processor.should == processor
+    end
+  end
+
+  describe '#delta?' do
+    it "returns the given delta setting" do
+      source = ThinkingSphinx::ActiveRecord::SQLSource.new model,
+        :delta? => true
+
+      source.should be_a_delta
+    end
+  end
+
+  describe '#disable_range?' do
+    it "returns the given range setting" do
+      source = ThinkingSphinx::ActiveRecord::SQLSource.new model,
+        :disable_range? => true
+
+      source.disable_range?.should be_true
+    end
+  end
+
+  describe '#fields' do
+    it "has the internal class field by default" do
+      source.fields.collect(&:name).should include('sphinx_internal_class')
+    end
+
+    it "sets the sphinx class field to use a string of the class name" do
+      source.fields.detect { |field|
+        field.name == 'sphinx_internal_class'
+      }.columns.first.__name.should == "'User'"
+    end
+
+    it "uses the inheritance column if it exists for the sphinx class field" do
+      adapter.stub(:convert_nulls) { |clause, default|
+        "ifnull(#{clause}, #{default})"
+      }
+      model.stub :column_names => ['type']
+
+      source.fields.detect { |field|
+        field.name == 'sphinx_internal_class'
+      }.columns.first.__name.
+        should == "ifnull(type, 'User')"
+    end
+
+    it "marks the internal class field as a facet" do
+      source.fields.detect { |field|
+        field.name == 'sphinx_internal_class'
+      }.options[:facet].should be_true
+    end
+  end
+
+  describe '#name' do
+    it "defaults to the model name downcased with the core suffix" do
+      source.name.should == 'user_core'
+    end
+
+    it "changes the suffix to delta if set to true" do
+      source = ThinkingSphinx::ActiveRecord::SQLSource.new model,
+        :delta? => true
+
+      source.name.should == 'user_delta'
+    end
+
+    it "allows for custom names, but adds the core suffix" do
+      source = ThinkingSphinx::ActiveRecord::SQLSource.new model,
+        :name => 'people'
+
+      source.name.should == 'people_core'
+    end
+
+    it "allows for custom names and adds the delta suffix if a delta source" do
+      source = ThinkingSphinx::ActiveRecord::SQLSource.new model,
+        :name => 'people', :delta? => true
+
+      source.name.should == 'people_delta'
+    end
+  end
+
+  describe '#offset' do
+    it "returns the given offset" do
+      source = ThinkingSphinx::ActiveRecord::SQLSource.new model, :offset => 12
+
+      source.offset.should == 12
+    end
+  end
+
+  describe '#render' do
+    let(:builder)   { double('builder', :sql_query_pre => []).as_null_object }
+    let(:config)    { double('config', :settings => {}) }
+    let(:presenter) { double('presenter', :collection_type => :uint) }
+    let(:template)  { double('template', :apply => true) }
+
+    before :each do
+      ThinkingSphinx::ActiveRecord::SQLBuilder.stub! :new => builder
+      ThinkingSphinx::ActiveRecord::Attribute::SphinxPresenter.stub :new => presenter
+      ThinkingSphinx::ActiveRecord::SQLSource::Template.stub :new => template
+      ThinkingSphinx::Configuration.stub :instance => config
+    end
+
+    it "sets the sql_host setting from the model's database settings" do
+      db_config[:host] = '12.34.56.78'
+
+      source.render
+
+      source.sql_host.should == '12.34.56.78'
+    end
+
+    it "defaults sql_host to localhost if the model has no host" do
+      db_config[:host] = nil
+
+      source.render
+
+      source.sql_host.should == 'localhost'
+    end
+
+    it "sets the sql_user setting from the model's database settings" do
+      db_config[:username] = 'pat'
+
+      source.render
+
+      source.sql_user.should == 'pat'
+    end
+
+    it "uses the user setting if username is not set in the model" do
+      db_config[:username] = nil
+      db_config[:user]     = 'pat'
+
+      source.render
+
+      source.sql_user.should == 'pat'
+    end
+
+    it "sets the sql_pass setting from the model's database settings" do
+      db_config[:password] = 'swordfish'
+
+      source.render
+
+      source.sql_pass.should == 'swordfish'
+    end
+
+    it "escapes hashes in the password for sql_pass" do
+      db_config[:password] = 'sword#fish'
+
+      source.render
+
+      source.sql_pass.should == 'sword\#fish'
+    end
+
+    it "sets the sql_db setting from the model's database settings" do
+      db_config[:database] = 'rails_app'
+
+      source.render
+
+      source.sql_db.should == 'rails_app'
+    end
+
+    it "sets the sql_port setting from the model's database settings" do
+      db_config[:port] = 5432
+
+      source.render
+
+      source.sql_port.should == 5432
+    end
+
+    it "sets the sql_sock setting from the model's database settings" do
+      db_config[:socket] = '/unix/socket'
+
+      source.render
+
+      source.sql_sock.should == '/unix/socket'
+    end
+
+    it "uses the builder's sql_query value" do
+      builder.stub! :sql_query => 'select * from table'
+
+      source.render
+
+      source.sql_query.should == 'select * from table'
+    end
+
+    it "uses the builder's sql_query_range value" do
+      builder.stub! :sql_query_range => 'select 0, 10 from table'
+
+      source.render
+
+      source.sql_query_range.should == 'select 0, 10 from table'
+    end
+
+    it "uses the builder's sql_query_info value" do
+      builder.stub! :sql_query_info => 'select * from table where id = ?'
+
+      source.render
+
+      source.sql_query_info.should == 'select * from table where id = ?'
+    end
+
+    it "appends the builder's sql_query_pre value" do
+      builder.stub! :sql_query_pre => ['Change Setting']
+
+      source.render
+
+      source.sql_query_pre.should == ['Change Setting']
+    end
+
+    it "adds fields with attributes to sql_field_string" do
+      source.fields << double('field',
+        :name => 'title', :with_attribute? => true, :file? => false)
+
+      source.render
+
+      source.sql_field_string.should include('title')
+    end
+
+    it "adds any joined or file fields" do
+      source.fields << double('field',
+        :name => 'title', :file? => true, :with_attribute? => false)
+
+      source.render
+
+      source.sql_file_field.should include('title')
+    end
+
+    it "adds any joined fields"
+
+    it "adds integer attributes to sql_attr_uint" do
+      source.attributes << double('attribute')
+      presenter.stub :declaration => 'count', :collection_type => :uint
+
+      source.render
+
+      source.sql_attr_uint.should include('count')
+    end
+
+    it "adds boolean attributes to sql_attr_bool" do
+      source.attributes << double('attribute')
+      presenter.stub :declaration => 'published', :collection_type => :bool
+
+      source.render
+
+      source.sql_attr_bool.should include('published')
+    end
+
+    it "adds string attributes to sql_attr_string" do
+      source.attributes << double('attribute')
+      presenter.stub :declaration => 'name', :collection_type => :string
+
+      source.render
+
+      source.sql_attr_string.should include('name')
+    end
+
+    it "adds timestamp attributes to sql_attr_timestamp" do
+      source.attributes << double('attribute')
+      presenter.stub :declaration => 'created_at',
+        :collection_type => :timestamp
+
+      source.render
+
+      source.sql_attr_timestamp.should include('created_at')
+    end
+
+    it "adds float attributes to sql_attr_float" do
+      source.attributes << double('attribute')
+      presenter.stub :declaration => 'rating', :collection_type => :float
+
+      source.render
+
+      source.sql_attr_float.should include('rating')
+    end
+
+    it "adds bigint attributes to sql_attr_bigint" do
+      source.attributes << double('attribute')
+      presenter.stub :declaration => 'super_id', :collection_type => :bigint
+
+      source.render
+
+      source.sql_attr_bigint.should include('super_id')
+    end
+
+    it "adds ordinal strings to sql_attr_str2ordinal" do
+      source.attributes << double('attribute')
+      presenter.stub :declaration => 'name', :collection_type => :str2ordinal
+
+      source.render
+
+      source.sql_attr_str2ordinal.should include('name')
+    end
+
+    it "adds multi-value attributes to sql_attr_multi" do
+      source.attributes << double('attribute')
+      presenter.stub :declaration => 'uint tag_ids from field',
+        :collection_type => :multi
+
+      source.render
+
+      source.sql_attr_multi.should include('uint tag_ids from field')
+    end
+
+    it "adds word count attributes to sql_attr_str2wordcount" do
+      source.attributes << double('attribute')
+      presenter.stub :declaration => 'name', :collection_type => :str2wordcount
+
+      source.render
+
+      source.sql_attr_str2wordcount.should include('name')
+    end
+
+    it "adds relevant settings from thinking_sphinx.yml" do
+      config.settings['mysql_ssl_cert'] = 'foo.cert'
+      config.settings['morphology']     = 'stem_en' # should be ignored
+
+      source.render
+
+      source.mysql_ssl_cert.should == 'foo.cert'
+    end
+  end
+
+  describe '#type' do
+    it "is mysql when using the MySQL Adapter" do
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter.
+        stub!(:=== => true)
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter.
+        stub!(:=== => false)
+
+      source.type.should == 'mysql'
+    end
+
+    it "is pgsql when using the PostgreSQL Adapter" do
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter.
+        stub!(:=== => false)
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter.
+        stub!(:=== => true)
+
+      source.type.should == 'pgsql'
+    end
+
+    it "raises an exception for any other adapter" do
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters::MySQLAdapter.
+        stub!(:=== => false)
+      ThinkingSphinx::ActiveRecord::DatabaseAdapters::PostgreSQLAdapter.
+        stub!(:=== => false)
+
+      lambda { source.type }.should raise_error
+    end
+  end
+end

data/spec/thinking_sphinx/configuration_spec.rb

@@ -1,258 +1,351 @@
 require 'spec_helper'
 
 describe ThinkingSphinx::Configuration do
-  describe "environment class method" do
-    before :each do
-      ThinkingSphinx::Configuration.reset_environment
+  let(:config) { ThinkingSphinx::Configuration.instance }
 
-      ENV["RAILS_ENV"] = nil
-    end
+  after :each do
+    ThinkingSphinx::Configuration.reset
+  end
 
-    it "should use Rails.env if set" do
-      was = Rails.env
-      Rails.env = 'global_rails'
+  describe '.instance' do
+    it "returns an instance of ThinkingSphinx::Configuration" do
+      ThinkingSphinx::Configuration.instance.
+        should be_a(ThinkingSphinx::Configuration)
+    end
 
-      ThinkingSphinx::Configuration.environment.should == 'global_rails'
+    it "memoizes the instance" do
+      config = double('configuration')
 
-      Rails.env = was
-    end
+      ThinkingSphinx::Configuration.should_receive(:new).once.and_return(config)
 
-    it "should use the Rails environment value if set" do
-      Rails.stub!(:env => "rails_production")
-      ThinkingSphinx::Configuration.environment.should == "rails_production"
+      ThinkingSphinx::Configuration.instance
+      ThinkingSphinx::Configuration.instance
     end
+  end
 
-    it "should default to development" do
-      ThinkingSphinx::Configuration.environment.should == "development"
+  describe '#configuration_file' do
+    it "uses the Rails environment in the configuration file name" do
+      config.configuration_file.
+        should == Rails.root.join('config', 'test.sphinx.conf')
     end
   end
 
-  describe '#version' do
+  describe '#connection' do
+    let(:connection) { double('connection') }
+
     before :each do
-      @config = ThinkingSphinx::Configuration.instance
-      @config.reset
+      Mysql2::Client.stub :new => connection
     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
+    it "connects using the searchd address and port" do
+      config.searchd.stub :address => '127.0.0.1', :mysql41 => 121
 
-      @config.version.should == '0.9.7'
+      Mysql2::Client.should_receive(:new).with(
+        :host  => '127.0.0.1',
+        :port  => 121,
+        :flags => Mysql2::Client::MULTI_STATEMENTS
+      ).and_return(connection)
+
+      config.connection
+    end
 
-      FileUtils.rm "#{Rails.root}/config/sphinx.yml"
+    it "returns the connection" do
+      config.connection.should == connection
     end
 
-    it "should detect the version from Riddle otherwise" do
-      controller = @config.controller
-      controller.stub!(:sphinx_version => '0.9.6')
+    it "respects any connection options in the settings" do
+      write_configuration(
+        'connection_options' => {:username => 'pat', :port => 9312}
+      )
 
-      Riddle::Controller.stub!(:new => controller)
-      @config.reset
+      Mysql2::Client.should_receive(:new).with(
+        :host     => '127.0.0.1',
+        :port     => 9312,
+        :flags    => Mysql2::Client::MULTI_STATEMENTS,
+        :username => 'pat'
+      ).and_return(connection)
 
-      @config.version.should == '0.9.6'
+      config.connection
     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
+  describe '#controller' do
+    it "returns an instance of Riddle::Controller" do
+      config.controller.should be_a(Riddle::Controller)
     end
 
-    it "should use the accessors to set the configuration values" do
-      config = ThinkingSphinx::Configuration.instance
-      config.send(:parse_config)
+    it "memoizes the instance" do
+      Riddle::Controller.should_receive(:new).once.
+        and_return(double('controller'))
 
-      %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
+      config.controller
+      config.controller
     end
 
-    after :each do
-      FileUtils.rm "#{Rails.root}/config/sphinx.yml"
+    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/'
     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"
+    it "appends a backslash to the bin_path if appropriate" do
+      write_configuration('bin_path' => '/foo/bar/bin')
 
-      ThinkingSphinx::Configuration.instance.reset
+      config.controller.bin_path.should == '/foo/bar/bin/'
     end
   end
 
-  describe "initialisation" do
-    it "should have a default bin_path of nothing" do
-      ThinkingSphinx::Configuration.instance.bin_path.should == ""
+  describe '#index_paths' do
+    it "uses app/indices in the Rails app by default" do
+      config.index_paths.should == [Rails.root.join('app', 'indices')]
     end
+  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
+  describe '#indices_for_references' do
+    it "selects from the full index set those with matching references" do
+      config.indices << double('index', :reference => :article)
+      config.indices << double('index', :reference => :book)
+      config.indices << double('index', :reference => :page)
 
-      ThinkingSphinx::Configuration.instance.send(:parse_config)
-      ThinkingSphinx::Configuration.instance.bin_path.should match(/\/$/)
+      config.indices_for_references(:book, :article).length.should == 2
+    end
+  end
 
-      FileUtils.rm "#{Rails.root}/config/sphinx.yml"
+  describe '#indices_location' do
+    it "stores index files in db/sphinx/ENVIRONMENT" do
+      config.indices_location.should == Rails.root.join('db', 'sphinx', 'test')
     end
   end
 
-  describe "index options" do
-    before :each do
-      @settings = {
-        "development" => {"disable_range" => true}
-      }
+  describe '#initialize' do
+    it "sets the daemon pid file within log for the Rails app" do
+      config.searchd.pid_file.
+        should == Rails.root.join('log', 'test.sphinx.pid')
+    end
 
-      open("#{Rails.root}/config/sphinx.yml", "w") do |f|
-        f.write  YAML.dump(@settings)
-      end
+    it "sets the daemon log within log for the Rails app" do
+      config.searchd.log.should == Rails.root.join('log', 'test.searchd.log')
+    end
+
+    it "sets the query log within log for the Rails app" do
+      config.searchd.query_log.
+        should == Rails.root.join('log', 'test.searchd.query.log')
+    end
+  end
+
+  describe '#next_offset' do
+    let(:reference) { double('reference') }
 
-      @config = ThinkingSphinx::Configuration.instance
-      @config.send(:parse_config)
+    it "starts at 0" do
+      config.next_offset(reference).should == 0
     end
 
-    it "should collect disable_range" do
-      @config.index_options[:disable_range].should be_true
+    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
     end
 
-    after :each do
-      FileUtils.rm "#{Rails.root}/config/sphinx.yml"
+    it "doesn't increment for recorded references" do
+      config.next_offset(reference).should == 0
+      config.next_offset(reference).should == 0
     end
   end
 
-  it "should insert set index options into the configuration file" do
-    config = ThinkingSphinx::Configuration.instance
+  describe '#preload_indices' do
+    it "searches each index path for ruby files" do
+      config.index_paths.replace ['/path/to/indices', '/path/to/other/indices']
 
-    ThinkingSphinx::Configuration::IndexOptions.each do |option|
-      config.reset
-      config.index_options[option.to_sym] = "something"
-      config.build
+      Dir.should_receive(:[]).with('/path/to/indices/**/*.rb').once.
+        and_return([])
+      Dir.should_receive(:[]).with('/path/to/other/indices/**/*.rb').once.
+        and_return([])
 
-      file = open(config.config_file) { |f| f.read }
-      file.should match(/#{option}\s+= something/)
+      config.preload_indices
+    end
+
+    it "loads each file returned" do
+      config.index_paths.replace ['/path/to/indices']
+      Dir.stub! :[] => [
+        '/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
 
-      config.index_options[option.to_sym] = nil
+      config.preload_indices
+    end
+
+    it "does not double-load indices" do
+      config.index_paths.replace ['/path/to/indices']
+      Dir.stub! :[] => [
+        '/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
+
+      config.preload_indices
+      config.preload_indices
     end
   end
 
-  it "should insert set source options into the configuration file" do
-    config = ThinkingSphinx::Configuration.instance
-    config.reset
+  describe '#render' do
+    before :each do
+      config.searchd.stub! :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.
+        and_return([])
+      Dir.should_receive(:[]).with('/path/to/other/indices/**/*.rb').once.
+        and_return([])
 
-    config.source_options[:sql_query_pre] = ["something"]
-    ThinkingSphinx::Configuration::SourceOptions.each do |option|
-      config.source_options[option.to_sym] ||= "something"
-      config.build
+      config.render
+    end
 
-      file = open(config.config_file) { |f| f.read }
-      file.should match(/#{option}\s+= something/)
+    it "loads each file returned" do
+      config.index_paths.replace ['/path/to/indices']
+      Dir.stub! :[] => [
+        '/path/to/indices/foo_index.rb',
+        '/path/to/indices/bar_index.rb'
+      ]
 
-      config.source_options.delete option.to_sym
+      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
+
+      config.render
     end
 
-    config.source_options[:sql_query_pre] = []
+    it "does not double-load indices" do
+      config.index_paths.replace ['/path/to/indices']
+      Dir.stub! :[] => [
+        '/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
+
+      config.preload_indices
+      config.preload_indices
+    end
   end
 
-  it "should not blow away delta or utf options if sql pre is specified in config" do
-    config = ThinkingSphinx::Configuration.instance
-    config.reset
+  describe '#render_to_file' do
+    let(:file)   { double('file') }
+    let(:output) { config.render }
+
+    before :each do
+      config.searchd.stub! :render => 'searchd { }'
+    end
 
-    config.source_options[:sql_query_pre] = ["a pre query"]
-    config.build
-    file = open(config.config_file) { |f| f.read }
+    it "writes the rendered configuration to the file" do
+      config.configuration_file = '/path/to/file.config'
 
-    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.should_receive(:open).with('/path/to/file.config', 'w').
+        and_yield(file)
+      file.should_receive(:write).with(output)
 
-    config.source_options[:sql_query_pre] = []
+      config.render_to_file
+    end
   end
 
-  it "should set any explicit prefixed or infixed fields" do
-    ThinkingSphinx::Configuration.instance.build
+  describe '#searchd' do
+    describe '#address' do
+      it "defaults to 127.0.0.1" do
+        config.searchd.address.should == '127.0.0.1'
+      end
 
-    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 "respects the address setting" do
+        write_configuration('address' => '10.11.12.13')
 
-  it "should not have prefix fields in indexes where nothing is set" do
-    ThinkingSphinx::Configuration.instance.build
+        config.searchd.address.should == '10.11.12.13'
+      end
+    end
 
-    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 '#mysql41' do
+      it "defaults to 9306" do
+        config.searchd.mysql41.should == 9306
+      end
 
-  describe '#generate' do
-    let(:config) { ThinkingSphinx::Configuration.instance }
+      it "respects the port setting" do
+        write_configuration('port' => 9313)
 
-    it "should set all sphinx_internal_id attributes to bigints if one is" do
-      config.reset
-      config.generate
+        config.searchd.mysql41.should == 9313
+      end
 
-      config.configuration.indices.each do |index|
-        next if index.is_a? Riddle::Configuration::DistributedIndex
+      it "respects the mysql41 setting" do
+        write_configuration('mysql41' => 9307)
 
-        index.sources.each do |source|
-          source.sql_attr_bigint.should include(:sphinx_internal_id)
-        end
+        config.searchd.mysql41.should == 9307
       end
     end
   end
 
-  describe '#models_by_crc' do
-    before :each do
-      @config = ThinkingSphinx::Configuration.instance
-    end
+  describe '#settings' do
+    context 'YAML file exists' do
+      before :each do
+        File.stub :exists? => true
+      end
+
+      it "reads from the YAML file" do
+        File.should_receive(:read).and_return('')
+
+        config.settings
+      end
 
-    it "should return a hash" do
-      @config.models_by_crc.should be_a(Hash)
+      it "uses the settings for the given environment" do
+        File.stub :read => {
+          'test'    => {'foo' => 'bar'},
+          'staging' => {'baz' => 'qux'}
+        }.to_yaml
+        Rails.stub :env => 'staging'
+
+        config.settings['baz'].should == 'qux'
+      end
+
+      it "remembers the file contents" do
+        File.should_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'
+
+        config.settings.should == {}
+      end
     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'
+    context 'YAML file does not exist' do
+      before :each do
+        File.stub :exists? => false
+      end
+
+      it "does not read the file" do
+        File.should_not_receive(:read)
+
+        config.settings
+      end
+
+      it "returns an empty hash" do
+        config.settings.should == {}
+      end
     end
   end
 end