rest-man 1.0.0 → 1.1.0

data/rest-man.gemspec

@@ -23,19 +23,13 @@ Gem::Specification.new do |s|
   s.add_development_dependency('pry', '~> 0')
   s.add_development_dependency('pry-doc', '~> 0')
   s.add_development_dependency('rdoc', '>= 2.4.2', '< 7.0')
-  s.add_development_dependency('rubocop', '~> 0.49')
+  s.add_development_dependency('rubocop', '~> 1.50.2')
 
   s.add_dependency('http-accept', '>= 1.7.0', '< 3.0')
   s.add_dependency('http-cookie', '>= 1.0.2', '< 2.0')
-  s.add_dependency('mime-types', '>= 1.16', '< 4.0')
+  s.add_dependency('mime-types', '>= 3.0', '< 4.0')
   s.add_dependency('netrc', '~> 0.8')
+  s.add_dependency('active_method', '~> 1.3')
 
-  s.required_ruby_version = '>= 2.0.0'
-
-  case ENV['BUILD_PLATFORM'] || RUBY_PLATFORM
-  when /(mingw32|mswin32)/
-    # ffi is needed for RestMan::Windows::RootCerts
-    s.add_dependency('ffi', '~> 1.9')
-    s.platform = platform
-  end
+  s.required_ruby_version = '>= 2.6.0'
 end

data/spec/integration/capath_digicert/ce5e74ef.0

@@ -1 +1 @@
-spec/integration/capath_digicert/digicert.crt
+digicert.crt

data/spec/integration/request_spec.rb

@@ -62,7 +62,7 @@ describe RestMan::Request do
 
 
     # verify_callback is not works well with VCR
-    # it "executes the verify_callback", focus: true do
+    # it "executes the verify_callback" do
     #   ran_callback = false
     #   request = RestMan::Request.new(
     #     :method => :get,
@@ -129,6 +129,18 @@ describe RestMan::Request do
       expect { request.execute }.to(
         raise_error(RestMan::Exceptions::ReadTimeout))
     end
+
+    it "raises WriteTimeout when it hits a write timeout via :write_timeout" do
+      allow_any_instance_of(Net::HTTP).to receive(:request).and_raise(Net::WriteTimeout.new)
+
+      request = RestMan::Request.new(
+        :method => :post,
+        :url => 'https://www.mozilla.org',
+        :write_timeout => 1e-10,
+      )
+      expect { request.execute }.to(
+        raise_error(RestMan::Exceptions::WriteTimeout))
+    end
   end
 
 end

data/spec/spec_helper.rb

@@ -1,3 +1,14 @@
+require 'simplecov'
+
+if ENV['UPLOAD_COVERAGE_TO_CODACY']
+  require 'simplecov-cobertura'
+  SimpleCov.formatter = SimpleCov::Formatter::CoberturaFormatter
+end
+
+SimpleCov.start do
+  add_filter "/spec"
+end
+
 require 'webmock/rspec'
 require 'rest-man'
 

data/spec/unit/abstract_response_spec.rb

@@ -26,6 +26,20 @@ describe RestMan::AbstractResponse, :include_helpers do
     expect(@response.code).to eq 200
   end
 
+  [200, 255, 299].each do |code|
+    it "#success? - return true when response code is #{code}" do
+      expect(@net_http_res).to receive(:code).and_return(code.to_s)
+      expect(@response.success?).to eq true
+    end
+  end
+
+  [100, 199, 300, 399, 400, 499, 500, 599].each do |code|
+    it "#success? - return false when response code is #{code}" do
+      expect(@net_http_res).to receive(:code).and_return(code.to_s)
+      expect(@response.success?).to eq false
+    end
+  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')

data/spec/unit/exception_spec.rb

@@ -0,0 +1,64 @@
+require_relative '_lib'
+
+describe RestMan::Exception do
+
+  it "contains exceptions in RestMan" do
+    expect(RestMan::Unauthorized.new).to be_a_kind_of(RestMan::Exception)
+    expect(RestMan::ServerBrokeConnection.new).to be_a_kind_of(RestMan::Exception)
+  end
+
+  describe '#message' do
+    it "returns a 'message' equal to the class name if the message is not set, because 'message' should not be nil" do
+      e = RestMan::Exception.new
+      expect(e.message).to eq "RestMan::Exception"
+    end
+
+    it "returns the 'message' that was set" do
+      e = RestMan::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(RestMan::ResourceNotFound.new.message).to eq 'Not Found'
+    end
+  end
+
+  describe "#http_code" do
+    it 'return the initial_response_code' do
+      e = RestMan::Exception.new(nil, 111)
+      expect(e.http_code).to eq(111)
+    end
+
+    it 'return from response.code' do
+      e = RestMan::Exception.new(double("response", code: '111'))
+      expect(e.http_code).to eq(111)
+    end
+  end
+
+  describe "#http_headers" do
+    it 'return from response.headers' do
+      e = RestMan::Exception.new(double("response", headers: 'headers'))
+      expect(e.http_headers).to eq("headers")
+    end
+
+    it 'return nil when response is nil' do
+      e = RestMan::Exception.new
+      expect(e.http_headers).to be_nil
+    end
+  end
+
+  describe "#http_body" do
+    it 'return from response.body' do
+      e = RestMan::Exception.new(double("response", body: 'body'))
+      expect(e.http_body).to eq("body")
+    end
+
+    it 'return nil when response is nil' do
+      e = RestMan::Exception.new
+      expect(e.http_body).to be_nil
+    end
+  end
+
+end

data/spec/unit/exceptions/backwards_campatibility_spec.rb

@@ -0,0 +1,29 @@
+require_relative '../_lib'
+
+describe "backwards compatibility" do
+  it 'aliases RestMan::NotFound as ResourceNotFound' do
+    expect(RestMan::ResourceNotFound).to eq RestMan::NotFound
+  end
+
+  it 'aliases old names for HTTP 413, 414, 416' do
+    expect(RestMan::RequestEntityTooLarge).to eq RestMan::PayloadTooLarge
+    expect(RestMan::RequestURITooLong).to eq RestMan::URITooLong
+    expect(RestMan::RequestedRangeNotSatisfiable).to eq RestMan::RangeNotSatisfiable
+  end
+
+  it 'subclasses NotFound from RequestFailed, ExceptionWithResponse' do
+    expect(RestMan::NotFound).to be < RestMan::RequestFailed
+    expect(RestMan::NotFound).to be < RestMan::ExceptionWithResponse
+  end
+
+  it 'subclasses timeout from RestMan::RequestTimeout, RequestFailed, EWR' do
+    expect(RestMan::Exceptions::OpenTimeout).to be < RestMan::Exceptions::Timeout
+    expect(RestMan::Exceptions::ReadTimeout).to be < RestMan::Exceptions::Timeout
+
+    expect(RestMan::Exceptions::Timeout).to be < RestMan::RequestTimeout
+    expect(RestMan::Exceptions::Timeout).to be < RestMan::RequestFailed
+    expect(RestMan::Exceptions::Timeout).to be < RestMan::ExceptionWithResponse
+  end
+
+end
+

data/spec/unit/exceptions/exceptions_map_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe RestMan::Exceptions::EXCEPTIONS_MAP do
+
+   it 'can success map for 1xx code' do
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[100]).to eq(RestMan::Continue)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[101]).to eq(RestMan::SwitchingProtocols)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[102]).to eq(RestMan::Processing)
+   end
+
+   it 'can success map for 2xx code' do
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[200]).to eq(RestMan::OK)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[201]).to eq(RestMan::Created)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[202]).to eq(RestMan::Accepted)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[203]).to eq(RestMan::NonAuthoritativeInformation)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[204]).to eq(RestMan::NoContent)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[205]).to eq(RestMan::ResetContent)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[206]).to eq(RestMan::PartialContent)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[207]).to eq(RestMan::MultiStatus)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[208]).to eq(RestMan::AlreadyReported)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[226]).to eq(RestMan::IMUsed)
+   end
+
+   it 'can success map for 3xx code' do
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[300]).to eq(RestMan::MultipleChoices)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[301]).to eq(RestMan::MovedPermanently)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[302]).to eq(RestMan::Found)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[303]).to eq(RestMan::SeeOther)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[304]).to eq(RestMan::NotModified)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[305]).to eq(RestMan::UseProxy)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[306]).to eq(RestMan::SwitchProxy)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[307]).to eq(RestMan::TemporaryRedirect)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[308]).to eq(RestMan::PermanentRedirect)
+   end
+
+   it 'can success map for 4xx code' do
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[400]).to eq(RestMan::BadRequest)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[401]).to eq(RestMan::Unauthorized)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[402]).to eq(RestMan::PaymentRequired)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[403]).to eq(RestMan::Forbidden)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[404]).to eq(RestMan::NotFound)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[405]).to eq(RestMan::MethodNotAllowed)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[406]).to eq(RestMan::NotAcceptable)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[407]).to eq(RestMan::ProxyAuthenticationRequired)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[408]).to eq(RestMan::RequestTimeout)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[409]).to eq(RestMan::Conflict)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[410]).to eq(RestMan::Gone)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[411]).to eq(RestMan::LengthRequired)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[412]).to eq(RestMan::PreconditionFailed)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[413]).to eq(RestMan::PayloadTooLarge)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[414]).to eq(RestMan::URITooLong)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[415]).to eq(RestMan::UnsupportedMediaType)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[416]).to eq(RestMan::RangeNotSatisfiable)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[417]).to eq(RestMan::ExpectationFailed)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[418]).to eq(RestMan::ImATeapot)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[421]).to eq(RestMan::TooManyConnectionsFromThisIP)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[422]).to eq(RestMan::UnprocessableEntity)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[423]).to eq(RestMan::Locked)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[424]).to eq(RestMan::FailedDependency)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[425]).to eq(RestMan::UnorderedCollection)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[426]).to eq(RestMan::UpgradeRequired)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[428]).to eq(RestMan::PreconditionRequired)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[429]).to eq(RestMan::TooManyRequests)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[431]).to eq(RestMan::RequestHeaderFieldsTooLarge)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[449]).to eq(RestMan::RetryWith)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[450]).to eq(RestMan::BlockedByWindowsParentalControls)
+
+      expect(RestMan::ResourceNotFound).to eq(RestMan::NotFound)
+      expect(RestMan::RequestEntityTooLarge).to eq(RestMan::PayloadTooLarge)
+      expect(RestMan::RequestURITooLong).to eq(RestMan::URITooLong)
+      expect(RestMan::RequestedRangeNotSatisfiable).to eq(RestMan::RangeNotSatisfiable)
+   end
+
+   it 'can success map for 5xx code' do
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[500]).to eq(RestMan::InternalServerError)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[501]).to eq(RestMan::NotImplemented)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[502]).to eq(RestMan::BadGateway)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[503]).to eq(RestMan::ServiceUnavailable)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[504]).to eq(RestMan::GatewayTimeout)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[505]).to eq(RestMan::HTTPVersionNotSupported)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[506]).to eq(RestMan::VariantAlsoNegotiates)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[507]).to eq(RestMan::InsufficientStorage)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[508]).to eq(RestMan::LoopDetected)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[509]).to eq(RestMan::BandwidthLimitExceeded)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[510]).to eq(RestMan::NotExtended)
+      expect(RestMan::Exceptions::EXCEPTIONS_MAP[511]).to eq(RestMan::NetworkAuthenticationRequired)
+   end
+
+end

data/spec/unit/exceptions/request_failed_spec.rb

@@ -0,0 +1,51 @@
+require_relative '../_lib'
+
+describe RestMan::RequestFailed do
+  before do
+    @response = double('HTTP Response', :code => '502')
+  end
+
+  it "stores the http response on the exception" do
+    response = "response"
+    begin
+      raise RestMan::RequestFailed, response
+    rescue RestMan::RequestFailed => e
+      expect(e.response).to eq response
+    end
+  end
+
+  it "http_code convenience method for fetching the code as an integer" do
+    expect(RestMan::RequestFailed.new(@response).http_code).to eq 502
+  end
+
+  it "http_body convenience method for fetching the body (decoding when necessary)" do
+    expect(RestMan::RequestFailed.new(@response).http_code).to eq 502
+    expect(RestMan::RequestFailed.new(@response).message).to eq 'HTTP status code 502'
+  end
+
+  it "shows the status code in the message" do
+    expect(RestMan::RequestFailed.new(@response).to_s).to match(/502/)
+  end
+end
+
+describe RestMan::ResourceNotFound do
+  it "also has the http response attached" do
+    response = "response"
+    begin
+      raise RestMan::ResourceNotFound, response
+    rescue RestMan::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
+      RestMan.get "www.example.com"
+      raise
+    rescue RestMan::ResourceNotFound => e
+      expect(e.response.body).to eq body
+    end
+  end
+end

data/spec/unit/exceptions/server_broke_connection_spec.rb

@@ -0,0 +1,8 @@
+require_relative '../_lib'
+
+describe RestMan::ServerBrokeConnection do
+  it "should have a default message of 'Server broke connection'" do
+    e = RestMan::ServerBrokeConnection.new
+    expect(e.message).to eq 'Server broke connection'
+  end
+end

data/spec/unit/exceptions/timeout_spec.rb

@@ -0,0 +1,59 @@
+require_relative '../_lib'
+
+describe RestMan::Exceptions::Timeout do
+
+  describe 'OpenTimeout' do
+    it '#message' do
+      e = RestMan::Exceptions::OpenTimeout.new("error message...")
+      expect(e.message).to eq("error message...")
+    end
+
+    it "#message - should have a default message of 'Timed out connection to server'" do
+      e = RestMan::Exceptions::OpenTimeout.new
+      expect(e.message).to eq("Timed out connecting to server")
+    end
+
+    it "#original_exception" do
+      original_exception = StandardError.new('someting wrong')
+      e = RestMan::Exceptions::OpenTimeout.new('error message...', original_exception)
+      expect(e.original_exception).to eq(original_exception)
+    end
+  end
+
+  describe 'ReadTimeout' do
+    it '#message' do
+      e = RestMan::Exceptions::ReadTimeout.new("error message...")
+      expect(e.message).to eq("error message...")
+    end
+
+    it "#message - should have a default message of 'Timed out connection to server'" do
+      e = RestMan::Exceptions::ReadTimeout.new
+      expect(e.message).to eq("Timed out reading data from server")
+    end
+
+    it "#original_exception" do
+      original_exception = StandardError.new('someting wrong')
+      e = RestMan::Exceptions::ReadTimeout.new('error message...', original_exception)
+      expect(e.original_exception).to eq(original_exception)
+    end
+  end
+
+  describe 'WriteTimeout' do
+    it '#message' do
+      e = RestMan::Exceptions::WriteTimeout.new("error message...")
+      expect(e.message).to eq("error message...")
+    end
+
+    it "#message - should have a default message of 'Timed out connection to server'" do
+      e = RestMan::Exceptions::WriteTimeout.new
+      expect(e.message).to eq("Timed out writing data to server")
+    end
+
+    it "#original_exception" do
+      original_exception = StandardError.new('someting wrong')
+      e = RestMan::Exceptions::WriteTimeout.new('error message...', original_exception)
+      expect(e.original_exception).to eq(original_exception)
+    end
+  end
+
+end

data/spec/unit/params_array/process_pair_spec.rb

@@ -0,0 +1,59 @@
+require 'spec_helper'
+
+describe RestMan::ParamsArray::ProcessPair do
+
+  let(:process_pair) { RestMan::ParamsArray::ProcessPair.call(pair) }
+
+  context 'when pair is a hash' do
+    context 'which containts only one key-value pair' do
+      let(:pair) { {a: 1} }
+
+      it "return the array [key, value]" do
+        expect(process_pair).to eq([:a, 1])
+      end
+    end
+
+    context 'which containts multiple key-value pairs' do
+      let(:pair) { { a: 1, b: 2 } }
+
+      it "raise ArgumentError" do
+        expect{process_pair}.to raise_error(ArgumentError, "Bad # of fields for pair: {:a=>1, :b=>2}")
+      end
+    end
+  end
+
+  context 'when pair is an array' do
+    context 'which containts only one item like [key]' do
+      let(:pair) { [:a] }
+
+      it "return the array [key, nil]" do
+        expect(process_pair).to eq([:a, nil])
+      end
+    end
+
+    context 'which containts two items like [key, value]' do
+      let(:pair) { [:a, 1] }
+
+      it "return the array [key, value]" do
+        expect(process_pair).to eq([:a, 1])
+      end
+    end
+
+    context 'which containts more than two items like [a, b, c]' do
+      let(:pair) { [:a, 1, :b] }
+
+      it "raise ArgumentError" do
+        expect{process_pair}.to raise_error(ArgumentError, "Bad # of fields for pair: [:a, 1, :b]")
+      end
+    end
+  end
+
+  context 'when pair is an array like object' do
+    let(:pair) { double('ArrayLikeObject', to_a: [:a, 1]) }
+
+    it 'convert it to array' do
+      expect(process_pair).to eq([:a, 1])
+    end
+  end
+
+end

data/spec/unit/params_array_spec.rb

@@ -2,19 +2,19 @@ require_relative '_lib'
 
 describe RestMan::ParamsArray do
 
-  describe '.new' do
+  describe '.new + .to_a' 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(RestMan::ParamsArray.new(input).to_a).to eq as_array
+      parse = lambda do |input, to:|
+        expect(RestMan::ParamsArray.new(input).to_a).to eq to
       end
 
+      parse.([[:foo, 123], [:foo, 456], [:bar, 789], [:empty, nil]], to: [[:foo, 123], [:foo, 456], [:bar, 789], [:empty, nil]])
+      parse.([{foo: 123},  {foo: 456},  {bar: 789},  {empty: nil}],  to: [[:foo, 123], [:foo, 456], [:bar, 789], [:empty, nil]])
+      parse.([{foo: 123},  {foo: 456},  {bar: 789},  {empty: nil}],  to: [[:foo, 123], [:foo, 456], [:bar, 789], [:empty, nil]])
+      parse.([{foo: 123},  [:foo, 456], {bar: 789},  {empty: nil}],  to: [[:foo, 123], [:foo, 456], [:bar, 789], [:empty, nil]])
+      parse.([{foo: 123},  [:foo, 456], {bar: 789},  [:empty]],      to: [[:foo, 123], [:foo, 456], [:bar, 789], [:empty, nil]])
+      parse.([], to: [])
+
       expect(RestMan::ParamsArray.new([]).to_a).to eq []
       expect(RestMan::ParamsArray.new([]).empty?).to eq true
     end
@@ -33,4 +33,9 @@ describe RestMan::ParamsArray do
       }.to raise_error(NoMethodError)
     end
   end
+
+  it '#emtpy?' do
+    expect(RestMan::ParamsArray.new([]).empty?).to eq true
+    expect(RestMan::ParamsArray.new({foo: 1}).empty?).to eq false
+  end
 end

data/spec/unit/payload/multipart_spec.rb

@@ -0,0 +1,116 @@
+# encoding: binary
+
+require_relative '../_lib'
+
+describe RestMan::Payload::Multipart, :include_helpers do
+
+  it "should use standard enctype as default content-type" do
+    m = RestMan::Payload::Multipart.new({})
+    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
+    m = RestMan::Payload::Multipart.new(:file => File.new(test_image_path))
+    3.times {m.close}
+  end
+
+  it "should form properly separated multipart data" do
+    m = RestMan::Payload::Multipart.new([[:bar, "baz"], [:foo, "bar"]])
+    expect(m.to_s).to 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 = RestMan::Payload::Multipart.new([["bar ", "baz"]])
+    expect(m.to_s).to 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(test_image_path)
+    m = RestMan::Payload::Multipart.new({:foo => f})
+    expect(m.to_s).to eq <<~EOS
+      --#{m.boundary}\r
+      Content-Disposition: form-data; name="foo"; filename="ISS.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(test_image_path)
+    m = RestMan::Payload::Multipart.new({nil => f})
+    expect(m.to_s).to eq <<~EOS
+      --#{m.boundary}\r
+      Content-Disposition: form-data; filename="ISS.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(test_image_path)
+    expect(MIME::Types).to receive(:type_for).with(f.path).and_return("")
+    expect(f).to receive(:original_filename).and_return('foo.txt')
+    m = RestMan::Payload::Multipart.new({:foo => f})
+    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
+      \r
+      #{File.open(f.path, 'rb'){|bin| bin.read}}\r
+      --#{m.boundary}--\r
+      EOS
+  end
+
+  it "should handle hash in hash parameters" do
+    m = RestMan::Payload::Multipart.new({:bar => {:baz => "foo"}})
+    expect(m.to_s).to eq <<~EOS
+      --#{m.boundary}\r
+      Content-Disposition: form-data; name="bar[baz]"\r
+      \r
+      foo\r
+      --#{m.boundary}--\r
+      EOS
+
+    f = File.new(test_image_path)
+    f.instance_eval "def content_type; 'text/plain'; end"
+    f.instance_eval "def original_filename; 'foo.txt'; end"
+    m = RestMan::Payload::Multipart.new({:foo => {:bar => f}})
+    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
+      \r
+      #{File.open(f.path, 'rb'){|bin| bin.read}}\r
+      --#{m.boundary}--\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(test_image_path)
+    m = RestMan::Payload::Multipart.new({:foo => f})
+    expect(m.boundary).to eq('-' * 4 + 'RubyFormBoundary' + 'TGs89AttwBxna6TV')
+  end
+
+end

data/spec/unit/payload/streamed_spec.rb

@@ -0,0 +1,48 @@
+# encoding: binary
+
+require_relative '../_lib'
+
+describe RestMan::Payload::Streamed, :include_helpers do
+
+  it "should properly determine the size of file payloads" do
+    f = File.new(test_image_path)
+    payload = RestMan::Payload.generate(f)
+    expect(payload.size).to eq 72_463
+    expect(payload.length).to eq 72_463
+  end
+
+  it "should properly determine the size of other kinds of streaming payloads" do
+    s = StringIO.new 'foo'
+    payload = RestMan::Payload.generate(s)
+    expect(payload.size).to eq 3
+    expect(payload.length).to eq 3
+
+    begin
+      f = Tempfile.new "rest-man"
+      f.write 'foo bar'
+
+      payload = RestMan::Payload.generate(f)
+      expect(payload.size).to eq 7
+      expect(payload.length).to eq 7
+    ensure
+      f.close
+    end
+  end
+
+  it "should preperly determin the size of an IO like paylod" do
+    io = IO.new(0)
+    allow(io).to receive(:stat).and_return(double("IO::Stat", size: 10))
+    payload = RestMan::Payload.generate(io)
+    expect(payload.size).to eq 10
+    expect(payload.length).to eq 10
+  end
+
+  it "should have a closed? method" do
+    f = File.new(test_image_path)
+    payload = RestMan::Payload.generate(f)
+    expect(payload.closed?).to be_falsey
+    payload.close
+    expect(payload.closed?).to be_truthy
+  end
+
+end