patron 0.14.0 → 1.0.0

data/spec/session_ssl_spec.rb

@@ -1,431 +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
-    # The first TLS handshake takes a few seconds when both ends run under valgrind
-    @session.connect_timeout = 10
-  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 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(ssl: true) do |url|
-      session = Patron::Session.new
-      session.base_url = url
-      session.insecure = true
-      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 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 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(ssl: true) do |url|
-      session = Patron::Session.new
-      session.base_url = url
-      session.insecure = true
-      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 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
-
-  describe 'with a server that requires a client certificate' do
-    let(:certs) { File.join(__dir__, 'support', 'certs') }
-
-    # libcurl's GnuTLS backend reports any client certificate it can't load as CURLE_SSL_CONNECT_ERROR
-    let(:gnutls) { Patron.libcurl_version.include?('GnuTLS') }
-
-    def refused_by_server
-      raise_error { |e|
-        expect(e).to be_kind_of(Patron::Error)
-        expect(e).not_to be_kind_of(Patron::ClientCertificateError)
-        expect(e).not_to be_kind_of(Patron::TimeoutError)
-      }
-    end
-
-    before(:each) do
-      @session.base_url = "https://localhost:9044"
-      @session.insecure = false
-      @session.cacert = File.join(certs, 'cacert.pem')
-    end
-
-    it "presents a PKCS#12 client certificate" do
-      @session.ssl_cert = File.join(certs, 'client.p12')
-      @session.ssl_cert_type = 'P12'
-      @session.ssl_key_password = 'patron'
-      response = @session.get("/peercert")
-      expect(response.status).to be == 200
-      expect(response.body).to include('CN=patron-test-client')
-    end
-
-    it "presents a PEM client certificate with a separate encrypted key" do
-      @session.ssl_cert = File.join(certs, 'client_cert.pem')
-      @session.ssl_cert_type = 'PEM'
-      @session.ssl_key = File.join(certs, 'client_key.pem')
-      @session.ssl_key_password = 'patron'
-      response = @session.get("/peercert")
-      expect(response.status).to be == 200
-      expect(response.body).to include('CN=patron-test-client')
-    end
-
-    it "accepts the client certificate as a per-request option" do
-      response = @session.request(:get, "/peercert", {},
-        ssl_cert: File.join(certs, 'client.p12'), ssl_cert_type: 'P12', ssl_key_password: 'patron')
-      expect(response.body).to include('CN=patron-test-client')
-    end
-
-    it "accepts Pathnames for the certificate and key and a Symbol for the type" do
-      @session.cacert = Pathname(certs).join('cacert.pem')
-      @session.ssl_cert = Pathname(certs).join('client_cert.pem')
-      @session.ssl_cert_type = :PEM
-      @session.ssl_key = Pathname(certs).join('client_key.pem')
-      @session.ssl_key_password = 'patron'
-      response = @session.get("/peercert")
-      expect(response.body).to include('CN=patron-test-client')
-    end
-
-    it "does not leak a failed request's options into the next one" do
-      @session.ssl_cert = File.join(certs, 'client.p12')
-      @session.ssl_cert_type = 'P12'
-      @session.ssl_key_password = 'patron'
-      expect {
-        @session.request(:get, "/test", {'X-Leaked' => 'yes'}, ssl_key_password: 1234)
-      }.to raise_error(TypeError)
-
-      body = yaml_load(@session.get("/test").body)
-      expect(body.header).not_to have_key('x-leaked')
-    end
-
-    it "raises ClientCertificateError when the key password is wrong" do
-      skip "GnuTLS does not tell this apart from a handshake failure" if gnutls
-      @session.ssl_cert = File.join(certs, 'client.p12')
-      @session.ssl_cert_type = 'P12'
-      @session.ssl_key_password = 'wrong'
-      expect { @session.get("/peercert") }.to raise_error(Patron::ClientCertificateError)
-    end
-
-    it "raises ClientCertificateError when the certificate file does not exist" do
-      skip "GnuTLS does not tell this apart from a handshake failure" if gnutls
-      @session.ssl_cert = File.join(certs, 'nonexistent.p12')
-      @session.ssl_cert_type = 'P12'
-      @session.ssl_key_password = 'patron'
-      expect { @session.get("/peercert") }.to raise_error(Patron::ClientCertificateError)
-    end
-
-    it "fails when the server does not trust the client certificate" do
-      @session.ssl_cert = File.join(certs, 'rogue_client.p12')
-      @session.ssl_cert_type = 'P12'
-      @session.ssl_key_password = 'patron'
-      expect { @session.get("/peercert") }.to refused_by_server
-    end
-
-    it "fails when no client certificate is presented" do
-      # Depending on the TLS version the server rejects us either during or right after the handshake
-      expect { @session.get("/peercert") }.to refused_by_server
-    end
-  end
-end

data/spec/spec_helper.rb

@@ -1,40 +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) }
-
-mtls_server = Fork.new do
-  PatronTestServer.start(true, 9044, client_ca: File.join(__dir__, 'support', 'certs', 'client_ca.pem'))
-end
-
-RSpec.configure do |c|
-  c.after(:suite) do
-    http_server.kill("TERM")
-    https_server.kill("TERM")
-    mtls_server.kill("TERM")
-    http_server.wait
-    https_server.wait
-    mtls_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/client_ca.pem

@@ -1,20 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDWzCCAkOgAwIBAgIBATANBgkqhkiG9w0BAQsFADBPMQswCQYDVQQGEwJVUzEg
-MB4GA1UECgwXUGF0cm9uIFRlc3QgQ2VydGlmaWNhdGUxHjAcBgNVBAMMFVBhdHJv
-biBUZXN0IENsaWVudCBDQTAeFw0yNTAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBa
-ME8xCzAJBgNVBAYTAlVTMSAwHgYDVQQKDBdQYXRyb24gVGVzdCBDZXJ0aWZpY2F0
-ZTEeMBwGA1UEAwwVUGF0cm9uIFRlc3QgQ2xpZW50IENBMIIBIjANBgkqhkiG9w0B
-AQEFAAOCAQ8AMIIBCgKCAQEA1iqOoIm5gW9MP0onsmSuOdlAdFZkP5r7rRSn+100
-5ceHDpRdaR+k8ZIoi7noesryrf7ibZL+9VzZEBGlCcUGEIjQjL/BHsHa5vLfAJnT
-0zbeQFk5MjGZOUPXC33CgidsxF3DsRFDNmOqGBiCf3A/ae/VOMDEyv6aFdKc6JQC
-OoudnCGzVNJuLIa+/yGx9HhIjobbYGuZ7gwLjJk3HW9WixTupUKJME9f7cTIPW+k
-ahw7ZQGzIUHejqy8cDnmBRYNpZ8NU5oTuhr5NFDWhOSGfM70NYFlGDifI2kMPhdc
-s4nEUajG1b3NLBfKMM1HioqG2ivMQv6WNRWGJCn3sdJEXQIDAQABo0IwQDAPBgNV
-HRMBAf8EBTADAQH/MA4GA1UdDwEB/wQEAwIBBjAdBgNVHQ4EFgQUd1Pmdua66Xyn
-qKIbXkVUC389WA8wDQYJKoZIhvcNAQELBQADggEBAD+6HGi8mdkHDnegma3AvQ0K
-4EoTtKljui93zVhsaXpycr/UtOe7p6jBApBdh93up6Fx9cYu2OtTLh0t9rnLXBWD
-GZQt1jajEwvdRg2ncFfoWkxeftUttd5uTVMN6Apv3nGw3VXZnNmVaRyZnGG5j1JO
-lnN94DfE37MyePhuFCDd5RZXegIsel62AMPJNV/RtwPf5b7T59f/Ol1oTMkaWEtM
-wYU/2cFTqGjtqeTv7IewTERbqBxJcvIU3pNVHthq/jyiiuaLeAybbx1AZoI3fkY8
-FO1LAtZx1/xZwjqtSuTZn8CbryLoMetpvVqsUlI72FxStQf5JAFjO+H4kWEEORU=
------END CERTIFICATE-----

data/spec/support/certs/client_cert.pem

@@ -1,20 +0,0 @@
------BEGIN CERTIFICATE-----
-MIIDSzCCAjOgAwIBAgIBAjANBgkqhkiG9w0BAQsFADBPMQswCQYDVQQGEwJVUzEg
-MB4GA1UECgwXUGF0cm9uIFRlc3QgQ2VydGlmaWNhdGUxHjAcBgNVBAMMFVBhdHJv
-biBUZXN0IENsaWVudCBDQTAeFw0yNTAxMDEwMDAwMDBaFw00NTAxMDEwMDAwMDBa
-MEwxCzAJBgNVBAYTAlVTMSAwHgYDVQQKDBdQYXRyb24gVGVzdCBDZXJ0aWZpY2F0
-ZTEbMBkGA1UEAwwScGF0cm9uLXRlc3QtY2xpZW50MIIBIjANBgkqhkiG9w0BAQEF
-AAOCAQ8AMIIBCgKCAQEAnp7kL8f5Yk/T6B+IRoLWvCTHeORa4ilp7ixTE4EJOwTB
-atAfnoue4U+xMBAX91oIiGT8u5yKcC+EbvmvcOuOYQPCVXvx3bHBzeTzjBkH37k1
-rBeXVxfhEnkXAANJOccTpPJRH2m+1X/FcXuUNKZOnSrc4G/Gpraj2Opygz8ntxbW
-JR94mz1nkkAILlkCie4VFfSdnxE5ghQSnt8B7W9SdqSKD22NKpBmOff2x5136IEo
-YNK7zYintgJfX6Pa7TR8peEVtAkl3/EjSEoSmfFQVZz2OB7IK3xFT2RyqoC9MjO6
-2mItbD0LgZzTD3f91g00a7z6EjSW8g8QYc5pXSdC1wIDAQABozUwMzAMBgNVHRMB
-Af8EAjAAMA4GA1UdDwEB/wQEAwIFoDATBgNVHSUEDDAKBggrBgEFBQcDAjANBgkq
-hkiG9w0BAQsFAAOCAQEAU/u+MOKWMXQqkPSQx2RjrOale3KKdkHX6LlGfZYjqMhn
-IQjYbEfGtIKyD2MChXrhKMLwuwvMUaCMQWq0r9vZb2cz+AGDS/OzHui/YXgoUU/D
-JOqmT17ClM1JIBZjfbLaogGGY//l4NA48MjhTDHw9MGOnnjzVYUy7CC6qiFu0onC
-Ko+ZE0Ebb3KyjUeJLSCXEhTVW0myGc+/jNRJP0YW/TvxKRZ5EAhaJrLXvKm7tjil
-SZpXBETiXq6eZZsD+XNfQvytBIFO4eBhv3sipQ8Ga30L3SqkMlsb4ptWpa5+z1Vk
-BlkuYdKpPhD/nmx/OfRdfTItDVstm8Q13+MGS5Rokw==
------END CERTIFICATE-----

data/spec/support/certs/client_key.pem

@@ -1,30 +0,0 @@
------BEGIN RSA PRIVATE KEY-----
-Proc-Type: 4,ENCRYPTED
-DEK-Info: AES-256-CBC,73A5C7F43CBFB22BDECED16E3F6D4014
-
-s2DHo+hKzlo9ZFcql4V84w5c8OADkBHNYp3DJJSII+LSufiNLJ1JVcACEZdr/JsF
-vLKTlCIjExGY1b85GPZ25PArB5jrZvWCcOFfs5PGzr3/ykRTfTMHSXo+WfFwkZ2x
-2k/Zt8yVJ7f69G7EevTtVbkmx/wLMnlTSjMKfzWfs/f57GP+dWM5rHOiMBKK2KhC
-OlD6yhKV4frmF9YTQlslrg5Nmd+3UQsSubT6s4qLByYrLm7pJHB9mx2LNLLQnoxv
-IBIL+FcQRQvLtGGbzV42BHEqr6Kq7aqDf9RT6JohOMdGMYMtABZP9/iOqCUMT2QB
-2/cio1jjgijHqpVBsPg9D493t0fm+1FXLK21wfvQgP6/v0wDB3YKlGlHzWWiVc2f
-4EF/VAyPR8bJwpnZvQpsQ16HEftyyHTbishVbiqzvTNi4HnmSX6WQI2pwFHlF22j
-UWJzSfLqp8NW340zo/EYDAm/dPaqVGR+pVtUEta+oGSI7OQWB3hGt7znSpdgFrah
-i1IOkcu3fie15FzSlBtFhByigtz6iedrTCvYZhfswU4XxJfPJtlVnDubQ9xKDXp6
-3xuy8R4ekMysSOGHq2NdOaYvOoMK8LAJ++KZwEe6UJfBDvEkC23V3mkoCKiUANDY
-GuJ5SOqw6DF6cO/i+StvOuB+2mxMOhR4x893N/ntQrITYldvRh+QHNFoyKc5NUu4
-035ezDVRDR4kzJzzTFfO9yshGFrqb7oyfUegzZMGah1sNn7AWG7AtBSbxSzmRk5s
-0uBrBX7ASfMUGkpUV7BFsvDPi819k5iWLYLFPiFB/CJ5Wq0HHU4j9XDIa/dEuSe+
-0HvQpYf/2IiYocxKxnZOXfdO06cigip1OjxbIXgx1uqrCyzB7c7XMLEUXETpdj1p
-XPCvZ/9BaRNjWvvTrNNB2nMSarFdtjY6pB8bZtP4xObiQ59L3mLoL9/MD87Cnhzn
-Gr8Yr3V5TJk8o60rWNNpaXeCbIlJONFN128uAP8vgjaYviHNb15ViDW1a57fO/OW
-4XOt5jqVDC/NfQXADku7bcs1SPUOKbDgVeYiiq0na3t5yePNRZVcA6FEHuc9hDLi
-T+Fp7bqxXa7pZMn9FOCJ0cRhtoD6LaIqNbtzCIU9u6HBbJkg36Nz7ysh3riYPKBI
-ShLhSb+unI2owdWBi6QwDRus2FtcvPwPNrqtnZ1V5/YyFY6k7ScLR6R67A4ESKNJ
-qIWQ0iCN9nCjbCGpO62e5BzwoVGXiTQK7QK1WPT95+E3Qlv8q6hGi32d5gMUNR1h
-r8OmL+HXMZE2azKJB1mKldYznOYiSIJDjvSp/Jm4A+6zYB6wwiQWwZUUrmW7zbg0
-o7PHImDvRj8hkJlpNRCqLKkyKF+/PaqkFx2dJxJT3xmVJ+H7wqmwhii1Y0RE9YHu
-yzrL7vZpC2a2cjyJnlDG7sX4ZLPNg1vOEXcnKO/6+HHDLkmPQj85+mqHInrTvuca
-GqC/JZeD8FMnpsWQC51ZwThbwlzq91kvFPhSxOqEequ0HP/1K3DdNhxQNKwQseV2
-0jK0rCgibSroD8bE7kghtUPK/fts6XGRqgXmPmx9i3VJGbJw14GvKGp3oyosVEna
------END RSA PRIVATE KEY-----

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-----