http 0.8.0.pre4 → 0.8.0.pre5

data/lib/http/response/status/reasons.rb

@@ -1,3 +1,5 @@
+# AUTO-GENERATED FILE, DO NOT CHANGE IT MANUALLY
+
 require "delegate"
 
 module HTTP
@@ -9,7 +11,6 @@ module HTTP
       #
       #   REASONS[400] # => "Bad Request"
       #   REASONS[414] # => "Request-URI Too Long"
-      #   REASONS[418] # => "I'm a Teapot"
       #
       # @return [Hash<Fixnum => String>]
       REASONS = {
@@ -24,6 +25,7 @@ module HTTP
         205 => "Reset Content",
         206 => "Partial Content",
         207 => "Multi-Status",
+        208 => "Already Reported",
         226 => "IM Used",
         300 => "Multiple Choices",
         301 => "Moved Permanently",
@@ -31,7 +33,6 @@ module HTTP
         303 => "See Other",
         304 => "Not Modified",
         305 => "Use Proxy",
-        306 => "Reserved",
         307 => "Temporary Redirect",
         308 => "Permanent Redirect",
         400 => "Bad Request",
@@ -47,16 +48,19 @@ module HTTP
         410 => "Gone",
         411 => "Length Required",
         412 => "Precondition Failed",
-        413 => "Request Entity Too Large",
-        414 => "Request-URI Too Long",
+        413 => "Payload Too Large",
+        414 => "URI Too Long",
         415 => "Unsupported Media Type",
-        416 => "Requested Range Not Satisfiable",
+        416 => "Range Not Satisfiable",
         417 => "Expectation Failed",
-        418 => "I'm a Teapot",
+        421 => "Misdirected Request",
         422 => "Unprocessable Entity",
         423 => "Locked",
         424 => "Failed Dependency",
         426 => "Upgrade Required",
+        428 => "Precondition Required",
+        429 => "Too Many Requests",
+        431 => "Request Header Fields Too Large",
         500 => "Internal Server Error",
         501 => "Not Implemented",
         502 => "Bad Gateway",
@@ -65,7 +69,9 @@ module HTTP
         505 => "HTTP Version Not Supported",
         506 => "Variant Also Negotiates",
         507 => "Insufficient Storage",
-        510 => "Not Extended"
+        508 => "Loop Detected",
+        510 => "Not Extended",
+        511 => "Network Authentication Required"
       }.each { |_, v| v.freeze }.freeze
     end
   end

data/lib/http/timeout/global.rb

@@ -1,4 +1,3 @@
-# rubocop:disable Lint/HandleExceptions
 module HTTP
   module Timeout
     class Global < PerOperation
@@ -11,24 +10,28 @@ module HTTP
         @total_timeout = time_left
       end
 
-      # Abstracted out from the normal connect for SSL connections
-      def connect_with_timeout(*args)
+      def connect(socket_class, host, port)
         reset_timer
+        ::Timeout.timeout(time_left, TimeoutError) do
+          @socket = socket_class.open(host, port)
+        end
 
-        begin
-          socket.connect_nonblock(*args)
+        log_time
+      end
+
+      def connect_ssl
+        reset_timer
 
+        begin
+          socket.connect_nonblock
         rescue IO::WaitReadable
           IO.select([socket], nil, nil, time_left)
           log_time
           retry
-
-        rescue Errno::EINPROGRESS
+        rescue IO::WaitWritable
           IO.select(nil, [socket], nil, time_left)
           log_time
           retry
-
-        rescue Errno::EISCONN
         end
       end
 
@@ -58,26 +61,9 @@ module HTTP
         end
       end
 
-      private
+      alias_method :<<, :write
 
-      # Create a DNS resolver
-      def resolve_address(host)
-        addr = HostResolver.getaddress(host)
-        return addr if addr
-
-        reset_timer
-
-        addr = Resolv::DNS.open(:timeout => time_left) do |dns|
-          dns.getaddress
-        end
-
-        log_time
-
-        addr
-
-      rescue Resolv::ResolvTimeout
-        raise TimeoutError, "DNS timed out after #{total_timeout} seconds"
-      end
+      private
 
       # Due to the run/retry nature of nonblocking I/O, it's easier to keep track of time
       # via method calls instead of a block to monitor.
@@ -96,4 +82,3 @@ module HTTP
     end
   end
 end
-# rubocop:enable Lint/HandleExceptions

data/lib/http/timeout/null.rb

@@ -25,8 +25,6 @@ module HTTP
 
       # Configures the SSL connection and starts the connection
       def start_tls(host, ssl_socket_class, ssl_context)
-        # TODO: abstract away SSLContexts so we can use other TLS libraries
-        ssl_context ||= OpenSSL::SSL::SSLContext.new
         @socket = ssl_socket_class.new(socket, ssl_context)
         socket.sync_close = true
 

data/lib/http/timeout/per_operation.rb

@@ -1,6 +1,3 @@
-# rubocop:disable Lint/HandleExceptions
-require "resolv"
-
 module HTTP
   module Timeout
     class PerOperation < Null
@@ -20,40 +17,28 @@ module HTTP
         @connect_timeout = options.fetch(:connect_timeout, CONNECT_TIMEOUT)
       end
 
-      def connect(_, host, port)
-        # https://github.com/celluloid/celluloid-io/blob/master/lib/celluloid/io/tcp_socket.rb
-        begin
-          addr = Resolv::IPv4.create(host)
-        rescue ArgumentError
-        end
-
-        # Guess it's not IPv4! Is it IPv6?
-        begin
-          addr ||= Resolv::IPv6.create(host)
-        rescue ArgumentError
+      def connect(socket_class, host, port)
+        ::Timeout.timeout(connect_timeout, TimeoutError) do
+          @socket = socket_class.open(host, port)
         end
+      end
 
-        unless addr
-          addr = resolve_address(host)
-          fail Resolv::ResolvError, "DNS result has no information for #{host}" unless addr
+      def connect_ssl
+        socket.connect_nonblock
+      rescue IO::WaitReadable
+        if IO.select([socket], nil, nil, connect_timeout)
+          retry
+        else
+          raise TimeoutError, "Connection timed out after #{connect_timeout} seconds"
         end
-
-        case addr
-        when Resolv::IPv4
-          family = Socket::AF_INET
-        when Resolv::IPv6
-          family = Socket::AF_INET6
-        else fail ArgumentError, "unsupported address class: #{addr.class}"
+      rescue IO::WaitWritable
+        if IO.select(nil, [socket], nil, connect_timeout)
+          retry
+        else
+          raise TimeoutError, "Connection timed out after #{connect_timeout} seconds"
         end
-
-        @socket = Socket.new(family, Socket::SOCK_STREAM, 0)
-
-        connect_with_timeout(Socket.sockaddr_in(port, addr.to_s))
       end
 
-      # No changes need to be made for the SSL connection
-      alias_method :connect_with_timeout, :connect_ssl
-
       # Read data from the socket
       def readpartial(size)
         socket.read_nonblock(size)
@@ -75,43 +60,6 @@ module HTTP
           raise TimeoutError, "Read timed out after #{write_timeout} seconds"
         end
       end
-
-      private
-
-      # Actually do the connect after we're setup
-      def connect_with_timeout(*args)
-        socket.connect_nonblock(*args)
-
-      rescue IO::WaitReadable
-        if IO.select([socket], nil, nil, connect_timeout)
-          retry
-        else
-          raise TimeoutError, "Connection timed out after #{connect_timeout} seconds"
-        end
-
-      rescue Errno::EINPROGRESS
-        if IO.select(nil, [socket], nil, connect_timeout)
-          retry
-        else
-          raise TimeoutError, "Connection timed out after #{connect_timeout} seconds"
-        end
-
-      rescue Errno::EISCONN
-      end
-
-      # Create a DNS resolver
-      def resolve_address(host)
-        addr = HostResolver.getaddress(host)
-        return addr if addr
-
-        Resolv::DNS.open(:timeout => connect_timeout) do |dns|
-          dns.getaddress
-        end
-
-      rescue Resolv::ResolvTimeout
-        raise TimeoutError, "DNS timed out after #{connect_timeout} seconds"
-      end
     end
   end
 end
-# rubocop:enable Lint/HandleExceptions

data/lib/http/version.rb

@@ -1,3 +1,3 @@
 module HTTP
-  VERSION = "0.8.0.pre4"
+  VERSION = "0.8.0.pre5"
 end

data/spec/lib/http/client_spec.rb

@@ -1,10 +1,11 @@
 require "support/http_handling_shared"
 require "support/dummy_server"
+require "support/ssl_helper"
+
 require "http/cache"
 
 RSpec.describe HTTP::Client do
   run_server(:dummy) { DummyServer.new }
-  run_server(:dummy_ssl) { DummyServer.new(:ssl => true) }
 
   StubbedClient = Class.new(HTTP::Client) do
     def make_request(request, options)
@@ -59,7 +60,7 @@ RSpec.describe HTTP::Client do
     end
 
     it "fails if max amount of hops reached" do
-      client = StubbedClient.new(:follow => 5).stub(
+      client = StubbedClient.new(:follow => {:max_hops => 5}).stub(
         "http://example.com/"  => redirect_response("/1"),
         "http://example.com/1" => redirect_response("/2"),
         "http://example.com/2" => redirect_response("/3"),
@@ -169,44 +170,39 @@ RSpec.describe HTTP::Client do
 
   include_context "HTTP handling" do
     let(:options) { {} }
-    let(:server) { dummy }
-    let(:client) { described_class.new(options) }
+    let(:server)  { dummy }
+    let(:client)  { described_class.new(options) }
   end
 
-  describe "SSL" do
+  describe "working with SSL" do
+    run_server(:dummy_ssl) { DummyServer.new(:ssl => true) }
+
     let(:client) do
-      described_class.new(
-        options.merge(
-          :ssl_context => OpenSSL::SSL::SSLContext.new.tap do |context|
-            context.options = OpenSSL::SSL::SSLContext::DEFAULT_PARAMS[:options]
-
-            context.verify_mode = OpenSSL::SSL::VERIFY_PEER
-            context.ca_file = File.join(certs_dir, "ca.crt")
-            context.cert = OpenSSL::X509::Certificate.new(
-              File.read(File.join(certs_dir, "client.crt"))
-            )
-            context.key = OpenSSL::PKey::RSA.new(
-              File.read(File.join(certs_dir, "client.key"))
-            )
-            context
-          end
-        )
-      )
+      described_class.new options.merge :ssl_context => SSLHelper.client_context
     end
 
-    include_context "HTTP handling", true do
+    include_context "HTTP handling" do
       let(:server) { dummy_ssl }
     end
 
-    it "works via SSL" do
+    it "just works" do
       response = client.get(dummy_ssl.endpoint)
       expect(response.body.to_s).to eq("<!doctype html>")
     end
 
-    context "with a mismatch host" do
-      it "errors" do
-        expect { client.get(dummy_ssl.endpoint.gsub("127.0.0.1", "localhost")) }
-          .to raise_error(OpenSSL::SSL::SSLError, /does not match/)
+    it "fails with OpenSSL::SSL::SSLError if host mismatch" do
+      expect { client.get(dummy_ssl.endpoint.gsub("127.0.0.1", "localhost")) }
+        .to raise_error(OpenSSL::SSL::SSLError, /does not match/)
+    end
+
+    context "with SSL options instead of a context" do
+      let(:client) do
+        described_class.new options.merge :ssl => SSLHelper.client_params
+      end
+
+      it "just works" do
+        response = client.get(dummy_ssl.endpoint)
+        expect(response.body.to_s).to eq("<!doctype html>")
       end
     end
   end

data/spec/lib/http/options/merge_spec.rb

@@ -35,6 +35,7 @@ RSpec.describe HTTP::Options, "merge" do
       :keep_alive_timeout => 10,
       :headers   => {:accept  => "xml", :bar => "bar"},
       :timeout_options => {:foo => :bar},
+      :ssl       => {:foo => "bar"},
       :proxy     => {:proxy_address => "127.0.0.1", :proxy_port => 8080})
 
     expect(foo.merge(bar).to_hash).to eq(
@@ -47,6 +48,7 @@ RSpec.describe HTTP::Options, "merge" do
       :json      => {:bar => "bar"},
       :persistent  => "https://www.googe.com",
       :keep_alive_timeout => 10,
+      :ssl       => {:foo => "bar"},
       :headers   => {"Foo" => "foo", "Accept"  => "xml", "Bar" => "bar"},
       :proxy     => {:proxy_address => "127.0.0.1", :proxy_port => 8080},
       :follow => nil,

data/spec/lib/http/redirector_spec.rb

@@ -3,95 +3,376 @@ RSpec.describe HTTP::Redirector do
     HTTP::Response.new(status, "1.1", headers, body)
   end
 
-  def redirect_response(location, status)
+  def redirect_response(status, location)
     simple_response status, "", "Location" => location
   end
 
-  let(:max_hops) { 5 }
-  subject(:redirector) { described_class.new max_hops }
+  describe "#strict" do
+    subject { redirector.strict }
 
-  context "following 300 redirect" do
-    let(:orig_request)  { HTTP::Request.new :post, "http://www.example.com/" }
-    let(:orig_response) { redirect_response "http://example.com/", 300 }
+    context "by default" do
+      let(:redirector) { described_class.new }
+      it { is_expected.to be true }
+    end
+  end
 
-    it "follows without changing verb" do
-      redirector.perform(orig_request, orig_response) do |request|
-        expect(request.verb).to be orig_request.verb
-        simple_response 200
-      end
+  describe "#max_hops" do
+    subject { redirector.max_hops }
+
+    context "by default" do
+      let(:redirector) { described_class.new }
+      it { is_expected.to eq 5 }
     end
   end
 
-  context "following 301 redirect" do
-    let(:orig_request)  { HTTP::Request.new :post, "http://www.example.com/" }
-    let(:orig_response) { redirect_response "http://example.com/", 301 }
+  describe "#perform" do
+    let(:options)    { {} }
+    let(:redirector) { described_class.new options }
+
+    it "fails with TooManyRedirectsError if max hops reached" do
+      req = HTTP::Request.new :head, "http://example.com"
+      res = proc { |prev_req| redirect_response(301, "#{prev_req.uri}/1") }
+
+      expect { redirector.perform(req, res.call(req), &res) }
+        .to raise_error HTTP::Redirector::TooManyRedirectsError
+    end
+
+    it "fails with EndlessRedirectError if endless loop detected" do
+      req = HTTP::Request.new :head, "http://example.com"
+      res = redirect_response(301, req.uri)
+
+      expect { redirector.perform(req, res) { res } }
+        .to raise_error HTTP::Redirector::EndlessRedirectError
+    end
+
+    it "fails with StateError if there were no Location header" do
+      req = HTTP::Request.new :head, "http://example.com"
+      res = simple_response(301)
+
+      expect { |b| redirector.perform(req, res, &b) }
+        .to raise_error HTTP::StateError
+    end
+
+    it "returns first non-redirect response" do
+      req  = HTTP::Request.new :head, "http://example.com"
+      hops = [
+        redirect_response(301, "http://example.com/1"),
+        redirect_response(301, "http://example.com/2"),
+        redirect_response(301, "http://example.com/3"),
+        simple_response(200, "foo"),
+        redirect_response(301, "http://example.com/4"),
+        simple_response(200, "bar")
+      ]
 
-    it "follows without changing verb" do
-      redirector.perform(orig_request, orig_response) do |request|
-        expect(request.verb).to be orig_request.verb
-        simple_response 200
+      res = redirector.perform(req, hops.shift) { hops.shift }
+      expect(res.to_s).to eq "foo"
+    end
+
+    context "following 300 redirect" do
+      context "with strict mode" do
+        let(:options) { {:strict => true} }
+
+        it "it follows with original verb if it's safe" do
+          req = HTTP::Request.new :head, "http://example.com"
+          res = redirect_response 300, "http://example.com/1"
+
+          redirector.perform(req, res) do |prev_req, _|
+            expect(prev_req.verb).to be :head
+            simple_response 200
+          end
+        end
+
+        it "raises StateError if original request was PUT" do
+          req = HTTP::Request.new :put, "http://example.com"
+          res = redirect_response 300, "http://example.com/1"
+
+          expect { redirector.perform(req, res) { simple_response 200 } }
+            .to raise_error HTTP::StateError
+        end
+
+        it "raises StateError if original request was POST" do
+          req = HTTP::Request.new :post, "http://example.com"
+          res = redirect_response 300, "http://example.com/1"
+
+          expect { redirector.perform(req, res) { simple_response 200 } }
+            .to raise_error HTTP::StateError
+        end
+
+        it "raises StateError if original request was DELETE" do
+          req = HTTP::Request.new :delete, "http://example.com"
+          res = redirect_response 300, "http://example.com/1"
+
+          expect { redirector.perform(req, res) { simple_response 200 } }
+            .to raise_error HTTP::StateError
+        end
+      end
+
+      context "with non-strict mode" do
+        let(:options) { {:strict => false} }
+
+        it "it follows with original verb if it's safe" do
+          req = HTTP::Request.new :head, "http://example.com"
+          res = redirect_response 300, "http://example.com/1"
+
+          redirector.perform(req, res) do |prev_req, _|
+            expect(prev_req.verb).to be :head
+            simple_response 200
+          end
+        end
+
+        it "it follows with GET if original request was PUT" do
+          req = HTTP::Request.new :put, "http://example.com"
+          res = redirect_response 300, "http://example.com/1"
+
+          redirector.perform(req, res) do |prev_req, _|
+            expect(prev_req.verb).to be :get
+            simple_response 200
+          end
+        end
+
+        it "it follows with GET if original request was POST" do
+          req = HTTP::Request.new :post, "http://example.com"
+          res = redirect_response 300, "http://example.com/1"
+
+          redirector.perform(req, res) do |prev_req, _|
+            expect(prev_req.verb).to be :get
+            simple_response 200
+          end
+        end
+
+        it "it follows with GET if original request was DELETE" do
+          req = HTTP::Request.new :delete, "http://example.com"
+          res = redirect_response 300, "http://example.com/1"
+
+          redirector.perform(req, res) do |prev_req, _|
+            expect(prev_req.verb).to be :get
+            simple_response 200
+          end
+        end
       end
     end
-  end
 
-  context "following 302 redirect" do
-    let(:orig_request)  { HTTP::Request.new :post, "http://www.example.com/" }
-    let(:orig_response) { redirect_response "http://example.com/", 302 }
+    context "following 301 redirect" do
+      context "with strict mode" do
+        let(:options) { {:strict => true} }
+
+        it "it follows with original verb if it's safe" do
+          req = HTTP::Request.new :head, "http://example.com"
+          res = redirect_response 301, "http://example.com/1"
+
+          redirector.perform(req, res) do |prev_req, _|
+            expect(prev_req.verb).to be :head
+            simple_response 200
+          end
+        end
+
+        it "raises StateError if original request was PUT" do
+          req = HTTP::Request.new :put, "http://example.com"
+          res = redirect_response 301, "http://example.com/1"
+
+          expect { redirector.perform(req, res) { simple_response 200 } }
+            .to raise_error HTTP::StateError
+        end
+
+        it "raises StateError if original request was POST" do
+          req = HTTP::Request.new :post, "http://example.com"
+          res = redirect_response 301, "http://example.com/1"
+
+          expect { redirector.perform(req, res) { simple_response 200 } }
+            .to raise_error HTTP::StateError
+        end
+
+        it "raises StateError if original request was DELETE" do
+          req = HTTP::Request.new :delete, "http://example.com"
+          res = redirect_response 301, "http://example.com/1"
+
+          expect { redirector.perform(req, res) { simple_response 200 } }
+            .to raise_error HTTP::StateError
+        end
+      end
+
+      context "with non-strict mode" do
+        let(:options) { {:strict => false} }
+
+        it "it follows with original verb if it's safe" do
+          req = HTTP::Request.new :head, "http://example.com"
+          res = redirect_response 301, "http://example.com/1"
+
+          redirector.perform(req, res) do |prev_req, _|
+            expect(prev_req.verb).to be :head
+            simple_response 200
+          end
+        end
+
+        it "it follows with GET if original request was PUT" do
+          req = HTTP::Request.new :put, "http://example.com"
+          res = redirect_response 301, "http://example.com/1"
+
+          redirector.perform(req, res) do |prev_req, _|
+            expect(prev_req.verb).to be :get
+            simple_response 200
+          end
+        end
+
+        it "it follows with GET if original request was POST" do
+          req = HTTP::Request.new :post, "http://example.com"
+          res = redirect_response 301, "http://example.com/1"
+
+          redirector.perform(req, res) do |prev_req, _|
+            expect(prev_req.verb).to be :get
+            simple_response 200
+          end
+        end
 
-    it "follows without changing verb" do
-      redirector.perform(orig_request, orig_response) do |request|
-        expect(request.verb).to be orig_request.verb
-        simple_response 200
+        it "it follows with GET if original request was DELETE" do
+          req = HTTP::Request.new :delete, "http://example.com"
+          res = redirect_response 301, "http://example.com/1"
+
+          redirector.perform(req, res) do |prev_req, _|
+            expect(prev_req.verb).to be :get
+            simple_response 200
+          end
+        end
       end
     end
-  end
 
-  context "following 303 redirect" do
-    context "upon POST request" do
-      let(:orig_request)  { HTTP::Request.new :post, "http://www.example.com/" }
-      let(:orig_response) { redirect_response "http://example.com/", 303 }
+    context "following 302 redirect" do
+      context "with strict mode" do
+        let(:options) { {:strict => true} }
 
-      it "follows without changing verb" do
-        redirector.perform(orig_request, orig_response) do |request|
-          expect(request.verb).to be :get
-          simple_response 200
+        it "it follows with original verb if it's safe" do
+          req = HTTP::Request.new :head, "http://example.com"
+          res = redirect_response 302, "http://example.com/1"
+
+          redirector.perform(req, res) do |prev_req, _|
+            expect(prev_req.verb).to be :head
+            simple_response 200
+          end
+        end
+
+        it "raises StateError if original request was PUT" do
+          req = HTTP::Request.new :put, "http://example.com"
+          res = redirect_response 302, "http://example.com/1"
+
+          expect { redirector.perform(req, res) { simple_response 200 } }
+            .to raise_error HTTP::StateError
+        end
+
+        it "raises StateError if original request was POST" do
+          req = HTTP::Request.new :post, "http://example.com"
+          res = redirect_response 302, "http://example.com/1"
+
+          expect { redirector.perform(req, res) { simple_response 200 } }
+            .to raise_error HTTP::StateError
+        end
+
+        it "raises StateError if original request was DELETE" do
+          req = HTTP::Request.new :delete, "http://example.com"
+          res = redirect_response 302, "http://example.com/1"
+
+          expect { redirector.perform(req, res) { simple_response 200 } }
+            .to raise_error HTTP::StateError
+        end
+      end
+
+      context "with non-strict mode" do
+        let(:options) { {:strict => false} }
+
+        it "it follows with original verb if it's safe" do
+          req = HTTP::Request.new :head, "http://example.com"
+          res = redirect_response 302, "http://example.com/1"
+
+          redirector.perform(req, res) do |prev_req, _|
+            expect(prev_req.verb).to be :head
+            simple_response 200
+          end
+        end
+
+        it "it follows with GET if original request was PUT" do
+          req = HTTP::Request.new :put, "http://example.com"
+          res = redirect_response 302, "http://example.com/1"
+
+          redirector.perform(req, res) do |prev_req, _|
+            expect(prev_req.verb).to be :get
+            simple_response 200
+          end
+        end
+
+        it "it follows with GET if original request was POST" do
+          req = HTTP::Request.new :post, "http://example.com"
+          res = redirect_response 302, "http://example.com/1"
+
+          redirector.perform(req, res) do |prev_req, _|
+            expect(prev_req.verb).to be :get
+            simple_response 200
+          end
+        end
+
+        it "it follows with GET if original request was DELETE" do
+          req = HTTP::Request.new :delete, "http://example.com"
+          res = redirect_response 302, "http://example.com/1"
+
+          redirector.perform(req, res) do |prev_req, _|
+            expect(prev_req.verb).to be :get
+            simple_response 200
+          end
         end
       end
     end
 
-    context "upon HEAD request" do
-      let(:orig_request)  { HTTP::Request.new :head, "http://www.example.com/" }
-      let(:orig_response) { redirect_response "http://example.com/", 303 }
+    context "following 303 redirect" do
+      it "follows with HEAD if original request was HEAD" do
+        req = HTTP::Request.new :head, "http://example.com"
+        res = redirect_response 303, "http://example.com/1"
 
-      it "follows without changing verb" do
-        redirector.perform(orig_request, orig_response) do |request|
-          expect(request.verb).to be :get
+        redirector.perform(req, res) do |prev_req, _|
+          expect(prev_req.verb).to be :head
+          simple_response 200
+        end
+      end
+
+      it "follows with GET if original request was GET" do
+        req = HTTP::Request.new :get, "http://example.com"
+        res = redirect_response 303, "http://example.com/1"
+
+        redirector.perform(req, res) do |prev_req, _|
+          expect(prev_req.verb).to be :get
+          simple_response 200
+        end
+      end
+
+      it "follows with GET if original request was neither GET nor HEAD" do
+        req = HTTP::Request.new :post, "http://example.com"
+        res = redirect_response 303, "http://example.com/1"
+
+        redirector.perform(req, res) do |prev_req, _|
+          expect(prev_req.verb).to be :get
           simple_response 200
         end
       end
     end
-  end
 
-  context "following 307 redirect" do
-    let(:orig_request)  { HTTP::Request.new :post, "http://www.example.com/" }
-    let(:orig_response) { redirect_response "http://example.com/", 307 }
+    context "following 307 redirect" do
+      it "follows with original request's verb" do
+        req = HTTP::Request.new :post, "http://example.com"
+        res = redirect_response 307, "http://example.com/1"
 
-    it "follows without changing verb" do
-      redirector.perform(orig_request, orig_response) do |request|
-        expect(request.verb).to be orig_request.verb
-        simple_response 200
+        redirector.perform(req, res) do |prev_req, _|
+          expect(prev_req.verb).to be :post
+          simple_response 200
+        end
       end
     end
-  end
 
-  context "following 308 redirect" do
-    let(:orig_request)  { HTTP::Request.new :post, "http://www.example.com/" }
-    let(:orig_response) { redirect_response "http://example.com/", 308 }
+    context "following 308 redirect" do
+      it "follows with original request's verb" do
+        req = HTTP::Request.new :post, "http://example.com"
+        res = redirect_response 308, "http://example.com/1"
 
-    it "follows without changing verb" do
-      redirector.perform(orig_request, orig_response) do |request|
-        expect(request.verb).to be orig_request.verb
-        simple_response 200
+        redirector.perform(req, res) do |prev_req, _|
+          expect(prev_req.verb).to be :post
+          simple_response 200
+        end
       end
     end
   end