http 0.5.1 → 0.6.0.pre

data/lib/http/{response_parser.rb → response/parser.rb}

@@ -18,7 +18,7 @@ module HTTP
       end
 
       def http_version
-        @parser.http_version.join(".")
+        @parser.http_version.join('.')
       end
 
       def status_code
@@ -53,6 +53,8 @@ module HTTP
       end
 
       def reset
+        @parser.reset!
+
         @finished = false
         @headers  = nil
         @chunk    = nil

data/lib/http/version.rb

@@ -1,3 +1,3 @@
 module HTTP
-  VERSION = "0.5.1" unless defined?(HTTP::VERSION)
+  VERSION = '0.6.0.pre'
 end

data/spec/http/authorization_header/basic_auth_spec.rb

@@ -0,0 +1,29 @@
+require 'spec_helper'
+
+describe HTTP::AuthorizationHeader::BasicAuth do
+  describe '.new' do
+    it 'fails when options is not a Hash' do
+      expect { described_class.new '[FOOBAR]' }.to raise_error
+    end
+
+    it 'fails when :pass is not given' do
+      expect { described_class.new :user => '[USER]' }.to raise_error
+    end
+
+    it 'fails when :user is not given' do
+      expect { described_class.new :pass => '[PASS]' }.to raise_error
+    end
+  end
+
+  describe '#to_s' do
+    let(:user)        { 'foo' }
+    let(:pass)        { 'bar' * 100 }
+    let(:user_n_pass) { user + ':' + pass }
+    let(:builder)     { described_class.new :user => user, :pass => pass }
+
+    subject { builder.to_s }
+
+    it { should eq "Basic #{Base64.strict_encode64 user_n_pass}" }
+    it { should match(/^Basic [^\s]+$/) }
+  end
+end

data/spec/http/authorization_header/bearer_token_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe HTTP::AuthorizationHeader::BearerToken do
+  describe '.new' do
+    it 'fails when options is not a Hash' do
+      expect { described_class.new '[TOKEN]' }.to raise_error
+    end
+
+    it 'fails when :token is not given' do
+      expect { described_class.new :encode => true }.to raise_error
+    end
+  end
+
+  describe '#to_s' do
+    let(:token)   { 'foobar' * 100 }
+    let(:builder) { described_class.new options.merge :token => token }
+
+    subject { builder.to_s }
+
+    context 'when :encode => true' do
+      let(:options) { {:encode => true} }
+      it { should eq "Bearer #{Base64.strict_encode64 token}" }
+      it { should match(/^Bearer [^\s]+$/) }
+    end
+
+    context 'when :encode => false' do
+      let(:options) { {:encode => false} }
+      it { should eq "Bearer #{token}" }
+    end
+
+    context 'when :encode not specified' do
+      let(:options) { {} }
+      it { should eq "Bearer #{token}" }
+    end
+  end
+end

data/spec/http/authorization_header_spec.rb

@@ -0,0 +1,41 @@
+require 'spec_helper'
+
+describe HTTP::AuthorizationHeader do
+  describe '.build' do
+    context 'with unkown type' do
+      let(:type) { :foobar }
+      let(:opts) { {:foo => :bar} }
+
+      it 'fails' do
+        expect { described_class.build type, opts }.to raise_error
+      end
+    end
+
+    context 'with :basic type' do
+      let(:type) { :basic }
+      let(:opts) { {:user => 'user', :pass => 'pass'} }
+
+      it 'passes options to BasicAuth' do
+        expect(described_class::BasicAuth).to receive(:new).with(opts)
+        described_class.build type, opts
+      end
+    end
+
+    context 'with :bearer type' do
+      let(:type) { :bearer }
+      let(:opts) { {:token => 'token', :encode => true} }
+
+      it 'passes options to BearerToken' do
+        expect(described_class::BearerToken).to receive(:new).with(opts)
+        described_class.build type, opts
+      end
+    end
+  end
+
+  describe '.register' do
+    it 'registers given klass in builders registry' do
+      described_class.register :dummy, Class.new { def initialize(*); end }
+      expect { described_class.build(:dummy, 'foobar') }.to_not raise_error
+    end
+  end
+end

data/spec/http/backports/base64_spec.rb

@@ -0,0 +1,13 @@
+require 'spec_helper'
+
+describe Base64 do
+  specify { expect(Base64).to respond_to :strict_encode64 }
+
+  describe '.strict_encode64' do
+    let(:long_string) { (0...256).map { ('a'..'z').to_a[rand(26)] }.join }
+
+    it 'returns a String without whitespaces' do
+      expect(Base64.strict_encode64 long_string).to_not match(/\s/)
+    end
+  end
+end

data/spec/http/client_spec.rb

@@ -0,0 +1,181 @@
+require 'spec_helper'
+
+describe HTTP::Client do
+  StubbedClient = Class.new(HTTP::Client) do
+    def perform_without_following_redirects(request, options)
+      stubs.fetch(request.uri.to_s) { super(request, options) }
+    end
+
+    def stubs
+      @stubs ||= {}
+    end
+
+    def stub(stubs)
+      @stubs = stubs
+      self
+    end
+  end
+
+  def redirect_response(location, status = 302)
+    HTTP::Response.new(status, '1.1', {'Location' => location}, '')
+  end
+
+  def simple_response(body, status = 200)
+    HTTP::Response.new(status, '1.1', {}, body)
+  end
+
+  describe 'following redirects' do
+    it 'returns response of new location' do
+      client = StubbedClient.new(:follow => true).stub(
+        'http://example.com/'     => redirect_response('http://example.com/blog'),
+        'http://example.com/blog' => simple_response('OK')
+      )
+
+      expect(client.get('http://example.com/').to_s).to eq 'OK'
+    end
+
+    it 'prepends previous request uri scheme and host if needed' do
+      client = StubbedClient.new(:follow => true).stub(
+        'http://example.com/'           => redirect_response('/index'),
+        'http://example.com/index'      => redirect_response('/index.html'),
+        'http://example.com/index.html' => simple_response('OK')
+      )
+
+      expect(client.get('http://example.com/').to_s).to eq 'OK'
+    end
+
+    it 'fails upon endless redirects' do
+      client = StubbedClient.new(:follow => true).stub(
+        'http://example.com/' => redirect_response('/')
+      )
+
+      expect { client.get('http://example.com/') } \
+        .to raise_error(HTTP::Redirector::EndlessRedirectError)
+    end
+
+    it 'fails if max amount of hops reached' do
+      client = StubbedClient.new(:follow => 5).stub(
+        'http://example.com/'  => redirect_response('/1'),
+        'http://example.com/1' => redirect_response('/2'),
+        'http://example.com/2' => redirect_response('/3'),
+        'http://example.com/3' => redirect_response('/4'),
+        'http://example.com/4' => redirect_response('/5'),
+        'http://example.com/5' => redirect_response('/6'),
+        'http://example.com/6' => simple_response('OK')
+      )
+
+      expect { client.get('http://example.com/') } \
+        .to raise_error(HTTP::Redirector::TooManyRedirectsError)
+    end
+  end
+
+  describe 'parsing params' do
+    it 'accepts params within the provided URL' do
+      client = HTTP::Client.new
+      allow(client).to receive(:perform)
+      expect(HTTP::Request).to receive(:new) do |_, uri|
+        params = CGI.parse(URI(uri).query)
+        expect(params).to eq('foo' => ['bar'])
+      end
+
+      client.get('http://example.com/?foo=bar')
+    end
+
+    it 'combines GET params from the URI with the passed in params' do
+      client = HTTP::Client.new
+      allow(client).to receive(:perform)
+      expect(HTTP::Request).to receive(:new) do |_, uri|
+        params = CGI.parse(URI(uri).query)
+        expect(params).to eq('foo' => ['bar'], 'baz' => ['quux'])
+      end
+
+      client.get('http://example.com/?foo=bar', :params => {:baz => 'quux'})
+    end
+  end
+
+  describe 'passing json' do
+    it 'encodes given object' do
+      client = HTTP::Client.new
+      allow(client).to receive(:perform)
+
+      expect(HTTP::Request).to receive(:new) do |*args|
+        expect(args.last).to eq('{"foo":"bar"}')
+      end
+
+      client.get('http://example.com/', :json => {:foo => :bar})
+    end
+  end
+
+  describe '#request' do
+    context 'with explicitly given `Host` header' do
+      let(:headers) { {'Host' => 'another.example.com'} }
+      let(:client)  { described_class.new :headers => headers }
+
+      it 'keeps `Host` header as is' do
+        expect(client).to receive(:perform) do |req, options|
+          expect(req['Host']).to eq 'another.example.com'
+        end
+
+        client.request(:get, 'http://example.com/')
+      end
+    end
+  end
+
+  describe '#perform' do
+    let(:client) { described_class.new }
+
+    it 'calls finish_response before actual performance' do
+      TCPSocket.stub(:open) { throw :halt }
+      expect(client).to receive(:finish_response)
+      catch(:halt) { client.head "http://127.0.0.1:#{ExampleService::PORT}/" }
+    end
+
+    it 'calls finish_response once body was fully flushed' do
+      expect(client).to receive(:finish_response).twice.and_call_original
+      client.get("http://127.0.0.1:#{ExampleService::PORT}/").to_s
+    end
+
+    context 'with HEAD request' do
+      it 'does not iterates through body' do
+        expect(client).to_not receive(:readpartial)
+        client.head("http://127.0.0.1:#{ExampleService::PORT}/")
+      end
+
+      it 'finishes response after headers were received' do
+        expect(client).to receive(:finish_response).twice.and_call_original
+        client.head("http://127.0.0.1:#{ExampleService::PORT}/")
+      end
+    end
+
+    context 'when server fully flushes response in one chunk' do
+      before do
+        socket_spy = double
+
+        chunks = [
+          <<-RESPONSE.gsub(/^\s*\| */, '').gsub(/\n/, "\r\n")
+          | HTTP/1.1 200 OK
+          | Content-Type: text/html
+          | Server: WEBrick/1.3.1 (Ruby/1.9.3/2013-11-22)
+          | Date: Mon, 24 Mar 2014 00:32:22 GMT
+          | Content-Length: 15
+          | Connection: Keep-Alive
+          |
+          | <!doctype html>
+          RESPONSE
+        ]
+
+        socket_spy.stub(:close) { nil }
+        socket_spy.stub(:closed?) { true }
+        socket_spy.stub(:readpartial) { chunks.shift }
+        socket_spy.stub(:<<) { nil }
+
+        TCPSocket.stub(:open) { socket_spy }
+      end
+
+      it 'properly reads body' do
+        body = client.get("http://127.0.0.1:#{ExampleService::PORT}/").to_s
+        expect(body).to eq '<!doctype html>'
+      end
+    end
+  end
+end

data/spec/http/content_type_spec.rb

@@ -0,0 +1,47 @@
+require 'spec_helper'
+
+describe HTTP::ContentType do
+  describe '.parse' do
+    context 'with text/plain' do
+      subject { described_class.parse 'text/plain' }
+      its(:mime_type) { should eq 'text/plain' }
+      its(:charset)   { should be_nil }
+    end
+
+    context 'with tEXT/plaIN' do
+      subject { described_class.parse 'tEXT/plaIN' }
+      its(:mime_type) { should eq 'text/plain' }
+      its(:charset)   { should be_nil }
+    end
+
+    context 'with text/plain; charset=utf-8' do
+      subject { described_class.parse 'text/plain; charset=utf-8' }
+      its(:mime_type) { should eq 'text/plain' }
+      its(:charset)   { should eq 'utf-8' }
+    end
+
+    context 'with text/plain; charset="utf-8"' do
+      subject { described_class.parse 'text/plain; charset="utf-8"' }
+      its(:mime_type) { should eq 'text/plain' }
+      its(:charset)   { should eq 'utf-8' }
+    end
+
+    context 'with text/plain; charSET=utf-8' do
+      subject { described_class.parse 'text/plain; charSET=utf-8' }
+      its(:mime_type) { should eq 'text/plain' }
+      its(:charset)   { should eq 'utf-8' }
+    end
+
+    context 'with text/plain; foo=bar; charset=utf-8' do
+      subject { described_class.parse 'text/plain; foo=bar; charset=utf-8' }
+      its(:mime_type) { should eq 'text/plain' }
+      its(:charset)   { should eq 'utf-8' }
+    end
+
+    context 'with text/plain;charset=utf-8;foo=bar' do
+      subject { described_class.parse 'text/plain;charset=utf-8;foo=bar' }
+      its(:mime_type) { should eq 'text/plain' }
+      its(:charset)   { should eq 'utf-8' }
+    end
+  end
+end

data/spec/http/headers/mixin_spec.rb

@@ -0,0 +1,36 @@
+require 'spec_helper'
+
+describe HTTP::Headers::Mixin do
+  let :dummy_class do
+    Class.new do
+      include HTTP::Headers::Mixin
+
+      def initialize(headers)
+        @headers = headers
+      end
+    end
+  end
+
+  let(:headers) { HTTP::Headers.new }
+  let(:dummy)   { dummy_class.new headers }
+
+  describe '#headers' do
+    it 'returns @headers instance variable' do
+      expect(dummy.headers).to be headers
+    end
+  end
+
+  describe '#[]' do
+    it 'proxies to headers#[]' do
+      expect(headers).to receive(:[]).with(:accept)
+      dummy[:accept]
+    end
+  end
+
+  describe '#[]=' do
+    it 'proxies to headers#[]' do
+      expect(headers).to receive(:[]=).with(:accept, 'text/plain')
+      dummy[:accept] = 'text/plain'
+    end
+  end
+end

data/spec/http/headers_spec.rb

@@ -0,0 +1,417 @@
+require 'spec_helper'
+
+describe HTTP::Headers do
+  subject(:headers) { described_class.new }
+
+  it 'is Enumerable' do
+    expect(headers).to be_an Enumerable
+  end
+
+  describe '#set' do
+    it 'sets header value' do
+      headers.set 'Accept', 'application/json'
+      expect(headers['Accept']).to eq 'application/json'
+    end
+
+    it 'normalizes header name' do
+      headers.set :content_type, 'application/json'
+      expect(headers['Content-Type']).to eq 'application/json'
+    end
+
+    it 'overwrites previous value' do
+      headers.set :set_cookie, 'hoo=ray'
+      headers.set :set_cookie, 'woo=hoo'
+      expect(headers['Set-Cookie']).to eq 'woo=hoo'
+    end
+
+    it 'allows set multiple values' do
+      headers.set :set_cookie, 'hoo=ray'
+      headers.set :set_cookie, %w[hoo=ray woo=hoo]
+      expect(headers['Set-Cookie']).to eq %w[hoo=ray woo=hoo]
+    end
+  end
+
+  describe '#[]=' do
+    it 'sets header value' do
+      headers['Accept'] = 'application/json'
+      expect(headers['Accept']).to eq 'application/json'
+    end
+
+    it 'normalizes header name' do
+      headers[:content_type] = 'application/json'
+      expect(headers['Content-Type']).to eq 'application/json'
+    end
+
+    it 'overwrites previous value' do
+      headers[:set_cookie] = 'hoo=ray'
+      headers[:set_cookie] = 'woo=hoo'
+      expect(headers['Set-Cookie']).to eq 'woo=hoo'
+    end
+
+    it 'allows set multiple values' do
+      headers[:set_cookie] = 'hoo=ray'
+      headers[:set_cookie] = %w[hoo=ray woo=hoo]
+      expect(headers['Set-Cookie']).to eq %w[hoo=ray woo=hoo]
+    end
+  end
+
+  describe '#delete' do
+    before { headers.set 'Content-Type', 'application/json' }
+
+    it 'removes given header' do
+      headers.delete 'Content-Type'
+      expect(headers['Content-Type']).to be_nil
+    end
+
+    it 'normalizes header name' do
+      headers.delete :content_type
+      expect(headers['Content-Type']).to be_nil
+    end
+  end
+
+  describe '#add' do
+    it 'sets header value' do
+      headers.add 'Accept', 'application/json'
+      expect(headers['Accept']).to eq 'application/json'
+    end
+
+    it 'normalizes header name' do
+      headers.add :content_type, 'application/json'
+      expect(headers['Content-Type']).to eq 'application/json'
+    end
+
+    it 'appends new value if header exists' do
+      headers.add :set_cookie, 'hoo=ray'
+      headers.add :set_cookie, 'woo=hoo'
+      expect(headers['Set-Cookie']).to eq %w[hoo=ray woo=hoo]
+    end
+
+    it 'allows append multiple values' do
+      headers.add :set_cookie, 'hoo=ray'
+      headers.add :set_cookie, %w[woo=hoo yup=pie]
+      expect(headers['Set-Cookie']).to eq %w[hoo=ray woo=hoo yup=pie]
+    end
+  end
+
+  describe '#get' do
+    before { headers.set 'Content-Type', 'application/json' }
+
+    it 'returns array of associated values' do
+      expect(headers.get 'Content-Type').to eq %w[application/json]
+    end
+
+    it 'normalizes header name' do
+      expect(headers.get :content_type).to eq %w[application/json]
+    end
+
+    context 'when header does not exists' do
+      it 'returns empty array' do
+        expect(headers.get :accept).to eq []
+      end
+    end
+  end
+
+  describe '#[]' do
+    context 'when header does not exists' do
+      it 'returns nil' do
+        expect(headers[:accept]).to be_nil
+      end
+    end
+
+    context 'when header has a single value' do
+      before { headers.set 'Content-Type', 'application/json' }
+
+      it 'normalizes header name' do
+        expect(headers[:content_type]).to_not be_nil
+      end
+
+      it 'returns it returns a single value' do
+        expect(headers[:content_type]).to eq 'application/json'
+      end
+    end
+
+    context 'when header has a multiple values' do
+      before do
+        headers.add :set_cookie, 'hoo=ray'
+        headers.add :set_cookie, 'woo=hoo'
+      end
+
+      it 'normalizes header name' do
+        expect(headers[:set_cookie]).to_not be_nil
+      end
+
+      it 'returns array of associated values' do
+        expect(headers[:set_cookie]).to eq %w[hoo=ray woo=hoo]
+      end
+    end
+  end
+
+  describe '#to_h' do
+    before do
+      headers.add :content_type, 'application/json'
+      headers.add :set_cookie,   'hoo=ray'
+      headers.add :set_cookie,   'woo=hoo'
+    end
+
+    it 'returns a Hash' do
+      expect(headers.to_h).to be_a Hash
+    end
+
+    it 'returns Hash with normalized keys' do
+      expect(headers.to_h.keys).to match_array %w[Content-Type Set-Cookie]
+    end
+
+    context 'for a header with single value' do
+      it 'provides a value as is' do
+        expect(headers.to_h['Content-Type']).to eq 'application/json'
+      end
+    end
+
+    context 'for a header with multiple values' do
+      it 'provides an array of values' do
+        expect(headers.to_h['Set-Cookie']).to eq %w[hoo=ray woo=hoo]
+      end
+    end
+  end
+
+  describe '#to_a' do
+    before do
+      headers.add :content_type, 'application/json'
+      headers.add :set_cookie,   'hoo=ray'
+      headers.add :set_cookie,   'woo=hoo'
+    end
+
+    it 'returns an Array' do
+      expect(headers.to_a).to be_a Array
+    end
+
+    it 'returns Array of key/value pairs with normalized keys' do
+      expect(headers.to_a).to eq [
+        %w[Content-Type application/json],
+        %w[Set-Cookie hoo=ray],
+        %w[Set-Cookie woo=hoo]
+      ]
+    end
+  end
+
+  describe '#inspect' do
+    before  { headers.set :set_cookie, %w[hoo=ray woo=hoo] }
+    subject { headers.inspect }
+
+    it { should eq '#<HTTP::Headers {"Set-Cookie"=>["hoo=ray", "woo=hoo"]}>' }
+  end
+
+  describe '#keys' do
+    before do
+      headers.add :content_type, 'application/json'
+      headers.add :set_cookie,   'hoo=ray'
+      headers.add :set_cookie,   'woo=hoo'
+    end
+
+    it 'returns uniq keys only' do
+      expect(headers.keys).to have_exactly(2).items
+    end
+
+    it 'normalizes keys' do
+      expect(headers.keys).to include('Content-Type', 'Set-Cookie')
+    end
+  end
+
+  describe '#each' do
+    before do
+      headers.add :set_cookie,   'hoo=ray'
+      headers.add :content_type, 'application/json'
+      headers.add :set_cookie,   'woo=hoo'
+    end
+
+    it 'yields each key/value pair separatedly' do
+      expect { |b| headers.each(&b) }.to yield_control.exactly(3).times
+    end
+
+    it 'yields headers in the same order they were added' do
+      expect { |b| headers.each(&b) }.to yield_successive_args(
+        %w[Set-Cookie hoo=ray],
+        %w[Content-Type application/json],
+        %w[Set-Cookie woo=hoo]
+      )
+    end
+  end
+
+  describe '.empty?' do
+    subject { headers.empty? }
+
+    context 'initially' do
+      it { should be_true }
+    end
+
+    context 'when header exists' do
+      before { headers.add :accept, 'text/plain' }
+      it { should be_false }
+    end
+
+    context 'when last header was removed' do
+      before do
+        headers.add :accept, 'text/plain'
+        headers.delete :accept
+      end
+
+      it { should be_true }
+    end
+  end
+
+  describe '#hash' do
+    let(:left)  { described_class.new }
+    let(:right) { described_class.new }
+
+    it 'equals if two headers equals' do
+      left.add :accept, 'text/plain'
+      right.add :accept, 'text/plain'
+
+      expect(left.hash).to eq right.hash
+    end
+  end
+
+  describe '#==' do
+    let(:left)  { described_class.new }
+    let(:right) { described_class.new }
+
+    it 'compares header keys and values' do
+      left.add :accept, 'text/plain'
+      right.add :accept, 'text/plain'
+
+      expect(left).to eq right
+    end
+
+    it 'allows comparison with Array of key/value pairs' do
+      left.add :accept, 'text/plain'
+      expect(left).to eq [%w[Accept text/plain]]
+    end
+
+    it 'sensitive to headers order' do
+      left.add :accept, 'text/plain'
+      left.add :cookie, 'woo=hoo'
+      right.add :cookie, 'woo=hoo'
+      right.add :accept, 'text/plain'
+
+      expect(left).to_not eq right
+    end
+
+    it 'sensitive to header values order' do
+      left.add :cookie, 'hoo=ray'
+      left.add :cookie, 'woo=hoo'
+      right.add :cookie, 'woo=hoo'
+      right.add :cookie, 'hoo=ray'
+
+      expect(left).to_not eq right
+    end
+  end
+
+  describe '#dup' do
+    before { headers.set :content_type, 'application/json' }
+
+    subject(:dupped) { headers.dup }
+
+    it { should be_a described_class }
+    it { should_not be headers }
+
+    it 'has headers copied' do
+      expect(dupped[:content_type]).to eq 'application/json'
+    end
+
+    context 'modifying a copy' do
+      before { dupped.set :content_type, 'text/plain' }
+
+      it 'modifies dupped copy' do
+        expect(dupped[:content_type]).to eq 'text/plain'
+      end
+
+      it 'does not affects original headers' do
+        expect(headers[:content_type]).to eq 'application/json'
+      end
+    end
+  end
+
+  describe '#merge!' do
+    before do
+      headers.set :host, 'example.com'
+      headers.set :accept, 'application/json'
+      headers.merge! :accept => 'plain/text', :cookie => %w[hoo=ray woo=hoo]
+    end
+
+    it 'leaves headers not presented in other as is' do
+      expect(headers[:host]).to eq 'example.com'
+    end
+
+    it 'overwrites existing values' do
+      expect(headers[:accept]).to eq 'plain/text'
+    end
+
+    it 'appends other headers, not presented in base' do
+      expect(headers[:cookie]).to eq %w[hoo=ray woo=hoo]
+    end
+  end
+
+  describe '#merge' do
+    before do
+      headers.set :host, 'example.com'
+      headers.set :accept, 'application/json'
+    end
+
+    subject(:merged) do
+      headers.merge :accept => 'plain/text', :cookie => %w[hoo=ray woo=hoo]
+    end
+
+    it { should be_a described_class }
+    it { should_not be headers }
+
+    it 'does not affects original headers' do
+      expect(merged.to_h).to_not eq headers.to_h
+    end
+
+    it 'leaves headers not presented in other as is' do
+      expect(merged[:host]).to eq 'example.com'
+    end
+
+    it 'overwrites existing values' do
+      expect(merged[:accept]).to eq 'plain/text'
+    end
+
+    it 'appends other headers, not presented in base' do
+      expect(merged[:cookie]).to eq %w[hoo=ray woo=hoo]
+    end
+  end
+
+  describe '.coerce' do
+    let(:dummyClass) { Class.new { def respond_to?(*); end } }
+
+    it 'accepts any object that respond to #to_hash' do
+      hashie = double :to_hash => {'accept' => 'json'}
+      expect(described_class.coerce(hashie)['accept']).to eq 'json'
+    end
+
+    it 'accepts any object that respond to #to_h' do
+      hashie = double :to_h => {'accept' => 'json'}
+      expect(described_class.coerce(hashie)['accept']).to eq 'json'
+    end
+
+    it 'accepts any object that respond to #to_a' do
+      hashie = double :to_a => [%w[accept json]]
+      expect(described_class.coerce(hashie)['accept']).to eq 'json'
+    end
+
+    it 'fails if given object cannot be coerced' do
+      expect { described_class.coerce dummyClass.new }.to raise_error HTTP::Error
+    end
+
+    context 'with duplicate header keys (mixed case)' do
+      let(:headers) { {'Set-Cookie' => 'hoo=ray', 'set-cookie' => 'woo=hoo'} }
+
+      it 'adds all headers' do
+        expect(described_class.coerce(headers).to_a).to match_array([
+          %w[Set-Cookie hoo=ray],
+          %w[Set-Cookie woo=hoo]
+        ])
+      end
+    end
+  end
+end