rest-client 1.7.0.rc1-x64-mingw32

data/spec/integration/capath_verisign/7651b327.0

@@ -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/capath_verisign/README

@@ -0,0 +1,8 @@
+The CA path symlinks can be created by c_rehash(1ssl).
+
+But in order for the tests to work on Windows, they have to be regular files.
+You can turn them all into regular files by running this on a GNU system:
+
+    for file in $(find . -type l); do
+        cp -iv --remove-destination $(readlink -e $file) $file
+    done

data/spec/integration/capath_verisign/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/certs/digicert.crt

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDxTCCAq2gAwIBAgIQAqxcJmoLQJuPC3nyrkYldzANBgkqhkiG9w0BAQUFADBsMQswCQYDVQQG
+EwJVUzEVMBMGA1UEChMMRGlnaUNlcnQgSW5jMRkwFwYDVQQLExB3d3cuZGlnaWNlcnQuY29tMSsw
+KQYDVQQDEyJEaWdpQ2VydCBIaWdoIEFzc3VyYW5jZSBFViBSb290IENBMB4XDTA2MTExMDAwMDAw
+MFoXDTMxMTExMDAwMDAwMFowbDELMAkGA1UEBhMCVVMxFTATBgNVBAoTDERpZ2lDZXJ0IEluYzEZ
+MBcGA1UECxMQd3d3LmRpZ2ljZXJ0LmNvbTErMCkGA1UEAxMiRGlnaUNlcnQgSGlnaCBBc3N1cmFu
+Y2UgRVYgUm9vdCBDQTCCASIwDQYJKoZIhvcNAQEBBQADggEPADCCAQoCggEBAMbM5XPm+9S75S0t
+Mqbf5YE/yc0lSbZxKsPVlDRnogocsF9ppkCxxLeyj9CYpKlBWTrT3JTWPNt0OKRKzE0lgvdKpVMS
+OO7zSW1xkX5jtqumX8OkhPhPYlG++MXs2ziS4wblCJEMxChBVfvLWokVfnHoNb9Ncgk9vjo4UFt3
+MRuNs8ckRZqnrG0AFFoEt7oT61EKmEFBIk5lYYeBQVCmeVyJ3hlKV9Uu5l0cUyx+mM0aBhakaHPQ
+NAQTXKFx01p8VdteZOE3hzBWBOURtCmAEvF5OYiiAhF8J2a3iLd48soKqDirCmTCv2ZdlYTBoSUe
+h10aUAsgEsxBu24LUTi4S8sCAwEAAaNjMGEwDgYDVR0PAQH/BAQDAgGGMA8GA1UdEwEB/wQFMAMB
+Af8wHQYDVR0OBBYEFLE+w2kD+L9HAdSYJhoIAu9jZCvDMB8GA1UdIwQYMBaAFLE+w2kD+L9HAdSY
+JhoIAu9jZCvDMA0GCSqGSIb3DQEBBQUAA4IBAQAcGgaX3NecnzyIZgYIVyHbIUf4KmeqvxgydkAQ
+V8GK83rZEWWONfqe/EW1ntlMMUu4kehDLI6zeM7b41N5cdblIZQB2lWHmiRk9opmzN6cN82oNLFp
+myPInngiK3BD41VHMWEZ71jFhS9OMPagMRYjyOfiZRYzy78aG6A9+MpeizGLYAiJLQwGXFK3xPkK
+mNEVX58Svnw2Yzi9RKR/5CYrCsSXaQ3pjOLAEFe4yHYSkVXySGnYvCoCWw9E1CAx2/S6cCZdkGCe
+vEsXCS+0yx5DaMkHJ8HSXPfqIbloEpw8nL+e/IBcm2PN7EeqJSdnoDfzAIJ9VNep+OkuE6N36B9K
+-----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/integration_spec.rb

@@ -0,0 +1,35 @@
+require 'spec_helper'
+
+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"
+    response.code.should eq 200
+    response.body.should eq body
+  end
+
+  it "a simple request with gzipped content" do
+    stub_request(:get, "www.example.com").with(:headers => { 'Accept-Encoding' => 'gzip, deflate' }).to_return(:body => "\037\213\b\b\006'\252H\000\003t\000\313T\317UH\257\312,HM\341\002\000G\242(\r\v\000\000\000", :status => 200,  :headers => { 'Content-Encoding' => 'gzip' } )
+    response = RestClient.get "www.example.com"
+    response.code.should eq 200
+    response.body.should eq "i'm gziped\n"
+  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
+      e.http_code.should eq 404
+      e.response.code.should eq 404
+      e.response.body.should eq body
+      e.http_body.should eq body
+    end
+  end
+
+
+end

data/spec/integration/request_spec.rb

@@ -0,0 +1,104 @@
+require 'spec_helper'
+
+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.org',
+        :ssl_ca_file => File.join(File.dirname(__FILE__), "certs", "digicert.crt")
+      )
+      expect { request.execute }.to_not raise_error
+    end
+
+    it "is successful with the correct ca_path" do
+      request = RestClient::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
+
+    # 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? 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? 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
+      ran_callback.should eq(true)
+    end
+
+    it "fails verification when the callback returns false",
+       :unless => RestClient::Platform.mac? 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? 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
+end

data/spec/spec_helper.rb

@@ -0,0 +1,12 @@
+def is_ruby_19?
+  RUBY_VERSION > '1.9'
+end
+
+begin
+  require "ruby-debug"
+rescue LoadError
+  # NOP, ignore
+end
+
+require 'webmock/rspec'
+require 'restclient'

data/spec/unit/abstract_response_spec.rb

@@ -0,0 +1,85 @@
+require 'spec_helper'
+
+describe RestClient::AbstractResponse do
+
+  class MyAbstractResponse
+
+    include RestClient::AbstractResponse
+
+    attr_accessor :size
+
+    def initialize net_http_res, args
+      @net_http_res = net_http_res
+      @args = args
+    end
+
+  end
+
+  before do
+    @net_http_res = double('net http response')
+    @response = MyAbstractResponse.new(@net_http_res, {})
+  end
+
+  it "fetches the numeric response code" do
+    @net_http_res.should_receive(:code).and_return('200')
+    @response.code.should eq 200
+  end
+
+  it "has a nice description" do
+    @net_http_res.should_receive(:to_hash).and_return({'Content-Type' => ['application/pdf']})
+    @net_http_res.should_receive(:code).and_return('200')
+    @response.description.should eq "200 OK | application/pdf  bytes\n"
+  end
+
+  it "beautifies the headers by turning the keys to symbols" do
+    h = RestClient::AbstractResponse.beautify_headers('content-type' => [ 'x' ])
+    h.keys.first.should 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' ] )
+    h.values.first.should eq 'text/html'
+  end
+
+  it "fetches the headers" do
+    @net_http_res.should_receive(:to_hash).and_return('content-type' => [ 'text/html' ])
+    @response.headers.should eq({ :content_type => 'text/html' })
+  end
+
+  it "extracts cookies from response headers" do
+    @net_http_res.should_receive(:to_hash).and_return('set-cookie' => ['session_id=1; path=/'])
+    @response.cookies.should eq({ 'session_id' => '1' })
+  end
+
+  it "extract strange cookies" do
+    @net_http_res.should_receive(:to_hash).and_return('set-cookie' => ['session_id=ZJ/HQVH6YE+rVkTpn0zvTQ==; path=/'])
+    @response.cookies.should eq({ 'session_id' => 'ZJ%2FHQVH6YE+rVkTpn0zvTQ%3D%3D' })
+  end
+
+  it "doesn't escape cookies" do
+    @net_http_res.should_receive(:to_hash).and_return('set-cookie' => ['session_id=BAh7BzoNYXBwX25hbWUiEGFwcGxpY2F0aW9uOgpsb2dpbiIKYWRtaW4%3D%0A--08114ba654f17c04d20dcc5228ec672508f738ca; path=/'])
+    @response.cookies.should eq({ 'session_id' => 'BAh7BzoNYXBwX25hbWUiEGFwcGxpY2F0aW9uOgpsb2dpbiIKYWRtaW4%3D%0A--08114ba654f17c04d20dcc5228ec672508f738ca' })
+  end
+
+  it "can access the net http result directly" do
+    @response.net_http_res.should eq @net_http_res
+  end
+
+  describe "#return!" do
+    it "should return the response itself on 200-codes" do
+      @net_http_res.should_receive(:code).and_return('200')
+      @response.return!.should be_equal(@response)
+    end
+
+    it "should raise RequestFailed on unknown codes" do
+      @net_http_res.should_receive(:code).and_return('1000')
+      lambda { @response.return! }.should raise_error RestClient::RequestFailed
+    end
+
+    it "should raise an error on a redirection after non-GET/HEAD requests" do
+      @net_http_res.should_receive(:code).and_return('301')
+      @response.args.merge(:method => :put)
+      lambda { @response.return! }.should raise_error RestClient::RequestFailed
+    end
+  end
+end

data/spec/unit/exceptions_spec.rb

@@ -0,0 +1,95 @@
+require 'spec_helper'
+
+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
+    e.message.should eq "RestClient::Exception"
+  end
+
+  it "returns the 'message' that was set" do
+    e = RestClient::Exception.new
+    message = "An explicitly set message"
+    e.message = message
+    e.message.should eq message
+  end
+
+  it "sets the exception message to ErrorMessage" do
+    RestClient::ResourceNotFound.new.message.should eq 'Resource Not Found'
+  end
+
+  it "contains exceptions in RestClient" do
+    RestClient::Unauthorized.new.should be_a_kind_of(RestClient::Exception)
+    RestClient::ServerBrokeConnection.new.should 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
+    e.message.should 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
+      e.response.should eq response
+    end
+  end
+
+  it "http_code convenience method for fetching the code as an integer" do
+    RestClient::RequestFailed.new(@response).http_code.should eq 502
+  end
+
+  it "http_body convenience method for fetching the body (decoding when necessary)" do
+    RestClient::RequestFailed.new(@response).http_code.should eq 502
+    RestClient::RequestFailed.new(@response).message.should eq 'HTTP status code 502'
+  end
+
+  it "shows the status code in the message" do
+    RestClient::RequestFailed.new(@response).to_s.should 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
+      e.response.should eq response
+    end
+  end
+end
+
+describe "backwards compatibility" do
+  it "alias RestClient::Request::Redirect to RestClient::Redirect" do
+    RestClient::Request::Redirect.should eq RestClient::Redirect
+  end
+
+  it "alias RestClient::Request::Unauthorized to RestClient::Unauthorized" do
+    RestClient::Request::Unauthorized.should eq RestClient::Unauthorized
+  end
+
+  it "alias RestClient::Request::RequestFailed to RestClient::RequestFailed" do
+    RestClient::Request::RequestFailed.should eq RestClient::RequestFailed
+  end
+
+  it "make the exception's response act like an Net::HTTPResponse" 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
+      e.response.body.should eq body
+    end
+  end
+end

data/spec/unit/payload_spec.rb

@@ -0,0 +1,245 @@
+# encoding: binary
+
+require 'spec_helper'
+
+describe RestClient::Payload do
+  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'
+    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(
+                                                        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"
+    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"
+    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")
+    end
+
+    it "should handle attributes inside a 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")
+    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")
+    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"
+    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"
+    end
+
+    it 'should not close if stream already closed' do
+      p = RestClient::Payload::UrlEncoded.new({'foo ' => 'bar'})
+      3.times {p.close}
+    end
+
+  end
+
+  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'
+    end
+
+    it 'should not error on close if stream already closed' do
+      m = RestClient::Payload::Multipart.new(:file => File.new(File.join(File.dirname(File.expand_path(__FILE__)), 'master_shake.jpg')))
+      3.times {m.close}
+    end
+
+    it "should form properly separated multipart data" do
+      m = RestClient::Payload::Multipart.new([[:bar, "baz"], [:foo, "bar"]])
+      m.to_s.should eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="bar"\r
+\r
+baz\r
+--#{m.boundary}\r
+Content-Disposition: form-data; name="foo"\r
+\r
+bar\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    it "should not escape parameters names" do
+      m = RestClient::Payload::Multipart.new([["bar ", "baz"]])
+      m.to_s.should eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="bar "\r
+\r
+baz\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    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
+--#{m.boundary}\r
+Content-Disposition: form-data; name="foo"; filename="master_shake.jpg"\r
+Content-Type: image/jpeg\r
+\r
+#{File.open(f.path, 'rb'){|bin| bin.read}}\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    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
+--#{m.boundary}\r
+Content-Disposition: form-data; filename="master_shake.jpg"\r
+Content-Type: image/jpeg\r
+\r
+#{File.open(f.path, 'rb'){|bin| bin.read}}\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    it "should detect optional (original) content type and filename" do
+      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      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
+--#{m.boundary}\r
+Content-Disposition: form-data; name="foo"; filename="foo.txt"\r
+Content-Type: text/plain\r
+\r
+#{File.open(f.path, 'rb'){|bin| bin.read}}\r
+--#{m.boundary}--\r
+      EOS
+    end
+
+    it "should handle hash in hash parameters" do
+      m = RestClient::Payload::Multipart.new({:bar => {:baz => "foo"}})
+      m.to_s.should eq <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="bar[baz]"\r
+\r
+foo\r
+--#{m.boundary}--\r
+      EOS
+
+      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      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
+--#{m.boundary}\r
+Content-Disposition: form-data; name="foo[bar]"; filename="foo.txt"\r
+Content-Type: text/plain\r
+\r
+#{File.open(f.path, 'rb'){|bin| bin.read}}\r
+--#{m.boundary}--\r
+      EOS
+    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
+    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
+
+      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
+      ensure
+        f.close
+      end
+    end
+  end
+
+  context "Payload generation" do
+    it "should recognize standard urlencoded params" do
+      RestClient::Payload.generate({"foo" => 'bar'}).should 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)
+    end
+
+    it "should be multipart if forced" do
+      RestClient::Payload.generate({"foo" => "bar", :multipart => true}).should 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)
+    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)
+    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)
+    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)
+    end
+
+    it "should recognize other payloads that can be streamed" do
+      RestClient::Payload.generate(StringIO.new('foo')).should 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)
+    end
+  end
+
+  class HashMapForTesting < Hash
+    alias :read :[]
+  end
+end