tcp-client 0.0.6 → 0.1.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 9a5a96328918c653aaec2296d19a7434b65c8801f3a1132a152dcd66326bc9ce
-  data.tar.gz: 5add4cd9d2607a90522b14c04a8b9d60a27bcad30c0f56212aba5df6c5036ac9
+  metadata.gz: bb5546419b47d6680b576f39d8c4b382c39d74f07ca43f6e782160122b6ba524
+  data.tar.gz: 3e563cd2db3efc765e491ece2fc37a784cb55ef05f6390eb23d1322a926be49e
 SHA512:
-  metadata.gz: 859acc902ed173236fac760ce2edbbda4353bf7fb438ecdb3856bdba3076a464a34f542458abc5b1fb2ec157b4f3ab007e0eb67123c551f1b6abedc6f810d978
-  data.tar.gz: 36b9c267842f00e2d6181d2523b84b776528b7d754fb4eb378fbdb4fc8d33fbb43ac7b9faf5ff613cf34c4687cc2eab74eaff04601fa72196efe3787d622dc7d
+  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
 ```
 
@@ -47,7 +53,7 @@ To install the gem globally use:
 $ gem install tcp-client
 ```
 
-After that you need only a single line of code in your project code to have all tools on board:
+After that you need only a single line of code in your project to have all tools on board:
 
 ```ruby
 require 'tcp-client'

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,22 +15,26 @@ class TCPClient
   end
 
   class NotConnected < SocketError
-    def self.raise!(which)
-      raise(self, format('client not connected - %s', 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)
-    return yield(client) if block_given?
-    client, ret = nil, client
-    ret
+    block_given? ? yield(client) : client
   ensure
-    client.close if client
+    client&.close if block_given?
   end
 
   attr_reader :address
@@ -46,8 +51,10 @@ class TCPClient
     close
     NoOpenSSL.raise! if configuration.ssl? && !defined?(SSLSocket)
     @address = Address.new(addr)
-    @socket = TCPSocket.new(@address, configuration, Timeout)
-    @socket = SSLSocket.new(@socket, @address, configuration, Timeout) if configuration.ssl?
+    @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
@@ -55,7 +62,7 @@ class TCPClient
 
   def close
     socket, @socket = @socket, nil
-    socket.close if socket
+    socket&.close
     self
   rescue IOError
     self
@@ -66,11 +73,13 @@ class TCPClient
   end
 
   def read(nbytes, timeout: @read_timeout)
-    closed? ? NotConnected.raise!(self) : @socket.read(nbytes, timeout: timeout, exception: Timeout)
+    NotConnected.raise!(self) if closed?
+    @socket.read(nbytes, timeout: timeout, exception: ReadTimeoutError)
   end
 
   def write(*msg, timeout: @write_timeout)
-    closed? ? NotConnected.raise!(self) : @socket.write(*msg, timeout: timeout, exception: Timeout)
+    NotConnected.raise!(self) if closed?
+    @socket.write(*msg, timeout: timeout, exception: WriteTimeoutError)
   end
 
   def flush

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,29 +20,31 @@ class TCPClient
       @addrinfo.freeze
     end
 
-    private
-
-    def init_from_string(str)
-      @hostname, port = from_string(str.to_s)
-      return init_from_addrinfo(Addrinfo.tcp(nil, port)) unless @hostname
-      @addrinfo = Addrinfo.tcp(@hostname, port)
-      @to_s = @hostname.index(':') ? "[#{@hostname}]:#{port}" : "#{@hostname}:#{port}"
+    def to_s
+      return "[#{@hostname}]:#{@addrinfo.ip_port}" if @hostname.index(':') # IP6
+      "#{@hostname}:#{@addrinfo.ip_port}"
     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
 
+    def init_from_string(str)
+      @hostname, port = from_string(str.to_s)
+      return init_from_addrinfo(Addrinfo.tcp(nil, port)) unless @hostname
+      @addrinfo = Addrinfo.tcp(@hostname, port)
+    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,8 +68,14 @@ class TCPClient
 
     private
 
+    def set(attribute, value)
+      public_send("#{attribute}=", value)
+    rescue NoMethodError
+      raise(ArgumentError, "unknown attribute - #{attribute}")
+    end
+
     def seconds(value)
-      value && value > 0 ? value : nil
+      value&.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

@@ -3,31 +3,39 @@ IOTimeoutError = Class.new(IOError) unless defined?(IOTimeoutError)
 module IOTimeoutMixin
   def self.included(mod)
     im = mod.instance_methods
-    mod.include(im.index(:wait_writable) && im.index(:wait_readable) ? WithDeadlineMethods : WidthDeadlineIO)
+    if im.index(:wait_writable) && im.index(:wait_readable)
+      mod.include(DeadlineMethods)
+    else
+      mod.include(DeadlineIO)
+    end
   end
 
   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){ read_nonblock(junk_size, exception: false) }
+      with_deadline(deadline, exception) do
+        read_nonblock(junk_size, exception: false)
+      end
     end
   end
 
   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|
-      with_deadline(deadline, exception){ write_nonblock(junk, exception: false) }
+    write_all(msgs.join.b) do |junk|
+      with_deadline(deadline, exception) do
+        write_nonblock(junk, exception: false)
+      end
     end
   end
 
   private
 
   def read_all(nbytes)
-    return '' if 0 == nbytes
+    return '' if nbytes.zero?
     result = ''
     loop do
       unless read = yield(nbytes - result.bytesize)
@@ -40,7 +48,7 @@ module IOTimeoutMixin
   end
 
   def write_all(data)
-    return 0 if 0 == (size = data.bytesize)
+    return 0 if (size = data.bytesize).zero?
     result = 0
     loop do
       written = yield(data)
@@ -50,18 +58,18 @@ module IOTimeoutMixin
     end
   end
 
-  module WithDeadlineMethods
+  module DeadlineMethods
     private
 
     def with_deadline(deadline, exclass)
       loop do
         case ret = yield
         when :wait_writable
-          remaining_time = deadline - Time.now
-          raise(exclass) if remaining_time <= 0 || wait_writable(remaining_time).nil?
+          raise(exclass) if (remaining_time = deadline - Time.now) <= 0
+          raise(exclass) if wait_writable(remaining_time).nil?
         when :wait_readable
-          remaining_time = deadline - Time.now
-          raise(exclass) if remaining_time <= 0 || wait_readable(remaining_time).nil?
+          raise(exclass) if (remaining_time = deadline - Time.now) <= 0
+          raise(exclass) if wait_readable(remaining_time).nil?
         else
           return ret
         end
@@ -69,18 +77,18 @@ module IOTimeoutMixin
     end
   end
 
-  module WidthDeadlineIO
+  module DeadlineIO
     private
 
     def with_deadline(deadline, exclass)
       loop do
         case ret = yield
         when :wait_writable
-          remaining_time = deadline - Time.now
-          raise(exclass) if remaining_time <= 0 || ::IO.select(nil, [self], nil, remaining_time).nil?
+          raise(exclass) if (remaining_time = deadline - Time.now) <= 0
+          raise(exclass) if ::IO.select(nil, [self], nil, remaining_time).nil?
         when :wait_readable
-          remaining_time = deadline - Time.now
-          raise(exclass) if remaining_time <= 0 || ::IO.select([self], nil, nil, remaining_time).nil?
+          raise(exclass) if (remaining_time = deadline - Time.now) <= 0
+          raise(exclass) if ::IO.select([self], nil, nil, remaining_time).nil?
         else
           return ret
         end
@@ -88,5 +96,5 @@ module IOTimeoutMixin
     end
   end
 
-  private_constant :WithDeadlineMethods, :WidthDeadlineIO
+  private_constant(:DeadlineMethods, :DeadlineIO)
 end

data/lib/tcp-client/ssl_socket.rb

@@ -31,10 +31,16 @@ class TCPClient
 
     def connect_to(address, check, timeout, exception)
       self.hostname = address.hostname
-      timeout ? with_deadline(Time.now + timeout, exception){ connect_nonblock(exception: false) } : connect
+      if timeout
+        with_deadline(Time.now + timeout, exception) do
+          connect_nonblock(exception: false)
+        end
+      else
+        connect
+      end
       post_connection_check(address.hostname) if check
     end
   end
 
-  private_constant :SSLSocket
+  private_constant(:SSLSocket)
 end

data/lib/tcp-client/tcp_socket.rb

@@ -14,9 +14,15 @@ 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){ connect_nonblock(addr, exception: false) }
+      with_deadline(Time.now + timeout, exception) do
+        connect_nonblock(addr, exception: false)
+      end
     end
 
     def configure(configuration)
@@ -29,5 +35,5 @@ class TCPClient
     end
   end
 
-  private_constant :TCPSocket
+  private_constant(:TCPSocket)
 end

data/lib/tcp-client/version.rb

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

data/rakefile.rb

@@ -1,5 +1,12 @@
-require 'bundler/gem_tasks'
+# frozen_string_literal: true
+
+require 'rake/clean'
 require 'rake/testtask'
+require 'bundler/gem_tasks'
+
+STDOUT.sync = STDERR.sync = true
+
+CLOBBER << 'prj'
 
 Rake::TestTask.new(:test) do |t|
   t.ruby_opts = %w[-w]
@@ -8,5 +15,5 @@ Rake::TestTask.new(:test) do |t|
 end
 
 task :default do
-  exec('rake -T')
+  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,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/tcp-client.gemspec

@@ -1,31 +1,34 @@
 # frozen_string_literal: true
 
-require File.expand_path('../lib/tcp-client/version', __FILE__)
+require_relative './lib/tcp-client/version'
 
 GemSpec = Gem::Specification.new do |spec|
   spec.name = 'tcp-client'
   spec.version = TCPClient::VERSION
   spec.summary = 'A TCP client implementation with working timeout support.'
-  spec.description = <<~EOS
+  spec.description = <<~DESCRIPTION
     This gem implements a TCP client with (optional) SSL support. The
     motivation of this project is the need to have a _really working_
     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`).
-  EOS
+  DESCRIPTION
   spec.author = 'Mike Blumtritt'
-  spec.email = 'mike.blumtritt@invision.de'
+  spec.email = 'mike.blumtritt@pm.me'
   spec.homepage = 'https://github.com/mblumtritt/tcp-client'
-  spec.metadata = {'issue_tracker' => 'https://github.com/mblumtritt/tcp-client/issues'}
+  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.add_development_dependency 'bundler'
-  spec.add_development_dependency 'rake'
   spec.add_development_dependency 'minitest'
+  spec.add_development_dependency 'rake'
 
   spec.platform = Gem::Platform::RUBY
-  spec.required_rubygems_version = Gem::Requirement.new('>= 1.3.6')
   spec.required_ruby_version = '>= 2.5.0'
+  spec.required_rubygems_version = Gem::Requirement.new('>= 1.3.6')
 
   spec.require_paths = %w[lib]
 
@@ -33,6 +36,5 @@ GemSpec = Gem::Specification.new do |spec|
   spec.test_files = all_files.grep(%r{^(spec|test)/})
   spec.files = all_files - spec.test_files
 
-  spec.has_rdoc = false
   spec.extra_rdoc_files = %w[README.md]
 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,17 +36,12 @@ 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 test_connected_state
-    server = TCPServer.new(1234)
-    TCPClient.open('localhost:1234', TCPClient::Configuration.new) do |subject|
+    TCPClient.open('localhost:1234') do |subject|
       refute(subject.closed?)
       assert_equal('localhost:1234', subject.to_s)
       refute_nil(subject.address)
@@ -56,55 +55,65 @@ class TCPClientTest < Test
       assert(subject.closed?)
       assert_same(address_when_opened, subject.address)
     end
-  ensure
-    server.close if server
   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
+      assert_raises(TCPClient::ReadTimeoutError) do
         start_time = Time.now
-        # we need to send 1MB to avoid any TCP stack buffering
-        subject.write('?' * (1024 * 1024), timeout: timeout)
+        subject.read(42, timeout: timeout)
       end
       assert_in_delta(timeout, Time.now - start_time, 0.02)
-      assert_raises(TCPClient::Timeout) do
+    end
+  end
+
+  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
-        subject.read(42, timeout: timeout)
+
+        # 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 test_read_write_timeout
-    server = TCPServer.new(1235) # this server will never read/write client data
-    [0.5, 1, 1.5].each do |timeout|
-      check_read_write_timeout(':1235', timeout)
-    end
-  ensure
-    server.close if server
+  def test_write_timeout
+    check_write_timeout(0.1)
+    check_write_timeout(0.25)
   end
 
-  def check_connect_timeout(addr, config, timeout)
+  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(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
-    server = TCPServer.new(1236)
-    config = TCPClient::Configuration.new
-    config.ssl = true
-    [0.5, 1, 1.5].each do |timeout|
-      config.timeout = timeout
-      check_connect_timeout('localhost:1236', config, timeout)
-    end
-  ensure
-    server.close if server
+    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.6
+  version: 0.1.0
 platform: ruby
 authors:
 - Mike Blumtritt
-autorequire: 
+autorequire:
 bindir: bin
 cert_chain: []
-date: 2018-02-21 00:00:00.000000000 Z
+date: 2021-02-11 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -25,7 +25,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: rake
+  name: minitest
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -39,7 +39,7 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '0'
 - !ruby/object:Gem::Dependency
-  name: minitest
+  name: rake
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
@@ -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@invision.de
+email: mike.blumtritt@pm.me
 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,14 +82,16 @@ 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
 homepage: https://github.com/mblumtritt/tcp-client
 licenses: []
 metadata:
-  issue_tracker: https://github.com/mblumtritt/tcp-client/issues
-post_install_message: 
+  source_code_uri: https://github.com/mblumtritt/tcp-client
+  bug_tracker_uri: https://github.com/mblumtritt/tcp-client/issues
+post_install_message:
 rdoc_options: []
 require_paths:
 - lib
@@ -103,14 +106,14 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: 1.3.6
 requirements: []
-rubyforge_project: tcp-client
-rubygems_version: 2.7.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