rest-client 2.0.2-x64-mingw32 → 2.1.0.rc1-x64-mingw32

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
 

data/spec/unit/resource_spec.rb

@@ -7,37 +7,37 @@ describe RestClient::Resource do
 
   context "Resource delegation" do
     it "GET" do
-      expect(RestClient::Request).to receive(:execute).with(:method => :get, :url => 'http://some/resource', :headers => {'X-Something' => '1'}, :user => 'jane', :password => 'mypass')
+      expect(RestClient::Request).to receive(:execute).with(:method => :get, :url => 'http://some/resource', :headers => {'X-Something' => '1'}, :user => 'jane', :password => 'mypass', :log => nil)
       @resource.get
     end
 
     it "HEAD" do
-      expect(RestClient::Request).to receive(:execute).with(:method => :head, :url => 'http://some/resource', :headers => {'X-Something' => '1'}, :user => 'jane', :password => 'mypass')
+      expect(RestClient::Request).to receive(:execute).with(:method => :head, :url => 'http://some/resource', :headers => {'X-Something' => '1'}, :user => 'jane', :password => 'mypass', :log => nil)
       @resource.head
     end
 
     it "POST" do
-      expect(RestClient::Request).to receive(:execute).with(:method => :post, :url => 'http://some/resource', :payload => 'abc', :headers => {:content_type => 'image/jpg', 'X-Something' => '1'}, :user => 'jane', :password => 'mypass')
+      expect(RestClient::Request).to receive(:execute).with(:method => :post, :url => 'http://some/resource', :payload => 'abc', :headers => {:content_type => 'image/jpg', 'X-Something' => '1'}, :user => 'jane', :password => 'mypass', :log => nil)
       @resource.post 'abc', :content_type => 'image/jpg'
     end
 
     it "PUT" do
-      expect(RestClient::Request).to receive(:execute).with(:method => :put, :url => 'http://some/resource', :payload => 'abc', :headers => {:content_type => 'image/jpg', 'X-Something' => '1'}, :user => 'jane', :password => 'mypass')
+      expect(RestClient::Request).to receive(:execute).with(:method => :put, :url => 'http://some/resource', :payload => 'abc', :headers => {:content_type => 'image/jpg', 'X-Something' => '1'}, :user => 'jane', :password => 'mypass', :log => nil)
       @resource.put 'abc', :content_type => 'image/jpg'
     end
 
     it "PATCH" do
-      expect(RestClient::Request).to receive(:execute).with(:method => :patch, :url => 'http://some/resource', :payload => 'abc', :headers => {:content_type => 'image/jpg', 'X-Something' => '1'}, :user => 'jane', :password => 'mypass')
+      expect(RestClient::Request).to receive(:execute).with(:method => :patch, :url => 'http://some/resource', :payload => 'abc', :headers => {:content_type => 'image/jpg', 'X-Something' => '1'}, :user => 'jane', :password => 'mypass', :log => nil)
       @resource.patch 'abc', :content_type => 'image/jpg'
     end
 
     it "DELETE" do
-      expect(RestClient::Request).to receive(:execute).with(:method => :delete, :url => 'http://some/resource', :headers => {'X-Something' => '1'}, :user => 'jane', :password => 'mypass')
+      expect(RestClient::Request).to receive(:execute).with(:method => :delete, :url => 'http://some/resource', :headers => {'X-Something' => '1'}, :user => 'jane', :password => 'mypass', :log => nil)
       @resource.delete
     end
 
     it "overrides resource headers" do
-      expect(RestClient::Request).to receive(:execute).with(:method => :get, :url => 'http://some/resource', :headers => {'X-Something' => '2'}, :user => 'jane', :password => 'mypass')
+      expect(RestClient::Request).to receive(:execute).with(:method => :get, :url => 'http://some/resource', :headers => {'X-Something' => '2'}, :user => 'jane', :password => 'mypass', :log => nil)
       @resource.get 'X-Something' => '2'
     end
   end

data/spec/unit/response_spec.rb

@@ -2,10 +2,10 @@ require_relative '_lib'
 
 describe RestClient::Response, :include_helpers do
   before do
-    @net_http_res = double('net http response', :to_hash => {"Status" => ["200 OK"]}, :code => 200)
+    @net_http_res = res_double(to_hash: {'Status' => ['200 OK']}, code: '200', body: 'abc')
     @example_url = 'http://example.com'
     @request = request_double(url: @example_url, method: 'get')
-    @response = RestClient::Response.create('abc', @net_http_res, @request)
+    @response = response_from_res_double(@net_http_res, @request, duration: 1)
   end
 
   it "behaves like string" do
@@ -17,6 +17,7 @@ describe RestClient::Response, :include_helpers do
   end
 
   it "accepts nil strings and sets it to empty for the case of HEAD" do
+    # TODO
     expect(RestClient::Response.create(nil, @net_http_res, @request).to_s).to eq ""
   end
 
@@ -27,13 +28,13 @@ describe RestClient::Response, :include_helpers do
     end
 
     it 'handles multiple headers by joining with comma' do
-      @net_http_res = double('net http response', :to_hash => {'My-Header' => ['foo', 'bar']}, :code => 200)
-      @example_url = 'http://example.com'
-      @request = request_double(url: @example_url, method: 'get')
-      @response = RestClient::Response.create('abc', @net_http_res, @request)
+      net_http_res = res_double(to_hash: {'My-Header' => ['foo', 'bar']}, code: '200', body: nil)
+      example_url = 'http://example.com'
+      request = request_double(url: example_url, method: 'get')
+      response = response_from_res_double(net_http_res, request)
 
-      expect(@response.raw_headers['My-Header']).to eq ['foo', 'bar']
-      expect(@response.headers[:my_header]).to eq 'foo, bar'
+      expect(response.raw_headers['My-Header']).to eq ['foo', 'bar']
+      expect(response.headers[:my_header]).to eq 'foo, bar'
     end
   end
 
@@ -72,7 +73,7 @@ describe RestClient::Response, :include_helpers do
   describe "exceptions processing" do
     it "should return itself for normal codes" do
       (200..206).each do |code|
-        net_http_res = response_double(:code => '200')
+        net_http_res = res_double(:code => '200')
         resp = RestClient::Response.create('abc', net_http_res, @request)
         resp.return!
       end
@@ -81,7 +82,7 @@ describe RestClient::Response, :include_helpers do
     it "should throw an exception for other codes" do
       RestClient::Exceptions::EXCEPTIONS_MAP.each_pair do |code, exc|
         unless (200..207).include? code
-          net_http_res = response_double(:code => code.to_i)
+          net_http_res = res_double(:code => code.to_i)
           resp = RestClient::Response.create('abc', net_http_res, @request)
           allow(@request).to receive(:max_redirects).and_return(5)
           expect { resp.return! }.to raise_error(exc)
@@ -131,28 +132,27 @@ describe RestClient::Response, :include_helpers do
     end
 
     it "doesn't follow a 301 when the request is a post" do
-      net_http_res = response_double(:code => 301)
+      net_http_res = res_double(:code => 301)
+      response = response_from_res_double(net_http_res, request_double(method: 'post'))
 
-      response = RestClient::Response.create('abc', net_http_res,
-                                             request_double(method: 'post'))
       expect {
         response.return!
       }.to raise_error(RestClient::MovedPermanently)
     end
 
     it "doesn't follow a 302 when the request is a post" do
-      net_http_res = response_double(:code => 302)
-      response = RestClient::Response.create('abc', net_http_res,
-                                             request_double(method: 'post'))
+      net_http_res = res_double(:code => 302)
+      response = response_from_res_double(net_http_res, request_double(method: 'post'))
+
       expect {
         response.return!
       }.to raise_error(RestClient::Found)
     end
 
     it "doesn't follow a 307 when the request is a post" do
-      net_http_res = response_double(:code => 307)
-      response = RestClient::Response.create('abc', net_http_res,
-                                             request_double(method: 'post'))
+      net_http_res = res_double(:code => 307)
+      response = response_from_res_double(net_http_res, request_double(method: 'post'))
+
       expect(response).not_to receive(:follow_redirection)
       expect {
         response.return!
@@ -160,9 +160,8 @@ describe RestClient::Response, :include_helpers do
     end
 
     it "doesn't follow a redirection when the request is a put" do
-      net_http_res = response_double(:code => 301)
-      response = RestClient::Response.create('abc', net_http_res,
-                                             request_double(method: 'put'))
+      net_http_res = res_double(:code => 301)
+      response = response_from_res_double(net_http_res, request_double(method: 'put'))
       expect {
         response.return!
       }.to raise_error(RestClient::MovedPermanently)
@@ -238,4 +237,16 @@ describe RestClient::Response, :include_helpers do
     end
   end
 
+  describe "logging" do
+    it "uses the request's logger" do
+      stub_request(:get, 'http://some/resource').to_return(body: 'potato', status: 200)
+
+      logger = double('logger', '<<' => true)
+      request = RestClient::Request.new(url: 'http://some/resource', method: :get, log: logger)
+
+      expect(logger).to receive(:<<)
+
+      request.execute
+    end
+  end
 end