active_record_host_pool 1.2.4 → 2.0.0.pre.2

data/test/helper.rb

@@ -1,198 +0,0 @@
-# frozen_string_literal: true
-
-require 'bundler/setup'
-require 'minitest/autorun'
-require 'pry-byebug'
-
-require 'active_record_host_pool'
-require 'logger'
-require 'minitest/mock_expectations'
-require 'phenix'
-
-ENV['RAILS_ENV'] = 'test'
-ENV['LEGACY_CONNECTION_HANDLING'] = 'true' if ENV['LEGACY_CONNECTION_HANDLING'].nil?
-
-if ActiveRecord.version >= Gem::Version.new('6.1')
-  ActiveRecord::Base.legacy_connection_handling = (ENV['LEGACY_CONNECTION_HANDLING'] == 'true')
-end
-
-RAILS_6_1_WITH_NON_LEGACY_CONNECTION_HANDLING =
-  ActiveRecord.version >= Gem::Version.new('6.1') && !ActiveRecord::Base.legacy_connection_handling
-
-ActiveRecord::Base.logger = Logger.new(File.dirname(__FILE__) + '/test.log')
-
-Thread.abort_on_exception = true
-
-# BEGIN preventing_writes? patch
-## Rails 6.1 by default does not allow writing to replica databases which prevents
-## us from properly setting up the test databases. This patch is used in test/schema.rb
-## to allow us to write to the replicas but only during migrations
-module ActiveRecordHostPool
-  cattr_accessor :allowing_writes
-  module PreventWritesPatch
-    def preventing_writes?
-      return false if ActiveRecordHostPool.allowing_writes && replica?
-
-      super
-    end
-  end
-end
-
-if ActiveRecord.version >= Gem::Version.new('6.1')
-  ActiveRecord::ConnectionAdapters::AbstractAdapter.prepend ActiveRecordHostPool::PreventWritesPatch
-end
-# END preventing_writes? patch
-
-Phenix.configure do |config|
-  config.skip_database = ->(name, conf) { name =~ /not_there/ || conf['username'] == 'john-doe' }
-end
-
-module ARHPTestSetup
-  private
-
-  def arhp_create_models
-    return if ARHPTestSetup.const_defined?('Pool1DbA')
-
-    if RAILS_6_1_WITH_NON_LEGACY_CONNECTION_HANDLING
-      eval <<-RUBY
-        class AbstractPool1DbC < ActiveRecord::Base
-          self.abstract_class = true
-          connects_to database: { writing: :test_pool_1_db_c }
-        end
-
-        # The placement of the Pool1DbC class is important so that its
-        # connection will not be the most recent connection established
-        # for test_pool_1.
-        class Pool1DbC < AbstractPool1DbC
-        end
-
-        class AbstractPool1DbA < ActiveRecord::Base
-          self.abstract_class = true
-          connects_to database: { writing: :test_pool_1_db_a, reading: :test_pool_1_db_a_replica }
-        end
-
-        class Pool1DbA < AbstractPool1DbA
-          self.table_name = "tests"
-        end
-
-        class AbstractPool1DbB < ActiveRecord::Base
-          self.abstract_class = true
-          connects_to database: { writing: :test_pool_1_db_b }
-        end
-
-        class Pool1DbB < AbstractPool1DbB
-          self.table_name = "tests"
-        end
-
-        class AbstractPool2DbD < ActiveRecord::Base
-          self.abstract_class = true
-          connects_to database: { writing: :test_pool_2_db_d }
-        end
-
-        class Pool2DbD < AbstractPool2DbD
-          self.table_name = "tests"
-        end
-
-        class AbstractPool2DbE < ActiveRecord::Base
-          self.abstract_class = true
-          connects_to database: { writing: :test_pool_2_db_e }
-        end
-
-        class Pool2DbE < AbstractPool2DbE
-          self.table_name = "tests"
-        end
-
-        class AbstractPool3DbE < ActiveRecord::Base
-          self.abstract_class = true
-          connects_to database: { writing: :test_pool_3_db_e }
-        end
-
-        class Pool3DbE < AbstractPool3DbE
-          self.table_name = "tests"
-        end
-
-        # Test ARHP with Rails 6.1+ horizontal sharding functionality
-        class AbstractShardedModel < ActiveRecord::Base
-          self.abstract_class = true
-          connects_to shards: {
-                        default: { writing: :test_pool_1_db_shard_a },
-                        shard_b: { writing: :test_pool_1_db_shard_b, reading: :test_pool_1_db_shard_b_replica },
-                        shard_c: { writing: :test_pool_1_db_shard_c, reading: :test_pool_1_db_shard_c_replica },
-                        shard_d: { writing: :test_pool_2_db_shard_d, reading: :test_pool_2_db_shard_d_replica }
-                      }
-        end
-
-        class ShardedModel < AbstractShardedModel
-          self.table_name = "tests"
-        end
-      RUBY
-    else
-      eval <<-RUBY
-        # The placement of the Pool1DbC class is important so that its
-        # connection will not be the most recent connection established
-        # for test_pool_1.
-        class Pool1DbC < ActiveRecord::Base
-          establish_connection(:test_pool_1_db_c)
-        end
-
-        class Pool1DbA < ActiveRecord::Base
-          self.table_name = "tests"
-          establish_connection(:test_pool_1_db_a)
-        end
-
-        class Pool1DbAReplica < ActiveRecord::Base
-          self.table_name = "tests"
-          establish_connection(:test_pool_1_db_a_replica)
-        end
-
-        class Pool1DbB < ActiveRecord::Base
-          self.table_name =  "tests"
-          establish_connection(:test_pool_1_db_b)
-        end
-
-        class Pool2DbD < ActiveRecord::Base
-          self.table_name = "tests"
-          establish_connection(:test_pool_2_db_d)
-        end
-
-        class Pool2DbE < ActiveRecord::Base
-          self.table_name = "tests"
-          establish_connection(:test_pool_2_db_e)
-        end
-
-        class Pool3DbE < ActiveRecord::Base
-          self.table_name = "tests"
-          establish_connection(:test_pool_3_db_e)
-        end
-      RUBY
-    end
-  end
-
-  def current_database(klass)
-    klass.connection.select_value('select DATABASE()')
-  end
-
-  # Remove a method from a given module that fixes something.
-  # Execute the passed in block.
-  # Re-add the method back to the module.
-  def without_module_patch(mod, method_name)
-    method_body = mod.instance_method(method_name)
-    mod.remove_method(method_name)
-    yield if block_given?
-  ensure
-    mod.define_method(method_name, method_body)
-  end
-
-  def simulate_rails_app_active_record_railties
-    if ActiveRecord.version >= Gem::Version.new('6.0') && !RAILS_6_1_WITH_NON_LEGACY_CONNECTION_HANDLING
-      # Necessary for testing ActiveRecord 6.0 which uses the connection
-      # handlers when clearing query caches across all handlers when
-      # an operation that dirties the cache is involved (e.g. create/insert,
-      # update, delete/destroy, truncate, etc.)
-      # In Rails 6.1 this is only present when legacy_connection_handling=true
-      ActiveRecord::Base.connection_handlers = {
-        ActiveRecord::Base.writing_role => ActiveRecord::Base.default_connection_handler
-      }
-    end
-  end
-end

data/test/schema.rb

@@ -1,23 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-begin
-  ActiveRecordHostPool.allowing_writes = true
-
-  ActiveRecord::Schema.define(version: 1) do
-    create_table 'tests', force: true do |t|
-      t.string   'val'
-    end
-
-    # Add a table only the shard database will have. Conditional
-    # exists since Phenix loads the schema file for every database.
-    if ActiveRecord::Base.connection.current_database == 'arhp_test_db_c'
-      create_table 'pool1_db_cs' do |t|
-        t.string 'name'
-      end
-    end
-  end
-ensure
-  ActiveRecordHostPool.allowing_writes = false
-end

data/test/test_arhp.rb

@@ -1,186 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class ActiveRecordHostPoolTest < Minitest::Test
-  include ARHPTestSetup
-  def setup
-    if RAILS_6_1_WITH_NON_LEGACY_CONNECTION_HANDLING
-      Phenix.rise! config_path: 'test/three_tier_database.yml'
-    else
-      Phenix.rise!
-    end
-    arhp_create_models
-  end
-
-  def teardown
-    ActiveRecord::Base.connection.disconnect!
-    ActiveRecordHostPool::PoolProxy.class_variable_set(:@@_connection_pools, {})
-    Phenix.burn!
-  end
-
-  def test_process_forking_with_connections
-    # Ensure we have a connection already
-    assert_equal(true, ActiveRecord::Base.connected?)
-
-    # Verify that when we fork, the process doesn't crash
-    pid = Process.fork do
-      if ActiveRecord.version >= Gem::Version.new('5.2')
-        assert_equal(false, ActiveRecord::Base.connected?) # New to Rails 5.2
-      else
-        assert_equal(true, ActiveRecord::Base.connected?)
-      end
-    end
-    Process.wait(pid)
-    # Cleanup any connections we may have left around
-    ActiveRecord::Base.connection_handler.clear_all_connections!
-  end
-
-  def test_models_with_matching_hosts_ports_sockets_usernames_and_replica_status_should_share_a_connection
-    assert_equal(Pool1DbA.connection.raw_connection, Pool1DbB.connection.raw_connection)
-    assert_equal(Pool2DbD.connection.raw_connection, Pool2DbE.connection.raw_connection)
-  end
-
-  def test_models_with_different_ports_should_not_share_a_connection
-    refute_equal(Pool1DbA.connection.raw_connection, Pool2DbD.connection.raw_connection)
-  end
-
-  def test_models_with_different_usernames_should_not_share_a_connection
-    refute_equal(Pool2DbE.connection.raw_connection, Pool3DbE.connection.raw_connection)
-  end
-
-  def test_should_select_on_correct_database
-    Pool1DbA.connection.send(:select_all, 'select 1')
-    assert_equal 'arhp_test_db_a', current_database(Pool1DbA)
-
-    Pool2DbD.connection.send(:select_all, 'select 1')
-    assert_equal 'arhp_test_db_d', current_database(Pool2DbD)
-
-    Pool3DbE.connection.send(:select_all, 'select 1')
-    assert_equal 'arhp_test_db_e', current_database(Pool3DbE)
-  end
-
-  def test_should_insert_on_correct_database
-    Pool1DbA.connection.send(:insert, "insert into tests values(NULL, 'foo')")
-    assert_equal 'arhp_test_db_a', current_database(Pool1DbA)
-
-    Pool2DbD.connection.send(:insert, "insert into tests values(NULL, 'foo')")
-    assert_equal 'arhp_test_db_d', current_database(Pool2DbD)
-
-    Pool3DbE.connection.send(:insert, "insert into tests values(NULL, 'foo')")
-    assert_equal 'arhp_test_db_e', current_database(Pool3DbE)
-  end
-
-  def test_connection_returns_a_proxy
-    assert_kind_of ActiveRecordHostPool::ConnectionProxy, Pool1DbA.connection
-  end
-
-  def test_connection_proxy_handles_private_methods
-    # Relies on connection.class returning the real class
-    Pool1DbA.connection.class.class_eval do
-      private
-
-      def test_private_method
-        true
-      end
-    end
-    assert Pool1DbA.connection.respond_to?(:test_private_method, true)
-    refute Pool1DbA.connection.respond_to?(:test_private_method)
-    assert_includes(Pool1DbA.connection.private_methods, :test_private_method)
-    assert_equal true, Pool1DbA.connection.send(:test_private_method)
-  end
-
-  def test_object_creation
-    Pool1DbA.create(val: 'foo')
-    assert_equal('arhp_test_db_a', current_database(Pool1DbA))
-
-    Pool2DbD.create(val: 'bar')
-    assert_equal('arhp_test_db_a', current_database(Pool1DbA))
-    assert_equal('arhp_test_db_d', current_database(Pool2DbD))
-
-    Pool1DbB.create!(val: 'bar_distinct')
-    assert_equal('arhp_test_db_b', current_database(Pool1DbB))
-    assert Pool1DbB.find_by_val('bar_distinct')
-    refute Pool1DbA.find_by_val('bar_distinct')
-  end
-
-  def test_disconnect
-    Pool1DbA.create(val: 'foo')
-    unproxied = Pool1DbA.connection.unproxied
-    Pool1DbA.connection_handler.clear_all_connections!
-    Pool1DbA.create(val: 'foo')
-    assert(unproxied != Pool1DbA.connection.unproxied)
-  end
-
-  def test_checkout
-    connection = ActiveRecord::Base.connection_pool.checkout
-    assert_kind_of(ActiveRecordHostPool::ConnectionProxy, connection)
-    ActiveRecord::Base.connection_pool.checkin(connection)
-    c2 = ActiveRecord::Base.connection_pool.checkout
-    assert(c2 == connection)
-  end
-
-  def test_no_switch_when_creating_db
-    conn = Pool1DbA.connection
-    assert_called(conn, :execute_without_switching) do
-      refute_called(conn, :_switch_connection) do
-        assert conn._host_pool_current_database
-        conn.create_database(:some_args)
-      end
-    end
-  end
-
-  def test_no_switch_when_dropping_db
-    conn = Pool1DbA.connection
-    assert_called(conn, :execute_without_switching) do
-      refute_called(conn, :_switch_connection) do
-        assert conn._host_pool_current_database
-        conn.drop_database(:some_args)
-      end
-    end
-  end
-
-  def test_underlying_assumption_about_test_db
-    debug_me = false
-    # ensure connection
-    Pool1DbA.first
-
-    # which is the "default" DB to connect to?
-    first_db = Pool1DbA.connection.unproxied.instance_variable_get(:@_cached_current_database)
-    puts "\nOk, we started on #{first_db}" if debug_me
-
-    switch_to_klass = case first_db
-    when 'arhp_test_db_b'
-      Pool1DbA
-    when 'arhp_test_db_a'
-      Pool1DbB
-    else
-      raise "Expected a database name, got #{first_db.inspect}"
-    end
-    expected_database = switch_to_klass.connection.instance_variable_get(:@database)
-
-    # switch to the other database
-    switch_to_klass.first
-    puts "\nAnd now we're on #{current_database(switch_to_klass)}" if debug_me
-
-    # get the current thread id so we can shoot ourselves in the head
-    thread_id = switch_to_klass.connection.select_value('select @@pseudo_thread_id')
-
-    # now, disable our auto-switching and trigger a mysql reconnect
-    switch_to_klass.connection.unproxied.stub(:_switch_connection, true) do
-      Pool2DbD.connection.execute("KILL #{thread_id}")
-    end
-
-    # and finally, did mysql reconnect correctly?
-    puts "\nAnd now we end up on #{current_database(switch_to_klass)}" if debug_me
-    assert_equal expected_database, current_database(switch_to_klass)
-  end
-
-  def test_release_connection
-    pool = ActiveRecord::Base.connection_pool
-    conn = pool.connection
-    assert_called_with(pool, :checkin, [conn]) do
-      pool.release_connection
-    end
-  end
-end