patron 0.13.4 → 1.0.0

data/spec/session_ssl_spec.rb

@@ -1,313 +0,0 @@
-require File.expand_path("./spec") + '/spec_helper.rb'
-require 'webrick'
-require 'yaml'
-require 'base64'
-require 'fileutils'
-
-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 = "https://localhost:9043"
-    @session.insecure = true
-  end
-
-  it "should retrieve a url with :get" do
-    response = @session.get("/test")
-    body = yaml_load(response.body)
-    expect(body.request_method).to be == "GET"
-  end
-
-  it "should download content with :get and a file path" do
-    tmpfile = "/tmp/patron_test.yaml"
-    response = @session.get_file "/test", tmpfile
-    expect(response.body).to be_nil
-    body = yaml_load(File.open(tmpfile).read)
-    expect(body.request_method).to be == "GET"
-    FileUtils.rm tmpfile
-  end
-
-  # See https://github.com/curl/curl/issues/788
-  # Basically any HTTPS operation crashes on OSX with securetransport-enabled libCURL
-  it "should download content in a forked subprocess" do
-    # To trigger the bug, we need to perform a request in the master process first
-    tmpfile = "/tmp/patron_test.yaml"
-    @session.get_file "/test", tmpfile
-    FileUtils.rm tmpfile
-    
-    # and this one segfaults
-    pid = fork do
-      response = @session.get_file "/test", tmpfile
-      expect(response.body).to be_nil
-      body = yaml_load(File.open(tmpfile).read)
-      expect(body.request_method).to be == "GET"
-      FileUtils.rm tmpfile
-    end
-    
-    exit_pid, status = Process.wait2(pid)
-    expect(status.exitstatus).to be_zero
-  end
-  
-  it "should download correctly(md5 ok) with get_file" do
-    tmpfile = "/tmp/picture"
-    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 include custom headers in a request" do
-    response = @session.get("/test", {"User-Agent" => "PatronTest"})
-    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)
-    expect(body.header["user-agent"]).to be == ["PatronTest"]
-    expect(body.header["x-test"]).to be == ["Testing"]
-  end
-
-  it "should raise an exception on timeout" do
-    @session.timeout = 1
-    expect {
-      @session.get("/timeout?millis=1100")
-    }.to raise_error(Patron::TimeoutError)
-  end
-
-  it "should follow redirects by default" do
-    @session.max_redirects = 1
-    response = @session.get("/redirect")
-    body = yaml_load(response.body)
-    expect(response.status).to be == 200
-    expect(body.path).to be == "/test"
-  end
-
-  it "should include redirect count in response" do
-    @session.max_redirects = 1
-    response = @session.get("/redirect")
-    expect(response.redirect_count).to be == 1
-  end
-
-  it "should not follow redirects when configured to do so" do
-    @session.max_redirects = 0
-    response = @session.get("/redirect")
-    expect(response.status).to be == 301
-    expect(response.body).to be_empty
-  end
-
-  it "should retrieve URL metadata with :head" do
-    response = @session.head("/test")
-    expect(response.status).to be == 200
-    expect(response.body).to be_empty
-    expect(response.headers).to_not be_empty
-  end
-
-  it "should send a delete request with :delete" do
-    response = @session.delete("/test")
-    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)
-    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)
-    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)
-    expect(body.request_method).to be == "GET"
-    expect(body.header['content-length']).to be == [data.size.to_s]
-  end
-
-  it "should upload data with :put" do
-    data = "upload data"
-    response = @session.put("/test", data)
-    body = yaml_load(response.body)
-    expect(body.request_method).to be == "PUT"
-    expect(body.header['content-length']).to be == [data.size.to_s]
-  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)
-    expect(body.request_method).to be == "PUT"
-  end
-
-  it "should raise when no file is provided to :put" 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"
-  end
-
-  it "should upload data with :post" do
-    data = "upload data"
-    response = @session.post("/test", data)
-    body = yaml_load(response.body)
-    expect(body.request_method).to be == "POST"
-    expect(body.header['content-length']).to be == [data.size.to_s]
-  end
-
-  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)
-    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/)
-  end
-
-  it "should raise when no data is provided to :post" do
-    expect { @session.post("/test", nil) }.to raise_error(ArgumentError)
-  end
-
-  it "should upload a file with :post" do
-    response = @session.post_file("/test", "LICENSE")
-    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)
-    expect(body.request_method).to be == "POST"
-  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"
-  end
-
-  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"
-  end
-
-  it "should not handle cookies by default" do
-    response = @session.get("/setcookie").body
-    expect(yaml_load(response).header).to_not include('cookie')
-  end
-
-  it "should raise exception if cookie store is not writable or readable" do
-    expect { @session.handle_cookies("/trash/clash/foo") }.to raise_error(ArgumentError)
-  end
-
-  it "should work with multiple threads" do
-    threads = []
-    3.times do
-      threads << Thread.new do
-        session = Patron::Session.new
-        session.base_url = "https://localhost:9043"
-        session.insecure = true
-        session.post_file("/test", "LICENSE")
-      end
-    end
-    threads.each {|t| t.join }
-  end
-
-  it "should fail when insecure mode is off" do
-    expect {
-      @session.insecure = nil
-      response = @session.get("/test")
-    }.to raise_error(Patron::Error)
-  end
-
-  it "should work when insecure mode is off but certificate is supplied" do
-    @session.insecure = nil
-    @session.cacert = File.join(__dir__, 'support', 'certs', 'cacert.pem')
-    response = @session.get("/test")
-    body = yaml_load(response.body)
-    expect(body.request_method).to be == "GET"
-  end
-
-  it "should allow to specify insecure mode per-request" do
-    @session.insecure = false
-    expect {
-      @session.request(:get, "/test", {}, insecure: true)
-    }.not_to raise_error
-    expect {
-      @session.request(:get, "/test", {})
-    }.to raise_error(Patron::Error)
-  end
-
-  it "should work with different SSL versions" do
-    ['TLSv1_0','TLSv1_1'].each do |version|
-      @session.ssl_version = version
-      response = @session.get("/test")
-      expect(response.status).to be == 200
-    end
-  end
-
-  it "should raise when an unsupported or unknown SSL version is requested" do
-    ['something', 1].each do |version|
-      @session.ssl_version = version
-      expect {
-        @session.get("/test")
-      }.to raise_error(Patron::UnsupportedSSLVersion)
-    end
-  end
-
-  it "should work with different HTTP versions" do
-    ['HTTPv1_0','HTTPv1_1'].each do |version|
-      @session.http_version = version
-      response = @session.get("/test")
-      expect(response.status).to be == 200
-    end
-  end
-
-  it "should raise when an unsupported or unknown HTTP version is requested" do
-    ['something', 1].each do |version|
-      @session.http_version = version
-      expect {
-        @session.get("/test")
-      }.to raise_error(Patron::UnsupportedHTTPVersion)
-    end
-  end
-
-  # ------------------------------------------------------------------------
-  describe 'when debug is enabled' do
-    it 'it should not clobber stderr' do
-      rdev = STDERR.stat.rdev
-
-      @session.enable_debug
-      expect(STDERR.stat.rdev).to be == rdev
-
-      @session.enable_debug
-      expect(STDERR.stat.rdev).to be == rdev
-    end
-  end
-
-end

data/spec/spec_helper.rb

@@ -1,34 +0,0 @@
-if ENV["COVERAGE"]
-  require 'simplecov'
-  SimpleCov.start do
-    add_filter "/spec/"
-  end
-end
-require 'rspec'
-
-# Kill warnings that not raising a specific exception still allows the method
-# to fail with another exception
-RSpec::Expectations.configuration.warn_about_potential_false_positives = false
-
-$:.unshift(File.dirname(__FILE__) + '/../lib')
-$:.unshift(File.dirname(__FILE__) + '/../ext')
-require 'patron'
-
-$stderr.puts "Build against #{Patron.libcurl_version}"
-
-Dir['./spec/support/**/*.rb'].each { |fn| require fn }
-
-http_server = Fork.new { PatronTestServer.start(false, 9001) }
-
-sleep 0.1 # Don't interfere the start up output of two processes.
-
-https_server = Fork.new { PatronTestServer.start(true, 9043) }
-
-RSpec.configure do |c|
-  c.after(:suite) do
-    http_server.kill("TERM")
-    https_server.kill("TERM")
-    http_server.wait
-    https_server.wait
-  end
-end

data/spec/support/certs/cacert.pem

@@ -1,36 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIGQzCCBCugAwIBAgIJALv7uLhAQdL/MA0GCSqGSIb3DQEBBQUAMIG3MQswCQYD
-VQQGEwJVUzETMBEGA1UECAwKU29tZS1TdGF0ZTEUMBIGA1UEBwwLRXhhbXBsZXRv
-d24xIDAeBgNVBAoMF1BhdHJvbiBUZXN0IENlcnRpZmljYXRlMSAwHgYDVQQLDBdQ
-YXRyb24gVGVzdCBDZXJ0aWZpY2F0ZTESMBAGA1UEAwwJbG9jYWxob3N0MSUwIwYJ
-KoZIhvcNAQkBFhZwYXRyb250ZXN0QGV4YW1wbGUuY29tMB4XDTEzMDQwNDAwMDAy
-M1oXDTQwMDgxOTAwMDAyM1owgbcxCzAJBgNVBAYTAlVTMRMwEQYDVQQIDApTb21l
-LVN0YXRlMRQwEgYDVQQHDAtFeGFtcGxldG93bjEgMB4GA1UECgwXUGF0cm9uIFRl
-c3QgQ2VydGlmaWNhdGUxIDAeBgNVBAsMF1BhdHJvbiBUZXN0IENlcnRpZmljYXRl
-MRIwEAYDVQQDDAlsb2NhbGhvc3QxJTAjBgkqhkiG9w0BCQEWFnBhdHJvbnRlc3RA
-ZXhhbXBsZS5jb20wggIiMA0GCSqGSIb3DQEBAQUAA4ICDwAwggIKAoICAQCpXSox
-AW/1rE/p3dgorv0MrGaOYS9/IV+fb1FkjYBhkvobn3jYJyLWdbCbT8RDGNVMBEUI
-FW03hqy5UthakGImArGkHxDFMrgLOkhid5sCWtectvhijmRRU7Fy2K0pJvZWqSAI
-bBEIbcm6VK0SWA/+ko7IfSC69Hbu76ABA6nytwvHid16SUF5Mnl/vjlmCLC7JFtt
-IuX/K2XpJzBZ1w9UdcU+xdc/veUR/uBS9DDkSEb8KXkPSDcA0W3oj1+VfB1qq/22
-e2+gXpgESGofKNuISM5TBRlj7i0r9abS1rRJqIdtFVdnVEHzMJMPH3dz5lep0vzy
-KyhAfDh1Q4Bi3LvFlSchXY7OnzE3hnhJqC2jGfe1cr8/WZTp7uT4zehQHdNg39r0
-pabpxip8zTuPZ6eBPeh4LaFIuWx7wOn7xQ5pfwLbWWCBr+FQbRatkqu3E+L6rhGw
-v/a/jlVnNekkSlADsyvya7t4hqfsDAxB5q/s/MpXItrGYf1sgtZX0nnNkPkgrF28
-Zf22SzqylBKSdsrbBfltitMa0YOQSLIMt1kZlOvtK8fb3ZbRf23uX0JLrA/+CgSr
-wyF3x/sbNtqvaAvQPB4yWdSGWoC1Z2DkD3n5cKVnmy7qNvTLCtazuIVOejAtoXyN
-WwwMOrpyN9yNXt5BVqqT5ihqG5xtYsBj5VxpqQIDAQABo1AwTjAdBgNVHQ4EFgQU
-6dREKfAo/84ZErAWrMxaMbeuB68wHwYDVR0jBBgwFoAU6dREKfAo/84ZErAWrMxa
-MbeuB68wDAYDVR0TBAUwAwEB/zANBgkqhkiG9w0BAQUFAAOCAgEARJWX+PKcJO1K
-GzxFIZlSX0IgKZSzyFd0K6dTEwRIX4oid7d0W+RMOPDt9iUMa1IoyopK88d1+Epx
-t5Rtfr9WQqJH5YrT0hPvMngDE+5L4T8dFJc13vHMYBVugLFRQ7gvZvX/WB6bARpm
-LsoCTxrgtSJjJ/dU6y94ijwBQOET6dhhG7B7LeADQwNx5TTxiZ12C0RqytWFZfNT
-OVJYkTfH4TYEVxewzBtEFGU7mXXn5WTtr7utohK89j1BlCmKWffiSYZko4321AbQ
-BhUFOzkawyHCDr1OKApAY3S7JJmcKF9hdrpk+ruEjMKlCTiv7qNN2bhtDTaofCNz
-VBJqcTgaU3vkTw4FnyEt3Xo/Sy1O+GMKC8wdyhjPTAF/8I8M9wzp5QMoPnvWT1Hn
-OlIRwG6ZM96uVRHQb1rNB8SDCgZYEAs8GwcQ/NcKhbM1kU3FHOZgJ1dAfBAcFKsN
-1eaqlyfEMHKdMOy+22rfAj7zsCFiLoDxf5ShIQFGL5benr6V+zSleKD6hQR+ylH8
-gV4G657aiBTojvkpfep8QAwOUDsdCNyisMn3H2Il72JMV5Q+vkC0nTT8MbZ1hxTf
-wQkc1YxCPDg/XXvrkjXNP3supO+XK8yEIbtekv9Yqtyz3U5i7LUha3XbLPGNoR7d
-djS6lZ9vTEbRM+GhU2PMKfvJbiQ/Y6Q=
------END CERTIFICATE-----

data/spec/support/certs/privkey.pem

@@ -1,51 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-MIIJKAIBAAKCAgEAqV0qMQFv9axP6d3YKK79DKxmjmEvfyFfn29RZI2AYZL6G594
-2Cci1nWwm0/EQxjVTARFCBVtN4asuVLYWpBiJgKxpB8QxTK4CzpIYnebAlrXnLb4
-Yo5kUVOxctitKSb2VqkgCGwRCG3JulStElgP/pKOyH0guvR27u+gAQOp8rcLx4nd
-eklBeTJ5f745ZgiwuyRbbSLl/ytl6ScwWdcPVHXFPsXXP73lEf7gUvQw5EhG/Cl5
-D0g3ANFt6I9flXwdaqv9tntvoF6YBEhqHyjbiEjOUwUZY+4tK/Wm0ta0SaiHbRVX
-Z1RB8zCTDx93c+ZXqdL88isoQHw4dUOAYty7xZUnIV2Ozp8xN4Z4Sagtoxn3tXK/
-P1mU6e7k+M3oUB3TYN/a9KWm6cYqfM07j2engT3oeC2hSLlse8Dp+8UOaX8C21lg
-ga/hUG0WrZKrtxPi+q4RsL/2v45VZzXpJEpQA7Mr8mu7eIan7AwMQeav7PzKVyLa
-xmH9bILWV9J5zZD5IKxdvGX9tks6spQSknbK2wX5bYrTGtGDkEiyDLdZGZTr7SvH
-292W0X9t7l9CS6wP/goEq8Mhd8f7Gzbar2gL0DweMlnUhlqAtWdg5A95+XClZ5su
-6jb0ywrWs7iFTnowLaF8jVsMDDq6cjfcjV7eQVaqk+YoahucbWLAY+VcaakCAwEA
-AQKCAgBeGlPdEs1glbN5YDhAsqoLpqb9KWa4npSBA9sXob/Zd07clkkQ4P3sZ0wP
-n8yO83dgW2b3zN/4YC4Mcsmf2GWQdSK67D/nMf0sz990RrysHEl82/U63Z9DyNrp
-0xazrOBm2mXgCBuWsVnK3E2lyaRpcIlBQLU066xBqoceySheofI7lpCm55knfDIi
-FlHSLbX05YifJSriEvz3BT1KTcJIzX8hF9A3rI1g6Fs//EpGLRqz9V88bIWTQMpu
-02rqpiG6KYI5KHCnjKeuiYXddlg0ay+o1UZ8TdRvfniI4Z8e5jMJGziLQze5ph2v
-4239ydiflYnSDMS6v8qm7TCivb7ebB9pGF92WJl/BlIOhgQRuZVoglOzVSGcRy+E
-nXh7bCRhKhIH32Yt2pp0BHVr02GAjKg4tu+XRzoYjpqFd4GgksiLi2oEc0OSvJbs
-j10gbHeEDaEEgjf61dJSxJlRrLDP//8j5grRx+XGMeWMV8iMG4NlssCj1YoLCc7M
-LNiB58Ao3kqZt/y9dlDnglMLv4QVpzrWwUgVGDy6ScN1U6m3nx8T0+FZvXSrUexk
-8jVm+jkzWAxvETLNefJAcnPxLvGuMcJUorirXfO03eQC8cXce3lWHgujMJhMtOOZ
-JL1MA0/YAQjGtEswRaSNUZr5hePHAIeC74nQ0Qrlw0G+25kk+QKCAQEA2RhtyNsn
-Wb6KUyr1umdcom0k7Sdg5uBP4koFjGG/1Ynz/uX1n7sfgOHRiSvg6hxOt/7fb4vd
-hY0ZBrkzC7W1YJpH7C5PC7MrlU+BuwwYjeKmHTwA4Usrm6t3EXShE9N/REgYBtlJ
-vWiAwsyBfZSR/uNCUA7RhztsOui+O90Q5TUBRdo/drvoxzPEO7xvpy8CaAKQdFVt
-jdt6xkcauYg46FJjSzkCCzu6AM+g8B5usIq/X6KkEVruoOVKXAAM74v7fso+s/3R
-36UeAPq61RADQYqmg5nLnKN6KOfQ6/vrqmYCrLfc0JP+V17/bZ299BhM+PsVgdX/
-upwnh8Ar/LD6KwKCAQEAx7b7vbLGzwDRKyOstNp0NVKBK2vuo9OKACYqNivL79HC
-09u3O+1bKKslAnHZpoyImbt/IVIaPIKaDPF4EphTsFW36fVNeU8+DWEOPitMSUnS
-MEJuHTVATaCVatsGovIkkBQ1PrCpryP1Tns514vIv3MEaeq3fj2MAGARGvWNU82R
-JZ0tMXb/ZSIuewUXMWo7fthL0Et9/ZSFqrP0NISh5vIu+7NayxHRIa4oGWWEfPl4
-3gr5NvUvD8ZXzYk2c5YNfeWvsy/gUPbDv+4poy/yNaTYdw4hOwFCnef7Y3H4TIWL
-Dbv87Jke4aZtKioI7sASLA/z42jlVQmeEfPtvoQlewKCAQEApgdpxsfcQ2VWkp5z
-SXjNPqdsKzcHg+qfDXgA4EjNlnknspSaEevg/wc04cw9+a1mgo8YwE1eQEoVjq/K
-mzT/nv6+7KDJ8S+4sDsbAzsP+EsTMZ53KdX8ZtRufloM6oXAei8MuQgqvgGTH+eZ
-TLp4IVAaofGDSwImFrNy8YNy7WhpLcvo51x0fQxZEjpdxaVNGNCFO4MuAuSM8+Dj
-Tmsg4oRHzfquVnr6GK6x7ZHIo5mpHHHdOiyp/UD+anfbbMRItcHkzHDctkaoOKWI
-h3P0mYZ5LIJNVuErhucrP57tr+bOOttus9HLHXTYsjOGV4zSKUSVQTOxnTzZepd8
-zIdo+wKCAQAg/Z80RPYGd/IVmD0NWxDbRhfEXn37XhRr1eIfNLjpktMGQENSiPEI
-FM12S+xSUOC31Hs5u+BNop1kCfd1yuf4NxC8eyMjKO3tM90wc+KUMLeh9TdPZ96J
-dD96eVftTuavTkdFZdWB8wSwxDZX3uV4ir1t6bIKDoyz+yqYM3v3HfweJIq0ox2p
-TS40cDDWnt/ZIk3TyMS1QPWbr0Jl8or0JYmRVp1m8jiDwcsp9tUd9+/5bgKhC3uM
-tY0HjOULzvvHkkul5ADAHyNS7zq9lEwEhIilkhX3M0wX3ZxvXwJPUbgYurcbNmgd
-imp6DpuPJPdbg/8bz9YiaAZOnObnE9lFAoIBAGIdAhDDhqhPIW3xDx54TBfxQFi+
-CeFw1g2duwXAXkBV98nKeLdTo3tL8gusb+32LzgVIq2spWUN72xXX40NJjW1Bxk5
-SGatM1T13BaUFNYtzpM9arDPNr3tCiCSzeVvMKdLfp+Vx9R9arnOgLlGkhRCdEtb
-lXAteE7Twuztvad/M0LGpbjN6BD23KLOfxx9C2TgfMuK/Fjt71ASV+80cq4SS2WK
-fqZQnKfGIRE8wcY2R5g2AwEzubCRzD93pGG3KleQKxrUKNoV32M2ZZcM04l8woZX
-vrkNxM3gbBkhFPAJ9LrmA4YExODUXzWt6Y2mCXuH2Ly60yiLa66HbEfhHrs=
------END RSA PRIVATE KEY-----

data/spec/support/config.ru

@@ -1,146 +0,0 @@
-require 'yaml'
-require 'ostruct'
-require 'zlib'
-
-## HTTP test server for integration tests
-
-Readback = Proc.new {|env|
-  # The Patron test suite is originally written to enable the following
-  # testing pattern:
-  # * Patron does a request
-  # * The request gets captured by Webrick
-  # * Webrick then takes it's Request object and YAMLs it wholesale (body, headers and all)
-  # * ...and sends it back to the client
-  # * The test suite then de-YAMLs the request object from the response body and does assertions on it
-  #
-  # The easiest way to fake it, preserving the entire test suite intact, is to simulate a Webrick
-  # request object using an ostruct. Of note is the following:
-  #
-  # 1) Webrick returns headers in arrays by default, accounting for repeats like with Cookie
-  # 2) Webrick does not convert headers to ENV_VARS_FOR_FCI it only downcases them. We have to match that.
-  req = Rack::Request.new(env)
-  req_headers = env.to_a.select do |(k,v)|
-    k.is_a?(String) && v.is_a?(String)
-  end.map do |(k,v)|
-   [k.downcase.gsub(/^http_/, '').gsub(/_/o, '-'), [v]]
-  end
-
-  fake_webrick_request_object = OpenStruct.new({
-    :fullpath => req.fullpath,
-    :path => req.path,
-    :query_string => req.query_string,
-    :request_method => req.request_method.to_s,
-    :header => Hash[req_headers],
-    :body => env['rack.input'].read,
-  })
-
-  body_str = fake_webrick_request_object.to_yaml
-  [200, {'Content-Type' => 'text/plain', 'Content-Length' => body_str.bytesize.to_s}, [body_str]]
-}
-
-GzipServlet = Proc.new {|env|
-  raise "Need to have the right Accept-Encoding: header" unless env['HTTP_ACCEPT_ENCODING']
-  
-  body = []
-  content_length = 0
-  z = Zlib::Deflate.new(Zlib::DEFAULT_COMPRESSION)
-  1024.times do
-    chunk = z.deflate('Some highly compressible data')
-    content_length += chunk.bytesize
-    body << chunk
-  end
-  fin = z.finish.to_s
-  body << fin
-  content_length += fin.bytesize
-  z.close
-
-  [200, {'Content-Encoding' => 'deflate', 'Content-Length' => content_length.to_s, 'Vary' => 'Accept-Encoding'}, body]
-}
-
-TimeoutServlet = Proc.new {|env|
-  query_vars = Rack::Utils.parse_nested_query(env.fetch('QUERY_STRING'))
-  query_millis = query_vars.fetch('millis').to_i
-  sleep(query_millis / 1000.0)
-  [200, {'Content-Type' => 'text/plain'}, ['That took a while']]
-}
-
-SlowServlet = Proc.new {|env|
-  body = Enumerator.new do |y|
-    y.yield 'x'
-    sleep 5
-    y.yield 'rest of body'
-  end
-  [200, {'Content-Type' => 'text/plain'}, body]
-}
-
-RedirectServlet = Proc.new {|env|
-  url_scheme = env.fetch('rack.url_scheme')
-  port = env.fetch('SERVER_PORT')
-  [301, {'Location' => "#{url_scheme}://localhost:#{port}/test"}, []]
-}
-
-EvilRedirectServlet = Proc.new {|env|
-  [301, {'Location' => "smtp://mailbox:secret@localhost"}, []]
-}
-
-BodyReadback = Proc.new {|env|
-  readback = {'method' => env['REQUEST_METHOD'], 'body' => env['rack.input'].read, 'content_type' => env.fetch('CONTENT_TYPE')}
-  [200, {'Content-Type' => 'text/plain'}, [OpenStruct.new(readback).to_yaml]]
-}
-
-TestPatchBodyServlet = BodyReadback
-
-SetCookieServlet = Proc.new {|env|
-  [301, {'Set-Cookie' => 'session_id=foo123', 'Location' => 'http://localhost:9001/test'}, []]
-}
-
-RepetitiveHeaderServlet = Proc.new {|env|
-  # The values of the header must be Strings,
-  # consisting of lines (for multiple header values, e.g. multiple
-  # <tt>Set-Cookie</tt> values) separated by "\\n".
-  [200, {'Set-Cookie' => "a=1\nb=2", 'Content-Type' => 'text/plain'}, ['Hi.']]
-}
-
-PictureServlet = Proc.new {|env|
-  # Rack::File allows us to test Range support as well
-  env_with_adjusted_path = env.merge('PATH_INFO' => Rack::Utils.escape('/pic.png'))
-  Rack::File.new('./').call(env_with_adjusted_path)
-}
-
-RedirectToPictureServlet = Proc.new {|env|
-  [307, {'Location' => '/picture'}, []]
-}
-
-WrongContentLengthServlet = Proc.new {|env|
-  [200, {'Content-Length' => '1024', 'Content-Type' => 'text/plain'}, ['Hello.']]
-}
-
-# Serves a substantial amount of data
-LargeServlet = Proc.new {|env|
-  rng = Random.new
-  len = 15 * 1024 * 1024
-  body = Enumerator.new do |y|
-    15.times do
-      y.yield(rng.bytes(1024 * 1024))
-    end
-  end
-  [200, {'Content-Type' => 'binary/octet-stream', 'Content-Length' => len.to_s}, body]
-}
-
-run Rack::URLMap.new({
-  "/" => Proc.new {|env| [200, {'Content-Length' => '2'}, ['Welcome']]},
-  "/test" => Readback,
-  "/testpost" => BodyReadback,
-  "/testpatch" => BodyReadback,
-  "/timeout" => TimeoutServlet,
-  "/slow" => SlowServlet,
-  "/redirect" => RedirectServlet,
-  "/evil-redirect" => EvilRedirectServlet,
-  "/picture" => PictureServlet,
-  "/redirect-to-picture" => RedirectToPictureServlet,
-  "/very-large" => LargeServlet,
-  "/setcookie" => SetCookieServlet,
-  "/repetitiveheader" => RepetitiveHeaderServlet,
-  "/wrongcontentlength" => WrongContentLengthServlet,
-  "/gzip-compressed" => GzipServlet,  
-})

data/spec/support/fork.rb

@@ -1,70 +0,0 @@
-require 'thread'
-
-class Fork
-  def initialize(&block)
-    @mu = Mutex.new
-    @cond = ConditionVariable.new
-    @pstate = nil
-    @pid = Process.fork(&block)
-    @killed = false
-
-    # Start monitoring the PID.
-    Thread.new { monitor }
-
-    # Kill the process anyway when the program exits.
-    ppid = Process.pid
-    at_exit do
-      if ppid == Process.pid # Make sure we are not inside another fork spawned by rspec example.
-        do_kill("KILL")
-      end
-    end
-  end
-
-  # Wait for process to exit.
-  def wait(timeout = nil)
-    @mu.synchronize do
-      next @pstate unless @pstate.nil?
-
-      @cond.wait(@mu, timeout)
-      @pstate
-    end
-  end
-
-  # Signal the process.
-  def kill(sig)
-    already_killed = @mu.synchronize do
-      old = @killed
-      @killed = true
-      old
-    end
-    signaled = do_kill(sig)
-    Thread.new { reaper } if signaled && !already_killed
-    signaled
-  end
-
-  private
-
-  # Signal the process.
-  def do_kill(sig)
-    Process.kill(sig, @pid)
-    true
-  rescue Errno::ESRCH # No such process
-    false
-  end
-
-  # Monitor the process state.
-  def monitor
-    _, pstate = Process.wait2(@pid)
-
-    @mu.synchronize do
-      @pstate = pstate
-      @cond.broadcast
-    end
-  end
-
-  # Wait 500 milliseconds and force terminate.
-  def reaper
-    pstate = wait(0.5)
-    do_kill("KILL") unless pstate
-  end
-end

data/spec/support/test_server.rb

@@ -1,26 +0,0 @@
-require 'rack'
-require 'puma'
-require 'rack/handler/puma'
-
-class PatronTestServer
-  APP = Rack::Builder.new { eval(File.read(File.join(__dir__, 'config.ru'))) }
-
-  def self.start(ssl = false, port = 9001 )
-    # Reset the RSpec's SIGINT handler that does not really terminate after
-    # the first Ctrl+C pressed.
-    # Useful to terminate the forked process before Puma is actually started:
-    # it happens when running one particular example that does not need Puma
-    # so the specs are in fact finished before the Puma started.
-    Signal.trap('INT', 'EXIT')
-    @ssl = ssl
-    keypath = File.join(__dir__, 'certs', 'privkey.pem')
-    certpath = File.join(__dir__, 'certs', 'cacert.pem')
-
-    host = if ssl
-      'ssl://0.0.0.0:%d?key=%s&cert=%s' % [port, keypath, certpath]
-    else
-      '0.0.0.0'
-    end
-    Rack::Handler::Puma.run(APP, {:Port => port.to_i, :Verbose => true, :Host => host})
-  end
-end