rest-client 1.6.0

data/lib/restclient/resource.rb

@@ -0,0 +1,147 @@
+module RestClient
+  # A class that can be instantiated for access to a RESTful resource,
+  # including authentication.
+  #
+  # Example:
+  #
+  #   resource = RestClient::Resource.new('http://some/resource')
+  #   jpg = resource.get(:accept => 'image/jpg')
+  #
+  # With HTTP basic authentication:
+  #
+  #   resource = RestClient::Resource.new('http://protected/resource', :user => 'user', :password => 'password')
+  #   resource.delete
+  #
+  # With a timeout (seconds):
+  #
+  #   RestClient::Resource.new('http://slow', :timeout => 10)
+  #
+  # With an open timeout (seconds):
+  #
+  #   RestClient::Resource.new('http://behindfirewall', :open_timeout => 10)
+  #
+  # You can also use resources to share common headers. For headers keys,
+  # symbols are converted to strings. Example:
+  #
+  #   resource = RestClient::Resource.new('http://some/resource', :headers => { :client_version => 1 })
+  #
+  # This header will be transported as X-Client-Version (notice the X prefix,
+  # capitalization and hyphens)
+  #
+  # Use the [] syntax to allocate subresources:
+  #
+  #   site = RestClient::Resource.new('http://example.com', :user => 'adam', :password => 'mypasswd')
+  #   site['posts/1/comments'].post 'Good article.', :content_type => 'text/plain'
+  #
+  class Resource
+    attr_reader :url, :options, :block
+
+    def initialize(url, options={}, backwards_compatibility=nil, &block)
+      @url = url
+      @block = block
+      if options.class == Hash
+        @options = options
+      else # compatibility with previous versions
+        @options = { :user => options, :password => backwards_compatibility }
+      end
+    end
+
+    def get(additional_headers={}, &block)
+      headers = (options[:headers] || {}).merge(additional_headers)
+      Request.execute(options.merge(
+              :method => :get,
+              :url => url,
+              :headers => headers), &(block || @block))
+    end
+
+    def post(payload, additional_headers={}, &block)
+      headers = (options[:headers] || {}).merge(additional_headers)
+      Request.execute(options.merge(
+              :method => :post,
+              :url => url,
+              :payload => payload,
+              :headers => headers), &(block || @block))
+    end
+
+    def put(payload, additional_headers={}, &block)
+      headers = (options[:headers] || {}).merge(additional_headers)
+      Request.execute(options.merge(
+              :method => :put,
+              :url => url,
+              :payload => payload,
+              :headers => headers), &(block || @block))
+    end
+
+    def delete(additional_headers={}, &block)
+      headers = (options[:headers] || {}).merge(additional_headers)
+      Request.execute(options.merge(
+              :method => :delete,
+              :url => url,
+              :headers => headers), &(block || @block))
+    end
+
+    def to_s
+      url
+    end
+
+    def user
+      options[:user]
+    end
+
+    def password
+      options[:password]
+    end
+
+    def headers
+      options[:headers] || {}
+    end
+
+    def timeout
+      options[:timeout]
+    end
+
+    def open_timeout
+      options[:open_timeout]
+    end
+
+    # Construct a subresource, preserving authentication.
+    #
+    # Example:
+    #
+    #   site = RestClient::Resource.new('http://example.com', 'adam', 'mypasswd')
+    #   site['posts/1/comments'].post 'Good article.', :content_type => 'text/plain'
+    #
+    # This is especially useful if you wish to define your site in one place and
+    # call it in multiple locations:
+    #
+    #   def orders
+    #     RestClient::Resource.new('http://example.com/orders', 'admin', 'mypasswd')
+    #   end
+    #
+    #   orders.get                     # GET http://example.com/orders
+    #   orders['1'].get                # GET http://example.com/orders/1
+    #   orders['1/items'].delete       # DELETE http://example.com/orders/1/items
+    #
+    # Nest resources as far as you want:
+    #
+    #   site = RestClient::Resource.new('http://example.com')
+    #   posts = site['posts']
+    #   first_post = posts['1']
+    #   comments = first_post['comments']
+    #   comments.post 'Hello', :content_type => 'text/plain'
+    #
+    def [](suburl)
+      self.class.new(concat_urls(url, suburl), options)
+    end
+
+    def concat_urls(url, suburl) # :nodoc:
+      url = url.to_s
+      suburl = suburl.to_s
+      if url.slice(-1, 1) == '/' or suburl.slice(0, 1) == '/'
+        url + suburl
+      else
+        "#{url}/#{suburl}"
+      end
+    end
+  end
+end

data/lib/restclient/response.rb

@@ -0,0 +1,24 @@
+module RestClient
+
+  # A Response from RestClient, you can access the response body, the code or the headers.
+  #
+  module Response
+
+    include AbstractResponse
+
+    attr_accessor :args, :body, :net_http_res
+
+    def body
+      self
+    end
+
+    def Response.create body, net_http_res, args
+      result = body || ''
+      result.extend Response
+      result.net_http_res = net_http_res
+      result.args = args
+      result
+    end
+
+  end
+end

data/spec/abstract_response_spec.rb

@@ -0,0 +1,67 @@
+require File.dirname(__FILE__) + '/base'
+
+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 = mock('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 == 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 == '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 == :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 == 'text/html'
+  end
+
+  it "fetches the headers" do
+    @net_http_res.should_receive(:to_hash).and_return('content-type' => [ 'text/html' ])
+    @response.headers.should == { :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 == { '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 == { '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 == { 'session_id' => 'BAh7BzoNYXBwX25hbWUiEGFwcGxpY2F0aW9uOgpsb2dpbiIKYWRtaW4%3D%0A--08114ba654f17c04d20dcc5228ec672508f738ca' }
+  end
+
+  it "can access the net http result directly" do
+    @response.net_http_res.should == @net_http_res
+  end
+end

data/spec/base.rb

@@ -0,0 +1,10 @@
+require 'rubygems'
+require 'spec'
+
+begin
+  require "ruby-debug"
+rescue LoadError
+  # NOP, ignore
+end
+
+require File.dirname(__FILE__) + '/../lib/restclient'

data/spec/exceptions_spec.rb

@@ -0,0 +1,79 @@
+require File.dirname(__FILE__) + '/base'
+
+require 'webmock/rspec'
+include WebMock
+
+describe RestClient::Exception do
+  it "sets the exception message to ErrorMessage" do
+    RestClient::ResourceNotFound.new.message.should == '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::RequestFailed do
+  before do
+    @response = mock('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 == response
+    end
+  end
+
+  it "http_code convenience method for fetching the code as an integer" do
+    RestClient::RequestFailed.new(@response).http_code.should == 502
+  end
+
+  it "http_body convenience method for fetching the body (decoding when necessary)" do
+    RestClient::RequestFailed.new(@response).http_code.should == 502
+    RestClient::RequestFailed.new(@response).message.should == '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 == response
+    end
+  end
+end
+
+describe "backwards compatibility" do
+  it "alias RestClient::Request::Redirect to RestClient::Redirect" do
+    RestClient::Request::Redirect.should == RestClient::Redirect
+  end
+
+  it "alias RestClient::Request::Unauthorized to RestClient::Unauthorized" do
+    RestClient::Request::Unauthorized.should == RestClient::Unauthorized
+  end
+
+  it "alias RestClient::Request::RequestFailed to RestClient::RequestFailed" do
+    RestClient::Request::RequestFailed.should == 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 == body
+    end
+  end
+end

data/spec/integration/certs/equifax.crt

@@ -0,0 +1,19 @@
+-----BEGIN CERTIFICATE-----
+MIIDIDCCAomgAwIBAgIENd70zzANBgkqhkiG9w0BAQUFADBOMQswCQYDVQQGEwJV
+UzEQMA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2Vy
+dGlmaWNhdGUgQXV0aG9yaXR5MB4XDTk4MDgyMjE2NDE1MVoXDTE4MDgyMjE2NDE1
+MVowTjELMAkGA1UEBhMCVVMxEDAOBgNVBAoTB0VxdWlmYXgxLTArBgNVBAsTJEVx
+dWlmYXggU2VjdXJlIENlcnRpZmljYXRlIEF1dGhvcml0eTCBnzANBgkqhkiG9w0B
+AQEFAAOBjQAwgYkCgYEAwV2xWGcIYu6gmi0fCG2RFGiYCh7+2gRvE4RiIcPRfM6f
+BeC4AfBONOziipUEZKzxa1NfBbPLZ4C/QgKO/t0BCezhABRP/PvwDN1Dulsr4R+A
+cJkVV5MW8Q+XarfCaCMczE1ZMKxRHjuvK9buY0V7xdlfUNLjUA86iOe/FP3gx7kC
+AwEAAaOCAQkwggEFMHAGA1UdHwRpMGcwZaBjoGGkXzBdMQswCQYDVQQGEwJVUzEQ
+MA4GA1UEChMHRXF1aWZheDEtMCsGA1UECxMkRXF1aWZheCBTZWN1cmUgQ2VydGlm
+aWNhdGUgQXV0aG9yaXR5MQ0wCwYDVQQDEwRDUkwxMBoGA1UdEAQTMBGBDzIwMTgw
+ODIyMTY0MTUxWjALBgNVHQ8EBAMCAQYwHwYDVR0jBBgwFoAUSOZo+SvSspXXR9gj
+IBBPM5iQn9QwHQYDVR0OBBYEFEjmaPkr0rKV10fYIyAQTzOYkJ/UMAwGA1UdEwQF
+MAMBAf8wGgYJKoZIhvZ9B0EABA0wCxsFVjMuMGMDAgbAMA0GCSqGSIb3DQEBBQUA
+A4GBAFjOKer89961zgK5F7WF0bnj4JXMJTENAKaSbn+2kmOeUJXRmm/kEd5jhW6Y
+7qj/WsjTVbJmcVfewCHrPSqnI0kBBIZCe/zuf6IWUrVnZ9NA2zsmWLIodz2uFHdh
+1voqZiegDfqnc1zqcPGUIWVEX/r87yloqaKHee9570+sB3c4
+-----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/request_spec.rb

@@ -0,0 +1,25 @@
+require File.dirname(__FILE__) + '/../base'
+
+describe RestClient::Request do
+  describe "ssl verification" do
+    it "is successful with the correct ca_file" do
+      request = RestClient::Request.new(
+        :method => :get,
+        :url => 'https://www.google.com',
+        :verify_ssl => OpenSSL::SSL::VERIFY_PEER,
+        :ssl_ca_file => File.join(File.dirname(__FILE__), "certs", "verisign.crt")
+      )
+      expect { request.execute }.to_not raise_error
+    end
+
+    it "is unsuccessful with an incorrect ca_file" do
+      request = RestClient::Request.new(
+        :method => :get,
+        :url => 'https://www.google.com',
+        :verify_ssl => OpenSSL::SSL::VERIFY_PEER,
+        :ssl_ca_file => File.join(File.dirname(__FILE__), "certs", "equifax.crt")
+      )
+      expect { request.execute }.to raise_error(RestClient::SSLCertificateNotVerified)
+    end
+  end
+end

data/spec/integration_spec.rb

@@ -0,0 +1,38 @@
+require File.dirname(__FILE__) + '/base'
+
+require 'webmock/rspec'
+include WebMock
+
+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 == 200
+    response.body.should == 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 == 200
+    response.body.should == "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 == 404
+      e.response.code.should == 404
+      e.response.body.should == body
+      e.http_body.should == body
+    end
+  end
+
+
+end

data/spec/payload_spec.rb

@@ -0,0 +1,219 @@
+require File.dirname(__FILE__) + "/base"
+
+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 == 'application/x-www-form-urlencoded'
+    end
+
+    it "should form properly encoded params" do
+      RestClient::Payload::UrlEncoded.new({:foo => 'bar'}).to_s.
+              should == "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 == "foo%20=bar"
+    end
+
+    it "should properly handle hashes as parameter" do
+      RestClient::Payload::UrlEncoded.new({:foo => {:bar => 'baz' }}).to_s.
+              should == "foo[bar]=baz"
+      RestClient::Payload::UrlEncoded.new({:foo => {:bar => {:baz => 'qux' }}}).to_s.
+              should == "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 == "foo=bar"
+      RestClient::Payload::UrlEncoded.new({:foo => {:bar => :baz }}).to_s.
+              should == "foo[bar]=baz"
+    end
+
+    it "should properly handle arrays as repeated parameters" do
+      RestClient::Payload::UrlEncoded.new({:foo => ['bar']}).to_s.
+              should == "foo[]=bar"
+      RestClient::Payload::UrlEncoded.new({:foo => ['bar', 'baz']}).to_s.
+              should == "foo[]=bar&foo[]=baz"
+    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 == 'multipart/form-data; boundary=123'
+    end
+
+    it "should form properly separated multipart data" do
+      m = RestClient::Payload::Multipart.new([[:bar, "baz"], [:foo, "bar"]])
+      m.to_s.should == <<-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 == <<-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 == <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="foo"; filename="master_shake.jpg"\r
+Content-Type: image/jpeg\r
+\r
+#{IO.read(f.path)}\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 == <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; filename="master_shake.jpg"\r
+Content-Type: image/jpeg\r
+\r
+#{IO.read(f.path)}\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 == <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="foo"; filename="foo.txt"\r
+Content-Type: text/plain\r
+\r
+#{IO.read(f.path)}\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 == <<-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 == <<-EOS
+--#{m.boundary}\r
+Content-Disposition: form-data; name="foo[bar]"; filename="foo.txt"\r
+Content-Type: text/plain\r
+\r
+#{IO.read(f.path)}\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 == 22_545
+      payload.length.should == 22_545
+    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 == 3
+      payload.length.should == 3
+
+      begin
+        f = Tempfile.new "rest-client"
+        f.write 'foo bar'
+
+        payload = RestClient::Payload.generate(f)
+        payload.size.should == 7
+        payload.length.should == 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" 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 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
+  end
+end