connection_pool 2.2.5 → 2.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: '0993b72c233b027a1229d532a126b4a1623ef3f146a7b56502c539084f9a228d'
-  data.tar.gz: 274efa04fc445ca0044f62da29484a4ee9fb5e02b5f213fb873fedfd63cadff0
+  metadata.gz: f55833e24bd0a92578d10d974f63342be9abd52ed1736d0821feb0f48f05cabe
+  data.tar.gz: cb5ad1fa9d0e79ec9eef583e6a8771f1e0208d5c0daa52d31a75523e3ccf3da1
 SHA512:
-  metadata.gz: 17c5bea167386115e8672b394138e0f66b55e6371b803dcfee7be08e51c84353aa9cd0257f169ae04053bc95be6b0c9b06576579f4915e68271146b1c9d602a5
-  data.tar.gz: 4eeccb9eaf397e8e386a41f81005b10d43d7441297661ab0d7656b6be30ac7ff1e751a95ed5c5b5a412124a29a0af3f5c90ae2882d70d3fa29d9dc8b2df412e3
+  metadata.gz: 37b6ee51a8563cd84846ac6647507103ff5a689a28e0a4daf203fdbfac5d7bb09a1416e7eaa71f674522ca9062a05557146182008af016130cbf7eda02eee21d
+  data.tar.gz: bba4be5b638f77942e9978328b7a247f5638c4860c263dc58277d39a4239bf3520bfebf14547e3cc8436e85c1be1b88a24246f113bc4038f699229ce41890e04

data/Changes.md

@@ -1,5 +1,11 @@
 # connection_pool Changelog
 
+2.3.0
+------
+
+- Minimum Ruby version is now 2.5.0
+- Add pool size to TimeoutError message
+
 2.2.5
 ------
 

data/README.md

@@ -4,16 +4,14 @@ connection\_pool
 
 Generic connection pooling for Ruby.
 
-MongoDB has its own connection pool.  ActiveRecord has its own connection pool.
-This is a generic connection pool that can be used with anything, e.g. Redis,
-Dalli and other Ruby network clients.
-
+MongoDB has its own connection pool.
+ActiveRecord has its own connection pool.
+This is a generic connection pool that can be used with anything, e.g. Redis, Dalli and other Ruby network clients.
 
 Usage
 -----
 
-Create a pool of objects to share amongst the fibers or threads in your Ruby
-application:
+Create a pool of objects to share amongst the fibers or threads in your Ruby application:
 
 ``` ruby
 $memcached = ConnectionPool.new(size: 5, timeout: 5) { Dalli::Client.new }
@@ -28,11 +26,12 @@ end
 ```
 
 If all the objects in the connection pool are in use, `with` will block
-until one becomes available.  If no object is available within `:timeout` seconds,
-`with` will raise a `Timeout::Error`.
+until one becomes available.
+If no object is available within `:timeout` seconds,
+`with` will raise a `ConnectionPool::TimeoutError` (a subclass of `Timeout::Error`).
 
 You can also use `ConnectionPool#then` to support _both_ a
-connection pool and a raw client (requires Ruby 2.5+).
+connection pool and a raw client.
 
 ```ruby
 # Compatible with a raw Redis::Client, and ConnectionPool Redis
@@ -48,15 +47,14 @@ end
 ```
 
 This will only modify the resource-get timeout for this particular
-invocation. This is useful if you want to fail-fast on certain non critical
-sections when a resource is not available, or conversely if you are comfortable
-blocking longer on a particular resource. This is not implemented in the below
-`ConnectionPool::Wrapper` class.
+invocation.
+This is useful if you want to fail-fast on certain non critical
+sections when a resource is not available, or conversely if you are comfortable blocking longer on a particular resource.
+This is not implemented in the `ConnectionPool::Wrapper` class.
 
 ## Migrating to a Connection Pool
 
-You can use `ConnectionPool::Wrapper` to wrap a single global connection,
-making it easier to migrate existing connection code over time:
+You can use `ConnectionPool::Wrapper` to wrap a single global connection, making it easier to migrate existing connection code over time:
 
 ``` ruby
 $redis = ConnectionPool::Wrapper.new(size: 5, timeout: 3) { Redis.new }
@@ -64,10 +62,8 @@ $redis.sadd('foo', 1)
 $redis.smembers('foo')
 ```
 
-The wrapper uses `method_missing` to checkout a connection, run the requested
-method and then immediately check the connection back into the pool.  It's
-**not** high-performance so you'll want to port your performance sensitive code
-to use `with` as soon as possible.
+The wrapper uses `method_missing` to checkout a connection, run the requested method and then immediately check the connection back into the pool.
+It's **not** high-performance so you'll want to port your performance sensitive code to use `with` as soon as possible.
 
 ``` ruby
 $redis.with do |conn|
@@ -76,31 +72,26 @@ $redis.with do |conn|
 end
 ```
 
-Once you've ported your entire system to use `with`, you can simply remove
-`Wrapper` and use the simpler and faster `ConnectionPool`.
+Once you've ported your entire system to use `with`, you can simply remove `Wrapper` and use the simpler and faster `ConnectionPool`.
 
 
 ## Shutdown
 
 You can shut down a ConnectionPool instance once it should no longer be used.
-Further checkout attempts will immediately raise an error but existing checkouts
-will work.
+Further checkout attempts will immediately raise an error but existing checkouts will work.
 
 ```ruby
 cp = ConnectionPool.new { Redis.new }
-cp.shutdown { |conn| conn.quit }
+cp.shutdown { |c| c.close }
 ```
 
 Shutting down a connection pool will block until all connections are checked in and closed.
-**Note that shutting down is completely optional**; Ruby's garbage collector will reclaim
-unreferenced pools under normal circumstances.
+**Note that shutting down is completely optional**; Ruby's garbage collector will reclaim unreferenced pools under normal circumstances.
 
 ## Reload
 
-You can reload a ConnectionPool instance in the case it is desired to close all
-connections to the pool and, unlike `shutdown`, afterwards recreate connections
-so the pool may continue to be used. Reloading may be useful after forking the
-process.
+You can reload a ConnectionPool instance in the case it is desired to close all connections to the pool and, unlike `shutdown`, afterwards recreate connections so the pool may continue to be used.
+Reloading may be useful after forking the process.
 
 ```ruby
 cp = ConnectionPool.new { Redis.new }
@@ -108,8 +99,7 @@ cp.reload { |conn| conn.quit }
 cp.with { |conn| conn.get('some-count') }
 ```
 
-Like `shutdown`, this will block until all connections are checked in and
-closed.
+Like `shutdown`, this will block until all connections are checked in and closed.
 
 ## Current State
 

data/connection_pool.gemspec

@@ -9,13 +9,14 @@ Gem::Specification.new do |s|
   s.homepage = "https://github.com/mperham/connection_pool"
   s.description = s.summary = "Generic connection pool for Ruby"
 
-  s.files = `git ls-files`.split("\n")
-  s.test_files = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables = `git ls-files -- bin/*`.split("\n").map { |f| File.basename(f) }
+  s.files = ["Changes.md", "LICENSE", "README.md", "connection_pool.gemspec",
+    "lib/connection_pool.rb", "lib/connection_pool/timed_stack.rb",
+    "lib/connection_pool/version.rb", "lib/connection_pool/wrapper.rb"]
+  s.executables = []
   s.require_paths = ["lib"]
   s.license = "MIT"
   s.add_development_dependency "bundler"
   s.add_development_dependency "minitest", ">= 5.0.0"
   s.add_development_dependency "rake"
-  s.required_ruby_version = ">= 2.2.0"
+  s.required_ruby_version = ">= 2.5.0"
 end

data/lib/connection_pool/timed_stack.rb

@@ -29,8 +29,8 @@ class ConnectionPool::TimedStack
     @created = 0
     @que = []
     @max = size
-    @mutex = Mutex.new
-    @resource = ConditionVariable.new
+    @mutex = Thread::Mutex.new
+    @resource = Thread::ConditionVariable.new
     @shutdown_block = nil
   end
 
@@ -49,7 +49,7 @@ class ConnectionPool::TimedStack
       @resource.broadcast
     end
   end
-  alias << push
+  alias_method :<<, :push
 
   ##
   # Retrieves a connection from the stack.  If a connection is available it is
@@ -74,7 +74,7 @@ class ConnectionPool::TimedStack
         return connection if connection
 
         to_wait = deadline - current_time
-        raise ConnectionPool::TimeoutError, "Waited #{timeout} sec" if to_wait <= 0
+        raise ConnectionPool::TimeoutError, "Waited #{timeout} sec, #{length}/#{@max} available" if to_wait <= 0
         @resource.wait(@mutex, to_wait)
       end
     end
@@ -87,7 +87,7 @@ class ConnectionPool::TimedStack
   # +:reload+ is +true+.
 
   def shutdown(reload: false, &block)
-    raise ArgumentError, "shutdown must receive a block" unless block_given?
+    raise ArgumentError, "shutdown must receive a block" unless block
 
     @mutex.synchronize do
       @shutdown_block = block

data/lib/connection_pool/version.rb

@@ -1,3 +1,3 @@
 class ConnectionPool
-  VERSION = "2.2.5"
+  VERSION = "2.3.0"
 end

data/lib/connection_pool/wrapper.rb

@@ -30,7 +30,6 @@ class ConnectionPool
       METHODS.include?(id) || with { |c| c.respond_to?(id, *args) }
     end
 
-    # rubocop:disable Style/MethodMissingSuper
     # rubocop:disable Style/MissingRespondToMissing
     if ::RUBY_VERSION >= "3.0.0"
       def method_missing(name, *args, **kwargs, &block)

data/lib/connection_pool.rb

@@ -1,9 +1,11 @@
 require "timeout"
-require "connection_pool/version"
+require_relative "connection_pool/version"
 
 class ConnectionPool
   class Error < ::RuntimeError; end
+
   class PoolShuttingDownError < ::ConnectionPool::Error; end
+
   class TimeoutError < ::Timeout::Error; end
 end
 
@@ -67,7 +69,7 @@ class ConnectionPool
       end
     end
   end
-  alias then with
+  alias_method :then, :with
 
   def checkout(options = {})
     if ::Thread.current[@key]
@@ -122,5 +124,5 @@ class ConnectionPool
   end
 end
 
-require "connection_pool/timed_stack"
-require "connection_pool/wrapper"
+require_relative "connection_pool/timed_stack"
+require_relative "connection_pool/wrapper"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: connection_pool
 version: !ruby/object:Gem::Version
-  version: 2.2.5
+  version: 2.3.0
 platform: ruby
 authors:
 - Mike Perham
@@ -9,7 +9,7 @@ authors:
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-04-14 00:00:00.000000000 Z
+date: 2022-09-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -61,21 +61,14 @@ executables: []
 extensions: []
 extra_rdoc_files: []
 files:
-- ".github/workflows/ci.yml"
-- ".gitignore"
 - Changes.md
-- Gemfile
 - LICENSE
 - README.md
-- Rakefile
 - connection_pool.gemspec
 - lib/connection_pool.rb
 - lib/connection_pool/timed_stack.rb
 - lib/connection_pool/version.rb
 - lib/connection_pool/wrapper.rb
-- test/helper.rb
-- test/test_connection_pool.rb
-- test/test_connection_pool_timed_stack.rb
 homepage: https://github.com/mperham/connection_pool
 licenses:
 - MIT
@@ -88,18 +81,15 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.2.0
+      version: 2.5.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
+rubygems_version: 3.2.32
 signing_key:
 specification_version: 4
 summary: Generic connection pool for Ruby
-test_files:
-- test/helper.rb
-- test/test_connection_pool.rb
-- test/test_connection_pool_timed_stack.rb
+test_files: []

data/.github/workflows/ci.yml

@@ -1,26 +0,0 @@
-name: CI
-
-on: [push, pull_request]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-    continue-on-error: ${{ matrix.experimental }}
-    strategy:
-      fail-fast: false
-      matrix:
-        ruby: ["2.4", "2.5", "2.6", "2.7", "3.0", "jruby"]
-        experimental: [false]
-        include:
-        - ruby: "truffleruby"
-          experimental: true
-    steps:
-    - uses: actions/checkout@v2
-    - uses: ruby/setup-ruby@v1
-      with:
-        ruby-version: ${{matrix.ruby}}
-        bundler-cache: true
-
-    - name: Run tests
-      timeout-minutes: 5
-      run: ${{matrix.env}} bundle exec rake

data/.gitignore

@@ -1,4 +0,0 @@
-*.gem
-.bundle
-Gemfile.lock
-pkg/*

data/Gemfile

@@ -1,3 +0,0 @@
-source "https://rubygems.org"
-
-gemspec(development_group: :runtime)

data/Rakefile

@@ -1,6 +0,0 @@
-require "bundler/gem_tasks"
-
-require "rake/testtask"
-Rake::TestTask.new
-
-task default: :test

data/test/helper.rb

@@ -1,8 +0,0 @@
-gem "minitest"
-
-require "minitest/pride"
-require "minitest/autorun"
-
-$VERBOSE = 1
-
-require_relative "../lib/connection_pool"

data/test/test_connection_pool.rb

@@ -1,567 +0,0 @@
-require_relative "helper"
-
-class TestConnectionPool < Minitest::Test
-  class NetworkConnection
-    SLEEP_TIME = 0.1
-
-    def initialize
-      @x = 0
-    end
-
-    def do_something(*_args, increment: 1)
-      @x += increment
-      sleep SLEEP_TIME
-      @x
-    end
-
-    def do_something_with_positional_hash(options)
-      @x += options[:increment] || 1
-      sleep SLEEP_TIME
-      @x
-    end
-
-    def fast
-      @x += 1
-    end
-
-    def do_something_with_block
-      @x += yield
-      sleep SLEEP_TIME
-      @x
-    end
-
-    def respond_to?(method_id, *args)
-      method_id == :do_magic || super(method_id, *args)
-    end
-  end
-
-  class Recorder
-    def initialize
-      @calls = []
-    end
-
-    attr_reader :calls
-
-    def do_work(label)
-      @calls << label
-    end
-  end
-
-  def use_pool(pool, size)
-    Array.new(size) {
-      Thread.new do
-        pool.with { sleep }
-      end
-    }.each do |thread|
-      Thread.pass until thread.status == "sleep"
-    end
-  end
-
-  def kill_threads(threads)
-    threads.each do |thread|
-      thread.kill
-      thread.join
-    end
-  end
-
-  def test_basic_multithreaded_usage
-    pool_size = 5
-    pool = ConnectionPool.new(size: pool_size) { NetworkConnection.new }
-
-    start = Time.new
-
-    generations = 3
-
-    result = Array.new(pool_size * generations) {
-      Thread.new do
-        pool.with do |net|
-          net.do_something
-        end
-      end
-    }.map(&:value)
-
-    finish = Time.new
-
-    assert_equal((1..generations).cycle(pool_size).sort, result.sort)
-
-    assert_operator(finish - start, :>, generations * NetworkConnection::SLEEP_TIME)
-  end
-
-  def test_timeout
-    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
-    thread = Thread.new {
-      pool.with do |net|
-        net.do_something
-        sleep 0.01
-      end
-    }
-
-    Thread.pass while thread.status == "run"
-
-    assert_raises Timeout::Error do
-      pool.with { |net| net.do_something }
-    end
-
-    thread.join
-
-    pool.with do |conn|
-      refute_nil conn
-    end
-  end
-
-  def test_with
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-
-    pool.with do
-      Thread.new {
-        assert_raises Timeout::Error do
-          pool.checkout
-        end
-      }.join
-    end
-
-    assert Thread.new { pool.checkout }.join
-  end
-
-  def test_then
-    pool = ConnectionPool.new { Object.new }
-
-    assert_equal pool.method(:then), pool.method(:with)
-  end
-
-  def test_with_timeout
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-
-    assert_raises Timeout::Error do
-      Timeout.timeout(0.01) do
-        pool.with do |obj|
-          assert_equal 0, pool.available
-          sleep 0.015
-        end
-      end
-    end
-    assert_equal 1, pool.available
-  end
-
-  def test_invalid_size
-    assert_raises ArgumentError, TypeError do
-      ConnectionPool.new(timeout: 0, size: nil) { Object.new }
-    end
-    assert_raises ArgumentError, TypeError do
-      ConnectionPool.new(timeout: 0, size: "") { Object.new }
-    end
-  end
-
-  def test_handle_interrupt_ensures_checkin
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-    def pool.checkout(options)
-      sleep 0.015
-      super
-    end
-
-    did_something = false
-
-    action = lambda do
-      Timeout.timeout(0.01) do
-        pool.with do |obj|
-          did_something = true
-          # Timeout::Error will be triggered by any non-trivial Ruby code
-          # executed here since it couldn't be raised during checkout.
-          # It looks like setting the local variable above does not trigger
-          # the Timeout check in MRI 2.2.1.
-          obj.tap { obj.hash }
-        end
-      end
-    end
-
-    if RUBY_ENGINE == "ruby"
-      # These asserts rely on the Ruby implementation reaching `did_something =
-      # true` before the interrupt is detected by the thread. Interrupt
-      # detection timing is implementation-specific in practice, with JRuby,
-      # Rubinius, and TruffleRuby all having different interrupt timings to MRI.
-      # In fact they generally detect interrupts more quickly than MRI, so they
-      # may not reach `did_something = true` before detecting the interrupt.
-
-      assert_raises Timeout::Error, &action
-
-      assert did_something
-    else
-      action.call
-    end
-
-    assert_equal 1, pool.available
-  end
-
-  def test_explicit_return
-    pool = ConnectionPool.new(timeout: 0, size: 1) {
-      mock = Minitest::Mock.new
-      def mock.disconnect!
-        raise "should not disconnect upon explicit return"
-      end
-      mock
-    }
-
-    pool.with do |conn|
-      return true
-    end
-  end
-
-  def test_with_timeout_override
-    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
-
-    t = Thread.new {
-      pool.with do |net|
-        net.do_something
-        sleep 0.01
-      end
-    }
-
-    Thread.pass while t.status == "run"
-
-    assert_raises Timeout::Error do
-      pool.with { |net| net.do_something }
-    end
-
-    pool.with(timeout: 2 * NetworkConnection::SLEEP_TIME) do |conn|
-      refute_nil conn
-    end
-  end
-
-  def test_checkin
-    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
-    conn = pool.checkout
-
-    Thread.new {
-      assert_raises Timeout::Error do
-        pool.checkout
-      end
-    }.join
-
-    pool.checkin
-
-    assert_same conn, Thread.new { pool.checkout }.value
-  end
-
-  def test_returns_value
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-    assert_equal 1, pool.with { |o| 1 }
-  end
-
-  def test_checkin_never_checkout
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-
-    e = assert_raises(ConnectionPool::Error) { pool.checkin }
-    assert_equal "no connections are checked out", e.message
-  end
-
-  def test_checkin_no_current_checkout
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-
-    pool.checkout
-    pool.checkin
-
-    assert_raises ConnectionPool::Error do
-      pool.checkin
-    end
-  end
-
-  def test_checkin_twice
-    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
-
-    pool.checkout
-    pool.checkout
-
-    pool.checkin
-
-    Thread.new {
-      assert_raises Timeout::Error do
-        pool.checkout
-      end
-    }.join
-
-    pool.checkin
-
-    assert Thread.new { pool.checkout }.join
-  end
-
-  def test_checkout
-    pool = ConnectionPool.new(size: 1) { NetworkConnection.new }
-
-    conn = pool.checkout
-
-    assert_kind_of NetworkConnection, conn
-
-    assert_same conn, pool.checkout
-  end
-
-  def test_checkout_multithread
-    pool = ConnectionPool.new(size: 2) { NetworkConnection.new }
-    conn = pool.checkout
-
-    t = Thread.new {
-      pool.checkout
-    }
-
-    refute_same conn, t.value
-  end
-
-  def test_checkout_timeout
-    pool = ConnectionPool.new(timeout: 0, size: 0) { Object.new }
-
-    assert_raises Timeout::Error do
-      pool.checkout
-    end
-  end
-
-  def test_checkout_timeout_override
-    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
-
-    thread = Thread.new {
-      pool.with do |net|
-        net.do_something
-        sleep 0.01
-      end
-    }
-
-    Thread.pass while thread.status == "run"
-
-    assert_raises Timeout::Error do
-      pool.checkout
-    end
-
-    assert pool.checkout timeout: 2 * NetworkConnection::SLEEP_TIME
-  end
-
-  def test_passthru
-    pool = ConnectionPool.wrap(timeout: 2 * NetworkConnection::SLEEP_TIME, size: 1) { NetworkConnection.new }
-    assert_equal 1, pool.do_something
-    assert_equal 2, pool.do_something
-    assert_equal 5, pool.do_something_with_block { 3 }
-    assert_equal 6, pool.with { |net| net.fast }
-    assert_equal 8, pool.do_something(increment: 2)
-    assert_equal 10, pool.do_something_with_positional_hash({ increment: 2, symbol_key: 3, "string_key" => 4 })
-  end
-
-  def test_passthru_respond_to
-    pool = ConnectionPool.wrap(timeout: 2 * NetworkConnection::SLEEP_TIME, size: 1) { NetworkConnection.new }
-    assert pool.respond_to?(:with)
-    assert pool.respond_to?(:do_something)
-    assert pool.respond_to?(:do_magic)
-    refute pool.respond_to?(:do_lots_of_magic)
-  end
-
-  def test_return_value
-    pool = ConnectionPool.new(timeout: 2 * NetworkConnection::SLEEP_TIME, size: 1) { NetworkConnection.new }
-    result = pool.with { |net|
-      net.fast
-    }
-    assert_equal 1, result
-  end
-
-  def test_heavy_threading
-    pool = ConnectionPool.new(timeout: 0.5, size: 3) { NetworkConnection.new }
-
-    threads = Array.new(20) {
-      Thread.new do
-        pool.with do |net|
-          sleep 0.01
-        end
-      end
-    }
-
-    threads.map { |thread| thread.join }
-  end
-
-  def test_reuses_objects_when_pool_not_saturated
-    pool = ConnectionPool.new(size: 5) { NetworkConnection.new }
-
-    ids = 10.times.map {
-      pool.with { |c| c.object_id }
-    }
-
-    assert_equal 1, ids.uniq.size
-  end
-
-  def test_nested_checkout
-    recorder = Recorder.new
-    pool = ConnectionPool.new(size: 1) { recorder }
-    pool.with do |r_outer|
-      @other = Thread.new { |t|
-        pool.with do |r_other|
-          r_other.do_work("other")
-        end
-      }
-
-      pool.with do |r_inner|
-        r_inner.do_work("inner")
-      end
-
-      Thread.pass
-
-      r_outer.do_work("outer")
-    end
-
-    @other.join
-
-    assert_equal ["inner", "outer", "other"], recorder.calls
-  end
-
-  def test_shutdown_is_executed_for_all_connections
-    recorders = []
-
-    pool = ConnectionPool.new(size: 3) {
-      Recorder.new.tap { |r| recorders << r }
-    }
-
-    threads = use_pool pool, 3
-
-    pool.shutdown do |recorder|
-      recorder.do_work("shutdown")
-    end
-
-    kill_threads(threads)
-
-    assert_equal [["shutdown"]] * 3, recorders.map { |r| r.calls }
-  end
-
-  def test_raises_error_after_shutting_down
-    pool = ConnectionPool.new(size: 1) { true }
-
-    pool.shutdown {}
-
-    assert_raises ConnectionPool::PoolShuttingDownError do
-      pool.checkout
-    end
-  end
-
-  def test_runs_shutdown_block_asynchronously_if_connection_was_in_use
-    recorders = []
-
-    pool = ConnectionPool.new(size: 3) {
-      Recorder.new.tap { |r| recorders << r }
-    }
-
-    threads = use_pool pool, 2
-
-    pool.checkout
-
-    pool.shutdown do |recorder|
-      recorder.do_work("shutdown")
-    end
-
-    kill_threads(threads)
-
-    assert_equal [["shutdown"], ["shutdown"], []], recorders.map { |r| r.calls }
-
-    pool.checkin
-
-    assert_equal [["shutdown"], ["shutdown"], ["shutdown"]], recorders.map { |r| r.calls }
-  end
-
-  def test_raises_an_error_if_shutdown_is_called_without_a_block
-    pool = ConnectionPool.new(size: 1) {}
-
-    assert_raises ArgumentError do
-      pool.shutdown
-    end
-  end
-
-  def test_shutdown_is_executed_for_all_connections_in_wrapped_pool
-    recorders = []
-
-    wrapper = ConnectionPool::Wrapper.new(size: 3) {
-      Recorder.new.tap { |r| recorders << r }
-    }
-
-    threads = use_pool wrapper, 3
-
-    wrapper.pool_shutdown do |recorder|
-      recorder.do_work("shutdown")
-    end
-
-    kill_threads(threads)
-
-    assert_equal [["shutdown"]] * 3, recorders.map { |r| r.calls }
-  end
-
-  def test_wrapper_wrapped_pool
-    wrapper = ConnectionPool::Wrapper.new { NetworkConnection.new }
-    assert_equal ConnectionPool, wrapper.wrapped_pool.class
-  end
-
-  def test_wrapper_method_missing
-    wrapper = ConnectionPool::Wrapper.new { NetworkConnection.new }
-
-    assert_equal 1, wrapper.fast
-  end
-
-  def test_wrapper_respond_to_eh
-    wrapper = ConnectionPool::Wrapper.new { NetworkConnection.new }
-
-    assert_respond_to wrapper, :with
-
-    assert_respond_to wrapper, :fast
-    refute_respond_to wrapper, :"nonexistent method"
-  end
-
-  def test_wrapper_with
-    wrapper = ConnectionPool::Wrapper.new(timeout: 0, size: 1) { Object.new }
-
-    wrapper.with do
-      Thread.new {
-        assert_raises Timeout::Error do
-          wrapper.with { flunk "connection checked out :(" }
-        end
-      }.join
-    end
-
-    assert Thread.new { wrapper.with {} }.join
-  end
-
-  class ConnWithEval
-    def eval(arg)
-      "eval'ed #{arg}"
-    end
-  end
-
-  def test_wrapper_kernel_methods
-    wrapper = ConnectionPool::Wrapper.new(timeout: 0, size: 1) { ConnWithEval.new }
-
-    assert_equal "eval'ed 1", wrapper.eval(1)
-  end
-
-  def test_wrapper_with_connection_pool
-    recorder = Recorder.new
-    pool = ConnectionPool.new(size: 1) { recorder }
-    wrapper = ConnectionPool::Wrapper.new(pool: pool)
-
-    pool.with { |r| r.do_work("with") }
-    wrapper.do_work("wrapped")
-
-    assert_equal ["with", "wrapped"], recorder.calls
-  end
-
-  def test_stats_without_active_connection
-    pool = ConnectionPool.new(size: 2) { NetworkConnection.new }
-
-    assert_equal(2, pool.size)
-    assert_equal(2, pool.available)
-  end
-
-  def test_stats_with_active_connection
-    pool = ConnectionPool.new(size: 2) { NetworkConnection.new }
-
-    pool.with do
-      assert_equal(1, pool.available)
-    end
-  end
-
-  def test_stats_with_string_size
-    pool = ConnectionPool.new(size: "2") { NetworkConnection.new }
-
-    pool.with do
-      assert_equal(2, pool.size)
-      assert_equal(1, pool.available)
-    end
-  end
-end

data/test/test_connection_pool_timed_stack.rb

@@ -1,150 +0,0 @@
-require_relative "helper"
-
-class TestConnectionPoolTimedStack < Minitest::Test
-  def setup
-    @stack = ConnectionPool::TimedStack.new { Object.new }
-  end
-
-  def test_empty_eh
-    stack = ConnectionPool::TimedStack.new(1) { Object.new }
-
-    refute_empty stack
-
-    popped = stack.pop
-
-    assert_empty stack
-
-    stack.push popped
-
-    refute_empty stack
-  end
-
-  def test_length
-    stack = ConnectionPool::TimedStack.new(1) { Object.new }
-
-    assert_equal 1, stack.length
-
-    popped = stack.pop
-
-    assert_equal 0, stack.length
-
-    stack.push popped
-
-    assert_equal 1, stack.length
-  end
-
-  def test_object_creation_fails
-    stack = ConnectionPool::TimedStack.new(2) { raise "failure" }
-
-    begin
-      stack.pop
-    rescue => error
-      assert_equal "failure", error.message
-    end
-
-    begin
-      stack.pop
-    rescue => error
-      assert_equal "failure", error.message
-    end
-
-    refute_empty stack
-    assert_equal 2, stack.length
-  end
-
-  def test_pop
-    object = Object.new
-    @stack.push object
-
-    popped = @stack.pop
-
-    assert_same object, popped
-  end
-
-  def test_pop_empty
-    e = assert_raises(ConnectionPool::TimeoutError) { @stack.pop timeout: 0 }
-    assert_equal "Waited 0 sec", e.message
-  end
-
-  def test_pop_empty_2_0_compatibility
-    e = assert_raises(Timeout::Error) { @stack.pop 0 }
-    assert_equal "Waited 0 sec", e.message
-  end
-
-  def test_pop_full
-    stack = ConnectionPool::TimedStack.new(1) { Object.new }
-
-    popped = stack.pop
-
-    refute_nil popped
-    assert_empty stack
-  end
-
-  def test_pop_wait
-    thread = Thread.start {
-      @stack.pop
-    }
-
-    Thread.pass while thread.status == "run"
-
-    object = Object.new
-
-    @stack.push object
-
-    assert_same object, thread.value
-  end
-
-  def test_pop_shutdown
-    @stack.shutdown {}
-
-    assert_raises ConnectionPool::PoolShuttingDownError do
-      @stack.pop
-    end
-  end
-
-  def test_pop_shutdown_reload
-    stack = ConnectionPool::TimedStack.new(1) { Object.new }
-    object = stack.pop
-    stack.push(object)
-
-    stack.shutdown(reload: true) {}
-
-    refute_equal object, stack.pop
-  end
-
-  def test_push
-    stack = ConnectionPool::TimedStack.new(1) { Object.new }
-
-    conn = stack.pop
-
-    stack.push conn
-
-    refute_empty stack
-  end
-
-  def test_push_shutdown
-    called = []
-
-    @stack.shutdown do |object|
-      called << object
-    end
-
-    @stack.push Object.new
-
-    refute_empty called
-    assert_empty @stack
-  end
-
-  def test_shutdown
-    @stack.push Object.new
-
-    called = []
-
-    @stack.shutdown do |object|
-      called << object
-    end
-
-    refute_empty called
-    assert_empty @stack
-  end
-end