Tests

import { performanceTest } from "#kit";
import { TOKEN } from "#models/configuration";
import { items } from "#payloads";

const path = "/authorized/small";

export default performanceTest({
  id: { family: "authorized", name: "allowed" },
  path,
  base: "json.small",
  varies: "authorization",
  heft: 1,
  about:
    "A bearer token the framework's own authorization mechanism has to check " +
    "before the handler runs. Read against json.small, the difference is the " +
    "check and the plumbing that carries it, not the crypto, which this " +
    "family leaves out.",

  request: (c) => c.get(path).header("authorization", `Bearer ${TOKEN}`).okWith(items.small),
});

import { performanceTest } from "#kit";
import { TOKEN } from "#models/configuration";

const path = "/authorized/small";

/** The token with its last character changed, so a refusal compares the whole string. */
const wrong = `${TOKEN.slice(0, -1)}0`;

export default performanceTest({
  id: { family: "authorized", name: "denied" },
  path,
  base: "authorized.allowed",
  varies: "outcome",
  heft: 2,
  about:
    "The same endpoint refusing. The token differs from the accepted one by " +
    "its last character, so the comparison walks the whole string and this " +
    "row measures the refusal path rather than a length check.",

  request: (c) => c.get(path).header("authorization", `Bearer ${wrong}`).status(403),
});

import { performanceTest, text } from "#kit";

const path = "/plaintext";

/** Written by the handler as a literal, so it is the one answer with no file in tests/payloads. */
const HELLO = text("Hello, World!", "Hello, World!");

export default performanceTest({
  id: { family: "baseline", name: "plaintext" },
  path,
  heft: 1,
  about:
    "The dispatch floor. A fixed string out, with no serialiser in the way, " +
    "so what is left is the framework accepting a connection, matching a " +
    "route and writing a response. Every other row in the corpus is read " +
    "against this one.",

  request: (c) => c.get(path).okWith(HELLO).hasHeader("content-type", /^text\/plain/),
});

import { performanceTest } from "#kit";
import { bind, order } from "#payloads";

const path = "/body/bind/small";

export default performanceTest({
  id: { family: "body", name: "bind_small" },
  path,
  heft: 2,
  about:
    "A body parsed and bound without being validated. The answer carries a " +
    "count of the leaves it found, which is what says the request was parsed " +
    "rather than piped to the response. This is what the validate row of the " +
    "same size is subtracted from.",

  request: (c) => c.post(path, order.small.value).okWith(bind.small),
});

import { performanceTest } from "#kit";
import { bind, order } from "#payloads";

const path = "/body/bind/medium";

export default performanceTest({
  id: { family: "body", name: "bind_medium" },
  path,
  base: "body.bind_small",
  varies: "size",
  heft: 3,
  about:
    "A body parsed and bound without being validated. The answer carries a " +
    "count of the leaves it found, which is what says the request was parsed " +
    "rather than piped to the response. This is what the validate row of the " +
    "same size is subtracted from.",

  request: (c) => c.post(path, order.medium.value).okWith(bind.medium),
});

import { performanceTest } from "#kit";
import { bind, order } from "#payloads";

const path = "/body/bind/large";

export default performanceTest({
  id: { family: "body", name: "bind_large" },
  path,
  base: "body.bind_medium",
  varies: "size",
  heft: 4,
  about:
    "A body parsed and bound without being validated, at about 40 KB. The " +
    "answer carries a count of the leaves it found, which is what says the " +
    "request was parsed rather than piped to the response. Read against " +
    "body.bind_medium, the difference is the parser and the binder at scale.",

  request: (c) => c.post(path, order.large.value).okWith(bind.large),
});

import { performanceTest } from "#kit";
import { bind, order } from "#payloads";

const path = "/body/validate/large";

export default performanceTest({
  id: { family: "body", name: "validate_large" },
  path,
  base: "body.bind_large",
  varies: "validation",
  heft: 5,
  about:
    "The same body checked against a schema before the handler sees it, and " +
    "answered exactly as the bind row answers it. Read against " +
    "body.bind_large, the difference is the validator alone rather than the " +
    "validator plus the parse.",

  request: (c) => c.post(path, order.large.value).okWith(bind.large),
});

import { performanceTest } from "#kit";
import { bind, order } from "#payloads";

const path = "/body/validate/medium";

export default performanceTest({
  id: { family: "body", name: "validate_medium" },
  path,
  base: "body.bind_medium",
  varies: "validation",
  heft: 3,
  about:
    "The same body checked against a schema before the handler sees it, and " +
    "answered exactly as the bind row answers it. Read against " +
    "body.bind_medium, the difference is the validator alone rather than the " +
    "validator plus the parse.",

  request: (c) => c.post(path, order.medium.value).okWith(bind.medium),
});

import { performanceTest } from "#kit";
import { bind, order } from "#payloads";

const path = "/body/validate/small";

export default performanceTest({
  id: { family: "body", name: "validate_small" },
  path,
  base: "body.bind_small",
  varies: "validation",
  heft: 2,
  about:
    "The same body checked against a schema before the handler sees it, and " +
    "answered exactly as the bind row answers it. Read against " +
    "body.bind_small, the difference is the validator alone rather than the " +
    "validator plus the parse.",

  request: (c) => c.post(path, order.small.value).okWith(bind.small),
});

import { performanceTest } from "#kit";
import { order } from "#payloads";

const path = "/body/validate/small";

export default performanceTest({
  id: { family: "body", name: "rejected_all" },
  path,
  base: "body.validate_small",
  varies: "outcome",
  heft: 2,
  about:
    "Three fields wrong in one body. What a rejection looks like is the " +
    "framework's own contract, so the status and the field paths are read " +
    "through its exceptions declaration and this test never sees an error " +
    "body.",

  request: (c) => c.post(path, order.invalid.value).rejected("customerId", "status", "lines"),
});

import { performanceTest } from "#kit";
import { order } from "#payloads";

const path = "/body/validate/first-error";

export default performanceTest({
  id: { family: "body", name: "rejected_first" },
  path,
  base: "body.rejected_all",
  varies: "error_contract",
  heft: 2,
  about:
    "The same body against a route that stops at the first bad field. Read " +
    "against body.rejected_all, the difference is the two error contracts: " +
    "one walks the whole object and one gives up, and the second is doing " +
    "less work.",

  request: (c) => c.post(path, order.invalid.value).rejected("customerId"),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/cache/large/{draw.key}";

export default performanceTest({
  id: { family: "cache", name: "large" },
  path,
  base: "json.large",
  varies: "response_cache",
  heft: 3,
  about:
    "The handler skipped and a stored answer written back, under one of four " +
    "keys the path names. Read against json.large, the difference is the store " +
    "answering instead of the framework, which is why this row asserts the " +
    "serial repeated rather than changed.",

  request: (c) => c.get(`/cache/large/${c.draw.key()}`).okWith(items.large).replayed(),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/cache/medium/{draw.key}";

export default performanceTest({
  id: { family: "cache", name: "medium" },
  path,
  base: "json.medium",
  varies: "response_cache",
  heft: 1,
  about:
    "The handler skipped and a stored answer written back, under one of four " +
    "keys the path names. Read against json.medium, the difference is the store " +
    "answering instead of the framework, which is why this row asserts the " +
    "serial repeated rather than changed.",

  request: (c) => c.get(`/cache/medium/${c.draw.key()}`).okWith(items.medium).replayed(),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/cache/small/{draw.key}";

export default performanceTest({
  id: { family: "cache", name: "small" },
  path,
  base: "json.small",
  varies: "response_cache",
  heft: 1,
  about:
    "The handler skipped and a stored answer written back, under one of four " +
    "keys the path names. Read against json.small, the difference is the store " +
    "answering instead of the framework, which is why this row asserts the " +
    "serial repeated rather than changed.",

  request: (c) => c.get(`/cache/small/${c.draw.key()}`).okWith(items.small).replayed(),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/cache/vary/one/{draw.key}";
/** Two tenants, so a store that ignores the header holds one entry where two keys were sent. */
const tenants = ["alpha", "beta"];

export default performanceTest({
  id: { family: "cache", name: "vary_one" },
  path,
  base: "cache.small",
  varies: "cache_key",
  heft: 1,
  about:
    "The stored answer keyed by a request header as well as by the path. One " +
    "header with two values, picked per instance, so a store that ignores the " +
    "vary header holds four entries where the plan sent eight keys.",

  request: (c) =>
    c
      .get(`/cache/vary/one/${c.draw.key()}`)
      .header("x-rb-tenant", c.draw.choice(tenants))
      .okWith(items.small)
      .replayed(),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/cache/vary/many/{draw.key}";
/** Two values of each header, so a store that ignores one holds half the entries it was sent. */
const channels = ["web", "app"];
const regions = ["eu", "us"];
const tenants = ["alpha", "beta"];

export default performanceTest({
  id: { family: "cache", name: "vary_many" },
  path,
  base: "cache.vary_one",
  varies: "cache_key",
  heft: 1,
  about:
    "The same thing keyed on three headers instead of one. Read against " +
    "cache.vary_one, the difference is thirty-two distinct keys where there were " +
    "eight, which is what a store has to be sized against rather than what it " +
    "costs to read.",

  request: (c) =>
    c
      .get(`/cache/vary/many/${c.draw.key()}`)
      .header("x-rb-channel", c.draw.choice(channels))
      .header("x-rb-region", c.draw.choice(regions))
      .header("x-rb-tenant", c.draw.choice(tenants))
      .okWith(items.small)
      .replayed(),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/compressed/large";

export default performanceTest({
  id: { family: "compressed", name: "identity_large" },
  path,
  base: "json.large",
  varies: "compression_wiring",
  heft: 4,
  about:
    "The compression middleware installed and declining. The client asks for " +
    "identity, so nothing is compressed and what this row carries is the cost " +
    "of the wiring being in the path at all. It is what the gzip arm is " +
    "subtracted from.",

  request: (c) =>
    c
      .get(path)
      .header("accept-encoding", "identity")
      .header("cache-control", "no-cache")
      .okWith(items.large, { compressed: false })
      .fresh(),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/compressed/large";

export default performanceTest({
  id: { family: "compressed", name: "gzip_large" },
  path,
  base: "compressed.identity_large",
  varies: "compression",
  heft: 5,
  about:
    "The middleware compressing a body large enough to be worth it. Read " +
    "against compressed.identity_large, the difference is the compression and " +
    "nothing else, because both rows carry the same wiring.",

  request: (c) =>
    c
      .get(path)
      .header("accept-encoding", "gzip")
      .header("cache-control", "no-cache")
      .okWith(items.large, { compressed: true })
      .fresh(),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/compressed/small";

export default performanceTest({
  id: { family: "compressed", name: "identity_small" },
  path,
  base: "json.small",
  varies: "compression_wiring",
  heft: 1,
  about:
    "The compression middleware installed and declining. The client asks for " +
    "identity, so nothing is compressed and what this row carries is the cost " +
    "of the wiring being in the path at all. It is what the gzip arm is " +
    "subtracted from.",

  request: (c) =>
    c
      .get(path)
      .header("accept-encoding", "identity")
      .header("cache-control", "no-cache")
      .okWith(items.small, { compressed: false })
      .fresh(),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/compressed/small";

export default performanceTest({
  id: { family: "compressed", name: "gzip_small" },
  path,
  base: "compressed.identity_small",
  varies: "compression",
  heft: 2,
  about:
    "The middleware actually asked to compress, on a body too small to " +
    "benefit. Whether a framework bothers is the point, so this row does not " +
    "assert that the answer came back compressed; it asserts the answer is " +
    "right either way.",

  request: (c) =>
    c
      .get(path)
      .header("accept-encoding", "gzip")
      .header("cache-control", "no-cache")
      .okWith(items.small)
      .fresh(),
});

import { validationTest } from "#kit";
import { CORS } from "#models/configuration";

const path = "/cors/small";
const cors = CORS;

export default validationTest({
  id: { family: "cors", name: "disallowed" },
  path,
  about:
    "A preflight from an origin the policy does not name gets no " +
    "access-control-allow-origin, which is what stops the browser. The status " +
    "is not checked, because frameworks differ on it.",

  request: (c) =>
    c
      .options(path)
      .header("origin", "https://elsewhere.example.net")
      .header("access-control-request-method", cors.method)
      .header("access-control-request-headers", cors.header)
      .noHeader("access-control-allow-origin"),
});

import { performanceTest } from "#kit";
import { CORS } from "#models/configuration";

const path = "/cors/small";
const cors = CORS;

/** The header among any others the framework lists, in any case. */
const LISTS = new RegExp(`(^|,)\\s*${cors.header}\\s*(,|$)`, "i");

export default performanceTest({
  id: { family: "cors", name: "preflight" },
  path,
  base: "baseline.plaintext",
  varies: "preflight",
  heft: 1,
  about:
    "The question a browser asks before a cross-origin request with a custom " +
    "header, answered by the CORS feature before any handler runs. The " +
    "handler on this route writes x-rb-serial, so its absence shows the " +
    "feature answered alone. 200 and 204 are both accepted, because the Fetch " +
    "standard takes any 2xx and frameworks split. Read against " +
    "baseline.plaintext, the difference is the policy being matched.",

  request: (c) =>
    c
      .options(path)
      .header("origin", cors.origin)
      .header("access-control-request-method", cors.method)
      .header("access-control-request-headers", cors.header)
      .status(200, 204)
      .hasHeader("access-control-allow-origin", cors.origin)
      .hasHeader("access-control-allow-headers", LISTS)
      .hasHeader("access-control-max-age", String(cors.maxAgeSeconds))
      .noHeader("x-rb-serial"),
});

import { performanceTest } from "#kit";
import { CORS } from "#models/configuration";
import { items } from "#payloads";

const path = "/cors/small";
const cors = CORS;

export default performanceTest({
  id: { family: "cors", name: "request" },
  path,
  base: "json.small",
  varies: "cors",
  heft: 1,
  about:
    "The cross-origin request itself, with the origin and the custom header " +
    "the preflight asked about. The feature adds its header and lets the " +
    "request through to the handler. Read against json.small, the difference " +
    "is the policy checked on a request that passes it.",

  request: (c) =>
    c
      .get(path)
      .header("origin", cors.origin)
      .header(cors.header, c.run.tenant)
      .okWith(items.small)
      .hasHeader("access-control-allow-origin", cors.origin)
      .fresh(),
});

import { validationTest } from "#kit";
import { CORS } from "#models/configuration";

const path = "/json/small";
const cors = CORS;

export default validationTest({
  id: { family: "cors", name: "scoped" },
  path,
  about:
    "The allowed origin asking a route outside /cors gets no " +
    "access-control-allow-origin, because the policy is attached to /cors and " +
    "nowhere else. A framework whose CORS feature can only cover the whole " +
    "application cannot pass this, and says why in the skips of its rb.json.",

  request: (c) => c.get(path).header("origin", cors.origin).ok().noHeader("access-control-allow-origin"),
});

import { validationTest } from "#kit";
import { CORS } from "#models/configuration";

const path = "/cors/small";
const cors = CORS;

export default validationTest({
  id: { family: "cors", name: "vary" },
  path,
  about:
    "The real response carries Vary: Origin. A policy that names its origin " +
    "answers differently per origin, so a cache in front of the framework has " +
    "to key on it.",

  request: (c) =>
    c
      .get(path)
      .header("origin", cors.origin)
      .header(cors.header, c.run.tenant)
      .ok()
      .hasHeader("vary", /(^|,)\s*origin\s*(,|$)/i),
});

import { performanceTest } from "#kit";

const path = "/body/validate/small";

/** Truncated mid-array, so the parser fails before any field is ever looked at. */
const MALFORMED = '{"customerId": 1, "lines": [';

export default performanceTest({
  id: { family: "errors", name: "malformed" },
  path,
  base: "body.rejected_all",
  varies: "parse_failure",
  heft: 2,
  about:
    "A body that is not JSON at all. Read against body.rejected_all, the " +
    "difference is the parser failing rather than the validator refusing, " +
    "which is often not even the same status inside one framework.",

  request: (c) => c.post(path).raw(MALFORMED).unparseable(),
});

import { performanceTest } from "#kit";

const path = "/items/999999";

export default performanceTest({
  id: { family: "errors", name: "not_found" },
  path,
  base: "items.read",
  varies: "outcome",
  heft: 1,
  about:
    "A lookup the router matches and the handler refuses, because no row has " +
    "that id. Read against items.read, the difference is the refusal in place " +
    "of a row, and against errors.unmatched it is the handler deciding rather " +
    "than the router missing.",

  request: (c) => c.get(path).notFound(),
});

import { performanceTest } from "#kit";

const path = "/errors/unmatched";

export default performanceTest({
  id: { family: "errors", name: "unmatched" },
  path,
  heft: 1,
  about:
    "A path no route matches, which is the router's own miss rather than a " +
    "handler's decision. A framework that walks its whole route table before " +
    "giving up pays for it here and nowhere else.",

  request: (c) => c.get(path).notFound(),
});

import { performanceTest } from "#kit";

const path = "/items/{draw.item}";

export default performanceTest({
  id: { family: "errors", name: "wrong_method" },
  path,
  base: "errors.unmatched",
  varies: "known_path",
  heft: 1,
  about:
    "A path with routes, asked with a method none of them has. A router that " +
    "matches the path first answers 405, and one that matches the method and " +
    "the path together answers 404, so the status is read from the " +
    "framework's declaration. Read against errors.unmatched, the difference " +
    "is how far the router got before it gave up.",

  request: (c) => c.post(`/items/${c.draw.item()}`).wrongMethod(),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/etag/large";

export default performanceTest({
  id: { family: "etag", name: "large" },
  path,
  base: "json.large",
  varies: "validators",
  heft: 4,
  about:
    "The framework hashing the body it is about to send and writing the " +
    "validator it computed onto the response. Read against json.large, the " +
    "difference is the hash and the header. The tag is the framework's own, " +
    "so no two of them agree on it.",

  request: (c) => c.get(path).okWith(items.large).hasHeader("etag").fresh(),
});

import { performanceTest } from "#kit";

const path = "/etag/large";

export default performanceTest({
  id: { family: "etag", name: "match_large" },
  path,
  base: "etag.large",
  varies: "conditional",
  heft: 4,
  about:
    "The only row that cannot be sent until the framework has answered a " +
    "different one: the validator is the framework's to produce. A 304 saves " +
    "the write and nothing else, because the body is built and hashed before " +
    "anything is compared.",

  request: async (c) => {
    const tag = await c.once(path, () => c.get(path).etag());

    return c.get(path).header("if-none-match", tag).notModified().emptyBody();
  },
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/etag/large";

/** A validator no framework computes. */
const stale = '"0000000000000000"';

export default performanceTest({
  id: { family: "etag", name: "stale_large" },
  path,
  base: "etag.large",
  varies: "stale_validator",
  heft: 4,
  about:
    "A conditional request whose validator does not match, answered in full. " +
    "Read against etag.match_large, the difference is the write the 304 " +
    "saved, and read against etag.large it is the comparison that failed.",

  request: (c) => c.get(path).header("if-none-match", stale).okWith(items.large).fresh(),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/etag/small";

export default performanceTest({
  id: { family: "etag", name: "small" },
  path,
  base: "json.small",
  varies: "validators",
  heft: 1,
  about:
    "The framework hashing the body it is about to send and writing the " +
    "validator it computed onto the response. Read against json.small, the " +
    "difference is the hash and the header. The tag is the framework's own, " +
    "so no two of them agree on it.",

  request: (c) => c.get(path).okWith(items.small).hasHeader("etag").fresh(),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/forms/urlencoded";
const FIELDS = ["page", "size", "status", "category", "sort", "q", "minPrice", "maxPrice"] as const;

export default performanceTest({
  id: { family: "forms", name: "urlencoded" },
  path,
  base: "query.many",
  varies: "form",
  heft: 2,
  about:
    "query.many's eight fields posted as an application/x-www-form-urlencoded " +
    "body instead of a query string, bound and echoed. The answer is exactly " +
    "what query.many answers, so the difference between the two is the form " +
    "parser against the query parser.",

  request: (c) => {
    const form = new URLSearchParams(FIELDS.map((name) => [name, String(c.run[name])])).toString();
    return c.post(path).raw(form, "application/x-www-form-urlencoded").okWith(items.small, { echo: FIELDS });
  },
});

import { performanceTest } from "#kit";
import type { RunValues } from "#kit";
import { forms, uploaded } from "#payloads";

const path = "/forms/multipart";
const BOUNDARY = "rb-7c4f1e0a9d";

function part(disposition: string, body: string, type?: string): string {
  const typed = type === undefined ? "" : `Content-Type: ${type}\r\n`;
  return `--${BOUNDARY}\r\nContent-Disposition: form-data; ${disposition}\r\n${typed}\r\n${body}\r\n`;
}

/** Built once per run's values, so the 32 KB concatenation is not inside every instance's timed window. */
const bodies = new WeakMap<RunValues, string>();

function multipart(run: RunValues): string {
  let body = bodies.get(run);
  if (body === undefined) {
    body =
      part('name="tenant"', run.tenant) +
      part('name="requestId"', run.requestId) +
      part(`name="file"; filename="${forms.file.name}"`, forms.file.value, "text/plain") +
      `--${BOUNDARY}--\r\n`;
    bodies.set(run, body);
  }
  return body;
}

export default performanceTest({
  id: { family: "forms", name: "multipart" },
  path,
  base: "forms.urlencoded",
  varies: "multipart",
  heft: 3,
  about:
    "A multipart/form-data upload of two fields and a 32 KB text file. The " +
    "handler echoes the fields and answers the file's name and byte count, so " +
    "it has to have read the whole part. Read against forms.urlencoded, the " +
    "difference is the multipart parser and a body of 32 KB instead of a " +
    "line.",

  request: (c) =>
    c
      .post(path)
      .raw(multipart(c.run), `multipart/form-data; boundary=${BOUNDARY}`)
      .okWith(uploaded, { echo: ["tenant", "requestId"] }),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/headers";

export default performanceTest({
  id: { family: "headers", name: "few" },
  path,
  heft: 1,
  about:
    "Five request headers, none of which the handler reads. Two of the five " +
    "are what an HTTP client adds itself, and the other three are the ones " +
    "the binding rows bind. This is what headers.many is subtracted from.",

  request: (c) =>
    c
      .get(path)
      .header("x-rb-tenant", c.run.tenant)
      .header("x-rb-request-id", c.run.requestId)
      .header("x-rb-account", String(c.run.account))
      .okWith(items.small),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/headers/bind";

export default performanceTest({
  id: { family: "headers", name: "bind_few" },
  path,
  base: "headers.few",
  varies: "header_binding",
  heft: 1,
  about:
    "The same five headers with three of them bound through the framework and " +
    "written back, one as an integer. Read against headers.few, the " +
    "difference is the binding rather than the materialising.",

  request: (c) =>
    c
      .get(path)
      .header("x-rb-tenant", c.run.tenant)
      .header("x-rb-request-id", c.run.requestId)
      .header("x-rb-account", String(c.run.account))
      .okWith(items.small, { echo: ["tenant", "requestId", "account"] }),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";
import { BROWSER_AND_PROXY } from "#models/fixture";

const path = "/headers/bind";

export default performanceTest({
  id: { family: "headers", name: "bind_many" },
  path,
  base: "headers.bind_few",
  varies: "header_count",
  heft: 2,
  about:
    "Three headers bound out of thirty instead of out of five. Read against " +
    "headers.bind_few, the difference is whether a framework's binder pays " +
    "for the headers it was not asked about.",

  request: (c) => {
    let call = c
      .get(path)
      .header("x-rb-tenant", c.run.tenant)
      .header("x-rb-request-id", c.run.requestId)
      .header("x-rb-account", String(c.run.account));

    for (const [name, value] of BROWSER_AND_PROXY) call = call.header(name, value);

    return call.okWith(items.small, { echo: ["tenant", "requestId", "account"] });
  },
});

import { performanceTest } from "#kit";
import { items } from "#payloads";
import { BROWSER_AND_PROXY } from "#models/fixture";

const path = "/headers";

export default performanceTest({
  id: { family: "headers", name: "many" },
  path,
  base: "headers.few",
  varies: "header_count",
  heft: 2,
  about:
    "Thirty request headers, still read by nothing. Read against headers.few, " +
    "the difference is the cost of materialising twenty-five more that nobody " +
    "asked for, which is about a kilobyte and close to what a real request " +
    "carries.",

  request: (c) => {
    let call = c
      .get(path)
      .header("x-rb-tenant", c.run.tenant)
      .header("x-rb-request-id", c.run.requestId)
      .header("x-rb-account", String(c.run.account));

    for (const [name, value] of BROWSER_AND_PROXY) call = call.header(name, value);

    return call.okWith(items.small);
  },
});

import { performanceTest } from "#kit";
import { CREATED, created, items } from "#payloads";

const path = "/items";

/** Relative, or absolute on whatever host the framework thinks it is. */
const LOCATION = new RegExp(`^(https?://[^/]+)?/items/${CREATED}$`);

export default performanceTest({
  id: { family: "items", name: "create" },
  path,
  base: "body.bind_small",
  varies: "creation",
  heft: 2,
  about:
    "A new item posted as JSON and answered 201, with where it would live and " +
    "what it would hold. Nothing is stored, so the answer is always the id " +
    "after the last row. Read against body.bind_small, the difference is a " +
    "body bound to a model and answered as a created resource rather than " +
    "echoed with counts.",

  request: (c) => c.post(path, items.new.value).status(201).bodyIs(created).hasHeader("location", LOCATION),
});

import { performanceTest } from "#kit";
import { items, replaced } from "#payloads";

const path = "/items/{draw.item}";

export default performanceTest({
  id: { family: "items", name: "replace" },
  path,
  base: "items.create",
  varies: "method",
  heft: 2,
  about:
    "A whole item put at an id and answered with the item under that id. Read " +
    "against items.create, the difference is the id coming from the path " +
    "rather than from the server.",

  request: (c) => {
    const id = c.draw.item();
    return c.put(`/items/${id}`, items.new.value).okWith(replaced(id));
  },
});

import { performanceTest } from "#kit";
import { items, patched } from "#payloads";

const path = "/items/{draw.item}";

export default performanceTest({
  id: { family: "items", name: "update" },
  path,
  base: "items.replace",
  varies: "method",
  heft: 2,
  about:
    "Two fields patched onto a row and answered with the row as it would be. " +
    "The handler has to read the row, merge the body into it and serialise " +
    "the result. Read against items.replace, the difference is the merge.",

  request: (c) => {
    const id = c.draw.item();
    return c.patch(`/items/${id}`, items.patch.value).okWith(patched(id));
  },
});

import { performanceTest } from "#kit";
import { row } from "#payloads";

const path = "/items/{draw.item}";

export default performanceTest({
  id: { family: "items", name: "read" },
  path,
  base: "parameters.one",
  varies: "lookup",
  heft: 1,
  about:
    "One row of the large payload, looked up by the id in the path. The id is " +
    "drawn per request, so each instance reads a different row. Read against " +
    "parameters.one, the difference is a lookup and one row serialised in " +
    "place of an echo beside the small payload.",

  request: (c) => {
    const id = c.draw.item();
    return c.get(`/items/${id}`).okWith(row(id));
  },
});

import { performanceTest } from "#kit";

const path = "/items/{draw.item}";

export default performanceTest({
  id: { family: "items", name: "delete" },
  path,
  base: "items.read",
  varies: "method",
  heft: 1,
  about:
    "A row deleted and answered 204 with no body. Nothing is removed, so " +
    "every instance finds the row it names. Read against items.read, the " +
    "difference is that nothing is serialised at all.",

  request: (c) => c.delete(`/items/${c.draw.item()}`).status(204).emptyBody(),
});

import { performanceTest } from "#kit";

const path = "/items/{draw.item}";

export default performanceTest({
  id: { family: "items", name: "head" },
  path,
  base: "items.read",
  varies: "method",
  heft: 1,
  about:
    "The same lookup asked with HEAD, which the framework answers from its GET " +
    "route with no body. Read against items.read, the difference is the body " +
    "left unwritten. Content-Length is not checked, because a framework that " +
    "streams its JSON sends none on the GET either.",

  request: (c) => c.head(`/items/${c.draw.item()}`).ok().hasHeader("content-type", /^application\/json/).emptyBody(),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/json/small";

export default performanceTest({
  id: { family: "json", name: "small" },
  path,
  heft: 1,
  about:
    "One row out, serialised from a body the framework already holds. The " +
    "plainest question in the corpus once something has to be serialised. " +
    "Read against baseline.plaintext, the difference is the codec.",

  request: (c) => c.get(path).okWith(items.small),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/json/large";

export default performanceTest({
  id: { family: "json", name: "large" },
  path,
  base: "json.small",
  varies: "size",
  heft: 4,
  about:
    "Fourteen hundred rows out, serialised from a body the framework already " +
    "holds. The size at which the writer stops being free. Read against " +
    "json.small, the pair is what separates a framework with a fast codec " +
    "from one with a fast request path.",

  request: (c) => c.get(path).okWith(items.large),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/json/medium";

export default performanceTest({
  id: { family: "json", name: "medium" },
  path,
  base: "json.small",
  varies: "size",
  heft: 2,
  about:
    "Eighty-nine rows out, serialised from a body the framework already " +
    "holds. The middle size, where the codec is doing real work and the " +
    "response still fits a single write. Read against json.small rather than " +
    "on its own.",

  request: (c) => c.get(path).okWith(items.medium),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/middleware/none";

export default performanceTest({
  id: { family: "middleware", name: "none" },
  path,
  base: "json.small",
  varies: "route",
  heft: 1,
  about:
    "No layers in front of a handler that serialises the small payload. A " +
    "different route carrying the same handler, which should cost nothing. It " +
    "is the zero point the other two are read against, and a framework where " +
    "this differs from json.small is paying for the route rather than the " +
    "layers.",

  request: (c) => c.get(path).okWith(items.small),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/middleware/four";

export default performanceTest({
  id: { family: "middleware", name: "four" },
  path,
  base: "middleware.none",
  varies: "layers",
  heft: 1,
  about:
    "Four no-op layers in front of a handler that serialises the small " +
    "payload. Four layers in front of the handler, each calling the next and " +
    "doing nothing else. Read against middleware.none, the difference divided " +
    "by four is the framework's per-layer cost.",

  request: (c) => c.get(path).okWith(items.small),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/middleware/sixteen";

export default performanceTest({
  id: { family: "middleware", name: "sixteen" },
  path,
  base: "middleware.none",
  varies: "layers",
  heft: 1,
  about:
    "Sixteen no-op layers in front of a handler that serialises the small " +
    "payload. Sixteen layers, which is where a per-layer cost that looked " +
    "like noise at four becomes readable. Read against middleware.none, and " +
    "against middleware.four to see whether the cost is linear.",

  request: (c) => c.get(path).okWith(items.small),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/parameters/static/segment/literal";

export default performanceTest({
  id: { family: "parameters", name: "static" },
  path,
  base: "json.small",
  varies: "depth",
  heft: 1,
  about:
    "Four static segments and no captures. This holds the route depth " +
    "constant for the two rows that capture, so subtracting it leaves the " +
    "router capturing rather than the router matching a longer path.",

  request: (c) => c.get(path).okWith(items.small),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/parameters/{run.one}/segment/literal";

export default performanceTest({
  id: { family: "parameters", name: "one" },
  path,
  base: "parameters.static",
  varies: "captures",
  heft: 1,
  about:
    "One segment captured, bound as an integer and written back. The value is " +
    "drawn per run, so a framework that answered from a table would have had " +
    "to know it in advance, and the echo is checked against what was sent.",

  request: (c) => c.get(`/parameters/${c.run.one}/segment/literal`).okWith(items.small, { echo: ["one"] }),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/parameters/{run.one}/with-second/{run.two}";

export default performanceTest({
  id: { family: "parameters", name: "two" },
  path,
  base: "parameters.one",
  varies: "captures",
  heft: 1,
  about:
    "The same depth with a second capture in it. Read against parameters.one, " +
    "the difference is one more segment the router has to capture and one " +
    "more value the framework has to convert.",

  request: (c) =>
    c.get(`/parameters/${c.run.one}/with-second/${c.run.two}`).okWith(items.small, { echo: ["one", "two"] }),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/parameters/{run.one}/{run.two}/{run.three}";

export default performanceTest({
  id: { family: "parameters", name: "three" },
  path,
  base: "parameters.two",
  varies: "captures",
  heft: 1,
  about:
    "The same depth with three of its four segments captured, which leaves " +
    "parameters as the only static one. Read against parameters.two, the " +
    "difference is a third segment the router has to capture and a third " +
    "value the framework has to convert.",

  request: (c) =>
    c.get(`/parameters/${c.run.one}/${c.run.two}/${c.run.three}`).okWith(items.small, { echo: ["one", "two", "three"] }),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/query/one?page={run.page}";

export default performanceTest({
  id: { family: "query", name: "one" },
  path,
  base: "json.small",
  varies: "query_params",
  heft: 1,
  about:
    "One query parameter parsed, coerced to an integer and written back. Read " +
    "against json.small, the difference is the query string being parsed at " +
    "all.",

  request: (c) => c.get("/query/one").query("page", String(c.run.page)).okWith(items.small, { echo: ["page"] }),
});

import { performanceTest } from "#kit";
import { items } from "#payloads";

const path = "/query/many?page={run.page}&size={run.size}&status={run.status}&category={run.category}&sort={run.sort}&q={run.q}&minPrice={run.minPrice}&maxPrice={run.maxPrice}";

export default performanceTest({
  id: { family: "query", name: "many" },
  path,
  base: "query.one",
  varies: "query_params",
  heft: 2,
  about:
    "Eight parameters, which is what a real search endpoint carries: a page " +
    "and a size, a sort, a text term and four filters. Read against " +
    "query.one, the difference is seven more keys parsed, coerced and echoed.",

  request: (c) =>
    c
      .get("/query/many")
      .query("page", String(c.run.page))
      .query("size", String(c.run.size))
      .query("status", c.run.status)
      .query("category", c.run.category)
      .query("sort", c.run.sort)
      .query("q", c.run.q)
      .query("minPrice", String(c.run.minPrice))
      .query("maxPrice", String(c.run.maxPrice))
      .okWith(items.small, { echo: ["page", "size", "status", "category", "sort", "q", "minPrice", "maxPrice"] }),
});

import { performanceTest } from "#kit";
import { sse } from "#payloads";

const path = "/sse/medium";

export default performanceTest({
  id: { family: "sse", name: "medium" },
  path,
  base: "stream.ndjson",
  varies: "event_stream",
  heft: 3,
  about:
    "items.medium's 89 rows, each the data of one server-sent event. The request " +
    "carries the Accept header an EventSource sends. Every event is of type " +
    "message with no id, and there is no Content-Length. Read against " +
    "stream.ndjson, the difference is the framework's event framing against a " +
    "line per row.",

  request: (c) =>
    c
      .get(path)
      .header("accept", "text/event-stream")
      .okWith(sse)
      .hasHeader("content-type", /^text\/event-stream/)
      .noHeader("content-length"),
});

import { performanceTest } from "#kit";
import { files } from "#payloads";

const path = "/static/items.large.json";

export default performanceTest({
  id: { family: "static", name: "large" },
  path,
  base: "json.large",
  varies: "static_file",
  heft: 4,
  about:
    "items.large.json sent by the framework's static-file feature from the " +
    "payload directory, with its modification time. The request accepts gzip, " +
    "as a browser's does, and the body is compared byte for byte after " +
    "decoding, so the file may go out as it is or compressed. This is the one " +
    "family where serving the file's bytes is the point. Last-Modified is " +
    "checked rather than an ETag, because Go's file server sends no ETag.",

  request: (c) =>
    c
      .get(path)
      .header("accept-encoding", "gzip")
      .okWith(files.large)
      .hasHeader("content-type", /^application\/json/)
      .hasHeader("last-modified"),
});

import { performanceTest } from "#kit";
import { files } from "#payloads";

const path = "/static/items.medium.json";

export default performanceTest({
  id: { family: "static", name: "medium" },
  path,
  base: "json.medium",
  varies: "static_file",
  heft: 2,
  about:
    "items.medium.json sent by the same static-file feature, with its " +
    "modification time, to a request that accepts gzip. Read against " +
    "json.medium, the difference is the file served against the same 89 rows " +
    "serialised, and against static.small it is the feature's cost per byte.",

  request: (c) =>
    c
      .get(path)
      .header("accept-encoding", "gzip")
      .okWith(files.medium)
      .hasHeader("content-type", /^application\/json/)
      .hasHeader("last-modified"),
});

import { performanceTest } from "#kit";
import { files } from "#payloads";

const path = "/static/items.small.json";

export default performanceTest({
  id: { family: "static", name: "small" },
  path,
  base: "json.small",
  varies: "static_file",
  heft: 1,
  about:
    "items.small.json sent by the same static-file feature, with its " +
    "modification time, to a request that accepts gzip. The file is one row, " +
    "so what is left is the feature's own cost per request: finding the file, " +
    "reading its metadata and writing its headers.",

  request: (c) =>
    c
      .get(path)
      .header("accept-encoding", "gzip")
      .okWith(files.small)
      .hasHeader("content-type", /^application\/json/)
      .hasHeader("last-modified"),
});

import { performanceTest } from "#kit";
import { stream } from "#payloads";

const path = "/stream/items";

export default performanceTest({
  id: { family: "stream", name: "ndjson" },
  path,
  base: "json.medium",
  varies: "streaming",
  heft: 3,
  about:
    "items.medium's 89 rows written one per line as application/x-ndjson. " +
    "There is no Content-Length, which is what shows the body left in parts " +
    "rather than buffered. Read against json.medium, the difference is the " +
    "framework's streaming path and a write per row.",

  request: (c) => c.get(path).okWith(stream).hasHeader("content-type", /^application\/x-ndjson/).noHeader("content-length"),
});

import { performanceTest } from "#kit";
import { pages } from "#payloads";

const path = "/template/large";

export default performanceTest({
  id: { family: "template", name: "large" },
  path,
  base: "json.large",
  varies: "renderer",
  heft: 5,
  about:
    "All 1,425 rows of items.large through the same template. Read against " +
    "template.medium, the difference is the engine's per-row cost at scale, " +
    "and against json.large it is rendering against serialising at one size.",

  request: (c) => c.get(path).okWith(pages.large).hasHeader("content-type", /html/),
});

import { performanceTest } from "#kit";
import { pages } from "#payloads";

const path = "/template/medium";

export default performanceTest({
  id: { family: "template", name: "medium" },
  path,
  base: "json.medium",
  varies: "renderer",
  heft: 3,
  about:
    "Eighty-nine rows through the same template. Read against template.small, " +
    "the difference is the engine's per-row cost, and against json.medium it " +
    "is rendering against serialising at one size.",

  request: (c) => c.get(path).okWith(pages.medium).hasHeader("content-type", /html/),
});

import { performanceTest } from "#kit";
import { pages } from "#payloads";

const path = "/template/small";

export default performanceTest({
  id: { family: "template", name: "small" },
  path,
  base: "json.small",
  varies: "renderer",
  heft: 2,
  about:
    "One row rendered through the framework's own view layer instead of " +
    "serialised. Read against json.small, the difference is the engine, which " +
    "is why this family is comparable across engines and not across " +
    "frameworks.",

  request: (c) => c.get(path).okWith(pages.small).hasHeader("content-type", /html/),
});