patron 0.13.3 → 0.14.0

data/spec/session_spec.rb

@@ -4,9 +4,18 @@ require 'yaml'
 require 'base64'
 require 'fileutils'
 require 'securerandom'
+require 'timeout'
 
 describe Patron::Session do
 
+  def yaml_load(str)
+    if RUBY_VERSION >= '3.1.0'
+      YAML::safe_load(str, permitted_classes: [OpenStruct])
+    else
+      YAML::load(str)
+    end
+  end
+
   before(:each) do
     @session = Patron::Session.new
     @session.base_url = "http://localhost:9001"
@@ -59,6 +68,16 @@ describe Patron::Session do
       unescaped = @session.unescape(escaped)
       expect(unescaped).to be == string
     end
+
+    it "unescapes a %00 to a NUL byte instead of cutting the string there" do
+      expect(@session.unescape("a%00b").b).to be == "a\0b".b
+      expect(@session.escape("a\0b")).to be == "a%00b"
+    end
+
+    it "rejects a file path with an embedded NUL byte" do
+      expect { @session.enable_debug("/tmp/x\0y") }.to raise_error(ArgumentError)
+      expect { @session.handle_cookies("/tmp/x\0y") }.to raise_error(ArgumentError)
+    end
   end
   
   it "should raise an error when passed an invalid action" do
@@ -72,10 +91,23 @@ describe Patron::Session do
 
   it "should retrieve a url with :get" do
     response = @session.get("/test")
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.request_method).to be == "GET"
   end
 
+  it "should expose curl's cumulative transfer timings" do
+    timings = @session.get("/test").timings
+
+    expect(timings.keys).to contain_exactly(
+      :namelookup, :connect, :appconnect, :pretransfer, :starttransfer, :redirect, :total
+    )
+    expect(timings.values).to all(be_a(Float).and(be >= 0))
+    expect(timings[:namelookup]).to be <= timings[:connect]
+    expect(timings[:connect]).to be <= timings[:starttransfer]
+    expect(timings[:starttransfer]).to be <= timings[:total]
+    expect(timings[:total]).to be > 0
+  end
+
   it "should use full base url" do
     @session.base_url = "http://localhost:9001/api/v1"
     response = @session.get("/test")
@@ -88,38 +120,68 @@ describe Patron::Session do
   end
 
   it "should download content with :get and a file path" do
-    tmpfile = "/tmp/patron_test.yaml"
+    tf = Tempfile.new
+    tf.close
+    tmpfile = tf.path
+
     response = @session.get_file "/test", tmpfile
     expect(response.body).to be_nil
-    body = YAML::load_file(tmpfile)
+    body = yaml_load(File.open(tmpfile).read)
     expect(body.request_method).to be == "GET"
-    FileUtils.rm tmpfile
   end
 
   it "should download correctly(md5 ok) with get_file" do
-    tmpfile = "/tmp/picture"
+    tf = Tempfile.new
+    tf.close
+    tmpfile = tf.path
+
     response = @session.get_file "/picture", tmpfile
     expect(response.body).to be_nil
     expect(File.size(File.join(File.dirname(__FILE__),"../pic.png"))).to be == File.size(tmpfile)
-    FileUtils.rm tmpfile
+  end
+
+  it "should follow a 307 redirect with Range headers" do
+    tf = Tempfile.new
+    tf.close
+    tmpfile = tf.path
+
+    response = @session.get_file "/redirect-to-picture", tmpfile, {'Range' => 'bytes=0-3'}
+    expect(response.body).to be_nil
+    expect(File.size(tmpfile)).to eq(4)
   end
 
   it "downloads a very large file" do
-    tmpfile = "/tmp/large-succeeded"
+    tf = Tempfile.new
+    tf.close
+    tmpfile = tf.path
+
     @session.get_file "/very-large", tmpfile
     expect(File.size(tmpfile)).to eq(15 * 1024 * 1024)
   end
 
   it "raises an exception if the download body limit is exceeded when using direct-to-file download" do
-    tmpfile = "/tmp/large-aborted"
+    tf = Tempfile.new
+    tf.close
+    tmpfile = tf.path
+
     @session.download_byte_limit = 1024
     @session.buffer_size = 1024
     expect {
       @session.get_file "/very-large", tmpfile
     }.to raise_error(Patron::Error)
     # On Ruby 2.x Patron::Aborted takes precedence, but
-    # on 1.9 it will be Patron::PartialFileError
-    expect(File.size(tmpfile)).to be < (1024 * 3)
+    # on 1.9 it will be Patron::PartialFileError, so we cannot match on exception.
+    #
+    # Not clear why, but Patron (or libCURL, or the two in combination)
+    # may fetch more bytes than we permit it to - for example,
+    # on Darwin the limit is respected exactly, while on Linux in GH actions
+    # it does retrieve substantially more.
+    # The URL we are hitting is serving a file that is 15 megabytes. On Linux
+    # the tempfile fills to 103344 in our tests, so this is probably either
+    # OS-dependent or related to timings with the RubyVM context switching.
+    # To ensure our limiting works, it is enough to check that the downloaded file
+    # is perceptibly smaller than the complete size of 15MB. Let's say < 1MB.
+    expect(File.size(tmpfile)).to be < (1024 * 1024)
   end
 
   it "raises an exception if the download body limit is exceeded when using download-to-memory" do
@@ -132,36 +194,44 @@ describe Patron::Session do
     # on 1.9 it will be Patron::PartialFileError
   end
 
+  it "accepts a download body limit above 2 GiB and timeouts given as Floats" do
+    @session.download_byte_limit = 5 * 1024 * 1024 * 1024
+    @session.dns_cache_timeout = 2.5
+    @session.low_speed_time = 2.5
+    @session.low_speed_limit = 1.5
+    expect(@session.get("/test").status).to be == 200
+  end
+
   it "should not send the user-agent if it has been deleted from headers" do
     @session.headers.delete 'User-Agent'
     response = @session.get("/test")
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.header["user-agent"]).to be_nil
   end
   
   it "should set the default User-agent" do
     response = @session.get("/test")
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.header["user-agent"]).to be == [Patron.user_agent_string]
   end
 
   it "should include custom headers in a request" do
     response = @session.get("/test", {"User-Agent" => "PatronTest"})
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.header["user-agent"]).to be == ["PatronTest"]
   end
 
   it "should include default headers in a request, if they were defined" do
     @session.headers = {"User-Agent" => "PatronTest"}
     response = @session.get("/test")
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.header["user-agent"]).to be == ["PatronTest"]
   end
 
   it "should merge custom headers with session headers" do
     @session.headers["X-Test"] = "Testing"
     response = @session.get("/test", {"User-Agent" => "PatronTest"})
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.header["user-agent"]).to be == ["PatronTest"]
     expect(body.header["x-test"]).to be == ["Testing"]
   end
@@ -181,70 +251,141 @@ describe Patron::Session do
     expect {@session.get("/timeout?millis=400")}.to raise_error(Patron::TimeoutError)
   end
 
-  it "should raise an exception on timeout when reading from a slow resource" do
-    @session.timeout = 40
+  it "should raise an exception on timeout when reading from a slow resource and low speed limit is set", :timing do
+    @session.timeout = 10 # Greater than the low_speed_time
     @session.low_speed_time = 2
     @session.low_speed_limit = 10
+
+    # Our test server starts sending the body only after 5 seconds. We should be able to abort
+    # by exceeding the low_speed_time.
+    started = Time.now.to_f
     expect {@session.get("/slow")}.to raise_error(Patron::TimeoutError)
+    delta_s = Time.now.to_f - started
+    # For some reason libCURL times out after 3 seconds instead of 2 sometimes.
+    expect(delta_s).to be_within(0.1).of(2).or be_within(0.1).of(3)
   end
 
-  it "is able to terminate the thread that is running a slow request using Thread#kill (uses the custom unblock)" do
+  it "is able to terminate the thread that is running a slow request using Thread#kill (uses the custom unblock)", :timing do
     t = Thread.new do
       session = Patron::Session.new
-      session.timeout = 40
+      session.timeout = 10 # Greater than the sleep duration
       session.base_url = "http://localhost:9001"
       session.get("/slow")
     end
 
-    # Our test server starts sending the body only after 20 seconds. We should be able to abort
+    # Our test server starts sending the body only after 5 seconds. We should be able to abort
     # using a signal during that time.
-    started = Time.now.to_i
-    sleep 5 # Less than what it takes for the server to respond
+    started = Time.now.to_f
+    sleep 2 # Less than what it takes for the server to respond
     t.kill # Kill the thread forcibly
-    t.join # wrap up the thread. If Patron is still busy there, this join call will still take 15s.
+    t.join # wrap up the thread. If Patron is still busy there, this join call will still take another 1s.
 
-    delta_s = Time.now.to_i - started
-    expect(delta_s).to be_within(2).of(5)
+    delta_s = Time.now.to_f - started
+    # For some reason libCURL times out after 3 seconds instead of 2 sometimes.
+    expect(delta_s).to be_within(0.1).of(2).or be_within(0.1).of(3)
   end
 
-  it "is able to terminate the thread that is running a slow request" do
+  it "is able to terminate the process that is running a slow request with SIGINT", :timing do
     pid = Process.fork do
       trap('SIGINT') do
         exit # exit the process
       end
       session = Patron::Session.new
-      session.timeout = 40
+      session.timeout = 10 # Greater than the sleep duration
       session.base_url = "http://localhost:9001"
       session.get("/slow")
     end
 
-    # Our test server starts sending the body only after 20 seconds. We should be able to abort
+    # Our test server starts sending the body only after 5 seconds. We should be able to abort
     # using a signal during that time.
-    started = Time.now.to_i
-    sleep 5 # Less than what it takes for the server to respond
-    Process.kill("INT", pid) # Signal ourselves...
-    Process.wait(pid) # wrap up the process. If Patron is still busy there, this call will still take 15s.
-    delta_s = Time.now.to_i - started
-    expect(delta_s).to be_within(2).of(5)
+    started = Time.now.to_f
+    sleep 2 # Less than what it takes for the server to respond
+    Process.kill("INT", pid) # Signal the process...
+    Process.wait(pid) # wrap up the process. If Patron is still busy there, this call will still take another 1s.
+    delta_s = Time.now.to_f - started
+    # For some reason libCURL times out after 3 seconds instead of 2 sometimes.
+    expect(delta_s).to be_within(0.1).of(2).or be_within(0.1).of(3)
   end
 
   it "receives progress callbacks" do
     session = Patron::Session.new
-    session.timeout = 40
+    session.timeout = 10 # # Greater than the /slow respond time (5 seconds)
     session.base_url = "http://localhost:9001"
     callback_args = []
     session.progress_callback = Proc.new {|dltotal, dlnow, ultotal, ulnow|
       callback_args << [dltotal, dlnow, ultotal, ulnow]
     }
     session.get("/slow")
+    expect(callback_args).not_to be_empty
 
+    # Make sure that the callback setting was not reset.
+    callback_args = []
+    session.get("/slow")
     expect(callback_args).not_to be_empty
   end
 
+  it "propagates an exception raised in the progress callback and keeps the session usable" do
+    session = Patron::Session.new
+    session.timeout = 10
+    session.base_url = "http://localhost:9001"
+    boom = Class.new(StandardError)
+    session.progress_callback = Proc.new { raise boom, "from the callback" }
+
+    expect { session.get("/slow") }.to raise_error(boom, "from the callback")
+
+    session.progress_callback = nil
+    expect(session.get("/test").status).to be == 200
+  end
+
+  it "lets a throw from the progress callback unwind to the catch around the request" do
+    # Timeout.timeout on Rubies before 3.1 unwinds with throw rather than raise
+    session = Patron::Session.new
+    session.timeout = 10
+    session.base_url = "http://localhost:9001"
+    session.progress_callback = Proc.new { throw :stop_right_there, :thrown }
+
+    expect(catch(:stop_right_there) { session.get("/slow") }).to be == :thrown
+
+    session.progress_callback = nil
+    expect(session.get("/test").status).to be == 200
+  end
+
+  it "can be interrupted with Timeout.timeout while a progress callback is set", :timing do
+    session = Patron::Session.new
+    session.timeout = 10
+    session.base_url = "http://localhost:9001"
+    session.progress_callback = Proc.new { |*| }
+
+    started = Time.now.to_f
+    expect { Timeout.timeout(1) { session.get("/slow") } }.to raise_error(Timeout::Error)
+    expect(Time.now.to_f - started).to be < 3
+
+    session.progress_callback = nil
+    expect(session.get("/test").status).to be == 200
+  end
+
+  it "raises the right exception class after the heap has been compacted" do
+    # The exception classes are looked up from C once at load time; if they
+    # were not registered with the GC, compaction would move them away
+    skip "no compaction on this Ruby" unless GC.respond_to?(:verify_compaction_references)
+    begin
+      begin
+        GC.verify_compaction_references(expand_heap: true, toward: :empty)
+      rescue ArgumentError # expand_heap: is double_heap: on Rubies before 3.2
+        GC.verify_compaction_references(double_heap: true, toward: :empty)
+      end
+    rescue NotImplementedError
+      skip "compaction is not supported on this platform"
+    end
+
+    session = Patron::Session.new
+    expect { session.get("http://localhost:1/") }.to raise_error(Patron::ConnectionFailed)
+  end
+
   it "should follow redirects by default" do
     @session.max_redirects = 1
     response = @session.get("/redirect")
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(response.status).to be == 200
     expect(body.path).to be == "/test"
   end
@@ -277,26 +418,26 @@ describe Patron::Session do
 
   it "should send a delete request with :delete" do
     response = @session.delete("/test")
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.request_method).to be == "DELETE"
   end
 
   it "should send a COPY request with :copy" do
     response = @session.copy("/test", "/test2")
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.request_method).to be == "COPY"
   end
 
   it "should include a Destination header in COPY requests" do
     response = @session.copy("/test", "/test2")
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.header['destination'].first).to be == "/test2"
   end
 
   it "should upload data with :get" do
     data = "upload data"
     response = @session.request(:get, "/test", {}, :data => data)
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.request_method).to be == "GET"
     expect(body.header['content-length']).to be == [data.size.to_s]
   end
@@ -304,7 +445,7 @@ describe Patron::Session do
   it "should call to_s on the data being uploaded via GET if it is not already a String" do
     data = 12345
     response = @session.request(:get, "/test", {}, :data => data)
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.request_method).to be == "GET"
   end
   
@@ -315,7 +456,7 @@ describe Patron::Session do
     # you can have very deeply going queries, which are still technically GETs
     data = Random.new.bytes(1024 * 24)
     response = @session.request(:get, "/test", {}, :data => data)
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.request_method).to be == "GET"
     expect(body.header['content-length']).to be == [data.size.to_s]
   end
@@ -323,7 +464,7 @@ describe Patron::Session do
   it "should upload data with :put" do
     data = Random.new.bytes(1024 * 24)
     response = @session.put("/test", data)
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.request_method).to be == "PUT"
     expect(body.header['content-length']).to be == [data.size.to_s]
   end
@@ -334,7 +475,7 @@ describe Patron::Session do
     data.flush; data.rewind
     
     response = @session.put("/test", data, {'Expect' => ''})
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.request_method).to be == "PUT"
     expect(body.header['content-length']).to be == [data.size.to_s]
   end
@@ -342,25 +483,45 @@ describe Patron::Session do
   it "should upload data with :patch" do
     data = "upload data"
     response = @session.patch("/testpatch", data)
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.body).to eq("upload data")
   end
 
   it "should upload data with :delete" do
     data = "upload data"
     response = @session.request(:delete, "/test", {}, :data => data)
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.request_method).to be == "DELETE"
     expect(body.header['content-length']).to be == [data.size.to_s]
   end
 
+  it "keeps a request body built by #to_s alive for the duration of the transfer" do
+    # The body only exists as the return value of #to_s, and libcurl reads it
+    # while the GVL is released - GC.stress makes that window reliable
+    payload = Random.new.bytes(64 * 1024)
+    body_object = Object.new
+    body_object.define_singleton_method(:to_s) { payload + '' }
+
+    begin
+      GC.stress = true
+      [:post, :put, :delete].each do |verb|
+        response = @session.request(verb, "/test", {}, :data => body_object)
+        body = yaml_load(response.body)
+        expect(body.request_method).to be == verb.to_s.upcase
+        expect(body.body.b).to be == payload
+      end
+    ensure
+      GC.stress = false
+    end
+  end
+
   it "should raise when no data is provided to :put" do
     expect { @session.put("/test", nil) }.to raise_error(ArgumentError)
   end
 
   it "should upload a file with :put" do
     response = @session.put_file("/test", "LICENSE")
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.request_method).to be == "PUT"
   end
 
@@ -368,23 +529,33 @@ describe Patron::Session do
     expect { @session.put_file("/test", nil) }.to raise_error(ArgumentError)
   end
 
-  it "should use chunked encoding when uploading a file with :put" do
-    response = @session.put_file("/test", "LICENSE")
-    body = YAML::load(response.body)
-    expect(body.header['transfer-encoding'].first).to be == "chunked"
+  it "should upload a file with :put using chunked transfer-encoding" do
+    # Transfer-Encoding is a hop-by-hop header (RFC 7230 3.3.1): a conformant server
+    # decodes the chunked framing and never exposes the header to the application, so
+    # we capture the raw request to assert how Patron actually frames the upload.
+    captured = capture_request do |url|
+      session = Patron::Session.new
+      session.base_url = url
+      session.timeout = 5
+      session.put_file("/test", "LICENSE")
+    end
+    expect(captured.request_line).to start_with("PUT ")
+    expect(captured.headers["transfer-encoding"]).to be == "chunked"
+    expect(captured.headers).to_not have_key("content-length")
+    expect(captured.body.bytesize).to be == File.size("LICENSE")
   end
   
   it "should call to_s on the data being uploaded via POST if it is not already a String" do
     data = 12345
     response = @session.post("/testpost", data)
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body['body']).to eq("12345")
   end
   
   it "should upload data with :post" do
     data = "upload data"
     response = @session.post("/test", data)
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.request_method).to be == "POST"
     expect(body.header['content-length']).to be == [data.size.to_s]
   end
@@ -392,7 +563,7 @@ describe Patron::Session do
   it "should POST a hash of arguments as a urlencoded form" do
     data = {:foo => 123, 'baz' => '++hello world++'}
     response = @session.post("/testpost", data)
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body['content_type']).to be == "application/x-www-form-urlencoded"
     expect(body['body']).to match(/baz=%2B%2Bhello%20world%2B%2B/)
     expect(body['body']).to match(/foo=123/)
@@ -404,42 +575,66 @@ describe Patron::Session do
 
   it "should upload a file with :post" do
     response = @session.post_file("/test", "LICENSE")
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.request_method).to be == "POST"
   end
 
   it "should upload a multipart with :post" do
     response = @session.post_multipart("/test", { :test_data => "123" }, { :test_file => "LICENSE" } )
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.request_method).to be == "POST"
   end
 
+  it "sends multipart field names and binary values intact" do
+    # A Symbol key gets stringified into a temporary libcurl must copy,
+    # and a value with NUL bytes must survive past the first one
+    value = "before\0middle\0after".b
+    response = @session.post_multipart("/test", { :sym_key => value }, { :test_file => "LICENSE" })
+    body = yaml_load(response.body)
+    raw = body.body.b
+    expect(raw).to include('name="sym_key"')
+    expect(raw).to include(value)
+    expect(raw).to include('name="test_file"; filename="LICENSE"')
+    expect(raw).to include(File.read("LICENSE").b)
+  end
+
   it "should raise when no file is provided to :post" do
     expect { @session.post_file("/test", nil) }.to raise_error(ArgumentError)
   end
 
-  it "should use chunked encoding when uploading a file with :post" do
-    response = @session.post_file("/test", "LICENSE")
-    body = YAML::load(response.body)
-    expect(body.header['transfer-encoding'].first).to be == "chunked"
+  it "should upload a file with :post using chunked transfer-encoding" do
+    # See the :put counterpart above: Transfer-Encoding is hop-by-hop and invisible
+    # to the application, so we capture the raw request to assert the framing.
+    captured = capture_request do |url|
+      session = Patron::Session.new
+      session.base_url = url
+      session.timeout = 5
+      session.post_file("/test", "LICENSE")
+    end
+    expect(captured.request_line).to start_with("POST ")
+    expect(captured.headers["transfer-encoding"]).to be == "chunked"
+    expect(captured.headers).to_not have_key("content-length")
+    expect(captured.body.bytesize).to be == File.size("LICENSE")
   end
 
   it "should pass credentials as http basic auth" do
     @session.username = "foo"
     @session.password = "bar"
     response = @session.get("/test")
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.header['authorization']).to be == [encode_authz("foo", "bar")]
   end
 
   it "should store cookies across multiple requests" do
     tf = Tempfile.new('cookiejar')
+    tf.close
     cookie_jar_path = tf.path
     
     @session.handle_cookies(cookie_jar_path)
     response = @session.get("/setcookie").body
     
-    cookie_jar_contents = tf.read
+    cookie_jar_contents = tf.open.read
+    tf.unlink
     expect(cookie_jar_contents).not_to be_empty
     expect(cookie_jar_contents).to include('Netscape HTTP Cookie File')
   end
@@ -447,12 +642,12 @@ describe Patron::Session do
   it "should handle cookies if set" do
     @session.handle_cookies
     response = @session.get("/setcookie").body
-    expect(YAML::load(response).header['cookie'].first).to be == "session_id=foo123"
+    expect(yaml_load(response).header['cookie'].first).to be == "session_id=foo123"
   end
 
   it "should not handle cookies by default" do
     response = @session.get("/setcookie").body
-    expect(YAML::load(response).header).to_not include('cookie')
+    expect(yaml_load(response).header).to_not include('cookie')
   end
 
   it "should ignore a wrong Content-Length when asked to" do
@@ -473,6 +668,31 @@ describe Patron::Session do
     expect { @session.handle_cookies("/trash/clash/foo") }.to raise_error(ArgumentError)
   end
 
+  it "refuses to run two requests on one Session from two threads at the same time" do
+    session = Patron::Session.new
+    session.timeout = 10
+    session.base_url = "http://localhost:9001"
+
+    outcomes = Array.new(2) do
+      Thread.new do
+        begin
+          session.get("/slow")
+          :completed
+        rescue Patron::Error => e
+          e
+        end
+      end
+    end.map(&:value)
+
+    refused = outcomes.grep(Patron::Error)
+    expect(refused.size).to be == 1
+    expect(refused.first.message).to include("another thread")
+    expect(outcomes - refused).to be == [:completed]
+
+    # ...and is free again once the in-flight request is done
+    expect(session.get("/test").status).to be == 200
+  end
+
   it "should work with multiple threads" do
     threads = []
     3.times do
@@ -497,7 +717,7 @@ describe Patron::Session do
 
     expect {
       response = @session.get("/test")
-      body = YAML::load(response.body)
+      body = yaml_load(response.body)
     }.to_not raise_error
 
     expect(body.request_method).to be == "GET"
@@ -516,13 +736,13 @@ describe Patron::Session do
   
   it "should serialize query params and append them to the url" do
     response = @session.request(:get, "/test", {}, :query => {:foo => "bar"})
-    request = YAML::load(response.body)
+    request = yaml_load(response.body)
     expect(request.path + '?' + request.query_string).to be == "/test?foo=bar"
   end
 
   it "should merge parameters in the :query option with pre-existing query parameters" do
     response = @session.request(:get, "/test?foo=bar", {}, :query => {:baz => "quux"})
-    request = YAML::load(response.body)
+    request = yaml_load(response.body)
     expect(request.path + '?' + request.query_string).to be == "/test?foo=bar&baz=quux"
   end