tcp-client 0.0.10 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: b04df2a87aaa1d7eea3322907e4f37c8ae228507474b6b59927617e12eb73d49
-  data.tar.gz: 4454f0e6a53984627ffc3cb681a6b496f49306040d3a2bc0bfdabdf2405595a8
+  metadata.gz: a122629b36ac22b95c2ee7ed0d520391cfc00136982e9c0c4a8c7d0ea4dd5b47
+  data.tar.gz: a63612520461f6d84abffbe71c750158b2d7d0c5227d4ae9de16b9cac5071540
 SHA512:
-  metadata.gz: 48e6bae6c20b9335593ca20d45f03884fd11db4fe2ff97b35766f17444f414f4cf15d5e187b02f059001e1bc819ed442cb4abd715de44bffbcac53f01dcacba5
-  data.tar.gz: 912f1716f2bdeeb3e9bbdff18a5232c015d15c461f4aa4ba1919af2d7836f8f56e7916ee3800e7a26633dfee3c05257849a255669f9cb6eaf1a87c475f12a459
+  metadata.gz: 31d0760aa3f16564d171ba27dc0c3a919490356319265aa099762ef7f1e9ff57a20e968315d0d70beb291d62405040e01ec76aa4dfd78a229f3d91c0a7db029b
+  data.tar.gz: 265a8cda03d5c8f62138311f05a40756dd7e052c8b55d6e43412b3cf51dcea91e98c6ba38943bedf4b41de7af6b0d3dc86700197f7eafd4919093abd59d15351

data/README.md

@@ -8,20 +8,22 @@ 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|
+  # query 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: google.com\r\n\r\n")
+
+    # read "HTTP/1.1 " + 3 byte HTTP status code
+    pp client.read(12)
+  end
 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
@@ -14,14 +15,20 @@ class TCPClient
   end
 
   class NotConnected < SocketError
-    def self.raise!(which)
-      raise(self, "client not connected - #{which}", caller(1))
+    def self.raise!(reason)
+      raise(self, "client not connected - #{reason}", caller(1))
     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)
@@ -34,20 +41,20 @@ class TCPClient
 
   def initialize
     @socket = @address = @write_timeout = @read_timeout = nil
+    @deadline = nil
   end
 
   def to_s
     @address ? @address.to_s : ''
   end
 
-  def connect(addr, configuration)
+  def connect(addr, configuration, exception: ConnectTimeoutError)
     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, exception)
+    configuration.ssl? &&
+      @socket = SSLSocket.new(@socket, @address, configuration, exception)
     @write_timeout = configuration.write_timeout
     @read_timeout = configuration.read_timeout
     self
@@ -59,24 +66,47 @@ class TCPClient
     self
   rescue IOError
     self
+  ensure
+    @deadline = nil
   end
 
   def closed?
     @socket.nil? || @socket.closed?
   end
 
-  def read(nbytes, timeout: @read_timeout)
+  def with_deadline(timeout)
+    raise('no block given') unless block_given?
+    raise('deadline already used') if @deadline
+    tm = timeout&.to_f
+    raise(ArgumentError, "invalid deadline - #{timeout}") unless tm.positive?
+    @deadline = Time.now + tm
+    yield(self)
+  ensure
+    @deadline = nil
+  end
+
+  def read(nbytes, timeout: nil, exception: ReadTimeoutError)
     NotConnected.raise!(self) if closed?
-    @socket.read(nbytes, timeout: timeout, exception: Timeout)
+    time = timeout || remaining_time(exception) || @read_timeout
+    @socket.read(nbytes, timeout: time, exception: exception)
   end
 
-  def write(*msg, timeout: @write_timeout)
+  def write(*msg, timeout: nil, exception: WriteTimeoutError)
     NotConnected.raise!(self) if closed?
-    @socket.write(*msg, timeout: timeout, exception: Timeout)
+    time = timeout || remaining_time(exception) || @write_timeout
+    @socket.write(*msg, timeout: time, exception: exception)
   end
 
   def flush
     @socket.flush unless closed?
     self
   end
+
+  private
+
+  def remaining_time(exception)
+    return unless @deadline
+    remaining_time = @deadline - Time.now
+    0 < remaining_time ? remaining_time : raise(exception)
+  end
 end

data/lib/tcp-client/address.rb

@@ -4,7 +4,7 @@ require 'socket'
 
 class TCPClient
   class Address
-    attr_reader :to_s, :hostname, :addrinfo
+    attr_reader :hostname, :addrinfo
 
     def initialize(addr)
       case addr
@@ -20,17 +20,33 @@ class TCPClient
       @addrinfo.freeze
     end
 
+    def to_s
+      return "[#{@hostname}]:#{@addrinfo.ip_port}" if @hostname.index(':') # IP6
+      "#{@hostname}:#{@addrinfo.ip_port}"
+    end
+
+    def to_h
+      { host: @hostname, port: @addrinfo.ip_port }
+    end
+
+    def ==(other)
+      to_h == other.to_h
+    end
+    alias eql? ==
+
+    def equal?(other)
+      self.class == other.class && self == other
+    end
+
     private
 
     def init_from_selfclass(address)
-      @to_s = address.to_s
       @hostname = address.hostname
       @addrinfo = address.addrinfo
     end
 
     def init_from_addrinfo(addrinfo)
-      @hostname, port = addrinfo.getnameinfo(Socket::NI_NUMERICSERV)
-      @to_s = "#{@hostname}:#{port}"
+      @hostname, _port = addrinfo.getnameinfo(Socket::NI_NUMERICSERV)
       @addrinfo = addrinfo
     end
 
@@ -38,19 +54,13 @@ class TCPClient
       @hostname, port = from_string(str.to_s)
       return init_from_addrinfo(Addrinfo.tcp(nil, port)) unless @hostname
       @addrinfo = Addrinfo.tcp(@hostname, port)
-      @to_s = as_str(@hostname, port)
     end
 
     def from_string(str)
-      return [nil, str.to_i] unless idx = str.rindex(':')
+      idx = str.rindex(':') or return nil, str.to_i
       name = str[0, idx]
       name = name[1, name.size - 2] if name[0] == '[' && name[-1] == ']'
       [name, str[idx + 1, str.size - idx].to_i]
     end
-
-    def as_str(hostname, port)
-      return "[#{hostname}]:#{port}" if hostname.index(':') # IP6
-      "#{hostname}:#{port}"
-    end
   end
 end

data/lib/tcp-client/configuration.rb

@@ -1,39 +1,40 @@
 class TCPClient
   class Configuration
-    def self.create
-      ret = new
+    def self.create(options = {})
+      ret = new(options)
       yield(ret) if block_given?
       ret
     end
 
-    attr_reader :buffered, :keep_alive, :reverse_lookup
+    attr_reader :buffered, :keep_alive, :reverse_lookup, :timeout
     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?
       @ssl_params ? true : false
     end
 
-    def ssl=(yn)
-      return @ssl_params = nil unless yn
-      return @ssl_params = yn if Hash === yn
+    def ssl=(value)
+      return @ssl_params = nil unless value
+      return @ssl_params = value.dup if Hash === value
       @ssl_params ||= {}
     end
 
-    def buffered=(yn)
-      @buffered = yn ? true : false
+    def buffered=(value)
+      @buffered = value ? true : false
     end
 
-    def keep_alive=(yn)
-      @keep_alive = yn ? true : false
+    def keep_alive=(value)
+      @keep_alive = value ? true : false
     end
 
-    def reverse_lookup=(yn)
-      @reverse_lookup = yn ? true : false
+    def reverse_lookup=(value)
+      @reverse_lookup = value ? true : false
     end
 
     def timeout=(seconds)
@@ -65,10 +66,38 @@ class TCPClient
       @read_timeout = seconds(seconds)
     end
 
+    def to_h
+      {
+        buffered: @buffered,
+        keep_alive: @keep_alive,
+        reverse_lookup: @reverse_lookup,
+        timeout: @timeout,
+        connect_timeout: @connect_timeout,
+        read_timeout: @read_timeout,
+        write_timeout: @write_timeout,
+        ssl_params: @ssl_params
+      }
+    end
+
+    def ==(other)
+      to_h == other.to_h
+    end
+    alias eql? ==
+
+    def equal?(other)
+      self.class == other.class && self == other
+    end
+
     private
 
+    def set(attribute, value)
+      public_send("#{attribute}=", value)
+    rescue NoMethodError
+      raise(ArgumentError, "unknown attribute - #{attribute}")
+    end
+
     def seconds(value)
-      value&.positive? ? value : nil
+      value&.to_f&.positive? ? value : nil
     end
   end
 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
@@ -59,9 +59,7 @@ module IOTimeoutMixin
   end
 
   module DeadlineMethods
-    private
-
-    def with_deadline(deadline, exclass)
+    private def with_deadline(deadline, exclass)
       loop do
         case ret = yield
         when :wait_writable
@@ -78,9 +76,7 @@ module IOTimeoutMixin
   end
 
   module DeadlineIO
-    private
-
-    def with_deadline(deadline, exclass)
+    private def with_deadline(deadline, exclass)
       loop do
         case ret = yield
         when :wait_writable

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.10'.freeze
+  VERSION = '0.1.4'.freeze
 end

data/rakefile.rb

@@ -4,7 +4,9 @@ require 'rake/clean'
 require 'rake/testtask'
 require 'bundler/gem_tasks'
 
-STDOUT.sync = STDERR.sync = true
+$stdout.sync = $stderr.sync = true
+
+task(:default) { exec('rake --tasks') }
 
 CLOBBER << 'prj'
 
@@ -13,7 +15,3 @@ Rake::TestTask.new(:test) do |t|
   t.verbose = true
   t.test_files = FileList['test/**/*_test.rb']
 end
-
-task :default do
-  exec("#{$PROGRAM_NAME} --tasks")
-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,17 @@
 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|
+  # query 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: google.com\r\n\r\n")
+
+    # read "HTTP/1.1 " + 3 byte HTTP status code
+    pp client.read(12)
+  end
 end

data/tcp-client.gemspec

@@ -5,6 +5,10 @@ require_relative './lib/tcp-client/version'
 GemSpec = Gem::Specification.new do |spec|
   spec.name = 'tcp-client'
   spec.version = TCPClient::VERSION
+  spec.author = 'Mike Blumtritt'
+
+  spec.required_ruby_version = '>= 2.7.0'
+
   spec.summary = 'A TCP client implementation with working timeout support.'
   spec.description = <<~DESCRIPTION
     This gem implements a TCP client with (optional) SSL support. The
@@ -13,27 +17,17 @@ GemSpec = Gem::Specification.new do |spec|
     other implementations this client respects given/configurable time
     limits for each method (`connect`, `read`, `write`).
   DESCRIPTION
-  spec.author = 'Mike Blumtritt'
-  spec.email = 'mike.blumtritt@pm.me'
   spec.homepage = 'https://github.com/mblumtritt/tcp-client'
-  spec.metadata = {
-    'source_code_uri' => 'https://github.com/mblumtritt/tcp-client',
-    'bug_tracker_uri' => 'https://github.com/mblumtritt/tcp-client/issues'
-  }
-  spec.rubyforge_project = spec.name
+
+  spec.metadata['source_code_uri'] = 'https://github.com/mblumtritt/tcp-client'
+  spec.metadata['bug_tracker_uri'] = 'https://github.com/mblumtritt/tcp-client/issues'
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'minitest'
   spec.add_development_dependency 'rake'
 
-  spec.platform = Gem::Platform::RUBY
-  spec.required_ruby_version = '>= 2.5.0'
-  spec.required_rubygems_version = Gem::Requirement.new('>= 1.3.6')
-
-  spec.require_paths = %w[lib]
-
-  all_files = %x(git ls-files -z).split(0.chr)
-  spec.test_files = all_files.grep(%r{^(spec|test)/})
+  all_files = Dir.chdir(__dir__) { `git ls-files -z`.split(0.chr) }
+  spec.test_files = all_files.grep(%r{^test/})
   spec.files = all_files - spec.test_files
 
   spec.extra_rdoc_files = %w[README.md]

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)
@@ -52,4 +54,12 @@ class AddressTest < Test
     assert(subject.addrinfo.ip?)
     assert(subject.addrinfo.ipv6?)
   end
+
+  def test_compare
+    a = TCPClient::Address.new('localhost:42')
+    b = TCPClient::Address.new('localhost:42')
+    assert_equal(a, b)
+    assert(a == b)
+    assert(a === b)
+  end
 end

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)
@@ -54,4 +87,12 @@ class ConfigurationTest < Test
     assert_same(42, subject.read_timeout)
     assert_same(42, subject.write_timeout)
   end
+
+  def test_compare
+    a = TCPClient::Configuration.new
+    b = TCPClient::Configuration.new
+    assert_equal(a, b)
+    assert(a == b)
+    assert(a === b)
+  end
 end

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,26 +1,32 @@
 require_relative 'test_helper'
 
-class TCPClientTest < Test
+class TCPClientTest < MiniTest::Test
+  parallelize_me!
+
+  HUGE_AMOUNT_OF_DATA = Array.new(2024, '?' * 1024).freeze
+
+  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)
+    client
   rescue Errno::EADDRNOTAVAIL
-  ensure
-    return client
+    client
   end
 
   def test_failed_state
@@ -32,84 +38,120 @@ 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
+    assert_raises(TCPClient::NotConnected) { subject.write('hello world!') }
+    assert_raises(TCPClient::NotConnected) { subject.read(42) }
   end
 
-  def with_dummy_server(port)
-    # this server will never receive or send any data
-    server = TCPServer.new('localhost', port)
-    yield
-  ensure
-    server&.close
+  def test_connected_state
+    TCPClient.open('localhost:1234', config) 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 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)
+  def check_read_timeout(timeout)
+    TCPClient.open('localhost:1234', config) do |subject|
+      refute(subject.closed?)
+      start_time = nil
+      assert_raises(TCPClient::ReadTimeoutError) do
+        start_time = Time.now
+        subject.read(42, timeout: timeout)
       end
+      assert_in_delta(timeout, Time.now - start_time, 0.11)
     end
   end
 
-  def check_read_write_timeout(addr, timeout)
-    TCPClient.open(addr) do |subject|
+  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::Timeout) do
+      assert_raises(TCPClient::WriteTimeoutError) do
         start_time = Time.now
-        # send 1MB to avoid any TCP stack buffering
-        subject.write('?' * (1024 * 1024), timeout: timeout)
+        subject.write(*HUGE_AMOUNT_OF_DATA, timeout: timeout)
       end
       assert_in_delta(timeout, Time.now - start_time, 0.02)
-      assert_raises(TCPClient::Timeout) do
-        start_time = Time.now
-        subject.read(42, timeout: timeout)
+    end
+  end
+
+  def test_write_timeout
+    check_write_timeout(0.01)
+    check_write_timeout(0.25)
+  end
+
+  def test_write_deadline
+    TCPClient.open('localhost:1234', config) do |subject|
+      refute(subject.closed?)
+      assert_raises(TCPClient::WriteTimeoutError) do
+        subject.with_deadline(0.25) do |*args|
+          assert_equal([subject], args)
+          loop { subject.write('some data here') }
+        end
+      end
+    end
+  end
+
+  def test_read_deadline
+    TCPClient.open('localhost:1234', 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) }
+        end
       end
-      assert_in_delta(timeout, Time.now - start_time, 0.02)
     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_write_deadline
+    TCPClient.open('localhost:1234', 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.read(0)
+          end
+        end
       end
     end
   end
 
-  def check_connect_timeout(addr, config)
+  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.11)
   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

@@ -1,9 +1,11 @@
+# frozen_string_literal: true
+
 require 'minitest/autorun'
 require 'minitest/parallel'
 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.10
+  version: 0.1.4
 platform: ruby
 authors:
 - Mike Blumtritt
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2019-05-01 00:00:00.000000000 Z
+date: 2021-02-12 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -58,7 +58,7 @@ description: |
   easy to use client which can handle time limits correctly. Unlike
   other implementations this client respects given/configurable time
   limits for each method (`connect`, `read`, `write`).
-email: mike.blumtritt@pm.me
+email:
 executables: []
 extensions: []
 extra_rdoc_files:
@@ -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
@@ -97,20 +99,21 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 2.5.0
+      version: 2.7.0
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.3.6
+      version: '0'
 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