net_tcp_client 1.0.2 → 2.0.0

data/lib/net/tcp_client/version.rb

@@ -1,5 +1,5 @@
 module Net
   class TCPClient #:nodoc
-    VERSION = '1.0.2'
+    VERSION = '2.0.0'
   end
 end

data/test/address_test.rb

@@ -0,0 +1,91 @@
+require_relative 'test_helper'
+require 'ipaddr'
+
+class Net::TCPClient::AddressTest < Minitest::Test
+  describe Net::TCPClient::Address do
+    describe '.ip_addresses' do
+      it 'returns the ip addresses for a known DNS' do
+        ips = Net::TCPClient::Address.ip_addresses('google.com')
+        assert ips.count > 0
+        ips.each do |ip|
+          # Validate IP Addresses
+          IPAddr.new(ip)
+        end
+      end
+
+      it 'returns an ip address' do
+        ips = Net::TCPClient::Address.ip_addresses('127.0.0.1')
+        assert_equal 1, ips.count
+        assert_equal '127.0.0.1', ips.first
+      end
+    end
+
+    describe '.addresses' do
+      it 'returns one address for a known DNS' do
+        addresses = Net::TCPClient::Address.addresses('localhost', 80)
+        assert_equal 1, addresses.count, addresses.ai
+        address = addresses.first
+        assert_equal 80, address.port
+        assert_equal '127.0.0.1', address.ip_address
+        assert_equal 'localhost', address.host_name
+      end
+
+      it 'returns addresses for a DNS with mutiple IPs' do
+        addresses = Net::TCPClient::Address.addresses('google.com', 80)
+        assert addresses.count > 0
+        addresses.each do |address|
+          # Validate IP Addresses
+          IPAddr.new(address.ip_address)
+          assert_equal 80, address.port
+          assert_equal 'google.com', address.host_name
+        end
+      end
+
+      it 'returns an ip address' do
+        addresses = Net::TCPClient::Address.addresses('127.0.0.1', 80)
+        assert_equal 1, addresses.count
+        address = addresses.first
+        assert_equal 80, address.port
+        assert_equal '127.0.0.1', address.ip_address
+        assert_equal '127.0.0.1', address.host_name
+      end
+    end
+
+    describe '.addresses_for_server_name' do
+      it 'returns addresses for server name' do
+        addresses = Net::TCPClient::Address.addresses_for_server_name('localhost:80')
+        assert_equal 1, addresses.count, addresses.ai
+        address = addresses.first
+        assert_equal 80, address.port
+        assert_equal '127.0.0.1', address.ip_address
+        assert_equal 'localhost', address.host_name
+      end
+
+      it 'returns an ip address' do
+        addresses = Net::TCPClient::Address.addresses_for_server_name('127.0.0.1:80')
+        assert_equal 1, addresses.count
+        address = addresses.first
+        assert_equal 80, address.port
+        assert_equal '127.0.0.1', address.ip_address
+        assert_equal '127.0.0.1', address.host_name
+      end
+    end
+
+    describe '.new' do
+      it 'creates an address' do
+        address = Net::TCPClient::Address.new('host_name', 'ip_address', '2000')
+        assert_equal 'host_name', address.host_name
+        assert_equal 'ip_address', address.ip_address
+        assert_equal 2000, address.port
+      end
+    end
+
+    describe '#to_s' do
+      it 'returns a string of the address' do
+        address = Net::TCPClient::Address.new('host_name', 'ip_address', '2000')
+        assert_equal 'host_name[ip_address]:2000', address.to_s
+      end
+    end
+
+  end
+end

data/test/policy/custom_policy_test.rb

@@ -0,0 +1,42 @@
+require_relative '../test_helper'
+class Net::TCPClient::Policy::CustomTest < Minitest::Test
+  describe Net::TCPClient::Policy::Custom do
+    describe '#each' do
+      before do
+        @proc = -> addresses, count do
+          addresses[count - 1]
+        end
+      end
+
+      it 'must return one server, once' do
+        servers   = ['localhost:80']
+        policy    = Net::TCPClient::Policy::Custom.new(servers, @proc)
+        collected = []
+        policy.each { |address| collected << address }
+        assert_equal 1, collected.size
+        address = collected.first
+        assert_equal 80, address.port
+        assert_equal 'localhost', address.host_name
+        assert_equal '127.0.0.1', address.ip_address
+      end
+
+      it 'must return the servers in the supplied order' do
+        servers = %w(localhost:80 127.0.0.1:2000 lvh.me:2100)
+        policy  = Net::TCPClient::Policy::Custom.new(servers, @proc)
+        names   = []
+        policy.each { |address| names << address.host_name }
+        assert_equal %w(localhost 127.0.0.1 lvh.me), names
+      end
+
+      it 'must handle an empty list of servers' do
+        servers = []
+        policy  = Net::TCPClient::Policy::Custom.new(servers, @proc)
+        names   = []
+        policy.each { |address| names << address.host_name }
+        assert_equal [], names
+      end
+    end
+
+  end
+end
+

data/test/policy/ordered_policy_test.rb

@@ -0,0 +1,36 @@
+require_relative '../test_helper'
+class Net::TCPClient::Policy::OrderedTest < Minitest::Test
+  describe Net::TCPClient::Policy::Ordered do
+    describe '#each' do
+      it 'must return one server, once' do
+        servers   = ['localhost:80']
+        policy    = Net::TCPClient::Policy::Ordered.new(servers)
+        collected = []
+        policy.each { |address| collected << address }
+        assert_equal 1, collected.size
+        address = collected.first
+        assert_equal 80, address.port
+        assert_equal 'localhost', address.host_name
+        assert_equal '127.0.0.1', address.ip_address
+      end
+
+      it 'must return the servers in the supplied order' do
+        servers = %w(localhost:80 127.0.0.1:2000 lvh.me:2100)
+        policy  = Net::TCPClient::Policy::Ordered.new(servers)
+        names   = []
+        policy.each { |address| names << address.host_name }
+        assert_equal %w(localhost 127.0.0.1 lvh.me), names
+      end
+
+      it 'must handle an empty list of servers' do
+        servers = []
+        policy  = Net::TCPClient::Policy::Ordered.new(servers)
+        names   = []
+        policy.each { |address| names << address.host_name }
+        assert_equal [], names
+      end
+    end
+
+  end
+end
+

data/test/policy/random_policy_test.rb

@@ -0,0 +1,46 @@
+require_relative '../test_helper'
+class Net::TCPClient::Policy::RandomTest < Minitest::Test
+  describe Net::TCPClient::Policy::Random do
+    describe '#each' do
+      it 'must return one server, once' do
+        servers   = ['localhost:80']
+        policy    = Net::TCPClient::Policy::Random.new(servers)
+        collected = []
+        policy.each { |address| collected << address }
+        assert_equal 1, collected.size
+        address = collected.first
+        assert_equal 80, address.port
+        assert_equal 'localhost', address.host_name
+        assert_equal '127.0.0.1', address.ip_address
+      end
+
+      it 'must return the servers in random order' do
+        servers = %w(localhost:80 127.0.0.1:2000 lvh.me:2100)
+        policy  = Net::TCPClient::Policy::Random.new(servers)
+        count   = 0
+
+        names = []
+        # It is possible the random order is the supplied order.
+        # Keep retrying until the order is different.
+        3.times do
+          policy.each { |address| names << address.host_name }
+          break if names != %w(localhost:80 127.0.0.1:2000 lvh.me:2100)
+          names = []
+        end
+
+        refute_equal %w(localhost 127.0.0.1 lvh.me), names
+        assert_equal %w(localhost 127.0.0.1 lvh.me).sort, names.sort
+      end
+
+      it 'must handle an empty list of servers' do
+        servers = []
+        policy  = Net::TCPClient::Policy::Random.new(servers)
+        names   = []
+        policy.each { |address| names << address.host_name }
+        assert_equal [], names
+      end
+    end
+
+  end
+end
+

data/test/simple_tcp_server.rb

@@ -1,4 +1,5 @@
 require 'socket'
+require 'openssl'
 require 'bson'
 require 'semantic_logger'
 
@@ -18,19 +19,34 @@ def read_bson_document(io)
   return BSON.deserialize(bytebuf)
 end
 
+def ssl_file_path(name)
+  File.join(File.dirname(__FILE__), 'ssl_files', name)
+end
+
 # Simple single threaded server for testing purposes using a local socket
 # Sends and receives BSON Messages
 class SimpleTCPServer
   include SemanticLogger::Loggable
-
   attr_accessor :thread, :server
+  attr_reader :port, :name, :ssl
 
-  def initialize(port = 2000)
-    start(port)
+  def initialize(options = {})
+    @port = (options[:port] || 2000).to_i
+    @name = options[:name] || 'tcp'
+    @ssl  = options[:ssl] || false
+    start
   end
 
-  def start(port)
-    self.server = TCPServer.open(port)
+  def start
+    tcp_server = TCPServer.open(port)
+
+    if ssl
+      context = OpenSSL::SSL::SSLContext.new
+      context.set_params(ssl)
+      tcp_server = OpenSSL::SSL::SSLServer.new(tcp_server, context)
+    end
+
+    self.server = tcp_server
     self.thread = Thread.new do
       loop do
         logger.debug 'Waiting for a client to connect'
@@ -59,6 +75,8 @@ class SimpleTCPServer
     case message['action']
     when 'test1'
       {'result' => 'test1'}
+    when 'servername'
+      {'result' => @name}
     when 'sleep'
       sleep message['duration'] || 1
       {'result' => 'sleep'}
@@ -91,9 +109,7 @@ class SimpleTCPServer
         server.close
         client.close
         logger.debug 'Server closed'
-        #thread.kill
-        logger.debug 'thread killed'
-        start(2000)
+        start
         logger.debug 'Server Restarted'
         break
       end
@@ -108,6 +124,17 @@ end
 if $0 == __FILE__
   SemanticLogger.default_level = :trace
   SemanticLogger.add_appender(STDOUT)
-  server = SimpleTCPServer.new(2000)
+  server = SimpleTCPServer.new(port: 2000)
+
+  # For SSL:
+  # server = SimpleTCPServer.new(
+  #   port: 2000,
+  #   ssl:  {
+  #     cert:    ssl_file_path('localhost-server.pem'),
+  #     key:     ssl_file_path('localhost-server-key.pem'),
+  #     ca_file: ssl_file_path('ca.pem')
+  #   }
+  # )
+
   server.thread.join
 end

data/test/ssl_files/ca.pem

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDCzCCAfOgAwIBAgIJANF9v1dJ6jhOMA0GCSqGSIb3DQEBBQUAMBwxGjAYBgNV
+BAMMEXRlc3QtdG1nYXJkbmVyLWNhMB4XDTE1MTEwNjA0NDk0NVoXDTE1MTIwNjA0
+NDk0NVowHDEaMBgGA1UEAwwRdGVzdC10bWdhcmRuZXItY2EwggEiMA0GCSqGSIb3
+DQEBAQUAA4IBDwAwggEKAoIBAQDIi3qxxegV2RYl8lEWu/iwb9tqsdEYQ1gAhdAS
+OJAJk8SfgvjlKnyx0rV2LXhORpp13uLMB5QKXS1B+JByCYEZrC3q9b9Cl58Nl4am
+ky6uI/AXvbEvzSAo2resea5JGpQDxl3UJC674QdVCGR7s7Wm7am/JEr8aami4V5O
++CmLfdr030jPaNVcqVS2Bf0AqrxNa3nWoHsPh1MG2VJRVpnqIuqPVL7yRi39/cu2
+Kd1WjJPxpbrM8H2AClX2OY6fxa3RHUUyOaveOkX5AWYXtqoMs9Evv95m4hOVAogd
+KzBjdtpTiIM+bdlpxY0y2Dpc9oibRFiLFqooB9Bb8VsmE/2JAgMBAAGjUDBOMB0G
+A1UdDgQWBBQo+GvUH8j+YFYkWtwQl32d4fVoZTAfBgNVHSMEGDAWgBQo+GvUH8j+
+YFYkWtwQl32d4fVoZTAMBgNVHRMEBTADAQH/MA0GCSqGSIb3DQEBBQUAA4IBAQAH
+RvaXH9dN3fiRvMZ8+tXY7W57jspvYtQJjNxcVGU+Pn5fznrr0E3STPoSKy6+u9rQ
+L0Jzq9e0tjbMmdbMugRjSOdVUGtXaki/YaGNkbKOsMLHWSgFHVZF3gJ83KdDuuFK
+bMTqOmrQvCG+JECH3i/lh5GHLuZlCzOmBwhzWuorjQQy/MUxQHRkHPVk4Ik7pCXm
+HsNcp9l2L5oKG8I4X54ElGXHoshdIXKUS6yKcnTJlhI2nt6cQCMzKoiVA5TxNnvz
+jdCID4nezuHFyYI3KVxsR7PzqS2fmHcfC9qGqskn+QgJ4JcwvAhT3USj4muuu3mJ
+/F9cJiBN2yeRQuknI6de
+-----END CERTIFICATE-----

data/test/ssl_files/localhost-server-key.pem

@@ -0,0 +1,27 @@
+-----BEGIN RSA PRIVATE KEY-----
+MIIEogIBAAKCAQEApAeEPJjQwT10hLgBl8550gJeBuP43R8sDO63H2Q2QsgN0sLg
+G0fzjR8qNjYf62XwADMsCE9PwheaVSM+sREbEGu80G3IICTFP5HPuqm6ugiuYZpD
+BtZgiSFM1A7ShSTR0gCWqusRaR+r/IOREftvQcjqeJP0hZxYjx4XO9jBufiQMpGq
+qPaUQC3cXv4aDoLYbHAP+XH4FxwAbEz9/qBTeAiNorL2ruFJeqMHlKPIDt6123LF
+kMZ8pxke8gqmggieKH549j8VHUSpwo2TbxSIqArM8P6wDRFrZik6ZMEIX13yuet2
+XaFMyHLMknyh2+0vKz9sup533rk7fKUKhTtJ/QIDAQABAoIBAAnOYTt2L1S+Jc8h
+aQb4UxQZDCIBUwl1KZ8ETnJT/WJ0r07gU6GN5aOUL2PaTII4L+bzKDi+9Re3bYSV
+fNP9H88Vgc48IfC6AgjQ4MhaCU3B4xr2q/cmrdLE6ODsme1XzCtv2ZISR5IvUIri
+GrQmgfo+1rWqsr2iITE9LUpopPxHJV29DIVc5EuP/c+r4TFarUFd+1JdthABE3v7
+xMgyejnLs59Dy084RcL60mpCahvIBXdKEMY8nzhN3APp7VHx/++yTvsvcG+aNVrr
+C/FixbUnQWIHCeu8lvFz6fb+mMt923ZE2mcbdmOzgZqjEQYaPxfERRDTHNz9NlPQ
+2Jahz0ECgYEA2JGdlD26KsYYBvFtNCsxw78DfonLolwcWK0pwKDtXb/3h8RWjBlu
+vmCmhE726nVl00nt2FUoGpHwcVDPwjdxFkStaSezGxEJQHEov9ZjSYJY9IdpDOhL
+Q8nz2geDL8P2Ti6pOCKPqgwgbgOsIgTYwreFG1KemsHIH2HeQZxFllkCgYEAweUC
+k3OjR1cLa5mgABLkcl8RDEBoPAFcNZg+gGgSMneEDvP2DqZ2h8CxzdG1d2VSpTHD
+IC2LeF5EwNq7h6X7Har0j+e9h1/TESqvx60ph89AxecjsEqjOBKto5rBMTOaah9M
+IXvk+fP/bwOY+6W7F4KJQk6BYw1i2FiCzivXZEUCgYAg5YWdNf8obizKKTQgX4tQ
+o5xBRWckQ3+ezLbx5sAHpJhSDDXlVBupWX8Ry/jfxnNwM+OoH89WseJnJBJa+xb3
+ffklZv1i2CSioE3DTiqIyP8ALe18I3EDXBLphIid4dNxLs9PkphmCS+H5pDoHfpb
+IYtbiiJDeboPYktjhfxgCQKBgDW8dVlOPBtCaXzZp7k9gyibZksh8oFm0xpbZj8K
+GLj53JSUUkY/Jix7YAutqgA8CYqU3wIk/TlPzvgv5rcybgUL4xma3TEOgp2IWg0Z
+1Z+49bejVoW+ObwJmSv1cMNlDM+KevvwrUYEtG8c7SIZDV/3onjI7xz3kcRpy16+
+UcSNAoGAe1sVhiyZczEZYgjKMedLvFoFaerw4Ik6PnGCi61nrQtsa3HpLd45M648
+j8/HAq7/nF+7grkPFJPFBjrx1B44k6vRZNK2hC6XexaVBgGxFktfqCfytalpL3AX
+QqQTsJcW63zEqaFJDhO0dv9oHJuSuYnHTERgVw7VwyLC+bEkYIk=
+-----END RSA PRIVATE KEY-----

data/test/ssl_files/localhost-server.pem

@@ -0,0 +1,18 @@
+-----BEGIN CERTIFICATE-----
+MIIC+TCCAeGgAwIBAgIJANNH6Xe+/HxXMA0GCSqGSIb3DQEBBQUAMBwxGjAYBgNV
+BAMMEXRlc3QtdG1nYXJkbmVyLWNhMB4XDTE1MTEwNjA0NTMwMloXDTE1MTIwNjA0
+NTMwMlowKjEoMCYGA1UEAwwfdGVzdC10bWdhcmRuZXItbG9jYWxob3N0LXNlcnZl
+cjCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAKQHhDyY0ME9dIS4AZfO
+edICXgbj+N0fLAzutx9kNkLIDdLC4BtH840fKjY2H+tl8AAzLAhPT8IXmlUjPrER
+GxBrvNBtyCAkxT+Rz7qpuroIrmGaQwbWYIkhTNQO0oUk0dIAlqrrEWkfq/yDkRH7
+b0HI6niT9IWcWI8eFzvYwbn4kDKRqqj2lEAt3F7+Gg6C2GxwD/lx+BccAGxM/f6g
+U3gIjaKy9q7hSXqjB5SjyA7etdtyxZDGfKcZHvIKpoIInih+ePY/FR1EqcKNk28U
+iKgKzPD+sA0Ra2YpOmTBCF9d8rnrdl2hTMhyzJJ8odvtLys/bLqed965O3ylCoU7
+Sf0CAwEAAaMwMC4wCQYDVR0TBAIwADALBgNVHQ8EBAMCBeAwFAYDVR0RBA0wC4IJ
+bG9jYWxob3N0MA0GCSqGSIb3DQEBBQUAA4IBAQCR6ruCXgsTyeI+RtnhfVrWlsdF
+69eQHxGeHLd882V7xN4XfIKtfpgMVp7UlXTS/Lgtw08x+2bPiPz8EPgXa0WoYRjg
+i5M/4lrK++YPMzIY4o8nJY7jRcwoWGzw3rQemrc4cjj7e9YnNLOSG/pww0ticV4F
++85IjE9rRsO4m/yla+epJTZiqJ0lSnCCaeNyW4/f4bipgA6PfddmteaJFUt+c7wF
+N992bWpb8+x0ZXGg5+A6a0NVFMu2856WeVRwMKbNwfXObDYxCdHSOufcv9hsxL4j
+fiF/R2ts5QbxYSoG2gnRPYxmyn/fnNen3f1u6iY4f8PVmb+6SOu0DH4sDf49
+-----END CERTIFICATE-----

data/test/tcp_client_test.rb

@@ -5,175 +5,239 @@ require_relative 'simple_tcp_server'
 # Unit Test for Net::TCPClient
 class TCPClientTest < Minitest::Test
   describe Net::TCPClient do
-    describe 'without server' do
-      it 'raises an exception when cannot reach server after 5 retries' do
-        exception = assert_raises Net::TCPClient::ConnectionFailure do
-          Net::TCPClient.new(
-            server:                 'localhost:3300',
-            connect_retry_interval: 0.1,
-            connect_retry_count:    5)
-        end
-        assert_match /After 5 connection attempts to host 'localhost:3300': Errno::ECONNREFUSED/, exception.message
-      end
-
-      it 'times out on connect' do
-        # Create a TCP Server, but do not respond to connections
-        server = TCPServer.open(2001)
-
-        exception = assert_raises Net::TCPClient::ConnectionTimeout do
-          1000.times do
-            Net::TCPClient.new(
-              server:              'localhost:2001',
-              connect_timeout:     0.5,
-              connect_retry_count: 3
-            )
+    [false, true].each do |with_ssl|
+      describe (with_ssl ? 'ssl' : 'non-ssl') do
+        describe '#connect' do
+          it 'raises an exception when cannot reach server after 5 retries' do
+            exception = assert_raises Net::TCPClient::ConnectionFailure do
+              new_net_tcp_client(with_ssl,
+                server:                 'localhost:3300',
+                connect_retry_interval: 0.1,
+                connect_retry_count:    5
+              )
+            end
+            assert_match(/Failed to connect to any of localhost:3300 after 5 retries/, exception.message)
+            assert_match Errno::ECONNREFUSED.to_s, exception.cause.class.to_s
           end
-        end
-        assert_match /Timedout after/, exception.message
-        server.close
-      end
 
-    end
-
-    describe "with server" do
-      before do
-        @server      = SimpleTCPServer.new(2000)
-        @server_name = 'localhost:2000'
-      end
-
-      after do
-        @server.stop if @server
-      end
-
-      describe 'without client connection' do
-        it 'times out on first receive and then successfully reads the response' do
-          @read_timeout = 3.0
-          # Need a custom client that does not auto close on error:
-          @client       = Net::TCPClient.new(
-            server:         @server_name,
-            read_timeout:   @read_timeout,
-            close_on_error: false
-          )
-
-          request = {'action' => 'sleep', 'duration' => @read_timeout + 0.5}
-          @client.write(BSON.serialize(request))
-
-          exception = assert_raises Net::TCPClient::ReadTimeout do
-            # Read 4 bytes from server
-            @client.read(4)
+          it 'times out on connect' do
+            # Create a TCP Server, but do not respond to connections
+            server = TCPServer.open(2001)
+
+            exception = assert_raises Net::TCPClient::ConnectionFailure do
+              1000.times do
+                new_net_tcp_client(with_ssl,
+                  server:              'localhost:2001',
+                  connect_timeout:     0.5,
+                  connect_retry_count: 3
+                )
+              end
+            end
+            assert_match(/Failed to connect to any of localhost:2001 after 3 retries/, exception.message)
+            server.close
           end
-          assert_equal false, @client.close_on_error
-          assert @client.alive?, 'The client connection is not alive after the read timed out with close_on_error: false'
-          assert_match /Timedout after #{@read_timeout} seconds trying to read from #{@server_name}/, exception.message
-          reply = read_bson_document(@client)
-          assert_equal 'sleep', reply['result']
-          @client.close
         end
 
-        it 'support infinite timeout' do
-          @client = Net::TCPClient.new(
-            server:          @server_name,
-            connect_timeout: -1
-          )
-          request = {'action' => 'test1'}
-          @client.write(BSON.serialize(request))
-          reply = read_bson_document(@client)
-          assert_equal 'test1', reply['result']
-          @client.close
-        end
-      end
+        describe 'with server' do
+          before do
+            options = {port: 2000}
+            if with_ssl
+              options[:ssl] = {
+                cert:    OpenSSL::X509::Certificate.new(File.open(ssl_file_path('localhost-server.pem'))),
+                key:     OpenSSL::PKey::RSA.new(File.open(ssl_file_path('localhost-server-key.pem'))),
+                ca_file: ssl_file_path('ca.pem')
+              }
+            end
+            count = 0
+            begin
+              @server = SimpleTCPServer.new(options)
+            rescue Errno::EADDRINUSE => exc
+              @server.stop if @server
+              # Give previous test server time to stop
+              count += 1
+              sleep 1
+              retry if count <= 30
+              raise exc
+            end
 
-      describe 'with client connection' do
-        before do
-          @read_timeout = 3.0
-          @client       = Net::TCPClient.new(
-            server:       @server_name,
-            read_timeout: @read_timeout
-          )
-          assert @client.alive?
-          assert_equal true, @client.close_on_error
-        end
+            @server_name = 'localhost:2000'
+          end
 
-        def after
-          if @client
-            @client.close
-            assert !@client.alive?
+          after do
+            @client.close if @client
+            @server.stop if @server
           end
-        end
 
-        it 'sends and receives data' do
-          request = {'action' => 'test1'}
-          @client.write(BSON.serialize(request))
-          reply = read_bson_document(@client)
-          assert_equal 'test1', reply['result']
-        end
+          describe '#read' do
+            it 'read timeout, followed by successful read' do
+              @read_timeout = 3.0
+              # Need a custom client that does not auto close on error:
+              @client       = new_net_tcp_client(with_ssl,
+                server:         @server_name,
+                read_timeout:   @read_timeout,
+                close_on_error: false
+              )
+
+              request = {'action' => 'sleep', 'duration' => @read_timeout + 0.5}
+              @client.write(BSON.serialize(request))
+
+              exception = assert_raises Net::TCPClient::ReadTimeout do
+                # Read 4 bytes from server
+                @client.read(4)
+              end
+              assert_equal false, @client.close_on_error
+              assert @client.alive?, 'The client connection is not alive after the read timed out with close_on_error: false'
+              assert_equal "Timed out after #{@read_timeout} seconds trying to read from localhost[127.0.0.1]:2000", exception.message
+              reply = read_bson_document(@client)
+              assert_equal 'sleep', reply['result']
+              @client.close
+            end
 
-        it 'timeouts on receive' do
-          request = {'action' => 'sleep', 'duration' => @read_timeout + 0.5}
-          @client.write(BSON.serialize(request))
+            it 'infinite timeout' do
+              @client = new_net_tcp_client(with_ssl,
+                server:          @server_name,
+                connect_timeout: -1
+              )
+              request = {'action' => 'test1'}
+              @client.write(BSON.serialize(request))
+              reply = read_bson_document(@client)
+              assert_equal 'test1', reply['result']
+              @client.close
+            end
+          end
 
-          exception = assert_raises Net::TCPClient::ReadTimeout do
-            # Read 4 bytes from server
-            @client.read(4)
+          describe '#connect' do
+            it 'calls on_connect after connection' do
+              @client = new_net_tcp_client(with_ssl,
+                server:       @server_name,
+                read_timeout: 3,
+                on_connect:   Proc.new do |socket|
+                  # Reset user_data on each connection
+                  socket.user_data = {sequence: 1}
+                end
+              )
+              assert_equal 'localhost[127.0.0.1]:2000', @client.address.to_s
+              assert_equal 1, @client.user_data[:sequence]
+
+              request = {'action' => 'test1'}
+              @client.write(BSON.serialize(request))
+              reply = read_bson_document(@client)
+              assert_equal 'test1', reply['result']
+            end
           end
-          # Due to close_on_error: true, a timeout will close the connection
-          # to prevent use of a socket connection in an inconsistent state
-          assert_equal false, @client.alive?
-          assert_match /Timedout after #{@read_timeout} seconds trying to read from #{@server_name}/, exception.message
-        end
 
-        it 'retries on connection failure' do
-          attempt = 0
-          reply   = @client.retry_on_connection_failure do
-            request = {'action' => 'fail', 'attempt' => (attempt+=1)}
-            @client.write(BSON.serialize(request))
-            # Note: Do not put the read in this block if it never sends the
-            #       same request twice to the server
-            read_bson_document(@client)
+          describe 'failover' do
+            it 'connects to second server when the first is down' do
+              @client = new_net_tcp_client(with_ssl,
+                servers:      ['localhost:1999', @server_name],
+                read_timeout: 3
+              )
+              assert_equal 'localhost[127.0.0.1]:2000', @client.address.to_s
+
+              request = {'action' => 'test1'}
+              @client.write(BSON.serialize(request))
+              reply = read_bson_document(@client)
+              assert_equal 'test1', reply['result']
+            end
           end
-          assert_equal 'fail', reply['result']
-        end
 
-      end
+          describe 'with client' do
+            before do
+              @read_timeout = 3.0
+              @client       = new_net_tcp_client(with_ssl,
+                server:       @server_name,
+                read_timeout: @read_timeout
+              )
+              assert @client.alive?, @client.ai
+              assert_equal true, @client.close_on_error
+            end
 
-      describe 'without client connection' do
-        it 'connects to second server when the first is down' do
-          client = Net::TCPClient.new(
-            servers:      ['localhost:1999', @server_name],
-            read_timeout: 3
-          )
-          assert_equal @server_name, client.server
+            describe '#alive?' do
+              it 'returns false once the connection is closed' do
+                assert @client.alive?
+                @client.close
+                refute @client.alive?
+              end
+            end
 
-          request = {'action' => 'test1'}
-          client.write(BSON.serialize(request))
-          reply = read_bson_document(client)
-          assert_equal 'test1', reply['result']
+            describe '#closed?' do
+              it 'returns true once the connection is closed' do
+                refute @client.closed?
+                @client.close
+                assert @client.closed?
+              end
+            end
 
-          client.close
-        end
+            describe '#close' do
+              it 'closes the connection, repeatedly without error' do
+                @client.close
+                @client.close
+              end
+            end
 
-        it 'calls on_connect after connection' do
-          client = Net::TCPClient.new(
-            server:       @server_name,
-            read_timeout: 3,
-            on_connect:   Proc.new do |socket|
-              # Reset user_data on each connection
-              socket.user_data = {sequence: 1}
+            describe '#write' do
+              it 'writes data' do
+                request = {'action' => 'test1'}
+                @client.write(BSON.serialize(request))
+              end
             end
-          )
-          assert_equal @server_name, client.server
-          assert_equal 1, client.user_data[:sequence]
 
-          request = {'action' => 'test1'}
-          client.write(BSON.serialize(request))
-          reply = read_bson_document(client)
-          assert_equal 'test1', reply['result']
+            describe '#read' do
+              it 'reads a response' do
+                request = {'action' => 'test1'}
+                @client.write(BSON.serialize(request))
+                reply = read_bson_document(@client)
+                assert_equal 'test1', reply['result']
+              end
+
+              it 'times out on receive' do
+                request = {'action' => 'sleep', 'duration' => @read_timeout + 0.5}
+                @client.write(BSON.serialize(request))
+
+                exception = assert_raises Net::TCPClient::ReadTimeout do
+                  # Read 4 bytes from server
+                  @client.read(4)
+                end
+                # Due to close_on_error: true, a timeout will close the connection
+                # to prevent use of a socket connection in an inconsistent state
+                assert_equal false, @client.alive?
+                assert_equal "Timed out after #{@read_timeout} seconds trying to read from localhost[127.0.0.1]:2000", exception.message
+              end
+            end
 
-          client.close
+            describe '#retry_on_connection_failure' do
+              it 'retries on connection failure' do
+                attempt = 0
+                reply   = @client.retry_on_connection_failure do
+                  request = {'action' => 'fail', 'attempt' => (attempt+=1)}
+                  @client.write(BSON.serialize(request))
+                  read_bson_document(@client)
+                end
+                assert_equal 'fail', reply['result']
+              end
+            end
+          end
         end
       end
 
     end
 
+    def ssl_file_path(name)
+      File.join(File.dirname(__FILE__), 'ssl_files', name)
+    end
+
+    def new_net_tcp_client(with_ssl, params)
+      params = params.dup
+      if with_ssl
+        params.merge!(
+          ssl: {
+            ca_file:     ssl_file_path('ca.pem'),
+            verify_mode: OpenSSL::SSL::VERIFY_NONE
+          }
+        )
+      end
+      Net::TCPClient.new(params)
+    end
+
   end
 end