Refactor test servers to remove webrick dependency

Author: sferik

Gemfile

@@ -5,10 +5,6 @@ ruby RUBY_VERSION
 
 gem "rake"
 
-# Ruby 3.0 does not ship it anymore.
-# TODO: We should probably refactor tests to avoid need for it.
-gem "webrick"
-
 group :development do
   gem "debug", platform: :mri
 

lib/http/response/status.rb

@@ -19,8 +19,8 @@ class << self
         # @api public
         def coerce(object)
           code = case object
-                 when String  then SYMBOL_CODES.dig(symbolize(object))
-                 when Symbol  then SYMBOL_CODES.dig(object)
+                 when String  then SYMBOL_CODES[symbolize(object)]
+                 when Symbol  then SYMBOL_CODES[object]
                  when Numeric then object
                  end
 

test/support/black_hole.rb

@@ -1,44 +1,124 @@
 # frozen_string_literal: true
 
-require "webrick"
-require "webrick/ssl"
+require "socket"
+require "openssl"
 
-require "support/black_hole"
 require "support/dummy_server/servlet"
-require "support/servers/config"
 require "support/servers/runner"
 require "support/ssl_helper"
 
-class DummyServer < WEBrick::HTTPServer
-  include ServerConfig
-
-  CONFIG = {
-    BindAddress: "127.0.0.1",
-    Port:        0,
-    AccessLog:   BlackHole,
-    Logger:      BlackHole
-  }.freeze
-
-  SSL_CONFIG = CONFIG.merge(
-    SSLEnable:           true,
-    SSLStartImmediately: true
-  ).freeze
-
+class DummyServer
   def initialize(options = {})
-    super(options[:ssl] ? SSL_CONFIG : CONFIG)
-    @memo = {}
-    mount("/", Servlet, @memo)
+    @ssl        = options[:ssl]
+    @tcp_server = TCPServer.new("127.0.0.1", 0)
+    @port       = @tcp_server.addr[1]
+    @memo       = {}
+    @servlet    = Servlet.new(self, @memo)
+    @running    = false
+  end
+
+  def addr
+    "127.0.0.1"
   end
 
+  attr_reader :port
+
   def endpoint
     "#{scheme}://#{addr}:#{port}"
   end
 
   def scheme
-    config[:SSLEnable] ? "https" : "http"
+    @ssl ? "https" : "http"
+  end
+
+  def start
+    server = @ssl ? ssl_server : @tcp_server
+    @running = true
+
+    while @running
+      client = server.accept
+      Thread.new(client) { |c| handle_connection(c) }
+    end
+  rescue IOError, Errno::EBADF
+    # Server socket closed during shutdown
+  end
+
+  def shutdown
+    @running = false
+    @tcp_server.close
+  rescue
+    nil
   end
 
   def ssl_context
     @ssl_context ||= SSLHelper.server_context
   end
+
+  private
+
+  def ssl_server
+    OpenSSL::SSL::SSLServer.new(@tcp_server, ssl_context)
+  end
+
+  def handle_connection(client)
+    loop do
+      request = read_request(client)
+      break unless request
+
+      Thread.pass
+      respond(client, request)
+    end
+  rescue IOError, Errno::ECONNRESET, Errno::EPIPE, Errno::EPROTOTYPE, OpenSSL::SSL::SSLError
+    # Connection closed or SSL error
+  ensure
+    client.close rescue nil # rubocop:disable Style/RescueModifier
+  end
+
+  def respond(client, request)
+    response = Response.new
+    @servlet.dispatch(request, response)
+    client.write(response.serialize(head_request: request.request_method == "HEAD"))
+  end
+
+  def read_request(client)
+    line = client.gets
+    return unless line
+
+    method, uri, = line.split(" ", 3)
+    return bad_request(client) unless uri.ascii_only?
+
+    raw_path, query_string = uri.split("?", 2)
+    headers = read_headers(client)
+
+    Request.new({
+      request_method: method, request_path: percent_decode(raw_path),
+      query_string: query_string, headers: headers,
+      body: read_body(client, headers), socket: client, unparsed_uri: uri
+    })
+  end
+
+  def read_headers(client)
+    headers = {}
+    while (header_line = client.gets)
+      break if header_line == "\r\n"
+
+      key, value = header_line.split(": ", 2)
+      headers[key.downcase] = value.strip
+    end
+    headers
+  end
+
+  def read_body(client, headers)
+    content_length = headers["content-length"]
+    client.read(content_length.to_i) if content_length
+  end
+
+  def bad_request(client)
+    client.write("HTTP/1.1 400 Bad Request\r\nContent-Length: 0\r\nConnection: close\r\n\r\n")
+    nil
+  end
+
+  def percent_decode(str)
+    str.b.gsub(/%([0-9A-Fa-f]{2})/) { [::Regexp.last_match(1)].pack("H2") }
+  end
 end

test/support/dummy_server.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class DummyServer < WEBrick::HTTPServer
+class DummyServer
   class Servlet
     post "/encoded-body" do |req, res|
       res.status = 200

test/support/dummy_server/encoding_routes.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 
-class DummyServer < WEBrick::HTTPServer
+class DummyServer
   class Servlet
     get "/" do |req, res|
       res.status = 200
@@ -65,12 +65,12 @@ class Servlet
 
     get "/redirect-301" do |_req, res|
       res.status      = 301
-      res["Location"] = "http://#{@server.config[:BindAddress]}:#{@server.config[:Port]}/"
+      res["Location"] = "http://#{@server.addr}:#{@server.port}/"
     end
 
     get "/redirect-302" do |_req, res|
       res.status      = 302
-      res["Location"] = "http://#{@server.config[:BindAddress]}:#{@server.config[:Port]}/"
+      res["Location"] = "http://#{@server.addr}:#{@server.port}/"
     end
 
     post "/form" do |req, res|

test/support/dummy_server/routes.rb

@@ -2,37 +2,134 @@
 
 require "uri"
 
-class DummyServer < WEBrick::HTTPServer
-  class Servlet < WEBrick::HTTPServlet::AbstractServlet
+class DummyServer
+  Cookie = Struct.new(:name, :value)
+
+  class Request
+    attr_reader :request_method
+    attr_reader :path
+    attr_reader :query_string
+    attr_reader :body
+    attr_reader :unparsed_uri
+
+    def initialize(attrs)
+      @request_method = attrs[:request_method]
+      @path           = attrs[:request_path]
+      @query_string   = attrs[:query_string]
+      @headers        = attrs[:headers]
+      @body           = attrs[:body]
+      @socket         = attrs[:socket]
+      @unparsed_uri   = attrs[:unparsed_uri]
+    end
+
+    def [](header)
+      @headers[header.downcase]
+    end
+
+    def query
+      @query ||= if body && @headers["content-type"]&.include?("application/x-www-form-urlencoded")
+                   URI.decode_www_form(body).to_h
+                 elsif query_string
+                   URI.decode_www_form(query_string).to_h
+                 else
+                   {}
+                 end
+    end
+
+    def cookies
+      @cookies ||= parse_cookies
+    end
+
+    private
+
+    def parse_cookies
+      cookie_header = @headers["cookie"]
+      return [] unless cookie_header
+
+      cookie_header.split("; ").map do |pair|
+        name, value = pair.split("=", 2)
+        Cookie.new(name, value)
+      end
+    end
+  end
+
+  class Response
+    attr_accessor :status
+    attr_accessor :body
+
+    STATUS_TEXTS = {
+      200 => "OK",
+      204 => "No Content",
+      301 => "Moved Permanently",
+      302 => "Found",
+      400 => "Bad Request",
+      404 => "Not Found",
+      500 => "Internal Server Error"
+    }.freeze
+
+    def initialize
+      @status  = 200
+      @headers = {}
+      @body    = ""
+    end
+
+    def []=(header, value)
+      @headers[header] = value
+    end
+
+    def [](header)
+      @headers[header]
+    end
+
+    def serialize(head_request: false)
+      status_text = STATUS_TEXTS[@status] || "OK"
+      body_bytes  = @body.to_s.b
+
+      lines = "HTTP/1.1 #{@status} #{status_text}\r\n"
+      @headers.each { |k, v| lines << "#{k}: #{v}\r\n" }
+      lines << "Content-Length: #{body_bytes.bytesize}\r\n" unless @headers.key?("Content-Length")
+      lines << "Connection: keep-alive\r\n"
+      lines << "\r\n"
+      lines << body_bytes unless head_request
+      lines
+    end
+  end
+
+  class Servlet
     def self.sockets
       @sockets ||= []
     end
 
+    def self.handlers
+      @handlers ||= {}
+    end
+
+    def initialize(server, memo)
+      @server = server
+      @memo   = memo
+    end
+
     def not_found(req, res)
       res.status = 404
       res.body   = "#{req.unparsed_uri} not found"
     end
 
-    def self.handlers
-      @handlers ||= {}
-    end
+    def dispatch(req, res)
+      method  = req.request_method.downcase
+      handler = self.class.handlers["#{method}:#{req.path}"]
 
-    def initialize(server, memo)
-      super(server)
-      @memo = memo
+      if handler
+        instance_exec(req, res, &handler)
+      else
+        not_found(req, res)
+      end
     end
 
     %w[get post head].each do |method|
       class_eval <<-RUBY, __FILE__, __LINE__ + 1
         def self.#{method}(path, &block)
           handlers["#{method}:\#{path}"] = block
         end
-
-        def do_#{method.upcase}(req, res)
-          handler = self.class.handlers["#{method}:\#{req.path}"]
-          return instance_exec(req, res, &handler) if handler
-          not_found(req, res)
-        end
       RUBY
     end
   end