tcp-client 0.4.1 → 0.7.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4a9fe010bf08d26652d93212beee9ffe55275b3b051809a3093d2ff066719372
-  data.tar.gz: bf23f4441be6f32d581dfb069afb09bfbb8a9ca78b90f3e0f2332f16abed89e8
+  metadata.gz: 582575d6b5a66a264900141fd5010a1a80a363e15d0ca369f262889d99d932d0
+  data.tar.gz: a0c2335a50addbf5f424d869cd2931256a1334a0a075530ef3873d9065246834
 SHA512:
-  metadata.gz: c929de839e7335c4e8e950d0b96fb6028c74ba1ae6a1acec3bb4a572e54a6564d799a8ee8fdef51b77273a83a2af4c5cc29d66a4ed92c3647e1185e103d82fda
-  data.tar.gz: 00dacdc8d09584e1f4421c7ca62786ab617eaed1005db955ca36da4c1294738591820159d282d27e24fe3194d84e9cd5cb02b47966f231af5d5a26336bcfa366
+  metadata.gz: b160bd656c4f6091a669cf65349e54aeaa2e7c057e0a5a3c896edf5e8ab91166a3a5cdafedfe84e4b04d5a79e0602fb2433c6ff9144e6881746f3607b8d8290b
+  data.tar.gz: 6726ebdfbc777258e62b3d915fa7e4a57f7ae514d6259ce5f0051ee649294142acf09faac490901e32083072d7a68dd4ce71fa697e0bf05c0d9556c0d57bb6a5

data/lib/tcp-client/configuration.rb

@@ -37,7 +37,7 @@ class TCPClient
 
     def initialize_copy(_org)
       super
-      @ssl_params = @ssl_params.dup
+      @ssl_params = Hash[@ssl_params] if @ssl_params
       self
     end
 
@@ -48,7 +48,7 @@ class TCPClient
     def ssl=(value)
       @ssl_params =
         if Hash === value
-          value.dup
+          Hash[value]
         else
           value ? {} : nil
         end
@@ -83,23 +83,23 @@ class TCPClient
     end
 
     def timeout_error=(exception)
-      raise(NotAnException, exception) unless exception_class?(exception)
+      raise(NotAnExceptionError, exception) unless exception_class?(exception)
       @connect_timeout_error =
         @read_timeout_error = @write_timeout_error = exception
     end
 
     def connect_timeout_error=(exception)
-      raise(NotAnException, exception) unless exception_class?(exception)
+      raise(NotAnExceptionError, exception) unless exception_class?(exception)
       @connect_timeout_error = exception
     end
 
     def read_timeout_error=(exception)
-      raise(NotAnException, exception) unless exception_class?(exception)
+      raise(NotAnExceptionError, exception) unless exception_class?(exception)
       @read_timeout_error = exception
     end
 
     def write_timeout_error=(exception)
-      raise(NotAnException, exception) unless exception_class?(exception)
+      raise(NotAnExceptionError, exception) unless exception_class?(exception)
       @write_timeout_error = exception
     end
 
@@ -136,7 +136,7 @@ class TCPClient
     def set(attribute, value)
       public_send("#{attribute}=", value)
     rescue NoMethodError
-      raise(UnknownAttribute, attribute)
+      raise(UnknownAttributeError, attribute)
     end
 
     def seconds(value)

data/lib/tcp-client/deadline.rb

@@ -2,7 +2,7 @@
 
 class TCPClient
   class Deadline
-    MONOTONIC = !!defined?(Process::CLOCK_MONOTONIC)
+    MONOTONIC = defined?(Process::CLOCK_MONOTONIC) ? true : false
 
     def initialize(timeout)
       timeout = timeout&.to_f
@@ -29,4 +29,6 @@ class TCPClient
       end
     end
   end
+
+  private_constant(:Deadline)
 end

data/lib/tcp-client/errors.rb

@@ -1,37 +1,37 @@
 # frozen_string_literal: true
 
 class TCPClient
-  class NoOpenSSL < RuntimeError
+  class NoOpenSSLError < RuntimeError
     def initialize
       super('OpenSSL is not available')
     end
   end
 
-  class NoBlockGiven < ArgumentError
+  class NoBlockGivenError < ArgumentError
     def initialize
       super('no block given')
     end
   end
 
-  class InvalidDeadLine < ArgumentError
+  class InvalidDeadLineError < ArgumentError
     def initialize(timeout)
       super("invalid deadline - #{timeout}")
     end
   end
 
-  class UnknownAttribute < ArgumentError
+  class UnknownAttributeError < ArgumentError
     def initialize(attribute)
       super("unknown attribute - #{attribute}")
     end
   end
 
-  class NotAnException < TypeError
+  class NotAnExceptionError < TypeError
     def initialize(object)
       super("exception class required - #{object.inspect}")
     end
   end
 
-  class NotConnected < IOError
+  class NotConnectedError < IOError
     def initialize
       super('client not connected')
     end
@@ -65,6 +65,18 @@ class TCPClient
     end
   end
 
-  Timeout = TimeoutError # backward compatibility
-  deprecate_constant(:Timeout)
+  NoOpenSSL = NoOpenSSLError
+  NoBlockGiven = NoBlockGivenError
+  InvalidDeadLine = InvalidDeadLineError
+  UnknownAttribute = UnknownAttributeError
+  NotAnException = NotAnExceptionError
+  NotConnected = NotConnectedError
+  deprecate_constant(
+    :NoOpenSSL,
+    :NoBlockGiven,
+    :InvalidDeadLine,
+    :UnknownAttribute,
+    :NotAnException,
+    :NotConnected
+  )
 end

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

@@ -5,6 +5,8 @@ module IOWithDeadlineMixin
     methods = mod.instance_methods
     if methods.index(:wait_writable) && methods.index(:wait_readable)
       mod.include(ViaWaitMethod)
+    elsif methods.index(:to_io)
+      mod.include(ViaIOWaitMethod)
     else
       mod.include(ViaSelect)
     end
@@ -12,6 +14,13 @@ module IOWithDeadlineMixin
 
   def read_with_deadline(bytes_to_read, deadline, exception)
     raise(exception) unless deadline.remaining_time
+    if bytes_to_read.nil?
+      return(
+        with_deadline(deadline, exception) do
+          read_nonblock(65_536, exception: false)
+        end
+      )
+    end
     result = ''.b
     while result.bytesize < bytes_to_read
       read =
@@ -59,6 +68,25 @@ module IOWithDeadlineMixin
     end
   end
 
+  module ViaIOWaitMethod
+    private def with_deadline(deadline, exception)
+      loop do
+        case ret = yield
+        when :wait_writable
+          remaining_time = deadline.remaining_time or raise(exception)
+          raise(exception) if to_io.wait_writable(remaining_time).nil?
+        when :wait_readable
+          remaining_time = deadline.remaining_time or raise(exception)
+          raise(exception) if to_io.wait_readable(remaining_time).nil?
+        else
+          return ret
+        end
+      end
+    rescue Errno::ETIMEDOUT
+      raise(exception)
+    end
+  end
+
   module ViaSelect
     private def with_deadline(deadline, exception)
       loop do
@@ -78,5 +106,5 @@ module IOWithDeadlineMixin
     end
   end
 
-  private_constant(:ViaWaitMethod, :ViaSelect)
+  private_constant(:ViaWaitMethod, :ViaIOWaitMethod, :ViaSelect)
 end

data/lib/tcp-client/ssl_socket.rb

@@ -13,12 +13,11 @@ class TCPClient
   class SSLSocket < ::OpenSSL::SSL::SSLSocket
     include IOWithDeadlineMixin
 
-    def initialize(socket, address, configuration, exception)
+    def initialize(socket, address, configuration, deadline, exception)
       ssl_params = Hash[configuration.ssl_params]
       super(socket, create_context(ssl_params))
       self.sync_close = true
       self.hostname = address.hostname
-      deadline = Deadline.new(configuration.connect_timeout)
       deadline.valid? ? connect_with_deadline(deadline, exception) : connect
       post_connection_check(address.hostname) if should_verify?(ssl_params)
     end
@@ -26,9 +25,7 @@ class TCPClient
     private
 
     def create_context(ssl_params)
-      context = OpenSSL::SSL::SSLContext.new
-      context.set_params(ssl_params)
-      context
+      OpenSSL::SSL::SSLContext.new.tap { |ctx| ctx.set_params(ssl_params) }
     end
 
     def connect_with_deadline(deadline, exception)
@@ -36,7 +33,8 @@ class TCPClient
     end
 
     def should_verify?(ssl_params)
-      ssl_params[:verify_mode] != OpenSSL::SSL::VERIFY_NONE
+      ssl_params[:verify_mode] != OpenSSL::SSL::VERIFY_NONE &&
+        context.verify_hostname
     end
   end
 

data/lib/tcp-client/tcp_socket.rb

@@ -8,21 +8,20 @@ class TCPClient
   class TCPSocket < ::Socket
     include IOWithDeadlineMixin
 
-    def initialize(address, configuration, exception)
+    def initialize(address, configuration, deadline, exception)
       super(address.addrinfo.ipv6? ? :INET6 : :INET, :STREAM)
       configure(configuration)
-      deadline = Deadline.new(configuration.connect_timeout)
-      connect_to(address, deadline, exception)
+      connect_to(as_addr_in(address), deadline, exception)
     end
 
     private
 
-    def connect_to(address, deadline, exception)
-      addr =
-        ::Socket.pack_sockaddr_in(
-          address.addrinfo.ip_port,
-          address.addrinfo.ip_address
-        )
+    def as_addr_in(address)
+      addrinfo = address.addrinfo
+      ::Socket.pack_sockaddr_in(addrinfo.ip_port, addrinfo.ip_address)
+    end
+
+    def connect_to(addr, deadline, exception)
       return connect(addr) unless deadline.valid?
       with_deadline(deadline, exception) do
         connect_nonblock(addr, exception: false)

data/lib/tcp-client/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 class TCPClient
-  VERSION = '0.4.1'
+  VERSION = '0.7.0'
 end

data/lib/tcp-client.rb

@@ -10,33 +10,46 @@ require_relative 'tcp-client/default_configuration'
 require_relative 'tcp-client/version'
 
 class TCPClient
-  def self.open(addr, configuration = Configuration.default)
+  def self.open(address, configuration = Configuration.default)
     client = new
-    client.connect(Address.new(addr), configuration)
+    client.connect(Address.new(address), configuration)
     block_given? ? yield(client) : client
   ensure
-    client&.close if block_given?
+    client.close if block_given?
   end
 
-  attr_reader :address
+  def self.with_deadline(
+    timeout,
+    address,
+    configuration = Configuration.default
+  )
+    client = nil
+    raise(NoBlockGivenError) unless block_given?
+    address = Address.new(address)
+    client = new
+    client.with_deadline(timeout) do
+      yield(client.connect(address, configuration))
+    end
+  ensure
+    client&.close
+  end
+
+  attr_reader :address, :configuration
 
   def initialize
-    @socket = @address = @deadline = @cfg = nil
+    @socket = @address = @deadline = @configuration = nil
   end
 
   def to_s
-    @address ? @address.to_s : ''
+    @address&.to_s || ''
   end
 
-  def connect(addr, configuration, exception: nil)
-    raise(NoOpenSSL) if configuration.ssl? && !defined?(SSLSocket)
-    close
-    @address = Address.new(addr)
-    @cfg = configuration.dup
-    exception ||= configuration.connect_timeout_error
-    @socket = TCPSocket.new(@address, @cfg, exception)
-    @cfg.ssl? &&
-      @socket = SSLSocket.new(@socket, @address, configuration, exception)
+  def connect(address, configuration, timeout: nil, exception: nil)
+    close if @socket
+    raise(NoOpenSSLError) if configuration.ssl? && !defined?(SSLSocket)
+    @address = Address.new(address)
+    @configuration = configuration.dup.freeze
+    @socket = create_socket(timeout, exception)
     self
   end
 
@@ -55,48 +68,48 @@ class TCPClient
 
   def with_deadline(timeout)
     previous_deadline = @deadline
-    raise(NoBlockGiven) unless block_given?
+    raise(NoBlockGivenError) unless block_given?
     @deadline = Deadline.new(timeout)
-    raise(InvalidDeadLine, timeout) unless @deadline.valid?
+    raise(InvalidDeadLineError, timeout) unless @deadline.valid?
     yield(self)
   ensure
     @deadline = previous_deadline
   end
 
-  def read(nbytes, timeout: nil, exception: nil)
-    raise(NotConnected) if closed?
-    timeout.nil? && @deadline and
-      return read_with_deadline(nbytes, @deadline, exception)
-    deadline = Deadline.new(timeout || @cfg.read_timeout)
+  def read(nbytes = nil, timeout: nil, exception: nil)
+    raise(NotConnectedError) if closed?
+    deadline = create_deadline(timeout, configuration.read_timeout)
     return @socket.read(nbytes) unless deadline.valid?
-    read_with_deadline(nbytes, deadline, exception)
+    exception ||= configuration.read_timeout_error
+    @socket.read_with_deadline(nbytes, deadline, exception)
   end
 
   def write(*msg, timeout: nil, exception: nil)
-    raise(NotConnected) if closed?
-    timeout.nil? && @deadline and
-      return write_with_deadline(msg, @deadline, exception)
-    deadline = Deadline.new(timeout || @cfg.read_timeout)
+    raise(NotConnectedError) if closed?
+    deadline = create_deadline(timeout, configuration.write_timeout)
     return @socket.write(*msg) unless deadline.valid?
-    write_with_deadline(msg, deadline, exception)
+    exception ||= configuration.write_timeout_error
+    msg.sum do |chunk|
+      @socket.write_with_deadline(chunk.b, deadline, exception)
+    end
   end
 
   def flush
-    @socket.flush unless closed?
+    @socket&.flush
     self
   end
 
   private
 
-  def read_with_deadline(nbytes, deadline, exception)
-    exception ||= @cfg.read_timeout_error
-    @socket.read_with_deadline(nbytes, deadline, exception)
+  def create_deadline(timeout, default)
+    timeout.nil? && @deadline ? @deadline : Deadline.new(timeout || default)
   end
 
-  def write_with_deadline(msg, deadline, exception)
-    exception ||= @cfg.write_timeout_error
-    msg.sum do |chunk|
-      @socket.write_with_deadline(chunk.b, deadline, exception)
-    end
+  def create_socket(timeout, exception)
+    deadline = create_deadline(timeout, configuration.connect_timeout)
+    exception ||= configuration.connect_timeout_error
+    @socket = TCPSocket.new(address, configuration, deadline, exception)
+    return @socket unless configuration.ssl?
+    SSLSocket.new(@socket, address, configuration, deadline, exception)
   end
 end

data/lib/tcp_client.rb

@@ -1 +1,3 @@
+# frozen_string_literal: true
+
 require_relative 'tcp-client'

data/sample/google.rb

@@ -2,21 +2,20 @@
 
 require_relative '../lib/tcp-client'
 
-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 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
+# global configuration.
+# - 0.5 seconds to connect the server
+# - 0.25 seconds to write a single data junk
+# - 0.25 seconds to read some bytes
+TCPClient.configure do |cfg|
+  cfg.connect_timeout = 0.5
+  cfg.write_timeout = 0.25
+  cfg.read_timeout = 0.25
+end
 
+# request to Google:
+# - send a simple HTTP get request
+# - read 12 byte: "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: www.google.com\r\n\r\n")
-
-  # read "HTTP/1.1 " + 3 byte HTTP status code
-  pp client.read(12)
+  p client.write("GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n")
+  p client.read(12)
 end

data/sample/google_ssl.rb

@@ -2,18 +2,23 @@
 
 require_relative '../lib/tcp-client'
 
-TCPClient.configure do |cfg|
-  cfg.connect_timeout = 1 # limit connect time the server to 1 second
-  cfg.ssl_params = { ssl_version: :TLSv1_2 } # use TLS 1.2
-end
-
-TCPClient.open('www.google.com:443') do |client|
-  # next sequence should not last longer than 0.5 seconds
-  client.with_deadline(0.5) do
-    # simple HTTP get request
-    pp client.write("GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n")
+# create a configuration.
+# - use TLS 1.2
+# - don't use internal buffering
+cfg =
+  TCPClient::Configuration.create(
+    buffered: false,
+    ssl_params: {
+      ssl_version: :TLSv1_2
+    }
+  )
 
-    # read "HTTP/1.1 " + 3 byte HTTP status code
-    pp client.read(12)
-  end
+# request to Google:
+# - limit all interactions to 0.5 seconds
+# - use the Configuration cfg
+# - send a simple HTTP get request
+# - read 12 byte: "HTTP/1.1 " + 3 byte HTTP status code
+TCPClient.with_deadline(0.5, 'www.google.com:443', cfg) do |client|
+  p client.write("GET / HTTP/1.1\r\nHost: www.google.com\r\n\r\n")
+  p client.read(12)
 end

data/tcp-client.gemspec

@@ -2,7 +2,7 @@
 
 require_relative './lib/tcp-client/version'
 
-GemSpec = Gem::Specification.new do |spec|
+Gem::Specification.new do |spec|
   spec.name = 'tcp-client'
   spec.version = TCPClient::VERSION
   spec.author = 'Mike Blumtritt'
@@ -20,9 +20,11 @@ GemSpec = Gem::Specification.new do |spec|
     actions can also be monitored.
   DESCRIPTION
   spec.homepage = 'https://github.com/mblumtritt/tcp-client'
+  spec.license = 'BSD-3-Clause'
 
   spec.metadata['source_code_uri'] = 'https://github.com/mblumtritt/tcp-client'
-  spec.metadata['bug_tracker_uri'] = 'https://github.com/mblumtritt/tcp-client/issues'
+  spec.metadata['bug_tracker_uri'] =
+    'https://github.com/mblumtritt/tcp-client/issues'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'minitest'
@@ -32,5 +34,5 @@ GemSpec = Gem::Specification.new do |spec|
   spec.test_files = all_files.grep(%r{^test/})
   spec.files = all_files - spec.test_files
 
-  spec.extra_rdoc_files = %w[README.md]
+  spec.extra_rdoc_files = %w[README.md LICENSE]
 end

data/test/helper.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'minitest/parallel'
+require_relative '../lib/tcp-client'
+
+# this pseudo-server never reads or writes anything
+PseudoServer = TCPServer.new('localhost', 0)
+Minitest.after_run { PseudoServer.close }
+
+class Test < MiniTest::Test
+  parallelize_me!
+end
+
+class Timing
+  def initialize
+    @start_time = nil
+  end
+
+  def started?
+    @start_time != nil
+  end
+
+  def start
+    @start_time = now
+  end
+
+  def elapsed
+    now - @start_time
+  end
+
+  if defined?(Process::CLOCK_MONOTONIC)
+    def now
+      Process.clock_gettime(Process::CLOCK_MONOTONIC)
+    end
+  else
+    def now
+      ::Time.now
+    end
+  end
+end

data/test/tcp-client/address_test.rb

@@ -1,10 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../test_helper'
-
-class AddressTest < MiniTest::Test
-  parallelize_me!
+require_relative '../helper'
 
+class AddressTest < Test
   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,10 +1,8 @@
 # frozen_string_literal: true
 
-require_relative '../test_helper'
-
-class ConfigurationTest < MiniTest::Test
-  parallelize_me!
+require_relative '../helper'
 
+class ConfigurationTest < Test
   def test_defaults
     subject = TCPClient::Configuration.new
     assert(subject.buffered)

data/test/tcp-client/deadline_test.rb

@@ -1,25 +1,25 @@
 # frozen_string_literal: true
 
-require_relative '../test_helper'
+require_relative '../helper'
 
-class Deadlineest < MiniTest::Test
-  parallelize_me!
+class DeadlineTest < Test
+  Deadline = TCPClient.const_get(:Deadline)
 
   def test_validity
-    assert(TCPClient::Deadline.new(1).valid?)
-    assert(TCPClient::Deadline.new(0.0001).valid?)
+    assert(Deadline.new(1).valid?)
+    assert(Deadline.new(0.0001).valid?)
 
-    refute(TCPClient::Deadline.new(0).valid?)
-    refute(TCPClient::Deadline.new(nil).valid?)
+    refute(Deadline.new(0).valid?)
+    refute(Deadline.new(nil).valid?)
   end
 
   def test_remaining_time
-    assert(TCPClient::Deadline.new(1).remaining_time > 0)
+    assert(Deadline.new(1).remaining_time > 0)
 
-    assert_nil(TCPClient::Deadline.new(0).remaining_time)
-    assert_nil(TCPClient::Deadline.new(nil).remaining_time)
+    assert_nil(Deadline.new(0).remaining_time)
+    assert_nil(Deadline.new(nil).remaining_time)
 
-    deadline = TCPClient::Deadline.new(0.2)
+    deadline = Deadline.new(0.2)
     sleep(0.2)
     assert_nil(deadline.remaining_time)
   end

data/test/tcp-client/default_configuration_test.rb

@@ -1,4 +1,4 @@
-require_relative '../test_helper'
+require_relative '../helper'
 
 class DefauktConfigurationTest < MiniTest::Test
   def test_default

data/test/tcp-client/version_test.rb

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

data/test/tcp_client_test.rb

@@ -1,11 +1,9 @@
 # frozen_string_literal: true
 
-require_relative 'test_helper'
+require_relative 'helper'
 
-class TCPClientTest < MiniTest::Test
-  parallelize_me!
-
-  HUGE_AMOUNT_OF_DATA = Array.new(2024, '?' * 1024).freeze
+class TCPClientTest < Test
+  HUGE_AMOUNT_OF_DATA = Array.new(1024, '?' * 2048).freeze
 
   attr_reader :config
 
@@ -17,20 +15,26 @@ class TCPClientTest < MiniTest::Test
     PseudoServer.local_address.ip_port
   end
 
+  def address
+    "localhost:#{port}"
+  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) { subject.write('hello world!') }
-    assert_raises(TCPClient::NotConnected) { subject.read(42) }
+    assert_raises(TCPClient::NotConnectedError) do
+      subject.write('hello world!')
+    end
+    assert_raises(TCPClient::NotConnectedError) { subject.read(42) }
   end
 
   def create_nonconnected_client
     client = TCPClient.new
     client.connect('', config)
-    client
+    :you_should_not_get_this
   rescue Errno::EADDRNOTAVAIL
     client
   end
@@ -44,17 +48,19 @@ class TCPClientTest < MiniTest::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) { subject.write('hello world!') }
-    assert_raises(TCPClient::NotConnected) { subject.read(42) }
+    assert_raises(TCPClient::NotConnectedError) do
+      subject.write('hello world!')
+    end
+    assert_raises(TCPClient::NotConnectedError) { subject.read(42) }
   end
 
   def test_connected_state
-    TCPClient.open("localhost:#{port}", config) do |subject|
+    TCPClient.open(address, config) do |subject|
       refute(subject.closed?)
-      assert_equal("localhost:#{port}", subject.to_s)
+      assert_equal(address, subject.to_s)
       refute_nil(subject.address)
       address_when_opened = subject.address
-      assert_equal("localhost:#{port}", subject.address.to_s)
+      assert_equal(address, subject.address.to_s)
       assert_equal('localhost', subject.address.hostname)
       assert_instance_of(Addrinfo, subject.address.addrinfo)
       assert_same(port, subject.address.addrinfo.ip_port)
@@ -66,14 +72,14 @@ class TCPClientTest < MiniTest::Test
   end
 
   def check_read_timeout(timeout)
-    TCPClient.open("localhost:#{port}", config) do |subject|
+    TCPClient.open(address, config) do |subject|
       refute(subject.closed?)
-      start_time = nil
+      timing = Timing.new
       assert_raises(TCPClient::ReadTimeoutError) do
-        start_time = Time.now
+        timing.start
         subject.read(42, timeout: timeout)
       end
-      assert_in_delta(timeout, Time.now - start_time, 0.15)
+      assert_in_delta(timeout, timing.elapsed, 0.15)
     end
   end
 
@@ -84,14 +90,14 @@ class TCPClientTest < MiniTest::Test
   end
 
   def check_write_timeout(timeout)
-    TCPClient.open("localhost:#{port}", config) do |subject|
+    TCPClient.open(address, config) do |subject|
       refute(subject.closed?)
-      start_time = nil
+      timing = Timing.new
       assert_raises(TCPClient::WriteTimeoutError) do
-        start_time = Time.now
+        timing.start
         subject.write(*HUGE_AMOUNT_OF_DATA, timeout: timeout)
       end
-      assert_in_delta(timeout, Time.now - start_time, 0.15)
+      assert_in_delta(timeout, timing.elapsed, 0.15)
     end
   end
 
@@ -101,7 +107,7 @@ class TCPClientTest < MiniTest::Test
   end
 
   def test_write_deadline
-    TCPClient.open("localhost:#{port}", config) do |subject|
+    TCPClient.open(address, config) do |subject|
       refute(subject.closed?)
       assert_raises(TCPClient::WriteTimeoutError) do
         subject.with_deadline(0.25) do |*args|
@@ -113,25 +119,25 @@ class TCPClientTest < MiniTest::Test
   end
 
   def test_read_deadline
-    TCPClient.open("localhost:#{port}", config) do |subject|
+    TCPClient.open(address, config) do |subject|
       refute(subject.closed?)
       assert_raises(TCPClient::ReadTimeoutError) do
         subject.with_deadline(0.25) do |*args|
           assert_equal([subject], args)
-          loop { subject.read(0) }
+          loop { subject.read(42) }
         end
       end
     end
   end
 
   def test_read_write_deadline
-    TCPClient.open("localhost:#{port}", config) do |subject|
+    TCPClient.open(address, config) do |subject|
       refute(subject.closed?)
       assert_raises(TCPClient::TimeoutError) do
         subject.with_deadline(0.25) do |*args|
           assert_equal([subject], args)
           loop do
-            subject.write('HUGE_AMOUNT_OF_DATA')
+            subject.write('some data')
             subject.read(0)
           end
         end
@@ -140,12 +146,12 @@ class TCPClientTest < MiniTest::Test
   end
 
   def check_connect_timeout(ssl_config)
-    start_time = nil
+    timing = Timing.new
     assert_raises(TCPClient::ConnectTimeoutError) do
-      start_time = Time.now
-      TCPClient.new.connect("localhost:#{port}", ssl_config)
+      timing.start
+      TCPClient.new.connect(address, ssl_config)
     end
-    assert_in_delta(ssl_config.connect_timeout, Time.now - start_time, 0.25)
+    assert_in_delta(ssl_config.connect_timeout, timing.elapsed, 0.25)
   end
 
   def test_connect_ssl_timeout
@@ -160,4 +166,19 @@ class TCPClientTest < MiniTest::Test
     ssl_config.connect_timeout = 1.5
     check_connect_timeout(ssl_config)
   end
+
+  def test_deadline
+    assert(TCPClient.with_deadline(0.15, address, config, &:itself).closed?)
+  end
+
+  def test_deadline_timeout
+    timing = Timing.new
+    assert_raises(TCPClient::ReadTimeoutError) do
+      timing.start
+      TCPClient.with_deadline(0.15, address, config) do |client|
+        client.read(42)
+      end
+    end
+    assert_in_delta(0.15, timing.elapsed, 0.15)
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tcp-client
 version: !ruby/object:Gem::Version
-  version: 0.4.1
+  version: 0.7.0
 platform: ruby
 authors:
 - Mike Blumtritt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-08-01 00:00:00.000000000 Z
+date: 2021-11-06 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -65,6 +65,7 @@ executables: []
 extensions: []
 extra_rdoc_files:
 - README.md
+- LICENSE
 files:
 - ".gitignore"
 - LICENSE
@@ -85,15 +86,16 @@ files:
 - sample/google.rb
 - sample/google_ssl.rb
 - tcp-client.gemspec
+- test/helper.rb
 - test/tcp-client/address_test.rb
 - test/tcp-client/configuration_test.rb
 - test/tcp-client/deadline_test.rb
 - test/tcp-client/default_configuration_test.rb
 - test/tcp-client/version_test.rb
 - test/tcp_client_test.rb
-- test/test_helper.rb
 homepage: https://github.com/mblumtritt/tcp-client
-licenses: []
+licenses:
+- BSD-3-Clause
 metadata:
   source_code_uri: https://github.com/mblumtritt/tcp-client
   bug_tracker_uri: https://github.com/mblumtritt/tcp-client/issues
@@ -112,15 +114,15 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.22
+rubygems_version: 3.2.28
 signing_key:
 specification_version: 4
 summary: A TCP client implementation with working timeout support.
 test_files:
+- test/helper.rb
 - test/tcp-client/address_test.rb
 - test/tcp-client/configuration_test.rb
 - test/tcp-client/deadline_test.rb
 - test/tcp-client/default_configuration_test.rb
 - test/tcp-client/version_test.rb
 - test/tcp_client_test.rb
-- test/test_helper.rb

data/test/test_helper.rb

@@ -1,9 +0,0 @@
-# frozen_string_literal: true
-
-require 'minitest/autorun'
-require 'minitest/parallel'
-require_relative '../lib/tcp-client'
-
-# this pseudo-server never reads or writes anything
-PseudoServer = TCPServer.new('localhost', 0)
-Minitest.after_run { PseudoServer.close }