net-http-persistent 2.9.4 → 4.0.1

data/lib/net/http/persistent/connection.rb

@@ -0,0 +1,40 @@
+##
+# A Net::HTTP connection wrapper that holds extra information for managing the
+# connection's lifetime.
+
+class Net::HTTP::Persistent::Connection # :nodoc:
+
+  attr_accessor :http
+
+  attr_accessor :last_use
+
+  attr_accessor :requests
+
+  attr_accessor :ssl_generation
+
+  def initialize http_class, http_args, ssl_generation
+    @http           = http_class.new(*http_args)
+    @ssl_generation = ssl_generation
+
+    reset
+  end
+
+  def finish
+    @http.finish
+  rescue IOError
+  ensure
+    reset
+  end
+
+  def reset
+    @last_use = Net::HTTP::Persistent::EPOCH
+    @requests = 0
+  end
+
+  def ressl ssl_generation
+    @ssl_generation = ssl_generation
+
+    finish
+  end
+
+end

data/lib/net/http/persistent/pool.rb

@@ -0,0 +1,53 @@
+class Net::HTTP::Persistent::Pool < ConnectionPool # :nodoc:
+
+  attr_reader :available # :nodoc:
+  attr_reader :key # :nodoc:
+
+  def initialize(options = {}, &block)
+    super
+
+    @available = Net::HTTP::Persistent::TimedStackMulti.new(@size, &block)
+    @key = "current-#{@available.object_id}"
+  end
+
+  def checkin net_http_args
+    stack = Thread.current[@key][net_http_args] ||= []
+
+    raise ConnectionPool::Error, 'no connections are checked out' if
+      stack.empty?
+
+    conn = stack.pop
+
+    if stack.empty?
+      @available.push conn, connection_args: net_http_args
+
+      Thread.current[@key].delete(net_http_args)
+      Thread.current[@key] = nil if Thread.current[@key].empty?
+    end
+
+    nil
+  end
+
+  def checkout net_http_args
+    stacks = Thread.current[@key] ||= {}
+    stack  = stacks[net_http_args] ||= []
+
+    if stack.empty? then
+      conn = @available.pop connection_args: net_http_args
+    else
+      conn = stack.last
+    end
+
+    stack.push conn
+
+    conn
+  end
+
+  def shutdown
+    Thread.current[@key] = nil
+    super
+  end
+end
+
+require_relative 'timed_stack_multi'
+

data/lib/net/http/persistent/timed_stack_multi.rb

@@ -0,0 +1,79 @@
+class Net::HTTP::Persistent::TimedStackMulti < ConnectionPool::TimedStack # :nodoc:
+
+  ##
+  # Returns a new hash that has arrays for keys
+  #
+  # Using a class method to limit the bindings referenced by the hash's
+  # default_proc
+
+  def self.hash_of_arrays # :nodoc:
+    Hash.new { |h,k| h[k] = [] }
+  end
+
+  def initialize(size = 0, &block)
+    super
+
+    @enqueued = 0
+    @ques = self.class.hash_of_arrays
+    @lru = {}
+    @key = :"connection_args-#{object_id}"
+  end
+
+  def empty?
+    (@created - @enqueued) >= @max
+  end
+
+  def length
+    @max - @created + @enqueued
+  end
+
+  private
+
+  def connection_stored? options = {} # :nodoc:
+    !@ques[options[:connection_args]].empty?
+  end
+
+  def fetch_connection options = {} # :nodoc:
+    connection_args = options[:connection_args]
+
+    @enqueued -= 1
+    lru_update connection_args
+    @ques[connection_args].pop
+  end
+
+  def lru_update connection_args # :nodoc:
+    @lru.delete connection_args
+    @lru[connection_args] = true
+  end
+
+  def shutdown_connections # :nodoc:
+    @ques.each_key do |key|
+      super connection_args: key
+    end
+  end
+
+  def store_connection obj, options = {} # :nodoc:
+    @ques[options[:connection_args]].push obj
+    @enqueued += 1
+  end
+
+  def try_create options = {} # :nodoc:
+    connection_args = options[:connection_args]
+
+    if @created >= @max && @enqueued >= 1
+      oldest, = @lru.first
+      @lru.delete oldest
+      @ques[oldest].pop
+
+      @created -= 1
+    end
+
+    if @created < @max
+      @created += 1
+      lru_update connection_args
+      return @create_block.call(connection_args)
+    end
+  end
+
+end
+

data/test/test_net_http_persistent.rb

@@ -51,24 +51,13 @@ class Net::HTTP
   include Net::HTTP::Persistent::TestConnect
 end
 
-class Net::HTTP::Persistent::SSLReuse
-  include Net::HTTP::Persistent::TestConnect
-end
-
 class TestNetHttpPersistent < Minitest::Test
 
-  RUBY_1 = RUBY_VERSION < '2'
-
   def setup
-    @http_class = if RUBY_1 and HAVE_OPENSSL then
-                    Net::HTTP::Persistent::SSLReuse
-                  else
-                    Net::HTTP
-                  end
-
     @http = Net::HTTP::Persistent.new
 
-    @uri  = URI.parse 'http://example.com/path'
+    @uri    = URI 'http://example.com/path'
+    @uri_v6 = URI 'http://[2001:db8::1]/path'
 
     ENV.delete 'http_proxy'
     ENV.delete 'HTTP_PROXY'
@@ -80,25 +69,23 @@ class TestNetHttpPersistent < Minitest::Test
     ENV.delete 'NO_PROXY'
 
     Net::HTTP.use_connect :test_connect
-    Net::HTTP::Persistent::SSLReuse.use_connect :test_connect
   end
 
   def teardown
-    Thread.current.keys.each do |key|
-      Thread.current[key] = nil
-    end
-
     Net::HTTP.use_connect :orig_connect
-    Net::HTTP::Persistent::SSLReuse.use_connect :orig_connect
   end
 
   class BasicConnection
-    attr_accessor :started, :finished, :address, :port,
-                  :read_timeout, :open_timeout
+    attr_accessor :started, :finished, :address, :port, :use_ssl,
+                  :read_timeout, :open_timeout, :keep_alive_timeout
+    attr_accessor :ciphers, :ssl_timeout, :ssl_version, :min_version,
+                  :max_version, :verify_depth, :verify_mode, :cert_store,
+                  :ca_file, :ca_path, :cert, :key
     attr_reader :req, :debug_output
     def initialize
       @started, @finished = 0, 0
       @address, @port = 'example.com', 80
+      @use_ssl = false
     end
     def finish
       @finished += 1
@@ -125,21 +112,34 @@ class TestNetHttpPersistent < Minitest::Test
     def started?
       @started >= 1
     end
+    def proxy_address
+    end
+    def proxy_port
+    end
   end
 
   def basic_connection
     raise "#{@uri} is not HTTP" unless @uri.scheme.downcase == 'http'
 
-    c = BasicConnection.new
-    conns[0]["#{@uri.host}:#{@uri.port}"] = c
-    c
+    net_http_args = [@uri.hostname, @uri.port, nil, nil, nil, nil]
+
+    connection = Net::HTTP::Persistent::Connection.allocate
+    connection.ssl_generation = @http.ssl_generation
+    connection.http = BasicConnection.new
+    connection.reset
+
+    @http.pool.available.push connection, connection_args: net_http_args
+
+    connection
   end
 
-  def connection
-    c = basic_connection
-    touts[c.object_id] = Time.now
+  def connection uri = @uri
+    @uri = uri
+
+    connection = basic_connection
+    connection.last_use = Time.now
 
-    def c.request(req)
+    def (connection.http).request(req)
       @req = req
       r = Net::HTTPResponse.allocate
       r.instance_variable_set :@header, {}
@@ -149,30 +149,22 @@ class TestNetHttpPersistent < Minitest::Test
       r
     end
 
-    c
+    connection
   end
 
-  def conns
-    Thread.current[@http.generation_key] ||= Hash.new { |h,k| h[k] = {} }
-  end
+  def ssl_connection
+    raise "#{@uri} is not HTTPS" unless @uri.scheme.downcase == 'https'
 
-  def reqs
-    Thread.current[@http.request_key] ||= Hash.new 0
-  end
+    net_http_args = [@uri.hostname, @uri.port, nil, nil, nil, nil]
 
-  def ssl_conns
-    Thread.current[@http.ssl_generation_key] ||= Hash.new { |h,k| h[k] = {} }
-  end
+    connection = Net::HTTP::Persistent::Connection.allocate
+    connection.ssl_generation = @http.ssl_generation
+    connection.http = BasicConnection.new
+    connection.reset
 
-  def ssl_connection generation = 0
-    raise "#{@uri} is not HTTPS" unless @uri.scheme.downcase == 'https'
-    c = BasicConnection.new
-    ssl_conns[generation]["#{@uri.host}:#{@uri.port}"] = c
-    c
-  end
+    @http.pool.available.push connection, connection_args: net_http_args
 
-  def touts
-    Thread.current[@http.timeout_key] ||= Hash.new Net::HTTP::Persistent::EPOCH
+    connection
   end
 
   def test_initialize
@@ -188,7 +180,7 @@ class TestNetHttpPersistent < Minitest::Test
   end
 
   def test_initialize_name
-    http = Net::HTTP::Persistent.new 'name'
+    http = Net::HTTP::Persistent.new name: 'name'
     assert_equal 'name', http.name
   end
 
@@ -212,7 +204,7 @@ class TestNetHttpPersistent < Minitest::Test
   def test_initialize_proxy
     proxy_uri = URI.parse 'http://proxy.example'
 
-    http = Net::HTTP::Persistent.new nil, proxy_uri
+    http = Net::HTTP::Persistent.new proxy: proxy_uri
 
     assert_equal proxy_uri, http.proxy_uri
   end
@@ -224,37 +216,11 @@ class TestNetHttpPersistent < Minitest::Test
     assert_equal 1, @http.ssl_generation
   end
 
-  def test_can_retry_eh_change_requests
-    post = Net::HTTP::Post.new '/'
+  def test_ca_path_equals
+    @http.ca_path = :ca_path
 
-    refute @http.can_retry? post
-
-    @http.retry_change_requests = true
-
-    assert @http.can_retry? post
-  end
-
-  if RUBY_1 then
-    def test_can_retry_eh_idempotent
-      head = Net::HTTP::Head.new '/'
-
-      assert @http.can_retry? head
-
-      post = Net::HTTP::Post.new '/'
-
-      refute @http.can_retry? post
-    end
-  else
-    def test_can_retry_eh_idempotent
-      head = Net::HTTP::Head.new '/'
-
-      assert @http.can_retry? head
-      refute @http.can_retry? head, true
-
-      post = Net::HTTP::Post.new '/'
-
-      refute @http.can_retry? post
-    end
+    assert_equal :ca_path, @http.ca_path
+    assert_equal 1, @http.ssl_generation
   end
 
   def test_cert_store_equals
@@ -271,168 +237,162 @@ class TestNetHttpPersistent < Minitest::Test
     assert_equal 1, @http.ssl_generation
   end
 
+  def test_ciphers_equals
+    @http.ciphers = :ciphers
+
+    assert_equal :ciphers, @http.ciphers
+    assert_equal 1, @http.ssl_generation
+  end
+
   def test_connection_for
     @http.open_timeout = 123
     @http.read_timeout = 321
     @http.idle_timeout = 42
-    c = @http.connection_for @uri
+    @http.max_retries  = 5
 
-    assert_kind_of @http_class, c
+    used = @http.connection_for @uri do |c|
+      assert_kind_of Net::HTTP, c.http
 
-    assert c.started?
-    refute c.proxy?
+      assert c.http.started?
+      refute c.http.proxy?
 
-    assert_equal 123, c.open_timeout
-    assert_equal 321, c.read_timeout
-    assert_equal 42, c.keep_alive_timeout unless RUBY_1
+      assert_equal 123, c.http.open_timeout
+      assert_equal 321, c.http.read_timeout
+      assert_equal 42, c.http.keep_alive_timeout
+      assert_equal 5, c.http.max_retries if c.http.respond_to?(:max_retries)
 
-    assert_includes conns[0].keys, 'example.com:80'
-    assert_same c, conns[0]['example.com:80']
+      c
+    end
+
+    stored = @http.pool.checkout ['example.com', 80, nil, nil, nil, nil]
+
+    assert_same used, stored
   end
 
   def test_connection_for_cached
     cached = basic_connection
-    cached.start
-    conns[0]['example.com:80'] = cached
+    cached.http.start
 
     @http.read_timeout = 5
 
-    c = @http.connection_for @uri
-
-    assert c.started?
+    @http.connection_for @uri do |c|
+      assert c.http.started?
 
-    assert_equal 5,       c.read_timeout
+      assert_equal 5, c.http.read_timeout
 
-    assert_same cached, c
+      assert_same cached, c
+    end
   end
 
   def test_connection_for_closed
     cached = basic_connection
-    cached.start
+    cached.http.start
     if Socket.const_defined? :TCP_NODELAY then
       io = Object.new
       def io.setsockopt(*a) raise IOError, 'closed stream' end
       cached.instance_variable_set :@socket, Net::BufferedIO.new(io)
     end
-    conns['example.com:80'] = cached
-
-    c = @http.connection_for @uri
-
-    assert c.started?
 
-    assert_includes conns.keys, 'example.com:80'
-    assert_same c, conns[0]['example.com:80']
+    @http.connection_for @uri do |c|
+      assert c.http.started?
 
-    socket = c.instance_variable_get :@socket
+      socket = c.http.instance_variable_get :@socket
 
-    refute_includes socket.io.instance_variables, :@setsockopt
-    refute_includes socket.io.instance_variables, '@setsockopt'
+      refute_includes socket.io.instance_variables, :@setsockopt
+      refute_includes socket.io.instance_variables, '@setsockopt'
+    end
   end
 
   def test_connection_for_debug_output
     io = StringIO.new
     @http.debug_output = io
 
-    c = @http.connection_for @uri
-
-    assert c.started?
-    assert_equal io, c.instance_variable_get(:@debug_output)
-
-    assert_includes conns[0].keys, 'example.com:80'
-    assert_same c, conns[0]['example.com:80']
+    @http.connection_for @uri do |c|
+      assert c.http.started?
+      assert_equal io, c.http.instance_variable_get(:@debug_output)
+    end
   end
 
   def test_connection_for_cached_expire_always
     cached = basic_connection
-    cached.start
-    conns[0]['example.com:80'] = cached
-    reqs[cached.object_id] = 10
-    touts[cached.object_id] = Time.now # last used right now
+    cached.http.start
+    cached.requests = 10
+    cached.last_use = Time.now # last used right now
 
     @http.idle_timeout = 0
 
-    c = @http.connection_for @uri
-
-    assert c.started?
+    @http.connection_for @uri do |c|
+      assert c.http.started?
 
-    assert_same cached, c
+      assert_same cached, c
 
-    assert_equal 0, reqs[cached.object_id],
-                 'connection reset due to timeout'
+      assert_equal 0, c.requests, 'connection reset due to timeout'
+    end
   end
 
   def test_connection_for_cached_expire_never
     cached = basic_connection
-    cached.start
-    conns[0]['example.com:80'] = cached
-    reqs[cached.object_id] = 10
-    touts[cached.object_id] = Time.now # last used right now
+    cached.http.start
+    cached.requests = 10
+    cached.last_use = Time.now # last used right now
 
     @http.idle_timeout = nil
 
-    c = @http.connection_for @uri
-
-    assert c.started?
+    @http.connection_for @uri do |c|
+      assert c.http.started?
 
-    assert_same cached, c
+      assert_same cached, c
 
-    assert_equal 10, reqs[cached.object_id],
-                 'connection reset despite no timeout'
+      assert_equal 10, c.requests, 'connection reset despite no timeout'
+    end
   end
 
   def test_connection_for_cached_expired
     cached = basic_connection
-    cached.start
-    conns[0]['example.com:80'] = cached
-    reqs[cached.object_id] = 10
-    touts[cached.object_id] = Time.now - 3600
-
-    c = @http.connection_for @uri
-
-    assert c.started?
+    cached.http.start
+    cached.requests = 10
+    cached.last_use = Time.now - 3600
 
-    assert_same cached, c
-    assert_equal 0, reqs[cached.object_id],
-                 'connection not reset due to timeout'
-  end
+    @http.connection_for @uri do |c|
+      assert c.http.started?
 
-  def test_connection_for_refused
-    Net::HTTP.use_connect :refused_connect
-    Net::HTTP::Persistent::SSLReuse.use_connect :refused_connect
-
-    e = assert_raises Net::HTTP::Persistent::Error do
-      @http.connection_for @uri
+      assert_same cached, c
+      assert_equal 0, cached.requests, 'connection not reset due to timeout'
     end
-
-    assert_equal 'connection refused: example.com:80', e.message
   end
 
   def test_connection_for_finished_ssl
     skip 'OpenSSL is missing' unless HAVE_OPENSSL
 
     uri = URI.parse 'https://example.com/path'
-    c = @http.connection_for uri
 
-    assert c.started?
-    assert c.use_ssl?
+    @http.connection_for uri do |c|
+      assert c.http.started?
+      assert c.http.use_ssl?
 
-    @http.finish c
+      @http.finish c
 
-    refute c.started?
+      refute c.http.started?
+    end
 
-    c2 = @http.connection_for uri
+    @http.connection_for uri do |c2|
+      assert c2.http.started?
+    end
+  end
 
-    assert c2.started?
+  def test_connection_for_ipv6
+    @http.connection_for @uri_v6 do |c|
+      assert_equal '2001:db8::1', c.http.address
+    end
   end
 
   def test_connection_for_host_down
-    cached = basic_connection
-    def cached.start; raise Errno::EHOSTDOWN end
-    def cached.started?; false end
-    conns[0]['example.com:80'] = cached
+    c = basic_connection
+    def (c.http).start; raise Errno::EHOSTDOWN end
+    def (c.http).started?; false end
 
     e = assert_raises Net::HTTP::Persistent::Error do
-      @http.connection_for @uri
+      @http.connection_for @uri do end
     end
 
     assert_equal 'host down: example.com:80', e.message
@@ -440,8 +400,10 @@ class TestNetHttpPersistent < Minitest::Test
 
   def test_connection_for_http_class_with_fakeweb
     Object.send :const_set, :FakeWeb, nil
-    c = @http.connection_for @uri
-    assert_instance_of Net::HTTP, c
+
+    @http.connection_for @uri do |c|
+      assert_instance_of Net::HTTP, c.http
+    end
   ensure
     if Object.const_defined?(:FakeWeb) then
       Object.send :remove_const, :FakeWeb
@@ -450,8 +412,9 @@ class TestNetHttpPersistent < Minitest::Test
 
   def test_connection_for_http_class_with_webmock
     Object.send :const_set, :WebMock, nil
-    c = @http.connection_for @uri
-    assert_instance_of Net::HTTP, c
+    @http.connection_for @uri do |c|
+      assert_instance_of Net::HTTP, c.http
+    end
   ensure
     if Object.const_defined?(:WebMock) then
       Object.send :remove_const, :WebMock
@@ -460,8 +423,9 @@ class TestNetHttpPersistent < Minitest::Test
 
   def test_connection_for_http_class_with_artifice
     Object.send :const_set, :Artifice, nil
-    c = @http.connection_for @uri
-    assert_instance_of Net::HTTP, c
+    @http.connection_for @uri do |c|
+      assert_instance_of Net::HTTP, c.http
+    end
   ensure
     if Object.const_defined?(:Artifice) then
       Object.send :remove_const, :Artifice
@@ -469,23 +433,12 @@ class TestNetHttpPersistent < Minitest::Test
   end
 
   def test_connection_for_name
-    http = Net::HTTP::Persistent.new 'name'
+    http = Net::HTTP::Persistent.new name: 'name'
     uri = URI.parse 'http://example/'
 
-    c = http.connection_for uri
-
-    assert c.started?
-
-    refute_includes conns.keys, 'example:80'
-  end
-
-  def test_connection_for_no_ssl_reuse
-    @http.reuse_ssl_sessions = false
-    @http.open_timeout = 123
-    @http.read_timeout = 321
-    c = @http.connection_for @uri
-
-    assert_instance_of Net::HTTP, c
+    http.connection_for uri do |c|
+      assert c.http.started?
+    end
   end
 
   def test_connection_for_proxy
@@ -493,16 +446,20 @@ class TestNetHttpPersistent < Minitest::Test
     uri.user     = 'johndoe'
     uri.password = 'muffins'
 
-    http = Net::HTTP::Persistent.new nil, uri
+    http = Net::HTTP::Persistent.new proxy: uri
 
-    c = http.connection_for @uri
+    used = http.connection_for @uri do |c|
+      assert c.http.started?
+      assert c.http.proxy?
 
-    assert c.started?
-    assert c.proxy?
+      c
+    end
 
-    assert_includes conns[1].keys,
-                    'example.com:80:proxy.example:80:johndoe:muffins'
-    assert_same c, conns[1]['example.com:80:proxy.example:80:johndoe:muffins']
+    stored = http.pool.checkout ['example.com', 80,
+                                 'proxy.example', 80,
+                                 'johndoe', 'muffins']
+
+    assert_same used, stored
   end
 
   def test_connection_for_proxy_unescaped
@@ -511,25 +468,28 @@ class TestNetHttpPersistent < Minitest::Test
     uri.password = 'muf%3Afins'
     uri.freeze
 
-    http = Net::HTTP::Persistent.new nil, uri
-    c = http.connection_for @uri
+    http = Net::HTTP::Persistent.new proxy: uri
+
+    http.connection_for @uri do end
+
+    stored = http.pool.checkout ['example.com', 80,
+                                 'proxy.example', 80,
+                                 'john@doe', 'muf:fins']
 
-    assert_includes conns[1].keys,
-                    'example.com:80:proxy.example:80:john@doe:muf:fins'
+    assert stored
   end
 
   def test_connection_for_proxy_host_down
     Net::HTTP.use_connect :host_down_connect
-    Net::HTTP::Persistent::SSLReuse.use_connect :host_down_connect
 
     uri = URI.parse 'http://proxy.example'
     uri.user     = 'johndoe'
     uri.password = 'muffins'
 
-    http = Net::HTTP::Persistent.new nil, uri
+    http = Net::HTTP::Persistent.new proxy: uri
 
     e = assert_raises Net::HTTP::Persistent::Error do
-      http.connection_for @uri
+      http.connection_for @uri do end
     end
 
     assert_equal 'host down: proxy.example:80', e.message
@@ -537,16 +497,15 @@ class TestNetHttpPersistent < Minitest::Test
 
   def test_connection_for_proxy_refused
     Net::HTTP.use_connect :refused_connect
-    Net::HTTP::Persistent::SSLReuse.use_connect :refused_connect
 
     uri = URI.parse 'http://proxy.example'
     uri.user     = 'johndoe'
     uri.password = 'muffins'
 
-    http = Net::HTTP::Persistent.new nil, uri
+    http = Net::HTTP::Persistent.new proxy: uri
 
     e = assert_raises Net::HTTP::Persistent::Error do
-      http.connection_for @uri
+      http.connection_for @uri do end
     end
 
     assert_equal 'connection refused: proxy.example:80', e.message
@@ -558,38 +517,52 @@ class TestNetHttpPersistent < Minitest::Test
     uri.password = 'muffins'
     uri.query    = 'no_proxy=example.com'
 
-    http = Net::HTTP::Persistent.new nil, uri
+    http = Net::HTTP::Persistent.new proxy: uri
 
-    c = http.connection_for @uri
+    http.connection_for @uri do |c|
+      assert c.http.started?
+      refute c.http.proxy?
+    end
 
-    assert c.started?
-    refute c.proxy?
+    stored = http.pool.checkout ['example.com', 80]
 
-    assert_includes conns[1].keys, 'example.com:80'
-    assert_same c, conns[1]['example.com:80']
+    assert stored
+  end
+
+  def test_connection_for_no_proxy_from_env
+    ENV['http_proxy'] = 'proxy.example'
+    ENV['no_proxy'] = 'localhost, example.com,'
+    ENV['proxy_user'] = 'johndoe'
+    ENV['proxy_password'] = 'muffins'
+
+    http = Net::HTTP::Persistent.new proxy: :ENV
+
+    http.connection_for @uri do |c|
+      assert c.http.started?
+      refute c.http.proxy?
+      refute c.http.proxy_from_env?
+    end
   end
 
   def test_connection_for_refused
-    cached = basic_connection
-    def cached.start; raise Errno::ECONNREFUSED end
-    def cached.started?; false end
-    conns[0]['example.com:80'] = cached
+    Net::HTTP.use_connect :refused_connect
 
     e = assert_raises Net::HTTP::Persistent::Error do
-      @http.connection_for @uri
+      @http.connection_for @uri do end
     end
 
-    assert_match %r%connection refused%, e.message
+    assert_equal 'connection refused: example.com:80', e.message
   end
 
   def test_connection_for_ssl
     skip 'OpenSSL is missing' unless HAVE_OPENSSL
 
     uri = URI.parse 'https://example.com/path'
-    c = @http.connection_for uri
 
-    assert c.started?
-    assert c.use_ssl?
+    @http.connection_for uri do |c|
+      assert c.http.started?
+      assert c.http.use_ssl?
+    end
   end
 
   def test_connection_for_ssl_cached
@@ -597,11 +570,11 @@ class TestNetHttpPersistent < Minitest::Test
 
     @uri = URI.parse 'https://example.com/path'
 
-    cached = ssl_connection 0
-
-    c = @http.connection_for @uri
+    cached = ssl_connection
 
-    assert_same cached, c
+    @http.connection_for @uri do |c|
+      assert_same cached, c
+    end
   end
 
   def test_connection_for_ssl_cached_reconnect
@@ -611,46 +584,38 @@ class TestNetHttpPersistent < Minitest::Test
 
     cached = ssl_connection
 
-    @http.reconnect_ssl
+    ssl_generation = @http.ssl_generation
 
-    c = @http.connection_for @uri
+    @http.reconnect_ssl
 
-    refute_same cached, c
+    @http.connection_for @uri do |c|
+      assert_same cached, c
+      refute_equal ssl_generation, c.ssl_generation
+    end
   end
 
   def test_connection_for_ssl_case
     skip 'OpenSSL is missing' unless HAVE_OPENSSL
 
     uri = URI.parse 'HTTPS://example.com/path'
-    c = @http.connection_for uri
-
-    assert c.started?
-    assert c.use_ssl?
+    @http.connection_for uri do |c|
+      assert c.http.started?
+      assert c.http.use_ssl?
+    end
   end
 
   def test_connection_for_timeout
     cached = basic_connection
-    cached.start
-    reqs[cached.object_id] = 10
-    touts[cached.object_id] = Time.now - 6
-    conns[0]['example.com:80'] = cached
+    cached.http.start
+    cached.requests = 10
+    cached.last_use = Time.now - 6
 
-    c = @http.connection_for @uri
-
-    assert c.started?
-    assert_equal 0, reqs[c.object_id]
-
-    assert_same cached, c
-  end
+    @http.connection_for @uri do |c|
+      assert c.http.started?
+      assert_equal 0, c.requests
 
-  def test_error_message
-    c = basic_connection
-    touts[c.object_id] = Time.now - 1
-    reqs[c.object_id] = 5
-
-    message = @http.error_message(c)
-    assert_match %r%after 4 requests on #{c.object_id}%, message
-    assert_match %r%, last used [\d.]+ seconds ago%, message
+      assert_same cached, c
+    end
   end
 
   def test_escape
@@ -667,8 +632,8 @@ class TestNetHttpPersistent < Minitest::Test
 
   def test_expired_eh
     c = basic_connection
-    reqs[c.object_id] = 0
-    touts[c.object_id] = Time.now - 11
+    c.requests = 0
+    c.last_use = Time.now - 11
 
     @http.idle_timeout = 0
     assert @http.expired? c
@@ -688,41 +653,59 @@ class TestNetHttpPersistent < Minitest::Test
 
   def test_expired_due_to_max_requests
     c = basic_connection
-    reqs[c.object_id] = 0
-    touts[c.object_id] = Time.now
+    c.requests = 0
+    c.last_use = Time.now
 
     refute @http.expired? c
 
-    reqs[c.object_id] = 10
+    c.requests = 10
     refute @http.expired? c
 
     @http.max_requests = 10
     assert @http.expired? c
 
-    reqs[c.object_id] = 9
+    c.requests = 9
     refute @http.expired? c
   end
 
   def test_finish
     c = basic_connection
-    reqs[c.object_id] = 5
+    c.requests = 5
+    c.http.instance_variable_set(:@last_communicated, Process.clock_gettime(Process::CLOCK_MONOTONIC))
 
     @http.finish c
 
-    refute c.started?
-    assert c.finished?
-    assert_equal 0, reqs[c.object_id]
+    refute c.http.started?
+    assert c.http.finished?
+
+    assert_equal 0, c.requests
+    assert_equal Net::HTTP::Persistent::EPOCH, c.last_use
+    assert_nil c.http.instance_variable_get(:@last_communicated)
   end
 
   def test_finish_io_error
     c = basic_connection
-    def c.finish; @finished += 1; raise IOError end
-    reqs[c.object_id] = 5
+    def (c.http).finish; @finished += 1; raise IOError end
+    c.requests = 5
+
+    @http.finish c
+
+    refute c.http.started?
+    assert c.http.finished?
+  end
+
+  def test_finish_ssl_no_session_reuse
+    http = Net::HTTP.new 'localhost', 443, ssl: true
+    http.instance_variable_set :@ssl_session, :something
+
+    c = Net::HTTP::Persistent::Connection.allocate
+    c.instance_variable_set :@http, http
+
+    @http.reuse_ssl_sessions = false
 
     @http.finish c
 
-    refute c.started?
-    assert c.finished?
+    assert_nil c.http.instance_variable_get :@ssl_session
   end
 
   def test_http_version
@@ -735,23 +718,21 @@ class TestNetHttpPersistent < Minitest::Test
     assert_equal '1.1', @http.http_version(@uri)
   end
 
-  def test_idempotent_eh
-    assert @http.idempotent? Net::HTTP::Delete.new '/'
-    assert @http.idempotent? Net::HTTP::Get.new '/'
-    assert @http.idempotent? Net::HTTP::Head.new '/'
-    assert @http.idempotent? Net::HTTP::Options.new '/'
-    assert @http.idempotent? Net::HTTP::Put.new '/'
-    assert @http.idempotent? Net::HTTP::Trace.new '/'
+  def test_http_version_IPv6
+    assert_nil @http.http_version @uri_v6
 
-    refute @http.idempotent? Net::HTTP::Post.new '/'
-  end
+    connection @uri_v6
 
-  def test_max_age
-    assert_in_delta Time.now - 5, @http.max_age
+    @http.request @uri_v6
 
-    @http.idle_timeout = nil
+    assert_equal '1.1', @http.http_version(@uri_v6)
+  end
+
+  def test_max_retries_equals
+    @http.max_retries = 5
 
-    assert_in_delta Time.now + 1, @http.max_age
+    assert_equal 5, @http.max_retries
+    assert_equal 1, @http.generation
   end
 
   def test_normalize_uri
@@ -774,8 +755,7 @@ class TestNetHttpPersistent < Minitest::Test
     skip 'net-http-pipeline not installed' unless defined?(Net::HTTP::Pipeline)
 
     cached = basic_connection
-    cached.start
-    conns['example.com:80'] = cached
+    cached.http.start
 
     requests = [
       Net::HTTP::Get.new((@uri + '1').request_uri),
@@ -810,7 +790,7 @@ class TestNetHttpPersistent < Minitest::Test
   def test_proxy_equals_nil
     @http.proxy = nil
 
-    assert_equal nil, @http.proxy_uri
+    assert_nil @http.proxy_uri
 
     assert_equal 1, @http.generation, 'generation'
     assert_equal 1, @http.ssl_generation, 'ssl_generation'
@@ -824,6 +804,14 @@ class TestNetHttpPersistent < Minitest::Test
     assert_equal proxy_uri, @http.proxy_uri
   end
 
+  def test_proxy_equals_uri_IPv6
+    proxy_uri = @uri_v6
+
+    @http.proxy = proxy_uri
+
+    assert_equal proxy_uri, @http.proxy_uri
+  end
+
   def test_proxy_from_env
     ENV['http_proxy']      = 'proxy.example'
     ENV['http_proxy_user'] = 'johndoe'
@@ -935,18 +923,47 @@ class TestNetHttpPersistent < Minitest::Test
   end
 
   def test_reconnect_ssl
-    result = @http.reconnect_ssl
+    skip 'OpenSSL is missing' unless HAVE_OPENSSL
 
-    assert_equal 1, result
+    @uri = URI 'https://example.com'
+    now = Time.now
+
+    ssl_http = ssl_connection
+
+    def (ssl_http.http).finish
+      @started = 0
+    end
+
+    used1 = @http.connection_for @uri do |c|
+      c.requests = 1
+      c.last_use = now
+      c
+    end
+
+    assert_equal OpenSSL::SSL::VERIFY_PEER, used1.http.verify_mode
+
+    @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    @http.reconnect_ssl
+
+    used2 = @http.connection_for @uri do |c|
+      c
+    end
+
+    assert_same used1, used2
+
+    assert_equal OpenSSL::SSL::VERIFY_NONE, used2.http.verify_mode,
+                 'verify mode must change'
+    assert_equal 0, used2.requests
+    assert_equal Net::HTTP::Persistent::EPOCH, used2.last_use
   end
 
-  def test_request
+  def test_requestx
     @http.override_headers['user-agent'] = 'test ua'
     @http.headers['accept'] = 'text/*'
     c = connection
 
     res = @http.request @uri
-    req = c.req
+    req = c.http.req
 
     assert_kind_of Net::HTTPResponse, res
 
@@ -959,86 +976,9 @@ class TestNetHttpPersistent < Minitest::Test
     assert_equal 'keep-alive', req['connection']
     assert_equal '30',         req['keep-alive']
 
-    assert_in_delta Time.now, touts[c.object_id]
-
-    assert_equal 1, reqs[c.object_id]
-  end
-
-  def test_request_ETIMEDOUT
-    c = basic_connection
-    def c.request(*a) raise Errno::ETIMEDOUT, "timed out" end
-
-    e = assert_raises Net::HTTP::Persistent::Error do
-      @http.request @uri
-    end
-
-    assert_equal 0, reqs[c.object_id]
-    assert_match %r%too many connection resets%, e.message
-  end
-
-  def test_request_bad_response
-    c = basic_connection
-    def c.request(*a) raise Net::HTTPBadResponse end
-
-    e = assert_raises Net::HTTP::Persistent::Error do
-      @http.request @uri
-    end
-
-    assert_equal 0, reqs[c.object_id]
-    assert_match %r%too many bad responses%, e.message
-  end
-
-  if RUBY_1 then
-    def test_request_bad_response_retry
-      c = basic_connection
-      def c.request(*a)
-        if defined? @called then
-          r = Net::HTTPResponse.allocate
-          r.instance_variable_set :@header, {}
-          def r.http_version() '1.1' end
-          r
-        else
-          @called = true
-          raise Net::HTTPBadResponse
-        end
-      end
-
-      @http.request @uri
-
-      assert c.finished?
-    end
-  else
-    def test_request_bad_response_retry
-      c = basic_connection
-      def c.request(*a)
-        raise Net::HTTPBadResponse
-      end
-
-      assert_raises Net::HTTP::Persistent::Error do
-        @http.request @uri
-      end
+    assert_in_delta Time.now, c.last_use
 
-      assert c.finished?
-    end
-  end
-
-  def test_request_bad_response_unsafe
-    c = basic_connection
-    def c.request(*a)
-      if instance_variable_defined? :@request then
-        raise 'POST must not be retried'
-      else
-        @request = true
-        raise Net::HTTPBadResponse
-      end
-    end
-
-    e = assert_raises Net::HTTP::Persistent::Error do
-      @http.request @uri, Net::HTTP::Post.new(@uri.path)
-    end
-
-    assert_equal 0, reqs[c.object_id]
-    assert_match %r%too many bad responses%, e.message
+    assert_equal 1, c.requests
   end
 
   def test_request_block
@@ -1050,7 +990,7 @@ class TestNetHttpPersistent < Minitest::Test
       body = r.read_body
     end
 
-    req = c.req
+    req = c.http.req
 
     assert_kind_of Net::HTTPResponse, res
     refute_nil body
@@ -1061,17 +1001,17 @@ class TestNetHttpPersistent < Minitest::Test
     assert_equal '30',         req['keep-alive']
     assert_match %r%test ua%,  req['user-agent']
 
-    assert_equal 1, reqs[c.object_id]
+    assert_equal 1, c.requests
   end
 
   def test_request_close_1_0
     c = connection
 
-    class << c
+    class << c.http
       remove_method :request
     end
 
-    def c.request req
+    def (c.http).request req
       @req = req
       r = Net::HTTPResponse.allocate
       r.instance_variable_set :@header, {}
@@ -1084,7 +1024,7 @@ class TestNetHttpPersistent < Minitest::Test
     request = Net::HTTP::Get.new @uri.request_uri
 
     res = @http.request @uri, request
-    req = c.req
+    req = c.http.req
 
     assert_kind_of Net::HTTPResponse, res
 
@@ -1093,7 +1033,7 @@ class TestNetHttpPersistent < Minitest::Test
     assert_equal 'keep-alive', req['connection']
     assert_equal '30',         req['keep-alive']
 
-    assert c.finished?
+    assert c.http.finished?
   end
 
   def test_request_connection_close_request
@@ -1103,26 +1043,26 @@ class TestNetHttpPersistent < Minitest::Test
     request['connection'] = 'close'
 
     res = @http.request @uri, request
-    req = c.req
+    req = c.http.req
 
     assert_kind_of Net::HTTPResponse, res
 
     assert_kind_of Net::HTTP::Get, req
     assert_equal '/path',      req.path
     assert_equal 'close',      req['connection']
-    assert_equal nil,          req['keep-alive']
+    assert_nil req['keep-alive']
 
-    assert c.finished?
+    assert c.http.finished?
   end
 
   def test_request_connection_close_response
     c = connection
 
-    class << c
+    class << c.http
       remove_method :request
     end
 
-    def c.request req
+    def (c.http).request req
       @req = req
       r = Net::HTTPResponse.allocate
       r.instance_variable_set :@header, {}
@@ -1136,7 +1076,7 @@ class TestNetHttpPersistent < Minitest::Test
     request = Net::HTTP::Get.new @uri.request_uri
 
     res = @http.request @uri, request
-    req = c.req
+    req = c.http.req
 
     assert_kind_of Net::HTTPResponse, res
 
@@ -1145,53 +1085,33 @@ class TestNetHttpPersistent < Minitest::Test
     assert_equal 'keep-alive', req['connection']
     assert_equal '30',         req['keep-alive']
 
-    assert c.finished?
+    assert c.http.finished?
   end
 
   def test_request_exception
     c = basic_connection
-    def c.request(*a) raise Exception, "very bad things happened" end
+    def (c.http).request(*a)
+      raise Exception, "very bad things happened"
+    end
 
     assert_raises Exception do
       @http.request @uri
     end
 
-    assert_equal 0, reqs[c.object_id]
-    assert c.finished?
+    assert_equal 0, c.requests
+    assert c.http.finished?
   end
 
   def test_request_invalid
     c = basic_connection
-    def c.request(*a) raise Errno::EINVAL, "write" end
+    def (c.http).request(*a) raise Errno::EINVAL, "write" end
 
-    e = assert_raises Net::HTTP::Persistent::Error do
+    e = assert_raises Errno::EINVAL do
       @http.request @uri
     end
 
-    assert_equal 0, reqs[c.object_id]
-    assert_match %r%too many connection resets%, e.message
-  end
-
-  def test_request_invalid_retry
-    c = basic_connection
-    touts[c.object_id] = Time.now
-
-    def c.request(*a)
-      if defined? @called then
-        r = Net::HTTPResponse.allocate
-        r.instance_variable_set :@header, {}
-        def r.http_version() '1.1' end
-        r
-      else
-        @called = true
-        raise Errno::EINVAL, "write"
-      end
-    end
-
-    @http.request @uri
-
-    assert c.reset?
-    assert c.finished?
+    assert_equal 0, c.requests
+    assert_match %r%Invalid argument - write%, e.message
   end
 
   def test_request_post
@@ -1200,96 +1120,11 @@ class TestNetHttpPersistent < Minitest::Test
     post = Net::HTTP::Post.new @uri.path
 
     @http.request @uri, post
-    req = c.req
+    req = c.http.req
 
     assert_same post, req
   end
 
-  def test_request_reset
-    c = basic_connection
-    def c.request(*a) raise Errno::ECONNRESET end
-
-    e = assert_raises Net::HTTP::Persistent::Error do
-      @http.request @uri
-    end
-
-    assert_equal 0, reqs[c.object_id]
-    assert_match %r%too many connection resets%, e.message
-  end
-
-  if RUBY_1 then
-    def test_request_reset_retry
-      c = basic_connection
-      touts[c.object_id] = Time.now
-      def c.request(*a)
-        if defined? @called then
-          r = Net::HTTPResponse.allocate
-          r.instance_variable_set :@header, {}
-          def r.http_version() '1.1' end
-          r
-        else
-          @called = true
-          raise Errno::ECONNRESET
-        end
-      end
-
-      @http.request @uri
-
-      assert c.reset?
-      assert c.finished?
-    end
-  else
-    def test_request_reset_retry
-      c = basic_connection
-      touts[c.object_id] = Time.now
-
-      def c.request(*a)
-        raise Errno::ECONNRESET
-      end
-
-      assert_raises Net::HTTP::Persistent::Error do
-        @http.request @uri
-      end
-
-      refute c.reset?
-      assert c.finished?
-    end
-  end
-
-  def test_request_reset_unsafe
-    c = basic_connection
-    def c.request(*a)
-      if instance_variable_defined? :@request then
-        raise 'POST must not be retried'
-      else
-        @request = true
-        raise Errno::ECONNRESET
-      end
-    end
-
-    e = assert_raises Net::HTTP::Persistent::Error do
-      @http.request @uri, Net::HTTP::Post.new(@uri.path)
-    end
-
-    assert_equal 0, reqs[c.object_id]
-    assert_match %r%too many connection resets%, e.message
-  end
-
-  def test_request_ssl_error
-    skip 'OpenSSL is missing' unless HAVE_OPENSSL
-
-    uri = URI.parse 'https://example.com/path'
-    c = @http.connection_for uri
-    def c.request(*)
-      raise OpenSSL::SSL::SSLError, "SSL3_WRITE_PENDING:bad write retry"
-    end
-
-    e = assert_raises Net::HTTP::Persistent::Error do
-      @http.request uri
-    end
-    assert_match %r%bad write retry%, e.message
-  end
-
   def test_request_setup
     @http.override_headers['user-agent'] = 'test ua'
     @http.headers['accept'] = 'text/*'
@@ -1308,59 +1143,51 @@ class TestNetHttpPersistent < Minitest::Test
     assert_equal '30',         req['keep-alive']
   end
 
-  def test_request_setup_uri
-    uri = @uri + '?a=b'
-
-    req = @http.request_setup uri
+  def test_request_string
+    @http.override_headers['user-agent'] = 'test ua'
+    @http.headers['accept'] = 'text/*'
+    c = connection
 
-    assert_kind_of Net::HTTP::Get, req
-    assert_equal '/path?a=b',  req.path
-  end
+    res = @http.request @uri.to_s
+    req = c.http.req
 
-  def test_request_failed
-    c = basic_connection
-    reqs[c.object_id] = 1
-    touts[c.object_id] = Time.now
+    assert_kind_of Net::HTTPResponse, res
 
-    original = nil
+    assert_kind_of Net::HTTP::Get, req
+    assert_equal '/path',      req.path
 
-    begin
-      raise 'original'
-    rescue => original
-    end
+    assert_equal 1, c.requests
+  end
 
-    req = Net::HTTP::Get.new '/'
-      
-    e = assert_raises Net::HTTP::Persistent::Error do
-      @http.request_failed original, req, c
-    end
+  def test_request_setup_uri
+    uri = @uri + '?a=b'
 
-    assert_match "too many connection resets (due to original - RuntimeError)",
-                 e.message
+    req = @http.request_setup uri
 
-    assert_equal original.backtrace, e.backtrace
+    assert_kind_of Net::HTTP::Get, req
+    assert_equal '/path?a=b',  req.path
   end
 
   def test_reset
     c = basic_connection
-    c.start
-    touts[c.object_id] = Time.now
-    reqs[c.object_id]  = 5
+    c.http.start
+    c.last_use = Time.now
+    c.requests  = 5
 
     @http.reset c
 
-    assert c.started?
-    assert c.finished?
-    assert c.reset?
-    assert_equal 0, reqs[c.object_id]
-    assert_equal Net::HTTP::Persistent::EPOCH, touts[c.object_id]
+    assert c.http.started?
+    assert c.http.finished?
+    assert c.http.reset?
+    assert_equal 0, c.requests
+    assert_equal Net::HTTP::Persistent::EPOCH, c.last_use
   end
 
   def test_reset_host_down
     c = basic_connection
-    touts[c.object_id] = Time.now
-    def c.start; raise Errno::EHOSTDOWN end
-    reqs[c.object_id] = 5
+    c.last_use = Time.now
+    def (c.http).start; raise Errno::EHOSTDOWN end
+    c.requests = 5
 
     e = assert_raises Net::HTTP::Persistent::Error do
       @http.reset c
@@ -1372,20 +1199,20 @@ class TestNetHttpPersistent < Minitest::Test
 
   def test_reset_io_error
     c = basic_connection
-    touts[c.object_id] = Time.now
-    reqs[c.object_id] = 5
+    c.last_use = Time.now
+    c.requests = 5
 
     @http.reset c
 
-    assert c.started?
-    assert c.finished?
+    assert c.http.started?
+    assert c.http.finished?
   end
 
   def test_reset_refused
     c = basic_connection
-    touts[c.object_id] = Time.now
-    def c.start; raise Errno::ECONNREFUSED end
-    reqs[c.object_id] = 5
+    c.last_use = Time.now
+    def (c.http).start; raise Errno::ECONNREFUSED end
+    c.requests = 5
 
     e = assert_raises Net::HTTP::Persistent::Error do
       @http.reset c
@@ -1395,167 +1222,39 @@ class TestNetHttpPersistent < Minitest::Test
     assert_match __FILE__, e.backtrace.first
   end
 
-  def test_retry_change_requests_equals
-    get  = Net::HTTP::Get.new('/')
-    post = Net::HTTP::Post.new('/')
-
-    refute @http.retry_change_requests
-
-    if RUBY_1 then
-      assert @http.can_retry?(get)
-    else
-      assert @http.can_retry?(get)
-    end
-    refute @http.can_retry?(get, true)
-    refute @http.can_retry?(post)
-
-    @http.retry_change_requests = true
-
-    assert @http.retry_change_requests
-
-    if RUBY_1 then
-      assert @http.can_retry?(get)
-    else
-      assert @http.can_retry?(get)
-      refute @http.can_retry?(get, true)
-    end
-
-    assert @http.can_retry?(post)
-  end
-
   def test_shutdown
-    ssl_conns
     c = connection
-    rs = reqs
-    ts = touts
 
     orig = @http
-    @http = Net::HTTP::Persistent.new 'name'
+    @http = Net::HTTP::Persistent.new name: 'name'
     c2 = connection
 
     orig.shutdown
 
     @http = orig
 
-    assert c.finished?, 'last-generation connection must be finished'
-    refute c2.finished?, 'present generation connection must not be finished'
-
-    refute_same rs, reqs
-    refute_same ts, touts
-
-    assert_empty conns
-    assert_empty ssl_conns
-
-    assert_empty reqs
-    assert_empty touts
-  end
-
-  def test_shutdown_in_all_threads
-    conns
-    ssl_conns
-
-    t = Thread.new do
-      c = connection
-      ssl_conns
-      conns
-      reqs
-
-      Thread.stop
-
-      c
-    end
-
-    Thread.pass until t.status == 'sleep'
-
-    c = connection
-
-    assert_nil @http.shutdown_in_all_threads
-
-    assert c.finished?, 'connection in same thread must be finished'
-
-    assert_empty Thread.current[@http.generation_key]
-
-    assert_nil Thread.current[@http.request_key]
-
-    t.run
-    assert t.value.finished?, 'connection in other thread must be finished'
-
-    assert_empty t[@http.generation_key]
-
-    assert_nil t[@http.request_key]
-  end
-
-  def test_shutdown_no_connections
-    @http.shutdown
-
-    assert_nil Thread.current[@http.generation_key]
-    assert_nil Thread.current[@http.ssl_generation_key]
-
-    assert_nil Thread.current[@http.request_key]
-    assert_nil Thread.current[@http.timeout_key]
-  end
-
-  def test_shutdown_not_started
-    ssl_conns
-
-    c = basic_connection
-    def c.finish() raise IOError end
-
-    conns[0]["#{@uri.host}:#{@uri.port}"] = c
-
-    @http.shutdown
-
-    assert_empty Thread.current[@http.generation_key]
-    assert_empty Thread.current[@http.ssl_generation_key]
-
-    assert_nil Thread.current[@http.request_key]
-    assert_nil Thread.current[@http.timeout_key]
+    assert c.http.finished?, 'last-generation connection must be finished'
+    refute c2.http.finished?, 'present generation connection must not be finished'
   end
 
-  def test_shutdown_ssl
+  def test_ssl
     skip 'OpenSSL is missing' unless HAVE_OPENSSL
 
-    @uri = URI 'https://example'
-
-    @http.connection_for @uri
-
-    @http.shutdown
-
-    assert_empty ssl_conns
-  end
-
-  def test_shutdown_thread
-    t = Thread.new do
-      c = connection
-      conns
-      ssl_conns
-
-      reqs
-
-      Thread.stop
-
-      c
-    end
-
-    Thread.pass until t.status == 'sleep'
-
-    c = connection
-
-    @http.shutdown t
+    @http.verify_callback = :callback
+    c = Net::HTTP.new 'localhost', 80
 
-    refute c.finished?
+    @http.ssl c
 
-    t.run
-    assert t.value.finished?
-    assert_empty t[@http.generation_key]
-    assert_empty t[@http.ssl_generation_key]
-    assert_nil t[@http.request_key]
-    assert_nil t[@http.timeout_key]
+    assert c.use_ssl?
+    assert_equal OpenSSL::SSL::VERIFY_PEER, c.verify_mode
+    assert_kind_of OpenSSL::X509::Store,    c.cert_store
+    assert_nil c.verify_callback
   end
 
-  def test_ssl
+  def test_ssl_ca_file
     skip 'OpenSSL is missing' unless HAVE_OPENSSL
 
+    @http.ca_file = 'ca_file'
     @http.verify_callback = :callback
     c = Net::HTTP.new 'localhost', 80
 
@@ -1563,14 +1262,13 @@ class TestNetHttpPersistent < Minitest::Test
 
     assert c.use_ssl?
     assert_equal OpenSSL::SSL::VERIFY_PEER, c.verify_mode
-    assert_kind_of OpenSSL::X509::Store,    c.cert_store
-    assert_nil c.verify_callback
+    assert_equal :callback, c.verify_callback
   end
 
-  def test_ssl_ca_file
+  def test_ssl_ca_path
     skip 'OpenSSL is missing' unless HAVE_OPENSSL
 
-    @http.ca_file = 'ca_file'
+    @http.ca_path = 'ca_path'
     @http.verify_callback = :callback
     c = Net::HTTP.new 'localhost', 80
 
@@ -1667,34 +1365,37 @@ class TestNetHttpPersistent < Minitest::Test
     end
   end
 
-  def test_ssl_cleanup
-    skip 'OpenSSL is missing' unless HAVE_OPENSSL
-
-    uri1 = URI.parse 'https://one.example'
+  def test_ssl_timeout_equals
+    @http.ssl_timeout = :ssl_timeout
 
-    c1 = @http.connection_for uri1
+    assert_equal :ssl_timeout, @http.ssl_timeout
+    assert_equal 1, @http.ssl_generation
+  end
 
-    touts[c1.object_id] = Time.now
-    reqs[c1.object_id] = 5
+  def test_ssl_version_equals
+    @http.ssl_version = :ssl_version
 
-    @http.reconnect_ssl
+    assert_equal :ssl_version, @http.ssl_version
+    assert_equal 1, @http.ssl_generation
+  end
 
-    @http.ssl_cleanup @http.ssl_generation
+  def test_min_version_equals
+    @http.min_version = :min_version
 
-    assert_empty ssl_conns
-    assert_empty touts
-    assert_empty reqs # sanity check, performed by #finish
+    assert_equal :min_version, @http.min_version
+    assert_equal 1, @http.ssl_generation
   end
 
-  def test_ssl_version_equals
-    @http.ssl_version = :ssl_version
+  def test_max_version_equals
+    @http.max_version = :max_version
 
-    assert_equal :ssl_version, @http.ssl_version
+    assert_equal :max_version, @http.max_version
     assert_equal 1, @http.ssl_generation
-  end unless RUBY_1
+  end
 
   def test_start
     c = basic_connection
+    c = c.http
 
     @http.socket_options << [Socket::SOL_SOCKET, Socket::SO_KEEPALIVE, 1]
     @http.debug_output = $stderr
@@ -1722,6 +1423,13 @@ class TestNetHttpPersistent < Minitest::Test
     assert_equal 1, @http.ssl_generation
   end
 
+  def test_verify_depth_equals
+    @http.verify_depth = :verify_depth
+
+    assert_equal :verify_depth, @http.verify_depth
+    assert_equal 1, @http.ssl_generation
+  end
+
   def test_verify_mode_equals
     @http.verify_mode = :verify_mode