trmnl_preview 0.15.0 → 0.17.0

data/lib/trmnlp/screenshot.rb

@@ -7,6 +7,26 @@ require_relative 'errors'
 
 module TRMNLP
   class Screenshot
+    # TRMNL's Converter::Html waits for these flags, longer for a map, then captures what is drawn.
+    READINESS_TIMEOUT_SECONDS = 5
+    READINESS_TIMEOUT_WITH_MAPS_SECONDS = 12
+    MAPS_DOCUMENT_PATTERN = %r{TRMNLMaps\.[a-z]|maplibre-gl(?:\.js|\.css|[/@]\d)}
+    READINESS_CHECK_SCRIPT = <<~JS
+      return document.readyState === 'complete' && window.TRMNL_PLUGINS_READY === true &&
+             window.TRMNL_HIGHCHARTS_DONE === true && window.TRMNL_CHILD_DITHER_DONE !== false
+    JS
+    # Stops timers and animation callbacks from changing the page mid-capture.
+    FREEZE_TIMERS = <<~JS
+      const noop = () => 0;
+      window.setTimeout = window.setInterval = noop;
+      window.requestAnimationFrame = noop;
+      if (window.requestIdleCallback) window.requestIdleCallback = noop;
+      for (let i = 100000; i >= 0; i--) { window.clearTimeout(i); window.clearInterval(i); }
+      if (window.ResizeObserver) window.ResizeObserver.prototype.observe = noop;
+      if (window.MutationObserver) window.MutationObserver.prototype.observe = noop;
+      window.onresize = null;
+    JS
+
     def initialize(pool:, viewport_timeout: 5)
       @pool = pool
       @viewport_timeout = viewport_timeout
@@ -25,11 +45,25 @@ module TRMNLP
       end
     end
 
+    # Loads html into driver at width x height and waits until TRMNL would capture it, and until wait_for
+    # (a JavaScript expression) is true when given: a page still drawing would be stopped by the frozen timers.
+    # rubocop:disable-next Metrics/ParameterLists -- the page, its size, and what to wait for
+    def show(driver, html, width, height, wait_for: nil, wait_for_timeout: READINESS_TIMEOUT_SECONDS)
+      resize(driver, width, height)
+      load_page(driver, html) { wait_for_expression(driver, wait_for, wait_for_timeout) if wait_for }
+    end
+
+    def capture(driver)
+      file = Tempfile.new(['screenshot', '.png'])
+      driver.save_screenshot(file.path)
+      file.close
+      file
+    end
+
     private
 
     def render(driver, html, width, height)
-      resize(driver, width, height)
-      load_page(driver, html)
+      show(driver, html, width, height)
       capture(driver)
     end
 
@@ -87,23 +121,28 @@ module TRMNLP
         document.close();
       JS
 
-      Selenium::WebDriver::Wait.new(timeout: 5).until do
-        driver.execute_script('return document.readyState') == 'complete'
-      end
-
+      wait_until_ready(driver, html)
+      yield if block_given?
       driver.execute_script('return document.fonts && document.fonts.ready')
 
       driver.execute_script(<<~JS)
         document.documentElement.style.overflow = 'hidden';
         document.body.style.overflow = 'hidden';
       JS
+      driver.execute_script(FREEZE_TIMERS)
     end
 
-    def capture(driver)
-      file = Tempfile.new(['screenshot', '.png'])
-      driver.save_screenshot(file.path)
-      file.close
-      file
+    def wait_for_expression(driver, expression, timeout)
+      Selenium::WebDriver::Wait.new(timeout:, interval: 0.05).until { driver.execute_script("return !!(#{expression});") }
+    rescue Selenium::WebDriver::Error::TimeoutError
+      raise RenderError, "The page did not reach #{expression} within #{timeout}s"
+    end
+
+    def wait_until_ready(driver, html)
+      timeout = html.match?(MAPS_DOCUMENT_PATTERN) ? READINESS_TIMEOUT_WITH_MAPS_SECONDS : READINESS_TIMEOUT_SECONDS
+      Selenium::WebDriver::Wait.new(timeout:, interval: 0.05).until { driver.execute_script(READINESS_CHECK_SCRIPT) }
+    rescue Selenium::WebDriver::Error::TimeoutError
+      nil
     end
   end
 end

data/lib/trmnlp/select_field_choices.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module TRMNLP
+  # A select field's options as TRMNL saves them: "New York" as new_york, { Label: value } as its value.
+  class SelectFieldChoices
+    def initialize(field)
+      options = field['options']
+      @options = options.is_a?(Array) ? options.compact : []
+    end
+
+    def pairs
+      @pairs ||= @options.map do |option|
+        option.is_a?(Hash) ? [option.keys.first, option.values.first] : [option, option.to_s.downcase.tr(' ', '_')]
+      end
+    end
+
+    # A label becomes its value; a value, or anything the options do not list, is kept as it is.
+    def stored_value(input)
+      return input.map { stored_value(it) } if input.is_a?(Array)
+      return input if input.to_s.empty? || pairs.any? { |_, value| value.to_s == input.to_s }
+
+      pairs.find { |label, _| label.to_s == input.to_s }&.last&.to_s || input
+    end
+  end
+end

data/lib/trmnlp/testing/browser.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'tmpdir'
+
+require_relative '../browser_pool'
+require_relative '../firefox_driver'
+require_relative '../screen_generator'
+require_relative '../screenshot'
+require_relative 'inline_stylesheets'
+
+module TRMNLP
+  module Testing
+    # The Firefox one example renders in, checked out of the pool on first use and back in by #release.
+    # Pages load the way `trmnlp build --png` loads them, through ScreenGenerator and Screenshot.
+    class Browser
+      def initialize(pool:)
+        @pool = pool
+        @screenshot = Screenshot.new(pool:)
+        @pages = {}.compare_by_identity
+        @fresh_browsers = []
+      end
+
+      # A Firefox of its own, with nothing cached, closed when this browser is released.
+      def fresh
+        pool = BrowserPool.new(driver_factory: FirefoxDriver.method(:build), max_size: 1)
+        self.class.new(pool:).tap { @fresh_browsers << [it, pool] }
+      end
+
+      # The PNG path, quantized to the device's bit depth like a build's.
+      def capture(screen)
+        @capturing = screen
+        keep(generate(screen))
+      end
+
+      # ScreenGenerator's screenshot interface: html arrives with chart libraries swapped for TRMNL's copies.
+      def call(html:, width:, height:)
+        @pages[@capturing] = [html, width, height]
+        show(@capturing)
+        @screenshot.capture(driver)
+      end
+
+      # Yields the driver with screen's page loaded, reloading it if a later render replaced it.
+      def on(screen)
+        show(screen) unless @showing.equal?(screen)
+        yield driver
+      end
+
+      def release
+        @fresh_browsers.each do |browser, pool|
+          browser.release
+          pool.shutdown
+        end
+        @fresh_browsers.clear
+        @pool.checkin(@driver) if @driver
+        @driver = nil
+        @showing = nil
+      end
+
+      private
+
+      def generate(screen)
+        device = screen.device
+        html = InlineStylesheets.call(screen.html)
+        ScreenGenerator.new(html, screenshot: self, width: device.width, height: device.height,
+                                  color_depth: device.bit_depth).process
+      end
+
+      def driver = @driver ||= @pool.checkout
+
+      def show(screen)
+        html, width, height = @pages.fetch(screen)
+        @screenshot.show(driver, html, width, height,
+                         wait_for: screen.wait_for, wait_for_timeout: screen.wait_for_timeout)
+        @showing = screen
+      end
+
+      def keep(image)
+        path = File.join(Dir.mktmpdir('trmnlp-screen-'), 'screen.png')
+        FileUtils.cp(image.path, path)
+        path
+      ensure
+        image.close!
+      end
+    end
+  end
+end

data/lib/trmnlp/testing/certificate_authority.rb

@@ -0,0 +1,84 @@
+# frozen_string_literal: true
+
+require 'fileutils'
+require 'openssl'
+require 'tmpdir'
+
+module TRMNLP
+  module Testing
+    # A throwaway authority the transform process is told to trust, so MockProxy can answer HTTPS.
+    # Lives for one server process; nothing is written outside its temp directory.
+    class CertificateAuthority
+      # Wide enough for any time a test freezes the clock at.
+      VALID_FROM = Time.utc(2000, 1, 1)
+      VALID_UNTIL = Time.utc(2099, 12, 31)
+
+      attr_reader :pem_path, :bundle_path, :php_ini_dir
+
+      def initialize
+        @key = OpenSSL::PKey::RSA.new(2048)
+        @certificate = sign(subject: 'trmnlp test CA', public_key: @key.public_key, authority: true)
+        @leaves = {}
+        @lock = Mutex.new
+        write_files(Dir.mktmpdir('trmnlp-ca-'))
+      end
+
+      # The variables that make Node, Python, Ruby and PHP trust this authority.
+      def environment
+        { 'NODE_EXTRA_CA_CERTS' => pem_path, 'SSL_CERT_FILE' => bundle_path, 'REQUESTS_CA_BUNDLE' => bundle_path,
+          'CURL_CA_BUNDLE' => bundle_path, 'PHP_INI_SCAN_DIR' => ":#{php_ini_dir}" }
+      end
+
+      def remove = FileUtils.remove_entry(File.dirname(pem_path))
+
+      def ssl_context_for(host)
+        @lock.synchronize do
+          @leaves[host] ||= OpenSSL::SSL::SSLContext.new.tap do |context|
+            context.key = @key
+            context.cert = sign(subject: host, public_key: @key.public_key, authority: false, host:)
+          end
+        end
+      end
+
+      private
+
+      def sign(subject:, public_key:, authority:, host: nil)
+        certificate = OpenSSL::X509::Certificate.new
+        certificate.version = 2
+        certificate.serial = OpenSSL::BN.rand(64)
+        certificate.subject = OpenSSL::X509::Name.parse("/CN=#{subject}")
+        certificate.issuer = authority ? certificate.subject : @certificate.subject
+        certificate.public_key = public_key
+        certificate.not_before = VALID_FROM
+        certificate.not_after = VALID_UNTIL
+        add_extensions(certificate, authority, host)
+        certificate.sign(@key, OpenSSL::Digest.new('SHA256'))
+      end
+
+      def add_extensions(certificate, authority, host)
+        factory = OpenSSL::X509::ExtensionFactory.new(authority ? certificate : @certificate, certificate)
+        if authority
+          certificate.add_extension(factory.create_extension('basicConstraints', 'CA:TRUE', true))
+          certificate.add_extension(factory.create_extension('keyUsage', 'keyCertSign,cRLSign', true))
+        else
+          name = host.match?(/\A[\d.]+\z/) ? "IP:#{host}" : "DNS:#{host}"
+          certificate.add_extension(factory.create_extension('subjectAltName', name))
+          certificate.add_extension(factory.create_extension('extendedKeyUsage', 'serverAuth'))
+        end
+      end
+
+      def write_files(dir)
+        @pem_path = File.join(dir, 'ca.pem')
+        @bundle_path = File.join(dir, 'bundle.pem')
+        @php_ini_dir = File.join(dir, 'php')
+        File.write(pem_path, @certificate.to_pem)
+        system_file = OpenSSL::X509::DEFAULT_CERT_FILE
+        system_bundle = File.exist?(system_file) ? File.read(system_file) : ''
+        File.write(bundle_path, system_bundle + @certificate.to_pem)
+        Dir.mkdir(php_ini_dir)
+        php_settings = "curl.cainfo=#{bundle_path}\nopenssl.cafile=#{bundle_path}\n"
+        File.write(File.join(php_ini_dir, 'trmnlp-ca.ini'), php_settings)
+      end
+    end
+  end
+end

data/lib/trmnlp/testing/device_models.rb

@@ -0,0 +1,80 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'json'
+
+require_relative '../errors'
+
+module TRMNLP
+  module Testing
+    # TRMNL's device models, as `trmnlp serve`'s picker loads them, turned into what a render needs.
+    module DeviceModels
+      API_URL = 'https://trmnl.com/api'
+
+      Device = Data.define(:name, :width, :height, :bit_depth, :screen_classes, :image_size_limit) do
+        def render_params = { width:, height:, model: name, bit_depth: }
+      end
+
+      module_function
+
+      def names = models.map { it['name'] }
+
+      # A model name, or a Hash of width:, height:, bit_depth: and optionally screen_classes: for a custom screen.
+      def find(device, orientation: :landscape, palette: nil)
+        return custom(device) if device.is_a?(Hash)
+
+        model = models.find { it['name'] == device.to_s } ||
+                raise(TestingError, "Unknown device #{device.inspect}; known: #{names.join(', ')}")
+        portrait = orientation.to_s == 'portrait'
+        width, height = portrait ? model.values_at('height', 'width') : model.values_at('width', 'height')
+        chosen = palette_for(model, palette)
+        Device.new(name: model['name'], width:, height:, bit_depth: bit_depth(model, chosen),
+                   screen_classes: screen_classes(model, chosen, portrait), image_size_limit: model['image_size_limit'])
+      end
+
+      # The picker's classes: palette, device, size, then portrait.
+      def screen_classes(model, palette, portrait)
+        css = model.dig('css', 'classes') || {}
+        ['screen', palette&.fetch('framework_class'), css['device'], css['size'],
+         ('screen--portrait' if portrait)].compact.join(' ')
+      end
+
+      def palette_for(model, id)
+        candidates = palettes.select { model['palette_ids'].to_a.include?(it['id']) }
+        return candidates.find { it['id'] == id.to_s } || raise(TestingError, unknown_palette(model, id)) if id
+
+        candidates.find { it['grays'] == 2**model['bit_depth'] } || candidates.first
+      end
+
+      # A palette of fewer grays draws the PNG at that depth, as the device then does.
+      def bit_depth(model, palette)
+        grays = palette && palette['grays']
+        grays ? [Math.log2(grays).ceil, model['bit_depth']].min : model['bit_depth']
+      end
+
+      def unknown_palette(model, id)
+        "Model #{model['name']} has no palette #{id.inspect}; it has #{model['palette_ids'].to_a.join(', ')}"
+      end
+
+      def custom(device)
+        device = device.transform_keys(&:to_sym)
+        Device.new(name: device.fetch(:model, 'custom'), width: device.fetch(:width), height: device.fetch(:height),
+                   bit_depth: device.fetch(:bit_depth, 1), screen_classes: device[:screen_classes],
+                   image_size_limit: device[:image_size_limit])
+      end
+
+      def models = @models ||= fetch('models')
+      def palettes = @palettes ||= fetch('palettes')
+
+      def fetch(resource)
+        response = Faraday.get("#{API_URL}/#{resource}")
+        raise TestingError, "Could not load TRMNL's #{resource} (HTTP #{response.status})" unless response.success?
+
+        body = JSON.parse(response.body)
+        body.is_a?(Hash) ? body.fetch('data') : body
+      rescue Faraday::Error => e
+        raise TestingError, "Could not load TRMNL's #{resource}: #{e.message}. Pass a device Hash to test offline."
+      end
+    end
+  end
+end

data/lib/trmnlp/testing/frozen_clock.rb

@@ -0,0 +1,86 @@
+# frozen_string_literal: true
+
+require 'rbconfig'
+
+require_relative '../errors'
+
+module TRMNLP
+  module Testing
+    # Starts every clock a run reads at the test's time: Ruby's own (Liquid's `now`, the trmnl namespace)
+    # and, through libfaketime, the transform process's, whatever its language.
+    module FrozenClock
+      LIBRARY_ENV_KEY = 'TRMNLP_LIBFAKETIME'
+      LIBRARY_GLOBS = {
+        darwin: %w[/opt/homebrew/opt/libfaketime/lib/faketime/libfaketime.1.dylib
+                   /usr/local/opt/libfaketime/lib/faketime/libfaketime.1.dylib],
+        linux: %w[/usr/lib/*/faketime/libfaketime.so.1 /usr/lib/faketime/libfaketime.so.1
+                  /usr/local/lib/faketime/libfaketime.so.1]
+      }.freeze
+      INSTALL_HINTS = { darwin: 'brew install libfaketime', linux: 'apt-get install libfaketime' }.freeze
+      # macOS drops DYLD_* variables for the binaries System Integrity Protection guards.
+      PROTECTED_PREFIXES = %w[/usr/bin/ /bin/ /sbin/ /usr/sbin/ /System/].freeze
+
+      # Answers Time.now with the frozen time on the current thread while it is set.
+      module FrozenNow
+        def now(...) = Thread.current[:trmnlp_frozen_now]&.dup || super
+      end
+      Time.singleton_class.prepend(FrozenNow)
+
+      module_function
+
+      def around(time)
+        previous = Thread.current[:trmnlp_frozen_now]
+        Thread.current[:trmnlp_frozen_now] = time
+        yield
+      ensure
+        Thread.current[:trmnlp_frozen_now] = previous
+      end
+
+      # The clock reads its time from clock_file on every call, so #move can set it forward mid-run.
+      def environment(time, interpreter:, clock_file:)
+        os = operating_system
+        library = library_path(os)
+        refuse_protected(interpreter) if os == :darwin
+
+        write(clock_file, time)
+        preload_variables(os, library).merge('FAKETIME_TIMESTAMP_FILE' => clock_file.to_s, 'FAKETIME_NO_CACHE' => '1',
+                                             'FAKETIME_DONT_FAKE_MONOTONIC' => '1', 'FAKETIME_DONT_RESET' => '1',
+                                             'TZ' => 'UTC')
+      end
+
+      def write(clock_file, time) = File.write(clock_file, "#{time.utc.strftime('@%Y-%m-%d %H:%M:%S')}\n")
+
+      def preload_variables(os, library)
+        return { 'LD_PRELOAD' => library } if os == :linux
+
+        { 'DYLD_INSERT_LIBRARIES' => library, 'DYLD_FORCE_FLAT_NAMESPACE' => '1' }
+      end
+
+      def operating_system
+        case RbConfig::CONFIG['host_os']
+        when /darwin/ then :darwin
+        when /linux/ then :linux
+        else raise TestingError, 'A frozen clock needs libfaketime, which runs on macOS and Linux only'
+        end
+      end
+
+      def library_path(os)
+        return ENV[LIBRARY_ENV_KEY] if ENV[LIBRARY_ENV_KEY]
+
+        found = LIBRARY_GLOBS.fetch(os).flat_map { Dir.glob(it) }.first
+        return found if found
+
+        raise TestingError,
+              "A frozen clock needs libfaketime: #{INSTALL_HINTS.fetch(os)} (or set #{LIBRARY_ENV_KEY})"
+      end
+
+      def refuse_protected(interpreter)
+        real_path = File.realpath(interpreter)
+        return unless PROTECTED_PREFIXES.any? { real_path.start_with?(it) }
+
+        raise TestingError,
+              "macOS will not freeze the clock for #{real_path}; install the interpreter with brew or mise"
+      end
+    end
+  end
+end

data/lib/trmnlp/testing/inline_stylesheets.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'faraday'
+require 'uri'
+
+module TRMNLP
+  module Testing
+    # Puts a page's linked stylesheets in the page itself. A page written with document.write, as TRMNL and
+    # trmnlp write theirs, runs its scripts without waiting for linked stylesheets, so a script that
+    # measures text (a layout solver, say) raced them and drew a different board from run to run.
+    module InlineStylesheets
+      LINK = /<link\b[^>]*\brel=["']stylesheet["'][^>]*>/i
+      HREF = /\bhref=["'](https?:[^"']+)["']/i
+      CSS_URL = /url\(\s*(['"]?)(?!data:|https?:|#)([^'")]+)\1\s*\)/i
+
+      module_function
+
+      def call(html)
+        html.gsub(LINK) do |link|
+          url = link[HREF, 1]
+          css = url && stylesheet(url)
+          css ? "<style data-href=\"#{url}\">#{css}</style>" : link
+        end
+      end
+
+      # nil when the stylesheet cannot be fetched: the page keeps its link.
+      def stylesheet(url)
+        cache.fetch(url) do
+          response = Faraday.get(url)
+          cache[url] = response.success? ? absolute_urls(response.body, url) : nil
+        end
+      rescue Faraday::Error
+        nil
+      end
+
+      def absolute_urls(css, base) = css.gsub(CSS_URL) { "url(\"#{URI.join(base, Regexp.last_match(2))}\")" }
+
+      def cache = @cache ||= {}
+    end
+  end
+end

data/lib/trmnlp/testing/memory_sampler.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+module TRMNLP
+  module Testing
+    # The peak memory of a running process, read every few milliseconds until it exits: VmHWM on Linux
+    # (the kernel's own high-water mark), the resident size from ps on macOS (the highest one seen).
+    class MemorySampler
+      INTERVAL_SECONDS = 0.01
+
+      def self.start(pid) = new(pid).tap(&:start)
+
+      def initialize(pid)
+        @pid = pid
+        @peak_kb = nil
+      end
+
+      def start
+        @thread = Thread.new do
+          while (kb = read_kb)
+            @peak_kb = [@peak_kb.to_i, kb].max
+            sleep INTERVAL_SECONDS
+          end
+        end
+      end
+
+      def peak_mb
+        @thread&.join
+        @peak_kb && (@peak_kb / 1024.0).round(1)
+      end
+
+      private
+
+      # nil once the process is gone.
+      def read_kb
+        return File.read("/proc/#{@pid}/status")[/VmHWM:\s+(\d+)/, 1]&.to_i if File.exist?('/proc/self/status')
+
+        kb = IO.popen(['ps', '-o', 'rss=', '-p', @pid.to_s], err: File::NULL, &:read).strip
+        kb.empty? ? nil : kb.to_i
+      rescue SystemCallError
+        nil
+      end
+    end
+  end
+end

data/lib/trmnlp/testing/mock_proxy.rb

@@ -0,0 +1,124 @@
+# frozen_string_literal: true
+
+require 'openssl'
+require 'socket'
+
+module TRMNLP
+  module Testing
+    # The HTTP(S) proxy a transform process runs behind, answering from a MockTable. HTTPS is opened with
+    # certificates from CertificateAuthority, so mocks work for every language and library that honors
+    # the proxy variables. One request per connection, then the connection closes.
+    class MockProxy
+      def initialize(table:, authority:)
+        @table = table
+        @authority = authority
+      end
+
+      def self.open(table:, authority:)
+        proxy = new(table:, authority:).start
+        yield proxy
+      ensure
+        proxy&.stop
+      end
+
+      def start
+        @server = TCPServer.new('127.0.0.1', 0)
+        @thread = Thread.new { loop { Thread.new(@server.accept) { serve(it) } } }
+        self
+      end
+
+      def stop
+        @thread&.kill
+        @server&.close
+      end
+
+      def environment
+        proxy = "http://127.0.0.1:#{@server.addr[1]}"
+        { 'HTTP_PROXY' => proxy, 'HTTPS_PROXY' => proxy, 'http_proxy' => proxy, 'https_proxy' => proxy,
+          'NO_PROXY' => '', 'no_proxy' => '', 'NODE_USE_ENV_PROXY' => '1' }.merge(@authority.environment)
+      end
+
+      private
+
+      def serve(socket)
+        verb, target = socket.gets.to_s.split
+        return socket.close unless verb
+
+        verb == 'CONNECT' ? serve_tunnel(socket, target) : serve_request(socket, verb, target, read_headers(socket))
+      rescue IOError, SystemCallError, OpenSSL::SSL::SSLError
+        nil
+      ensure
+        socket.close unless socket.closed?
+      end
+
+      def serve_tunnel(socket, target)
+        read_headers(socket)
+        host, port = target.split(':')
+        socket.write("HTTP/1.1 200 Connection Established\r\n\r\n")
+        tls = OpenSSL::SSL::SSLSocket.new(socket, @authority.ssl_context_for(host))
+        tls.accept
+        verb, path = tls.gets.to_s.split
+        origin = port == '443' ? "https://#{host}" : "https://#{host}:#{port}"
+        serve_request(tls, verb, origin + path.to_s, read_headers(tls))
+        tls.close
+      end
+
+      def serve_request(io, verb, url, headers)
+        body = read_body(io, headers)
+        response = @table.answer(verb, url, headers:, body:, via: :transform)
+        return io.close unless response
+        return if hung_up?(io)
+
+        write_response(io, response)
+        response.record[:delivered] = true
+      rescue IOError, SystemCallError, OpenSSL::SSL::SSLError
+        nil
+      end
+
+      def write_response(io, response)
+        body = response.body.b
+        io.write(head(response, body.bytesize))
+        io.flush
+        sleep(response.body_delay) if response.body_delay
+        io.write(body)
+      end
+
+      # A transform that gave up (its own timeout, an abort signal) has closed the connection by now.
+      def hung_up?(io)
+        socket = io.respond_to?(:to_io) ? io.to_io : io
+        return false unless socket.wait_readable(0)
+
+        socket.recv_nonblock(1, Socket::MSG_PEEK, exception: false).then { it.nil? || it.empty? }
+      end
+
+      def read_headers(io)
+        headers = {}
+        while (line = io.gets) && !line.strip.empty?
+          name, value = line.split(':', 2)
+          headers[name.strip.downcase] = value.to_s.strip
+        end
+        headers
+      end
+
+      def read_body(io, headers)
+        return io.read(headers['content-length'].to_i) if headers['content-length']
+        return nil unless headers['transfer-encoding'].to_s.include?('chunked')
+
+        chunks = +''
+        while (size = io.gets.to_s.to_i(16)).positive?
+          chunks << io.read(size)
+          io.gets
+        end
+        io.gets
+        chunks
+      end
+
+      def head(response, length)
+        lines = response.headers.reject { |name, _| %w[content-length connection].include?(name.downcase) }
+                        .map { |name, value| "#{name}: #{value}" }
+        "HTTP/1.1 #{response.status} Mocked\r\n#{lines.join("\r\n")}\r\ncontent-length: #{length}\r\n" \
+          "connection: close\r\n\r\n"
+      end
+    end
+  end
+end