http 3.3.0 → 4.4.1

data/lib/http/timeout/per_operation.rb

@@ -11,8 +11,6 @@ module HTTP
       WRITE_TIMEOUT = 0.25
       READ_TIMEOUT = 0.25
 
-      attr_reader :read_timeout, :write_timeout, :connect_timeout
-
       def initialize(*args)
         super
 
@@ -22,7 +20,7 @@ module HTTP
       end
 
       def connect(socket_class, host, port, nodelay = false)
-        ::Timeout.timeout(connect_timeout, TimeoutError) do
+        ::Timeout.timeout(@connect_timeout, TimeoutError) do
           @socket = socket_class.open(host, port)
           @socket.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1) if nodelay
         end
@@ -67,7 +65,7 @@ module HTTP
             return :eof   if result.nil?
             return result if result != :wait_readable
 
-            raise TimeoutError, "Read timed out after #{read_timeout} seconds" if timeout
+            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
@@ -78,7 +76,7 @@ module HTTP
             # 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)
+            timeout = true unless @socket.to_io.wait_readable(@read_timeout)
           end
         end
 
@@ -89,9 +87,9 @@ module HTTP
             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)
+            timeout = true unless @socket.to_io.wait_writable(@write_timeout)
           end
         end
 

data/lib/http/uri.rb

@@ -26,6 +26,19 @@ module HTTP
     # @private
     HTTPS_SCHEME = "https"
 
+    # @private
+    NORMALIZER = lambda do |uri|
+      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
+      )
+    end
+
     # Parse the given URI string, returning an HTTP::URI object
     #
     # @param [HTTP::URI, String, #to_str] uri to parse

data/lib/http/version.rb

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

data/spec/lib/http/client_spec.rb

@@ -98,9 +98,8 @@ 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
@@ -190,6 +189,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
@@ -213,9 +228,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 +249,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 +266,18 @@ 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
   end
 

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

@@ -1,9 +1,11 @@
 # 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",
@@ -13,56 +15,70 @@ RSpec.describe HTTP::Features::AutoInflate do
     )
   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,
+          :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,56 @@
+# frozen_string_literal: true
+
+RSpec.describe HTTP::Features::Instrumentation do
+  subject(:feature) { HTTP::Features::Instrumentation.new(:instrumenter => instrumenter) }
+  let(:instrumenter) { TestInstrumenter.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(instrumenter.output[:start]).to eq(:request => request)
+    end
+  end
+
+  describe "logging the response" do
+    let(:response) do
+      HTTP::Response.new(
+        :version => "1.1",
+        :uri => "https://example.com",
+        :status => 200,
+        :headers => {:content_type => "application/json"},
+        :body => '{"success": true}'
+      )
+    end
+
+    it "should log the response" do
+      feature.wrap_response(response)
+
+      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

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

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require "logger"
+
+RSpec.describe HTTP::Features::Logging do
+  subject(:feature) do
+    logger = Logger.new(logdev)
+    logger.formatter = ->(severity, _, _, message) do
+      format("** %s **\n%s\n", severity, message)
+    end
+
+    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",
+        :uri     => "https://example.com",
+        :status  => 200,
+        :headers => {:content_type => "application/json"},
+        :body    => '{"success": true}'
+      )
+    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

data/spec/lib/http/redirector_spec.rb

@@ -75,6 +75,19 @@ RSpec.describe HTTP::Redirector do
       expect(res.to_s).to eq "foo"
     end
 
+    it "concatenates multiple Location headers" do
+      req     = HTTP::Request.new :verb => :head, :uri => "http://example.com"
+      headers = HTTP::Headers.new
+
+      %w[http://example.com /123].each { |loc| headers.add("Location", loc) }
+
+      res = redirector.perform(req, simple_response(301, "", headers)) do |redirect|
+        simple_response(200, redirect.uri.to_s)
+      end
+
+      expect(res.to_s).to eq "http://example.com/123"
+    end
+
     context "following 300 redirect" do
       context "with strict mode" do
         let(:options) { {:strict => true} }

data/spec/lib/http/request/body_spec.rb

@@ -125,6 +125,28 @@ RSpec.describe HTTP::Request::Body do
       end
     end
 
+    context "when body is a pipe" do
+      let(:ios)  { IO.pipe }
+      let(:body) { ios[0] }
+
+      around do |example|
+        writer = Thread.new(ios[1]) do |io|
+          io << "abcdef"
+          io.close
+        end
+
+        begin
+          example.run
+        ensure
+          writer.join
+        end
+      end
+
+      it "yields chunks of content" do
+        expect(chunks.inject("", :+)).to eq("abcdef")
+      end
+    end
+
     context "when body is an Enumerable IO" do
       let(:data) { "a" * 16 * 1024 + "b" * 10 * 1024 }
       let(:body) { StringIO.new data }
@@ -157,4 +179,33 @@ RSpec.describe HTTP::Request::Body do
       end
     end
   end
+
+  describe "#==" do
+    context "when sources are equivalent" do
+      let(:body1) { HTTP::Request::Body.new("content") }
+      let(:body2) { HTTP::Request::Body.new("content") }
+
+      it "returns true" do
+        expect(body1).to eq body2
+      end
+    end
+
+    context "when sources are not equivalent" do
+      let(:body1) { HTTP::Request::Body.new("content") }
+      let(:body2) { HTTP::Request::Body.new(nil) }
+
+      it "returns false" do
+        expect(body1).not_to eq body2
+      end
+    end
+
+    context "when objects are not of the same class" do
+      let(:body1) { HTTP::Request::Body.new("content") }
+      let(:body2) { "content" }
+
+      it "returns false" do
+        expect(body1).not_to eq body2
+      end
+    end
+  end
 end