http 4.4.0 → 5.0.0

data/lib/http/timeout/null.rb

@@ -12,7 +12,7 @@ module HTTP
 
       attr_reader :options, :socket
 
-      def initialize(options = {}) # rubocop:disable Style/OptionHash
+      def initialize(options = {})
         @options = options
       end
 
@@ -36,6 +36,7 @@ module HTTP
         connect_ssl
 
         return unless ssl_context.verify_mode == OpenSSL::SSL::VERIFY_PEER
+        return if ssl_context.respond_to?(:verify_hostname) && !ssl_context.verify_hostname
 
         @socket.post_connection_check(host)
       end

data/lib/http/timeout/per_operation.rb

@@ -34,65 +34,42 @@ module HTTP
         end
       end
 
-      # NIO with exceptions
-      if RUBY_VERSION < "2.1.0"
-        # Read data from the socket
-        def readpartial(size, buffer = nil)
-          rescue_readable do
-            @socket.read_nonblock(size, buffer)
-          end
-        rescue EOFError
-          :eof
-        end
-
-        # Write data to the socket
-        def write(data)
-          rescue_writable do
-            @socket.write_nonblock(data)
-          end
-        rescue EOFError
-          :eof
-        end
-
-      # NIO without exceptions
-      else
-        # Read data from the socket
-        def readpartial(size, buffer = nil)
-          timeout = false
-          loop do
-            result = @socket.read_nonblock(size, buffer, :exception => false)
-
-            return :eof   if result.nil?
-            return result if result != :wait_readable
-
-            raise TimeoutError, "Read timed out after #{@read_timeout} seconds" if timeout
-            # marking the socket for timeout. Why is this not being raised immediately?
-            # it seems there is some race-condition on the network level between calling
-            # #read_nonblock and #wait_readable, in which #read_nonblock signalizes waiting
-            # for reads, and when waiting for x seconds, it returns nil suddenly without completing
-            # the x seconds. In a normal case this would be a timeout on wait/read, but it can
-            # also mean that the socket has been closed by the server. Therefore we "mark" the
-            # socket for timeout and try to read more bytes. If it returns :eof, it's all good, no
-            # timeout. Else, the first timeout was a proper timeout.
-            # This hack has to be done because io/wait#wait_readable doesn't provide a value for when
-            # the socket is closed by the server, and HTTP::Parser doesn't provide the limit for the chunks.
-            timeout = true unless @socket.to_io.wait_readable(@read_timeout)
-          end
+      # Read data from the socket
+      def readpartial(size, buffer = nil)
+        timeout = false
+        loop do
+          result = @socket.read_nonblock(size, buffer, :exception => false)
+
+          return :eof   if result.nil?
+          return result if result != :wait_readable
+
+          raise TimeoutError, "Read timed out after #{@read_timeout} seconds" if timeout
+
+          # marking the socket for timeout. Why is this not being raised immediately?
+          # it seems there is some race-condition on the network level between calling
+          # #read_nonblock and #wait_readable, in which #read_nonblock signalizes waiting
+          # for reads, and when waiting for x seconds, it returns nil suddenly without completing
+          # the x seconds. In a normal case this would be a timeout on wait/read, but it can
+          # also mean that the socket has been closed by the server. Therefore we "mark" the
+          # socket for timeout and try to read more bytes. If it returns :eof, it's all good, no
+          # timeout. Else, the first timeout was a proper timeout.
+          # This hack has to be done because io/wait#wait_readable doesn't provide a value for when
+          # the socket is closed by the server, and HTTP::Parser doesn't provide the limit for the chunks.
+          timeout = true unless @socket.to_io.wait_readable(@read_timeout)
         end
+      end
 
-        # Write data to the socket
-        def write(data)
-          timeout = false
-          loop do
-            result = @socket.write_nonblock(data, :exception => false)
-            return result unless result == :wait_writable
+      # Write data to the socket
+      def write(data)
+        timeout = false
+        loop do
+          result = @socket.write_nonblock(data, :exception => false)
+          return result unless result == :wait_writable
 
-            raise TimeoutError, "Write timed out after #{@write_timeout} seconds" if timeout
+          raise TimeoutError, "Write timed out after #{@write_timeout} seconds" if timeout
 
-            timeout = true unless @socket.to_io.wait_writable(@write_timeout)
-          end
+          timeout = true unless @socket.to_io.wait_writable(@write_timeout)
         end
-
       end
     end
   end

data/lib/http/uri.rb

@@ -31,11 +31,11 @@ module HTTP
       uri = HTTP::URI.parse uri
 
       HTTP::URI.new(
-        :scheme     => uri.normalized_scheme,
-        :authority  => uri.normalized_authority,
-        :path       => uri.normalized_path,
-        :query      => uri.query,
-        :fragment   => uri.normalized_fragment
+        :scheme    => uri.normalized_scheme,
+        :authority => uri.normalized_authority,
+        :path      => uri.normalized_path,
+        :query     => uri.query,
+        :fragment  => uri.normalized_fragment
       )
     end
 

data/lib/http/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module HTTP
-  VERSION = "4.4.0"
+  VERSION = "5.0.0"
 end

data/spec/lib/http/client_spec.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # coding: utf-8
+# frozen_string_literal: true
 
 require "support/http_handling_shared"
 require "support/dummy_server"
@@ -8,39 +8,50 @@ require "support/ssl_helper"
 RSpec.describe HTTP::Client do
   run_server(:dummy) { DummyServer.new }
 
-  StubbedClient = Class.new(HTTP::Client) do
-    def perform(request, options)
-      stubs.fetch(request.uri) { super(request, options) }
-    end
+  before do
+    stubbed_client = Class.new(HTTP::Client) do
+      def perform(request, options)
+        stubbed = stubs[HTTP::URI::NORMALIZER.call(request.uri).to_s]
+        stubbed ? stubbed.call(request) : super(request, options)
+      end
 
-    def stubs
-      @stubs ||= {}
-    end
+      def stubs
+        @stubs ||= {}
+      end
 
-    def stub(stubs)
-      @stubs = stubs.each_with_object({}) do |(k, v), o|
-        o[HTTP::URI.parse k] = v
+      def stub(stubs)
+        @stubs = stubs.transform_keys do |k|
+          HTTP::URI::NORMALIZER.call(k).to_s
+        end
+
+        self
       end
+    end
 
-      self
+    def redirect_response(location, status = 302)
+      lambda do |request|
+        HTTP::Response.new(
+          :status  => status,
+          :version => "1.1",
+          :headers => {"Location" => location},
+          :body    => "",
+          :request => request
+        )
+      end
     end
-  end
 
-  def redirect_response(location, status = 302)
-    HTTP::Response.new(
-      :status  => status,
-      :version => "1.1",
-      :headers => {"Location" => location},
-      :body    => ""
-    )
-  end
+    def simple_response(body, status = 200)
+      lambda do |request|
+        HTTP::Response.new(
+          :status  => status,
+          :version => "1.1",
+          :body    => body,
+          :request => request
+        )
+      end
+    end
 
-  def simple_response(body, status = 200)
-    HTTP::Response.new(
-      :status  => status,
-      :version => "1.1",
-      :body    => body
-    )
+    stub_const("StubbedClient", stubbed_client)
   end
 
   describe "following redirects" do
@@ -193,7 +204,7 @@ RSpec.describe HTTP::Client do
     context "when passing an HTTP::FormData object directly" do
       it "creates url encoded form data object" do
         client    = HTTP::Client.new
-        form_data = HTTP::FormData::Multipart.new(:foo => "bar")
+        form_data = HTTP::FormData::Multipart.new({ :foo => "bar" })
 
         allow(client).to receive(:perform)
 
@@ -279,6 +290,75 @@ RSpec.describe HTTP::Client do
         end
       end
     end
+
+    context "Feature" do
+      let(:feature_class) do
+        Class.new(HTTP::Feature) do
+          attr_reader :captured_request, :captured_response, :captured_error
+
+          def wrap_request(request)
+            @captured_request = request
+          end
+
+          def wrap_response(response)
+            @captured_response = response
+          end
+
+          def on_error(request, error)
+            @captured_request = request
+            @captured_error = error
+          end
+        end
+      end
+
+      it "is given a chance to wrap the Request" do
+        feature_instance = feature_class.new
+
+        response = client.use(:test_feature => feature_instance).
+                   request(:get, dummy.endpoint)
+
+        expect(response.code).to eq(200)
+        expect(feature_instance.captured_request.verb).to eq(:get)
+        expect(feature_instance.captured_request.uri.to_s).to eq("#{dummy.endpoint}/")
+      end
+
+      it "is given a chance to wrap the Response" do
+        feature_instance = feature_class.new
+
+        response = client.use(:test_feature => feature_instance).
+                   request(:get, dummy.endpoint)
+
+        expect(feature_instance.captured_response).to eq(response)
+      end
+
+      it "is given a chance to handle an error" do
+        sleep_url = "#{dummy.endpoint}/sleep"
+        feature_instance = feature_class.new
+
+        expect do
+          client.use(:test_feature => feature_instance).
+            timeout(0.2).
+            request(:post, sleep_url)
+        end.to raise_error(HTTP::TimeoutError)
+
+        expect(feature_instance.captured_error).to be_a(HTTP::TimeoutError)
+        expect(feature_instance.captured_request.verb).to eq(:post)
+        expect(feature_instance.captured_request.uri.to_s).to eq(sleep_url)
+      end
+
+      it "is given a chance to handle a connection timeout error" do
+        allow(TCPSocket).to receive(:open) { sleep 1 }
+        sleep_url = "#{dummy.endpoint}/sleep"
+        feature_instance = feature_class.new
+
+        expect do
+          client.use(:test_feature => feature_instance).
+            timeout(0.001).
+            request(:post, sleep_url)
+        end.to raise_error(HTTP::TimeoutError)
+        expect(feature_instance.captured_error).to be_a(HTTP::TimeoutError)
+      end
+    end
   end
 
   include_context "HTTP handling" do
@@ -288,7 +368,8 @@ RSpec.describe HTTP::Client do
     let(:client)  { described_class.new(options.merge(extra_options)) }
   end
 
-  describe "working with SSL" do
+  # TODO: https://github.com/httprb/http/issues/627
+  xdescribe "working with SSL" do
     run_server(:dummy_ssl) { DummyServer.new(:ssl => true) }
 
     let(:extra_options) { {} }
@@ -331,6 +412,14 @@ RSpec.describe HTTP::Client do
       client.get(dummy.endpoint).to_s
     end
 
+    it "provides access to the Request from the Response" do
+      unique_value = "20190424"
+      response = client.headers("X-Value" => unique_value).get(dummy.endpoint)
+
+      expect(response.request).to be_a(HTTP::Request)
+      expect(response.request.headers["X-Value"]).to eq(unique_value)
+    end
+
     context "with HEAD request" do
       it "does not iterates through body" do
         expect_any_instance_of(HTTP::Connection).to_not receive(:readpartial)
@@ -421,7 +510,7 @@ RSpec.describe HTTP::Client do
           BODY
         end
 
-        it "raises HTTP::ConnectionError" do
+        xit "raises HTTP::ConnectionError" do
           expect { client.get(dummy.endpoint).to_s }.to raise_error(HTTP::ConnectionError)
         end
       end

data/spec/lib/http/connection_spec.rb

@@ -3,9 +3,9 @@
 RSpec.describe HTTP::Connection do
   let(:req) do
     HTTP::Request.new(
-      :verb     => :get,
-      :uri      => "http://example.com/",
-      :headers  => {}
+      :verb    => :get,
+      :uri     => "http://example.com/",
+      :headers => {}
     )
   end
   let(:socket) { double(:connect => nil) }
@@ -20,14 +20,17 @@ RSpec.describe HTTP::Connection do
         <<-RESPONSE.gsub(/^\s*\| */, "").gsub(/\n/, "\r\n")
         | HTTP/1.1 200 OK
         | Content-Type: text
+        | foo_bar: 123
         |
         RESPONSE
       end
     end
 
-    it "reads data in parts" do
+    it "populates headers collection, preserving casing" do
       connection.read_headers!
-      expect(connection.headers).to eq("Content-Type" => "text")
+      expect(connection.headers).to eq("Content-Type" => "text", "foo_bar" => "123")
+      expect(connection.headers["Foo-Bar"]).to eq("123")
+      expect(connection.headers["foo_bar"]).to eq("123")
     end
   end
 

data/spec/lib/http/features/auto_inflate_spec.rb

@@ -11,7 +11,8 @@ RSpec.describe HTTP::Features::AutoInflate do
       :version    => "1.1",
       :status     => 200,
       :headers    => headers,
-      :connection => connection
+      :connection => connection,
+      :request    => HTTP::Request.new(:verb => :get, :uri => "http://example.com")
     )
   end
 
@@ -73,7 +74,8 @@ RSpec.describe HTTP::Features::AutoInflate do
           :status     => 200,
           :headers    => {:content_encoding => "gzip"},
           :connection => connection,
-          :uri        => "https://example.com"
+          :uri        => "https://example.com",
+          :request    => HTTP::Request.new(:verb => :get, :uri => "https://example.com")
         )
       end
 

data/spec/lib/http/features/instrumentation_spec.rb

@@ -2,15 +2,36 @@
 
 RSpec.describe HTTP::Features::Instrumentation do
   subject(:feature) { HTTP::Features::Instrumentation.new(:instrumenter => instrumenter) }
+
   let(:instrumenter) { TestInstrumenter.new }
 
+  before do
+    test_instrumenter = Class.new(HTTP::Features::Instrumentation::NullInstrumenter) do
+      attr_reader :output
+
+      def initialize
+        @output = {}
+      end
+
+      def start(_name, payload)
+        output[:start] = payload
+      end
+
+      def finish(_name, payload)
+        output[:finish] = payload
+      end
+    end
+
+    stub_const("TestInstrumenter", test_instrumenter)
+  end
+
   describe "logging the request" do
     let(:request) do
       HTTP::Request.new(
-        :verb => :post,
-        :uri => "https://example.com/",
+        :verb    => :post,
+        :uri     => "https://example.com/",
         :headers => {:accept => "application/json"},
-        :body => '{"hello": "world!"}'
+        :body    => '{"hello": "world!"}'
       )
     end
 
@@ -25,10 +46,11 @@ RSpec.describe HTTP::Features::Instrumentation do
     let(:response) do
       HTTP::Response.new(
         :version => "1.1",
-        :uri => "https://example.com",
-        :status => 200,
+        :uri     => "https://example.com",
+        :status  => 200,
         :headers => {:content_type => "application/json"},
-        :body => '{"success": true}'
+        :body    => '{"success": true}',
+        :request => HTTP::Request.new(:verb => :get, :uri => "https://example.com")
       )
     end
 
@@ -38,19 +60,4 @@ RSpec.describe HTTP::Features::Instrumentation do
       expect(instrumenter.output[:finish]).to eq(:response => response)
     end
   end
-
-  class TestInstrumenter < HTTP::Features::Instrumentation::NullInstrumenter
-    attr_reader :output
-    def initialize
-      @output = {}
-    end
-
-    def start(_name, payload)
-      output[:start] = payload
-    end
-
-    def finish(_name, payload)
-      output[:finish] = payload
-    end
-  end
 end