patron 0.14.0 → 1.0.0

data/spec/support/config.ru

@@ -1,153 +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]
-}
-
-# Echoes the subject of the client certificate Puma verified, if any
-PeerCertServlet = Proc.new {|env|
-  subject = env['puma.peercert'] ? env['puma.peercert'].subject.to_s : 'none'
-  [200, {'Content-Type' => 'text/plain', 'Content-Length' => subject.bytesize.to_s}, [subject]]
-}
-
-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,  
-  "/peercert" => PeerCertServlet,
-})

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/raw_request_capture.rb

@@ -1,93 +0,0 @@
-require 'socket'
-require 'openssl'
-require 'stringio'
-
-# Captures the raw HTTP request a client puts on the wire, independent of any
-# Rack/HTTP server. This lets us assert on hop-by-hop details such as
-# Transfer-Encoding which a conformant server (webrick, puma, ...) decodes and
-# never exposes to the application.
-module RawRequestCapture
-  CapturedRequest = Struct.new(:request_line, :headers, :body)
-
-  CERT_DIR = File.join(__dir__, 'certs')
-
-  # Boots a one-shot capture server on an ephemeral port, yields its base URL to
-  # the block (which must perform a single request against it) and returns the
-  # CapturedRequest. Pass ssl: true to terminate TLS using the test certificates.
-  def capture_request(ssl: false)
-    tcp = TCPServer.new('127.0.0.1', 0)
-    port = tcp.addr[1]
-    server = ssl ? wrap_tls(tcp) : tcp
-    captured = nil
-    acceptor = Thread.new do
-      conn = server.accept
-      captured = read_request(conn)
-      conn.write("HTTP/1.1 200 OK\r\nContent-Length: 2\r\n\r\nok")
-      conn.close
-    end
-    yield "#{ssl ? 'https' : 'http'}://127.0.0.1:#{port}"
-    acceptor.join(5)
-    captured
-  ensure
-    tcp.close if tcp
-  end
-
-  private
-
-  def wrap_tls(tcp)
-    ctx = OpenSSL::SSL::SSLContext.new
-    ctx.cert = OpenSSL::X509::Certificate.new(File.read(File.join(CERT_DIR, 'cacert.pem')))
-    ctx.key = OpenSSL::PKey.read(File.read(File.join(CERT_DIR, 'privkey.pem')))
-    OpenSSL::SSL::SSLServer.new(tcp, ctx)
-  end
-
-  def read_request(conn)
-    buf = +''
-    buf << conn.readpartial(4096) until buf.include?("\r\n\r\n")
-    head, rest = buf.split("\r\n\r\n", 2)
-    request_line, *header_lines = head.split("\r\n")
-    headers = header_lines.each_with_object({}) do |line, acc|
-      name, value = line.split(': ', 2)
-      acc[name.downcase] = value
-    end
-    # Honour Expect: 100-continue so the client proceeds to send the body.
-    conn.write("HTTP/1.1 100 Continue\r\n\r\n") if headers['expect'].to_s =~ /100-continue/i
-    CapturedRequest.new(request_line, headers, read_body(conn, headers, rest))
-  end
-
-  def read_body(conn, headers, rest)
-    if headers['transfer-encoding'] == 'chunked'
-      dechunk(drain_chunked(conn, rest))
-    elsif (len = headers['content-length'])
-      read_exactly(conn, len.to_i, rest)
-    else
-      rest
-    end
-  end
-
-  def drain_chunked(conn, rest)
-    buf = rest.dup
-    buf << conn.readpartial(4096) until buf.include?("0\r\n\r\n")
-    buf
-  end
-
-  def read_exactly(conn, n, rest)
-    buf = rest.dup
-    buf << conn.readpartial(4096) while buf.bytesize < n
-    buf.byteslice(0, n)
-  end
-
-  def dechunk(buf)
-    io = StringIO.new(buf)
-    out = +''
-    while (size_line = io.gets("\r\n"))
-      size = size_line.strip.split(';', 2).first.to_i(16)
-      break if size.zero?
-      out << io.read(size).to_s
-      io.read(2) # trailing CRLF
-    end
-    out
-  end
-end
-
-RSpec.configure { |c| c.include RawRequestCapture }

data/spec/support/test_server.rb

@@ -1,29 +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, client_ca: nil)
-    # 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 && client_ca
-      # force_peer makes Puma drop the handshake when no valid client certificate is presented
-      'ssl://0.0.0.0:%d?key=%s&cert=%s&ca=%s&verify_mode=force_peer' % [port, keypath, certpath, client_ca]
-    elsif 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

data/spec/support/valgrind.supp

@@ -1,2 +0,0 @@
-# Suppressions for the valgrind CI job. Keep this to things that are demonstrably
-# not Patron's: nothing from session_ext.c or membuffer.c may be suppressed here.

data/spec/util_spec.rb

@@ -1,71 +0,0 @@
-require File.expand_path("./spec") + '/spec_helper.rb'
-
-describe Patron::Util do
-
-  describe :build_query_pairs_from_hash do
-    
-    it "correctly serializes a simple hash" do
-      hash = {:foo => "bar", "baz" => 42}
-      array = Patron::Util.build_query_pairs_from_hash(hash)
-      expect(array.size).to be == 2
-      expect(array).to include("foo=bar")
-      expect(array).to include("baz=42")
-    end
-    
-    it "correctly serializes a more complex hash" do
-      hash = {
-        :foo => "bar",
-        :baz => {
-          "quux" => {
-            :zing => {
-              :ying => 42
-            }
-          },
-          :blargh => {
-            :spaz => "sox",
-            :razz => "matazz"
-          }
-        }
-      }
-      array = Patron::Util.build_query_pairs_from_hash(hash)
-      expect(array.size).to be == 4
-      expect(array).to include("foo=bar")
-      expect(array).to include("baz[quux][zing][ying]=42")
-      expect(array).to include("baz[blargh][spaz]=sox")
-      expect(array).to include("baz[blargh][razz]=matazz")
-    end
-  end
-
-  describe :build_query_string_from_hash do
-    it "correctly serializes a simple hash" do
-      hash = {:foo => "bar", "baz" => 42}
-      array = Patron::Util.build_query_string_from_hash(hash).split('&')
-      expect(array.size).to be == 2
-      expect(array).to include("foo=bar")
-      expect(array).to include("baz=42")
-    end
-    it "correctly serializes a more complex hash" do
-      hash = {
-        :foo => "bar",
-        :baz => {
-          "quux" => {
-            :zing => {
-              :ying => 42
-            }
-          },
-          :blargh => {
-            :spaz => "sox",
-            :razz => "matazz"
-          }
-        }
-      }
-      array = Patron::Util.build_query_string_from_hash(hash).split('&')
-      expect(array.size).to be == 4
-      expect(array).to include("foo=bar")
-      expect(array).to include("baz[quux][zing][ying]=42")
-      expect(array).to include("baz[blargh][spaz]=sox")
-      expect(array).to include("baz[blargh][razz]=matazz")
-    end
-  end
-
-end