rest-man 1.0.0

data/spec/integration/certs/digicert.crt

@@ -0,0 +1,20 @@
+-----BEGIN CERTIFICATE-----
+MIIDQTCCAimgAwIBAgITBmyfz5m/jAo54vB4ikPmljZbyjANBgkqhkiG9w0BAQsF
+ADA5MQswCQYDVQQGEwJVUzEPMA0GA1UEChMGQW1hem9uMRkwFwYDVQQDExBBbWF6
+b24gUm9vdCBDQSAxMB4XDTE1MDUyNjAwMDAwMFoXDTM4MDExNzAwMDAwMFowOTEL
+MAkGA1UEBhMCVVMxDzANBgNVBAoTBkFtYXpvbjEZMBcGA1UEAxMQQW1hem9uIFJv
+b3QgQ0EgMTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBALJ4gHHKeNXj
+ca9HgFB0fW7Y14h29Jlo91ghYPl0hAEvrAIthtOgQ3pOsqTQNroBvo3bSMgHFzZM
+9O6II8c+6zf1tRn4SWiw3te5djgdYZ6k/oI2peVKVuRF4fn9tBb6dNqcmzU5L/qw
+IFAGbHrQgLKm+a/sRxmPUDgH3KKHOVj4utWp+UhnMJbulHheb4mjUcAwhmahRWa6
+VOujw5H5SNz/0egwLX0tdHA114gk957EWW67c4cX8jJGKLhD+rcdqsq08p8kDi1L
+93FcXmn/6pUCyziKrlA4b9v7LWIbxcceVOF34GfID5yHI9Y/QCB/IIDEgEw+OyQm
+jgSubJrIqg0CAwEAAaNCMEAwDwYDVR0TAQH/BAUwAwEB/zAOBgNVHQ8BAf8EBAMC
+AYYwHQYDVR0OBBYEFIQYzIU07LwMlJQuCFmcx7IQTgoIMA0GCSqGSIb3DQEBCwUA
+A4IBAQCY8jdaQZChGsV2USggNiMOruYou6r4lK5IpDB/G/wkjUu0yKGX9rbxenDI
+U5PMCCjjmCXPI6T53iHTfIUJrU6adTrCC2qJeHZERxhlbI1Bjjt/msv0tadQ1wUs
+N+gDS63pYaACbvXy8MWy7Vu33PqUXHeeE6V/Uq2V8viTO96LXFvKWlJbYK8U90vv
+o/ufQJVtMVT8QtPHRh8jrdkPSHCa2XV4cdFyQzR1bldZwgJcJmApzyMZFo6IQ6XU
+5MsI+yMRQ+hDKXJioaldXgjUkK642M4UwtBV8ob2xJNDd2ZhwLnoQdeXeGADbkpy
+rqXRfboQnoZsG4q5WTP468SQvvG5
+-----END CERTIFICATE-----

data/spec/integration/certs/verisign.crt

@@ -0,0 +1,14 @@
+-----BEGIN CERTIFICATE-----
+MIICPDCCAaUCEHC65B0Q2Sk0tjjKewPMur8wDQYJKoZIhvcNAQECBQAwXzELMAkG
+A1UEBhMCVVMxFzAVBgNVBAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFz
+cyAzIFB1YmxpYyBQcmltYXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MB4XDTk2
+MDEyOTAwMDAwMFoXDTI4MDgwMTIzNTk1OVowXzELMAkGA1UEBhMCVVMxFzAVBgNV
+BAoTDlZlcmlTaWduLCBJbmMuMTcwNQYDVQQLEy5DbGFzcyAzIFB1YmxpYyBQcmlt
+YXJ5IENlcnRpZmljYXRpb24gQXV0aG9yaXR5MIGfMA0GCSqGSIb3DQEBAQUAA4GN
+ADCBiQKBgQDJXFme8huKARS0EN8EQNvjV69qRUCPhAwL0TPZ2RHP7gJYHyX3KqhE
+BarsAx94f56TuZoAqiN91qyFomNFx3InzPRMxnVx0jnvT0Lwdd8KkMaOIG+YD/is
+I19wKTakyYbnsZogy1Olhec9vn2a/iRFM9x2Fe0PonFkTGUugWhFpwIDAQABMA0G
+CSqGSIb3DQEBAgUAA4GBALtMEivPLCYATxQT3ab7/AoRhIzzKBxnki98tsX63/Do
+lbwdj2wsqFHMc9ikwFPwTtYmwHYBV4GSXiHx0bH/59AhWM1pF+NEHJwZRDmJXNyc
+AA9WjQKZ7aKQRUzkuxCkPfAyAw7xzvjoyVGM5mKf5p/AfbdynMk2OmufTqj/ZA1k
+-----END CERTIFICATE-----

data/spec/integration/httpbin_spec.rb

@@ -0,0 +1,137 @@
+require_relative '_lib'
+require 'json'
+
+require 'zlib'
+
+describe RestMan::Request do
+
+  def default_httpbin_url
+    # add a hack to work around java/jruby bug
+    # java.lang.RuntimeException: Could not generate DH keypair with backtrace
+    # Also (2017-04-09) Travis Jruby versions have a broken CA keystore
+    if ENV['TRAVIS_RUBY_VERSION'] =~ /\Ajruby-/
+      'http://httpbin.org/'
+    else
+      'https://httpbin.org/'
+    end
+  end
+
+  def httpbin(suffix='')
+    url = ENV.fetch('HTTPBIN_URL', default_httpbin_url)
+    unless url.end_with?('/')
+      url += '/'
+    end
+
+    url + suffix
+  end
+
+  def execute_httpbin(suffix, opts={})
+    opts = {url: httpbin(suffix)}.merge(opts)
+    RestMan::Request.execute(opts)
+  end
+
+  def execute_httpbin_json(suffix, opts={})
+    JSON.parse(execute_httpbin(suffix, opts))
+  end
+
+  describe '.execute' do
+    it 'sends a user agent' do
+      VCR.use_cassette("request_httpbin_with_user_agent") do
+        data = execute_httpbin_json('user-agent', method: :get)
+        expect(data['user-agent']).to match(/rest-man/)
+      end
+    end
+
+    it 'receives cookies on 302' do
+      VCR.use_cassette("request_httpbin_with_cookies") do
+        expect {
+          execute_httpbin('cookies/set?foo=bar', method: :get, max_redirects: 0)
+        }.to raise_error(RestMan::Found) { |ex|
+          expect(ex.http_code).to eq 302
+          expect(ex.response.cookies['foo']).to eq 'bar'
+        }
+      end
+    end
+
+    it 'passes along cookies through 302' do
+      VCR.use_cassette("request_httpbin_with_cookies_2") do
+        data = execute_httpbin_json('cookies/set?foo=bar', method: :get)
+        expect(data).to have_key('cookies')
+        expect(data['cookies']['foo']).to eq 'bar'
+      end
+    end
+
+    it 'handles quote wrapped cookies' do
+      VCR.use_cassette("request_httpbin_with_cookies_3") do
+        expect {
+          execute_httpbin('cookies/set?foo=' + CGI.escape('"bar:baz"'),
+                          method: :get, max_redirects: 0)
+        }.to raise_error(RestMan::Found) { |ex|
+          expect(ex.http_code).to eq 302
+          expect(ex.response.cookies['foo']).to eq '"bar:baz"'
+        }
+      end
+    end
+
+    it 'sends basic auth' do
+      VCR.use_cassette("request_httpbin_with_basic_auth") do
+        user = 'user'
+        pass = 'pass'
+
+        data = execute_httpbin_json("basic-auth/#{user}/#{pass}", method: :get, user: user, password: pass)
+        expect(data).to eq({'authenticated' => true, 'user' => user})
+
+        expect {
+          execute_httpbin_json("basic-auth/#{user}/#{pass}", method: :get, user: user, password: 'badpass')
+        }.to raise_error(RestMan::Unauthorized) { |ex|
+          expect(ex.http_code).to eq 401
+        }
+      end
+    end
+
+    it 'handles gzipped/deflated responses' do
+      [['gzip', 'gzipped'], ['deflate', 'deflated']].each do |encoding, var|
+        VCR.use_cassette("request_httpbin_with_encoding_#{encoding}") do
+          raw = execute_httpbin(encoding, method: :get)
+
+          begin
+            data = JSON.parse(raw)
+          rescue StandardError
+            puts "Failed to parse: " + raw.inspect
+            raise
+          end
+
+          expect(data['method']).to eq 'GET'
+          expect(data.fetch(var)).to be true
+        end
+      end
+    end
+
+    it 'does not uncompress response when accept-encoding is set' do
+      VCR.use_cassette("request_httpbin_with_encoding_gzip_and_accept_headers") do
+        # == gzip ==
+        raw = execute_httpbin('gzip', method: :get, headers: {accept_encoding: 'gzip, deflate'})
+
+        # check for gzip magic number
+        expect(raw.body).to start_with("\x1F\x8B".b)
+
+        decoded = Zlib::GzipReader.new(StringIO.new(raw.body)).read
+        parsed = JSON.parse(decoded)
+
+        expect(parsed['method']).to eq 'GET'
+        expect(parsed.fetch('gzipped')).to be true
+      end
+
+      VCR.use_cassette("request_httpbin_with_encoding_deflate_and_accept_headers") do
+        # == delate ==
+        raw = execute_httpbin('deflate', method: :get, headers: {accept_encoding: 'gzip, deflate'})
+
+        decoded = Zlib::Inflate.new.inflate(raw.body)
+        parsed = JSON.parse(decoded)
+
+        expect(parsed['method']).to eq 'GET'
+        expect(parsed.fetch('deflated')).to be true
+      end
+    end
+  end
+end

data/spec/integration/integration_spec.rb

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+require_relative '_lib'
+require 'base64'
+
+describe RestMan do
+
+  it "a simple request" do
+    body = 'abc'
+    stub_request(:get, "www.example.com").to_return(:body => body, :status => 200)
+    response = RestMan.get "www.example.com"
+    expect(response.code).to eq 200
+    expect(response.body).to eq body
+  end
+
+  it "a 404" do
+    body = "Ho hai ! I'm not here !"
+    stub_request(:get, "www.example.com").to_return(:body => body, :status => 404)
+    begin
+      RestMan.get "www.example.com"
+      raise
+    rescue RestMan::ResourceNotFound => e
+      expect(e.http_code).to eq 404
+      expect(e.response.code).to eq 404
+      expect(e.response.body).to eq body
+      expect(e.http_body).to eq body
+    end
+  end
+
+  describe 'charset parsing' do
+    it 'handles utf-8' do
+      body = "λ".force_encoding('ASCII-8BIT')
+      stub_request(:get, "www.example.com").to_return(
+        :body => body, :status => 200, :headers => {
+          'Content-Type' => 'text/plain; charset=UTF-8'
+      })
+      response = RestMan.get "www.example.com"
+      expect(response.encoding).to eq Encoding::UTF_8
+      expect(response.valid_encoding?).to eq true
+    end
+
+    it 'handles windows-1252' do
+      body = "\xff".force_encoding('ASCII-8BIT')
+      stub_request(:get, "www.example.com").to_return(
+        :body => body, :status => 200, :headers => {
+          'Content-Type' => 'text/plain; charset=windows-1252'
+      })
+      response = RestMan.get "www.example.com"
+      expect(response.encoding).to eq Encoding::WINDOWS_1252
+      expect(response.encode('utf-8')).to eq "ÿ"
+      expect(response.valid_encoding?).to eq true
+    end
+
+    it 'handles binary' do
+      body = "\xfe".force_encoding('ASCII-8BIT')
+      stub_request(:get, "www.example.com").to_return(
+        :body => body, :status => 200, :headers => {
+          'Content-Type' => 'application/octet-stream; charset=binary'
+      })
+      response = RestMan.get "www.example.com"
+      expect(response.encoding).to eq Encoding::BINARY
+      expect {
+        response.encode('utf-8')
+      }.to raise_error(Encoding::UndefinedConversionError)
+      expect(response.valid_encoding?).to eq true
+    end
+
+    it 'handles euc-jp' do
+      body = "\xA4\xA2\xA4\xA4\xA4\xA6\xA4\xA8\xA4\xAA".
+        force_encoding(Encoding::BINARY)
+      body_utf8 = 'あいうえお'
+      expect(body_utf8.encoding).to eq Encoding::UTF_8
+
+      stub_request(:get, 'www.example.com').to_return(
+        :body => body, :status => 200, :headers => {
+          'Content-Type' => 'text/plain; charset=EUC-JP'
+      })
+      response = RestMan.get 'www.example.com'
+      expect(response.encoding).to eq Encoding::EUC_JP
+      expect(response.valid_encoding?).to eq true
+      expect(response.length).to eq 5
+      expect(response.encode('utf-8')).to eq body_utf8
+    end
+
+    it 'defaults to the default encoding' do
+      stub_request(:get, 'www.example.com').to_return(
+        body: 'abc', status: 200, headers: {
+          'Content-Type' => 'text/plain'
+        })
+
+      response = RestMan.get 'www.example.com'
+      # expect(response.encoding).to eq Encoding.default_external
+      expect(response.encoding).to eq Encoding::UTF_8
+    end
+
+    it 'handles invalid encoding' do
+      stub_request(:get, 'www.example.com').to_return(
+        body: 'abc', status: 200, headers: {
+          'Content-Type' => 'text; charset=plain'
+        })
+
+      response = RestMan.get 'www.example.com'
+      # expect(response.encoding).to eq Encoding.default_external
+      expect(response.encoding).to eq Encoding::UTF_8
+    end
+
+    it 'leaves images as binary' do
+      gif = Base64.strict_decode64('R0lGODlhAQABAAAAADs=')
+
+      stub_request(:get, 'www.example.com').to_return(
+        body: gif, status: 200, headers: {
+          'Content-Type' => 'image/gif'
+        })
+
+      response = RestMan.get 'www.example.com'
+      expect(response.encoding).to eq Encoding::BINARY
+    end
+  end
+end

data/spec/integration/request_spec.rb

@@ -0,0 +1,134 @@
+require_relative '_lib'
+
+describe RestMan::Request do
+
+  describe "ssl verification" do
+    it "is successful with the correct ca_file" do
+      VCR.use_cassette('request_mozilla_org') do
+        request = RestMan::Request.new(
+          :method => :get,
+          :url => 'https://www.mozilla.org',
+          :ssl_ca_file => File.join(File.dirname(__FILE__), "certs", "digicert.crt")
+        )
+        expect { request.execute }.to_not raise_error
+      end
+    end
+
+    it "is successful with the correct ca_path" do
+      VCR.use_cassette('request_mozilla_org') do
+        request = RestMan::Request.new(
+          :method => :get,
+          :url => 'https://www.mozilla.org',
+          :ssl_ca_path => File.join(File.dirname(__FILE__), "capath_digicert")
+        )
+        expect { request.execute }.to_not raise_error
+      end
+    end
+
+    it "is unsuccessful with an incorrect ca_file", :unless => RestMan::Platform.mac_mri? do
+      VCR.use_cassette('request_mozilla_org_with_incorrect_ca_file') do
+        request = RestMan::Request.new(
+          :method => :get,
+          :url => 'https://www.mozilla.org',
+          :ssl_ca_file => File.join(File.dirname(__FILE__), "certs", "verisign.crt")
+        )
+        expect { request.execute }.to raise_error(OpenSSL::SSL::SSLError)
+      end
+    end
+
+    # On OS X, this test fails since Apple has patched OpenSSL to always fall
+    # back on the system CA store.
+    it "is unsuccessful with an incorrect ca_path", :unless => RestMan::Platform.mac_mri? do
+      VCR.use_cassette('request_mozilla_org_with_incorrect_ca_path') do
+        request = RestMan::Request.new(
+          :method => :get,
+          :url => 'https://www.mozilla.org',
+          :ssl_ca_path => File.join(File.dirname(__FILE__), "capath_verisign")
+        )
+        expect { request.execute }.to raise_error(OpenSSL::SSL::SSLError)
+      end
+    end
+
+    it "is successful using the default system cert store" do
+      VCR.use_cassette('request_mozilla_org_with_system_cert') do
+        request = RestMan::Request.new(
+          :method => :get,
+          :url => 'https://www.mozilla.org',
+          :verify_ssl => true,
+        )
+        expect {request.execute }.to_not raise_error
+      end
+    end
+
+
+    # verify_callback is not works well with VCR
+    # it "executes the verify_callback", focus: true do
+    #   ran_callback = false
+    #   request = RestMan::Request.new(
+    #     :method => :get,
+    #     :url => 'https://www.mozilla.org',
+    #     :verify_ssl => true,
+    #     :ssl_verify_callback => lambda { |preverify_ok, store_ctx|
+    #       ran_callback = true
+    #       preverify_ok
+    #     },
+    #   )
+    #   expect {request.execute }.to_not raise_error
+    #   expect(ran_callback).to eq(true)
+    # end
+
+    it "fails verification when the callback returns false",
+       :unless => RestMan::Platform.mac_mri? do
+      VCR.use_cassette('request_mozilla_org_callback_returns_false') do
+        request = RestMan::Request.new(
+          :method => :get,
+          :url => 'https://www.mozilla.org',
+          :verify_ssl => true,
+          :ssl_verify_callback => lambda { |preverify_ok, store_ctx| false },
+        )
+        expect { request.execute }.to raise_error(OpenSSL::SSL::SSLError)
+      end
+    end
+
+    it "succeeds verification when the callback returns true",
+       :unless => RestMan::Platform.mac_mri? do
+      VCR.use_cassette('request_mozilla_org_callback_returns_true') do
+        request = RestMan::Request.new(
+          :method => :get,
+          :url => 'https://www.mozilla.org',
+          :verify_ssl => true,
+          :ssl_ca_file => File.join(File.dirname(__FILE__), "certs", "verisign.crt"),
+          :ssl_verify_callback => lambda { |preverify_ok, store_ctx| true },
+        )
+        expect { request.execute }.to_not raise_error
+      end
+    end
+  end
+
+  describe "timeouts" do
+    it "raises OpenTimeout when it hits an open timeout" do
+      allow_any_instance_of(Net::HTTP).to receive(:request).and_raise(Net::OpenTimeout.new)
+
+      request = RestMan::Request.new(
+        :method => :get,
+        :url => 'http://www.mozilla.org',
+        :open_timeout => 1e-10,
+      )
+      expect { request.execute }.to(
+        raise_error(RestMan::Exceptions::OpenTimeout))
+    end
+
+    it "raises ReadTimeout when it hits a read timeout via :read_timeout" do
+      allow_any_instance_of(Net::HTTP).to receive(:request).and_raise(Net::ReadTimeout.new)
+
+      request = RestMan::Request.new(
+        :method => :get,
+        :url => 'https://www.mozilla.org',
+        :read_timeout => 1e-10,
+      )
+      expect { request.execute }.to(
+        raise_error(RestMan::Exceptions::ReadTimeout))
+    end
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,40 @@
+require 'webmock/rspec'
+require 'rest-man'
+
+require_relative './helpers'
+require 'byebug' unless RUBY_PLATFORM == 'java'
+require 'ruby-debug' if RUBY_PLATFORM == 'java'
+require 'vcr'
+
+VCR.configure do |config|
+  config.default_cassette_options = { match_requests_on: %i[uri method] }
+  config.cassette_library_dir = 'spec/cassettes'
+  config.hook_into :webmock
+end
+
+# See http://rubydoc.info/gems/rspec-core/RSpec/Core/Configuration
+RSpec.configure do |config|
+  config.raise_errors_for_deprecations!
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+
+  # always run with ruby warnings enabled
+  # TODO: figure out why this is so obscenely noisy (rspec bug?)
+  # config.warnings = true
+
+  # add helpers
+  config.include Helpers, :include_helpers
+
+  config.filter_run_when_matching :focus
+
+  config.mock_with :rspec do |mocks|
+    mocks.yield_receiver_to_any_instance_implementation_blocks = true
+  end
+end
+
+# always run with ruby warnings enabled (see above)
+$VERBOSE = true

data/spec/unit/_lib.rb

@@ -0,0 +1 @@
+require_relative '../spec_helper'

data/spec/unit/abstract_response_spec.rb

@@ -0,0 +1,145 @@
+require_relative '_lib'
+
+describe RestMan::AbstractResponse, :include_helpers do
+
+  # Sample class implementing AbstractResponse used for testing.
+  class MyAbstractResponse
+
+    include RestMan::AbstractResponse
+
+    attr_accessor :size
+
+    def initialize(net_http_res, request)
+      response_set_vars(net_http_res, request, Time.now - 1)
+    end
+
+  end
+
+  before do
+    @net_http_res = res_double()
+    @request = request_double(url: 'http://example.com', method: 'get')
+    @response = MyAbstractResponse.new(@net_http_res, @request)
+  end
+
+  it "fetches the numeric response code" do
+    expect(@net_http_res).to receive(:code).and_return('200')
+    expect(@response.code).to eq 200
+  end
+
+  it "has a nice description" do
+    expect(@net_http_res).to receive(:to_hash).and_return({'Content-Type' => ['application/pdf']})
+    expect(@net_http_res).to receive(:code).and_return('200')
+    expect(@response.description).to eq "200 OK | application/pdf  bytes\n"
+  end
+
+  describe '.beautify_headers' do
+    it "beautifies the headers by turning the keys to symbols" do
+      h = RestMan::AbstractResponse.beautify_headers('content-type' => [ 'x' ])
+      expect(h.keys.first).to eq :content_type
+    end
+
+    it "beautifies the headers by turning the values to strings instead of one-element arrays" do
+      h = RestMan::AbstractResponse.beautify_headers('x' => [ 'text/html' ] )
+      expect(h.values.first).to eq 'text/html'
+    end
+
+    it 'joins multiple header values by comma' do
+      expect(RestMan::AbstractResponse.beautify_headers(
+        {'My-Header' => ['one', 'two']}
+      )).to eq({:my_header => 'one, two'})
+    end
+
+    it 'leaves set-cookie headers as array' do
+      expect(RestMan::AbstractResponse.beautify_headers(
+        {'Set-Cookie' => ['cookie1=foo', 'cookie2=bar']}
+      )).to eq({:set_cookie => ['cookie1=foo', 'cookie2=bar']})
+    end
+  end
+
+  it "fetches the headers" do
+    expect(@net_http_res).to receive(:to_hash).and_return('content-type' => [ 'text/html' ])
+    expect(@response.headers).to eq({ :content_type => 'text/html' })
+  end
+
+  it "extracts cookies from response headers" do
+    expect(@net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
+    expect(@response.cookies).to eq({ 'session_id' => '1' })
+  end
+
+  it "extract strange cookies" do
+    expect(@net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=ZJ/HQVH6YE+rVkTpn0zvTQ==; path=/'])
+    expect(@response.headers).to eq({:set_cookie => ['session_id=ZJ/HQVH6YE+rVkTpn0zvTQ==; path=/']})
+    expect(@response.cookies).to eq({ 'session_id' => 'ZJ/HQVH6YE+rVkTpn0zvTQ==' })
+  end
+
+  it "doesn't escape cookies" do
+    expect(@net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=BAh7BzoNYXBwX25hbWUiEGFwcGxpY2F0aW9uOgpsb2dpbiIKYWRtaW4%3D%0A--08114ba654f17c04d20dcc5228ec672508f738ca; path=/'])
+    expect(@response.cookies).to eq({ 'session_id' => 'BAh7BzoNYXBwX25hbWUiEGFwcGxpY2F0aW9uOgpsb2dpbiIKYWRtaW4%3D%0A--08114ba654f17c04d20dcc5228ec672508f738ca' })
+  end
+
+  describe '.cookie_jar' do
+    it 'extracts cookies into cookie jar' do
+      expect(@net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
+      expect(@response.cookie_jar).to be_a HTTP::CookieJar
+
+      cookie = @response.cookie_jar.cookies.first
+      expect(cookie.domain).to eq 'example.com'
+      expect(cookie.name).to eq 'session_id'
+      expect(cookie.value).to eq '1'
+      expect(cookie.path).to eq '/'
+    end
+
+    it 'handles cookies when URI scheme is implicit' do
+      net_http_res = double('net http response')
+      expect(net_http_res).to receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
+      request = double('request', url: 'example.com', uri: URI.parse('http://example.com'),
+                       method: 'get', cookie_jar: HTTP::CookieJar.new, redirection_history: nil)
+      response = MyAbstractResponse.new(net_http_res, request)
+      expect(response.cookie_jar).to be_a HTTP::CookieJar
+
+      cookie = response.cookie_jar.cookies.first
+      expect(cookie.domain).to eq 'example.com'
+      expect(cookie.name).to eq 'session_id'
+      expect(cookie.value).to eq '1'
+      expect(cookie.path).to eq '/'
+    end
+  end
+
+  it "can access the net http result directly" do
+    expect(@response.net_http_res).to eq @net_http_res
+  end
+
+  describe "#return!" do
+    it "should return the response itself on 200-codes" do
+      expect(@net_http_res).to receive(:code).and_return('200')
+      expect(@response.return!).to be_equal(@response)
+    end
+
+    it "should raise RequestFailed on unknown codes" do
+      expect(@net_http_res).to receive(:code).and_return('1000')
+      expect { @response.return! }.to raise_error RestMan::RequestFailed
+    end
+
+    it "should raise an error on a redirection after non-GET/HEAD requests" do
+      expect(@net_http_res).to receive(:code).and_return('301')
+      expect(@request).to receive(:method).and_return('put')
+      expect(@response).not_to receive(:follow_redirection)
+      expect { @response.return! }.to raise_error RestMan::RequestFailed
+    end
+
+    it "should follow 302 redirect" do
+      expect(@net_http_res).to receive(:code).and_return('302')
+      expect(@response).to receive(:check_max_redirects).and_return('fake-check')
+      expect(@response).to receive(:follow_redirection).and_return('fake-redirection')
+      expect(@response.return!).to eq 'fake-redirection'
+    end
+
+    it "should gracefully handle 302 redirect with no location header" do
+      @net_http_res = res_double(code: 302)
+      @request = request_double()
+      @response = MyAbstractResponse.new(@net_http_res, @request)
+      expect(@response).to receive(:check_max_redirects).and_return('fake-check')
+      expect { @response.return! }.to raise_error RestMan::Found
+    end
+  end
+end