tcp-client 0.6.0 → 0.9.1

data/test/helper.rb

@@ -1,41 +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 }
-
-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,65 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../helper'
-
-class AddressTest < Test
-  def test_create_from_integer
-    subject = TCPClient::Address.new(42)
-    assert_equal('localhost:42', subject.to_s)
-    assert_equal('localhost', subject.hostname)
-    assert(subject.addrinfo.ip?)
-    assert(subject.addrinfo.ipv6?)
-    assert_same(42, subject.addrinfo.ip_port)
-  end
-
-  def test_create_from_addrinfo
-    addrinfo = Addrinfo.tcp('localhost', 42)
-    subject = TCPClient::Address.new(addrinfo)
-    assert_equal(addrinfo.getnameinfo[0], subject.hostname)
-    assert_equal(addrinfo, subject.addrinfo)
-  end
-
-  def test_create_from_str
-    subject = TCPClient::Address.new('localhost:42')
-    assert_equal('localhost:42', subject.to_s)
-    assert_equal('localhost', subject.hostname)
-    assert(subject.addrinfo.ip?)
-    assert(subject.addrinfo.ipv6?)
-    assert_same(42, subject.addrinfo.ip_port)
-  end
-
-  def test_create_from_str_short
-    subject = TCPClient::Address.new(':42')
-    assert_equal(':42', subject.to_s)
-    assert_empty(subject.hostname)
-    assert_same(42, subject.addrinfo.ip_port)
-    assert(subject.addrinfo.ip?)
-    assert(subject.addrinfo.ipv4?)
-  end
-
-  def test_create_from_str_ip6
-    subject = TCPClient::Address.new('[::1]:42')
-    assert_equal('[::1]:42', subject.to_s)
-    assert_equal('::1', subject.hostname)
-    assert_same(42, subject.addrinfo.ip_port)
-    assert(subject.addrinfo.ip?)
-    assert(subject.addrinfo.ipv6?)
-  end
-
-  def test_create_from_empty_str
-    subject = TCPClient::Address.new('')
-    assert_equal('localhost:0', subject.to_s)
-    assert_equal('localhost', subject.hostname)
-    assert_same(0, subject.addrinfo.ip_port)
-    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,141 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../helper'
-
-class ConfigurationTest < Test
-  def test_defaults
-    subject = TCPClient::Configuration.new
-    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
-    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)
-    assert_same(42, subject.connect_timeout)
-    assert_same(42, subject.read_timeout)
-    assert_same(42, subject.write_timeout)
-    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,
-        connect_timeout_error: IOError
-      )
-    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?)
-    assert_same(IOError, subject.connect_timeout_error)
-    assert_same(TCPClient::ReadTimeoutError, subject.read_timeout_error)
-  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?)
-    assert_nil(subject.ssl_params)
-    subject.ssl = true
-    assert(subject.ssl?)
-    assert_empty(subject.ssl_params)
-    subject.ssl_params[:ssl_version] = :TLSv1_2
-    subject.ssl = false
-    assert_nil(subject.ssl_params)
-  end
-
-  def test_timeout_overwrite
-    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)
-
-    subject.timeout = 42
-    assert_same(42, subject.connect_timeout)
-    assert_same(42, subject.read_timeout)
-    assert_same(42, subject.write_timeout)
-  end
-
-  def test_timeout_error_overwrite
-    subject = TCPClient::Configuration.new
-    assert_same(TCPClient::ConnectTimeoutError, subject.connect_timeout_error)
-    assert_same(TCPClient::ReadTimeoutError, subject.read_timeout_error)
-    assert_same(TCPClient::WriteTimeoutError, subject.write_timeout_error)
-
-    subject.timeout_error = IOError
-    assert_same(IOError, subject.connect_timeout_error)
-    assert_same(IOError, subject.read_timeout_error)
-    assert_same(IOError, subject.write_timeout_error)
-  end
-
-  def test_compare
-    a = TCPClient::Configuration.new
-    b = TCPClient::Configuration.new
-    assert_equal(a, b)
-    assert(a == b)
-    assert(a === b)
-  end
-
-  def test_dup
-    source =
-      TCPClient::Configuration.new(
-        buffered: false,
-        keep_alive: false,
-        reverse_lookup: false,
-        connect_timeout: 1,
-        read_timeout: 2,
-        write_timeout: 3,
-        ssl: {
-          ssl_version: :TLSv1_2
-        }
-      )
-    shadow = source.dup.freeze
-
-    # some changes
-    source.buffered = true
-    source.write_timeout = 5
-    source.ssl_params[:err] = true
-    source.timeout_error = IOError
-
-    refute_equal(source.__id__, shadow.__id__)
-    refute(shadow.buffered)
-    assert_equal(3, shadow.write_timeout)
-    assert_equal({ ssl_version: :TLSv1_2 }, shadow.ssl_params)
-    assert_same(TCPClient::ReadTimeoutError, shadow.read_timeout_error)
-  end
-end

data/test/tcp-client/deadline_test.rb

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

data/test/tcp-client/default_configuration_test.rb

@@ -1,59 +0,0 @@
-require_relative '../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,9 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../helper'
-
-class VersionTest < Test
-  def test_format
-    assert_match(/\d+\.\d+\.\d+/, TCPClient::VERSION)
-  end
-end

data/test/tcp_client_test.rb

@@ -1,180 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'helper'
-
-class TCPClientTest < Test
-  HUGE_AMOUNT_OF_DATA = Array.new(1024, '?' * 2048).freeze
-
-  attr_reader :config
-
-  def setup
-    @config = TCPClient::Configuration.create(buffered: false)
-  end
-
-  def port
-    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) }
-  end
-
-  def create_nonconnected_client
-    client = TCPClient.new
-    client.connect('', config)
-    :you_should_not_get_this
-  rescue Errno::EADDRNOTAVAIL
-    client
-  end
-
-  def test_failed_state
-    subject = create_nonconnected_client
-    assert(subject.closed?)
-    assert_equal('localhost:0', subject.to_s)
-    refute_nil(subject.address)
-    assert_equal('localhost:0', subject.address.to_s)
-    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) }
-  end
-
-  def test_connected_state
-    TCPClient.open(address, config) do |subject|
-      refute(subject.closed?)
-      assert_equal(address, subject.to_s)
-      refute_nil(subject.address)
-      address_when_opened = subject.address
-      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)
-
-      subject.close
-      assert(subject.closed?)
-      assert_same(address_when_opened, subject.address)
-    end
-  end
-
-  def check_read_timeout(timeout)
-    TCPClient.open(address, config) do |subject|
-      refute(subject.closed?)
-      timing = Timing.new
-      assert_raises(TCPClient::ReadTimeoutError) do
-        timing.start
-        subject.read(42, timeout: timeout)
-      end
-      assert_in_delta(timeout, timing.elapsed, 0.15)
-    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(address, config) do |subject|
-      refute(subject.closed?)
-      timing = Timing.new
-      assert_raises(TCPClient::WriteTimeoutError) do
-        timing.start
-        subject.write(*HUGE_AMOUNT_OF_DATA, timeout: timeout)
-      end
-      assert_in_delta(timeout, timing.elapsed, 0.15)
-    end
-  end
-
-  def test_write_timeout
-    check_write_timeout(0.01)
-    check_write_timeout(0.25)
-  end
-
-  def test_write_deadline
-    TCPClient.open(address, 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(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(42) }
-        end
-      end
-    end
-  end
-
-  def test_read_write_deadline
-    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('some data')
-            subject.read(0)
-          end
-        end
-      end
-    end
-  end
-
-  def check_connect_timeout(ssl_config)
-    timing = Timing.new
-    assert_raises(TCPClient::ConnectTimeoutError) do
-      timing.start
-      TCPClient.new.connect(address, ssl_config)
-    end
-    assert_in_delta(ssl_config.connect_timeout, timing.elapsed, 0.25)
-  end
-
-  def test_connect_ssl_timeout
-    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
-
-  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