http 3.1.0 → 5.3.1

data/spec/lib/http/client_spec.rb

@@ -1,5 +1,8 @@
-# frozen_string_literal: true
 # coding: utf-8
+# frozen_string_literal: true
+
+require "cgi"
+require "logger"
 
 require "support/http_handling_shared"
 require "support/dummy_server"
@@ -8,39 +11,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.transform_keys do |k|
+          HTTP::URI::NORMALIZER.call(k).to_s
+        end
 
-    def stub(stubs)
-      @stubs = stubs.each_with_object({}) do |(k, v), o|
-        o[HTTP::URI.parse k] = v
+        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
@@ -98,13 +112,45 @@ RSpec.describe HTTP::Client do
       end
 
       it "works like a charm in real world" do
-        url    = "http://git.io/jNeY"
-        client = HTTP.follow
-        expect(client.get(url).to_s).to include "support for non-ascii URIs"
+        expect(HTTP.follow.get("https://bit.ly/2UaBT4R").parse(:json)).
+          to include("url" => "https://httpbin.org/anything/könig")
       end
     end
   end
 
+  describe "following redirects with logging" do
+    let(:logger) do
+      logger           = Logger.new(logdev)
+      logger.formatter = ->(severity, _, _, message) { format("** %s **\n%s\n", severity, message) }
+      logger.level     = Logger::INFO
+      logger
+    end
+
+    let(:logdev) { StringIO.new }
+
+    it "logs all requests" do
+      client = StubbedClient.new(:follow => true, :features => { :logging => { :logger => logger } }).stub(
+        "http://example.com/"  => redirect_response("/1"),
+        "http://example.com/1" => redirect_response("/2"),
+        "http://example.com/2" => redirect_response("/3"),
+        "http://example.com/3" => simple_response("OK")
+      )
+
+      expect { client.get("http://example.com/") }.not_to raise_error
+
+      expect(logdev.string).to eq <<~OUTPUT
+        ** INFO **
+        > GET http://example.com/
+        ** INFO **
+        > GET http://example.com/1
+        ** INFO **
+        > GET http://example.com/2
+        ** INFO **
+        > GET http://example.com/3
+      OUTPUT
+    end
+  end
+
   describe "parsing params" do
     let(:client) { HTTP::Client.new }
     before { allow(client).to receive :perform }
@@ -190,6 +236,22 @@ RSpec.describe HTTP::Client do
 
       client.get("http://example.com/", :form => {:foo => HTTP::FormData::Part.new("content")})
     end
+
+    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" })
+
+        allow(client).to receive(:perform)
+
+        expect(HTTP::Request).to receive(:new) do |opts|
+          expect(opts[:body]).to be form_data
+          expect(opts[:body].to_s).to match(/^Content-Disposition: form-data; name="foo"\r\n\r\nbar\r\n/m)
+        end
+
+        client.get("http://example.com/", :form => form_data)
+      end
+    end
   end
 
   describe "passing json" do
@@ -199,6 +261,7 @@ RSpec.describe HTTP::Client do
 
       expect(HTTP::Request).to receive(:new) do |opts|
         expect(opts[:body]).to eq '{"foo":"bar"}'
+        expect(opts[:headers]["Content-Type"]).to eq "application/json; charset=utf-8"
       end
 
       client.get("http://example.com/", :json => {:foo => :bar})
@@ -213,9 +276,9 @@ RSpec.describe HTTP::Client do
       end
 
       it "works like a charm in real world" do
-        url     = "https://github.com/httprb/http.rb/pull/197/ö無"
-        client  = HTTP.follow
-        expect(client.get(url).to_s).to include "support for non-ascii URIs"
+        url = "https://httpbin.org/anything/ö無"
+
+        expect(HTTP.follow.get(url).parse(:json)).to include("url" => url)
       end
     end
 
@@ -234,7 +297,7 @@ RSpec.describe HTTP::Client do
 
     context "when :auto_deflate was specified" do
       let(:headers) { {"Content-Length" => "12"} }
-      let(:client)  { described_class.new :headers => headers, :features => {:auto_deflate => {}} }
+      let(:client)  { described_class.new :headers => headers, :features => {:auto_deflate => {}}, :body => "foo" }
 
       it "deletes Content-Length header" do
         expect(client).to receive(:perform) do |req, _|
@@ -251,6 +314,87 @@ RSpec.describe HTTP::Client do
 
         client.request(:get, "http://example.com/")
       end
+
+      context "and there is no body" do
+        let(:client) { described_class.new :headers => headers, :features => {:auto_deflate => {}} }
+
+        it "doesn't set Content-Encoding header" do
+          expect(client).to receive(:perform) do |req, _|
+            expect(req.headers).not_to include "Content-Encoding"
+          end
+
+          client.request(:get, "http://example.com/")
+        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::ConnectTimeoutError)
+        expect(feature_instance.captured_error).to be_a(HTTP::ConnectTimeoutError)
+      end
     end
   end
 
@@ -261,7 +405,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) { {} }
@@ -304,6 +449,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)
@@ -394,7 +547,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,16 +3,36 @@
 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) }
+  let(:socket) { double(:connect => nil, :close => nil) }
   let(:timeout_class) { double(:new => socket) }
   let(:opts) { HTTP::Options.new(:timeout_class => timeout_class) }
   let(:connection) { HTTP::Connection.new(req, opts) }
 
+  describe "#initialize times out" do
+    let(:req) do
+      HTTP::Request.new(
+        :verb    => :get,
+        :uri     => "https://example.com/",
+        :headers => {}
+      )
+    end
+
+    before do
+      expect(socket).to receive(:start_tls).and_raise(HTTP::TimeoutError)
+      expect(socket).to receive(:closed?) { false }
+      expect(socket).to receive(:close)
+    end
+
+    it "closes the connection" do
+      expect { connection }.to raise_error(HTTP::TimeoutError)
+    end
+  end
+
   describe "#read_headers!" do
     before do
       connection.instance_variable_set(:@pending_response, true)
@@ -20,14 +40,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
 
@@ -55,9 +78,11 @@ RSpec.describe HTTP::Connection do
       connection.read_headers!
       buffer = String.new
       while (s = connection.readpartial(3))
+        expect(connection.finished_request?).to be false if s != ""
         buffer << s
       end
       expect(buffer).to eq "1234567890"
+      expect(connection.finished_request?).to be true
     end
   end
 end

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

@@ -1,68 +1,85 @@
 # frozen_string_literal: true
 
 RSpec.describe HTTP::Features::AutoInflate do
-  subject { HTTP::Features::AutoInflate.new }
+  subject(:feature) { HTTP::Features::AutoInflate.new }
+
   let(:connection) { double }
-  let(:headers) { {} }
+  let(:headers)    { {} }
+
   let(:response) do
     HTTP::Response.new(
       :version    => "1.1",
       :status     => 200,
       :headers    => headers,
-      :connection => connection
+      :connection => connection,
+      :request    => HTTP::Request.new(:verb => :get, :uri => "http://example.com")
     )
   end
 
-  describe "stream_for" do
+  describe "#wrap_response" do
+    subject(:result) { feature.wrap_response(response) }
+
     context "when there is no Content-Encoding header" do
-      it "returns connection" do
-        stream = subject.stream_for(connection, response)
-        expect(stream).to eq(connection)
+      it "returns original request" do
+        expect(result).to be response
       end
     end
 
     context "for identity Content-Encoding header" do
-      let(:headers) { {:content_encoding => "not-supported"} }
+      let(:headers) { {:content_encoding => "identity"} }
 
-      it "returns connection" do
-        stream = subject.stream_for(connection, response)
-        expect(stream).to eq(connection)
+      it "returns original request" do
+        expect(result).to be response
       end
     end
 
     context "for unknown Content-Encoding header" do
       let(:headers) { {:content_encoding => "not-supported"} }
 
-      it "returns connection" do
-        stream = subject.stream_for(connection, response)
-        expect(stream).to eq(connection)
+      it "returns original request" do
+        expect(result).to be response
       end
     end
 
     context "for deflate Content-Encoding header" do
       let(:headers) { {:content_encoding => "deflate"} }
 
-      it "returns HTTP::Response::Inflater instance - connection wrapper" do
-        stream = subject.stream_for(connection, response)
-        expect(stream).to be_instance_of HTTP::Response::Inflater
+      it "returns a HTTP::Response wrapping the inflated response body" do
+        expect(result.body).to be_instance_of HTTP::Response::Body
       end
     end
 
     context "for gzip Content-Encoding header" do
       let(:headers) { {:content_encoding => "gzip"} }
 
-      it "returns HTTP::Response::Inflater instance - connection wrapper" do
-        stream = subject.stream_for(connection, response)
-        expect(stream).to be_instance_of HTTP::Response::Inflater
+      it "returns a HTTP::Response wrapping the inflated response body" do
+        expect(result.body).to be_instance_of HTTP::Response::Body
       end
     end
 
     context "for x-gzip Content-Encoding header" do
       let(:headers) { {:content_encoding => "x-gzip"} }
 
-      it "returns HTTP::Response::Inflater instance - connection wrapper" do
-        stream = subject.stream_for(connection, response)
-        expect(stream).to be_instance_of HTTP::Response::Inflater
+      it "returns a HTTP::Response wrapping the inflated response body" do
+        expect(result.body).to be_instance_of HTTP::Response::Body
+      end
+    end
+
+    # TODO(ixti): We should refactor API to either make uri non-optional,
+    #   or add reference to request into response object (better).
+    context "when response has uri" do
+      let(:response) do
+        HTTP::Response.new(
+          :version    => "1.1",
+          :status     => 200,
+          :headers    => {:content_encoding => "gzip"},
+          :connection => connection,
+          :request    => HTTP::Request.new(:verb => :get, :uri => "https://example.com")
+        )
+      end
+
+      it "preserves uri in wrapped response" do
+        expect(result.uri).to eq HTTP::URI.parse("https://example.com")
       end
     end
   end

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

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+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/",
+        :headers => {:accept => "application/json"},
+        :body    => '{"hello": "world!"}'
+      )
+    end
+
+    it "should log the request" do
+      feature.wrap_request(request)
+
+      expect(instrumenter.output[:start]).to eq(:request => request)
+    end
+  end
+
+  describe "logging the response" do
+    let(:response) do
+      HTTP::Response.new(
+        :version => "1.1",
+        :status  => 200,
+        :headers => {:content_type => "application/json"},
+        :body    => '{"success": true}',
+        :request => HTTP::Request.new(:verb => :get, :uri => "https://example.com")
+      )
+    end
+
+    it "should log the response" do
+      feature.wrap_response(response)
+
+      expect(instrumenter.output[:finish]).to eq(:response => response)
+    end
+  end
+
+  describe "logging errors" do
+    let(:request) do
+      HTTP::Request.new(
+        :verb    => :post,
+        :uri     => "https://example.com/",
+        :headers => {:accept => "application/json"},
+        :body    => '{"hello": "world!"}'
+      )
+    end
+
+    let(:error) { HTTP::TimeoutError.new }
+
+    it "should log the error" do
+      feature.on_error(request, error)
+
+      expect(instrumenter.output[:finish]).to eq(:request => request, :error => error)
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "logger"
+
+RSpec.describe HTTP::Features::Logging do
+  subject(:feature) do
+    logger           = Logger.new(logdev)
+    logger.formatter = ->(severity, _, _, message) { format("** %s **\n%s\n", severity, message) }
+
+    described_class.new(:logger => logger)
+  end
+
+  let(:logdev) { StringIO.new }
+
+  describe "logging the request" do
+    let(:request) do
+      HTTP::Request.new(
+        :verb    => :post,
+        :uri     => "https://example.com/",
+        :headers => {:accept => "application/json"},
+        :body    => '{"hello": "world!"}'
+      )
+    end
+
+    it "should log the request" do
+      feature.wrap_request(request)
+
+      expect(logdev.string).to eq <<~OUTPUT
+        ** INFO **
+        > POST https://example.com/
+        ** DEBUG **
+        Accept: application/json
+        Host: example.com
+        User-Agent: http.rb/#{HTTP::VERSION}
+
+        {"hello": "world!"}
+      OUTPUT
+    end
+  end
+
+  describe "logging the response" do
+    let(:response) do
+      HTTP::Response.new(
+        :version => "1.1",
+        :status  => 200,
+        :headers => {:content_type => "application/json"},
+        :body    => '{"success": true}',
+        :request => HTTP::Request.new(:verb => :get, :uri => "https://example.com")
+      )
+    end
+
+    it "should log the response" do
+      feature.wrap_response(response)
+
+      expect(logdev.string).to eq <<~OUTPUT
+        ** INFO **
+        < 200 OK
+        ** DEBUG **
+        Content-Type: application/json
+
+        {"success": true}
+      OUTPUT
+    end
+  end
+end