http-client 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8833622cfb8dd5390e0daae8a669265432903ba5
-  data.tar.gz: 76efa57c394ef3b0ea0073426161c8cb9e7f04db
+  metadata.gz: d9e9eae81102b0be33c27dc85929a220ab8bfee5
+  data.tar.gz: 4a2f85ca306800e17f5ee29a459ff2747a70eacf
 SHA512:
-  metadata.gz: 28020a9dd60ca5f2415e4dcb3b44005550147afea1cf39232c962c22c06210b924ba3366b32b2f88137696499817b7abda4c5f1adff55ebaad07f6178df0687c
-  data.tar.gz: 6c2cc5c1e1e9e92e994e4e7164b98771d1eed5f3ceb019a01fc6ece374e7e26c8c759e3e7d72214550ea7985e07528dfd57a99a8b7940aacebd453db6adf112a
+  metadata.gz: 770fd61b83f170d613ca39ee167fd652adbb88654e01b13f34fda61e68f93a038d44f8cd719e6327bbe6ba0ecd5cd4c6af94df90c65b5899ba332d3779ba548c
+  data.tar.gz: 2d96e1124de41b12e14ce29f6de8d9e78029a5b6ed70fb19d25781cc196f040e23a5c477363f01da49f448d624ae120a3825ff104f85b54bf7faa722952119bf

data/CHANGELOG

@@ -1,3 +1,9 @@
+== 0.1.2 (2016-06-09)
+
+* Fix YARD documentation.
+* Preserve headers in 301, 302 & 303 redirects.
+* Handle 303, 307 & 308.
+
 == 0.1.1 (2016-06-08)
 
 * Less restrictive dependency versions.

data/README.md

@@ -1,6 +1,6 @@
 # HTTP Client
 
-A simple Net::HTTP wrapper with multi-part and cookie-jar support.
+A simple Net::HTTP wrapper with multi-part request, file upload and cookie-jar support.
 
 ## Install
 
@@ -12,26 +12,33 @@ gem install http-client
 
 ```ruby
 require 'http-client'
-res = HTTP::Client::Request.new(:get, "http://www.example.org", max_redirects: 2).execute
+res = HTTP::Client::Request.new(:get, "http://a.b/", max_redirects: 2).execute
 
 # save a few keystrokes.
-res = HTTP::Client.get("http://www.example.org/", max_redirects: 2)
-res = HTTP::Client.post(
-  "http://www.example.org/",
-  files: {pic: "kittens.jpg"},
-  query: {title: "the usual suspects"}
-)
+res = HTTP::Client.get("http://a.b/", max_redirects: 2)
+res = HTTP::Client.put("http://a.b/", files: {pic: "kittens.jpg"}, query: {title: "the usual suspects"})
+res = HTTP::Client.post("http://a.b/", auth: {username: "test", password: "test"}, headers: {'x-a' => 'b'})
+res = HTTP::Client.delete("http://a.b/", auth: {username: "test", password: "test"});
 ```
 
 ## API
 
 ```
+HTTP::Client
+    .get(uri, arguments = {})
+    .put(uri, arguments = {})
+    .post(uri, arguments = {})
+    .head(uri, arguments = {})
+    .trace(uri, arguments = {})
+    .delete(uri, arguments = {})
+    .options(uri, arguments = {})
+
 HTTP::Client::Request
     .new(verb, uri, arguments = {})
     #execute
 
 HTTP::Client::Response
-    .new net_http_response, last_effective_uri
+    .new(net_http_response, last_effective_uri)
     #code
     #body
     #headers
@@ -49,24 +56,32 @@ HTTP::Client::Response
 
 #### Optional arguments hash
 
-| Name | Type | Description |
-|------|------|-------------|
-| headers | Hash | Net::HTTP headers, in key-value pairs. |
-| query | Hash | Net::HTTP query-string in key-value pairs. |
-| files | Hash | Multi-part file uploads, in key-value pairs of {name => path_to_file} or {name => [File]} |
-| body | String | Request body. |
-| auth | Hash | Basic-Auth hash. {username: "...", password: "..."} |
-| timeout | Integer | Fixed timeout for connection, read and ssl handshake in seconds. |
-| open_timeout | Integer | Connection timeout in seconds. |
-| read_timeout | Integer | Read timeout in seconds. |
-| ssl_timeout | Integer | SSL handshake timeout in seconds. |
-| max_redirects | Integer | Max redirect follow, default: 0 |
-| ssl_verify | Integer | OpenSSL verification, HTTP::Client::SSL_VERIFY_PEER or HTTP::Client::SSL_VERIFY_NONE, defaults to SSL_VERIFY_PEER. |
-| jar | HTTP::CookieJar | Optional cookie jar to use. Relies on HTTP::CookieJar from http-cookie gem. |
-
-## TODO
-
-Extensive testing :/
+| Name | Type | Description | Default |
+|------|------|-------------|---------|
+| headers | Hash | Net::HTTP headers, in key-value pairs. | nil |
+| query | Hash | Net::HTTP query-string in key-value pairs. | nil |
+| files | Hash | Multi-part file uploads, in key-value pairs of {name => path_to_file} or {name => File} | nil |
+| body | String | Request body. | nil |
+| auth | Hash | Basic-Auth hash. {username: "...", password: "..."} | nil |
+| timeout | Integer | Fixed timeout for connection, read and ssl handshake in seconds. | Net::HTTP default |
+| open_timeout | Integer | Connection timeout in seconds. | Net::HTTP default |
+| read_timeout | Integer | Read timeout in seconds. | Net::HTTP default |
+| ssl_timeout | Integer | SSL handshake timeout in seconds. | Net::HTTP default |
+| max_redirects | Integer | Maximum redirects follow. | 0 |
+| ssl_verify | Integer | OpenSSL verification. HTTP::Client::SSL_VERIFY_PEER or HTTP::Client::SSL_VERIFY_NONE | SSL_VERIFY_PEER |
+| jar | HTTP::CookieJar | Optional cookie jar to use. Relies on HTTP::CookieJar from http-cookie gem. | HTTP::CookieJar.new |
+
+## Default behaviour
+
+### SSL
+
+* By default peer verification is done. You can turn this off by passing `ssl_verfy: HTTP::Client::SSL_VERIFY_NONE` option.
+
+### Redirects
+
+* By default the client does not follow redirects. You can enable this with a non-zero `max_redirects` option.
+* 301, 302 and 303 redirects are always followed with a GET method.
+* 307 and 308 redirects preserve original request method & body.
 
 ## License
 

data/lib/http/client.rb

@@ -7,7 +7,7 @@ require 'http-cookie'
 
 module HTTP
   module Client
-    VERSION = '0.1.1'
+    VERSION = '0.1.2'
 
     GET                     = Net::HTTP::Get
     HEAD                    = Net::HTTP::Head
@@ -16,45 +16,68 @@ module HTTP
     DELETE                  = Net::HTTP::Delete
     OPTIONS                 = Net::HTTP::Options
     TRACE                   = Net::HTTP::Trace
-    VALID_VERBS             = [GET, HEAD, PUT, POST, DELETE, OPTIONS, TRACE]
 
     SSL_VERIFY_NONE         = OpenSSL::SSL::VERIFY_NONE
     SSL_VERIFY_PEER         = OpenSSL::SSL::VERIFY_PEER
-    VALID_SSL_VERIFICATIONS = [SSL_VERIFY_NONE, SSL_VERIFY_PEER]
-
-    DEFAULT_HEADERS         = {'User-Agent' => 'HTTP Client API/1.0'}
 
     class Request
-      attr_reader :uri
+      VALID_PARAMETERS        = %w(headers files query body auth timeout open_timeout ssl_timeout read_timeout max_redirects ssl_verify jar)
+      DEFAULT_HEADERS         = {'User-Agent' => 'HTTP Client API/1.0'}
+
+      REDIRECT_WITH_GET       = [301, 302, 303]
+      REDIRECT_WITH_ORIGINAL  = [307, 308]
 
-      VALID_PARAMETERS = %w(headers files query body auth timeout open_timeout ssl_timeout read_timeout max_redirects ssl_verify jar)
+      VALID_VERBS             = [GET, HEAD, PUT, POST, DELETE, OPTIONS, TRACE]
+      VALID_SSL_VERIFICATIONS = [SSL_VERIFY_NONE, SSL_VERIFY_PEER]
+      VALID_REDIRECT_CODES    = REDIRECT_WITH_GET + REDIRECT_WITH_ORIGINAL
 
       # Create a new HTTP Client Request.
       #
-      # @param verb          [Symbol]          HTTP verb, one of :get, :head, :put, :post, :delete, :options, :trace.
-      # @param uri           [String] or [URI] Remote URI.
-      # @param headers       [Hash]            Net::HTTP headers, in key-value pairs.
-      # @param query         [Hash]            Net::HTTP query-string in key-value pairs.
-      # @param files         [Hash]            Multi-part file uploads, in key-value pairs of {name => path_to_file} or {name => File}
-      # @param body          [String]          Request body.
-      # @param auth          [Hash]            Basic-Auth hash. {username: "...", password: "..."}
-      # @param timeout       [Integer]         Fixed timeout for connection, read and ssl handshake in seconds.
-      # @param open_timeout  [Integer]         Connection timeout in seconds.
-      # @param read_timeout  [Integer]         Read timeout in seconds.
-      # @param ssl_timeout   [Integer]         SSL handshake timeout in seconds.
-      # @param max_redirects [Integer]         Max redirect follow, default: 0
-      # @param ssl_verify    [Integer]         OpenSSL verification, HTTP::Client::SSL_VERIFY_PEER or HTTP::Client::SSL_VERIFY_NONE, defaults to SSL_VERIFY_PEER.
-      # @param jar           [HTTP::CookieJar] Optional cookie jar to use. Relies on HTTP::CookieJar from http-cookie gem.
+      # @param  [Symbol]               verb            HTTP verb, one of :get, :head, :put, :post, :delete, :options, :trace.
+      # @param  [String or URI]        uri             Remote URI.
+      # @param  [Hash]                 args            Options, see below.
+      # @option args [Hash]            headers         Net::HTTP headers, in key-value pairs.
+      # @option args [Hash]            query           Net::HTTP query-string in key-value pairs.
+      # @option args [Hash]            files           Multi-part file uploads, in key-value pairs of name & path or name & File object.
+      # @option args [String]          body            Request body.
+      # @option args [Hash]            auth            Basic-Auth hash. Requires :username and :password.
+      # @option args [Integer]         timeout         Fixed timeout for connection, read and ssl handshake in seconds.
+      # @option args [Integer]         open_timeout    Connection timeout in seconds.
+      # @option args [Integer]         read_timeout    Read timeout in seconds.
+      # @option args [Integer]         ssl_timeout     SSL handshake timeout in seconds.
+      # @option args [Integer]         max_redirects   Max redirect follow, default: 0
+      # @option args [Integer]         ssl_verify      OpenSSL verification, SSL_VERIFY_PEER or SSL_VERIFY_NONE, defaults to SSL_VERIFY_PEER.
+      # @option args [HTTP::CookieJar] jar             Optional cookie jar to use. Relies on HTTP::CookieJar from http-cookie gem.
       #
       # @return [HTTP::Client::Request]
       #
+      # @example Retrieve a page using GET.
+      #   request  = HTTP::Client::Request.new(:get, "http://www.example.org/", query: {q: "search something"})
+      #   response = request.execute
+      #
+      # @example Handle redirects.
+      #   request  = HTTP::Client::Request.new(:get, "http://www.example.org/", max_redirects: 3)
+      #   response = request.execute
+      #
+      # @example Perform request and return result in one go.
+      #   response = HTTP::Client.get("http://www.example.org/", max_redirects: 3)
+      #
+      # @example Upload a few files in a POST request.
+      #   request  = HTTP::Client::Request.new(:post, "http://www.example.org/", files: {"cats" => "cats.jpg", "dogs" => "dogs.jpg"}, query: {title: "cute pics"})
+      #   response = request.execute
+      #
+      # @example Pass in an external cookie jar.
+      #   jar  = HTTP::CookieJar.new
+      #   jar.load("mycookies.cky")
+      #   response = HTTP::Client.get("http://www.example.org/", jar: jar)
+      #
       def initialize verb, uri, args = {}
         args.each do |k, v|
           raise ArgumentError, "unknown argument #{k}" unless VALID_PARAMETERS.include?(k.to_s)
         end
 
-        parse_uri! uri
-        setup_request_delegate! verb, args
+        uri       = parse_uri!(uri)
+        @delegate = create_request_delegate(verb, uri, args)
 
         if body = args[:body]
           raise ArgumentError, "#{verb} cannot have body" unless @delegate.class.const_get(:REQUEST_HAS_BODY)
@@ -77,9 +100,9 @@ module HTTP
         @ssl_timeout  = args[:ssl_timeout]  if args[:ssl_timeout]
         @read_timeout = args[:read_timeout] if args[:read_timeout]
 
-        @redirects    = args.fetch(:max_redirects, 0)
-        @ssl_verify   = args.fetch(:ssl_verify, SSL_VERIFY_PEER)
-        @jar          = args.fetch(:jar, HTTP::CookieJar.new)
+        @max_redirects = args.fetch(:max_redirects, 0)
+        @ssl_verify    = args.fetch(:ssl_verify, SSL_VERIFY_PEER)
+        @jar           = args.fetch(:jar, HTTP::CookieJar.new)
       end
 
       # Executes a request.
@@ -87,7 +110,7 @@ module HTTP
       # @return [HTTP::Client::Response]
       #
       def execute
-        @last_effective_uri = uri
+        last_effective_uri = uri
 
         cookie = HTTP::Cookie.cookie_value(@jar.cookies(uri))
         if cookie && !cookie.empty?
@@ -97,57 +120,73 @@ module HTTP
         response = request!(uri, @delegate)
         @jar.parse(response['set-cookie'].to_s, uri)
 
-        while @redirects > 0 && [301, 302, 307].include?(response.code.to_i)
-          @redirects -= 1
-          redirect    = redirect_to(response['location'])
+        redirects = 0
+        while redirects < @max_redirects && VALID_REDIRECT_CODES.include?(response.code.to_i)
+          redirects         += 1
+          last_effective_uri = parse_uri! response['location']
+          redirect_delegate  = redirect_to(last_effective_uri, response.code.to_i)
 
-          cookie = HTTP::Cookie.cookie_value(@jar.cookies(@last_effective_uri))
+          cookie = HTTP::Cookie.cookie_value(@jar.cookies(last_effective_uri))
           if cookie && !cookie.empty?
-            redirect.add_field('Cookie', cookie)
+            redirect_delegate.add_field('Cookie', cookie)
           end
 
-          response = request!(@last_effective_uri, redirect)
-          @jar.parse(response['set-cookie'].to_s, @last_effective_uri)
+          response = request!(last_effective_uri, redirect_delegate)
+          @jar.parse(response['set-cookie'].to_s, last_effective_uri)
         end
 
-        Response.new(response, @last_effective_uri)
+        Response.new(response, last_effective_uri)
       end
 
       private
+        def uri
+          @delegate.uri
+        end
+
         def parse_uri! uri
-          @uri = uri.kind_of?(URI) ? uri : URI.parse(uri)
-          case @uri
+          uri = uri.kind_of?(URI) ? uri : URI.parse(uri)
+          case uri
             when URI::HTTP, URI::HTTPS
-              # ok
+              uri
+            when URI::Generic
+              if @delegate.uri
+                @delegate.uri.dup.tap {|s| s += uri }
+              else
+                raise ArgumentError, "Invalid URI #{uri}"
+              end
             else
               raise ArgumentError, "Invalid URI #{uri}"
           end
         end
 
-        def setup_request_delegate! verb, args
-          klass    = find_delegate_class(verb)
-          @headers = DEFAULT_HEADERS.merge(args.fetch(:headers, {}))
+        def create_request_delegate verb, uri, args
+          klass   = find_delegate_class(verb)
+          headers = DEFAULT_HEADERS.merge(args.fetch(:headers, {}))
 
           files    = args[:files]
           qs       = args[:query]
+          uri      = uri.dup
+          delegate = nil
 
           if files
             raise ArgumentError, "#{verb} cannot have body" unless klass.const_get(:REQUEST_HAS_BODY)
-            multipart              = Multipart.new(files, qs)
-            @delegate              = klass.new(@uri.request_uri, headers_for(@uri))
-            @delegate.content_type = multipart.content_type
-            @delegate.body         = multipart.body
+            multipart             = Multipart.new(files, qs)
+            delegate              = klass.new(uri, headers)
+            delegate.content_type = multipart.content_type
+            delegate.body         = multipart.body
           elsif qs
             if klass.const_get(:REQUEST_HAS_BODY)
-              @delegate = klass.new(@uri.request_uri, headers_for(@uri))
-              @delegate.set_form_data(qs)
+              delegate = klass.new(uri, headers)
+              delegate.set_form_data(qs)
             else
-              @uri.query = URI.encode_www_form(qs)
-              @delegate = klass.new(@uri.request_uri, headers_for(@uri))
+              uri.query = URI.encode_www_form(qs)
+              delegate  = klass.new(uri, headers)
             end
           else
-            @delegate = klass.new(@uri.request_uri, headers_for(@uri))
+            delegate = klass.new(uri, headers)
           end
+
+          delegate
         end
 
         def request! uri, delegate
@@ -166,13 +205,28 @@ module HTTP
           response
         end
 
-        def redirect_to uri
-          @last_effective_uri = URI.parse(uri)
-          GET.new(@last_effective_uri.request_uri, headers_for(@last_effective_uri))
-        end
-
-        def headers_for uri
-          @headers
+        def redirect_to uri, code
+          # NOTE request-uri with query string is not preserved.
+          case code
+            when *REDIRECT_WITH_GET
+              GET.new(uri, {}).tap do |r|
+                @delegate.each_header do |field, value|
+                  next if field.downcase == 'host'
+                  r[field] = value
+                end
+              end
+            when *REDIRECT_WITH_ORIGINAL
+              @delegate.class.new(uri, {}).tap do |r|
+                @delegate.each_header do |field, value|
+                  next if field.downcase == 'host'
+                  r[field] = value
+                end
+
+                r.body = @delegate.body
+              end
+            else
+              raise RuntimeError, "response #{code} should not result in redirection."
+          end
         end
 
         def find_delegate_class verb
@@ -290,44 +344,56 @@ module HTTP
       # Creates a GET request and executes it, returning the response.
       # @see HTTP::Client::Request#initialize
       #
+      # @param  [String or URI] uri   Remote URI.
+      # @param  [Hash]          args  Options, see HTTP::Client::Request#initialize.
       # @return [HTTP::Client::Response]
       #
-      def get     *args; Request.new(GET, *args).execute; end
+      def get uri, args = {}; Request.new(GET, uri, args).execute; end
 
       # Creates a PUT request and executes it, returning the response.
       # @see HTTP::Client::Request#initialize
       #
+      # @param  [String or URI] uri   Remote URI.
+      # @param  [Hash]          args  Options, see HTTP::Client::Request#initialize.
       # @return [HTTP::Client::Response]
       #
-      def put     *args; Request.new(PUT, *args).execute; end
+      def put uri, args = {}; Request.new(PUT, uri, args).execute; end
 
       # Creates a POST request and executes it, returning the response.
       # @see HTTP::Client::Request#initialize
       #
+      # @param  [String or URI] uri   Remote URI.
+      # @param  [Hash]          args  Options, see HTTP::Client::Request#initialize.
       # @return [HTTP::Client::Response]
       #
-      def post    *args; Request.new(POST, *args).execute; end
+      def post  uri, args = {}; Request.new(POST, uri, args).execute; end
 
       # Creates a DELETE request and executes it, returning the response.
       # @see HTTP::Client::Request#initialize
       #
+      # @param  [String or URI] uri   Remote URI.
+      # @param  [Hash]          args  Options, see HTTP::Client::Request#initialize.
       # @return [HTTP::Client::Response]
       #
-      def delete  *args; Request.new(DELETE, *args).execute; end
+      def delete uri, args = {}; Request.new(DELETE, uri, args).execute; end
 
       # Creates a OPTIONS request and executes it, returning the response.
       # @see HTTP::Client::Request#initialize
       #
+      # @param  [String or URI] uri   Remote URI.
+      # @param  [Hash]          args  Options, see HTTP::Client::Request#initialize.
       # @return [HTTP::Client::Response]
       #
-      def options *args; Request.new(OPTIONS, *args).execute; end
+      def options uri, args = {}; Request.new(OPTIONS, uri, args).execute; end
 
       # Creates a TRACE request and executes it, returning the response.
       # @see HTTP::Client::Request#initialize
       #
+      # @param  [String or URI] uri   Remote URI.
+      # @param  [Hash]          args  Options, see HTTP::Client::Request#initialize.
       # @return [HTTP::Client::Response]
       #
-      def trace   *args; Request.new(TRACE, *args).execute; end
+      def trace uri, args = {}; Request.new(TRACE, uri, args).execute; end
     end
   end # Client
 end # HTTP

data/test/test_request.rb

@@ -2,20 +2,20 @@ require_relative 'helper'
 
 describe 'HTTP Client Request' do
   it 'should reject invalid arguments' do
-    assert_raises(ArgumentError, "invalid verb")        {HTTP::Client::Request.new(:foo)}
-    assert_raises(URI::InvalidURIError, "invalid uri")  {HTTP::Client::Request.new(:get, "http://")}
-    assert_raises(ArgumentError, "invalid argument")    {HTTP::Client::Request.new(:get, "http://example.org/", foo: 1)}
+    assert_raises(ArgumentError, 'invalid verb')        {HTTP::Client::Request.new(:foo)}
+    assert_raises(URI::InvalidURIError, 'invalid uri')  {HTTP::Client::Request.new(:get, 'http://')}
+    assert_raises(ArgumentError, 'invalid argument')    {HTTP::Client::Request.new(:get, 'http://example.org/', foo: 1)}
   end
 
   it 'validates body based on request verb' do
-    assert_raises(ArgumentError, "get cannot have body") {HTTP::Client::Request.new(:get, "http://a.c", files: {test: __FILE__})}
+    assert_raises(ArgumentError, 'get cannot have body') {HTTP::Client::Request.new(:get, 'http://a.c', files: {test: __FILE__})}
   end
 
   it 'allows creation of valid request object' do
     assert HTTP::Client::Request.new(
       :post,
-      "http://example.org/",
-      query:         {title: "test"},
+      'http://example.org/',
+      query:         {title: 'test'},
       files:         {test1: __FILE__, test2: __FILE__},
       max_redirects: 2,
       timeout:       10,
@@ -25,7 +25,7 @@ describe 'HTTP Client Request' do
   end
 
   it 'executes a request and returns reponse' do
-    app    = proc {|req| [200, {}, "Hello World!"]}
+    app    = proc {|req| [200, {}, 'Hello World!']}
     server = TestServer.new(app)
     server.run
 
@@ -43,65 +43,119 @@ describe 'HTTP Client Request' do
   end
 
   it 'handles redirects' do
-    app = proc do |req|
-      case req.path
-        when '/redirect2'
-          [200, {}, "Hello World!"]
-        when '/redirect1'
-          [302, {'Location' => '/redirect2'}, "Moved!"]
-        when '/'
-          [302, {'Location' => '/redirect1'}, "Moved!"]
+    cookie  = 'foo=bar; expires=Mon, 31-Dec-2038 23:59:59 GMT; path=/; domain=.127.0.0.1'
+
+    [301, 302, 303, 307, 308]. each do |code|
+      cookies = []
+      methods = []
+      headers = {}
+      app     = proc do |req|
+        cookies << req['cookie']
+        case req.path
+          when '/redirect2'
+            req.each {|k,v| headers[k] = v}
+            methods << req.request_method
+            [200, {}, 'Hello World!']
+          when '/redirect1'
+            methods << req.request_method
+            [code, {'Location' => '/redirect2'}, 'Moved!']
+          when '/'
+            [code, {'Location' => '/redirect1', 'Set-Cookie' => cookie}, 'Moved!']
+        end
+      end
+
+      server = TestServer.new(app)
+      server.run
+
+      response = HTTP::Client.post(server.root)
+      assert_equal code, response.code
+      assert_equal %Q{#{server.root + '/redirect1'}}, response.headers['location']
+
+      response = HTTP::Client.post(server.root, max_redirects: 1)
+      assert_equal code, response.code
+      assert_equal %Q{#{server.root + '/redirect1'}}, response.last_effective_uri.to_s
+      assert_equal %Q{#{server.root + '/redirect2'}}, response.headers['location']
+
+      response = HTTP::Client.post(server.root, headers: {'x-foo-1' => 'bar'}, max_redirects: 2)
+      assert_equal 200, response.code
+      assert_equal %Q{#{server.root + '/redirect2'}}, response.last_effective_uri.to_s
+
+      server.stop
+      cookies.compact!
+      assert_equal 3, cookies.size
+      assert_equal 1, cookies.uniq.size
+      assert_equal 'foo=bar', cookies.first
+
+      methods.compact!
+      assert_equal 1, methods.uniq.size
+      if [307, 308].include?(code)
+        assert_equal 'POST', methods.first
+      else
+        assert_equal 'GET', methods.first
       end
+
+      assert_equal 'bar',  headers['x-foo-1']
     end
-    server = TestServer.new(app)
-    server.run
+  end
 
-    response = HTTP::Client.get(server.root)
-    assert_equal 302, response.code
-    assert_equal %Q{#{server.root + "/redirect1"}}, response.headers['location']
+  it 'handles HTTP 1.1 redirects' do
+    [307, 308].each do |code|
+      bucket = []
+      app    = proc do |req|
+        case req.path
+          when '/redirect'
+            bucket = req.query
+            [200, {}, 'Hello World!']
+          when '/'
+            [code, {'Location' => '/redirect'}, 'Moved!']
+        end
+      end
 
-    response = HTTP::Client.get(server.root, max_redirects: 1)
-    assert_equal 302, response.code
-    assert_equal %Q{#{server.root + "/redirect1"}}, response.last_effective_uri.to_s
-    assert_equal %Q{#{server.root + "/redirect2"}}, response.headers['location']
+      server = TestServer.new(app)
+      server.run
 
-    response = HTTP::Client.get(server.root, max_redirects: 2)
-    assert_equal 200, response.code
-    assert_equal %Q{#{server.root + "/redirect2"}}, response.last_effective_uri.to_s
+      response = HTTP::Client.post(server.root, query: {foo: 'bar'}, files: {baz: __FILE__}, max_redirects: 1)
+      assert_equal 200, response.code
+      assert_equal %Q{#{server.root + '/redirect'}}, response.last_effective_uri.to_s
+      server.stop
+
+      assert bucket['foo'], 'query 1 preserved'
+      assert bucket['baz'], 'file upload preserved'
+    end
   end
 
   it 'posts url encoded form' do
     qs = {}
     app = proc do |req|
       qs = req.query
-      [200, {}, "OK!"]
+      [200, {}, 'OK!']
     end
     server = TestServer.new(app)
     server.run
 
-    response = HTTP::Client.post(server.root, query: {test1: "test2"})
+    response = HTTP::Client.post(server.root, query: {test1: 'test2'})
     server.stop
     assert_equal 200,     response.code
-    assert_equal "test2", qs["test1"]
+    assert_equal 'test2', qs['test1']
   end
 
   it 'posts multi-part encoded data' do
     qs = {}
     app = proc do |req|
       qs = req.query
-      [200, {}, "OK!"]
+      [200, {}, 'OK!']
     end
     server = TestServer.new(app)
     server.run
 
-    response = HTTP::Client.post(server.root, files: {this: __FILE__}, query: {test1: "test2"})
+    response = HTTP::Client.post(server.root, files: {this: __FILE__}, query: {test1: 'test2'})
     server.stop
 
     assert_equal 200,     response.code
-    assert_equal "test2", qs["test1"]
+    assert_equal 'test2', qs['test1']
 
     data = IO.read(__FILE__)
-    assert_equal data, qs["this"]
-    assert_equal File.basename(__FILE__), qs["this"].filename # people should stop overloading / extending String!
+    assert_equal data, qs['this']
+    assert_equal File.basename(__FILE__), qs['this'].filename # people should stop overloading / extending String!
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: http-client
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Bharanee Rathna
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-06-08 00:00:00.000000000 Z
+date: 2016-06-09 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: mime-types