rest-client 2.0.2 → 2.1.0

data/spec/integration/integration_spec.rb

@@ -12,13 +12,6 @@ describe RestClient do
     expect(response.body).to 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"
-    expect(response.code).to eq 200
-    expect(response.body).to 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)

data/spec/unit/abstract_response_spec.rb

@@ -2,21 +2,21 @@ require_relative '_lib'
 
 describe RestClient::AbstractResponse, :include_helpers do
 
+  # Sample class implementing AbstractResponse used for testing.
   class MyAbstractResponse
 
     include RestClient::AbstractResponse
 
     attr_accessor :size
 
-    def initialize net_http_res, request
-      @net_http_res = net_http_res
-      @request = request
+    def initialize(net_http_res, request)
+      response_set_vars(net_http_res, request, Time.now - 1)
     end
 
   end
 
   before do
-    @net_http_res = double('net http response')
+    @net_http_res = res_double()
     @request = request_double(url: 'http://example.com', method: 'get')
     @response = MyAbstractResponse.new(@net_http_res, @request)
   end
@@ -92,8 +92,8 @@ describe RestClient::AbstractResponse, :include_helpers do
     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)
+      request = double('request', url: 'example.com', uri: URI.parse('http://example.com'),
+                       method: 'get', cookie_jar: HTTP::CookieJar.new, redirection_history: nil)
       response = MyAbstractResponse.new(net_http_res, request)
       expect(response.cookie_jar).to be_a HTTP::CookieJar
 
@@ -135,7 +135,7 @@ describe RestClient::AbstractResponse, :include_helpers do
     end
 
     it "should gracefully handle 302 redirect with no location header" do
-      @net_http_res = response_double(code: 302, location: nil)
+      @net_http_res = res_double(code: 302)
       @request = request_double()
       @response = MyAbstractResponse.new(@net_http_res, @request)
       expect(@response).to receive(:check_max_redirects).and_return('fake-check')

data/spec/unit/payload_spec.rb

@@ -2,7 +2,7 @@
 
 require_relative '_lib'
 
-describe RestClient::Payload do
+describe RestClient::Payload, :include_helpers do
   context "Base Payload" do
     it "should reset stream after to_s" do
       payload = RestClient::Payload::Base.new('foobar')
@@ -80,7 +80,7 @@ describe RestClient::Payload do
     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')))
+      m = RestClient::Payload::Multipart.new(:file => File.new(test_image_path))
       3.times {m.close}
     end
 
@@ -111,11 +111,11 @@ baz\r
     end
 
     it "should form properly separated multipart data" do
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f = File.new(test_image_path)
       m = RestClient::Payload::Multipart.new({:foo => f})
       expect(m.to_s).to eq <<-EOS
 --#{m.boundary}\r
-Content-Disposition: form-data; name="foo"; filename="master_shake.jpg"\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
@@ -124,11 +124,11 @@ Content-Type: image/jpeg\r
     end
 
     it "should ignore the name attribute when it's not set" do
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f = File.new(test_image_path)
       m = RestClient::Payload::Multipart.new({nil => f})
       expect(m.to_s).to eq <<-EOS
 --#{m.boundary}\r
-Content-Disposition: form-data; filename="master_shake.jpg"\r
+Content-Disposition: form-data; filename="ISS.jpg"\r
 Content-Type: image/jpeg\r
 \r
 #{File.open(f.path, 'rb'){|bin| bin.read}}\r
@@ -137,9 +137,9 @@ Content-Type: image/jpeg\r
     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"
+      f = File.new(test_image_path)
+      expect(f).to receive(:content_type).and_return('text/plain')
+      expect(f).to receive(:original_filename).and_return('foo.txt')
       m = RestClient::Payload::Multipart.new({:foo => f})
       expect(m.to_s).to eq <<-EOS
 --#{m.boundary}\r
@@ -161,7 +161,7 @@ foo\r
 --#{m.boundary}--\r
       EOS
 
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      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 = RestClient::Payload::Multipart.new({:foo => {:bar => f}})
@@ -177,7 +177,7 @@ Content-Type: text/plain\r
 
     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')
+      f = File.new(test_image_path)
       m = RestClient::Payload::Multipart.new({:foo => f})
       expect(m.boundary).to eq('-' * 4 + 'RubyFormBoundary' + 'TGs89AttwBxna6TV')
     end
@@ -186,10 +186,10 @@ Content-Type: text/plain\r
 
   context "streamed payloads" do
     it "should properly determine the size of file payloads" do
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f = File.new(test_image_path)
       payload = RestClient::Payload.generate(f)
-      expect(payload.size).to eq 76_988
-      expect(payload.length).to eq 76_988
+      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
@@ -209,6 +209,14 @@ Content-Type: text/plain\r
         f.close
       end
     end
+
+    it "should have a closed? method" do
+      f = File.new(test_image_path)
+      payload = RestClient::Payload.generate(f)
+      expect(payload.closed?).to be_falsey
+      payload.close
+      expect(payload.closed?).to be_truthy
+    end
   end
 
   context "Payload generation" do
@@ -217,7 +225,7 @@ Content-Type: text/plain\r
     end
 
     it "should recognize multipart params" do
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f = File.new(test_image_path)
       expect(RestClient::Payload.generate({"foo" => f})).to be_kind_of(RestClient::Payload::Multipart)
     end
 
@@ -226,7 +234,7 @@ Content-Type: text/plain\r
     end
 
     it "should handle deeply nested multipart" do
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f = File.new(test_image_path)
       params = {foo: RestClient::ParamsArray.new({nested: f})}
       expect(RestClient::Payload.generate(params)).to be_kind_of(RestClient::Payload::Multipart)
     end
@@ -237,17 +245,17 @@ Content-Type: text/plain\r
     end
 
     it "should recognize nested multipart payloads in hashes" do
-      f = File.new(File.dirname(__FILE__) + "/master_shake.jpg")
+      f = File.new(test_image_path)
       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")
+      f = File.new(test_image_path)
       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")
+      f = File.new(test_image_path)
       expect(RestClient::Payload.generate(f)).to be_kind_of(RestClient::Payload::Streamed)
     end
 
@@ -259,5 +267,29 @@ Content-Type: text/plain\r
     it "shouldn't treat hashes as streameable" do
       expect(RestClient::Payload.generate({"foo" => 'bar'})).to be_kind_of(RestClient::Payload::UrlEncoded)
     end
+
+    it "should recognize multipart payload wrapped in ParamsArray" do
+      f = File.new(test_image_path)
+      params = RestClient::ParamsArray.new([[:image, f]])
+      expect(RestClient::Payload.generate(params)).to be_kind_of(RestClient::Payload::Multipart)
+    end
+
+    it "should handle non-multipart payload wrapped in ParamsArray" do
+      params = RestClient::ParamsArray.new([[:arg, 'value1'], [:arg, 'value2']])
+      expect(RestClient::Payload.generate(params)).to be_kind_of(RestClient::Payload::UrlEncoded)
+    end
+
+    it "should pass through Payload::Base and subclasses unchanged" do
+      payloads = [
+        RestClient::Payload::Base.new('foobar'),
+        RestClient::Payload::UrlEncoded.new({:foo => 'bar'}),
+        RestClient::Payload::Streamed.new(File.new(test_image_path)),
+        RestClient::Payload::Multipart.new({myfile: File.new(test_image_path)}),
+      ]
+
+      payloads.each do |payload|
+        expect(RestClient::Payload.generate(payload)).to equal(payload)
+      end
+    end
   end
 end

data/spec/unit/raw_response_spec.rb

@@ -2,9 +2,9 @@ require_relative '_lib'
 
 describe RestClient::RawResponse do
   before do
-    @tf = double("Tempfile", :read => "the answer is 42", :open => true)
+    @tf = double("Tempfile", :read => "the answer is 42", :open => true, :rewind => true)
     @net_http_res = double('net http response')
-    @request = double('http request')
+    @request = double('restclient request', :redirection_history => nil)
     @response = RestClient::RawResponse.new(@tf, @net_http_res, @request)
   end
 
@@ -15,4 +15,8 @@ describe RestClient::RawResponse do
   it "exposes a Tempfile" do
     expect(@response.file).to eq @tf
   end
+
+  it "includes AbstractResponse" do
+    expect(RestClient::RawResponse.ancestors).to include(RestClient::AbstractResponse)
+  end
 end

data/spec/unit/request2_spec.rb

@@ -1,23 +1,23 @@
 require_relative '_lib'
 
-describe RestClient::Request do
+describe RestClient::Request, :include_helpers do
 
   context 'params for GET requests' do
     it "manage params for get requests" do
-      stub_request(:get, 'http://some/resource?a=b&c=d').with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip, deflate', 'Foo'=>'bar'}).to_return(:body => 'foo', :status => 200)
+      stub_request(:get, 'http://some/resource?a=b&c=d').with(:headers => {'Accept'=>'*/*', 'Foo'=>'bar'}).to_return(:body => 'foo', :status => 200)
       expect(RestClient::Request.execute(:url => 'http://some/resource', :method => :get, :headers => {:foo => :bar, :params => {:a => :b, 'c' => 'd'}}).body).to eq 'foo'
 
-      stub_request(:get, 'http://some/resource').with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip, deflate', 'Foo'=>'bar'}).to_return(:body => 'foo', :status => 200)
+      stub_request(:get, 'http://some/resource').with(:headers => {'Accept'=>'*/*', 'Foo'=>'bar'}).to_return(:body => 'foo', :status => 200)
       expect(RestClient::Request.execute(:url => 'http://some/resource', :method => :get, :headers => {:foo => :bar, :params => :a}).body).to eq 'foo'
     end
 
     it 'adds GET params when params are present in URL' do
-      stub_request(:get, 'http://some/resource?a=b&c=d').with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip, deflate', 'Foo'=>'bar'}).to_return(:body => 'foo', :status => 200)
+      stub_request(:get, 'http://some/resource?a=b&c=d').with(:headers => {'Accept'=>'*/*', 'Foo'=>'bar'}).to_return(:body => 'foo', :status => 200)
       expect(RestClient::Request.execute(:url => 'http://some/resource?a=b', :method => :get, :headers => {:foo => :bar, :params => {:c => 'd'}}).body).to eq 'foo'
     end
 
     it 'encodes nested GET params' do
-      stub_request(:get, 'http://some/resource?a[foo][]=1&a[foo][]=2&a[bar]&b=foo+bar&math=2+%2B+2+%3D%3D+4').with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip, deflate'}).to_return(:body => 'foo', :status => 200)
+      stub_request(:get, 'http://some/resource?a[foo][]=1&a[foo][]=2&a[bar]&b=foo+bar&math=2+%2B+2+%3D%3D+4').with(:headers => {'Accept'=>'*/*',}).to_return(:body => 'foo', :status => 200)
       expect(RestClient::Request.execute(url: 'http://some/resource', method: :get, headers: {
         params: {
           a: {
@@ -37,15 +37,15 @@ describe RestClient::Request do
     block = proc do |http_response|
       response_value = http_response.body
     end
-    stub_request(:get, 'http://some/resource?a=b&c=d').with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip, deflate', 'Foo'=>'bar'}).to_return(:body => 'foo', :status => 200)
+    stub_request(:get, 'http://some/resource?a=b&c=d').with(:headers => {'Accept'=>'*/*', 'Foo'=>'bar'}).to_return(:body => 'foo', :status => 200)
     RestClient::Request.execute(:url => 'http://some/resource', :method => :get, :headers => {:foo => :bar, :params => {:a => :b, 'c' => 'd'}}, :block_response => block)
     expect(response_value).to eq "foo"
   end
 
   it 'closes payload if not nil' do
-    test_file = File.new(File.join( File.dirname(File.expand_path(__FILE__)), 'master_shake.jpg'))
+    test_file = File.new(test_image_path)
 
-    stub_request(:post, 'http://some/resource').with(:headers => {'Accept'=>'*/*', 'Accept-Encoding'=>'gzip, deflate'}).to_return(:body => 'foo', :status => 200)
+    stub_request(:post, 'http://some/resource').with(:headers => {'Accept'=>'*/*'}).to_return(:body => 'foo', :status => 200)
     RestClient::Request.execute(:url => 'http://some/resource', :method => :post, :payload => {:file => test_file})
 
     expect(test_file.closed?).to be true

data/spec/unit/request_spec.rb

@@ -27,46 +27,22 @@ describe RestClient::Request, :include_helpers do
     expect(@request.default_headers[:accept]).to eq '*/*'
   end
 
-  describe "compression" do
-
-    it "decodes an uncompressed result body by passing it straight through" do
-      expect(RestClient::Request.decode(nil, 'xyz')).to eq 'xyz'
-    end
-
-    it "doesn't fail for nil bodies" do
-      expect(RestClient::Request.decode('gzip', nil)).to be_nil
-    end
-
-
-    it "decodes a gzip body" do
-      expect(RestClient::Request.decode('gzip', "\037\213\b\b\006'\252H\000\003t\000\313T\317UH\257\312,HM\341\002\000G\242(\r\v\000\000\000")).to eq "i'm gziped\n"
-    end
-
-    it "ingores gzip for empty bodies" do
-      expect(RestClient::Request.decode('gzip', '')).to be_empty
-    end
-
-    it "decodes a deflated body" do
-      expect(RestClient::Request.decode('deflate', "x\234+\316\317MUHIM\313I,IMQ(I\255(\001\000A\223\006\363")).to eq "some deflated text"
-    end
-  end
-
   it "processes a successful result" do
-    res = response_double
+    res = res_double
     allow(res).to receive(:code).and_return("200")
     allow(res).to receive(:body).and_return('body')
     allow(res).to receive(:[]).with('content-encoding').and_return(nil)
-    expect(@request.send(:process_result, res).body).to eq 'body'
-    expect(@request.send(:process_result, res).to_s).to eq 'body'
+    expect(@request.send(:process_result, res, Time.now).body).to eq 'body'
+    expect(@request.send(:process_result, res, Time.now).to_s).to eq 'body'
   end
 
   it "doesn't classify successful requests as failed" do
     203.upto(207) do |code|
-      res = response_double
+      res = res_double
       allow(res).to receive(:code).and_return(code.to_s)
       allow(res).to receive(:body).and_return("")
       allow(res).to receive(:[]).with('content-encoding').and_return(nil)
-      expect(@request.send(:process_result, res)).to be_empty
+      expect(@request.send(:process_result, res, Time.now)).to be_empty
     end
   end
 
@@ -315,7 +291,7 @@ describe RestClient::Request, :include_helpers do
 
   describe "user headers" do
     it "merges user headers with the default headers" do
-      expect(@request).to receive(:default_headers).and_return({ :accept => '*/*', :accept_encoding => 'gzip, deflate' })
+      expect(@request).to receive(:default_headers).and_return({:accept => '*/*'})
       headers = @request.make_headers("Accept" => "application/json", :accept_encoding => 'gzip')
       expect(headers).to have_key "Accept-Encoding"
       expect(headers["Accept-Encoding"]).to eq "gzip"
@@ -472,12 +448,13 @@ describe RestClient::Request, :include_helpers do
     end
 
     it "does not attempt to send credentials if Authorization header is set" do
-      @request.headers['Authorization'] = 'Token abc123'
-      allow(@request).to receive(:user).and_return('joe')
-      allow(@request).to receive(:password).and_return('mypass')
-      req = double("request")
-      expect(req).not_to receive(:basic_auth)
-      @request.send(:setup_credentials, req)
+      ['Authorization', 'authorization', 'auTHORization', :authorization].each do |authorization|
+        headers = {authorization => 'Token abc123'}
+        request = RestClient::Request.new(method: :get, url: 'http://some/resource', headers: headers, user: 'joe', password: 'mypass')
+        req = double("net::http request")
+        expect(req).not_to receive(:basic_auth)
+        request.send(:setup_credentials, req)
+      end
     end
   end
 
@@ -535,25 +512,25 @@ describe RestClient::Request, :include_helpers do
 
   describe "exception" do
     it "raises Unauthorized when the response is 401" do
-      res = response_double(:code => '401', :[] => ['content-encoding' => ''], :body => '' )
-      expect { @request.send(:process_result, res) }.to raise_error(RestClient::Unauthorized)
+      res = res_double(:code => '401', :[] => ['content-encoding' => ''], :body => '' )
+      expect { @request.send(:process_result, res, Time.now) }.to raise_error(RestClient::Unauthorized)
     end
 
     it "raises ResourceNotFound when the response is 404" do
-      res = response_double(:code => '404', :[] => ['content-encoding' => ''], :body => '' )
-      expect { @request.send(:process_result, res) }.to raise_error(RestClient::ResourceNotFound)
+      res = res_double(:code => '404', :[] => ['content-encoding' => ''], :body => '' )
+      expect { @request.send(:process_result, res, Time.now) }.to raise_error(RestClient::ResourceNotFound)
     end
 
     it "raises RequestFailed otherwise" do
-      res = response_double(:code => '500', :[] => ['content-encoding' => ''], :body => '' )
-      expect { @request.send(:process_result, res) }.to raise_error(RestClient::InternalServerError)
+      res = res_double(:code => '500', :[] => ['content-encoding' => ''], :body => '' )
+      expect { @request.send(:process_result, res, Time.now) }.to raise_error(RestClient::InternalServerError)
     end
   end
 
   describe "block usage" do
     it "returns what asked to" do
-      res = response_double(:code => '401', :[] => ['content-encoding' => ''], :body => '' )
-      expect(@request.send(:process_result, res){|response, request| "foo"}).to eq "foo"
+      res = res_double(:code => '401', :[] => ['content-encoding' => ''], :body => '' )
+      expect(@request.send(:process_result, res, Time.now){|response, request| "foo"}).to eq "foo"
     end
   end
 
@@ -644,64 +621,74 @@ describe RestClient::Request, :include_helpers do
     it "logs a get request" do
       log = RestClient.log = []
       RestClient::Request.new(:method => :get, :url => 'http://url', :headers => {:user_agent => 'rest-client'}).log_request
-      expect(log[0]).to eq %Q{RestClient.get "http://url", "Accept"=>"*/*", "Accept-Encoding"=>"gzip, deflate", "User-Agent"=>"rest-client"\n}
+      expect(log[0]).to eq %Q{RestClient.get "http://url", "Accept"=>"*/*", "User-Agent"=>"rest-client"\n}
     end
 
     it "logs a post request with a small payload" do
       log = RestClient.log = []
       RestClient::Request.new(:method => :post, :url => 'http://url', :payload => 'foo', :headers => {:user_agent => 'rest-client'}).log_request
-      expect(log[0]).to eq %Q{RestClient.post "http://url", "foo", "Accept"=>"*/*", "Accept-Encoding"=>"gzip, deflate", "Content-Length"=>"3", "User-Agent"=>"rest-client"\n}
+      expect(log[0]).to eq %Q{RestClient.post "http://url", "foo", "Accept"=>"*/*", "Content-Length"=>"3", "User-Agent"=>"rest-client"\n}
     end
 
     it "logs a post request with a large payload" do
       log = RestClient.log = []
       RestClient::Request.new(:method => :post, :url => 'http://url', :payload => ('x' * 1000), :headers => {:user_agent => 'rest-client'}).log_request
-      expect(log[0]).to eq %Q{RestClient.post "http://url", 1000 byte(s) length, "Accept"=>"*/*", "Accept-Encoding"=>"gzip, deflate", "Content-Length"=>"1000", "User-Agent"=>"rest-client"\n}
+      expect(log[0]).to eq %Q{RestClient.post "http://url", 1000 byte(s) length, "Accept"=>"*/*", "Content-Length"=>"1000", "User-Agent"=>"rest-client"\n}
     end
 
     it "logs input headers as a hash" do
       log = RestClient.log = []
       RestClient::Request.new(:method => :get, :url => 'http://url', :headers => { :accept => 'text/plain', :user_agent => 'rest-client' }).log_request
-      expect(log[0]).to eq %Q{RestClient.get "http://url", "Accept"=>"text/plain", "Accept-Encoding"=>"gzip, deflate", "User-Agent"=>"rest-client"\n}
+      expect(log[0]).to eq %Q{RestClient.get "http://url", "Accept"=>"text/plain", "User-Agent"=>"rest-client"\n}
     end
 
     it "logs a response including the status code, content type, and result body size in bytes" do
       log = RestClient.log = []
-      res = double('result', :code => '200', :class => Net::HTTPOK, :body => 'abcd')
+      res = res_double(code: '200', class: Net::HTTPOK, body: 'abcd')
       allow(res).to receive(:[]).with('Content-type').and_return('text/html')
-      @request.log_response res
-      expect(log[0]).to eq "# => 200 OK | text/html 4 bytes\n"
+      response = response_from_res_double(res, @request)
+      response.log_response
+      expect(log).to eq ["# => 200 OK | text/html 4 bytes, 1.00s\n"]
     end
 
     it "logs a response with a nil Content-type" do
       log = RestClient.log = []
-      res = double('result', :code => '200', :class => Net::HTTPOK, :body => 'abcd')
+      res = res_double(code: '200', class: Net::HTTPOK, body: 'abcd')
       allow(res).to receive(:[]).with('Content-type').and_return(nil)
-      @request.log_response res
-      expect(log[0]).to eq "# => 200 OK |  4 bytes\n"
+      response = response_from_res_double(res, @request)
+      response.log_response
+      expect(log).to eq ["# => 200 OK |  4 bytes, 1.00s\n"]
     end
 
     it "logs a response with a nil body" do
       log = RestClient.log = []
-      res = double('result', :code => '200', :class => Net::HTTPOK, :body => nil)
+      res = res_double(code: '200', class: Net::HTTPOK, body: nil)
       allow(res).to receive(:[]).with('Content-type').and_return('text/html; charset=utf-8')
-      @request.log_response res
-      expect(log[0]).to eq "# => 200 OK | text/html 0 bytes\n"
+      response = response_from_res_double(res, @request)
+      response.log_response
+      expect(log).to eq ["# => 200 OK | text/html 0 bytes, 1.00s\n"]
     end
 
     it 'does not log request password' do
       log = RestClient.log = []
       RestClient::Request.new(:method => :get, :url => 'http://user:password@url', :headers => {:user_agent => 'rest-client'}).log_request
-      expect(log[0]).to eq %Q{RestClient.get "http://user:REDACTED@url", "Accept"=>"*/*", "Accept-Encoding"=>"gzip, deflate", "User-Agent"=>"rest-client"\n}
+      expect(log[0]).to eq %Q{RestClient.get "http://user:REDACTED@url", "Accept"=>"*/*", "User-Agent"=>"rest-client"\n}
+    end
+
+    it 'logs to a passed logger, if provided' do
+      logger = double('logger', '<<' => true)
+      expect(logger).to receive(:<<)
+      RestClient::Request.new(:method => :get, :url => 'http://user:password@url', log: logger).log_request
     end
   end
 
   it "strips the charset from the response content type" do
     log = RestClient.log = []
-    res = double('result', :code => '200', :class => Net::HTTPOK, :body => 'abcd')
+    res = res_double(code: '200', class: Net::HTTPOK, body: 'abcd')
     allow(res).to receive(:[]).with('Content-type').and_return('text/html; charset=utf-8')
-    @request.log_response res
-    expect(log[0]).to eq "# => 200 OK | text/html 4 bytes\n"
+    response = response_from_res_double(res, @request)
+    response.log_response
+    expect(log).to eq ["# => 200 OK | text/html 4 bytes, 1.00s\n"]
   end
 
   describe "timeout" do
@@ -1149,7 +1136,7 @@ describe RestClient::Request, :include_helpers do
     )
     net_http_res = Net::HTTPNoContent.new("", "204", "No Content")
     allow(net_http_res).to receive(:read_body).and_return(nil)
-    expect(@http).to receive(:request).and_return(@request.send(:fetch_body, net_http_res))
+    expect(@http).to receive(:request).and_return(net_http_res)
     response = @request.send(:transmit, @uri, 'req', 'payload')
     expect(response).not_to be_nil
     expect(response.code).to eq 204
@@ -1167,7 +1154,8 @@ describe RestClient::Request, :include_helpers do
 
       net_http_res = Net::HTTPOK.new(nil, "200", "body")
       allow(net_http_res).to receive(:read_body).and_return("body")
-      @request.send(:fetch_body, net_http_res)
+      received_tempfile = @request.send(:fetch_body_to_tempfile, net_http_res)
+      expect(received_tempfile).to eq tempfile
     end
   end
 
@@ -1233,10 +1221,10 @@ describe RestClient::Request, :include_helpers do
       expect(@request.process_url_params('https://example.com/', params: {
         foo: [1,2,3],
         null: nil,
-        false: false,
+        falsy: false,
         math: '2+2=4',
         nested: {'key + escaped' => 'value + escaped', other: [], arr: [1,2]},
-      })).to eq 'https://example.com/?foo[]=1&foo[]=2&foo[]=3&null&false=false&math=2%2B2%3D4' \
+      })).to eq 'https://example.com/?foo[]=1&foo[]=2&foo[]=3&null&falsy=false&math=2%2B2%3D4' \
                    '&nested[key+%2B+escaped]=value+%2B+escaped&nested[other]' \
                    '&nested[arr][]=1&nested[arr][]=2'
     end