master_slave_adapter 1.0.0.beta2 → 1.0.0

data/Rakefile

@@ -31,7 +31,7 @@ task :spec => ['spec:common', 'spec:integration']
 namespace :spec do
   desc 'Run common specs'
   MasterSlaveAdapterRSpecTask.new(:common) do |task|
-    task.pattern = './spec/*_spec.rb'
+    task.pattern = './spec/common/*_spec.rb'
     task.exclude = /mysql2/ unless mysql2_adapter_available?
     task.verbose = false
   end

data/Readme.md

@@ -180,6 +180,16 @@ development:
     - host: slave02
 ```
 
+## Testing
+
+You can execute all tests against your current ruby version via:
+
+    rake spec
+
+In case you have `rvm` installed, you can test against 1.8.7, 1.9.2 and 1.9.3 as well as ActiveRecord 2 and 3 via:
+
+    bash spec/all.sh
+
 ## Credits
 
 * Maurício Lenhares - _original master_slave_adapter plugin_

data/lib/active_record/connection_adapters/master_slave_adapter/version.rb

@@ -1,7 +1,7 @@
 module ActiveRecord
   module ConnectionAdapters
     module MasterSlaveAdapter
-      VERSION = "1.0.0.beta2"
+      VERSION = "1.0.0"
     end
   end
 end

data/master_slave_adapter.gemspec

@@ -7,7 +7,7 @@ Gem::Specification.new do |s|
   s.version     = ActiveRecord::ConnectionAdapters::MasterSlaveAdapter::VERSION
   s.platform    = Gem::Platform::RUBY
   s.authors     = [ 'Mauricio Linhares', 'Torsten Curdt', 'Kim Altintop', 'Omid Aladini', 'Tiago Loureiro', 'Tobias Schmidt', 'SoundCloud' ]
-  s.email       = %q{kim@soundcloud.com tcurdt@soundcloud.com ts@soundcloud}
+  s.email       = %q{tiago@soundcloud.com ts@soundcloud.com}
   s.homepage    = 'http://github.com/soundcloud/master_slave_adapter'
   s.summary     = %q{Replication Aware Master/Slave Database Adapter for ActiveRecord}
   s.description = %q{(MySQL) Replication Aware Master/Slave Database Adapter for ActiveRecord}
@@ -20,7 +20,7 @@ Gem::Specification.new do |s|
   s.required_ruby_version     = '>= 1.8.7'
   s.required_rubygems_version = '>= 1.3.7'
 
-  s.add_dependency 'activerecord', ['>= 2.3.9', '<= 4.0']
+  s.add_dependency 'activerecord', ['>= 2.3.9', '< 4.0']
 
   s.add_development_dependency 'rake'
   s.add_development_dependency 'rspec'

data/spec/all.sh

@@ -1,6 +1,6 @@
 #!/usr/bin/env bash
 
-source ~/.rvm/scripts/rvm
+source `which rvm | sed 's/rvm\/bin/rvm\/scripts/'`
 
 for ruby in 1.8.7 1.9.2 1.9.3; do
   rvm use $ruby

data/spec/{circuit_breaker_spec.rb → common/circuit_breaker_spec.rb}

@@ -1,4 +1,4 @@
-$: << File.expand_path(File.join(File.dirname( __FILE__ ), '..', 'lib'))
+$: << File.expand_path(File.join(File.dirname( __FILE__ ), '..', '..', 'lib'))
 
 require 'rspec'
 require 'active_record/connection_adapters/master_slave_adapter/circuit_breaker'

data/spec/{master_slave_adapter_spec.rb → common/master_slave_adapter_spec.rb}

@@ -1,12 +1,12 @@
-$: << File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$: << File.expand_path(File.join(File.dirname( __FILE__ ), '..', '..', 'lib'))
 
 require 'rspec'
-require 'logger'
-require 'active_record/connection_adapters/master_slave_adapter'
+require 'common/support/connection_setup_helper'
 
 module ActiveRecord
   class Base
     cattr_accessor :master_mock, :slave_mock
+
     def self.test_connection(config)
       config[:database] == 'slave' ? slave_mock : master_mock
     end
@@ -27,65 +27,14 @@ module ActiveRecord
       end
 
       def connection_error?(exception)
-        true
       end
     end
   end
 end
 
 describe ActiveRecord::ConnectionAdapters::MasterSlaveAdapter do
-  let(:default_database_setup) do
-    {
-      :adapter => 'master_slave',
-      :username => 'root',
-      :database => 'slave',
-      :connection_adapter => 'test',
-      :master => { :username => 'root', :database => 'master' },
-      :slaves => [{ :database => 'slave' }],
-    }
-  end
-
-  let(:database_setup) { default_database_setup }
-
-  let(:mocked_methods) do
-    {
-      :reconnect! => true,
-      :disconnect! => true,
-      :active? => true,
-    }
-  end
-
-  let!(:master_connection) do
-    mock(
-      'master connection',
-      mocked_methods.merge(:open_transactions => 0)
-    ).tap do |conn|
-      conn.stub!(:uncached).and_yield
-      ActiveRecord::Base.master_mock = conn
-    end
-  end
-
-  let!(:slave_connection) do
-    mock('slave connection', mocked_methods).tap do |conn|
-      conn.stub!(:uncached).and_yield
-      ActiveRecord::Base.slave_mock = conn
-    end
-  end
-
-  def adapter_connection
-    ActiveRecord::Base.connection
-  end
-
-  SchemaStatements = ActiveRecord::ConnectionAdapters::SchemaStatements.public_instance_methods.map(&:to_sym)
-  SelectMethods = [ :select_all, :select_one, :select_rows, :select_value, :select_values ] unless defined?(SelectMethods)
-
-  before do
-    ActiveRecord::Base.establish_connection(database_setup)
-  end
-
-  after do
-    ActiveRecord::Base.connection_handler.clear_all_connections!
-  end
+  include_context 'connection setup'
+  let(:connection_adapter) { 'test' }
 
   describe 'common configuration' do
     it "should call 'columns' on master" do
@@ -132,8 +81,8 @@ describe ActiveRecord::ConnectionAdapters::MasterSlaveAdapter do
         end
 
         it "raises MasterUnavailable if master is not available" do
+          adapter_connection.stub(:connection_error?).and_return(true)
           master_connection.stub(:open_transactions).and_return(1)
-          master_connection.stub(:connection_error?).and_return(true)
           master_connection.should_receive(method).with('testing').and_raise(ActiveRecord::StatementInvalid)
 
           expect do
@@ -150,7 +99,7 @@ describe ActiveRecord::ConnectionAdapters::MasterSlaveAdapter do
       end
 
       it "should raise MasterSlaveAdapter if master is not available" do
-        master_connection.stub(:connection_error?).and_return(true)
+        adapter_connection.stub(:connection_error?).and_return(true)
         master_connection.should_receive(method).and_raise(ActiveRecord::StatementInvalid)
 
         expect do

data/spec/common/mysql2_master_slave_adapter_spec.rb

@@ -0,0 +1,68 @@
+$: << File.expand_path(File.join(File.dirname( __FILE__ ), '..', '..', 'lib'))
+
+require 'rspec'
+require 'common/support/connection_setup_helper'
+require 'common/support/mysql_consistency_examples'
+require 'active_record/connection_adapters/mysql2_master_slave_adapter'
+
+module ActiveRecord
+  class Base
+    cattr_accessor :master_mock, :slave_mock
+
+    def self.mysql2_connection(config)
+      config[:database] == 'slave' ? slave_mock : master_mock
+    end
+  end
+end
+
+describe ActiveRecord::ConnectionAdapters::Mysql2MasterSlaveAdapter do
+  include_context 'connection setup'
+  let(:connection_adapter) { 'mysql2' }
+
+  it_should_behave_like 'mysql consistency'
+
+  describe "connection error detection" do
+    {
+      2002 => "query: not connected",
+      2003 => "Can't connect to MySQL server on 'localhost' (3306)",
+      2006 => "MySQL server has gone away",
+      2013 => "Lost connection to MySQL server during query",
+    }.each do |errno, description|
+      it "raises MasterUnavailable for '#{description}' during query execution" do
+        master_connection.stub_chain(:raw_connection, :errno).and_return(errno)
+        master_connection.should_receive(:insert).and_raise(ActiveRecord::StatementInvalid.new("Mysql2::Error: #{description}: INSERT 42"))
+
+        expect do
+          adapter_connection.insert("INSERT 42")
+        end.to raise_error(ActiveRecord::MasterUnavailable)
+      end
+
+      it "doesn't raise anything for '#{description}' during connection" do
+        error = Mysql2::Error.new(description)
+        error.stub(:errno).and_return(errno)
+        ActiveRecord::Base.should_receive(:master_mock).and_raise(error)
+
+        expect do
+          ActiveRecord::Base.connection_handler.clear_all_connections!
+          ActiveRecord::Base.connection
+        end.to_not raise_error
+      end
+    end
+
+    it "raises MasterUnavailable for 'closed MySQL connection' during query execution" do
+      master_connection.should_receive(:insert).and_raise(ActiveRecord::StatementInvalid.new("Mysql2::Error: closed MySQL connection: INSERT 42"))
+
+      expect do
+        adapter_connection.insert("INSERT 42")
+      end.to raise_error(ActiveRecord::MasterUnavailable)
+    end
+
+    it "raises StatementInvalid for other errors" do
+      master_connection.should_receive(:insert).and_raise(ActiveRecord::StatementInvalid.new("Mysql2::Error: Query execution was interrupted: INSERT 42"))
+
+      expect do
+        adapter_connection.insert("INSERT 42")
+      end.to raise_error(ActiveRecord::StatementInvalid)
+    end
+  end
+end

data/spec/common/mysql_master_slave_adapter_spec.rb

@@ -0,0 +1,62 @@
+$: << File.expand_path(File.join(File.dirname( __FILE__ ), '..', '..', 'lib'))
+
+require 'rspec'
+require 'common/support/connection_setup_helper'
+require 'common/support/mysql_consistency_examples'
+require 'active_record/connection_adapters/mysql_master_slave_adapter'
+
+module ActiveRecord
+  class Base
+    cattr_accessor :master_mock, :slave_mock
+
+    def self.mysql_connection(config)
+      config[:database] == 'slave' ? slave_mock : master_mock
+    end
+  end
+end
+
+describe ActiveRecord::ConnectionAdapters::MysqlMasterSlaveAdapter do
+  include_context 'connection setup'
+  let(:connection_adapter) { 'mysql' }
+
+  it_should_behave_like 'mysql consistency'
+
+  describe "connection error detection" do
+    {
+      Mysql::Error::CR_CONNECTION_ERROR   => "query: not connected",
+      Mysql::Error::CR_CONN_HOST_ERROR    => "Can't connect to MySQL server on 'localhost' (3306)",
+      Mysql::Error::CR_SERVER_GONE_ERROR  => "MySQL server has gone away",
+      Mysql::Error::CR_SERVER_LOST        => "Lost connection to MySQL server during query",
+    }.each do |errno, description|
+      it "raises MasterUnavailable for '#{description}' during query execution" do
+        master_connection.stub_chain(:raw_connection, :errno).and_return(errno)
+        master_connection.should_receive(:insert).and_raise(ActiveRecord::StatementInvalid.new("Mysql::Error: #{description}: INSERT 42"))
+
+        expect do
+          adapter_connection.insert("INSERT 42")
+        end.to raise_error(ActiveRecord::MasterUnavailable)
+      end
+
+      it "doesn't raise anything for '#{description}' during connection" do
+        error = Mysql::Error.new(description)
+        error.stub(:errno).and_return(errno)
+        ActiveRecord::Base.should_receive(:master_mock).and_raise(error)
+
+        expect do
+          ActiveRecord::Base.connection_handler.clear_all_connections!
+          ActiveRecord::Base.connection
+        end.to_not raise_error
+      end
+    end
+
+    it "raises StatementInvalid for other errors" do
+      error = ActiveRecord::StatementInvalid.new("Mysql::Error: Query execution was interrupted: INSERT 42")
+      master_connection.stub_chain(:raw_connection, :errno).and_return(Mysql::Error::ER_QUERY_INTERRUPTED)
+      master_connection.should_receive(:insert).and_raise(error)
+
+      expect do
+        adapter_connection.insert("INSERT 42")
+      end.to raise_error(ActiveRecord::StatementInvalid)
+    end
+  end
+end

data/spec/common/support/connection_setup_helper.rb

@@ -0,0 +1,56 @@
+require 'active_record/connection_adapters/master_slave_adapter'
+
+SchemaStatements = ActiveRecord::ConnectionAdapters::SchemaStatements.public_instance_methods.map(&:to_sym)
+SelectMethods = [ :select_all, :select_one, :select_rows, :select_value, :select_values ]
+
+shared_context 'connection setup' do
+  let(:default_database_setup) do
+    {
+      :adapter => 'master_slave',
+      :username => 'root',
+      :database => 'slave',
+      :connection_adapter => connection_adapter,
+      :master => { :username => 'root', :database => 'master' },
+      :slaves => [{ :database => 'slave' }],
+    }
+  end
+
+  let(:database_setup) do
+    default_database_setup
+  end
+
+  let(:mocked_methods) do
+    {
+      :reconnect!  => true,
+      :disconnect! => true,
+      :active?     => true,
+    }
+  end
+
+  let(:master_connection) do
+    stubs = mocked_methods.merge(:open_transactions => 0)
+    mock('master connection', stubs).tap do |conn|
+      conn.stub(:uncached).and_yield
+    end
+  end
+
+  let(:slave_connection) do
+    mock('slave connection', mocked_methods).tap do |conn|
+      conn.stub(:uncached).and_yield
+    end
+  end
+
+  before do
+    ActiveRecord::Base.master_mock = master_connection
+    ActiveRecord::Base.slave_mock = slave_connection
+    ActiveRecord::Base.establish_connection(database_setup)
+  end
+
+  after do
+    ActiveRecord::Base.connection_handler.clear_all_connections!
+  end
+
+  def adapter_connection
+    ActiveRecord::Base.connection
+  end
+end

data/spec/common/support/mysql_consistency_examples.rb

@@ -0,0 +1,263 @@
+require 'active_record/connection_adapters/master_slave_adapter/clock'
+
+Clock = ActiveRecord::ConnectionAdapters::MasterSlaveAdapter::Clock
+
+shared_examples_for 'mysql consistency' do
+  def zero
+    Clock.zero
+  end
+
+  def master_position(pos)
+    Clock.new('', pos)
+  end
+
+  def supports_prepared_statements?
+    described_class == ActiveRecord::ConnectionAdapters::MysqlMasterSlaveAdapter &&
+    ActiveRecord::ConnectionAdapters::MysqlAdapter.instance_methods.map(&:to_sym).include?(:exec_without_stmt)
+  end
+
+  def select_method
+    supports_prepared_statements? ? :exec_without_stmt : :select_one
+  end
+
+  def should_report_clock(pos, connection, log_file, log_pos, sql)
+    pos = Array(pos)
+    values = pos.map { |p| { log_file => '', log_pos => p } }
+    values.map! { |result| [ result ] } if supports_prepared_statements?
+
+    connection.
+      should_receive(select_method).exactly(pos.length).times.
+      with(sql).
+      and_return(*values)
+  end
+
+  def slave_should_report_clock(pos)
+    should_report_clock(pos, slave_connection, 'Relay_Master_Log_File', 'Exec_Master_Log_Pos', 'SHOW SLAVE STATUS')
+  end
+
+  def master_should_report_clock(pos)
+    should_report_clock(pos, master_connection, 'File', 'Position', 'SHOW MASTER STATUS')
+  end
+
+  SelectMethods.each do |method|
+    it "should send the method '#{method}' to the slave if nil is given" do
+      slave_should_report_clock(0)
+      slave_connection.should_receive(method).with('testing').and_return(true)
+      new_clock = ActiveRecord::Base.with_consistency(nil) do
+        adapter_connection.send(method, 'testing')
+      end
+      new_clock.should be_a(Clock)
+      new_clock.should equal(zero)
+    end
+
+    it "should send the method '#{method}' to the slave if clock.zero is given" do
+      slave_should_report_clock(0)
+      slave_connection.should_receive(method).with('testing').and_return(true)
+      old_clock = zero
+      new_clock = ActiveRecord::Base.with_consistency(old_clock) do
+        adapter_connection.send(method, 'testing')
+      end
+      new_clock.should be_a(Clock)
+      new_clock.should equal(old_clock)
+    end
+
+    it "should send the method '#{method}' to the master if slave hasn't cought up to required clock yet" do
+      slave_should_report_clock(0)
+      master_connection.should_receive(method).with('testing').and_return(true)
+      old_clock = master_position(1)
+      new_clock = ActiveRecord::Base.with_consistency(old_clock) do
+        adapter_connection.send(method, 'testing' )
+      end
+      new_clock.should be_a(Clock)
+      new_clock.should equal(old_clock)
+    end
+
+    it "should send the method '#{method}' to the master connection if there are open transactions" do
+      master_connection.stub!(:open_transactions).and_return(1)
+      master_connection.should_receive(method).with('testing').and_return(true)
+      old_clock = zero
+      new_clock = ActiveRecord::Base.with_consistency(old_clock) do
+        adapter_connection.send(method, 'testing')
+      end
+      new_clock.should be_a(Clock)
+      new_clock.should equal(zero)
+    end
+
+    it "should send the method '#{method}' to the master after a write operation" do
+      slave_should_report_clock(0)
+      master_should_report_clock(2)
+      slave_connection.should_receive(method).with('testing').and_return(true)
+      master_connection.should_receive(:update).with('testing').and_return(true)
+      master_connection.should_receive(method).with('testing').and_return(true)
+      old_clock = zero
+      new_clock = ActiveRecord::Base.with_consistency(old_clock) do
+        adapter_connection.send(method, 'testing')   # slave
+        adapter_connection.send(:update, 'testing') # master
+        adapter_connection.send(method, 'testing')   # master
+      end
+      new_clock.should be_a(Clock)
+      new_clock.should > old_clock
+    end
+  end
+
+  it "should update the clock after a transaction" do
+    slave_should_report_clock(0)
+    master_should_report_clock([0, 1, 1])
+
+    slave_connection.
+      should_receive(:select_all).exactly(1).times.with('testing').
+      and_return(true)
+
+    master_connection.
+      should_receive(:update).exactly(3).times.with('testing').
+      and_return(true)
+    master_connection.
+      should_receive(:select_all).exactly(5).times.with('testing').
+      and_return(true)
+    %w(begin_db_transaction
+       commit_db_transaction
+       increment_open_transactions
+       decrement_open_transactions
+       outside_transaction?).each do |txstmt|
+      master_connection.should_receive(txstmt).exactly(1).times
+    end
+
+    master_connection.
+      should_receive('open_transactions').exactly(13).times.
+      and_return(
+        # adapter: with_consistency, select_all, update, select_all
+        0, 0, 0, 0,
+        # connection: transaction
+        0,
+        # adapter: select_all, update, select_all, commit_db_transaction
+        1, 1, 1, 0,
+        # connection: transaction (ensure)
+        0,
+        # adapter: select_all, update, select_all
+        0, 0, 0
+       )
+
+    old_clock = zero
+    new_clock = ActiveRecord::Base.with_consistency(old_clock) do
+      adapter_connection.send(:select_all, 'testing') # slave  s=0 m=0
+      adapter_connection.send(:update, 'testing')     # master s=0 m=1
+      adapter_connection.send(:select_all, 'testing') # master s=0 m=1
+
+      ActiveRecord::Base.transaction do
+        adapter_connection.send(:select_all, 'testing') # master s=0 m=1
+        adapter_connection.send(:update, 'testing')     # master s=0 m=1
+        adapter_connection.send(:select_all, 'testing') # master s=0 m=1
+      end
+
+      adapter_connection.send(:select_all, 'testing') # master s=0 m=2
+      adapter_connection.send(:update, 'testing')     # master s=0 m=3
+      adapter_connection.send(:select_all, 'testing') # master s=0 m=3
+    end
+
+    new_clock.should > old_clock
+  end
+
+  context "with nested with_consistency" do
+    it "should return the same clock if not writing and no lag" do
+      slave_should_report_clock(0)
+      slave_connection.
+        should_receive(:select_one).exactly(3).times.with('testing').
+        and_return(true)
+
+      old_clock = zero
+      new_clock = ActiveRecord::Base.with_consistency(old_clock) do
+        adapter_connection.send(:select_one, 'testing')
+        ActiveRecord::Base.with_consistency(old_clock) do
+          adapter_connection.send(:select_one, 'testing')
+        end
+        adapter_connection.send(:select_one, 'testing')
+      end
+      new_clock.should equal(old_clock)
+    end
+
+    it "requesting a newer clock should return a new clock" do
+      adapter_connection.
+        should_receive('slave_consistent?').exactly(2).times.
+        and_return(true, false)
+      slave_connection.
+        should_receive(:select_all).exactly(2).times.with('testing').
+        and_return(true)
+      master_connection.
+        should_receive(:select_all).exactly(1).times.with('testing').
+        and_return(true)
+
+      start_clock = zero
+      inner_clock = zero
+      outer_clock = ActiveRecord::Base.with_consistency(start_clock) do
+        adapter_connection.send(:select_all, 'testing') # slave
+        inner_clock = ActiveRecord::Base.with_consistency(master_position(1)) do
+          adapter_connection.send(:select_all, 'testing') # master
+        end
+        adapter_connection.send(:select_all, 'testing') # slave
+      end
+
+      start_clock.should equal(outer_clock)
+      inner_clock.should > start_clock
+    end
+  end
+
+  it "should do the right thing when nested inside with_master" do
+    slave_should_report_clock(0)
+    slave_connection.should_receive(:select_all).exactly(1).times.with('testing').and_return(true)
+    master_connection.should_receive(:select_all).exactly(2).times.with('testing').and_return(true)
+    ActiveRecord::Base.with_master do
+      adapter_connection.send(:select_all, 'testing') # master
+      ActiveRecord::Base.with_consistency(zero) do
+        adapter_connection.send(:select_all, 'testing') # slave
+      end
+      adapter_connection.send(:select_all, 'testing') # master
+    end
+  end
+
+  it "should do the right thing when nested inside with_slave" do
+    slave_should_report_clock(0)
+    slave_connection.should_receive(:select_all).exactly(3).times.with('testing').and_return(true)
+    ActiveRecord::Base.with_slave do
+      adapter_connection.send(:select_all, 'testing') # slave
+      ActiveRecord::Base.with_consistency(zero) do
+        adapter_connection.send(:select_all, 'testing') # slave
+      end
+      adapter_connection.send(:select_all, 'testing') # slave
+    end
+  end
+
+  it "should do the right thing when wrapping with_master" do
+    slave_should_report_clock(0)
+    slave_connection.should_receive(:select_all).exactly(2).times.with('testing').and_return(true)
+    master_connection.should_receive(:select_all).exactly(1).times.with('testing').and_return(true)
+    ActiveRecord::Base.with_consistency(zero) do
+      adapter_connection.send(:select_all, 'testing') # slave
+      ActiveRecord::Base.with_master do
+        adapter_connection.send(:select_all, 'testing') # master
+      end
+      adapter_connection.send(:select_all, 'testing') # slave
+    end
+  end
+
+  it "should do the right thing when wrapping with_slave" do
+    slave_should_report_clock(0)
+    slave_connection.should_receive(:select_all).exactly(1).times.with('testing').and_return(true)
+    master_connection.should_receive(:select_all).exactly(2).times.with('testing').and_return(true)
+    ActiveRecord::Base.with_consistency(master_position(1)) do
+      adapter_connection.send(:select_all, 'testing') # master
+      ActiveRecord::Base.with_slave do
+        adapter_connection.send(:select_all, 'testing') # slave
+      end
+      adapter_connection.send(:select_all, 'testing') # master
+    end
+  end
+
+  it "should accept clock as string" do
+    slave_should_report_clock(0)
+    slave_connection.should_receive(:select_all).with('testing')
+
+    ActiveRecord::Base.with_consistency("@0") do
+      adapter_connection.send(:select_all, 'testing')
+    end
+  end
+end

data/spec/integration/mysql2_master_slave_adapter_spec.rb

@@ -2,7 +2,7 @@ $: << File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
 
 require 'rspec'
 require 'master_slave_adapter'
-require 'integration/helpers/shared_mysql_examples'
+require 'integration/support/shared_mysql_examples'
 
 describe "ActiveRecord::ConnectionAdapters::Mysql2MasterSlaveAdapter" do
   let(:connection_adapter) { 'mysql2' }

data/spec/integration/mysql_master_slave_adapter_spec.rb

@@ -2,7 +2,7 @@ $: << File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'lib'))
 
 require 'rspec'
 require 'master_slave_adapter'
-require 'integration/helpers/shared_mysql_examples'
+require 'integration/support/shared_mysql_examples'
 
 describe "ActiveRecord::ConnectionAdapters::MysqlMasterSlaveAdapter" do
   let(:connection_adapter) { 'mysql' }

data/spec/integration/{helpers/mysql_helper.rb → support/mysql_setup_helper.rb}

@@ -1,7 +1,7 @@
 require 'fileutils'
 require 'timeout'
 
-module MysqlHelper
+module MysqlSetupHelper
   MASTER_ID   = "1"
   MASTER_PORT = 3310
   SLAVE_ID    = "2"

data/spec/integration/{helpers → support}/shared_mysql_examples.rb

@@ -1,7 +1,7 @@
-require 'integration/helpers/mysql_helper'
+require 'integration/support/mysql_setup_helper'
 
 shared_examples_for "a MySQL MasterSlaveAdapter" do
-  include MysqlHelper
+  include MysqlSetupHelper
 
   let(:configuration) do
     {
@@ -20,7 +20,7 @@ shared_examples_for "a MySQL MasterSlaveAdapter" do
     }
   end
 
-  let(:test_table) { MysqlHelper::TEST_TABLE }
+  let(:test_table) { MysqlSetupHelper::TEST_TABLE }
 
   def connection
     ActiveRecord::Base.connection