tcp-client 0.10.1 → 0.11.2

data/spec/tcp-client/address_spec.rb

@@ -1,132 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../helper'
-
-RSpec.describe TCPClient::Address do
-  describe '.new' do
-    context 'when called with an Integer parameter' do
-      subject(:address) { TCPClient::Address.new(42) }
-
-      it 'points to the given port on localhost' do
-        expect(address.hostname).to eq 'localhost'
-        expect(address.port).to be 42
-        expect(address.to_s).to eq 'localhost:42'
-      end
-
-      it 'uses IPv6' do
-        expect(address.addrinfo.ip?).to be true
-        expect(address.addrinfo.ipv6?).to be true
-        expect(address.addrinfo.ipv4?).to be false
-      end
-    end
-
-    context 'when called with an Addrinfo' do
-      subject(:address) { TCPClient::Address.new(addrinfo) }
-      let(:addrinfo) { Addrinfo.tcp('::1', 42) }
-
-      it 'uses the given Addrinfo' do
-        expect(address.addrinfo).to eq addrinfo
-      end
-
-      it 'points to the given host and port' do
-        expect(address.hostname).to eq 'localhost'
-        expect(address.port).to be 42
-        expect(address.to_s).to eq 'localhost:42'
-      end
-
-      it 'uses IPv6' do
-        expect(address.addrinfo.ip?).to be true
-        expect(address.addrinfo.ipv6?).to be true
-        expect(address.addrinfo.ipv4?).to be false
-      end
-    end
-
-    context 'when called with a String' do
-      context 'when a host name and port is provided' do
-        subject(:address) { TCPClient::Address.new('localhost:42') }
-
-        it 'points to the given host and port' do
-          expect(address.hostname).to eq 'localhost'
-          expect(address.port).to be 42
-          expect(address.to_s).to eq 'localhost:42'
-          expect(address.addrinfo.ip?).to be true
-        end
-
-      end
-
-      context 'when only a port is provided' do
-        subject(:address) { TCPClient::Address.new(':42') }
-
-        it 'points to the given port on localhost' do
-          expect(address.hostname).to eq 'localhost'
-          expect(address.port).to be 42
-          expect(address.to_s).to eq 'localhost:42'
-          expect(address.addrinfo.ip?).to be true
-        end
-      end
-
-      context 'when an IPv6 address is provided' do
-        subject(:address) { TCPClient::Address.new('[::1]:42') }
-
-        it 'points to the given port on localhost' do
-          expect(address.hostname).to eq '::1'
-          expect(address.port).to be 42
-          expect(address.to_s).to eq '[::1]:42'
-          expect(address.addrinfo.ip?).to be true
-        end
-      end
-    end
-  end
-
-  describe '#to_h' do
-    subject(:address) { TCPClient::Address.new('localhost:42') }
-
-    it 'returns itself as an Hash' do
-      expect(address.to_h).to eq(host: 'localhost', port: 42)
-    end
-  end
-
-  describe 'comparison' do
-    context 'comparing two equal instances' do
-      let(:address_a) { TCPClient::Address.new('localhost:42') }
-      let(:address_b) { TCPClient::Address.new('localhost:42') }
-
-      it 'compares to equal' do
-        expect(address_a).to eq address_b
-      end
-
-      context 'using the == operator' do
-        it 'compares to equal' do
-          expect(address_a == address_b).to be true
-        end
-      end
-
-      context 'using the === operator' do
-        it 'compares to equal' do
-          expect(address_a === address_b).to be true
-        end
-      end
-    end
-
-    context 'comparing two non-equal instances' do
-      let(:address_a) { TCPClient::Address.new('localhost:42') }
-      let(:address_b) { TCPClient::Address.new('localhost:21') }
-
-      it 'compares not to equal' do
-        expect(address_a).not_to eq address_b
-      end
-
-      context 'using the == operator' do
-        it 'compares not to equal' do
-          expect(address_a == address_b).to be false
-        end
-      end
-
-      context 'using the === operator' do
-        it 'compares not to equal' do
-          expect(address_a === address_b).to be false
-        end
-      end
-    end
-  end
-end

data/spec/tcp-client/configuration_spec.rb

@@ -1,270 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../helper'
-
-RSpec.describe TCPClient::Configuration do
-  describe '.create' do
-    it 'yields a configuration' do
-      TCPClient::Configuration.create do |cfg|
-        expect(cfg).to be_a TCPClient::Configuration
-      end
-    end
-
-    it 'returns the configuration' do
-      yielded_cfg = nil
-      result = TCPClient::Configuration.create { |cfg| yielded_cfg = cfg }
-      expect(result).to be yielded_cfg
-    end
-  end
-
-  describe '.new' do
-    context 'without any parameter' do
-      subject(:configuration) { TCPClient::Configuration.new }
-
-      it 'allows buffering' do
-        expect(configuration.buffered).to be true
-      end
-
-      it 'allows keep alive signals' do
-        expect(configuration.keep_alive).to be true
-      end
-
-      it 'allows reverse address lokup' do
-        expect(configuration.reverse_lookup).to be true
-      end
-
-      it 'does not allow to normalize network errors' do
-        expect(configuration.normalize_network_errors).to be false
-      end
-
-      it 'does not allow SSL connections' do
-        expect(configuration.ssl?).to be false
-      end
-
-      it 'configures no timeout values' do
-        expect(configuration.connect_timeout).to be_nil
-        expect(configuration.read_timeout).to be_nil
-        expect(configuration.write_timeout).to be_nil
-      end
-
-      it 'configures default errors' do
-        expect(
-          configuration.connect_timeout_error
-        ).to be TCPClient::ConnectTimeoutError
-        expect(
-          configuration.read_timeout_error
-        ).to be TCPClient::ReadTimeoutError
-        expect(
-          configuration.write_timeout_error
-        ).to be TCPClient::WriteTimeoutError
-      end
-    end
-
-    context 'with valid options' do
-      subject(:configuration) do
-        TCPClient::Configuration.new(
-          buffered: false,
-          keep_alive: false,
-          reverse_lookup: false,
-          normalize_network_errors: true,
-          ssl: true,
-          timeout: 60,
-          timeout_error: custom_error
-        )
-      end
-      let(:custom_error) { Class.new(StandardError) }
-
-      it 'allows to configure buffering' do
-        expect(configuration.buffered).to be false
-      end
-
-      it 'allows to configure keep alive signals' do
-        expect(configuration.keep_alive).to be false
-      end
-
-      it 'allows to configure reverse address lookup' do
-        expect(configuration.reverse_lookup).to be false
-      end
-
-      it 'allows to configure to normalize network errors' do
-        expect(configuration.normalize_network_errors).to be true
-      end
-
-      it 'allows to configures SSL connections' do
-        expect(configuration.ssl?).to be true
-      end
-
-      it 'allows to configure no timeout values' do
-        expect(configuration.connect_timeout).to be 60
-        expect(configuration.read_timeout).to be 60
-        expect(configuration.write_timeout).to be 60
-      end
-
-      it 'allows to configure timeout errors' do
-        expect(configuration.connect_timeout_error).to be custom_error
-        expect(configuration.read_timeout_error).to be custom_error
-        expect(configuration.write_timeout_error).to be custom_error
-      end
-
-      it 'allows to configure dedicated timeout values' do
-        config =
-          TCPClient::Configuration.new(
-            connect_timeout: 21,
-            read_timeout: 42,
-            write_timeout: 84
-          )
-        expect(config.connect_timeout).to be 21
-        expect(config.read_timeout).to be 42
-        expect(config.write_timeout).to be 84
-      end
-
-      it 'allows to configure dedicated timeout errors' do
-        custom_connect = Class.new(StandardError)
-        custom_read = Class.new(StandardError)
-        custom_write = Class.new(StandardError)
-        config =
-          TCPClient::Configuration.new(
-            connect_timeout_error: custom_connect,
-            read_timeout_error: custom_read,
-            write_timeout_error: custom_write
-          )
-        expect(config.connect_timeout_error).to be custom_connect
-        expect(config.read_timeout_error).to be custom_read
-        expect(config.write_timeout_error).to be custom_write
-      end
-
-      it 'raises when no exception class is used to configure a timeout error' do
-        expect do
-          TCPClient::Configuration.new(
-            connect_timeout_error: double(:something)
-          )
-        end.to raise_error(TCPClient::NotAnExceptionError)
-        expect do
-          TCPClient::Configuration.new(read_timeout_error: double(:something))
-        end.to raise_error(TCPClient::NotAnExceptionError)
-        expect do
-          TCPClient::Configuration.new(write_timeout_error: double(:something))
-        end.to raise_error(TCPClient::NotAnExceptionError)
-      end
-    end
-
-    context 'with invalid attribute' do
-      it 'raises an error' do
-        expect { TCPClient::Configuration.new(invalid: :value) }.to raise_error(
-          TCPClient::UnknownAttributeError
-        )
-      end
-    end
-  end
-
-  describe '#to_h' do
-    subject(:configuration) do
-      TCPClient::Configuration.new(
-        buffered: false,
-        connect_timeout: 1,
-        read_timeout: 2,
-        write_timeout: 3,
-        ssl: {
-          min_version: :TLS1_2,
-          max_version: :TLS1_3
-        }
-      )
-    end
-
-    it 'returns itself as an Hash' do
-      expect(configuration.to_h).to eq(
-        buffered: false,
-        keep_alive: true,
-        reverse_lookup: true,
-        connect_timeout: 1,
-        connect_timeout_error: TCPClient::ConnectTimeoutError,
-        read_timeout: 2,
-        read_timeout_error: TCPClient::ReadTimeoutError,
-        write_timeout: 3,
-        write_timeout_error: TCPClient::WriteTimeoutError,
-        normalize_network_errors: false,
-        ssl_params: {
-          min_version: :TLS1_2,
-          max_version: :TLS1_3
-        }
-      )
-    end
-  end
-
-  describe '#dup' do
-    subject(:duplicate) { configuration.dup }
-    let(:configuration) do
-      TCPClient::Configuration.new(
-        buffered: false,
-        connect_timeout: 1,
-        read_timeout: 2,
-        write_timeout: 3,
-        ssl: {
-          min_version: :TLS1_2,
-          max_version: :TLS1_3
-        }
-      )
-    end
-
-    it 'returns a new instance' do
-      expect(duplicate).to be_a TCPClient::Configuration
-      expect(duplicate.__id__).not_to eq configuration.__id__
-    end
-
-    it 'contains same values as the original' do
-      expect(duplicate.buffered).to be false
-      expect(duplicate.connect_timeout).to be 1
-      expect(duplicate.read_timeout).to be 2
-      expect(duplicate.write_timeout).to be 3
-      expect(duplicate.ssl?).to be true
-      expect(duplicate.ssl_params).to eq(
-        min_version: :TLS1_2,
-        max_version: :TLS1_3
-      )
-    end
-  end
-
-  describe 'comparison' do
-    context 'comparing two equal instances' do
-      let(:config_a) { TCPClient::Configuration.new(timeout: 10) }
-      let(:config_b) { TCPClient::Configuration.new(timeout: 10) }
-
-      it 'compares to equal' do
-        expect(config_a).to eq config_b
-      end
-
-      context 'using the == operator' do
-        it 'compares to equal' do
-          expect(config_a == config_b).to be true
-        end
-      end
-
-      context 'using the === operator' do
-        it 'compares to equal' do
-          expect(config_a === config_b).to be true
-        end
-      end
-    end
-
-    context 'comparing two non-equal instances' do
-      let(:config_a) { TCPClient::Configuration.new(timeout: 10) }
-      let(:config_b) { TCPClient::Configuration.new(timeout: 20) }
-
-      it 'compares not to equal' do
-        expect(config_a).not_to eq config_b
-      end
-
-      context 'using the == operator' do
-        it 'compares not to equal' do
-          expect(config_a == config_b).to be false
-        end
-      end
-
-      context 'using the === operator' do
-        it 'compares not to equal' do
-          expect(config_a === config_b).to be false
-        end
-      end
-    end
-  end
-end

data/spec/tcp-client/default_configuration_spec.rb

@@ -1,22 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../helper'
-
-RSpec.describe 'TCPClient.configure' do
-  it 'is the default configuration' do
-    expect(TCPClient.configure).to be TCPClient::Configuration.default
-  end
-
-  context 'called with parameters' do
-    it 'creates a new configuratiion' do
-      expect(TCPClient::Configuration).to receive(:create).once.with(a: 1, b: 2)
-      TCPClient.configure(a: 1, b: 2)
-    end
-
-    it 'returns the new configuratiion' do
-      expect(TCPClient::Configuration).to receive(:create).and_return(:a_result)
-      TCPClient.configure(something: :new)
-      expect(TCPClient::Configuration.default).to be :a_result
-    end
-  end
-end

data/spec/tcp-client/version_spec.rb

@@ -1,13 +0,0 @@
-# frozen_string_literal: true
-
-require_relative '../helper'
-
-RSpec.describe 'TCPClient::VERSION' do
-  it 'is a valid version string' do
-    expect(TCPClient::VERSION).to match(/\d+\.\d+\.\d+/)
-  end
-
-  it 'is frozen' do
-    expect(TCPClient::VERSION.frozen?).to be true
-  end
-end