tcp-client 0.0.11 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: afd4d9a8cc41724a9d20fbdf0794dd8d7d4ed7103728d749ee6d823a49e03866
-  data.tar.gz: f63e5da4f6cdcfb449d918bddc79a0826fc6cf9c35017a6f1762dcc881f37c79
+  metadata.gz: bb5546419b47d6680b576f39d8c4b382c39d74f07ca43f6e782160122b6ba524
+  data.tar.gz: 3e563cd2db3efc765e491ece2fc37a784cb55ef05f6390eb23d1322a926be49e
 SHA512:
-  metadata.gz: 8da7b4a3a87585b206341d1aa770ecf08ebc937fcd5117a594804d6bb8d0fd1a8f12cf3e29e2fa2d8841e78496fa7b48ee4041edd4bff15b12cd1ecd43399106
-  data.tar.gz: 7b61d7ad8d26120a5a39414a93c51bd8fb0dc11eeb7008ea647b5bb8b2ac51af855539f41929f92c3374766765c3588f02009348c216d24dea2d88c4beab5a3c
+  metadata.gz: 712f24a4dc3427cf37126681ba50d53f0aefc9f839920283f611ef22e923f65f53f09fc83ca66cb45930536ca3c13d630dc7b0c5a5f40c6fc6f91f82bf123c3c
+  data.tar.gz: e97e52fc2aa1ad3cc548d2f561df97678e00c0e7e617c08afdbb9c6537709fc2743a07f26679cc8007124348cb32f1e8481d6417b7d3e28d247b504fcc951805

data/README.md

@@ -8,20 +8,26 @@ This gem implements a TCP client with (optional) SSL support. The motivation of
 ## Sample
 
 ```ruby
-configuration = TCPClient::Configuration.create do |cfg|
+require 'tcp-client'
+
+TCPClient.configure do |cfg|
   cfg.connect_timeout = 1 # second to connect the server
   cfg.write_timeout = 0.25 # seconds to write a single data junk
   cfg.read_timeout = 0.5 # seconds to read some bytes
-  cfg.ssl_params = {ssl_version: :TLSv1_2} # use TLS 1.2
+  cfg.ssl_params = { ssl_version: :TLSv1_2 } # use TLS 1.2
 end
 
 # the following request sequence is not allowed to last longer than 2 seconds:
 # 1 second to connect (incl. SSL handshake etc.)
 # + 0.25 seconds to write data
 # + 0.5 seconds to read a response
-TCPClient.open('www.google.com:443', configuration) do |client|
-  pp client.write("GET / HTTP/1.1\r\nHost: google.com\r\n\r\n") # simple HTTP get request
-  pp client.read(12) # "HTTP/1.1 " + 3 byte HTTP status code
+
+TCPClient.open('www.google.com:443') do |client|
+  # simple HTTP get request
+  pp client.write("GET / HTTP/1.1\r\nHost: google.com\r\n\r\n")
+
+  # read "HTTP/1.1 " + 3 byte HTTP status code
+  pp client.read(12)
 end
 ```
 

data/gems.rb

@@ -1,3 +1,3 @@
 # frozen_string_literal: true
 
-source('https://rubygems.org'){ gemspec }
+source('https://rubygems.org') { gemspec }

data/lib/tcp-client.rb

@@ -4,6 +4,7 @@ require_relative 'tcp-client/address'
 require_relative 'tcp-client/tcp_socket'
 require_relative 'tcp-client/ssl_socket'
 require_relative 'tcp-client/configuration'
+require_relative 'tcp-client/default_configuration'
 require_relative 'tcp-client/version'
 
 class TCPClient
@@ -19,9 +20,15 @@ class TCPClient
     end
   end
 
-  Timeout = Class.new(IOError)
+  TimeoutError = Class.new(IOError)
+  ConnectTimeoutError = Class.new(TimeoutError)
+  ReadTimeoutError = Class.new(TimeoutError)
+  WriteTimeoutError = Class.new(TimeoutError)
 
-  def self.open(addr, configuration = Configuration.new)
+  Timeout = TimeoutError # backward compatibility
+  deprecate_constant(:Timeout)
+
+  def self.open(addr, configuration = Configuration.default)
     addr = Address.new(addr)
     client = new
     client.connect(addr, configuration)
@@ -44,10 +51,10 @@ class TCPClient
     close
     NoOpenSSL.raise! if configuration.ssl? && !defined?(SSLSocket)
     @address = Address.new(addr)
-    @socket = TCPSocket.new(@address, configuration, Timeout)
-    configuration.ssl? && @socket = SSLSocket.new(
-      @socket, @address, configuration, Timeout
-    )
+    @socket = TCPSocket.new(@address, configuration, ConnectTimeoutError)
+    configuration.ssl? &&
+      @socket =
+        SSLSocket.new(@socket, @address, configuration, ConnectTimeoutError)
     @write_timeout = configuration.write_timeout
     @read_timeout = configuration.read_timeout
     self
@@ -67,12 +74,12 @@ class TCPClient
 
   def read(nbytes, timeout: @read_timeout)
     NotConnected.raise!(self) if closed?
-    @socket.read(nbytes, timeout: timeout, exception: Timeout)
+    @socket.read(nbytes, timeout: timeout, exception: ReadTimeoutError)
   end
 
   def write(*msg, timeout: @write_timeout)
     NotConnected.raise!(self) if closed?
-    @socket.write(*msg, timeout: timeout, exception: Timeout)
+    @socket.write(*msg, timeout: timeout, exception: WriteTimeoutError)
   end
 
   def flush

data/lib/tcp-client/address.rb

@@ -44,7 +44,7 @@ class TCPClient
     end
 
     def from_string(str)
-      return [nil, str.to_i] unless idx = str.rindex(':')
+      return nil, str.to_i unless idx = str.rindex(':')
       name = str[0, idx]
       name = name[1, name.size - 2] if name[0] == '[' && name[-1] == ']'
       [name, str[idx + 1, str.size - idx].to_i]

data/lib/tcp-client/configuration.rb

@@ -1,7 +1,7 @@
 class TCPClient
   class Configuration
-    def self.create
-      ret = new
+    def self.create(options = {})
+      ret = new(options)
       yield(ret) if block_given?
       ret
     end
@@ -9,9 +9,10 @@ class TCPClient
     attr_reader :buffered, :keep_alive, :reverse_lookup
     attr_accessor :ssl_params
 
-    def initialize
+    def initialize(options = {})
       @buffered = @keep_alive = @reverse_lookup = true
       self.timeout = @ssl_params = nil
+      options.each_pair { |attribute, value| set(attribute, value) }
     end
 
     def ssl?
@@ -67,6 +68,12 @@ class TCPClient
 
     private
 
+    def set(attribute, value)
+      public_send("#{attribute}=", value)
+    rescue NoMethodError
+      raise(ArgumentError, "unknown attribute - #{attribute}")
+    end
+
     def seconds(value)
       value&.positive? ? value : nil
     end

data/lib/tcp-client/default_configuration.rb

@@ -0,0 +1,21 @@
+require_relative 'configuration'
+
+class TCPClient
+  @default_configuration = Configuration.new
+
+  class << self
+    attr_reader :default_configuration
+
+    def configure(options = {})
+      cfg = Configuration.new(options)
+      yield(cfg) if block_given?
+      @default_configuration = cfg
+    end
+  end
+
+  class Configuration
+    def self.default
+      TCPClient.default_configuration
+    end
+  end
+end

data/lib/tcp-client/mixin/io_timeout.rb

@@ -12,7 +12,7 @@ module IOTimeoutMixin
 
   def read(nbytes, timeout: nil, exception: IOTimeoutError)
     timeout = timeout.to_f
-    return read_all(nbytes){ |junk_size| super(junk_size) } if timeout <= 0
+    return read_all(nbytes) { |junk_size| super(junk_size) } if timeout <= 0
     deadline = Time.now + timeout
     read_all(nbytes) do |junk_size|
       with_deadline(deadline, exception) do
@@ -23,9 +23,9 @@ module IOTimeoutMixin
 
   def write(*msgs, timeout: nil, exception: IOTimeoutError)
     timeout = timeout.to_f
-    return write_all(msgs.join){ |junk| super(junk) } if timeout <= 0
+    return write_all(msgs.join.b) { |junk| super(junk) } if timeout <= 0
     deadline = Time.now + timeout
-    write_all(msgs.join) do |junk|
+    write_all(msgs.join.b) do |junk|
       with_deadline(deadline, exception) do
         write_nonblock(junk, exception: false)
       end

data/lib/tcp-client/tcp_socket.rb

@@ -14,9 +14,11 @@ class TCPClient
     private
 
     def connect_to(address, timeout, exception)
-      addr = ::Socket.pack_sockaddr_in(
-        address.addrinfo.ip_port, address.addrinfo.ip_address
-      )
+      addr =
+        ::Socket.pack_sockaddr_in(
+          address.addrinfo.ip_port,
+          address.addrinfo.ip_address
+        )
       return connect(addr) unless timeout
       with_deadline(Time.now + timeout, exception) do
         connect_nonblock(addr, exception: false)

data/lib/tcp-client/version.rb

@@ -1,3 +1,3 @@
 class TCPClient
-  VERSION = '0.0.11'.freeze
+  VERSION = '0.1.0'.freeze
 end

data/sample/google.rb

@@ -1,16 +1,21 @@
 require_relative '../lib/tcp-client'
 
-configuration = TCPClient::Configuration.create do |cfg|
-  cfg.connect_timeout = 0.5 # seconds to connect the server
-  cfg.write_timeout = 0.25 # seconds to write a single data junk
-  cfg.read_timeout = 0.5 # seconds to read some bytes
-end
+TCPClient.configure(
+  connect_timeout: 0.5, # seconds to connect the server
+  write_timeout: 0.25, # seconds to write a single data junk
+  read_timeout: 0.5 # seconds to read some bytes
+)
 
-# the following request sequence is not allowed to last longer than 1.25 seconds:
-# 0.5 seconds to connect
+# the following request sequence is not allowed
+# to last longer than 1.25 seconds:
+#   0.5 seconds to connect
 # + 0.25 seconds to write data
 # + 0.5 seconds to read a response
-TCPClient.open('www.google.com:80', configuration) do |client|
-  pp client.write("GET / HTTP/1.1\r\nHost: google.com\r\n\r\n") # simple HTTP get request
-  pp client.read(12) # "HTTP/1.1 " + 3 byte HTTP status code
+
+TCPClient.open('www.google.com:80') do |client|
+  # simple HTTP get request
+  pp client.write("GET / HTTP/1.1\r\nHost: google.com\r\n\r\n")
+
+  # read "HTTP/1.1 " + 3 byte HTTP status code
+  pp client.read(12)
 end

data/sample/google_ssl.rb

@@ -1,17 +1,21 @@
 require_relative '../lib/tcp-client'
 
-configuration = TCPClient::Configuration.create do |cfg|
+TCPClient.configure do |cfg|
   cfg.connect_timeout = 1 # second to connect the server
   cfg.write_timeout = 0.25 # seconds to write a single data junk
   cfg.read_timeout = 0.5 # seconds to read some bytes
-  cfg.ssl_params = {ssl_version: :TLSv1_2} # use TLS 1.2
+  cfg.ssl_params = { ssl_version: :TLSv1_2 } # use TLS 1.2
 end
 
 # the following request sequence is not allowed to last longer than 2 seconds:
 # 1 second to connect (incl. SSL handshake etc.)
 # + 0.25 seconds to write data
 # + 0.5 seconds to read a response
-TCPClient.open('www.google.com:443', configuration) do |client|
-  pp client.write("GET / HTTP/1.1\r\nHost: google.com\r\n\r\n") # simple HTTP get request
-  pp client.read(12) # "HTTP/1.1 " + 3 byte HTTP status code
+
+TCPClient.open('www.google.com:443') do |client|
+  # simple HTTP get request
+  pp client.write("GET / HTTP/1.1\r\nHost: google.com\r\n\r\n")
+
+  # read "HTTP/1.1 " + 3 byte HTTP status code
+  pp client.read(12)
 end

data/test/tcp-client/address_test.rb

@@ -1,6 +1,8 @@
 require_relative '../test_helper'
 
-class AddressTest < Test
+class AddressTest < MiniTest::Test
+  parallelize_me!
+
   def test_create_from_integer
     subject = TCPClient::Address.new(42)
     assert_equal('localhost:42', subject.to_s)

data/test/tcp-client/configuration_test.rb

@@ -1,6 +1,8 @@
 require_relative '../test_helper'
 
-class ConfigurationTest < Test
+class ConfigurationTest < MiniTest::Test
+  parallelize_me!
+
   def test_defaults
     subject = TCPClient::Configuration.new
     assert(subject.buffered)
@@ -13,11 +15,12 @@ class ConfigurationTest < Test
   end
 
   def test_configure
-    subject = TCPClient::Configuration.create do |cfg|
-      cfg.buffered = cfg.keep_alive = cfg.reverse_lookup = false
-      cfg.timeout = 42
-      cfg.ssl = true
-    end
+    subject =
+      TCPClient::Configuration.create do |cfg|
+        cfg.buffered = cfg.keep_alive = cfg.reverse_lookup = false
+        cfg.timeout = 42
+        cfg.ssl = true
+      end
     refute(subject.buffered)
     refute(subject.keep_alive)
     refute(subject.reverse_lookup)
@@ -27,6 +30,35 @@ class ConfigurationTest < Test
     assert(subject.ssl?)
   end
 
+  def test_options
+    subject =
+      TCPClient::Configuration.new(
+        buffered: false,
+        keep_alive: false,
+        reverse_lookup: false,
+        connect_timeout: 1,
+        read_timeout: 2,
+        write_timeout: 3,
+        ssl: true
+      )
+    refute(subject.buffered)
+    refute(subject.keep_alive)
+    refute(subject.reverse_lookup)
+    assert_same(1, subject.connect_timeout)
+    assert_same(2, subject.read_timeout)
+    assert_same(3, subject.write_timeout)
+    assert(subject.ssl?)
+  end
+
+  def test_invalid_option
+    err =
+      assert_raises(ArgumentError) do
+        TCPClient::Configuration.new(unknown_attr: :argument)
+      end
+    assert_includes(err.message, 'attribute')
+    assert_includes(err.message, 'unknown_attr')
+  end
+
   def test_ssl_params
     subject = TCPClient::Configuration.new
     refute(subject.ssl?)
@@ -40,11 +72,12 @@ class ConfigurationTest < Test
   end
 
   def test_timeout_overwrite
-    subject = TCPClient::Configuration.create do |cfg|
-      cfg.connect_timeout = 1
-      cfg.read_timeout = 2
-      cfg.write_timeout = 3
-    end
+    subject =
+      TCPClient::Configuration.create do |cfg|
+        cfg.connect_timeout = 1
+        cfg.read_timeout = 2
+        cfg.write_timeout = 3
+      end
     assert_same(1, subject.connect_timeout)
     assert_same(2, subject.read_timeout)
     assert_same(3, subject.write_timeout)

data/test/tcp-client/default_configuration_test.rb

@@ -0,0 +1,59 @@
+require_relative '../test_helper'
+
+class DefauktConfigurationTest < MiniTest::Test
+  def test_default
+    subject = TCPClient.configure # reset to defaults
+
+    assert_same(
+      TCPClient.default_configuration,
+      TCPClient::Configuration.default
+    )
+    assert(subject.buffered)
+    assert(subject.keep_alive)
+    assert(subject.reverse_lookup)
+    refute(subject.ssl?)
+    assert_nil(subject.connect_timeout)
+    assert_nil(subject.read_timeout)
+    assert_nil(subject.write_timeout)
+  end
+
+  def test_configure_options
+    TCPClient.configure(
+      buffered: false,
+      keep_alive: false,
+      reverse_lookup: false,
+      ssl: true,
+      connect_timeout: 1,
+      read_timeout: 2,
+      write_timeout: 3
+    )
+    subject = TCPClient.default_configuration
+    refute(subject.buffered)
+    refute(subject.keep_alive)
+    refute(subject.reverse_lookup)
+    assert(subject.ssl?)
+    assert_same(1, subject.connect_timeout)
+    assert_same(2, subject.read_timeout)
+    assert_same(3, subject.write_timeout)
+  end
+
+  def test_configure_block
+    TCPClient.configure do |cfg|
+      cfg.buffered = false
+      cfg.keep_alive = false
+      cfg.reverse_lookup = false
+      cfg.ssl = true
+      cfg.connect_timeout = 1
+      cfg.read_timeout = 2
+      cfg.write_timeout = 3
+    end
+    subject = TCPClient.default_configuration
+    refute(subject.buffered)
+    refute(subject.keep_alive)
+    refute(subject.reverse_lookup)
+    assert(subject.ssl?)
+    assert_same(1, subject.connect_timeout)
+    assert_same(2, subject.read_timeout)
+    assert_same(3, subject.write_timeout)
+  end
+end

data/test/tcp-client/version_test.rb

@@ -1,6 +1,8 @@
 require_relative '../test_helper'
 
-class VersionTest < Test
+class VersionTest < MiniTest::Test
+  parallelize_me!
+
   def test_format
     assert_match(/\d+\.\d+\.\d+/, TCPClient::VERSION)
   end

data/test/tcp_client_test.rb

@@ -1,23 +1,27 @@
 require_relative 'test_helper'
 
-class TCPClientTest < Test
+class TCPClientTest < MiniTest::Test
+  parallelize_me!
+
+  attr_reader :config
+
+  def setup
+    @config = TCPClient::Configuration.create(buffered: false)
+  end
+
   def test_defaults
     subject = TCPClient.new
     assert(subject.closed?)
     assert_equal('', subject.to_s)
     assert_nil(subject.address)
     subject.close
-    assert_raises(TCPClient::NotConnected) do
-      subject.write('hello world!')
-    end
-    assert_raises(TCPClient::NotConnected) do
-      subject.read(42)
-    end
+    assert_raises(TCPClient::NotConnected) { subject.write('hello world!') }
+    assert_raises(TCPClient::NotConnected) { subject.read(42) }
   end
 
   def create_nonconnected_client
     client = TCPClient.new
-    client.connect('', TCPClient::Configuration.new)
+    client.connect('', config)
   rescue Errno::EADDRNOTAVAIL
   ensure
     return client
@@ -32,52 +36,32 @@ class TCPClientTest < Test
     assert_equal('localhost', subject.address.hostname)
     assert_instance_of(Addrinfo, subject.address.addrinfo)
     assert_same(0, subject.address.addrinfo.ip_port)
-    assert_raises(TCPClient::NotConnected) do
-      subject.write('hello world!')
-    end
-    assert_raises(TCPClient::NotConnected) do
-      subject.read(42)
-    end
-  end
-
-  def with_dummy_server(port)
-    # this server will never receive or send any data
-    server = TCPServer.new('localhost', port)
-    yield
-  ensure
-    server&.close
+    assert_raises(TCPClient::NotConnected) { subject.write('hello world!') }
+    assert_raises(TCPClient::NotConnected) { subject.read(42) }
   end
 
   def test_connected_state
-    with_dummy_server(1234) do
-      TCPClient.open('localhost:1234') do |subject|
-        refute(subject.closed?)
-        assert_equal('localhost:1234', subject.to_s)
-        refute_nil(subject.address)
-        address_when_opened = subject.address
-        assert_equal('localhost:1234', subject.address.to_s)
-        assert_equal('localhost', subject.address.hostname)
-        assert_instance_of(Addrinfo, subject.address.addrinfo)
-        assert_same(1234, subject.address.addrinfo.ip_port)
-
-        subject.close
-        assert(subject.closed?)
-        assert_same(address_when_opened, subject.address)
-      end
+    TCPClient.open('localhost:1234') do |subject|
+      refute(subject.closed?)
+      assert_equal('localhost:1234', subject.to_s)
+      refute_nil(subject.address)
+      address_when_opened = subject.address
+      assert_equal('localhost:1234', subject.address.to_s)
+      assert_equal('localhost', subject.address.hostname)
+      assert_instance_of(Addrinfo, subject.address.addrinfo)
+      assert_same(1234, subject.address.addrinfo.ip_port)
+
+      subject.close
+      assert(subject.closed?)
+      assert_same(address_when_opened, subject.address)
     end
   end
 
-  def check_read_write_timeout(addr, timeout)
-    TCPClient.open(addr) do |subject|
+  def check_read_timeout(timeout)
+    TCPClient.open('localhost:1234', config) do |subject|
       refute(subject.closed?)
       start_time = nil
-      assert_raises(TCPClient::Timeout) do
-        start_time = Time.now
-        # send 1MB to avoid any TCP stack buffering
-        subject.write('?' * (1024 * 1024), timeout: timeout)
-      end
-      assert_in_delta(timeout, Time.now - start_time, 0.02)
-      assert_raises(TCPClient::Timeout) do
+      assert_raises(TCPClient::ReadTimeoutError) do
         start_time = Time.now
         subject.read(42, timeout: timeout)
       end
@@ -85,31 +69,51 @@ class TCPClientTest < Test
     end
   end
 
-  def test_read_write_timeout
-    with_dummy_server(1235) do
-      [0.5, 1, 1.5].each do |timeout|
-        check_read_write_timeout('localhost:1235', timeout)
+  def test_read_timeout
+    check_read_timeout(0.5)
+    check_read_timeout(1)
+    check_read_timeout(1.5)
+  end
+
+  def check_write_timeout(timeout)
+    TCPClient.open('localhost:1234', config) do |subject|
+      refute(subject.closed?)
+      start_time = nil
+      assert_raises(TCPClient::WriteTimeoutError) do
+        start_time = Time.now
+
+        # send 1MB to avoid any TCP stack buffering
+        args = Array.new(2024, '?' * 1024)
+        subject.write(*args, timeout: timeout)
       end
+      assert_in_delta(timeout, Time.now - start_time, 0.02)
     end
   end
 
-  def check_connect_timeout(addr, config)
+  def test_write_timeout
+    check_write_timeout(0.1)
+    check_write_timeout(0.25)
+  end
+
+  def check_connect_timeout(ssl_config)
     start_time = nil
-    assert_raises(TCPClient::Timeout) do
+    assert_raises(TCPClient::ConnectTimeoutError) do
       start_time = Time.now
-      TCPClient.new.connect(addr, config)
+      TCPClient.new.connect('localhost:1234', ssl_config)
     end
-    assert_in_delta(config.connect_timeout, Time.now - start_time, 0.02)
+    assert_in_delta(ssl_config.connect_timeout, Time.now - start_time, 0.02)
   end
 
   def test_connect_ssl_timeout
-    with_dummy_server(1236) do
-      config = TCPClient::Configuration.new
-      config.ssl = true
-      [0.5, 1, 1.5].each do |timeout|
-        config.timeout = timeout
-        check_connect_timeout('localhost:1236', config)
-      end
-    end
+    ssl_config = TCPClient::Configuration.new(ssl: true)
+
+    ssl_config.connect_timeout = 0.5
+    check_connect_timeout(ssl_config)
+
+    ssl_config.connect_timeout = 1
+    check_connect_timeout(ssl_config)
+
+    ssl_config.connect_timeout = 1.5
+    check_connect_timeout(ssl_config)
   end
 end

data/test/test_helper.rb

@@ -4,6 +4,6 @@ require_relative '../lib/tcp-client'
 
 $stdout.sync = $stderr.sync = true
 
-class Test < Minitest::Test
-  parallelize_me!
-end
+# this pseudo-server never reads or writes anything
+DummyServer = TCPServer.new('localhost', 1234)
+Minitest.after_run { DummyServer.close }

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tcp-client
 version: !ruby/object:Gem::Version
-  version: 0.0.11
+  version: 0.1.0
 platform: ruby
 authors:
 - Mike Blumtritt
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-05-19 00:00:00.000000000 Z
+date: 2021-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -70,6 +70,7 @@ files:
 - lib/tcp-client.rb
 - lib/tcp-client/address.rb
 - lib/tcp-client/configuration.rb
+- lib/tcp-client/default_configuration.rb
 - lib/tcp-client/mixin/io_timeout.rb
 - lib/tcp-client/ssl_socket.rb
 - lib/tcp-client/tcp_socket.rb
@@ -81,6 +82,7 @@ files:
 - tcp-client.gemspec
 - test/tcp-client/address_test.rb
 - test/tcp-client/configuration_test.rb
+- test/tcp-client/default_configuration_test.rb
 - test/tcp-client/version_test.rb
 - test/tcp_client_test.rb
 - test/test_helper.rb
@@ -89,7 +91,7 @@ licenses: []
 metadata:
   source_code_uri: https://github.com/mblumtritt/tcp-client
   bug_tracker_uri: https://github.com/mblumtritt/tcp-client/issues
-post_install_message: 
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -104,13 +106,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 3.2.9
+signing_key:
 specification_version: 4
 summary: A TCP client implementation with working timeout support.
 test_files:
 - test/tcp-client/address_test.rb
 - test/tcp-client/configuration_test.rb
+- test/tcp-client/default_configuration_test.rb
 - test/tcp-client/version_test.rb
 - test/tcp_client_test.rb
 - test/test_helper.rb