connection_pool 2.2.0 → 2.2.5

data/lib/connection_pool/version.rb

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

data/lib/connection_pool/wrapper.rb

@@ -0,0 +1,57 @@
+class ConnectionPool
+  class Wrapper < ::BasicObject
+    METHODS = [:with, :pool_shutdown, :wrapped_pool]
+
+    def initialize(options = {}, &block)
+      @pool = options.fetch(:pool) { ::ConnectionPool.new(options, &block) }
+    end
+
+    def wrapped_pool
+      @pool
+    end
+
+    def with(&block)
+      @pool.with(&block)
+    end
+
+    def pool_shutdown(&block)
+      @pool.shutdown(&block)
+    end
+
+    def pool_size
+      @pool.size
+    end
+
+    def pool_available
+      @pool.available
+    end
+
+    def respond_to?(id, *args)
+      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)
+        with do |connection|
+          connection.send(name, *args, **kwargs, &block)
+        end
+      end
+    elsif ::RUBY_VERSION >= "2.7.0"
+      ruby2_keywords def method_missing(name, *args, &block)
+        with do |connection|
+          connection.send(name, *args, &block)
+        end
+      end
+    else
+      def method_missing(name, *args, &block)
+        with do |connection|
+          connection.send(name, *args, &block)
+        end
+      end
+    end
+    # rubocop:enable Style/MethodMissingSuper
+    # rubocop:enable Style/MissingRespondToMissing
+  end
+end

data/test/helper.rb

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

data/test/test_connection_pool.rb

@@ -1,15 +1,22 @@
-require_relative 'helper'
+require_relative "helper"
 
 class TestConnectionPool < Minitest::Test
-
   class NetworkConnection
+    SLEEP_TIME = 0.1
+
     def initialize
       @x = 0
     end
 
-    def do_something
-      @x += 1
-      sleep 0.05
+    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
 
@@ -19,7 +26,7 @@ class TestConnectionPool < Minitest::Test
 
     def do_something_with_block
       @x += yield
-      sleep 0.05
+      sleep SLEEP_TIME
       @x
     end
 
@@ -41,12 +48,12 @@ class TestConnectionPool < Minitest::Test
   end
 
   def use_pool(pool, size)
-    Array.new(size) do
+    Array.new(size) {
       Thread.new do
-        pool.with do sleep end
+        pool.with { sleep }
       end
-    end.each do |thread|
-      Thread.pass until thread.status == 'sleep'
+    }.each do |thread|
+      Thread.pass until thread.status == "sleep"
     end
   end
 
@@ -58,33 +65,38 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_basic_multithreaded_usage
-    pool = ConnectionPool.new(:size => 5) { NetworkConnection.new }
+    pool_size = 5
+    pool = ConnectionPool.new(size: pool_size) { NetworkConnection.new }
+
+    start = Time.new
+
+    generations = 3
 
-    threads = Array.new(15) do
+    result = Array.new(pool_size * generations) {
       Thread.new do
         pool.with do |net|
           net.do_something
         end
       end
-    end
+    }.map(&:value)
+
+    finish = Time.new
 
-    a = Time.now
-    result = threads.map(&:value)
-    b = Time.now
-    assert_operator((b - a), :>, 0.125)
-    assert_equal([1,2,3].cycle(5).sort, result.sort)
+    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 do
+    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
+    thread = Thread.new {
       pool.with do |net|
         net.do_something
         sleep 0.01
       end
-    end
+    }
 
-    Thread.pass while thread.status == 'run'
+    Thread.pass while thread.status == "run"
 
     assert_raises Timeout::Error do
       pool.with { |net| net.do_something }
@@ -98,42 +110,58 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_with
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
 
     pool.with do
-      assert_raises Timeout::Error do
-        Thread.new { pool.checkout }.join
-      end
+      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 }
+    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.instance_variable_get(:@available).instance_variable_get(:@que).size
+          assert_equal 0, pool.available
           sleep 0.015
         end
       end
     end
-    assert_equal 1, pool.instance_variable_get(:@available).instance_variable_get(:@que).size
+    assert_equal 1, pool.available
   end
 
-  def test_checkout_ignores_timeout
-    skip("Thread.handle_interrupt not available") unless Thread.respond_to?(:handle_interrupt)
+  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
 
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
+  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
-    assert_raises Timeout::Error do
+
+    action = lambda do
       Timeout.timeout(0.01) do
         pool.with do |obj|
           did_something = true
@@ -145,18 +173,33 @@ class TestConnectionPool < Minitest::Test
         end
       end
     end
-    assert did_something
-    assert_equal 1, pool.instance_variable_get(:@available).instance_variable_get(:@que).size
+
+    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) do
+    pool = ConnectionPool.new(timeout: 0, size: 1) {
       mock = Minitest::Mock.new
       def mock.disconnect!
         raise "should not disconnect upon explicit return"
       end
       mock
-    end
+    }
 
     pool.with do |conn|
       return true
@@ -164,33 +207,35 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_with_timeout_override
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
 
-    t = Thread.new do
+    t = Thread.new {
       pool.with do |net|
         net.do_something
         sleep 0.01
       end
-    end
+    }
 
-    Thread.pass while t.status == 'run'
+    Thread.pass while t.status == "run"
 
     assert_raises Timeout::Error do
       pool.with { |net| net.do_something }
     end
 
-    pool.with(:timeout => 0.1) do |conn|
+    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 }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
     conn = pool.checkout
 
-    assert_raises Timeout::Error do
-      Thread.new { pool.checkout }.join
-    end
+    Thread.new {
+      assert_raises Timeout::Error do
+        pool.checkout
+      end
+    }.join
 
     pool.checkin
 
@@ -198,22 +243,19 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_returns_value
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
-    assert_equal 1, pool.with {|o| 1 }
+    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 do
-      pool.checkin
-    end
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
 
-    assert_equal 'no connections are checked out', e.message
+    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 = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
 
     pool.checkout
     pool.checkin
@@ -224,18 +266,18 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_checkin_twice
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { Object.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { Object.new }
 
     pool.checkout
     pool.checkout
 
     pool.checkin
 
-    assert_raises Timeout::Error do
-      Thread.new do
+    Thread.new {
+      assert_raises Timeout::Error do
         pool.checkout
-      end.join
-    end
+      end
+    }.join
 
     pool.checkin
 
@@ -243,7 +285,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_checkout
-    pool = ConnectionPool.new(:size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.new(size: 1) { NetworkConnection.new }
 
     conn = pool.checkout
 
@@ -253,18 +295,18 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_checkout_multithread
-    pool = ConnectionPool.new(:size => 2) { NetworkConnection.new }
+    pool = ConnectionPool.new(size: 2) { NetworkConnection.new }
     conn = pool.checkout
 
-    t = Thread.new do
+    t = Thread.new {
       pool.checkout
-    end
+    }
 
     refute_same conn, t.value
   end
 
   def test_checkout_timeout
-    pool = ConnectionPool.new(:timeout => 0, :size => 0) { Object.new }
+    pool = ConnectionPool.new(timeout: 0, size: 0) { Object.new }
 
     assert_raises Timeout::Error do
       pool.checkout
@@ -272,34 +314,36 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_checkout_timeout_override
-    pool = ConnectionPool.new(:timeout => 0, :size => 1) { NetworkConnection.new }
+    pool = ConnectionPool.new(timeout: 0, size: 1) { NetworkConnection.new }
 
-    thread = Thread.new do
+    thread = Thread.new {
       pool.with do |net|
         net.do_something
         sleep 0.01
       end
-    end
+    }
 
-    Thread.pass while thread.status == 'run'
+    Thread.pass while thread.status == "run"
 
     assert_raises Timeout::Error do
       pool.checkout
     end
 
-    assert pool.checkout :timeout => 0.1
+    assert pool.checkout timeout: 2 * NetworkConnection::SLEEP_TIME
   end
 
   def test_passthru
-    pool = ConnectionPool.wrap(:timeout => 0.1, :size => 1) { NetworkConnection.new }
+    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 => 0.1, :size => 1) { NetworkConnection.new }
+    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)
@@ -307,67 +351,67 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_return_value
-    pool = ConnectionPool.new(:timeout => 0.1, :size => 1) { NetworkConnection.new }
-    result = pool.with do |net|
+    pool = ConnectionPool.new(timeout: 2 * NetworkConnection::SLEEP_TIME, size: 1) { NetworkConnection.new }
+    result = pool.with { |net|
       net.fast
-    end
+    }
     assert_equal 1, result
   end
 
   def test_heavy_threading
-    pool = ConnectionPool.new(:timeout => 0.5, :size => 3) { NetworkConnection.new }
+    pool = ConnectionPool.new(timeout: 0.5, size: 3) { NetworkConnection.new }
 
-    threads = Array.new(20) do
+    threads = Array.new(20) {
       Thread.new do
         pool.with do |net|
           sleep 0.01
         end
       end
-    end
+    }
 
     threads.map { |thread| thread.join }
   end
 
   def test_reuses_objects_when_pool_not_saturated
-    pool = ConnectionPool.new(:size => 5) { NetworkConnection.new }
+    pool = ConnectionPool.new(size: 5) { NetworkConnection.new }
 
-    ids = 10.times.map do
+    ids = 10.times.map {
       pool.with { |c| c.object_id }
-    end
+    }
 
     assert_equal 1, ids.uniq.size
   end
 
   def test_nested_checkout
     recorder = Recorder.new
-    pool = ConnectionPool.new(:size => 1) { recorder }
+    pool = ConnectionPool.new(size: 1) { recorder }
     pool.with do |r_outer|
-      @other = Thread.new do |t|
+      @other = Thread.new { |t|
         pool.with do |r_other|
-          r_other.do_work('other')
+          r_other.do_work("other")
         end
-      end
+      }
 
       pool.with do |r_inner|
-        r_inner.do_work('inner')
+        r_inner.do_work("inner")
       end
 
       Thread.pass
 
-      r_outer.do_work('outer')
+      r_outer.do_work("outer")
     end
 
     @other.join
 
-    assert_equal ['inner', 'outer', 'other'], recorder.calls
+    assert_equal ["inner", "outer", "other"], recorder.calls
   end
 
   def test_shutdown_is_executed_for_all_connections
     recorders = []
 
-    pool = ConnectionPool.new(:size => 3) do
+    pool = ConnectionPool.new(size: 3) {
       Recorder.new.tap { |r| recorders << r }
-    end
+    }
 
     threads = use_pool pool, 3
 
@@ -381,9 +425,9 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_raises_error_after_shutting_down
-    pool = ConnectionPool.new(:size => 1) { true }
+    pool = ConnectionPool.new(size: 1) { true }
 
-    pool.shutdown { }
+    pool.shutdown {}
 
     assert_raises ConnectionPool::PoolShuttingDownError do
       pool.checkout
@@ -393,9 +437,9 @@ class TestConnectionPool < Minitest::Test
   def test_runs_shutdown_block_asynchronously_if_connection_was_in_use
     recorders = []
 
-    pool = ConnectionPool.new(:size => 3) do
+    pool = ConnectionPool.new(size: 3) {
       Recorder.new.tap { |r| recorders << r }
-    end
+    }
 
     threads = use_pool pool, 2
 
@@ -415,7 +459,7 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_raises_an_error_if_shutdown_is_called_without_a_block
-    pool = ConnectionPool.new(:size => 1) { }
+    pool = ConnectionPool.new(size: 1) {}
 
     assert_raises ArgumentError do
       pool.shutdown
@@ -425,9 +469,9 @@ class TestConnectionPool < Minitest::Test
   def test_shutdown_is_executed_for_all_connections_in_wrapped_pool
     recorders = []
 
-    wrapper = ConnectionPool::Wrapper.new(:size => 3) do
+    wrapper = ConnectionPool::Wrapper.new(size: 3) {
       Recorder.new.tap { |r| recorders << r }
-    end
+    }
 
     threads = use_pool wrapper, 3
 
@@ -440,6 +484,11 @@ class TestConnectionPool < Minitest::Test
     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 }
 
@@ -456,17 +505,17 @@ class TestConnectionPool < Minitest::Test
   end
 
   def test_wrapper_with
-    wrapper = ConnectionPool::Wrapper.new(:timeout => 0, :size => 1) { Object.new }
+    wrapper = ConnectionPool::Wrapper.new(timeout: 0, size: 1) { Object.new }
 
     wrapper.with do
-      assert_raises Timeout::Error do
-        Thread.new do
-          wrapper.with { flunk 'connection checked out :(' }
-        end.join
-      end
+      Thread.new {
+        assert_raises Timeout::Error do
+          wrapper.with { flunk "connection checked out :(" }
+        end
+      }.join
     end
 
-    assert Thread.new { wrapper.with { } }.join
+    assert Thread.new { wrapper.with {} }.join
   end
 
   class ConnWithEval
@@ -481,4 +530,38 @@ class TestConnectionPool < Minitest::Test
     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