ibm_db 3.0.5-x86-mingw32 → 4.0.0-x86-mingw32

data/test/cases/connection_management_test.rb

@@ -1,122 +1,112 @@
-require "cases/helper"
-require "rack"
-
-module ActiveRecord
-  module ConnectionAdapters
-    class ConnectionManagementTest < ActiveRecord::TestCase
-      class App
-        attr_reader :calls
-        def initialize
-          @calls = []
-        end
-
-        def call(env)
-          @calls << env
-          [200, {}, ['hi mom']]
-        end
-      end
-
-      def setup
-        @env = {}
-        @app = App.new
-        @management = ConnectionManagement.new(@app)
-
-        # make sure we have an active connection
-        assert ActiveRecord::Base.connection
-        assert ActiveRecord::Base.connection_handler.active_connections?
-      end
-
-      if Process.respond_to?(:fork)
-        def test_connection_pool_per_pid
-          object_id = ActiveRecord::Base.connection.object_id
-
-          rd, wr = IO.pipe
-          rd.binmode
-          wr.binmode
-
-          pid = fork {
-            rd.close
-            wr.write Marshal.dump ActiveRecord::Base.connection.object_id
-            wr.close
-            exit!
-          }
-
-          wr.close
-
-          Process.waitpid pid
-          assert_not_equal object_id, Marshal.load(rd.read)
-          rd.close
-        end
-      end
-
-      def test_app_delegation
-        manager = ConnectionManagement.new(@app)
-
-        manager.call @env
-        assert_equal [@env], @app.calls
-      end
-
-      def test_connections_are_active_after_call
-        @management.call(@env)
-        assert ActiveRecord::Base.connection_handler.active_connections?
-      end
-
-      def test_body_responds_to_each
-        _, _, body = @management.call(@env)
-        bits = []
-        body.each { |bit| bits << bit }
-        assert_equal ['hi mom'], bits
-      end
-
-      def test_connections_are_cleared_after_body_close
-        _, _, body = @management.call(@env)
-        body.close
-        assert !ActiveRecord::Base.connection_handler.active_connections?
-      end
-
-      def test_active_connections_are_not_cleared_on_body_close_during_test
-        @env['rack.test'] = true
-        _, _, body = @management.call(@env)
-        body.close
-        assert ActiveRecord::Base.connection_handler.active_connections?
-      end
-
-      def test_connections_closed_if_exception
-        app       = Class.new(App) { def call(env); raise NotImplementedError; end }.new
-        explosive = ConnectionManagement.new(app)
-        assert_raises(NotImplementedError) { explosive.call(@env) }
-        assert !ActiveRecord::Base.connection_handler.active_connections?
-      end
-
-      def test_connections_not_closed_if_exception_and_test
-        @env['rack.test'] = true
-        app               = Class.new(App) { def call(env); raise; end }.new
-        explosive         = ConnectionManagement.new(app)
-        assert_raises(RuntimeError) { explosive.call(@env) }
-        assert ActiveRecord::Base.connection_handler.active_connections?
-      end
-
-      def test_connections_closed_if_exception_and_explicitly_not_test
-        @env['rack.test'] = false
-        app       = Class.new(App) { def call(env); raise NotImplementedError; end }.new
-        explosive = ConnectionManagement.new(app)
-        assert_raises(NotImplementedError) { explosive.call(@env) }
-        assert !ActiveRecord::Base.connection_handler.active_connections?
-      end
-
-      test "doesn't clear active connections when running in a test case" do
-        @env['rack.test'] = true
-        @management.call(@env)
-        assert ActiveRecord::Base.connection_handler.active_connections?
-      end
-
-      test "proxy is polite to it's body and responds to it" do
-        body = Class.new(String) { def to_path; "/path"; end }.new
-        app = lambda { |_| [200, {}, body] }
-        response_body = ConnectionManagement.new(app).call(@env)[2]
-        assert response_body.respond_to?(:to_path)
-        assert_equal response_body.to_path, "/path"
-      end
-    end
-  end
-end
+require "cases/helper"
+require "rack"
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionManagementTest < ActiveRecord::TestCase
+      self.use_transactional_tests = false
+
+      class App
+        attr_reader :calls
+        def initialize
+          @calls = []
+        end
+
+        def call(env)
+          @calls << env
+          [200, {}, ['hi mom']]
+        end
+      end
+
+      def setup
+        @env = {}
+        @app = App.new
+        @management = middleware(@app)
+
+        # make sure we have an active connection
+        assert ActiveRecord::Base.connection
+        assert ActiveRecord::Base.connection_handler.active_connections?
+      end
+
+      def test_app_delegation
+        manager = middleware(@app)
+
+        manager.call @env
+        assert_equal [@env], @app.calls
+      end
+
+      def test_body_responds_to_each
+        _, _, body = @management.call(@env)
+        bits = []
+        body.each { |bit| bits << bit }
+        assert_equal ['hi mom'], bits
+      end
+
+      def test_connections_are_cleared_after_body_close
+        _, _, body = @management.call(@env)
+        body.close
+        assert !ActiveRecord::Base.connection_handler.active_connections?
+      end
+
+      def test_active_connections_are_not_cleared_on_body_close_during_transaction
+        ActiveRecord::Base.transaction do
+          _, _, body = @management.call(@env)
+          body.close
+          assert ActiveRecord::Base.connection_handler.active_connections?
+        end
+      end
+
+      def test_connections_closed_if_exception
+        app       = Class.new(App) { def call(env); raise NotImplementedError; end }.new
+        explosive = middleware(app)
+        assert_raises(NotImplementedError) { explosive.call(@env) }
+        assert !ActiveRecord::Base.connection_handler.active_connections?
+      end
+
+      def test_connections_not_closed_if_exception_inside_transaction
+        ActiveRecord::Base.transaction do
+          app               = Class.new(App) { def call(env); raise RuntimeError; end }.new
+          explosive         = middleware(app)
+          assert_raises(RuntimeError) { explosive.call(@env) }
+          assert ActiveRecord::Base.connection_handler.active_connections?
+        end
+      end
+
+      test "doesn't clear active connections when running in a test case" do
+        executor.wrap do
+          @management.call(@env)
+          assert ActiveRecord::Base.connection_handler.active_connections?
+        end
+      end
+
+      test "proxy is polite to its body and responds to it" do
+        body = Class.new(String) { def to_path; "/path"; end }.new
+        app = lambda { |_| [200, {}, body] }
+        response_body = middleware(app).call(@env)[2]
+        assert response_body.respond_to?(:to_path)
+        assert_equal "/path", response_body.to_path
+      end
+
+      test "doesn't mutate the original response" do
+        original_response = [200, {}, 'hi']
+        app = lambda { |_| original_response }
+        middleware(app).call(@env)[2]
+        assert_equal 'hi', original_response.last
+      end
+
+      private
+        def executor
+          @executor ||= Class.new(ActiveSupport::Executor).tap do |exe|
+            ActiveRecord::QueryCache.install_executor_hooks(exe)
+          end
+        end
+
+        def middleware(app)
+          lambda do |env|
+            a, b, c = executor.wrap { app.call(env) }
+            [a, b, Rack::BodyProxy.new(c) { }]
+          end
+        end
+    end
+  end
+end

data/test/cases/connection_pool_test.rb

@@ -1,346 +1,521 @@
-require "cases/helper"
-require 'active_support/concurrency/latch'
-
-module ActiveRecord
-  module ConnectionAdapters
-    class ConnectionPoolTest < ActiveRecord::TestCase
-      attr_reader :pool
-
-      def setup
-        super
-
-        # Keep a duplicate pool so we do not bother others
-        @pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
-
-        if in_memory_db?
-          # Separate connections to an in-memory database create an entirely new database,
-          # with an empty schema etc, so we just stub out this schema on the fly.
-          @pool.with_connection do |connection|
-            connection.create_table :posts do |t|
-              t.integer :cololumn
-            end
-          end
-        end
-      end
-
-      teardown do
-        @pool.disconnect!
-      end
-
-      def active_connections(pool)
-        pool.connections.find_all(&:in_use?)
-      end
-
-      def test_checkout_after_close
-        connection = pool.connection
-        assert connection.in_use?
-
-        connection.close
-        assert !connection.in_use?
-
-        assert pool.connection.in_use?
-      end
-
-      def test_released_connection_moves_between_threads
-        thread_conn = nil
-
-        Thread.new {
-          pool.with_connection do |conn|
-            thread_conn = conn
-          end
-        }.join
-
-        assert thread_conn
-
-        Thread.new {
-          pool.with_connection do |conn|
-            assert_equal thread_conn, conn
-          end
-        }.join
-      end
-
-      def test_with_connection
-        assert_equal 0, active_connections(pool).size
-
-        main_thread = pool.connection
-        assert_equal 1, active_connections(pool).size
-
-        Thread.new {
-          pool.with_connection do |conn|
-            assert conn
-            assert_equal 2, active_connections(pool).size
-          end
-          assert_equal 1, active_connections(pool).size
-        }.join
-
-        main_thread.close
-        assert_equal 0, active_connections(pool).size
-      end
-
-      def test_active_connection_in_use
-        assert !pool.active_connection?
-        main_thread = pool.connection
-
-        assert pool.active_connection?
-
-        main_thread.close
-
-        assert !pool.active_connection?
-      end
-
-      def test_full_pool_exception
-        @pool.size.times { @pool.checkout }
-        assert_raises(ConnectionTimeoutError) do
-          @pool.checkout
-        end
-      end
-
-      def test_full_pool_blocks
-        cs = @pool.size.times.map { @pool.checkout }
-        t = Thread.new { @pool.checkout }
-
-        # make sure our thread is in the timeout section
-        Thread.pass until t.status == "sleep"
-
-        connection = cs.first
-        connection.close
-        assert_equal connection, t.join.value
-      end
-
-      def test_removing_releases_latch
-        cs = @pool.size.times.map { @pool.checkout }
-        t = Thread.new { @pool.checkout }
-
-        # make sure our thread is in the timeout section
-        Thread.pass until t.status == "sleep"
-
-        connection = cs.first
-        @pool.remove connection
-        assert_respond_to t.join.value, :execute
-        connection.close
-      end
-
-      def test_reap_and_active
-        @pool.checkout
-        @pool.checkout
-        @pool.checkout
-
-        connections = @pool.connections.dup
-
-        @pool.reap
-
-        assert_equal connections.length, @pool.connections.length
-      end
-
-      def test_reap_inactive
-        ready = ActiveSupport::Concurrency::Latch.new
-        @pool.checkout
-        child = Thread.new do
-          @pool.checkout
-          @pool.checkout
-          ready.release
-          Thread.stop
-        end
-        ready.await
-
-        assert_equal 3, active_connections(@pool).size
-
-        child.terminate
-        child.join
-        @pool.reap
-
-        assert_equal 1, active_connections(@pool).size
-      ensure
-        @pool.connections.each(&:close)
-      end
-
-      def test_remove_connection
-        conn = @pool.checkout
-        assert conn.in_use?
-
-        length = @pool.connections.length
-        @pool.remove conn
-        assert conn.in_use?
-        assert_equal(length - 1, @pool.connections.length)
-      ensure
-        conn.close
-      end
-
-      def test_remove_connection_for_thread
-        conn = @pool.connection
-        @pool.remove conn
-        assert_not_equal(conn, @pool.connection)
-      ensure
-        conn.close if conn
-      end
-
-      def test_active_connection?
-        assert !@pool.active_connection?
-        assert @pool.connection
-        assert @pool.active_connection?
-        @pool.release_connection
-        assert !@pool.active_connection?
-      end
-
-      def test_checkout_behaviour
-        pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
-        connection = pool.connection
-        assert_not_nil connection
-        threads = []
-        4.times do |i|
-          threads << Thread.new(i) do
-            connection = pool.connection
-            assert_not_nil connection
-            connection.close
-          end
-        end
-
-        threads.each(&:join)
-
-        Thread.new do
-          assert pool.connection
-          pool.connection.close
-        end.join
-      end
-
-      # The connection pool is "fair" if threads waiting for
-      # connections receive them the order in which they began
-      # waiting.  This ensures that we don't timeout one HTTP request
-      # even while well under capacity in a multi-threaded environment
-      # such as a Java servlet container.
-      #
-      # We don't need strict fairness: if two connections become
-      # available at the same time, it's fine of two threads that were
-      # waiting acquire the connections out of order.
-      #
-      # Thus this test prepares waiting threads and then trickles in
-      # available connections slowly, ensuring the wakeup order is
-      # correct in this case.
-      def test_checkout_fairness
-        @pool.instance_variable_set(:@size, 10)
-        expected = (1..@pool.size).to_a.freeze
-        # check out all connections so our threads start out waiting
-        conns = expected.map { @pool.checkout }
-        mutex = Mutex.new
-        order = []
-        errors = []
-
-        threads = expected.map do |i|
-          t = Thread.new {
-            begin
-              @pool.checkout # never checked back in
-              mutex.synchronize { order << i }
-            rescue => e
-              mutex.synchronize { errors << e }
-            end
-          }
-          Thread.pass until t.status == "sleep"
-          t
-        end
-
-        # this should wake up the waiting threads one by one in order
-        conns.each { |conn| @pool.checkin(conn); sleep 0.1 }
-
-        threads.each(&:join)
-
-        raise errors.first if errors.any?
-
-        assert_equal(expected, order)
-      end
-
-      # As mentioned in #test_checkout_fairness, we don't care about
-      # strict fairness.  This test creates two groups of threads:
-      # group1 whose members all start waiting before any thread in
-      # group2.  Enough connections are checked in to wakeup all
-      # group1 threads, and the fact that only group1 and no group2
-      # threads acquired a connection is enforced.
-      def test_checkout_fairness_by_group
-        @pool.instance_variable_set(:@size, 10)
-        # take all the connections
-        conns = (1..10).map { @pool.checkout }
-        mutex = Mutex.new
-        successes = []    # threads that successfully got a connection
-        errors = []
-
-        make_thread = proc do |i|
-          t = Thread.new {
-            begin
-              @pool.checkout # never checked back in
-              mutex.synchronize { successes << i }
-            rescue => e
-              mutex.synchronize { errors << e }
-            end
-          }
-          Thread.pass until t.status == "sleep"
-          t
-        end
-
-        # all group1 threads start waiting before any in group2
-        group1 = (1..5).map(&make_thread)
-        group2 = (6..10).map(&make_thread)
-
-        # checkin n connections back to the pool
-        checkin = proc do |n|
-          n.times do
-            c = conns.pop
-            @pool.checkin(c)
-          end
-        end
-
-        checkin.call(group1.size)         # should wake up all group1
-
-        loop do
-          sleep 0.1
-          break if mutex.synchronize { (successes.size + errors.size) == group1.size }
-        end
-
-        winners = mutex.synchronize { successes.dup }
-        checkin.call(group2.size)         # should wake up everyone remaining
-
-        group1.each(&:join)
-        group2.each(&:join)
-
-        assert_equal((1..group1.size).to_a, winners.sort)
-
-        if errors.any?
-          raise errors.first
-        end
-      end
-
-      def test_automatic_reconnect=
-        pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
-        assert pool.automatic_reconnect
-        assert pool.connection
-
-        pool.disconnect!
-        assert pool.connection
-
-        pool.disconnect!
-        pool.automatic_reconnect = false
-
-        assert_raises(ConnectionNotEstablished) do
-          pool.connection
-        end
-
-        assert_raises(ConnectionNotEstablished) do
-          pool.with_connection
-        end
-      end
-
-      def test_pool_sets_connection_visitor
-        assert @pool.connection.visitor.is_a?(Arel::Visitors::ToSql)
-      end
-
-      # make sure exceptions are thrown when establish_connection
-      # is called with an anonymous class
-      def test_anonymous_class_exception
-        anonymous = Class.new(ActiveRecord::Base)
-        handler = ActiveRecord::Base.connection_handler
-
-        assert_raises(RuntimeError) {
-          handler.establish_connection anonymous, nil
-        }
-      end
-    end
-  end
-end
+require "cases/helper"
+require 'concurrent/atomic/count_down_latch'
+
+module ActiveRecord
+  module ConnectionAdapters
+    class ConnectionPoolTest < ActiveRecord::TestCase
+      attr_reader :pool
+
+      def setup
+        super
+
+        # Keep a duplicate pool so we do not bother others
+        @pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
+
+        if in_memory_db?
+          # Separate connections to an in-memory database create an entirely new database,
+          # with an empty schema etc, so we just stub out this schema on the fly.
+          @pool.with_connection do |connection|
+            connection.create_table :posts do |t|
+              t.integer :cololumn
+            end
+          end
+        end
+      end
+
+      teardown do
+        @pool.disconnect!
+      end
+
+      def active_connections(pool)
+        pool.connections.find_all(&:in_use?)
+      end
+
+      def test_checkout_after_close
+        connection = pool.connection
+        assert connection.in_use?
+
+        connection.close
+        assert !connection.in_use?
+
+        assert pool.connection.in_use?
+      end
+
+      def test_released_connection_moves_between_threads
+        thread_conn = nil
+
+        Thread.new {
+          pool.with_connection do |conn|
+            thread_conn = conn
+          end
+        }.join
+
+        assert thread_conn
+
+        Thread.new {
+          pool.with_connection do |conn|
+            assert_equal thread_conn, conn
+          end
+        }.join
+      end
+
+      def test_with_connection
+        assert_equal 0, active_connections(pool).size
+
+        main_thread = pool.connection
+        assert_equal 1, active_connections(pool).size
+
+        Thread.new {
+          pool.with_connection do |conn|
+            assert conn
+            assert_equal 2, active_connections(pool).size
+          end
+          assert_equal 1, active_connections(pool).size
+        }.join
+
+        main_thread.close
+        assert_equal 0, active_connections(pool).size
+      end
+
+      def test_active_connection_in_use
+        assert !pool.active_connection?
+        main_thread = pool.connection
+
+        assert pool.active_connection?
+
+        main_thread.close
+
+        assert !pool.active_connection?
+      end
+
+      def test_full_pool_exception
+        @pool.size.times { @pool.checkout }
+        assert_raises(ConnectionTimeoutError) do
+          @pool.checkout
+        end
+      end
+
+      def test_full_pool_blocks
+        cs = @pool.size.times.map { @pool.checkout }
+        t = Thread.new { @pool.checkout }
+
+        # make sure our thread is in the timeout section
+        Thread.pass until @pool.num_waiting_in_queue == 1
+
+        connection = cs.first
+        connection.close
+        assert_equal connection, t.join.value
+      end
+
+      def test_removing_releases_latch
+        cs = @pool.size.times.map { @pool.checkout }
+        t = Thread.new { @pool.checkout }
+
+        # make sure our thread is in the timeout section
+        Thread.pass until @pool.num_waiting_in_queue == 1
+
+        connection = cs.first
+        @pool.remove connection
+        assert_respond_to t.join.value, :execute
+        connection.close
+      end
+
+      def test_reap_and_active
+        @pool.checkout
+        @pool.checkout
+        @pool.checkout
+
+        connections = @pool.connections.dup
+
+        @pool.reap
+
+        assert_equal connections.length, @pool.connections.length
+      end
+
+      def test_reap_inactive
+        ready = Concurrent::CountDownLatch.new
+        @pool.checkout
+        child = Thread.new do
+          @pool.checkout
+          @pool.checkout
+          ready.count_down
+          Thread.stop
+        end
+        ready.wait
+
+        assert_equal 3, active_connections(@pool).size
+
+        child.terminate
+        child.join
+        @pool.reap
+
+        assert_equal 1, active_connections(@pool).size
+      ensure
+        @pool.connections.each { |conn| conn.close if conn.in_use? }
+      end
+
+      def test_remove_connection
+        conn = @pool.checkout
+        assert conn.in_use?
+
+        length = @pool.connections.length
+        @pool.remove conn
+        assert conn.in_use?
+        assert_equal(length - 1, @pool.connections.length)
+      ensure
+        conn.close
+      end
+
+      def test_remove_connection_for_thread
+        conn = @pool.connection
+        @pool.remove conn
+        assert_not_equal(conn, @pool.connection)
+      ensure
+        conn.close if conn
+      end
+
+      def test_active_connection?
+        assert !@pool.active_connection?
+        assert @pool.connection
+        assert @pool.active_connection?
+        @pool.release_connection
+        assert !@pool.active_connection?
+      end
+
+      def test_checkout_behaviour
+        pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
+        main_connection = pool.connection
+        assert_not_nil main_connection
+        threads = []
+        4.times do |i|
+          threads << Thread.new(i) do
+            thread_connection = pool.connection
+            assert_not_nil thread_connection
+            thread_connection.close
+          end
+        end
+
+        threads.each(&:join)
+
+        Thread.new do
+          assert pool.connection
+          pool.connection.close
+        end.join
+      end
+
+      # The connection pool is "fair" if threads waiting for
+      # connections receive them in the order in which they began
+      # waiting.  This ensures that we don't timeout one HTTP request
+      # even while well under capacity in a multi-threaded environment
+      # such as a Java servlet container.
+      #
+      # We don't need strict fairness: if two connections become
+      # available at the same time, it's fine if two threads that were
+      # waiting acquire the connections out of order.
+      #
+      # Thus this test prepares waiting threads and then trickles in
+      # available connections slowly, ensuring the wakeup order is
+      # correct in this case.
+      def test_checkout_fairness
+        @pool.instance_variable_set(:@size, 10)
+        expected = (1..@pool.size).to_a.freeze
+        # check out all connections so our threads start out waiting
+        conns = expected.map { @pool.checkout }
+        mutex = Mutex.new
+        order = []
+        errors = []
+
+        threads = expected.map do |i|
+          t = Thread.new {
+            begin
+              @pool.checkout # never checked back in
+              mutex.synchronize { order << i }
+            rescue => e
+              mutex.synchronize { errors << e }
+            end
+          }
+          Thread.pass until @pool.num_waiting_in_queue == i
+          t
+        end
+
+        # this should wake up the waiting threads one by one in order
+        conns.each { |conn| @pool.checkin(conn); sleep 0.1 }
+
+        threads.each(&:join)
+
+        raise errors.first if errors.any?
+
+        assert_equal(expected, order)
+      end
+
+      # As mentioned in #test_checkout_fairness, we don't care about
+      # strict fairness.  This test creates two groups of threads:
+      # group1 whose members all start waiting before any thread in
+      # group2.  Enough connections are checked in to wakeup all
+      # group1 threads, and the fact that only group1 and no group2
+      # threads acquired a connection is enforced.
+      def test_checkout_fairness_by_group
+        @pool.instance_variable_set(:@size, 10)
+        # take all the connections
+        conns = (1..10).map { @pool.checkout }
+        mutex = Mutex.new
+        successes = []    # threads that successfully got a connection
+        errors = []
+
+        make_thread = proc do |i|
+          t = Thread.new {
+            begin
+              @pool.checkout # never checked back in
+              mutex.synchronize { successes << i }
+            rescue => e
+              mutex.synchronize { errors << e }
+            end
+          }
+          Thread.pass until @pool.num_waiting_in_queue == i
+          t
+        end
+
+        # all group1 threads start waiting before any in group2
+        group1 = (1..5).map(&make_thread)
+        group2 = (6..10).map(&make_thread)
+
+        # checkin n connections back to the pool
+        checkin = proc do |n|
+          n.times do
+            c = conns.pop
+            @pool.checkin(c)
+          end
+        end
+
+        checkin.call(group1.size)         # should wake up all group1
+
+        loop do
+          sleep 0.1
+          break if mutex.synchronize { (successes.size + errors.size) == group1.size }
+        end
+
+        winners = mutex.synchronize { successes.dup }
+        checkin.call(group2.size)         # should wake up everyone remaining
+
+        group1.each(&:join)
+        group2.each(&:join)
+
+        assert_equal((1..group1.size).to_a, winners.sort)
+
+        if errors.any?
+          raise errors.first
+        end
+      end
+
+      def test_automatic_reconnect=
+        pool = ConnectionPool.new ActiveRecord::Base.connection_pool.spec
+        assert pool.automatic_reconnect
+        assert pool.connection
+
+        pool.disconnect!
+        assert pool.connection
+
+        pool.disconnect!
+        pool.automatic_reconnect = false
+
+        assert_raises(ConnectionNotEstablished) do
+          pool.connection
+        end
+
+        assert_raises(ConnectionNotEstablished) do
+          pool.with_connection
+        end
+      end
+
+      def test_pool_sets_connection_visitor
+        assert @pool.connection.visitor.is_a?(Arel::Visitors::ToSql)
+      end
+
+      # make sure exceptions are thrown when establish_connection
+      # is called with an anonymous class
+      def test_anonymous_class_exception
+        anonymous = Class.new(ActiveRecord::Base)
+
+        assert_raises(RuntimeError) do
+          anonymous.establish_connection
+        end
+      end
+
+      def test_pool_sets_connection_schema_cache
+        connection = pool.checkout
+        schema_cache = SchemaCache.new connection
+        schema_cache.add(:posts)
+        pool.schema_cache = schema_cache
+
+        pool.with_connection do |conn|
+          assert_not_same pool.schema_cache, conn.schema_cache
+          assert_equal pool.schema_cache.size, conn.schema_cache.size
+          assert_same pool.schema_cache.columns(:posts), conn.schema_cache.columns(:posts)
+        end
+
+        pool.checkin connection
+      end
+
+      def test_concurrent_connection_establishment
+        assert_operator @pool.connections.size, :<=, 1
+
+        all_threads_in_new_connection = Concurrent::CountDownLatch.new(@pool.size - @pool.connections.size)
+        all_go                        = Concurrent::CountDownLatch.new
+
+        @pool.singleton_class.class_eval do
+          define_method(:new_connection) do
+            all_threads_in_new_connection.count_down
+            all_go.wait
+            super()
+          end
+        end
+
+        connecting_threads = []
+        @pool.size.times do
+          connecting_threads << Thread.new { @pool.checkout }
+        end
+
+        begin
+          Timeout.timeout(5) do
+            # the kernel of the whole test is here, everything else is just scaffolding,
+            # this latch will not be released unless conn. pool allows for concurrent
+            # connection creation
+            all_threads_in_new_connection.wait
+          end
+        rescue Timeout::Error
+          flunk 'pool unable to establish connections concurrently or implementation has ' <<
+                'changed, this test then needs to patch a different :new_connection method'
+        ensure
+          # clean up the threads
+          all_go.count_down
+          connecting_threads.map(&:join)
+        end
+      end
+
+      def test_non_bang_disconnect_and_clear_reloadable_connections_throw_exception_if_threads_dont_return_their_conns
+        @pool.checkout_timeout = 0.001 # no need to delay test suite by waiting the whole full default timeout
+        [:disconnect, :clear_reloadable_connections].each do |group_action_method|
+          @pool.with_connection do |connection|
+            assert_raises(ExclusiveConnectionTimeoutError) do
+              Thread.new { @pool.send(group_action_method) }.join
+            end
+          end
+        end
+      end
+
+      def test_disconnect_and_clear_reloadable_connections_attempt_to_wait_for_threads_to_return_their_conns
+        [:disconnect, :disconnect!, :clear_reloadable_connections, :clear_reloadable_connections!].each do |group_action_method|
+          begin
+            thread = timed_join_result = nil
+            @pool.with_connection do |connection|
+              thread = Thread.new { @pool.send(group_action_method) }
+
+              # give the other `thread` some time to get stuck in `group_action_method`
+              timed_join_result = thread.join(0.3)
+              # thread.join # => `nil` means the other thread hasn't finished running and is still waiting for us to
+              # release our connection
+              assert_nil timed_join_result
+
+              # assert that since this is within default timeout our connection hasn't been forcefully taken away from us
+              assert @pool.active_connection?
+            end
+          ensure
+            thread.join if thread && !timed_join_result # clean up the other thread
+          end
+        end
+      end
+
+      def test_bang_versions_of_disconnect_and_clear_reloadable_connections_if_unable_to_aquire_all_connections_proceed_anyway
+        @pool.checkout_timeout = 0.001 # no need to delay test suite by waiting the whole full default timeout
+        [:disconnect!, :clear_reloadable_connections!].each do |group_action_method|
+          @pool.with_connection do |connection|
+            Thread.new { @pool.send(group_action_method) }.join
+            # assert connection has been forcefully taken away from us
+            assert_not @pool.active_connection?
+
+            # make a new connection for with_connection to clean up
+            @pool.connection
+          end
+        end
+      end
+
+      def test_disconnect_and_clear_reloadable_connections_are_able_to_preempt_other_waiting_threads
+        with_single_connection_pool do |pool|
+          [:disconnect, :disconnect!, :clear_reloadable_connections, :clear_reloadable_connections!].each do |group_action_method|
+            conn               = pool.connection # drain the only available connection
+            second_thread_done = Concurrent::CountDownLatch.new
+
+            # create a first_thread and let it get into the FIFO queue first
+            first_thread = Thread.new do
+              pool.with_connection { second_thread_done.wait }
+            end
+
+            # wait for first_thread to get in queue
+            Thread.pass until pool.num_waiting_in_queue == 1
+
+            # create a different, later thread, that will attempt to do a "group action",
+            # but because of the group action semantics it should be able to preempt the
+            # first_thread when a connection is made available
+            second_thread = Thread.new do
+              pool.send(group_action_method)
+              second_thread_done.count_down
+            end
+
+            # wait for second_thread to get in queue
+            Thread.pass until pool.num_waiting_in_queue == 2
+
+            # return the only available connection
+            pool.checkin(conn)
+
+            # if the second_thread is not able to preempt the first_thread,
+            # they will temporarily (until either of them timeouts with ConnectionTimeoutError)
+            # deadlock and a join(2) timeout will be reached
+            failed = true unless second_thread.join(2)
+
+            #--- post test clean up start
+            second_thread_done.count_down if failed
+
+            first_thread.join
+            second_thread.join
+            #--- post test clean up end
+
+            flunk "#{group_action_method} is not able to preempt other waiting threads" if failed
+          end
+        end
+      end
+
+      def test_clear_reloadable_connections_creates_new_connections_for_waiting_threads_if_necessary
+        with_single_connection_pool do |pool|
+          conn = pool.connection # drain the only available connection
+          def conn.requires_reloading? # make sure it gets removed from the pool by clear_reloadable_connections
+            true
+          end
+
+          stuck_thread = Thread.new do
+            pool.with_connection {}
+          end
+
+          # wait for stuck_thread to get in queue
+          Thread.pass until pool.num_waiting_in_queue == 1
+
+          pool.clear_reloadable_connections
+
+          unless stuck_thread.join(2)
+            flunk 'clear_reloadable_connections must not let other connection waiting threads get stuck in queue'
+          end
+
+          assert_equal 0, pool.num_waiting_in_queue
+        end
+      end
+
+      private
+      def with_single_connection_pool
+        one_conn_spec = ActiveRecord::Base.connection_pool.spec.dup
+        one_conn_spec.config[:pool] = 1 # this is safe to do, because .dupped ConnectionSpecification also auto-dups its config
+        yield(pool = ConnectionPool.new(one_conn_spec))
+      ensure
+        pool.disconnect! if pool
+      end
+    end
+  end
+end