patron 0.13.3 → 0.13.4

data/patron.gemspec

@@ -6,23 +6,23 @@ require 'patron/version'
 Gem::Specification.new do |spec|
   spec.name        = "patron"
   spec.version     = Patron::VERSION
+  spec.licenses    = ["MIT"]
   spec.platform    = Gem::Platform::RUBY
-  spec.authors     = ["Phillip Toland"]
-  spec.email       = ["phil.toland@gmail.com"]
+  spec.authors     = ["Aeryn Riley Dowling-Toland"]
+  spec.email       = ["aeryn.toland@gmail.com"]
   spec.homepage    = "https://github.com/toland/patron"
   spec.summary     = "Patron HTTP Client"
   spec.description = "Ruby HTTP client library based on libcurl"
 
-  # Prevent pushing this gem to RubyGemspec.org. To allow pushes either set the 'allowed_push_host'
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
   # to allow pushing to a single host or delete this section to allow pushing to any host.
   if spec.respond_to?(:metadata)
     spec.metadata['allowed_push_host'] = "https://rubygems.org"
   else
-    raise "RubyGems 2.0 or newer is required to protect against public gem pushespec."
+    raise "RubyGems 2.0 or newer is required to protect against public gem pushes."
   end
 
   spec.required_rubygems_version = ">= 1.2.0"
-  spec.rubyforge_project = "patron"
 
   spec.files         = `git ls-files -z`.split("\x0")
   spec.bindir        = "exe"
@@ -31,16 +31,8 @@ Gem::Specification.new do |spec|
   spec.extensions   = ["ext/patron/extconf.rb"]
   spec.post_install_message = %q{
 Thank you for installing Patron. On OSX, make sure you are using libCURL with OpenSSL.
-SecureTransport-based builds might cause crashes in forking environment.
+SecureTransport-based builds might cause crashes in forking environments.
 
 For more info see https://github.com/curl/curl/issues/788
 }
-  spec.add_development_dependency "rake", "~> 10"
-  spec.add_development_dependency "bundler"
-  spec.add_development_dependency "rspec", ">= 2.3.0"
-  spec.add_development_dependency "simplecov", "~> 0.10"
-  spec.add_development_dependency "yard", "~> 0.9.11"
-  spec.add_development_dependency "rack", "~> 1"
-  spec.add_development_dependency "puma", '~> 3.11'
-  spec.add_development_dependency "rake-compiler"
 end

data/spec/session_spec.rb

@@ -7,6 +7,14 @@ require 'securerandom'
 
 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"
@@ -72,7 +80,7 @@ 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
 
@@ -88,38 +96,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
@@ -135,33 +173,33 @@ describe Patron::Session do
   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 +219,83 @@ 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" 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
     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" 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 "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 +328,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 +355,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 +366,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 +374,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 +385,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,14 +393,14 @@ 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
@@ -360,7 +411,7 @@ describe Patron::Session do
 
   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
 
@@ -370,21 +421,21 @@ describe Patron::Session do
 
   it "should use chunked encoding when uploading a file with :put" do
     response = @session.put_file("/test", "LICENSE")
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.header['transfer-encoding'].first).to be == "chunked"
   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 +443,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,13 +455,13 @@ 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
 
@@ -420,7 +471,7 @@ describe Patron::Session do
 
   it "should use chunked encoding when uploading a file with :post" do
     response = @session.post_file("/test", "LICENSE")
-    body = YAML::load(response.body)
+    body = yaml_load(response.body)
     expect(body.header['transfer-encoding'].first).to be == "chunked"
   end
 
@@ -428,18 +479,20 @@ describe Patron::Session 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 +500,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
@@ -497,7 +550,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 +569,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