http 3.1.0 → 5.3.1

data/spec/lib/http/uri/normalizer_spec.rb

@@ -0,0 +1,95 @@
+# frozen_string_literal: true
+
+RSpec.describe HTTP::URI::NORMALIZER do
+  describe "scheme" do
+    it "lower-cases scheme" do
+      expect(HTTP::URI::NORMALIZER.call("HttP://example.com").scheme).to eq "http"
+    end
+  end
+
+  describe "hostname" do
+    it "lower-cases hostname" do
+      expect(HTTP::URI::NORMALIZER.call("http://EXAMPLE.com").host).to eq "example.com"
+    end
+
+    it "decodes percent-encoded hostname" do
+      expect(HTTP::URI::NORMALIZER.call("http://ex%61mple.com").host).to eq "example.com"
+    end
+
+    it "removes trailing period in hostname" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com.").host).to eq "example.com"
+    end
+
+    it "IDN-encodes non-ASCII hostname" do
+      expect(HTTP::URI::NORMALIZER.call("http://exämple.com").host).to eq "xn--exmple-cua.com"
+    end
+  end
+
+  describe "path" do
+    it "ensures path is not empty" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com").path).to eq "/"
+    end
+
+    it "preserves double slashes in path" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com//a///b").path).to eq "//a///b"
+    end
+
+    it "resolves single-dot segments in path" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com/a/./b").path).to eq "/a/b"
+    end
+
+    it "resolves double-dot segments in path" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com/a/b/../c").path).to eq "/a/c"
+    end
+
+    it "resolves leading double-dot segments in path" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com/../a/b").path).to eq "/a/b"
+    end
+
+    it "percent-encodes control characters in path" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com/\x00\x7F\n").path).to eq "/%00%7F%0A"
+    end
+
+    it "percent-encodes space in path" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com/a b").path).to eq "/a%20b"
+    end
+
+    it "percent-encodes non-ASCII characters in path" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com/キョ").path).to eq "/%E3%82%AD%E3%83%A7"
+    end
+
+    it "does not percent-encode non-special characters in path" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com/~.-_!$&()*,;=:@{}").path).to eq "/~.-_!$&()*,;=:@{}"
+    end
+
+    it "preserves escape sequences in path" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com/%41").path).to eq "/%41"
+    end
+  end
+
+  describe "query" do
+    it "allows no query" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com").query).to be_nil
+    end
+
+    it "percent-encodes control characters in query" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com/?\x00\x7F\n").query).to eq "%00%7F%0A"
+    end
+
+    it "percent-encodes space in query" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com/?a b").query).to eq "a%20b"
+    end
+
+    it "percent-encodes non-ASCII characters in query" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com?キョ").query).to eq "%E3%82%AD%E3%83%A7"
+    end
+
+    it "does not percent-encode non-special characters in query" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com/?~.-_!$&()*,;=:@{}?").query).to eq "~.-_!$&()*,;=:@{}?"
+    end
+
+    it "preserves escape sequences in query" do
+      expect(HTTP::URI::NORMALIZER.call("http://example.com/?%41").query).to eq "%41"
+    end
+  end
+end

data/spec/lib/http/uri_spec.rb

@@ -1,11 +1,15 @@
 # frozen_string_literal: true
 
 RSpec.describe HTTP::URI do
+  let(:example_ipv6_address) { "2606:2800:220:1:248:1893:25c8:1946" }
+
   let(:example_http_uri_string)  { "http://example.com" }
   let(:example_https_uri_string) { "https://example.com" }
+  let(:example_ipv6_uri_string) { "https://[#{example_ipv6_address}]" }
 
   subject(:http_uri)  { described_class.parse(example_http_uri_string) }
   subject(:https_uri) { described_class.parse(example_https_uri_string) }
+  subject(:ipv6_uri) { described_class.parse(example_ipv6_uri_string) }
 
   it "knows URI schemes" do
     expect(http_uri.scheme).to eq "http"
@@ -20,6 +24,41 @@ RSpec.describe HTTP::URI do
     expect(https_uri.port).to eq 443
   end
 
+  describe "#host" do
+    it "strips brackets from IPv6 addresses" do
+      expect(ipv6_uri.host).to eq("2606:2800:220:1:248:1893:25c8:1946")
+    end
+  end
+
+  describe "#normalized_host" do
+    it "strips brackets from IPv6 addresses" do
+      expect(ipv6_uri.normalized_host).to eq("2606:2800:220:1:248:1893:25c8:1946")
+    end
+  end
+
+  describe "#host=" do
+    it "updates cached values for #host and #normalized_host" do
+      expect(http_uri.host).to eq("example.com")
+      expect(http_uri.normalized_host).to eq("example.com")
+
+      http_uri.host = "[#{example_ipv6_address}]"
+
+      expect(http_uri.host).to eq(example_ipv6_address)
+      expect(http_uri.normalized_host).to eq(example_ipv6_address)
+    end
+
+    it "ensures IPv6 addresses are bracketed in the inner Addressable::URI" do
+      expect(http_uri.host).to eq("example.com")
+      expect(http_uri.normalized_host).to eq("example.com")
+
+      http_uri.host = example_ipv6_address
+
+      expect(http_uri.host).to eq(example_ipv6_address)
+      expect(http_uri.normalized_host).to eq(example_ipv6_address)
+      expect(http_uri.instance_variable_get(:@uri).host).to eq("[#{example_ipv6_address}]")
+    end
+  end
+
   describe "#dup" do
     it "doesn't share internal value between duplicates" do
       duplicated_uri = http_uri.dup

data/spec/lib/http_spec.rb

@@ -1,5 +1,5 @@
-# frozen_string_literal: true
 # encoding: utf-8
+# frozen_string_literal: true
 
 require "json"
 
@@ -55,38 +55,17 @@ RSpec.describe HTTP do
     end
 
     context "with a large request body" do
-      %w[global null per_operation].each do |timeout|
-        context "with a #{timeout} timeout" do
-          [16_000, 16_500, 17_000, 34_000, 68_000].each do |size|
-            [0, rand(0..100), rand(100..1000)].each do |fuzzer|
-              context "with a #{size} body and #{fuzzer} of fuzzing" do
-                let(:client) { HTTP.timeout(timeout, :read => 2, :write => 2, :connect => 2) }
-
-                let(:characters) { ("A".."Z").to_a }
-                let(:request_body) do
-                  Array.new(size + fuzzer) { |i| characters[i % characters.length] }.join
-                end
-
-                it "returns a large body" do
-                  response = client.post("#{dummy.endpoint}/echo-body", :body => request_body)
-
-                  expect(response.body.to_s).to eq(request_body)
-                  expect(response.headers["Content-Length"].to_i).to eq(request_body.bytesize)
-                end
-
-                context "when bytesize != length" do
-                  let(:characters) { ("A".."Z").to_a.push("“") }
-
-                  it "returns a large body" do
-                    body = {:data => request_body}
-                    response = client.post("#{dummy.endpoint}/echo-body", :json => body)
-
-                    expect(CGI.unescape(response.body.to_s)).to eq(body.to_json)
-                    expect(response.headers["Content-Length"].to_i).to eq(body.to_json.bytesize)
-                  end
-                end
-              end
-            end
+      let(:request_body) { "“" * 1_000_000 } # use multi-byte character
+
+      [:null, 6, {:read => 2, :write => 2, :connect => 2}].each do |timeout|
+        context "with `.timeout(#{timeout.inspect})`" do
+          let(:client) { HTTP.timeout(timeout) }
+
+          it "writes the whole body" do
+            response = client.post "#{dummy.endpoint}/echo-body", :body => request_body
+
+            expect(response.body.to_s).to eq(request_body.b)
+            expect(response.headers["Content-Length"].to_i).to eq request_body.bytesize
           end
         end
       end
@@ -116,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>/)
@@ -152,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>/)
@@ -171,6 +152,35 @@ RSpec.describe HTTP do
     end
   end
 
+  describe ".retry" do
+    it "ensure endpoint counts retries" do
+      expect(HTTP.get("#{dummy.endpoint}/retry-2").to_s).to eq "retried 1x"
+      expect(HTTP.get("#{dummy.endpoint}/retry-2").to_s).to eq "retried 2x"
+    end
+
+    it "retries the request" do
+      response = HTTP.retriable(delay: 0, retry_statuses: 500...600).get "#{dummy.endpoint}/retry-2"
+      expect(response.to_s).to eq "retried 2x"
+    end
+
+    it "retries the request and gives us access to the failed requests" do
+      err = nil
+      retry_callback = ->(_, _, res) { expect(res.to_s).to match(/^retried \dx$/) }
+      begin
+        HTTP.retriable(
+          should_retry: ->(*) { true },
+          tries:        3,
+          delay:        0,
+          on_retry:     retry_callback
+        ).get "#{dummy.endpoint}/retry-2"
+      rescue HTTP::Error => e
+        err = e
+      end
+
+      expect(err.response.to_s).to eq "retried 3x"
+    end
+  end
+
   context "posting forms to resources" do
     it "is easy" do
       response = HTTP.post "#{dummy.endpoint}/form", :form => {:example => "testing-form"}
@@ -194,7 +204,7 @@ RSpec.describe HTTP do
 
     context "with encoding option" do
       it "respects option" do
-        response = HTTP.get "#{dummy.endpoint}/iso-8859-1", "encoding" => Encoding::BINARY
+        response = HTTP.get "#{dummy.endpoint}/iso-8859-1", :encoding => Encoding::BINARY
         expect(response.to_s.encoding).to eq(Encoding::BINARY)
       end
     end
@@ -202,7 +212,7 @@ RSpec.describe HTTP do
 
   context "passing a string encoding type" do
     it "finds encoding" do
-      response = HTTP.get dummy.endpoint, "encoding" => "ascii"
+      response = HTTP.get dummy.endpoint, :encoding => "ascii"
       expect(response.to_s.encoding).to eq(Encoding::ASCII)
     end
   end
@@ -255,15 +265,15 @@ RSpec.describe HTTP do
 
   describe ".basic_auth" do
     it "fails when options is not a Hash" do
-      expect { HTTP.basic_auth "[FOOBAR]" }.to raise_error
+      expect { HTTP.basic_auth "[FOOBAR]" }.to raise_error(NoMethodError)
     end
 
     it "fails when :pass is not given" do
-      expect { HTTP.basic_auth :user => "[USER]" }.to raise_error
+      expect { HTTP.basic_auth :user => "[USER]" }.to raise_error(KeyError)
     end
 
     it "fails when :user is not given" do
-      expect { HTTP.basic_auth :pass => "[PASS]" }.to raise_error
+      expect { HTTP.basic_auth :pass => "[PASS]" }.to raise_error(KeyError)
     end
 
     it "sets Authorization header with proper BasicAuth value" do
@@ -305,22 +315,8 @@ RSpec.describe HTTP do
   end
 
   describe ".timeout" do
-    context "without timeout type" do
-      subject(:client) { HTTP.timeout :read => 123 }
-
-      it "sets timeout_class to PerOperation" do
-        expect(client.default_options.timeout_class).
-          to be HTTP::Timeout::PerOperation
-      end
-
-      it "sets given timeout options" do
-        expect(client.default_options.timeout_options).
-          to eq :read_timeout => 123
-      end
-    end
-
-    context "with :null type" do
-      subject(:client) { HTTP.timeout :null, :read => 123 }
+    context "specifying a null timeout" do
+      subject(:client) { HTTP.timeout :null }
 
       it "sets timeout_class to Null" do
         expect(client.default_options.timeout_class).
@@ -328,8 +324,8 @@ RSpec.describe HTTP do
       end
     end
 
-    context "with :per_operation type" do
-      subject(:client) { HTTP.timeout :per_operation, :read => 123 }
+    context "specifying per operation timeouts" do
+      subject(:client) { HTTP.timeout :read => 123 }
 
       it "sets timeout_class to PerOperation" do
         expect(client.default_options.timeout_class).
@@ -342,24 +338,28 @@ RSpec.describe HTTP do
       end
     end
 
-    context "with :global type" do
-      subject(:client) { HTTP.timeout :global, :read => 123 }
+    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 }
 
       it "sets timeout_class to Global" do
         expect(client.default_options.timeout_class).
           to be HTTP::Timeout::Global
       end
 
-      it "sets given timeout options" do
+      it "sets given timeout option" do
         expect(client.default_options.timeout_options).
-          to eq :read_timeout => 123
+          to eq :global_timeout => 123
       end
     end
-
-    it "fails with unknown timeout type" do
-      expect { HTTP.timeout(:foobar, :read => 123) }.
-        to raise_error(ArgumentError, /foobar/)
-    end
   end
 
   describe ".cookies" do
@@ -469,6 +469,59 @@ 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
+      it "normalizes URI" do
+        response = HTTP.get "#{dummy.endpoint}/héllö-wörld"
+        expect(response.to_s).to eq("hello world")
+      end
+
+      it "uses the custom URI Normalizer method" do
+        client = HTTP.use(:normalize_uri => {:normalizer => :itself.to_proc})
+        response = client.get("#{dummy.endpoint}/héllö-wörld")
+        expect(response.status).to eq(400)
+      end
+
+      it "raises if custom URI Normalizer returns invalid path" do
+        client = HTTP.use(:normalize_uri => {:normalizer => :itself.to_proc})
+        expect { client.get("#{dummy.endpoint}/hello\nworld") }.
+          to raise_error HTTP::RequestError, 'Invalid request URI: "/hello\nworld"'
+      end
+
+      it "raises if custom URI Normalizer returns invalid host" do
+        normalizer = lambda do |uri|
+          uri.port = nil
+          uri.instance_variable_set(:@host, "example\ncom")
+          uri
+        end
+        client = HTTP.use(:normalize_uri => {:normalizer => normalizer})
+        expect { client.get(dummy.endpoint) }.
+          to raise_error HTTP::RequestError, 'Invalid host: "example\ncom"'
+      end
+
+      it "uses the default URI normalizer" do
+        client = HTTP.use :normalize_uri
+        expect(HTTP::URI::NORMALIZER).to receive(:call).and_call_original
+        response = client.get("#{dummy.endpoint}/héllö-wörld")
+        expect(response.to_s).to eq("hello world")
+      end
     end
   end
 
@@ -476,7 +529,7 @@ RSpec.describe HTTP do
     expect { HTTP.get "http://thishostshouldnotexists.com" }.
       to raise_error HTTP::ConnectionError
 
-    expect { HTTP.get "http://127.0.0.1:000" }.
+    expect { HTTP.get "http://127.0.0.1:111" }.
       to raise_error HTTP::ConnectionError
   end
 end

data/spec/regression_specs.rb

@@ -14,4 +14,11 @@ RSpec.describe "Regression testing" do
       expect { HTTP.get(google_uri).to_s }.not_to raise_error
     end
   end
+
+  describe "#422" do
+    it "reads body when 200 OK response contains Upgrade header" do
+      res = HTTP.get("https://httpbin.org/response-headers?Upgrade=h2,h2c")
+      expect(res.parse(:json)).to include("Upgrade" => "h2,h2c")
+    end
+  end
 end

data/spec/spec_helper.rb

@@ -1,22 +1,11 @@
 # 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"
+require "rspec/memory"
 require "support/capture_warning"
 require "support/fakeio"
 
@@ -40,6 +29,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 +44,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,24 +1,30 @@
-# frozen_string_literal: true
 # encoding: UTF-8
+# frozen_string_literal: true
+
+require "cgi"
 
 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
 
-    def not_found(_req, res)
+    def not_found(req, res)
       res.status = 404
-      res.body   = "Not Found"
+      res.body   = "#{req.unparsed_uri} not found"
     end
 
     def self.handlers
       @handlers ||= {}
     end
 
+    def initialize(server, memo)
+      super(server)
+      @memo = memo
+    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
@@ -26,7 +32,7 @@ class DummyServer < WEBrick::HTTPServer
         def do_#{method.upcase}(req, res)
           handler = self.class.handlers["#{method}:\#{req.path}"]
           return instance_exec(req, res, &handler) if handler
-          not_found
+          not_found(req, res)
         end
       RUBY
     end
@@ -67,7 +73,7 @@ class DummyServer < WEBrick::HTTPServer
     end
 
     get "/params" do |req, res|
-      next not_found unless "foo=bar" == req.query_string
+      next not_found(req, res) unless "foo=bar" == req.query_string
 
       res.status = 200
       res.body   = "Params!"
@@ -76,7 +82,7 @@ class DummyServer < WEBrick::HTTPServer
     get "/multiple-params" do |req, res|
       params = CGI.parse req.query_string
 
-      next not_found unless {"foo" => ["bar"], "baz" => ["quux"]} == params
+      next not_found(req, res) unless {"foo" => ["bar"], "baz" => ["quux"]} == params
 
       res.status = 200
       res.body   = "More Params!"
@@ -148,11 +154,16 @@ class DummyServer < WEBrick::HTTPServer
       res.body   = req.body
     end
 
+    get "/héllö-wörld".b do |_req, res|
+      res.status = 200
+      res.body   = "hello world"
+    end
+
     post "/encoded-body" do |req, res|
       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|
@@ -161,12 +172,32 @@ 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
+
+    get "/retry-2" do |_req, res|
+      @memo[:attempts] ||= 0
+      @memo[:attempts] += 1
+
+      res.body = "retried #{@memo[:attempts]}x"
+      res.status = @memo[:attempts] == 2 ? 200 : 500
+    end
   end
 end

data/spec/support/dummy_server.rb

@@ -13,20 +13,21 @@ class DummyServer < WEBrick::HTTPServer
   include ServerConfig
 
   CONFIG = {
-    :BindAddress  => "127.0.0.1",
-    :Port         => 0,
-    :AccessLog    => BlackHole,
-    :Logger       => BlackHole
+    :BindAddress => "127.0.0.1",
+    :Port        => 0,
+    :AccessLog   => BlackHole,
+    :Logger      => BlackHole
   }.freeze
 
   SSL_CONFIG = CONFIG.merge(
-    :SSLEnable            => true,
-    :SSLStartImmediately  => true
+    :SSLEnable           => true,
+    :SSLStartImmediately => true
   ).freeze
 
-  def initialize(options = {}) # rubocop:disable Style/OptionHash
+  def initialize(options = {})
     super(options[:ssl] ? SSL_CONFIG : CONFIG)
-    mount("/", Servlet)
+    @memo = {}
+    mount("/", Servlet, @memo)
   end
 
   def endpoint