httparty 0.13.1 → 0.13.2

data/spec/httparty/request_spec.rb

@@ -2,7 +2,7 @@ require File.expand_path(File.join(File.dirname(__FILE__), '..', 'spec_helper'))
 
 describe HTTParty::Request do
   before do
-    @request = HTTParty::Request.new(Net::HTTP::Get, 'http://api.foo.com/v1', :format => :xml)
+    @request = HTTParty::Request.new(Net::HTTP::Get, 'http://api.foo.com/v1', format: :xml)
   end
 
   describe "::NON_RAILS_QUERY_STRING_NORMALIZER" do
@@ -16,19 +16,19 @@ describe HTTParty::Request do
     context "when the query is an array" do
 
       it "doesn't include brackets" do
-        query_string = normalizer[{:page => 1, :foo => %w(bar baz)}]
+        query_string = normalizer[{page: 1, foo: %w(bar baz)}]
         URI.unescape(query_string).should == "foo=bar&foo=baz&page=1"
       end
 
       it "URI encodes array values" do
-        query_string = normalizer[{:people => ["Otis Redding", "Bob Marley", "Tim & Jon"], :page => 1, :xyzzy => 3}]
+        query_string = normalizer[{people: ["Otis Redding", "Bob Marley", "Tim & Jon"], page: 1, xyzzy: 3}]
         query_string.should == "page=1&people=Otis%20Redding&people=Bob%20Marley&people=Tim%20%26%20Jon&xyzzy=3"
       end
     end
 
     context "when the query is a hash" do
       it "correctly handles nil values" do
-        query_string = normalizer[{:page => 1, :per_page => nil}]
+        query_string = normalizer[{page: 1, per_page: nil}]
         query_string.should == "page=1&per_page"
       end
     end
@@ -42,7 +42,7 @@ describe HTTParty::Request do
 
     it "sets parser to the optional parser" do
       my_parser = lambda {}
-      request = HTTParty::Request.new(Net::HTTP::Get, 'http://google.com', :parser => my_parser)
+      request = HTTParty::Request.new(Net::HTTP::Get, 'http://google.com', parser: my_parser)
       request.parser.should == my_parser
     end
 
@@ -53,15 +53,32 @@ describe HTTParty::Request do
 
     it "sets connection_adapter to the optional connection_adapter" do
       my_adapter = lambda {}
-      request = HTTParty::Request.new(Net::HTTP::Get, 'http://google.com', :connection_adapter => my_adapter)
+      request = HTTParty::Request.new(Net::HTTP::Get, 'http://google.com', connection_adapter: my_adapter)
       request.connection_adapter.should == my_adapter
     end
+
+    context "when basic authentication credentials provided in uri" do
+      context "when basic auth options wasn't set explicitly" do
+        it "sets basic auth from uri" do
+          request = HTTParty::Request.new(Net::HTTP::Get, 'http://user1:pass1@example.com')
+          request.options[:basic_auth].should == {:username => 'user1', :password => 'pass1'}
+        end
+      end
+
+      context "when basic auth options was set explicitly" do
+        it "uses basic auth from url anyway" do
+          basic_auth = {:username => 'user2', :password => 'pass2'}
+          request = HTTParty::Request.new(Net::HTTP::Get, 'http://user1:pass1@example.com', :basic_auth => basic_auth)
+          request.options[:basic_auth].should == {:username => 'user1', :password => 'pass1'}
+        end
+      end
+    end
   end
 
   describe "#format" do
     context "request yet to be made" do
       it "returns format option" do
-        request = HTTParty::Request.new 'get', '/', :format => :xml
+        request = HTTParty::Request.new 'get', '/', format: :xml
         request.format.should == :xml
       end
 
@@ -73,7 +90,7 @@ describe HTTParty::Request do
 
     context "request has been made" do
       it "returns format option" do
-        request = HTTParty::Request.new 'get', '/', :format => :xml
+        request = HTTParty::Request.new 'get', '/', format: :xml
         request.last_response = stub
         request.format.should == :xml
       end
@@ -91,16 +108,16 @@ describe HTTParty::Request do
 
   context "options" do
     it "should use basic auth when configured" do
-      @request.options[:basic_auth] = {:username => 'foobar', :password => 'secret'}
+      @request.options[:basic_auth] = {username: 'foobar', password: 'secret'}
       @request.send(:setup_raw_request)
       @request.instance_variable_get(:@raw_request)['authorization'].should_not be_nil
     end
 
     it "should use digest auth when configured" do
       FakeWeb.register_uri(:get, "http://api.foo.com/v1",
-        :www_authenticate => 'Digest realm="Log Viewer", qop="auth", nonce="2CA0EC6B0E126C4800E56BA0C0003D3C", opaque="5ccc069c403ebaf9f0171e9517f40e41", stale=false')
+        www_authenticate: 'Digest realm="Log Viewer", qop="auth", nonce="2CA0EC6B0E126C4800E56BA0C0003D3C", opaque="5ccc069c403ebaf9f0171e9517f40e41", stale=false')
 
-      @request.options[:digest_auth] = {:username => 'foobar', :password => 'secret'}
+      @request.options[:digest_auth] = {username: 'foobar', password: 'secret'}
       @request.send(:setup_raw_request)
 
       raw_request = @request.instance_variable_get(:@raw_request)
@@ -108,13 +125,13 @@ describe HTTParty::Request do
     end
 
     it "should use the right http method for digest authentication" do
-      @post_request = HTTParty::Request.new(Net::HTTP::Post, 'http://api.foo.com/v1', :format => :xml)
+      @post_request = HTTParty::Request.new(Net::HTTP::Post, 'http://api.foo.com/v1', format: :xml)
       FakeWeb.register_uri(:post, "http://api.foo.com/v1", {})
 
       http = @post_request.send(:http)
       @post_request.should_receive(:http).and_return(http)
       http.should_not_receive(:head).and_return({'www-authenticate' => nil})
-      @post_request.options[:digest_auth] = {:username => 'foobar', :password => 'secret'}
+      @post_request.options[:digest_auth] = {username: 'foobar', password: 'secret'}
       @post_request.send(:setup_raw_request)
     end
 
@@ -127,6 +144,32 @@ describe HTTParty::Request do
   end
 
   describe "#uri" do
+    context "redirects" do
+      it "returns correct path when the server sets the location header to a filename" do
+        @request.last_uri = URI.parse("http://example.com/foo/bar")
+        @request.path = URI.parse("bar?foo=bar")
+        @request.redirect = true
+
+        @request.uri.should == URI.parse("http://example.com/foo/bar?foo=bar")
+      end
+
+      it "returns correct path when the server sets the location header to an absolute path" do
+        @request.last_uri = URI.parse("http://example.com/foo/bar")
+        @request.path = URI.parse("/bar?foo=bar")
+        @request.redirect = true
+
+        @request.uri.should == URI.parse("http://example.com/bar?foo=bar")
+      end
+
+      it "returns correct path when the server sets the location header to a full uri" do
+        @request.last_uri = URI.parse("http://example.com/foo/bar")
+        @request.path = URI.parse("http://example.com/bar?foo=bar")
+        @request.redirect = true
+
+        @request.uri.should == URI.parse("http://example.com/bar?foo=bar")
+      end
+    end
+
     context "query strings" do
       it "does not add an empty query string when default_params are blank" do
         @request.options[:default_params] = {}
@@ -136,7 +179,7 @@ describe HTTParty::Request do
       it "respects the query string normalization proc" do
         empty_proc = lambda {|qs| ""}
         @request.options[:query_string_normalizer] = empty_proc
-        @request.options[:query] = {:foo => :bar}
+        @request.options[:query] = {foo: :bar}
         URI.unescape(@request.uri.query).should == ""
       end
 
@@ -147,14 +190,14 @@ describe HTTParty::Request do
       end
 
       it "does not duplicate query string parameters when uri is called twice" do
-        @request.options[:query] = {:foo => :bar}
+        @request.options[:query] = {foo: :bar}
         @request.uri
         @request.uri.query.should == "foo=bar"
       end
 
       context "when representing an array" do
         it "returns a Rails style query string" do
-          @request.options[:query] = {:foo => %w(bar baz)}
+          @request.options[:query] = {foo: %w(bar baz)}
           URI.unescape(@request.uri.query).should == "foo[]=bar&foo[]=baz"
         end
       end
@@ -166,7 +209,7 @@ describe HTTParty::Request do
     context "when query_string_normalizer is set" do
       it "sets the body to the return value of the proc" do
         @request.options[:query_string_normalizer] = HTTParty::Request::NON_RAILS_QUERY_STRING_NORMALIZER
-        @request.options[:body] = {:page => 1, :foo => %w(bar baz)}
+        @request.options[:body] = {page: 1, foo: %w(bar baz)}
         @request.send(:setup_raw_request)
         body = @request.instance_variable_get(:@raw_request).body
         URI.unescape(body).should == "foo=bar&foo=baz&page=1"
@@ -178,7 +221,7 @@ describe HTTParty::Request do
     it "should get a connection from the connection_adapter" do
       http = Net::HTTP.new('google.com')
       adapter = mock('adapter')
-      request = HTTParty::Request.new(Net::HTTP::Get, 'https://api.foo.com/v1:443', :connection_adapter => adapter)
+      request = HTTParty::Request.new(Net::HTTP::Get, 'https://api.foo.com/v1:443', connection_adapter: adapter)
       adapter.should_receive(:call).with(request.uri, request.options).and_return(http)
       request.send(:http).should be http
     end
@@ -371,9 +414,9 @@ describe HTTParty::Request do
         end
 
         it "calls block given to perform with each redirect" do
-          @request = HTTParty::Request.new(Net::HTTP::Get, 'http://test.com/redirect', :format => :xml)
-          FakeWeb.register_uri(:get, "http://test.com/redirect", :status => [300, "REDIRECT"], :location => "http://api.foo.com/v2")
-          FakeWeb.register_uri(:get, "http://api.foo.com/v2", :body => "<hash><foo>bar</foo></hash>")
+          @request = HTTParty::Request.new(Net::HTTP::Get, 'http://test.com/redirect', format: :xml)
+          FakeWeb.register_uri(:get, "http://test.com/redirect", status: [300, "REDIRECT"], location: "http://api.foo.com/v2")
+          FakeWeb.register_uri(:get, "http://api.foo.com/v2", body: "<hash><foo>bar</foo></hash>")
           body = ""
           response = @request.perform { |chunk| body += chunk }
           body.length.should == 27
@@ -393,10 +436,10 @@ describe HTTParty::Request do
         end
 
         it "handles multiple redirects and relative location headers on different hosts" do
-          @request = HTTParty::Request.new(Net::HTTP::Get, 'http://test.com/redirect', :format => :xml)
-          FakeWeb.register_uri(:get, "http://test.com/redirect", :status => [300, "REDIRECT"], :location => "http://api.foo.com/v2")
-          FakeWeb.register_uri(:get, "http://api.foo.com/v2", :status => [300, "REDIRECT"], :location => "/v3")
-          FakeWeb.register_uri(:get, "http://api.foo.com/v3", :body => "<hash><foo>bar</foo></hash>")
+          @request = HTTParty::Request.new(Net::HTTP::Get, 'http://test.com/redirect', format: :xml)
+          FakeWeb.register_uri(:get, "http://test.com/redirect", status: [300, "REDIRECT"], location: "http://api.foo.com/v2")
+          FakeWeb.register_uri(:get, "http://api.foo.com/v2", status: [300, "REDIRECT"], location: "/v3")
+          FakeWeb.register_uri(:get, "http://api.foo.com/v3", body: "<hash><foo>bar</foo></hash>")
           response = @request.perform
           response.request.base_uri.to_s.should == "http://api.foo.com"
           response.request.path.to_s.should == "/v3"
@@ -454,7 +497,7 @@ describe HTTParty::Request do
     @request.perform.should == 'Content for you'
   end
 
-  describe "a request that redirects" do
+  describe "a request that 302 redirects" do
     before(:each) do
       @redirect = stub_response("", 302)
       @redirect['location'] = '/foo'
@@ -574,6 +617,142 @@ describe HTTParty::Request do
     end
   end
 
+  describe "a request that 303 redirects" do
+    before(:each) do
+      @redirect = stub_response("", 303)
+      @redirect['location'] = '/foo'
+
+      @ok = stub_response('<hash><foo>bar</foo></hash>', 200)
+    end
+
+    describe "once" do
+      before(:each) do
+        @http.stub!(:request).and_return(@redirect, @ok)
+      end
+
+      it "should be handled by GET transparently" do
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+      end
+
+      it "should be handled by POST transparently" do
+        @request.http_method = Net::HTTP::Post
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+      end
+
+      it "should be handled by DELETE transparently" do
+        @request.http_method = Net::HTTP::Delete
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+      end
+
+      it "should be handled by MOVE transparently" do
+        @request.http_method = Net::HTTP::Move
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+      end
+
+      it "should be handled by COPY transparently" do
+        @request.http_method = Net::HTTP::Copy
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+      end
+
+      it "should be handled by PATCH transparently" do
+        @request.http_method = Net::HTTP::Patch
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+      end
+
+      it "should be handled by PUT transparently" do
+        @request.http_method = Net::HTTP::Put
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+      end
+
+      it "should be handled by HEAD transparently" do
+        @request.http_method = Net::HTTP::Head
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+      end
+
+      it "should be handled by OPTIONS transparently" do
+        @request.http_method = Net::HTTP::Options
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+      end
+
+      it "should keep track of cookies between redirects" do
+        @redirect['Set-Cookie'] = 'foo=bar; name=value; HTTPOnly'
+        @request.perform
+        @request.options[:headers]['Cookie'].should match(/foo=bar/)
+        @request.options[:headers]['Cookie'].should match(/name=value/)
+      end
+
+      it 'should update cookies with rediects' do
+        @request.options[:headers] = {'Cookie'=> 'foo=bar;'}
+        @redirect['Set-Cookie'] = 'foo=tar;'
+        @request.perform
+        @request.options[:headers]['Cookie'].should match(/foo=tar/)
+      end
+
+      it 'should keep cookies between rediects' do
+        @request.options[:headers] = {'Cookie'=> 'keep=me'}
+        @redirect['Set-Cookie'] = 'foo=tar;'
+        @request.perform
+        @request.options[:headers]['Cookie'].should match(/keep=me/)
+      end
+
+      it "should handle multiple Set-Cookie headers between redirects" do
+        @redirect.add_field 'set-cookie', 'foo=bar; name=value; HTTPOnly'
+        @redirect.add_field 'set-cookie', 'one=1; two=2; HTTPOnly'
+        @request.perform
+        @request.options[:headers]['Cookie'].should match(/foo=bar/)
+        @request.options[:headers]['Cookie'].should match(/name=value/)
+        @request.options[:headers]['Cookie'].should match(/one=1/)
+        @request.options[:headers]['Cookie'].should match(/two=2/)
+      end
+
+      it 'should make resulting request a get request if it not already' do
+        @request.http_method = Net::HTTP::Delete
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+        @request.http_method.should == Net::HTTP::Get
+      end
+
+      it 'should make resulting request a get request if options[:maintain_method_across_redirects] is false' do
+        @request.options[:maintain_method_across_redirects] = false
+        @request.http_method = Net::HTTP::Delete
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+        @request.http_method.should == Net::HTTP::Get
+      end
+
+      it 'should make resulting request a get request if options[:maintain_method_across_redirects] is true but options[:resend_on_redirect] is false' do
+        @request.options[:maintain_method_across_redirects] = true
+        @request.options[:resend_on_redirect] = false
+        @request.http_method = Net::HTTP::Delete
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+        @request.http_method.should == Net::HTTP::Get
+      end
+
+      it 'should not make resulting request a get request if options[:maintain_method_across_redirects] and options[:resend_on_redirect] is true' do
+        @request.options[:maintain_method_across_redirects] = true
+        @request.options[:resend_on_redirect] = true
+        @request.http_method = Net::HTTP::Delete
+        @request.perform.should == {"hash" => {"foo" => "bar"}}
+        @request.http_method.should == Net::HTTP::Delete
+      end
+
+      it 'should log the redirection' do
+        logger_double = double
+        logger_double.should_receive(:info).twice
+        @request.options[:logger] = logger_double
+        @request.perform
+      end
+    end
+
+    describe "infinitely" do
+      before(:each) do
+        @http.stub!(:request).and_return(@redirect)
+      end
+
+      it "should raise an exception" do
+        lambda { @request.perform }.should raise_error(HTTParty::RedirectionTooDeep)
+      end
+    end
+  end
+
   describe "#handle_deflation" do
     context "context-encoding" do
       before do
@@ -611,7 +790,7 @@ describe HTTParty::Request do
   context "with POST http method" do
     it "should raise argument error if query is not a hash" do
       lambda {
-        HTTParty::Request.new(Net::HTTP::Post, 'http://api.foo.com/v1', :format => :xml, :query => 'astring').perform
+        HTTParty::Request.new(Net::HTTP::Post, 'http://api.foo.com/v1', format: :xml, query: 'astring').perform
       }.should raise_error(ArgumentError)
     end
   end
@@ -619,19 +798,19 @@ describe HTTParty::Request do
   describe "argument validation" do
     it "should raise argument error if basic_auth and digest_auth are both present" do
       lambda {
-        HTTParty::Request.new(Net::HTTP::Post, 'http://api.foo.com/v1', :basic_auth => {}, :digest_auth => {}).perform
+        HTTParty::Request.new(Net::HTTP::Post, 'http://api.foo.com/v1', basic_auth: {}, digest_auth: {}).perform
       }.should raise_error(ArgumentError, "only one authentication method, :basic_auth or :digest_auth may be used at a time")
     end
 
     it "should raise argument error if basic_auth is not a hash" do
       lambda {
-        HTTParty::Request.new(Net::HTTP::Post, 'http://api.foo.com/v1', :basic_auth => ["foo", "bar"]).perform
+        HTTParty::Request.new(Net::HTTP::Post, 'http://api.foo.com/v1', basic_auth: ["foo", "bar"]).perform
       }.should raise_error(ArgumentError, ":basic_auth must be a hash")
     end
 
     it "should raise argument error if digest_auth is not a hash" do
       lambda {
-        HTTParty::Request.new(Net::HTTP::Post, 'http://api.foo.com/v1', :digest_auth => ["foo", "bar"]).perform
+        HTTParty::Request.new(Net::HTTP::Post, 'http://api.foo.com/v1', digest_auth: ["foo", "bar"]).perform
       }.should raise_error(ArgumentError, ":digest_auth must be a hash")
     end
   end

data/spec/httparty/response_spec.rb

@@ -6,7 +6,7 @@ describe HTTParty::Response do
     @content_length = '1024'
     @request_object = HTTParty::Request.new Net::HTTP::Get, '/'
     @response_object = Net::HTTPOK.new('1.1', 200, 'OK')
-    @response_object.stub(:body => "{foo:'bar'}")
+    @response_object.stub(body: "{foo:'bar'}")
     @response_object['last-modified'] = @last_modified
     @response_object['content-length'] = @content_length
     @parsed_response = lambda { {"foo" => "bar"} }
@@ -155,46 +155,46 @@ describe HTTParty::Response do
 
     context "for specific codes" do
       SPECIFIC_CODES = {
-        :accepted?                        => Net::HTTPAccepted,
-        :bad_gateway?                     => Net::HTTPBadGateway,
-        :bad_request?                     => Net::HTTPBadRequest,
-        :conflict?                        => Net::HTTPConflict,
-        :continue?                        => Net::HTTPContinue,
-        :created?                         => Net::HTTPCreated,
-        :expectation_failed?              => Net::HTTPExpectationFailed,
-        :forbidden?                       => Net::HTTPForbidden,
-        :found?                           => Net::HTTPFound,
-        :gateway_time_out?                => Net::HTTPGatewayTimeOut,
-        :gone?                            => Net::HTTPGone,
-        :internal_server_error?           => Net::HTTPInternalServerError,
-        :length_required?                 => Net::HTTPLengthRequired,
-        :method_not_allowed?              => Net::HTTPMethodNotAllowed,
-        :moved_permanently?               => Net::HTTPMovedPermanently,
-        :multiple_choice?                 => Net::HTTPMultipleChoice,
-        :no_content?                      => Net::HTTPNoContent,
-        :non_authoritative_information?   => Net::HTTPNonAuthoritativeInformation,
-        :not_acceptable?                  => Net::HTTPNotAcceptable,
-        :not_found?                       => Net::HTTPNotFound,
-        :not_implemented?                 => Net::HTTPNotImplemented,
-        :not_modified?                    => Net::HTTPNotModified,
-        :ok?                              => Net::HTTPOK,
-        :partial_content?                 => Net::HTTPPartialContent,
-        :payment_required?                => Net::HTTPPaymentRequired,
-        :precondition_failed?             => Net::HTTPPreconditionFailed,
-        :proxy_authentication_required?   => Net::HTTPProxyAuthenticationRequired,
-        :request_entity_too_large?        => Net::HTTPRequestEntityTooLarge,
-        :request_time_out?                => Net::HTTPRequestTimeOut,
-        :request_uri_too_long?            => Net::HTTPRequestURITooLong,
-        :requested_range_not_satisfiable? => Net::HTTPRequestedRangeNotSatisfiable,
-        :reset_content?                   => Net::HTTPResetContent,
-        :see_other?                       => Net::HTTPSeeOther,
-        :service_unavailable?             => Net::HTTPServiceUnavailable,
-        :switch_protocol?                 => Net::HTTPSwitchProtocol,
-        :temporary_redirect?              => Net::HTTPTemporaryRedirect,
-        :unauthorized?                    => Net::HTTPUnauthorized,
-        :unsupported_media_type?          => Net::HTTPUnsupportedMediaType,
-        :use_proxy?                       => Net::HTTPUseProxy,
-        :version_not_supported?           => Net::HTTPVersionNotSupported
+        accepted?:                        Net::HTTPAccepted,
+        bad_gateway?:                     Net::HTTPBadGateway,
+        bad_request?:                     Net::HTTPBadRequest,
+        conflict?:                        Net::HTTPConflict,
+        continue?:                        Net::HTTPContinue,
+        created?:                         Net::HTTPCreated,
+        expectation_failed?:              Net::HTTPExpectationFailed,
+        forbidden?:                       Net::HTTPForbidden,
+        found?:                           Net::HTTPFound,
+        gateway_time_out?:                Net::HTTPGatewayTimeOut,
+        gone?:                            Net::HTTPGone,
+        internal_server_error?:           Net::HTTPInternalServerError,
+        length_required?:                 Net::HTTPLengthRequired,
+        method_not_allowed?:              Net::HTTPMethodNotAllowed,
+        moved_permanently?:               Net::HTTPMovedPermanently,
+        multiple_choice?:                 Net::HTTPMultipleChoice,
+        no_content?:                      Net::HTTPNoContent,
+        non_authoritative_information?:   Net::HTTPNonAuthoritativeInformation,
+        not_acceptable?:                  Net::HTTPNotAcceptable,
+        not_found?:                       Net::HTTPNotFound,
+        not_implemented?:                 Net::HTTPNotImplemented,
+        not_modified?:                    Net::HTTPNotModified,
+        ok?:                              Net::HTTPOK,
+        partial_content?:                 Net::HTTPPartialContent,
+        payment_required?:                Net::HTTPPaymentRequired,
+        precondition_failed?:             Net::HTTPPreconditionFailed,
+        proxy_authentication_required?:   Net::HTTPProxyAuthenticationRequired,
+        request_entity_too_large?:        Net::HTTPRequestEntityTooLarge,
+        request_time_out?:                Net::HTTPRequestTimeOut,
+        request_uri_too_long?:            Net::HTTPRequestURITooLong,
+        requested_range_not_satisfiable?: Net::HTTPRequestedRangeNotSatisfiable,
+        reset_content?:                   Net::HTTPResetContent,
+        see_other?:                       Net::HTTPSeeOther,
+        service_unavailable?:             Net::HTTPServiceUnavailable,
+        switch_protocol?:                 Net::HTTPSwitchProtocol,
+        temporary_redirect?:              Net::HTTPTemporaryRedirect,
+        unauthorized?:                    Net::HTTPUnauthorized,
+        unsupported_media_type?:          Net::HTTPUnsupportedMediaType,
+        use_proxy?:                       Net::HTTPUseProxy,
+        version_not_supported?:           Net::HTTPVersionNotSupported
       }
 
       # Ruby 2.0, new name for this response.