rest-client 1.6.14 → 2.0.2

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
+
+  class MyAbstractResponse
+
+    include RestClient::AbstractResponse
+
+    attr_accessor :size
+
+    def initialize net_http_res, request
+      @net_http_res = net_http_res
+      @request = request
+    end
+
+  end
+
+  before do
+    @net_http_res = double('net http response')
+    @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(url: 'example.com', uri: URI.parse('http://example.com'),
+                       method: 'get', cookie_jar: HTTP::CookieJar.new)
+      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 = response_double(code: 302, location: nil)
+      @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

data/spec/unit/params_array_spec.rb

@@ -0,0 +1,36 @@
+require_relative '_lib'
+
+describe RestClient::ParamsArray do
+
+  describe '.new' do
+    it 'accepts various types of containers' do
+      as_array = [[:foo, 123], [:foo, 456], [:bar, 789], [:empty, nil]]
+      [
+        [[:foo, 123], [:foo, 456], [:bar, 789], [:empty, nil]],
+        [{foo: 123}, {foo: 456}, {bar: 789}, {empty: nil}],
+        [{foo: 123}, {foo: 456}, {bar: 789}, {empty: nil}],
+        [{foo: 123}, [:foo, 456], {bar: 789}, {empty: nil}],
+        [{foo: 123}, [:foo, 456], {bar: 789}, [:empty]],
+      ].each do |input|
+        expect(RestClient::ParamsArray.new(input).to_a).to eq as_array
+      end
+
+      expect(RestClient::ParamsArray.new([]).to_a).to eq []
+      expect(RestClient::ParamsArray.new([]).empty?).to eq true
+    end
+
+    it 'rejects various invalid input' do
+      expect {
+        RestClient::ParamsArray.new([[]])
+      }.to raise_error(IndexError)
+
+      expect {
+        RestClient::ParamsArray.new([[1,2,3]])
+      }.to raise_error(ArgumentError)
+
+      expect {
+        RestClient::ParamsArray.new([1,2,3])
+      }.to raise_error(NoMethodError)
+    end
+  end
+end

data/spec/{payload_spec.rb → unit/payload_spec.rb}

@@ -1,59 +1,68 @@
 # encoding: binary
-require File.join(File.dirname(File.expand_path(__FILE__)), 'base')
+
+require_relative '_lib'
 
 describe RestClient::Payload do
+  context "Base Payload" do
+    it "should reset stream after to_s" do
+      payload = RestClient::Payload::Base.new('foobar')
+      expect(payload.to_s).to eq 'foobar'
+      expect(payload.to_s).to eq 'foobar'
+    end
+  end
+
   context "A regular Payload" do
     it "should use standard enctype as default content-type" do
-      RestClient::Payload::UrlEncoded.new({}).headers['Content-Type'].
-          should eq 'application/x-www-form-urlencoded'
+      expect(RestClient::Payload::UrlEncoded.new({}).headers['Content-Type']).
+        to eq 'application/x-www-form-urlencoded'
     end
 
     it "should form properly encoded params" do
-      RestClient::Payload::UrlEncoded.new({:foo => 'bar'}).to_s.
-          should eq "foo=bar"
-      ["foo=bar&baz=qux", "baz=qux&foo=bar"].should include(
+      expect(RestClient::Payload::UrlEncoded.new({:foo => 'bar'}).to_s).
+        to eq "foo=bar"
+      expect(["foo=bar&baz=qux", "baz=qux&foo=bar"]).to include(
                                                         RestClient::Payload::UrlEncoded.new({:foo => 'bar', :baz => 'qux'}).to_s)
     end
 
     it "should escape parameters" do
-      RestClient::Payload::UrlEncoded.new({'foo ' => 'bar'}).to_s.
-          should eq "foo%20=bar"
+      expect(RestClient::Payload::UrlEncoded.new({'foo + bar' => 'baz'}).to_s).
+        to eq "foo+%2B+bar=baz"
     end
 
     it "should properly handle hashes as parameter" do
-      RestClient::Payload::UrlEncoded.new({:foo => {:bar => 'baz'}}).to_s.
-          should eq "foo[bar]=baz"
-      RestClient::Payload::UrlEncoded.new({:foo => {:bar => {:baz => 'qux'}}}).to_s.
-          should eq "foo[bar][baz]=qux"
+      expect(RestClient::Payload::UrlEncoded.new({:foo => {:bar => 'baz'}}).to_s).
+        to eq "foo[bar]=baz"
+      expect(RestClient::Payload::UrlEncoded.new({:foo => {:bar => {:baz => 'qux'}}}).to_s).
+        to eq "foo[bar][baz]=qux"
     end
 
     it "should handle many attributes inside a hash" do
       parameters = RestClient::Payload::UrlEncoded.new({:foo => {:bar => 'baz', :baz => 'qux'}}).to_s
-      parameters.should include("foo[bar]=baz", "foo[baz]=qux")
+      expect(parameters).to eq 'foo[bar]=baz&foo[baz]=qux'
     end
 
-    it "should handle attributes inside a an array inside an hash" do
+    it "should handle attributes inside an array inside an hash" do
       parameters = RestClient::Payload::UrlEncoded.new({"foo" => [{"bar" => 'baz'}, {"bar" => 'qux'}]}).to_s
-      parameters.should include("foo[bar]=baz", "foo[bar]=qux")
+      expect(parameters).to eq 'foo[][bar]=baz&foo[][bar]=qux'
     end
 
-    it "should handle attributes inside a an array inside an array inside an hash" do
-      parameters = RestClient::Payload::UrlEncoded.new({"foo" => [[{"bar" => 'baz'}, {"bar" => 'qux'}]]}).to_s
-      parameters.should include("foo[bar]=baz", "foo[bar]=qux")
+    it "should handle arrays inside a hash inside a hash" do
+      parameters = RestClient::Payload::UrlEncoded.new({"foo" => {'even' => [0, 2], 'odd' => [1, 3]}}).to_s
+      expect(parameters).to eq 'foo[even][]=0&foo[even][]=2&foo[odd][]=1&foo[odd][]=3'
     end
 
     it "should form properly use symbols as parameters" do
-      RestClient::Payload::UrlEncoded.new({:foo => :bar}).to_s.
-          should eq "foo=bar"
-      RestClient::Payload::UrlEncoded.new({:foo => {:bar => :baz}}).to_s.
-          should eq "foo[bar]=baz"
+      expect(RestClient::Payload::UrlEncoded.new({:foo => :bar}).to_s).
+        to eq "foo=bar"
+      expect(RestClient::Payload::UrlEncoded.new({:foo => {:bar => :baz}}).to_s).
+        to eq "foo[bar]=baz"
     end
 
     it "should properly handle arrays as repeated parameters" do
-      RestClient::Payload::UrlEncoded.new({:foo => ['bar']}).to_s.
-          should eq "foo[]=bar"
-      RestClient::Payload::UrlEncoded.new({:foo => ['bar', 'baz']}).to_s.
-          should eq "foo[]=bar&foo[]=baz"
+      expect(RestClient::Payload::UrlEncoded.new({:foo => ['bar']}).to_s).
+        to eq "foo[]=bar"
+      expect(RestClient::Payload::UrlEncoded.new({:foo => ['bar', 'baz']}).to_s).
+        to eq "foo[]=bar&foo[]=baz"
     end
 
     it 'should not close if stream already closed' do
@@ -66,8 +75,8 @@ describe RestClient::Payload do
   context "A multipart Payload" do
     it "should use standard enctype as default content-type" do
       m = RestClient::Payload::Multipart.new({})
-      m.stub(:boundary).and_return(123)
-      m.headers['Content-Type'].should eq 'multipart/form-data; boundary=123'
+      allow(m).to receive(:boundary).and_return(123)
+      expect(m.headers['Content-Type']).to eq 'multipart/form-data; boundary=123'
     end
 
     it 'should not error on close if stream already closed' do
@@ -77,7 +86,7 @@ describe RestClient::Payload do
 
     it "should form properly separated multipart data" do
       m = RestClient::Payload::Multipart.new([[:bar, "baz"], [:foo, "bar"]])
-      m.to_s.should eq <<-EOS
+      expect(m.to_s).to eq <<-EOS
 --#{m.boundary}\r
 Content-Disposition: form-data; name="bar"\r
 \r
@@ -92,7 +101,7 @@ bar\r
 
     it "should not escape parameters names" do
       m = RestClient::Payload::Multipart.new([["bar ", "baz"]])
-      m.to_s.should eq <<-EOS
+      expect(m.to_s).to eq <<-EOS
 --#{m.boundary}\r
 Content-Disposition: form-data; name="bar "\r
 \r
@@ -104,7 +113,7 @@ baz\r
     it "should form properly separated multipart data" do
       f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
       m = RestClient::Payload::Multipart.new({:foo => f})
-      m.to_s.should eq <<-EOS
+      expect(m.to_s).to eq <<-EOS
 --#{m.boundary}\r
 Content-Disposition: form-data; name="foo"; filename="master_shake.jpg"\r
 Content-Type: image/jpeg\r
@@ -117,7 +126,7 @@ Content-Type: image/jpeg\r
     it "should ignore the name attribute when it's not set" do
       f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
       m = RestClient::Payload::Multipart.new({nil => f})
-      m.to_s.should eq <<-EOS
+      expect(m.to_s).to eq <<-EOS
 --#{m.boundary}\r
 Content-Disposition: form-data; filename="master_shake.jpg"\r
 Content-Type: image/jpeg\r
@@ -132,7 +141,7 @@ Content-Type: image/jpeg\r
       f.instance_eval "def content_type; 'text/plain'; end"
       f.instance_eval "def original_filename; 'foo.txt'; end"
       m = RestClient::Payload::Multipart.new({:foo => f})
-      m.to_s.should eq <<-EOS
+      expect(m.to_s).to eq <<-EOS
 --#{m.boundary}\r
 Content-Disposition: form-data; name="foo"; filename="foo.txt"\r
 Content-Type: text/plain\r
@@ -144,7 +153,7 @@ Content-Type: text/plain\r
 
     it "should handle hash in hash parameters" do
       m = RestClient::Payload::Multipart.new({:bar => {:baz => "foo"}})
-      m.to_s.should eq <<-EOS
+      expect(m.to_s).to eq <<-EOS
 --#{m.boundary}\r
 Content-Disposition: form-data; name="bar[baz]"\r
 \r
@@ -156,7 +165,7 @@ foo\r
       f.instance_eval "def content_type; 'text/plain'; end"
       f.instance_eval "def original_filename; 'foo.txt'; end"
       m = RestClient::Payload::Multipart.new({:foo => {:bar => f}})
-      m.to_s.should eq <<-EOS
+      expect(m.to_s).to eq <<-EOS
 --#{m.boundary}\r
 Content-Disposition: form-data; name="foo[bar]"; filename="foo.txt"\r
 Content-Type: text/plain\r
@@ -166,29 +175,36 @@ Content-Type: text/plain\r
       EOS
     end
 
+    it 'should correctly format hex boundary' do
+      allow(SecureRandom).to receive(:base64).with(12).and_return('TGs89+ttw/xna6TV')
+      f = File.new(File.dirname(__FILE__) + '/master_shake.jpg')
+      m = RestClient::Payload::Multipart.new({:foo => f})
+      expect(m.boundary).to eq('-' * 4 + 'RubyFormBoundary' + 'TGs89AttwBxna6TV')
+    end
+
   end
 
   context "streamed payloads" do
     it "should properly determine the size of file payloads" do
       f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
       payload = RestClient::Payload.generate(f)
-      payload.size.should eq 76_988
-      payload.length.should eq 76_988
+      expect(payload.size).to eq 76_988
+      expect(payload.length).to eq 76_988
     end
 
     it "should properly determine the size of other kinds of streaming payloads" do
       s = StringIO.new 'foo'
       payload = RestClient::Payload.generate(s)
-      payload.size.should eq 3
-      payload.length.should eq 3
+      expect(payload.size).to eq 3
+      expect(payload.length).to eq 3
 
       begin
         f = Tempfile.new "rest-client"
         f.write 'foo bar'
 
         payload = RestClient::Payload.generate(f)
-        payload.size.should eq 7
-        payload.length.should eq 7
+        expect(payload.size).to eq 7
+        expect(payload.length).to eq 7
       ensure
         f.close
       end
@@ -197,48 +213,51 @@ Content-Type: text/plain\r
 
   context "Payload generation" do
     it "should recognize standard urlencoded params" do
-      RestClient::Payload.generate({"foo" => 'bar'}).should be_kind_of(RestClient::Payload::UrlEncoded)
+      expect(RestClient::Payload.generate({"foo" => 'bar'})).to be_kind_of(RestClient::Payload::UrlEncoded)
     end
 
     it "should recognize multipart params" do
       f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
-      RestClient::Payload.generate({"foo" => f}).should be_kind_of(RestClient::Payload::Multipart)
+      expect(RestClient::Payload.generate({"foo" => f})).to be_kind_of(RestClient::Payload::Multipart)
     end
 
     it "should be multipart if forced" do
-      RestClient::Payload.generate({"foo" => "bar", :multipart => true}).should be_kind_of(RestClient::Payload::Multipart)
+      expect(RestClient::Payload.generate({"foo" => "bar", :multipart => true})).to be_kind_of(RestClient::Payload::Multipart)
     end
 
+    it "should handle deeply nested multipart" do
+      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      params = {foo: RestClient::ParamsArray.new({nested: f})}
+      expect(RestClient::Payload.generate(params)).to be_kind_of(RestClient::Payload::Multipart)
+    end
+
+
     it "should return data if no of the above" do
-      RestClient::Payload.generate("data").should be_kind_of(RestClient::Payload::Base)
+      expect(RestClient::Payload.generate("data")).to be_kind_of(RestClient::Payload::Base)
     end
 
     it "should recognize nested multipart payloads in hashes" do
       f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
-      RestClient::Payload.generate({"foo" => {"file" => f}}).should be_kind_of(RestClient::Payload::Multipart)
+      expect(RestClient::Payload.generate({"foo" => {"file" => f}})).to be_kind_of(RestClient::Payload::Multipart)
     end
 
     it "should recognize nested multipart payloads in arrays" do
       f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
-      RestClient::Payload.generate({"foo" => [f]}).should be_kind_of(RestClient::Payload::Multipart)
+      expect(RestClient::Payload.generate({"foo" => [f]})).to be_kind_of(RestClient::Payload::Multipart)
     end
 
     it "should recognize file payloads that can be streamed" do
       f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
-      RestClient::Payload.generate(f).should be_kind_of(RestClient::Payload::Streamed)
+      expect(RestClient::Payload.generate(f)).to be_kind_of(RestClient::Payload::Streamed)
     end
 
     it "should recognize other payloads that can be streamed" do
-      RestClient::Payload.generate(StringIO.new('foo')).should be_kind_of(RestClient::Payload::Streamed)
+      expect(RestClient::Payload.generate(StringIO.new('foo'))).to be_kind_of(RestClient::Payload::Streamed)
     end
 
     # hashery gem introduces Hash#read convenience method. Existence of #read method used to determine of content is streameable :/
     it "shouldn't treat hashes as streameable" do
-      RestClient::Payload.generate({"foo" => 'bar'}).should be_kind_of(RestClient::Payload::UrlEncoded)
+      expect(RestClient::Payload.generate({"foo" => 'bar'})).to be_kind_of(RestClient::Payload::UrlEncoded)
     end
   end
-
-  class HashMapForTesting < Hash
-    alias :read :[]
-  end
 end