http 4.4.1 → 5.1.0

data/spec/lib/http/redirector_spec.rb

@@ -6,12 +6,17 @@ RSpec.describe HTTP::Redirector do
       :status  => status,
       :version => "1.1",
       :headers => headers,
-      :body    => body
+      :body    => body,
+      :request => HTTP::Request.new(:verb => :get, :uri => "http://example.com")
     )
   end
 
-  def redirect_response(status, location)
-    simple_response status, "", "Location" => location
+  def redirect_response(status, location, set_cookie = {})
+    res = simple_response status, "", "Location" => location
+    set_cookie.each do |name, value|
+      res.headers.add("Set-Cookie", "#{name}=#{value}; path=/; httponly; secure; SameSite=none; Secure")
+    end
+    res
   end
 
   describe "#strict" do
@@ -88,6 +93,61 @@ RSpec.describe HTTP::Redirector do
       expect(res.to_s).to eq "http://example.com/123"
     end
 
+    it "returns cookies in response" do
+      req  = HTTP::Request.new :verb => :head, :uri => "http://example.com"
+      hops = [
+        redirect_response(301, "http://example.com/1", {"foo" => "42"}),
+        redirect_response(301, "http://example.com/2", {"bar" => "53", "deleted" => "foo"}),
+        redirect_response(301, "http://example.com/3", {"baz" => "64", "deleted" => ""}),
+        redirect_response(301, "http://example.com/4", {"baz" => "65"}),
+        simple_response(200, "bar")
+      ]
+
+      request_cookies = [
+        {"foo" => "42"},
+        {"foo" => "42", "bar" => "53", "deleted" => "foo"},
+        {"foo" => "42", "bar" => "53", "baz" => "64"},
+        {"foo" => "42", "bar" => "53", "baz" => "65"}
+      ]
+
+      res = redirector.perform(req, hops.shift) do |request|
+        req_cookie = HTTP::Cookie.cookie_value_to_hash(request.headers["Cookie"] || "")
+        expect(req_cookie).to eq request_cookies.shift
+        hops.shift
+      end
+      expect(res.to_s).to eq "bar"
+      cookies = res.cookies.cookies.to_h { |c| [c.name, c.value] }
+      expect(cookies["foo"]).to eq "42"
+      expect(cookies["bar"]).to eq "53"
+      expect(cookies["baz"]).to eq "65"
+      expect(cookies["deleted"]).to eq nil
+    end
+
+    it "returns original cookies in response" do
+      req = HTTP::Request.new :verb => :head, :uri => "http://example.com"
+      req.headers.set("Cookie", "foo=42; deleted=baz")
+      hops = [
+        redirect_response(301, "http://example.com/1", {"bar" => "64", "deleted" => ""}),
+        simple_response(200, "bar")
+      ]
+
+      request_cookies = [
+        {"foo" => "42", "bar" => "64"},
+        {"foo" => "42", "bar" => "64"}
+      ]
+
+      res = redirector.perform(req, hops.shift) do |request|
+        req_cookie = HTTP::Cookie.cookie_value_to_hash(request.headers["Cookie"] || "")
+        expect(req_cookie).to eq request_cookies.shift
+        hops.shift
+      end
+      expect(res.to_s).to eq "bar"
+      cookies = res.cookies.cookies.to_h { |c| [c.name, c.value] }
+      expect(cookies["foo"]).to eq "42"
+      expect(cookies["bar"]).to eq "64"
+      expect(cookies["deleted"]).to eq nil
+    end
+
     context "following 300 redirect" do
       context "with strict mode" do
         let(:options) { {:strict => true} }
@@ -395,5 +455,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

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # coding: utf-8
+# frozen_string_literal: true
 
 RSpec.describe HTTP::Request::Writer do
   let(:io)          { StringIO.new }
@@ -22,6 +22,18 @@ RSpec.describe HTTP::Request::Writer do
       end
     end
 
+    context "when headers are specified as strings with mixed case" do
+      let(:headers) { HTTP::Headers.coerce "content-Type" => "text", "X_MAX" => "200" }
+
+      it "writes the headers with the same casing" do
+        writer.stream
+        expect(io.string).to eq [
+          "#{headerstart}\r\n",
+          "content-Type: text\r\nX_MAX: 200\r\nContent-Length: 0\r\n\r\n"
+        ].join
+      end
+    end
+
     context "when body is nonempty" do
       let(:body) { HTTP::Request::Body.new("content") }
 
@@ -35,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/request_spec.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # coding: utf-8
+# frozen_string_literal: true
 
 RSpec.describe HTTP::Request do
   let(:proxy)       { {} }
@@ -8,10 +8,10 @@ RSpec.describe HTTP::Request do
 
   subject :request do
     HTTP::Request.new(
-      :verb     => :get,
-      :uri      => request_uri,
-      :headers  => headers,
-      :proxy    => proxy
+      :verb    => :get,
+      :uri     => request_uri,
+      :headers => headers,
+      :proxy   => proxy
     )
   end
 

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)..]]
     end
     subject(:body) do
       inflater = HTTP::Response::Inflater.new(connection)

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

@@ -3,14 +3,14 @@
 RSpec.describe HTTP::Response::Parser do
   subject(:parser) { described_class.new }
   let(:raw_response) do
-    "HTTP/1.1 200 OK\r\nContent-Length: 2\r\nContent-Type: application/json\r\nMy-Header: val\r\nEmpty-Header: \r\n\r\n{}"
+    "HTTP/1.1 200 OK\r\nContent-Length: 2\r\nContent-Type: application/json\r\nMyHeader: val\r\nEmptyHeader: \r\n\r\n{}"
   end
   let(:expected_headers) do
     {
       "Content-Length" => "2",
       "Content-Type"   => "application/json",
-      "My-Header"      => "val",
-      "Empty-Header"   => ""
+      "MyHeader"       => "val",
+      "EmptyHeader"    => ""
     }
   end
   let(:expected_body) { "{}" }
@@ -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)
@@ -42,4 +42,33 @@ RSpec.describe HTTP::Response::Parser do
       expect(subject.read(expected_body.size)).to eq(expected_body)
     end
   end
+
+  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!"
+    end
+
+    context "when response is feeded in one part" do
+      let(:parts) { [raw_response] }
+
+      it "skips to next non-info response" do
+        expect(subject.status_code).to eq(200)
+        expect(subject.headers).to eq("Content-Length" => "12")
+        expect(subject.read(12)).to eq("Hello World!")
+      end
+    end
+
+    context "when response is feeded in many parts" do
+      let(:parts) { raw_response.chars }
+
+      it "skips to next non-info response" do
+        expect(subject.status_code).to eq(200)
+        expect(subject.headers).to eq("Content-Length" => "12")
+        expect(subject.read(12)).to eq("Hello World!")
+      end
+    end
+  end
 end

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

@@ -26,7 +26,7 @@ RSpec.describe HTTP::Response::Status do
     end
 
     described_class::REASONS.each do |code, reason|
-      class_eval <<-RUBY
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
         context 'with well-known code: #{code}' do
           let(:code) { #{code} }
           it { is_expected.to eq #{reason.inspect} }
@@ -165,7 +165,7 @@ RSpec.describe HTTP::Response::Status do
     end
 
     described_class::SYMBOLS.each do |code, symbol|
-      class_eval <<-RUBY
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
         context 'with well-known code: #{code}' do
           let(:code) { #{code} }
           it { is_expected.to be #{symbol.inspect} }
@@ -193,7 +193,7 @@ RSpec.describe HTTP::Response::Status do
   end
 
   described_class::SYMBOLS.each do |code, symbol|
-    class_eval <<-RUBY
+    class_eval <<-RUBY, __FILE__, __LINE__ + 1
       describe '##{symbol}?' do
         subject { status.#{symbol}? }
 

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,7 +12,7 @@ RSpec.describe HTTP::Response do
       :version => "1.1",
       :headers => headers,
       :body    => body,
-      :uri     => uri
+      :request => request
     )
   end
 
@@ -109,7 +110,7 @@ RSpec.describe HTTP::Response do
         expect(response.parse("application/json")).to eq "foo" => "bar"
       end
 
-      it "supports MIME type aliases" do
+      it "supports mime type aliases" do
         expect(response.parse(:json)).to eq "foo" => "bar"
       end
     end
@@ -165,7 +166,8 @@ RSpec.describe HTTP::Response do
       HTTP::Response.new(
         :version    => "1.1",
         :status     => 200,
-        :connection => connection
+        :connection => connection,
+        :request    => request
       )
     end
 
@@ -182,4 +184,79 @@ 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
+
+  describe "#body" do
+    let(:connection) { double(:sequence_id => 0) }
+    let(:chunks)     { ["Hello, ", "World!"] }
+
+    subject(:response) do
+      HTTP::Response.new(
+        :status     => 200,
+        :version    => "1.1",
+        :headers    => headers,
+        :request    => request,
+        :connection => connection
+      )
+    end
+
+    before do
+      allow(connection).to receive(:readpartial) { chunks.shift }
+      allow(connection).to receive(:body_completed?) { chunks.empty? }
+    end
+
+    context "with no Content-Type" do
+      let(:headers) { {} }
+
+      it "returns a body with default binary encoding" do
+        expect(response.body.to_s.encoding).to eq Encoding::BINARY
+      end
+    end
+
+    context "with Content-Type: application/json" do
+      let(:headers) { {"Content-Type" => "application/json"} }
+
+      it "returns a body with a default UTF_8 encoding" do
+        expect(response.body.to_s.encoding).to eq Encoding::UTF_8
+      end
+    end
+  end
 end

data/spec/lib/http_spec.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # encoding: utf-8
+# frozen_string_literal: true
 
 require "json"
 
@@ -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>/)
@@ -307,6 +309,15 @@ RSpec.describe HTTP do
       end
     end
 
+    context "specifying per operation timeouts as frozen hash" do
+      let(:frozen_options) { {:read => 123}.freeze }
+      subject(:client) { HTTP.timeout(frozen_options) }
+
+      it "does not raise an error" do
+        expect { client }.not_to raise_error
+      end
+    end
+
     context "specifying a global timeout" do
       subject(:client) { HTTP.timeout 123 }
 
@@ -429,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

data/spec/spec_helper.rb

@@ -1,19 +1,7 @@
 # frozen_string_literal: true
 
-require "simplecov"
-require "coveralls"
-
-SimpleCov.formatter = SimpleCov::Formatter::MultiFormatter.new(
-  [
-    SimpleCov::Formatter::HTMLFormatter,
-    Coveralls::SimpleCov::Formatter
-  ]
-)
-
-SimpleCov.start do
-  add_filter "/spec/"
-  minimum_coverage 80
-end
+require_relative "./support/simplecov"
+require_relative "./support/fuubar" unless ENV["CI"]
 
 require "http"
 require "rspec/its"
@@ -40,6 +28,13 @@ RSpec.configure do |config|
     mocks.verify_partial_doubles = true
   end
 
+  # This option will default to `:apply_to_host_groups` in RSpec 4 (and will
+  # have no way to turn it off -- the option exists only for backwards
+  # compatibility in RSpec 3). It causes shared context metadata to be
+  # inherited by the metadata hash of host groups and examples, rather than
+  # triggering implicit auto-inclusion in groups with matching metadata.
+  config.shared_context_metadata_behavior = :apply_to_host_groups
+
   # These two settings work together to allow you to limit a spec run
   # to individual examples or groups you care about by tagging them with
   # `:focus` metadata. When nothing is tagged with `:focus`, all examples
@@ -48,17 +43,22 @@ RSpec.configure do |config|
   config.filter_run_excluding :flaky if defined?(JRUBY_VERSION) && ENV["CI"]
   config.run_all_when_everything_filtered = true
 
-  # Limits the available syntax to the non-monkey patched syntax that is recommended.
-  # For more details, see:
-  #   - http://myronmars.to/n/dev-blog/2012/06/rspecs-new-expectation-syntax
-  #   - http://teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
-  #   - http://myronmars.to/n/dev-blog/2014/05/notable-changes-in-rspec-3#new__config_option_to_disable_rspeccore_monkey_patching
-  config.disable_monkey_patching!
-
   # This setting enables warnings. It's recommended, but in some cases may
   # be too noisy due to issues in dependencies.
   config.warnings = 0 == ENV["GUARD_RSPEC"].to_i
 
+  # Allows RSpec to persist some state between runs in order to support
+  # the `--only-failures` and `--next-failure` CLI options. We recommend
+  # you configure your source control system to ignore this file.
+  config.example_status_persistence_file_path = "spec/examples.txt"
+
+  # Limits the available syntax to the non-monkey patched syntax that is
+  # recommended. For more details, see:
+  #   - http://rspec.info/blog/2012/06/rspecs-new-expectation-syntax/
+  #   - http://www.teaisaweso.me/blog/2013/05/27/rspecs-new-message-expectation-syntax/
+  #   - http://rspec.info/blog/2014/05/notable-changes-in-rspec-3/#zero-monkey-patching-mode
+  config.disable_monkey_patching!
+
   # Many RSpec users commonly either run the entire suite or an individual
   # file, and it's useful to allow more verbose output when running an
   # individual spec file.

data/spec/support/black_hole.rb

@@ -2,7 +2,7 @@
 
 module BlackHole
   class << self
-    def method_missing(*) # rubocop: disable Style/MethodMissing
+    def method_missing(*)
       self
     end
 

data/spec/support/dummy_server/servlet.rb

@@ -1,9 +1,8 @@
-# frozen_string_literal: true
 # encoding: UTF-8
+# frozen_string_literal: true
 
 class DummyServer < WEBrick::HTTPServer
-  # rubocop:disable Metrics/ClassLength
-  class Servlet < WEBrick::HTTPServlet::AbstractServlet
+  class Servlet < WEBrick::HTTPServlet::AbstractServlet # rubocop:disable Metrics/ClassLength
     def self.sockets
       @sockets ||= []
     end
@@ -18,7 +17,7 @@ class DummyServer < WEBrick::HTTPServer
     end
 
     %w[get post head].each do |method|
-      class_eval <<-RUBY, __FILE__, __LINE__
+      class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def self.#{method}(path, &block)
           handlers["#{method}:\#{path}"] = block
         end
@@ -157,7 +156,7 @@ class DummyServer < WEBrick::HTTPServer
       res.status = 200
 
       res.body = case req["Accept-Encoding"]
-                 when "gzip" then
+                 when "gzip"
                    res["Content-Encoding"] = "gzip"
                    StringIO.open do |out|
                      Zlib::GzipWriter.wrap(out) do |gz|
@@ -166,12 +165,24 @@ class DummyServer < WEBrick::HTTPServer
                        out.tap(&:rewind).read
                      end
                    end
-                 when "deflate" then
+                 when "deflate"
                    res["Content-Encoding"] = "deflate"
                    Zlib::Deflate.deflate("#{req.body}-deflated")
                  else
                    "#{req.body}-raw"
                  end
     end
+
+    post "/no-content-204" do |req, res|
+      res.status = 204
+      res.body   = ""
+
+      case req["Accept-Encoding"]
+      when "gzip"
+        res["Content-Encoding"] = "gzip"
+      when "deflate"
+        res["Content-Encoding"] = "deflate"
+      end
+    end
   end
 end