rest-client 1.6.7 → 2.1.0

data/spec/integration/integration_spec.rb

@@ -0,0 +1,118 @@
+# -*- coding: utf-8 -*-
+require_relative '_lib'
+require 'base64'
+
+describe RestClient do
+
+  it "a simple request" do
+    body = 'abc'
+    stub_request(:get, "www.example.com").to_return(:body => body, :status => 200)
+    response = RestClient.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
+      RestClient.get "www.example.com"
+      raise
+    rescue RestClient::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 = RestClient.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 = RestClient.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 = RestClient.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 = RestClient.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 = RestClient.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 = RestClient.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 = RestClient.get 'www.example.com'
+      expect(response.encoding).to eq Encoding::BINARY
+    end
+  end
+end

data/spec/integration/request_spec.rb

@@ -1,25 +1,127 @@
-require File.join( File.dirname(File.expand_path(__FILE__)), '../base')
+require_relative '_lib'
 
 describe RestClient::Request do
+  before(:all) do
+    WebMock.disable!
+  end
+
+  after(:all) do
+    WebMock.enable!
+  end
+
   describe "ssl verification" do
     it "is successful with the correct ca_file" do
       request = RestClient::Request.new(
         :method => :get,
-        :url => 'https://www.mozilla.com',
-        :verify_ssl => OpenSSL::SSL::VERIFY_PEER,
-        :ssl_ca_file => File.join(File.dirname(__FILE__), "certs", "equifax.crt")
+        :url => 'https://www.mozilla.org',
+        :ssl_ca_file => File.join(File.dirname(__FILE__), "certs", "digicert.crt")
       )
       expect { request.execute }.to_not raise_error
     end
 
-    it "is unsuccessful with an incorrect ca_file" do
+    it "is successful with the correct ca_path" do
       request = RestClient::Request.new(
         :method => :get,
-        :url => 'https://www.mozilla.com',
-        :verify_ssl => OpenSSL::SSL::VERIFY_PEER,
+        :url => 'https://www.mozilla.org',
+        :ssl_ca_path => File.join(File.dirname(__FILE__), "capath_digicert")
+      )
+      expect { request.execute }.to_not raise_error
+    end
+
+    # TODO: deprecate and remove RestClient::SSLCertificateNotVerified and just
+    # pass through OpenSSL::SSL::SSLError directly. See note in
+    # lib/restclient/request.rb.
+    #
+    # 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_file", :unless => RestClient::Platform.mac_mri? do
+      request = RestClient::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(RestClient::SSLCertificateNotVerified)
     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 => RestClient::Platform.mac_mri? do
+      request = RestClient::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(RestClient::SSLCertificateNotVerified)
+    end
+
+    it "is successful using the default system cert store" do
+      request = RestClient::Request.new(
+        :method => :get,
+        :url => 'https://www.mozilla.org',
+        :verify_ssl => true,
+      )
+      expect {request.execute }.to_not raise_error
+    end
+
+    it "executes the verify_callback" do
+      ran_callback = false
+      request = RestClient::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 => RestClient::Platform.mac_mri? do
+      request = RestClient::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(RestClient::SSLCertificateNotVerified)
+    end
+
+    it "succeeds verification when the callback returns true",
+       :unless => RestClient::Platform.mac_mri? do
+      request = RestClient::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
+
+  describe "timeouts" do
+    it "raises OpenTimeout when it hits an open timeout" do
+      request = RestClient::Request.new(
+        :method => :get,
+        :url => 'http://www.mozilla.org',
+        :open_timeout => 1e-10,
+      )
+      expect { request.execute }.to(
+        raise_error(RestClient::Exceptions::OpenTimeout))
+    end
+
+    it "raises ReadTimeout when it hits a read timeout via :read_timeout" do
+      request = RestClient::Request.new(
+        :method => :get,
+        :url => 'https://www.mozilla.org',
+        :read_timeout => 1e-10,
+      )
+      expect { request.execute }.to(
+        raise_error(RestClient::Exceptions::ReadTimeout))
+    end
+  end
+
 end

data/spec/spec_helper.rb

@@ -0,0 +1,29 @@
+require 'webmock/rspec'
+require 'rest-client'
+
+require_relative './helpers'
+
+# 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.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 RestClient::AbstractResponse, :include_helpers do
+
+  # Sample class implementing AbstractResponse used for testing.
+  class MyAbstractResponse
+
+    include RestClient::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 = RestClient::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 = RestClient::AbstractResponse.beautify_headers('x' => [ 'text/html' ] )
+      expect(h.values.first).to eq 'text/html'
+    end
+
+    it 'joins multiple header values by comma' do
+      expect(RestClient::AbstractResponse.beautify_headers(
+        {'My-Header' => ['one', 'two']}
+      )).to eq({:my_header => 'one, two'})
+    end
+
+    it 'leaves set-cookie headers as array' do
+      expect(RestClient::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 RestClient::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 RestClient::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 RestClient::Found
+    end
+  end
+end

data/spec/unit/exceptions_spec.rb

@@ -0,0 +1,108 @@
+require_relative '_lib'
+
+describe RestClient::Exception do
+  it "returns a 'message' equal to the class name if the message is not set, because 'message' should not be nil" do
+    e = RestClient::Exception.new
+    expect(e.message).to eq "RestClient::Exception"
+  end
+
+  it "returns the 'message' that was set" do
+    e = RestClient::Exception.new
+    message = "An explicitly set message"
+    e.message = message
+    expect(e.message).to eq message
+  end
+
+  it "sets the exception message to ErrorMessage" do
+    expect(RestClient::ResourceNotFound.new.message).to eq 'Not Found'
+  end
+
+  it "contains exceptions in RestClient" do
+    expect(RestClient::Unauthorized.new).to be_a_kind_of(RestClient::Exception)
+    expect(RestClient::ServerBrokeConnection.new).to be_a_kind_of(RestClient::Exception)
+  end
+end
+
+describe RestClient::ServerBrokeConnection do
+  it "should have a default message of 'Server broke connection'" do
+    e = RestClient::ServerBrokeConnection.new
+    expect(e.message).to eq 'Server broke connection'
+  end
+end
+
+describe RestClient::RequestFailed do
+  before do
+    @response = double('HTTP Response', :code => '502')
+  end
+
+  it "stores the http response on the exception" do
+    response = "response"
+    begin
+      raise RestClient::RequestFailed, response
+    rescue RestClient::RequestFailed => e
+      expect(e.response).to eq response
+    end
+  end
+
+  it "http_code convenience method for fetching the code as an integer" do
+    expect(RestClient::RequestFailed.new(@response).http_code).to eq 502
+  end
+
+  it "http_body convenience method for fetching the body (decoding when necessary)" do
+    expect(RestClient::RequestFailed.new(@response).http_code).to eq 502
+    expect(RestClient::RequestFailed.new(@response).message).to eq 'HTTP status code 502'
+  end
+
+  it "shows the status code in the message" do
+    expect(RestClient::RequestFailed.new(@response).to_s).to match(/502/)
+  end
+end
+
+describe RestClient::ResourceNotFound do
+  it "also has the http response attached" do
+    response = "response"
+    begin
+      raise RestClient::ResourceNotFound, response
+    rescue RestClient::ResourceNotFound => e
+      expect(e.response).to eq response
+    end
+  end
+
+  it 'stores the body on the response of the exception' do
+    body = "body"
+    stub_request(:get, "www.example.com").to_return(:body => body, :status => 404)
+    begin
+      RestClient.get "www.example.com"
+      raise
+    rescue RestClient::ResourceNotFound => e
+      expect(e.response.body).to eq body
+    end
+  end
+end
+
+describe "backwards compatibility" do
+  it 'aliases RestClient::NotFound as ResourceNotFound' do
+    expect(RestClient::ResourceNotFound).to eq RestClient::NotFound
+  end
+
+  it 'aliases old names for HTTP 413, 414, 416' do
+    expect(RestClient::RequestEntityTooLarge).to eq RestClient::PayloadTooLarge
+    expect(RestClient::RequestURITooLong).to eq RestClient::URITooLong
+    expect(RestClient::RequestedRangeNotSatisfiable).to eq RestClient::RangeNotSatisfiable
+  end
+
+  it 'subclasses NotFound from RequestFailed, ExceptionWithResponse' do
+    expect(RestClient::NotFound).to be < RestClient::RequestFailed
+    expect(RestClient::NotFound).to be < RestClient::ExceptionWithResponse
+  end
+
+  it 'subclasses timeout from RestClient::RequestTimeout, RequestFailed, EWR' do
+    expect(RestClient::Exceptions::OpenTimeout).to be < RestClient::Exceptions::Timeout
+    expect(RestClient::Exceptions::ReadTimeout).to be < RestClient::Exceptions::Timeout
+
+    expect(RestClient::Exceptions::Timeout).to be < RestClient::RequestTimeout
+    expect(RestClient::Exceptions::Timeout).to be < RestClient::RequestFailed
+    expect(RestClient::Exceptions::Timeout).to be < RestClient::ExceptionWithResponse
+  end
+
+end