http 5.0.0.pre3 → 5.0.3

data/spec/lib/http/client_spec.rb

@@ -4,50 +4,55 @@
 require "support/http_handling_shared"
 require "support/dummy_server"
 require "support/ssl_helper"
+require "logger"
 
 RSpec.describe HTTP::Client do
   run_server(:dummy) { DummyServer.new }
 
-  StubbedClient = Class.new(HTTP::Client) do
-    def perform(request, options)
-      stubbed = stubs[request.uri]
-      stubbed ? stubbed.call(request) : super(request, options)
-    end
-
-    def stubs
-      @stubs ||= {}
-    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 stub(stubs)
-      @stubs = stubs.each_with_object({}) do |(k, v), o|
-        o[HTTP::URI.parse k] = v
+      def stubs
+        @stubs ||= {}
       end
 
-      self
+      def stub(stubs)
+        @stubs = stubs.transform_keys do |k|
+          HTTP::URI::NORMALIZER.call(k).to_s
+        end
+
+        self
+      end
     end
-  end
 
-  def redirect_response(location, status = 302)
-    lambda do |request|
-      HTTP::Response.new(
-        :status  => status,
-        :version => "1.1",
-        :headers => {"Location" => location},
-        :body    => "",
-        :request => request
-      )
+    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 simple_response(body, status = 200)
-    lambda do |request|
-      HTTP::Response.new(
-        :status  => status,
-        :version => "1.1",
-        :body    => body,
-        :request => request
-      )
+    def simple_response(body, status = 200)
+      lambda do |request|
+        HTTP::Response.new(
+          :status  => status,
+          :version => "1.1",
+          :body    => body,
+          :request => request
+        )
+      end
     end
+
+    stub_const("StubbedClient", stubbed_client)
   end
 
   describe "following redirects" do
@@ -105,13 +110,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 }
@@ -197,6 +234,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
@@ -220,9 +273,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
 
@@ -291,6 +344,7 @@ RSpec.describe HTTP::Client do
           end
         end
       end
+
       it "is given a chance to wrap the Request" do
         feature_instance = feature_class.new
 
@@ -299,7 +353,7 @@ RSpec.describe HTTP::Client do
 
         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 + "/")
+        expect(feature_instance.captured_request.uri.to_s).to eq("#{dummy.endpoint}/")
       end
 
       it "is given a chance to wrap the Response" do
@@ -325,6 +379,19 @@ RSpec.describe HTTP::Client do
         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
 
@@ -335,7 +402,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) { {} }
@@ -476,7 +544,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/features/auto_inflate_spec.rb

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

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

@@ -2,8 +2,29 @@
 
 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(
@@ -25,7 +46,6 @@ RSpec.describe HTTP::Features::Instrumentation do
     let(:response) do
       HTTP::Response.new(
         :version => "1.1",
-        :uri     => "https://example.com",
         :status  => 200,
         :headers => {:content_type => "application/json"},
         :body    => '{"success": true}',
@@ -39,19 +59,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

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

@@ -4,10 +4,8 @@ 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
+    logger           = Logger.new(logdev)
+    logger.formatter = ->(severity, _, _, message) { format("** %s **\n%s\n", severity, message) }
 
     described_class.new(:logger => logger)
   end
@@ -44,7 +42,6 @@ RSpec.describe HTTP::Features::Logging do
     let(:response) do
       HTTP::Response.new(
         :version => "1.1",
-        :uri     => "https://example.com",
         :status  => 200,
         :headers => {:content_type => "application/json"},
         :body    => '{"success": true}',

data/spec/lib/http/headers_spec.rb

@@ -321,17 +321,17 @@ RSpec.describe HTTP::Headers do
 
     it "yields header keys specified as symbols in normalized form" do
       keys = headers.each.map(&:first)
-      expect(keys).to eq(["Set-Cookie", "Content-Type", "Set-Cookie"])
+      expect(keys).to eq(%w[Set-Cookie Content-Type Set-Cookie])
     end
 
     it "yields headers specified as strings without conversion" do
       headers.add "X_kEy", "value"
       keys = headers.each.map(&:first)
-      expect(keys).to eq(["Set-Cookie", "Content-Type", "Set-Cookie", "X_kEy"])
+      expect(keys).to eq(%w[Set-Cookie Content-Type Set-Cookie X_kEy])
     end
 
     it "returns self instance if block given" do
-      expect(headers.each { |*| }).to be headers
+      expect(headers.each { |*| }).to be headers # rubocop:disable Lint/EmptyBlock
     end
 
     it "returns Enumerator if no block given" do

data/spec/lib/http/redirector_spec.rb

@@ -396,5 +396,49 @@ RSpec.describe HTTP::Redirector do
         end
       end
     end
+
+    describe "changing verbs during redirects" do
+      let(:options) { {:strict => false} }
+      let(:post_body) { HTTP::Request::Body.new("i might be way longer in real life") }
+      let(:cookie) { "dont eat my cookies" }
+
+      def a_dangerous_request(verb)
+        HTTP::Request.new(
+          :verb => verb, :uri => "http://example.com",
+          :body => post_body, :headers => {
+            "Content-Type" => "meme",
+            "Cookie"       => cookie
+          }
+        )
+      end
+
+      def empty_body
+        HTTP::Request::Body.new(nil)
+      end
+
+      it "follows without body/content type if it has to change verb" do
+        req = a_dangerous_request(:post)
+        res = redirect_response 302, "http://example.com/1"
+
+        redirector.perform(req, res) do |prev_req, _|
+          expect(prev_req.body).to eq(empty_body)
+          expect(prev_req.headers["Cookie"]).to eq(cookie)
+          expect(prev_req.headers["Content-Type"]).to eq(nil)
+          simple_response 200
+        end
+      end
+
+      it "leaves body/content-type intact if it does not have to change verb" do
+        req = a_dangerous_request(:post)
+        res = redirect_response 307, "http://example.com/1"
+
+        redirector.perform(req, res) do |prev_req, _|
+          expect(prev_req.body).to eq(post_body)
+          expect(prev_req.headers["Cookie"]).to eq(cookie)
+          expect(prev_req.headers["Content-Type"]).to eq("meme")
+          simple_response 200
+        end
+      end
+    end
   end
 end

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

@@ -118,10 +118,10 @@ RSpec.describe HTTP::Request::Body do
     end
 
     context "when body is a non-Enumerable IO" do
-      let(:body) { FakeIO.new("a" * 16 * 1024 + "b" * 10 * 1024) }
+      let(:body) { FakeIO.new(("a" * 16 * 1024) + ("b" * 10 * 1024)) }
 
       it "yields chunks of content" do
-        expect(chunks.inject("", :+)).to eq "a" * 16 * 1024 + "b" * 10 * 1024
+        expect(chunks.inject("", :+)).to eq ("a" * 16 * 1024) + ("b" * 10 * 1024)
       end
     end
 
@@ -148,7 +148,7 @@ RSpec.describe HTTP::Request::Body do
     end
 
     context "when body is an Enumerable IO" do
-      let(:data) { "a" * 16 * 1024 + "b" * 10 * 1024 }
+      let(:data) { ("a" * 16 * 1024) + ("b" * 10 * 1024) }
       let(:body) { StringIO.new data }
 
       it "yields chunks of content" do

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

@@ -47,9 +47,20 @@ RSpec.describe HTTP::Request::Writer do
       end
     end
 
-    context "when body is empty" do
+    context "when body is not set" do
       let(:body) { HTTP::Request::Body.new(nil) }
 
+      it "doesn't write anything to the socket and doesn't set Content-Length" do
+        writer.stream
+        expect(io.string).to eq [
+          "#{headerstart}\r\n\r\n"
+        ].join
+      end
+    end
+
+    context "when body is empty" do
+      let(:body) { HTTP::Request::Body.new("") }
+
       it "doesn't write anything to the socket and sets Content-Length" do
         writer.stream
         expect(io.string).to eq [

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

@@ -2,7 +2,7 @@
 
 RSpec.describe HTTP::Response::Body do
   let(:connection) { double(:sequence_id => 0) }
-  let(:chunks)     { [String.new("Hello, "), String.new("World!")] }
+  let(:chunks)     { ["Hello, ", "World!"] }
 
   before do
     allow(connection).to receive(:readpartial) { chunks.shift }
@@ -16,7 +16,7 @@ RSpec.describe HTTP::Response::Body do
   end
 
   context "when body empty" do
-    let(:chunks) { [String.new("")] }
+    let(:chunks) { [""] }
 
     it "returns responds to empty? with true" do
       expect(subject).to be_empty
@@ -45,12 +45,12 @@ RSpec.describe HTTP::Response::Body do
     it "returns content in specified encoding" do
       body = described_class.new(connection)
       expect(connection).to receive(:readpartial).
-        and_return(String.new("content").force_encoding(Encoding::UTF_8))
+        and_return(String.new("content", :encoding => Encoding::UTF_8))
       expect(body.readpartial.encoding).to eq Encoding::BINARY
 
       body = described_class.new(connection, :encoding => Encoding::UTF_8)
       expect(connection).to receive(:readpartial).
-        and_return(String.new("content").force_encoding(Encoding::BINARY))
+        and_return(String.new("content", :encoding => Encoding::BINARY))
       expect(body.readpartial.encoding).to eq Encoding::UTF_8
     end
   end
@@ -59,7 +59,7 @@ RSpec.describe HTTP::Response::Body do
     let(:chunks) do
       body = Zlib::Deflate.deflate("Hi, HTTP here ☺")
       len  = body.length
-      [String.new(body[0, len / 2]), String.new(body[(len / 2)..-1])]
+      [body[0, len / 2], body[(len / 2)..-1]]
     end
     subject(:body) do
       inflater = HTTP::Response::Inflater.new(connection)

data/spec/lib/http/response/parser_spec.rb

@@ -32,7 +32,7 @@ RSpec.describe HTTP::Response::Parser do
   end
 
   context "response in many parts" do
-    let(:parts) { raw_response.split(//) }
+    let(:parts) { raw_response.chars }
 
     it "parses headers" do
       expect(subject.headers.to_h).to eq(expected_headers)
@@ -46,9 +46,9 @@ RSpec.describe HTTP::Response::Parser do
   context "when got 100 Continue response" do
     let :raw_response do
       "HTTP/1.1 100 Continue\r\n\r\n" \
-      "HTTP/1.1 200 OK\r\n" \
-      "Content-Length: 12\r\n\r\n" \
-      "Hello World!"
+        "HTTP/1.1 200 OK\r\n" \
+        "Content-Length: 12\r\n\r\n" \
+        "Hello World!"
     end
 
     context "when response is feeded in one part" do
@@ -62,7 +62,7 @@ RSpec.describe HTTP::Response::Parser do
     end
 
     context "when response is feeded in many parts" do
-      let(:parts) { raw_response.split(//) }
+      let(:parts) { raw_response.chars }
 
       it "skips to next non-info response" do
         expect(subject.status_code).to eq(200)

data/spec/lib/http/response_spec.rb

@@ -4,6 +4,7 @@ RSpec.describe HTTP::Response do
   let(:body)          { "Hello world!" }
   let(:uri)           { "http://example.com/" }
   let(:headers)       { {} }
+  let(:request)       { HTTP::Request.new(:verb => :get, :uri => uri) }
 
   subject(:response) do
     HTTP::Response.new(
@@ -11,8 +12,7 @@ RSpec.describe HTTP::Response do
       :version => "1.1",
       :headers => headers,
       :body    => body,
-      :uri     => uri,
-      :request => HTTP::Request.new(:verb => :get, :uri => "http://example.com")
+      :request => request
     )
   end
 
@@ -87,19 +87,32 @@ RSpec.describe HTTP::Response do
   end
 
   describe "#parse" do
-    let(:headers)   { {"Content-Type" => "application/json"} }
+    let(:headers)   { {"Content-Type" => content_type} }
     let(:body)      { '{"foo":"bar"}' }
 
-    it "fails if MIME type decoder is not found" do
-      expect { response.parse "text/html" }.to raise_error(HTTP::Error)
+    context "with known content type" do
+      let(:content_type) { "application/json" }
+      it "returns parsed body" do
+        expect(response.parse).to eq "foo" => "bar"
+      end
     end
 
-    it "uses decoder found by given MIME type" do
-      expect(response.parse("application/json")).to eq("foo" => "bar")
+    context "with unknown content type" do
+      let(:content_type) { "application/deadbeef" }
+      it "raises HTTP::Error" do
+        expect { response.parse }.to raise_error HTTP::Error
+      end
     end
 
-    it "uses decoder found by given MIME type alias" do
-      expect(response.parse(:json)).to eq("foo" => "bar")
+    context "with explicitly given mime type" do
+      let(:content_type) { "application/deadbeef" }
+      it "ignores mime_type of response" do
+        expect(response.parse("application/json")).to eq "foo" => "bar"
+      end
+
+      it "supports mime type aliases" do
+        expect(response.parse(:json)).to eq "foo" => "bar"
+      end
     end
   end
 
@@ -154,7 +167,7 @@ RSpec.describe HTTP::Response do
         :version    => "1.1",
         :status     => 200,
         :connection => connection,
-        :request    => HTTP::Request.new(:verb => :get, :uri => "http://example.com")
+        :request    => request
       )
     end
 
@@ -171,4 +184,43 @@ RSpec.describe HTTP::Response do
     end
     it { is_expected.not_to be_chunked }
   end
+
+  describe "backwards compatibilty with :uri" do
+    context "with no :verb" do
+      subject(:response) do
+        HTTP::Response.new(
+          :status  => 200,
+          :version => "1.1",
+          :headers => headers,
+          :body    => body,
+          :uri     => uri
+        )
+      end
+
+      it "defaults the uri to :uri" do
+        expect(response.request.uri.to_s).to eq uri
+      end
+
+      it "defaults to the verb to :get" do
+        expect(response.request.verb).to eq :get
+      end
+    end
+
+    context "with both a :request and :uri" do
+      subject(:response) do
+        HTTP::Response.new(
+          :status  => 200,
+          :version => "1.1",
+          :headers => headers,
+          :body    => body,
+          :uri     => uri,
+          :request => request
+        )
+      end
+
+      it "raises ArgumentError" do
+        expect { response }.to raise_error(ArgumentError)
+      end
+    end
+  end
 end

data/spec/lib/http_spec.rb

@@ -95,7 +95,8 @@ RSpec.describe HTTP do
         expect(response.to_s).to match(/<!doctype html>/)
       end
 
-      context "ssl" do
+      # TODO: htt:s://github.com/httprb/http/issues/627
+      xcontext "ssl" do
         it "responds with the endpoint's body" do
           response = ssl_client.via(proxy.addr, proxy.port).get dummy_ssl.endpoint
           expect(response.to_s).to match(/<!doctype html>/)
@@ -131,7 +132,8 @@ RSpec.describe HTTP do
         expect(response.status).to eq(407)
       end
 
-      context "ssl" do
+      # TODO: htt:s://github.com/httprb/http/issues/627
+      xcontext "ssl" do
         it "responds with the endpoint's body" do
           response = ssl_client.via(proxy.addr, proxy.port, "username", "password").get dummy_ssl.endpoint
           expect(response.to_s).to match(/<!doctype html>/)
@@ -438,6 +440,22 @@ RSpec.describe HTTP do
 
         expect(response.to_s).to eq("#{body}-deflated")
       end
+
+      it "returns empty body for no content response where Content-Encoding is gzip" do
+        client   = HTTP.use(:auto_inflate).headers("Accept-Encoding" => "gzip")
+        body     = "Hello!"
+        response = client.post("#{dummy.endpoint}/no-content-204", :body => body)
+
+        expect(response.to_s).to eq("")
+      end
+
+      it "returns empty body for no content response where Content-Encoding is deflate" do
+        client   = HTTP.use(:auto_inflate).headers("Accept-Encoding" => "deflate")
+        body     = "Hello!"
+        response = client.post("#{dummy.endpoint}/no-content-204", :body => body)
+
+        expect(response.to_s).to eq("")
+      end
     end
 
     context "with :normalize_uri" do