tcp-client 0.9.1 → 0.10.0

data/spec/tcp-client/address_spec.rb

@@ -9,8 +9,8 @@ RSpec.describe TCPClient::Address do
 
       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_port).to be 42
       end
 
       it 'uses IPv6' do
@@ -29,8 +29,9 @@ RSpec.describe TCPClient::Address do
       end
 
       it 'points to the given host and port' do
-        expect(address.hostname).to eq addrinfo.getnameinfo[0]
-        expect(address.addrinfo.ip_port).to be 42
+        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
@@ -46,30 +47,21 @@ RSpec.describe TCPClient::Address do
 
         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_port).to be 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 only a port is provided' do
-        subject(:address) { TCPClient::Address.new(':21') }
+        subject(:address) { TCPClient::Address.new(':42') }
 
         it 'points to the given port on localhost' do
-          expect(address.hostname).to eq ''
-          expect(address.to_s).to eq ':21'
-          expect(address.addrinfo.ip_port).to be 21
-        end
-
-        it 'uses IPv4' 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
-          expect(address.addrinfo.ipv6?).to be false
-          expect(address.addrinfo.ipv4?).to be true
         end
       end
 
@@ -78,14 +70,9 @@ RSpec.describe TCPClient::Address do
 
         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_port).to be 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
     end
@@ -108,13 +95,13 @@ RSpec.describe TCPClient::Address do
         expect(address_a).to eq address_b
       end
 
-      context 'using the == opperator' do
+      context 'using the == operator' do
         it 'compares to equal' do
           expect(address_a == address_b).to be true
         end
       end
 
-      context 'using the === opperator' do
+      context 'using the === operator' do
         it 'compares to equal' do
           expect(address_a === address_b).to be true
         end
@@ -129,13 +116,13 @@ RSpec.describe TCPClient::Address do
         expect(address_a).not_to eq address_b
       end
 
-      context 'using the == opperator' do
+      context 'using the == operator' do
         it 'compares not to equal' do
           expect(address_a == address_b).to be false
         end
       end
 
-      context 'using the === opperator' do
+      context 'using the === operator' do
         it 'compares not to equal' do
           expect(address_a === address_b).to be false
         end

data/spec/tcp-client/configuration_spec.rb

@@ -82,7 +82,7 @@ RSpec.describe TCPClient::Configuration do
         expect(configuration.keep_alive).to be false
       end
 
-      it 'allows to configure reverse address lokup' do
+      it 'allows to configure reverse address lookup' do
         expect(configuration.reverse_lookup).to be false
       end
 
@@ -148,7 +148,7 @@ RSpec.describe TCPClient::Configuration do
       end
     end
 
-    context 'with invalid attribte' do
+    context 'with invalid attribute' do
       it 'raises an error' do
         expect { TCPClient::Configuration.new(invalid: :value) }.to raise_error(
           TCPClient::UnknownAttributeError
@@ -182,6 +182,7 @@ RSpec.describe TCPClient::Configuration do
         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
@@ -232,13 +233,13 @@ RSpec.describe TCPClient::Configuration do
         expect(config_a).to eq config_b
       end
 
-      context 'using the == opperator' do
+      context 'using the == operator' do
         it 'compares to equal' do
           expect(config_a == config_b).to be true
         end
       end
 
-      context 'using the === opperator' do
+      context 'using the === operator' do
         it 'compares to equal' do
           expect(config_a === config_b).to be true
         end
@@ -253,13 +254,13 @@ RSpec.describe TCPClient::Configuration do
         expect(config_a).not_to eq config_b
       end
 
-      context 'using the == opperator' do
+      context 'using the == operator' do
         it 'compares not to equal' do
           expect(config_a == config_b).to be false
         end
       end
 
-      context 'using the === opperator' do
+      context 'using the === operator' do
         it 'compares not to equal' do
           expect(config_a === config_b).to be false
         end

data/spec/tcp_client_spec.rb

@@ -26,7 +26,7 @@ RSpec.describe TCPClient do
     subject(:client) { TCPClient.new }
 
     it 'is closed' do
-      expect(client.closed?).to be true
+      expect(client).to be_closed
     end
 
     it 'has no address' do
@@ -64,7 +64,7 @@ RSpec.describe TCPClient do
     before { allow_any_instance_of(::Socket).to receive(:connect) }
 
     it 'is not closed' do
-      expect(client.closed?).to be false
+      expect(client).not_to be_closed
     end
 
     it 'has an address' do
@@ -115,7 +115,7 @@ RSpec.describe TCPClient do
     end
 
     it 'is closed' do
-      expect(client.closed?).to be true
+      expect(client).to be_closed
     end
 
     it 'has an address' do
@@ -157,6 +157,8 @@ RSpec.describe TCPClient do
 
   context 'when not using SSL' do
     describe '#connect' do
+      subject(:client) { TCPClient.new }
+
       it 'configures the socket' do
         expect_any_instance_of(::Socket).to receive(:sync=).once.with(true)
         expect_any_instance_of(::Socket).to receive(:setsockopt)
@@ -169,7 +171,7 @@ RSpec.describe TCPClient do
           .once
           .with(false)
         expect_any_instance_of(::Socket).to receive(:connect)
-        TCPClient.new.connect('localhost:1234', configuration)
+        client.connect('localhost:1234', configuration)
       end
 
       context 'when a timeout is specified' do
@@ -177,7 +179,26 @@ RSpec.describe TCPClient do
           expect_any_instance_of(::Socket).to receive(:connect_nonblock)
             .once
             .with(kind_of(String), exception: false)
-          TCPClient.new.connect('localhost:1234', configuration, timeout: 10)
+          client.connect('localhost:1234', configuration, timeout: 10)
+        end
+
+        it 'is returns itself' do
+          allow_any_instance_of(::Socket).to receive(:connect_nonblock).with(
+            kind_of(String),
+            exception: false
+          )
+          result = client.connect('localhost:1234', configuration, timeout: 10)
+
+          expect(client).to be client
+        end
+
+        it 'is not closed' do
+          allow_any_instance_of(::Socket).to receive(:connect_nonblock).with(
+            kind_of(String),
+            exception: false
+          )
+          client.connect('localhost:1234', configuration, timeout: 10)
+          expect(client).not_to be_closed
         end
 
         context 'when the connection can not be established in time' do
@@ -188,25 +209,29 @@ RSpec.describe TCPClient do
 
           it 'raises an exception' do
             expect do
-              TCPClient.new.connect(
-                'localhost:1234',
-                configuration,
-                timeout: 0.25
-              )
+              client.connect('localhost:1234', configuration, timeout: 0.1)
             end.to raise_error(TCPClient::ConnectTimeoutError)
           end
 
           it 'allows to raise a custom exception' do
             exception = Class.new(StandardError)
             expect do
-              TCPClient.new.connect(
+              client.connect(
                 'localhost:1234',
                 configuration,
-                timeout: 0.25,
+                timeout: 0.1,
                 exception: exception
               )
             end.to raise_error(exception)
           end
+
+          it 'is still closed' do
+            begin
+              client.connect('localhost:1234', configuration, timeout: 0.1)
+            rescue TCPClient::ConnectTimeoutError
+            end
+            expect(client).to be_closed
+          end
         end
       end
 
@@ -226,7 +251,7 @@ RSpec.describe TCPClient do
           end
 
           SOCKET_ERRORS.each do |error_class|
-            it "raises a TCPClient::NetworkError when a #{error_class} appeared" do
+            it "raises TCPClient::NetworkError when a #{error_class} appeared" do
               allow_any_instance_of(::Socket).to receive(:connect) {
                 raise error_class
               }
@@ -270,18 +295,61 @@ RSpec.describe TCPClient do
           expect(client.read(timeout: 10)).to be data
         end
 
+        context 'when socket closed before any data can be read' do
+          it 'returns empty buffer' do
+            expect_any_instance_of(::Socket).to receive(:read_nonblock)
+              .and_return(nil)
+            expect(client.read(timeout: 10)).to be_empty
+          end
+
+          it 'is closed' do
+            expect_any_instance_of(::Socket).to receive(:read_nonblock)
+              .and_return(nil)
+
+            client.read(timeout: 10)
+            expect(client).to be_closed
+          end
+        end
+
         context 'when data can not be fetched in a single chunk' do
           it 'reads chunk by chunk' do
             expect_any_instance_of(::Socket).to receive(:read_nonblock)
               .once
-              .with(data_size * 2, exception: false)
+              .with(instance_of(Integer), exception: false)
               .and_return(data)
             expect_any_instance_of(::Socket).to receive(:read_nonblock)
               .once
-              .with(data_size, exception: false)
+              .with(instance_of(Integer), exception: false)
               .and_return(data)
             expect(client.read(data_size * 2, timeout: 10)).to eq data * 2
           end
+
+          context 'when socket closed before enough data is avail' do
+            it 'returns available data only' do
+              expect_any_instance_of(::Socket).to receive(:read_nonblock)
+                .once
+                .with(instance_of(Integer), exception: false)
+                .and_return(data)
+              expect_any_instance_of(::Socket).to receive(:read_nonblock)
+                .once
+                .with(instance_of(Integer), exception: false)
+                .and_return(nil)
+              expect(client.read(data_size * 2, timeout: 10)).to eq data
+            end
+
+            it 'is closed' do
+              expect_any_instance_of(::Socket).to receive(:read_nonblock)
+                .once
+                .with(instance_of(Integer), exception: false)
+                .and_return(data)
+              expect_any_instance_of(::Socket).to receive(:read_nonblock)
+                .once
+                .with(instance_of(Integer), exception: false)
+                .and_return(nil)
+              client.read(data_size * 2, timeout: 10)
+              expect(client).to be_closed
+            end
+          end
         end
 
         context 'when the data can not be read in time' do
@@ -329,6 +397,146 @@ RSpec.describe TCPClient do
       end
     end
 
+    describe '#readline' do
+      before { allow_any_instance_of(::Socket).to receive(:connect) }
+
+      it 'reads from socket' do
+        expect_any_instance_of(::Socket).to receive(:readline)
+          .once
+          .with($/, chomp: false)
+          .and_return("Hello World\n")
+        expect(client.readline).to eq "Hello World\n"
+      end
+
+      context 'when a separator is specified' do
+        it 'forwards the separator' do
+          expect_any_instance_of(::Socket).to receive(:readline)
+            .once
+            .with('/', chomp: false)
+            .and_return('Hello/')
+          expect(client.readline('/')).to eq 'Hello/'
+        end
+      end
+
+      context 'when chomp is true' do
+        it 'forwards the flag' do
+          expect_any_instance_of(::Socket).to receive(:readline)
+            .once
+            .with($/, chomp: true)
+            .and_return('Hello World')
+          expect(client.readline(chomp: true)).to eq 'Hello World'
+        end
+      end
+
+      context 'when a timeout is specified' do
+        it 'checks the time' do
+          expect_any_instance_of(::Socket).to receive(:read_nonblock)
+            .and_return("Hello World\nHello World\n")
+          expect(client.readline(timeout: 10)).to eq "Hello World\n"
+        end
+
+        it 'optional chomps the line' do
+          expect_any_instance_of(::Socket).to receive(:read_nonblock)
+            .and_return("Hello World\nHello World\n")
+          expect(client.readline(chomp: true, timeout: 10)).to eq 'Hello World'
+        end
+
+        it 'uses the given separator' do
+          expect_any_instance_of(::Socket).to receive(:read_nonblock)
+            .and_return("Hello/World\n")
+          expect(client.readline('/', timeout: 10)).to eq 'Hello/'
+        end
+
+        context 'when data can not be fetched in a single chunk' do
+          it 'reads chunk by chunk' do
+            expect_any_instance_of(::Socket).to receive(:read_nonblock)
+              .once
+              .with(instance_of(Integer), exception: false)
+              .and_return('Hello ')
+            expect_any_instance_of(::Socket).to receive(:read_nonblock)
+              .once
+              .with(instance_of(Integer), exception: false)
+              .and_return('World')
+            expect_any_instance_of(::Socket).to receive(:read_nonblock)
+              .once
+              .with(instance_of(Integer), exception: false)
+              .and_return("\nAnd so...")
+            expect(client.readline(timeout: 10)).to eq "Hello World\n"
+          end
+
+          context 'when socket closed before enough data is avail' do
+            it 'returns available data only' do
+              expect_any_instance_of(::Socket).to receive(:read_nonblock)
+                .once
+                .with(instance_of(Integer), exception: false)
+                .and_return('Hello ')
+              expect_any_instance_of(::Socket).to receive(:read_nonblock)
+                .once
+                .with(instance_of(Integer), exception: false)
+                .and_return(nil)
+             expect(client.readline(timeout: 10)).to eq "Hello "
+            end
+
+            it 'is closed' do
+              expect_any_instance_of(::Socket).to receive(:read_nonblock)
+                .once
+                .with(instance_of(Integer), exception: false)
+                .and_return('Hello ')
+              expect_any_instance_of(::Socket).to receive(:read_nonblock)
+                .once
+                .with(instance_of(Integer), exception: false)
+                .and_return(nil)
+              client.readline(timeout: 10)
+              expect(client).to be_closed
+            end
+          end
+        end
+
+        context 'when the data can not be read in time' do
+          before do
+            allow_any_instance_of(::Socket).to receive(:read_nonblock)
+              .and_return(:wait_readable)
+          end
+          it 'raises an exception' do
+            expect { client.readline(timeout: 0.25) }.to raise_error(
+              TCPClient::ReadTimeoutError
+            )
+          end
+
+          it 'allows to raise a custom exception' do
+            exception = Class.new(StandardError)
+            expect do
+              client.read(timeout: 0.25, exception: exception)
+            end.to raise_error(exception)
+          end
+        end
+      end
+
+      context 'when a SocketError appears' do
+        it 'does not handle it' do
+          allow_any_instance_of(::Socket).to receive(:read) {
+            raise SocketError
+          }
+          expect { client.read(10) }.to raise_error(SocketError)
+        end
+
+        context 'when normalize_network_errors is configured' do
+          let(:configuration) do
+            TCPClient::Configuration.create(normalize_network_errors: true)
+          end
+
+          SOCKET_ERRORS.each do |error_class|
+            it "raises a TCPClient::NetworkError when a #{error_class} appeared" do
+              allow_any_instance_of(::Socket).to receive(:read) {
+                raise error_class
+              }
+              expect { client.read(12) }.to raise_error(TCPClient::NetworkError)
+            end
+          end
+        end
+      end
+    end
+
     describe '#write' do
       let(:data) { 'some bytes' }
       let(:data_size) { data.bytesize }
@@ -463,20 +671,16 @@ RSpec.describe TCPClient do
           .with(kind_of(String), exception: false)
         expect_any_instance_of(::Socket).to receive(:read_nonblock)
           .once
-          .with(12, exception: false)
-          .and_return('123456789012')
+          .with(instance_of(Integer), exception: false)
+          .and_return('123456789012abcdefgAB')
         expect_any_instance_of(::Socket).to receive(:write_nonblock)
           .once
           .with('123456', exception: false)
           .and_return(6)
         expect_any_instance_of(::Socket).to receive(:read_nonblock)
           .once
-          .with(7, exception: false)
-          .and_return('abcdefg')
-        expect_any_instance_of(::Socket).to receive(:read_nonblock)
-          .once
-          .with(7, exception: false)
-          .and_return('ABCDEFG')
+          .with(instance_of(Integer), exception: false)
+          .and_return('CDEFG')
         expect_any_instance_of(::Socket).to receive(:write_nonblock)
           .once
           .with('abc', exception: false)

data/tcp-client.gemspec

@@ -5,12 +5,11 @@ require_relative './lib/tcp-client/version'
 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.author = 'Mike Blumtritt'
   spec.summary = 'A TCP client implementation with working timeout support.'
-  spec.description = <<~DESCRIPTION
+  spec.description = <<~description
     This Gem implements a TCP client with (optional) SSL support.
     It is an easy to use, versatile configurable client that can correctly
     handle time limits.
@@ -18,15 +17,15 @@ Gem::Specification.new do |spec|
     predefined/configurable time limits for each method
     (`connect`, `read`, `write`). Deadlines for a sequence of read/write
     actions can also be monitored.
-  DESCRIPTION
+  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['documentation_uri'] =
-    'https://rubydoc.info/github/mblumtritt/tcp-client'
-  spec.metadata['bug_tracker_uri'] =
-    'https://github.com/mblumtritt/tcp-client/issues'
+  spec.metadata.merge!(
+    'source_code_uri' => 'https://github.com/mblumtritt/tcp-client',
+    'bug_tracker_uri' => 'https://github.com/mblumtritt/tcp-client/issues',
+    'documentation_uri' => 'https://rubydoc.info/github/mblumtritt/tcp-client'
+  )
 
   spec.add_development_dependency 'bundler'
   spec.add_development_dependency 'rake'
@@ -36,6 +35,5 @@ Gem::Specification.new do |spec|
   all_files = Dir.chdir(__dir__) { `git ls-files -z`.split(0.chr) }
   spec.test_files = all_files.grep(%r{^spec/})
   spec.files = all_files - spec.test_files
-
   spec.extra_rdoc_files = %w[README.md LICENSE]
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: tcp-client
 version: !ruby/object:Gem::Version
-  version: 0.9.1
+  version: 0.10.0
 platform: ruby
 authors:
 - Mike Blumtritt
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2021-12-01 00:00:00.000000000 Z
+date: 2022-01-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -82,6 +82,7 @@ extra_rdoc_files:
 - LICENSE
 files:
 - ".gitignore"
+- ".yardopts"
 - LICENSE
 - README.md
 - gems.rb
@@ -111,8 +112,8 @@ licenses:
 - BSD-3-Clause
 metadata:
   source_code_uri: https://github.com/mblumtritt/tcp-client
-  documentation_uri: https://rubydoc.info/github/mblumtritt/tcp-client
   bug_tracker_uri: https://github.com/mblumtritt/tcp-client/issues
+  documentation_uri: https://rubydoc.info/github/mblumtritt/tcp-client
 post_install_message:
 rdoc_options: []
 require_paths:
@@ -128,7 +129,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.28
+rubygems_version: 3.3.3
 signing_key:
 specification_version: 4
 summary: A TCP client implementation with working timeout support.