Files
reverse-engineering-anything/src/browser/PlaywrightScenarioRequest.test.ts
T
morluto edff877c48 test(web): consolidate request schema validation checks (#13132)
* test(web): consolidate request schema validation checks

* test(web): keep unbound encoded JSON literal coverage
2026-11-21 10:52:55 -05:00

1962 lines
64 KiB
TypeScript

import { EventEmitter } from "node:events";
import type { Page, Route } from "playwright-core";
import { afterEach, describe, expect, it, onTestFinished, vi } from "vitest";
import { browserScenarioSchema } from "../domain/browserScenario.js";
import type { BrowserScenarioAction } from "../domain/browserScenarioValues.js";
import { BrowserScenarioSecrets } from "./BrowserScenarioSecrets.js";
import { scenarioSerializationAllowance } from "./BrowserScenarioSerialization.js";
import { responsePointerValue } from "./BrowserScenarioResponseValues.js";
import { performPlaywrightScenarioAction } from "./PlaywrightScenarioActions.js";
import { phaseArrival } from "../../tests/support/lifecycleHarness.js";
const ORIGIN = "https://app.example.test";
const scenarioInput = (
actions: readonly unknown[],
secrets: unknown[] = [],
) => ({
browser: { mode: "launch", executable_path: "/opt/chromium/chrome" },
start_url: { url: `${ORIGIN}/` },
actions,
storage: { cookies: [], local_storage: [], session_storage: [] },
secrets,
capture: {},
});
const scenario = (actions: readonly unknown[], secrets: unknown[] = []) =>
browserScenarioSchema.parse(scenarioInput(actions, secrets));
const requestStep = (fields: Record<string, unknown>) => ({
step_id: "create",
action: "request",
method: "POST",
path: "/api/folders",
...fields,
});
const issues = (actions: readonly unknown[]) => {
const result = browserScenarioSchema.safeParse(scenarioInput(actions));
return result.success ? [] : result.error.issues;
};
const issueAt = (path: readonly (string | number)[], message?: string) =>
expect.objectContaining({
path,
...(message === undefined
? {}
: { message: expect.stringContaining(message) }),
});
it("rejects invalid request options at their input paths", () => {
const literal = (value: string) => ({ source: "literal", value });
const header = (value: unknown, name = "X-A", prefix?: string) => ({
name,
value,
prefix,
});
const cases = [
[
{ headers: [header(literal("one")), header(literal("two"), "x-a")] },
["headers", 1, "name"],
"more than once",
],
[
{ headers: [header(literal("agent"), "User-Agent")] },
["headers", 0, "name"],
"cannot set",
],
[
{ headers: [header(literal("a\r\nX-B: b"))] },
["headers", 0, "value", "value"],
"line breaks",
],
[
{ headers: [header(literal("a"), "X-A", "Bearer\n")] },
["headers", 0, "prefix"],
"line breaks",
],
[{ expected_status: [200, 303] }, ["expected_status", 1], "3xx"],
[{ method: "GET", json: { a: 1 } }, ["json"], "cannot send a body"],
[{ path: "/\n/[bad]" }, ["path"], undefined],
] as const;
for (const [input, path, message] of cases)
expect(issues([requestStep(input)]), JSON.stringify(input)).toContainEqual(
issueAt(["actions", 0, ...path], message),
);
expect(
issues([
requestStep({
headers: [header({ source: "secret", secret_id: "key" })],
}),
]),
).toContainEqual(issueAt(["secrets"], "not declared"));
});
interface FakeFetch {
readonly url: string;
readonly init: RequestInit;
}
const fakePage = (options: {
readonly url?: string;
/** The origin the page reports when the request is sent, if it moved after the check. */
readonly sendingOrigin?: string;
readonly cookies?: readonly { name: string; value: string }[];
readonly storage?: Record<string, string>;
}) => {
const url = options.url ?? `${ORIGIN}/dashboard`;
vi.stubGlobal("localStorage", {
getItem: (key: string) => options.storage?.[key] ?? null,
});
vi.stubGlobal("location", {
origin: options.sendingOrigin ?? new URL(url).origin,
});
const context = { cookies: async () => options.cookies ?? [] };
return {
on: vi.fn(),
off: vi.fn(),
route: async () => {},
unroute: async () => {},
url: () => url,
context: () => context,
evaluate: async <Arg, Result>(
fn: (arg: Arg) => Result | Promise<Result>,
arg: Arg,
): Promise<Result> => {
// Like Playwright, run the callback from its source text with a cloned
// argument, so it cannot reach this module's imports or closures.
const pageFunction = new Function(
"arg",
`return (${fn.toString()})(arg);`,
) as (arg: Arg) => Result | Promise<Result>;
return await pageFunction(structuredClone(arg));
},
} as unknown as Page;
};
const stubFetch = (status: number, bodies: readonly string[] = []) => {
const calls: FakeFetch[] = [];
vi.stubGlobal("fetch", async (url: string, init: RequestInit) => {
calls.push({ url, init });
return new Response(bodies[calls.length - 1] ?? "{}", { status });
});
return calls;
};
const perform = async (
page: Page,
action: BrowserScenarioAction,
secrets: BrowserScenarioSecrets,
signal?: AbortSignal,
) =>
performPlaywrightScenarioAction({
page,
action,
secrets,
startOrigin: ORIGIN,
signal,
});
const resolved = (parsed: ReturnType<typeof scenario>, environment = {}) => {
const secrets = BrowserScenarioSecrets.resolve(parsed, environment);
if (!secrets.ok) throw secrets.error;
return secrets.value;
};
describe("request step execution", () => {
afterEach(() => {
vi.unstubAllGlobals();
});
it("sends requests with same-origin credentials", async () => {
const calls = stubFetch(200);
const parsed = scenario([requestStep({})]);
await perform(fakePage({}), parsed.actions[0]!, resolved(parsed));
expect(calls).toHaveLength(1);
expect(calls[0]!.init.credentials).toBe("same-origin");
});
it("refuses to run off the start origin, and fails on an unexpected status or a missing cookie", async () => {
stubFetch(403);
const parsed = scenario([requestStep({ expected_status: [200, 201] })]);
const action = parsed.actions[0]!;
await expect(
perform(
fakePage({ url: "https://other.test/" }),
action,
resolved(parsed),
),
).rejects.toThrow("start origin");
await expect(
perform(fakePage({}), action, resolved(parsed)),
).rejects.toThrow("answered 403; expected 200 or 201");
const withCookie = scenario([
requestStep({
headers: [{ name: "X-T", value: { source: "cookie", name: "absent" } }],
}),
]);
await expect(
perform(fakePage({}), withCookie.actions[0]!, resolved(withCookie)),
).rejects.toThrow("cookie absent is not set");
});
it("completes on any status when none is expected and reports fetch errors", async () => {
stubFetch(500);
const parsed = scenario([requestStep({})]);
await expect(
perform(fakePage({}), parsed.actions[0]!, resolved(parsed)),
).resolves.toBeUndefined();
vi.stubGlobal("fetch", async () => {
throw new TypeError("Failed to fetch");
});
await expect(
perform(fakePage({}), parsed.actions[0]!, resolved(parsed)),
).rejects.toThrow("Failed to fetch");
});
});
const useRequestClock = () => {
vi.useFakeTimers();
onTestFinished(() => void vi.useRealTimers());
};
describe("request dispatch boundary", () => {
afterEach(() => {
vi.unstubAllGlobals();
});
it("sends nothing when browser evaluation starts after the absolute deadline", async () => {
useRequestClock();
const calls = stubFetch(200);
const page = fakePage({});
const evaluate = page.evaluate.bind(page);
vi.spyOn(page, "evaluate").mockImplementation((fn, arg) => {
// Advance the page clock at evaluation without expiring the host's monotonic clock.
vi.setSystemTime(Date.now() + 20);
return evaluate(fn, arg);
});
const parsed = scenario([requestStep({ timeout_ms: 20 })]);
await expect(
perform(page, parsed.actions[0]!, resolved(parsed)),
).rejects.toThrow("The request ran out of time before it was sent");
expect(calls).toEqual([]);
});
it("aborts a dispatched fetch when the remaining budget expires", async () => {
useRequestClock();
const dispatched = phaseArrival<AbortSignal>();
vi.stubGlobal(
"fetch",
async (_url: string, init: RequestInit) =>
new Promise<Response>((_resolve, reject) => {
const signal = init.signal!;
signal.addEventListener("abort", () => reject(signal.reason), {
once: true,
});
dispatched.arrive(signal);
}),
);
const parsed = scenario([requestStep({ timeout_ms: 20 })]);
const result = perform(
fakePage({}),
parsed.actions[0]!,
resolved(parsed),
).catch((cause: unknown) => cause);
const signal = await dispatched.reached(result, "page fetch");
await vi.advanceTimersByTimeAsync(19);
expect(signal.aborted).toBe(false);
await vi.advanceTimersByTimeAsync(1);
expect(signal.reason).toMatchObject({ name: "TimeoutError" });
expect(await result).toMatchObject({
message: expect.stringContaining("The request ran out of time."),
});
});
it("guards dispatch after cancellation while evaluation was queued, and removes its route", async () => {
const parsed = scenario([requestStep({})]);
const controller = new AbortController();
const page = fakePage({});
let gate: ((route: Route) => Promise<void>) | undefined;
vi.spyOn(page, "route").mockImplementation(async (_match, handler) => {
gate = handler as typeof gate;
return {
dispose: async () => undefined,
[Symbol.asyncDispose]: async () => undefined,
};
});
const unroute = vi.spyOn(page, "unroute");
const sent = vi.fn();
vi.spyOn(page, "evaluate").mockImplementation(async (fn, arg) => {
controller.abort("abandoned while queued");
return (fn as (arg: unknown) => unknown)(arg);
});
vi.stubGlobal("fetch", async (_url: string, init: RequestInit) => {
if (gate === undefined) throw new Error("Missing dispatch owner");
await gate({
request: () => ({
method: () => init.method,
postData: () => init.body ?? null,
}),
fallback: sent,
abort: async () => {
throw new Error("aborted at dispatch");
},
} as unknown as Route);
return new Response("{}", { status: 200 });
});
await expect(
performPlaywrightScenarioAction({
page,
action: parsed.actions[0]!,
secrets: resolved(parsed),
startOrigin: ORIGIN,
signal: controller.signal,
}),
).rejects.toThrow("aborted at dispatch");
expect(sent).not.toHaveBeenCalled();
expect(unroute).toHaveBeenCalledOnce();
});
});
describe("request route cleanup", () => {
afterEach(() => {
vi.unstubAllGlobals();
});
it.each([
[200, "evaluation"],
[503, "cleanup"],
[200, "cleanup"],
[200, "cancellation"],
[503, "cancellation"],
[200, "deadline"],
[503, "deadline"],
[200, "complete"],
] as const)(
"settles response publication for status %i at %s",
async (status, end) => {
const evaluationFails = end === "evaluation";
const cleanupFails = evaluationFails || end === "cleanup";
const events = new EventEmitter();
const page = Object.assign(fakePage({}), {
on: events.on.bind(events),
off: events.off.bind(events),
});
const sent = {
url: () => `${ORIGIN}/api/folders`,
method: () => "POST",
postData: () => null,
};
const parsed = scenario([
requestStep({
expected_status: [200],
timeout_ms: 5_000,
save: [{ name: "id", json_pointer: "/id", secret: true }],
}),
]);
const secrets = resolved(parsed);
const savedValue = "scenario-saved-id";
vi.stubGlobal("fetch", async () => {
events.emit("request", sent);
return new Response(JSON.stringify({ id: savedValue }), { status });
});
const primary = new Error("page.evaluate: Target page has been closed");
const cleanup = new Error("page.unroute: Target page has been closed");
const cancel = new AbortController();
const began = performance.now();
if (evaluationFails)
vi.spyOn(page, "evaluate").mockRejectedValue(primary);
const unroute = vi.spyOn(page, "unroute").mockImplementation(async () => {
if (cleanupFails) throw cleanup;
if (end === "cancellation")
cancel.abort("cancelled during final route cleanup");
if (end === "deadline") {
const now = vi
.spyOn(performance, "now")
.mockReturnValue(began + 6_000);
onTestFinished(() => now.mockRestore());
}
});
const failure = await perform(
page,
parsed.actions[0]!,
secrets,
cancel.signal,
).catch((cause: unknown) => cause);
expect(unroute).toHaveBeenCalledOnce();
expect(events.listenerCount("request")).toBe(0);
expect(secrets.hasResponseProtection(sent)).toBe(
evaluationFails !== true,
);
if (end === "complete") {
expect(failure).toBeUndefined();
cancel.abort("cancelled after publication");
expect(secrets.savedValue("id")).toBe(savedValue);
expect(secrets.responseSecretsReady(sent)).toBe(true);
return;
}
expect(() => secrets.savedValue("id")).toThrow("No earlier step saved");
expect(secrets.responseSecretsReady(sent)).toBe(false);
if (cleanupFails && (evaluationFails || status === 503)) {
if (!(failure instanceof AggregateError))
throw new Error("Expected request and cleanup errors");
expect(failure.errors).toHaveLength(2);
expect(failure.errors[1]).toBe(cleanup);
if (evaluationFails) expect(failure.cause).toBe(primary);
else expect(failure.errors[0].message).toContain("answered 503");
expect(failure.cause).toBe(failure.errors[0]);
} else if (cleanupFails) {
expect(failure).toBe(cleanup);
} else {
expect(failure).toMatchObject({
message: expect.stringContaining(
status === 503 ? "answered 503" : "ended before",
),
});
}
},
);
});
describe("request page boundaries", () => {
afterEach(() => {
vi.unstubAllGlobals();
});
it("refuses foreign-origin storage before reading its value", async () => {
const calls = stubFetch(200);
const read = vi.fn();
const parsed = scenario([
requestStep({
headers: [
{
name: "Authorization",
value: { source: "local_storage", key: "token" },
},
],
}),
]);
const page = fakePage({ sendingOrigin: "https://other.test" });
vi.stubGlobal("localStorage", { getItem: read });
await expect(
perform(page, parsed.actions[0]!, resolved(parsed)),
).rejects.toThrow("local storage");
expect(read).not.toHaveBeenCalled();
expect(calls).toEqual([]);
});
it.each([
{ label: "discarded response", chunks: 8, save: [] },
{
label: "oversized saved response",
chunks: 3_000_000,
save: [{ name: "folder", json_pointer: "/id" }],
},
])(
"bounds response retention and releases the reader for a $label",
async ({ chunks, save }) => {
const packet = { done: false, value: new Uint8Array(chunks).fill(97) };
const read = vi
.fn()
.mockResolvedValueOnce(packet)
.mockResolvedValueOnce(packet)
.mockResolvedValue({ done: true });
const cancel = vi.fn();
const releaseLock = vi.fn();
const arrayBuffer = vi.fn();
vi.stubGlobal("fetch", async () => ({
status: 200,
type: "basic",
body: { getReader: () => ({ read, cancel, releaseLock }) },
arrayBuffer,
}));
const parsed = scenario([requestStep({ save })]);
const request = perform(
fakePage({}),
parsed.actions[0]!,
resolved(parsed),
);
if (save.length > 0) {
await expect(request).rejects.toThrow("too large to save values from");
expect(read).toHaveBeenCalledTimes(2);
expect(cancel).toHaveBeenCalledOnce();
} else {
await request;
expect(read).toHaveBeenCalledTimes(3);
expect(cancel).not.toHaveBeenCalled();
}
expect(releaseLock).toHaveBeenCalledOnce();
expect(arrayBuffer).not.toHaveBeenCalled();
},
);
});
describe("request step confinement", () => {
afterEach(() => {
vi.unstubAllGlobals();
});
it("follows no redirect and sends nothing once the page has left the start origin", async () => {
const calls: FakeFetch[] = [];
vi.stubGlobal("fetch", async (url: string, init: RequestInit) => {
calls.push({ url, init });
return {
type: "opaqueredirect",
status: 0,
arrayBuffer: async () => new ArrayBuffer(0),
};
});
const parsed = scenario([requestStep({})]);
const onOpaqueRedirect = vi.fn();
await expect(
performPlaywrightScenarioAction({
page: fakePage({}),
action: parsed.actions[0]!,
secrets: resolved(parsed),
startOrigin: ORIGIN,
onOpaqueRedirect,
}),
).rejects.toThrow("request steps do not follow");
expect(onOpaqueRedirect).toHaveBeenCalledOnce();
expect(calls[0]!.init.redirect).toBe("manual");
await expect(
perform(
fakePage({ sendingOrigin: "https://other.test" }),
parsed.actions[0]!,
resolved(parsed),
),
).rejects.toThrow("the page moved");
expect(calls).toHaveLength(1);
});
it.each(["deadline", "cancellation"])(
"installs no dispatch route after %s during header reads",
async (end) => {
useRequestClock();
const cancel = new AbortController();
const page = fakePage({
cookies: [{ name: "t", value: "token-value-1" }],
});
const context = page.context();
const readCookies = context.cookies.bind(context);
vi.spyOn(context, "cookies").mockImplementation(async (urls) => {
if (end === "deadline") await vi.advanceTimersByTimeAsync(20);
else cancel.abort("cancelled during header read");
return readCookies(urls);
});
const route = vi.spyOn(page, "route");
const calls = stubFetch(200);
const parsed = scenario([
requestStep({
timeout_ms: 20,
headers: [{ name: "X-T", value: { source: "cookie", name: "t" } }],
}),
]);
const failure = await perform(
page,
parsed.actions[0]!,
resolved(parsed),
cancel.signal,
).catch((cause: unknown) => cause);
expect(route).not.toHaveBeenCalled();
expect(failure).toMatchObject({
message: expect.stringContaining(
"ran out of time before its request was sent",
),
});
expect(calls).toEqual([]);
},
);
it("appends query entries after the path's literal query without re-encoding it", async () => {
const calls = stubFetch(200);
const parsed = scenario([
requestStep({
path: "/api/items?flag&a=b%20c&s=x;y",
query: [
{ name: "q", value: { source: "literal", value: "a b私😀!~'" } },
],
}),
]);
await perform(fakePage({}), parsed.actions[0]!, resolved(parsed));
expect(calls[0]!.url).toBe(
`${ORIGIN}/api/items?flag&a=b%20c&s=x;y&q=a%20b%E7%A7%81%F0%9F%98%80!~'`,
);
for (const [path, sent] of [
["/api/items?", "/api/items?q=1"],
["/api/items#", "/api/items?q=1"],
["/api/items?a=1&", "/api/items?a=1&q=1"],
["/api/items?a=1#top", "/api/items?a=1&q=1"],
] as const) {
const edge = scenario([
requestStep({
path,
query: [{ name: "q", value: { source: "literal", value: "1" } }],
}),
]);
await perform(fakePage({}), edge.actions[0]!, resolved(edge));
expect(calls.at(-1)!.url, path).toBe(`${ORIGIN}${sent}`);
}
});
});
describe("request page value admission", () => {
afterEach(() => {
vi.unstubAllGlobals();
});
it("preserves exact local storage pointer values and refuses lossy numbers before dispatch", async () => {
const calls = stubFetch(200);
const parsed = scenario([
requestStep({
headers: [
{
name: "X-Account",
value: {
source: "local_storage",
key: "auth",
json_pointer: "/id",
},
},
],
}),
]);
for (const literal of ["9007199254740993", "1e400", "-0"]) {
await expect(
perform(
fakePage({ storage: { auth: `{"id":${literal}}` } }),
parsed.actions[0]!,
resolved(parsed),
),
).rejects.toThrow("cannot be read exactly");
}
expect(calls).toEqual([]);
for (const [literal, expected] of [
["9007199254740991", "9007199254740991"],
['"9007199254740993"', "9007199254740993"],
["42", "42"],
]) {
await perform(
fakePage({
storage: { auth: `{"id":${literal},"unselected":9007199254740993}` },
}),
parsed.actions[0]!,
resolved(parsed),
);
expect(calls.at(-1)!.init.headers).toEqual([["X-Account", expected]]);
}
});
it("refuses page values a header cannot carry, and stored values it cannot read", async () => {
const calls = stubFetch(200);
const header = (value: Record<string, unknown>) =>
scenario([requestStep({ headers: [{ name: "X-T", value }] })]);
const cookie = header({ source: "cookie", name: "t" });
await expect(
perform(
fakePage({ cookies: [{ name: "t", value: "a\r\nX-B: b" }] }),
cookie.actions[0]!,
resolved(cookie),
),
).rejects.toThrow("cannot carry");
for (const [storage, pointer, message] of [
[{}, undefined, "local storage has no auth"],
[{ auth: "not json" }, "/token", "is not JSON"],
[{ auth: '{"other":1}' }, "/token", "no string or number at /token"],
] as const) {
const stored = header({
source: "local_storage",
key: "auth",
...(pointer === undefined ? {} : { json_pointer: pointer }),
});
await expect(
perform(fakePage({ storage }), stored.actions[0]!, resolved(stored)),
).rejects.toThrow(message);
}
expect(calls).toEqual([]);
});
});
describe("page value redaction", () => {
const secrets = () => resolved(scenario([requestStep({})]));
it("keeps the first marker and masks new spellings under the same label", () => {
const held = secrets();
const label = "write.X-Token";
const first = "first-token-AAAA";
const second = "second-token-BBBB";
held.admitPageValue(label, first);
held.admitPageValue("retry.X-Token", first);
held.admitPageValue(label, ` ${second}\t`);
expect(held.redact(first)).toBe("[REDACTED:page:write.X-Token]");
const redacted = held.redact(`X-Token: ${second}\t as sent: ${second}`);
expect(redacted).not.toContain(second);
});
it("redacts values at the page-value threshold without removing shorter identifiers", () => {
const held = secrets();
held.admitPageValue("s.X-Org-Id", "1");
held.admitPageValue("s.X-Port", "3000");
held.admitPageValue("s.X-Short-Id", "seven77");
held.admitPageValue("s.X-Boundary", "eight888");
const ordinary = "http://127.0.0.1:3000/api/items/seven77?page=1";
expect(held.redact(`${ordinary} eight888`)).toBe(
`${ordinary} [REDACTED:page:s.X-Boundary]`,
);
});
});
const savedValue = (name: string) => ({ source: "saved", name });
const clickSavingItem = (name: string) => ({
step_id: "save-item",
action: "click",
locator: { kind: "role", role: "button", name: "Save" },
save_response: {
method: "POST",
path: "/api/items",
save: [{ name, json_pointer: "/id" }],
},
});
const gotoStep = (url: string) => ({
step_id: "open",
action: "goto",
destination: { url },
wait_until: "load",
});
describe("scenario value validation", () => {
it("requires a prior binding wherever steps use saved values", () => {
const sendsItem = requestStep({ path: "/api/items/{saved:item}" });
expect(issues([clickSavingItem("item"), sendsItem])).toEqual([]);
expect(
issues([
gotoStep(`${ORIGIN}/search/{q}`),
requestStep({ path: "/api/items/{id}", json: { name: "{draft}" } }),
]),
).toEqual([]);
for (const step of [
gotoStep(`${ORIGIN}/items/{saved:item}`),
gotoStep(`${ORIGIN}/items/%7Bsaved%3Aitem%7D`),
requestStep({ path: "/api/items?parent={saved:item}" }),
requestStep({ json: { list: [{ parent: "{saved:item}" }] } }),
requestStep({ json: { note: "Copied from {saved:item}" } }),
requestStep({ headers: [{ name: "X-Item", value: savedValue("item") }] }),
requestStep({
headers: [
{
name: "Authorization",
value: {
source: "basic_credentials",
parts: [savedValue("item"), { source: "literal", value: "" }],
},
},
],
}),
])
expect(issues([step]), JSON.stringify(step)).toContainEqual(
issueAt(["actions", 0], "sends saved value item"),
);
});
it("validates Basic credential arity, references and password privacy", () => {
const basic = (parts: readonly unknown[]) =>
requestStep({
headers: [
{
name: "Authorization",
value: { source: "basic_credentials", parts },
},
],
});
const username = { source: "literal", value: "admin" };
const parts = ["actions", 0, "headers", 0, "value", "parts"];
expect(
issues([basic([username, { source: "literal", value: "private" }])]),
).toContainEqual(issueAt([...parts, 1], "not a literal"));
expect(
issues([basic([username, { source: "literal", value: "" }])]),
).toEqual([]);
expect(
issues([basic([username, { source: "secret", secret_id: "password" }])]),
).toContainEqual(issueAt(["secrets"], "not declared"));
expect(issues([basic([username])])).toContainEqual(issueAt(parts));
});
it("requires a UI save response to select a same-origin path and at least one value", () => {
const action = clickSavingItem("item");
for (const path of ["//other.test/api", "api/items", "https://other.test/"])
expect(
issues([
{ ...action, save_response: { ...action.save_response, path } },
]),
path,
).toContainEqual(issueAt(["actions", 0, "save_response", "path"]));
expect(
issues([
{ ...action, save_response: { ...action.save_response, save: [] } },
]),
).toContainEqual(issueAt(["actions", 0, "save_response", "save"]));
});
});
describe("saved value execution", () => {
afterEach(() => {
vi.unstubAllGlobals();
});
it("sends saved ids in the path and body with their saved type, and a saved secret only redacted", async () => {
const calls = stubFetch(200, [
'{"id":42,"session":{"token":"session-token-9f3e"}}',
]);
const parsed = scenario([
requestStep({
json: { title: "Scratch folder 1" },
save: [
{ name: "folder", json_pointer: "/id" },
{ name: "token", json_pointer: "/session/token", secret: true },
],
}),
requestStep({
step_id: "move",
method: "PUT",
path: "/api/folders/{saved:folder}",
json: {
title: "Moved",
parent: "{saved:folder}",
note: "Moved into {saved:folder}",
},
headers: [
{
name: "Authorization",
value: { source: "saved", name: "token" },
prefix: "Bearer ",
},
],
}),
]);
const secrets = resolved(parsed);
const page = fakePage({});
for (const action of parsed.actions) await perform(page, action, secrets);
expect(calls[1]).toEqual({
url: `${ORIGIN}/api/folders/42`,
init: expect.objectContaining({
method: "PUT",
headers: [
["Authorization", "Bearer session-token-9f3e"],
["content-type", "application/json"],
],
body: '{"title":"Moved","parent":42,"note":"Moved into 42"}',
}),
});
expect(secrets.redact("folder 42 with session-token-9f3e")).toBe(
"folder 42 with [REDACTED:page:create.token]",
);
});
});
describe("saved value credentials and limits", () => {
afterEach(() => {
vi.unstubAllGlobals();
});
it("sends percent-encoded JSON text unchanged without requiring its named binding", async () => {
const calls = stubFetch(200, ['{"id":7}']);
const parsed = scenario([
requestStep({ save: [{ name: "item", json_pointer: "/id" }] }),
requestStep({
step_id: "note",
json: { note: "%7Bsaved:unbound%7D", id: "{saved:item}" },
}),
]);
const secrets = resolved(parsed);
for (const action of parsed.actions)
await perform(fakePage({}), action, secrets);
expect(calls[1]!.init.body).toBe('{"note":"%7Bsaved:unbound%7D","id":7}');
});
it("fails a step whose response holds no value to save", async () => {
stubFetch(200, ['{"items":[]}', "not json"]);
const parsed = scenario([
requestStep({ save: [{ name: "folder", json_pointer: "/id" }] }),
]);
const secrets = resolved(parsed);
await expect(
perform(fakePage({}), parsed.actions[0]!, secrets),
).rejects.toThrow("no string or number at /id to save as folder");
await expect(
perform(fakePage({}), parsed.actions[0]!, secrets),
).rejects.toThrow("is not JSON");
expect(() => secrets.savedValue("folder")).toThrow();
});
it.each([
{ source: "declared secrets", username: "a", password: "b" },
{
source: "page storage",
username: "operator-7",
password: "cookie-key-5d1c",
},
])(
"sends Basic credentials from $source and masks the source values and the encoded header",
async ({ source, username, password }) => {
const declared = source === "declared secrets";
const calls = stubFetch(200, ['{"pin":"x7"}']);
const name = declared ? "X-Auth" : "Authorization";
const prefix = declared ? "" : "Basic ";
const parsed = scenario(
[
requestStep({
headers: [
{
name,
prefix,
value: {
source: "basic_credentials",
parts: declared
? [
{ source: "secret", secret_id: "user" },
{ source: "secret", secret_id: "password" },
]
: [
{
source: "local_storage",
key: "user",
json_pointer: "/name",
},
{ source: "cookie", name: "api_key" },
],
},
},
],
save: [{ name: "pin", json_pointer: "/pin", secret: true }],
}),
],
declared
? [
{ secret_id: "user", environment_variable: "APP_USER" },
{ secret_id: "password", environment_variable: "APP_PASSWORD" },
]
: [],
);
const secrets = resolved(
parsed,
declared ? { APP_USER: username, APP_PASSWORD: password } : {},
);
const page = fakePage(
declared
? {}
: {
cookies: [{ name: "api_key", value: password }],
storage: { user: JSON.stringify({ name: username }) },
},
);
await perform(page, parsed.actions[0]!, secrets);
const encoded = Buffer.from(`${username}:${password}`).toString("base64");
expect(calls[0]!.init.headers).toEqual([[name, prefix + encoded]]);
expect(secrets.savedValue("pin")).toBe("x7");
for (const value of [encoded, username, password, "x7"])
expect(secrets.redact(value)).toMatch(/^\[REDACTED(?::.+)?\]$/u);
},
);
});
describe("saved response JSON pointers", () => {
afterEach(() => {
vi.unstubAllGlobals();
});
it("selects the root and decodes escaped response keys once", () => {
const value = { "a/b": { "~1": "literal", "/": "slash" } };
expect(responsePointerValue(value, "")).toBe(value);
expect(responsePointerValue(value, "/a~1b/~01")).toBe("literal");
});
it("does not coerce a terminal newline in an array index", () => {
expect(responsePointerValue({ items: ["record-7"] }, "/items/0\n")).toBe(
undefined,
);
});
it.each(["length", "01", "-"])(
"refuses the non-index array token %s",
async (token) => {
stubFetch(201, ['{"items":["record-7","record-8"]}']);
const parsed = scenario([
requestStep({
save: [{ name: "item", json_pointer: `/items/${token}` }],
}),
]);
const secrets = resolved(parsed);
await expect(
perform(fakePage({}), parsed.actions[0]!, secrets),
).rejects.toThrow("has no string or number");
expect(() => secrets.savedValue("item")).toThrow("No earlier step saved");
},
);
it.each([
["/items/0", "record-7"],
["/length", 12],
["/01", "object-key"],
["/a~1b/~0key", "escaped-key"],
])("preserves JSON member identity at %s", async (pointer, expected) => {
stubFetch(201, [
'{"items":["record-7"],"length":12,"01":"object-key","a/b":{"~key":"escaped-key"}}',
]);
const parsed = scenario([
requestStep({ save: [{ name: "item", json_pointer: pointer }] }),
]);
const secrets = resolved(parsed);
await perform(fakePage({}), parsed.actions[0]!, secrets);
expect(secrets.savedValue("item")).toBe(expected);
});
});
describe("saved response number identity", () => {
afterEach(() => vi.unstubAllGlobals());
it.each([
["0", 0],
["0.0", 0],
["1.5", 1.5],
["12.50", 12.5],
["1E2", 100],
["0.1", 0.1],
['"record-7"', "record-7"],
["-0", undefined, "cannot be saved exactly"],
["1e-400", undefined, "cannot be saved exactly"],
["-1e-400", undefined, "cannot be saved exactly"],
["1.0000000000000000001", undefined, "cannot be saved exactly"],
["9007199254740993", undefined, "cannot be saved exactly"],
["1e400", undefined, "not finite"],
["-1e400", undefined, "not finite"],
] as const)(
"preserves saved response value identity for %s",
async (token, kept, refusal?: string) => {
stubFetch(201, [
`{"id":${token},"companion":"stable","unselected":1e-400}`,
]);
const parsed = scenario([
requestStep({
save: [
{ name: "companion", json_pointer: "/companion" },
{ name: "item", json_pointer: "/id" },
],
}),
]);
const secrets = resolved(parsed);
const attempt = perform(fakePage({}), parsed.actions[0]!, secrets);
if (refusal === undefined) {
await attempt;
expect(secrets.savedValue("item")).toBe(kept);
expect(secrets.savedValue("companion")).toBe("stable");
} else {
await expect(attempt).rejects.toThrow(refusal);
expect(() => secrets.savedValue("item")).toThrow(
"No earlier step saved item",
);
expect(() => secrets.savedValue("companion")).toThrow(
"No earlier step saved companion",
);
}
},
);
});
describe("values a URL path or Basic header cannot carry", () => {
afterEach(() => {
vi.unstubAllGlobals();
});
it("fails a Basic header whose username holds a colon, before sending it", async () => {
const calls = stubFetch(200, ["{}"]);
const parsed = scenario(
[
requestStep({
headers: [
{
name: "Authorization",
value: {
source: "basic_credentials",
parts: [
{ source: "secret", secret_id: "user" },
{ source: "secret", secret_id: "password" },
],
},
},
],
}),
],
[
{ secret_id: "user", environment_variable: "APP_USER" },
{ secret_id: "password", environment_variable: "APP_PASSWORD" },
],
);
const secrets = resolved(parsed, {
APP_USER: "ops:admin",
APP_PASSWORD: "b",
});
await expect(
perform(fakePage({}), parsed.actions[0]!, secrets),
).rejects.toThrow("Basic username with a colon");
expect(calls).toHaveLength(0);
});
it.each([
["/items/{saved:item}/edit", "."],
["/items/{saved:item}/edit", ".."],
["/items/{saved:item}.", "."],
["/items/%2e{saved:item}", "."],
["/safe\\{saved:item}.", "."],
["/safe\\%2e{saved:item}", "."],
])(
"rejects %s with saved %s before navigation or request dispatch",
async (path, saved) => {
const parsed = scenario([
requestStep({ save: [{ name: "item", json_pointer: "/id" }] }),
{
step_id: "open",
action: "goto",
destination: { url: ORIGIN + path },
wait_until: "load",
},
requestStep({ step_id: "edit", path }),
]);
const secrets = resolved(parsed);
secrets.save("create.item", "item", saved, false);
const goto = vi.fn();
const evaluate = vi.fn();
const page = { ...fakePage({}), goto, evaluate } as unknown as Page;
for (const action of parsed.actions.slice(1))
await expect(perform(page, action, secrets)).rejects.toThrow(
"dot segment",
);
expect(goto).not.toHaveBeenCalled();
expect(evaluate).not.toHaveBeenCalled();
},
);
it("sends dots that are part of a segment or of the query", async () => {
const parsed = scenario([
requestStep({ save: [{ name: "item", json_pointer: "/id" }] }),
{
step_id: "open",
action: "goto",
destination: { url: `${ORIGIN}/items/v{saved:item}?at={saved:item}` },
wait_until: "load",
},
]);
const secrets = resolved(parsed);
secrets.save("create.item", "item", "..", false);
const goto = vi.fn(async () => null);
await perform({ goto } as unknown as Page, parsed.actions[1]!, secrets);
expect(goto).toHaveBeenCalledWith(
`${ORIGIN}/items/v..?at=..`,
expect.anything(),
);
});
});
describe("bounded derived credentials", () => {
it("refuses over-budget Unicode spellings before building encoded copies", () => {
const secrets = resolved(scenario([requestStep({})]));
const encode = vi.spyOn(globalThis, "encodeURIComponent");
try {
expect(() =>
secrets.save("create.token", "token", "私".repeat(1_000_000), true),
).toThrow("more than 4000000 characters");
expect(encode).not.toHaveBeenCalled();
expect(() => secrets.savedValue("token")).toThrow(
"No earlier step saved",
);
} finally {
encode.mockRestore();
}
});
it("charges distinct Basic credentials while admitting repeated identical spellings once", () => {
const secrets = resolved(scenario([requestStep({})]));
const password = "x".repeat(300_000);
secrets.save("create.token", "token", password, false);
const first = secrets.basicCredential("login.auth", "operator-0", password);
for (let index = 0; index < 8; index++)
expect(
secrets.basicCredential("again.auth", "operator-0", password),
).toBe(first);
expect(() => {
for (let index = 1; index < 16; index++)
secrets.basicCredential(
`s${String(index)}.auth`,
`operator-${String(index)}`,
password,
);
}).toThrow("more than 4000000 characters");
expect(secrets.savedValue("token")).toBe(password);
expect(secrets.redact(first)).not.toContain(first);
});
it("refuses excessive base64 expansion before allocating the credential buffer", () => {
const secrets = resolved(scenario([requestStep({})]));
const allocate = vi.spyOn(Buffer, "allocUnsafe");
try {
expect(() =>
secrets.basicCredential("login.auth", "u", "x".repeat(3_000_001)),
).toThrow("encoded form exceeds");
expect(allocate).not.toHaveBeenCalled();
} finally {
allocate.mockRestore();
}
});
});
describe("saved value retention", () => {
afterEach(() => {
vi.unstubAllGlobals();
});
it("charges repeated identical secret saves only for retained values", () => {
const secrets = resolved(scenario([requestStep({})]));
const token = "s".repeat(1_000_000);
for (let index = 0; index < 8; index++)
secrets.save(`step${String(index)}.token`, "token", token, true);
expect(secrets.savedValue("token")).toBe(token);
expect(secrets.redact(token)).not.toContain(token);
});
it.each([
{ label: "an ordinary value", length: 2_500_000, padding: "", fill: 0 },
{ label: "a padded value", length: 198, padding: " ", fill: 3_999_000 },
])(
"charges secret spellings for $label before replacing a saved value",
({ length, padding, fill }) => {
const secrets = resolved(scenario([requestStep({})]));
const filler = "x".repeat(fill);
const token = "t".repeat(length);
const value = `${padding}${token}${padding}`;
secrets.save("seed.fill", "fill", filler, false);
secrets.save("sample.token", "token", value, false);
expect(secrets.savedValue("token")).toBe(value);
secrets.save("keep.token", "token", "previous", false);
expect(() => secrets.save("new.token", "token", value, true)).toThrow(
"more than 4000000 characters of saved values",
);
expect(secrets.savedValue("token")).toBe("previous");
expect(secrets.savedValue("fill")).toBe(filler);
expect(secrets.redact(value)).toBe(value);
expect(secrets.redact(token)).toBe(token);
},
);
it("rejects a new binding at capacity and can save it after replacing an older value", async () => {
const item = "y".repeat(200_000);
const body = JSON.stringify({ id: item });
stubFetch(201, [body, body]);
const parsed = scenario([
requestStep({ save: [{ name: "item", json_pointer: "/id" }] }),
]);
const secrets = resolved(parsed);
const original = "x".repeat(3_900_000);
secrets.save("seed.big", "big", original, false);
const page = fakePage({});
await expect(perform(page, parsed.actions[0]!, secrets)).rejects.toThrow(
"Step create: item cannot be saved: the scenario would keep more than",
);
expect(() => secrets.savedValue("item")).toThrow("No earlier step saved");
expect(secrets.savedValue("big")).toBe(original);
const replacement = "z".repeat(3_500_000);
secrets.save("replace.big", "big", replacement, false);
await perform(page, parsed.actions[0]!, secrets);
expect(secrets.savedValue("big")).toBe(replacement);
expect(secrets.savedValue("item")).toBe(item);
});
});
describe("goto placeholders", () => {
it("fills a goto destination's placeholders, percent-encoded", async () => {
const parsed = scenario([
requestStep({ save: [{ name: "item", json_pointer: "/id" }] }),
{
step_id: "open",
action: "goto",
destination: { url: `${ORIGIN}/items/{saved:item}/edit` },
wait_until: "load",
},
]);
const secrets = resolved(parsed);
secrets.save("create.item", "item", "a b/c", false);
const goto = vi.fn(async () => null);
await perform({ goto } as unknown as Page, parsed.actions[1]!, secrets);
expect(goto).toHaveBeenCalledWith(
`${ORIGIN}/items/a%20b%2Fc/edit`,
expect.anything(),
);
});
it("keeps a structured query value that spells a placeholder as written", async () => {
const parsed = scenario([
requestStep({ save: [{ name: "item", json_pointer: "/id" }] }),
{
step_id: "open",
action: "goto",
destination: {
url: `${ORIGIN}/items/{saved:item}`,
query: [
{
name: "note",
value: { source: "literal", value: "{saved:item}" },
},
],
},
wait_until: "load",
},
]);
const secrets = resolved(parsed);
secrets.save("create.item", "item", "7", false);
const goto = vi.fn(async () => null);
await perform({ goto } as unknown as Page, parsed.actions[1]!, secrets);
const [address] = goto.mock.calls[0] as unknown as [string];
const url = new URL(address);
expect(url.pathname).toBe("/items/7");
expect(url.searchParams.get("note")).toBe("{saved:item}");
});
});
interface FakeResponse {
readonly method: string;
readonly url: string;
readonly status: number;
readonly body: string;
/** A request already running when the step began, such as an earlier autosave. */
readonly earlier?: boolean;
/** The body size the browser received, when it differs from the body's. */
readonly size?: number;
readonly encoding?: string;
/** The Content-Length the response declares. */
readonly length?: string;
/** A body still arriving: the text resolves with it. */
readonly late?: Promise<string>;
}
/**
* A page whose click starts the given requests, emitting each that did not start earlier to request listeners, and
* answers them in order; waitForResponse resolves with the first answer it names once the click acted.
*/
const uiPage = (responses: readonly FakeResponse[], clickFails = false) => {
const order: string[] = [];
const reads = { count: 0 };
const listeners = new Set<(request: unknown) => void>();
let acted: () => void = () => undefined;
const clicked = new Promise<void>((resolve) => {
acted = resolve;
});
const answers = responses.map((response) => {
const request = {
method: () => response.method,
url: () => response.url,
sizes: async () => ({
responseBodySize: response.size ?? response.body.length,
}),
};
return {
response,
request,
answer: {
request: () => request,
url: () => response.url,
status: () => response.status,
headers: () => ({
...(response.encoding === undefined
? {}
: { "content-encoding": response.encoding }),
...(response.length === undefined
? {}
: { "content-length": response.length }),
}),
body: async () => {
reads.count += 1;
return Buffer.from(await (response.late ?? response.body));
},
},
};
});
const page = {
on: (_event: string, listener: (request: unknown) => void) =>
listeners.add(listener),
off: (_event: string, listener: (request: unknown) => void) =>
listeners.delete(listener),
getByRole: () => ({
click: async () => {
order.push("click");
if (clickFails) throw new Error("Element is not attached");
for (const { response, request } of answers)
if (response.earlier !== true)
for (const listener of listeners) listener(request);
acted();
},
}),
waitForResponse: async (
names: (response: unknown) => boolean,
options: { timeout?: number },
) => {
order.push(`wait ${String(options.timeout)}`);
await clicked;
const found = answers.map(({ answer }) => answer).find(names);
if (found === undefined) throw new Error("Timeout exceeded");
return found;
},
} as unknown as Page;
return { page, order, listeners, reads };
};
const clickSaving = (path: string) =>
scenario([
{
step_id: "save-item",
action: "click",
timeout_ms: 5000,
locator: { kind: "role", role: "button", name: "Save" },
save_response: {
method: "POST",
path,
save: [{ name: "item", json_pointer: "/id" }],
},
},
]);
it.each(["before response binding", "during the body read"])(
"refuses a competing request observed %s without publishing either identity",
async (phase) => {
vi.useFakeTimers();
onTestFinished(() => {
vi.useRealTimers();
});
const parsed = clickSaving("/api/items");
const secrets = resolved(parsed);
const body = '{"id":"created"}';
let finishBody!: (value: string) => void;
const late = new Promise<string>((resolveBody) => {
finishBody = resolveBody;
});
const started = { method: "POST", url: `${ORIGIN}/api/items`, status: 201 };
const beforeBinding = phase === "before response binding";
const { page, listeners, reads } = uiPage([
{ ...started, body, late },
...(beforeBinding ? [{ ...started, body: '{"id":"poll"}' }] : []),
]);
const outcome = perform(page, parsed.actions[0]!, secrets).catch(
(cause: unknown) => cause,
);
try {
await vi.advanceTimersByTimeAsync(0);
expect(reads.count).toBe(beforeBinding ? 0 : 1);
if (!beforeBinding) {
for (const listener of listeners)
listener({ method: () => started.method, url: () => started.url });
}
} finally {
finishBody(body);
await outcome;
}
expect(await outcome).toMatchObject({
message: expect.stringContaining("multiple matching requests"),
});
expect(() => secrets.savedValue("item")).toThrow("No earlier step saved");
expect(listeners.size).toBe(0);
},
);
describe("saving from a UI step's response", () => {
it("waits before clicking, and saves from the response the step names", async () => {
const parsed = clickSaving("/api/lists/{*}/items");
const secrets = resolved(parsed);
const { page, order } = uiPage([
{
method: "GET",
url: `${ORIGIN}/api/lists/3/items`,
status: 200,
body: '{"id":"read"}',
},
{
method: "POST",
url: `https://other.test/api/lists/3/items`,
status: 201,
body: '{"id":"foreign"}',
},
{
method: "POST",
url: `${ORIGIN}/api/lists/3/4/items`,
status: 201,
body: '{"id":"deeper"}',
},
{
method: "POST",
url: `${ORIGIN}/api/lists/3/items?draft=1`,
status: 201,
body: '{"id":"item-7"}',
},
]);
await perform(page, parsed.actions[0]!, secrets);
expect(order).toEqual(["wait 5000", "click"]);
expect(secrets.savedValue("item")).toBe("item-7");
});
it("saves from a request the step started, not one already running, and matches an encoded path", async () => {
const parsed = clickSaving("/api/lists/My List/items");
const secrets = resolved(parsed);
const { page, listeners } = uiPage([
{
method: "POST",
url: `${ORIGIN}/api/lists/My%20List/items`,
status: 201,
body: '{"id":"autosaved"}',
earlier: true,
},
{
method: "POST",
url: `${ORIGIN}/api/lists/My%20List/items`,
status: 201,
body: '{"id":"item-8"}',
},
]);
await perform(page, parsed.actions[0]!, secrets);
expect(secrets.savedValue("item")).toBe("item-8");
expect(listeners.size).toBe(0);
});
it("stops watching requests when the step fails before its response", async () => {
const parsed = clickSaving("/api/items");
const { page, listeners } = uiPage([], true);
await expect(
perform(page, parsed.actions[0]!, resolved(parsed)),
).rejects.toThrow("Element is not attached");
expect(listeners.size).toBe(0);
});
it("fails the step when no named response arrives or it is not 2xx", async () => {
const parsed = clickSaving("/api/items");
await expect(
perform(uiPage([]).page, parsed.actions[0]!, resolved(parsed)),
).rejects.toThrow(
"no POST /api/items response could be read, so nothing was saved: Timeout exceeded",
);
await expect(
perform(
uiPage([
{
method: "POST",
url: `${ORIGIN}/api/items`,
status: 422,
body: '{"id":"x"}',
},
]).page,
parsed.actions[0]!,
resolved(parsed),
),
).rejects.toThrow(
"answered 422; values are saved only from a 2xx response",
);
});
});
it("retains the physical response-wait failure through late cancellation", async () => {
const parsed = clickSaving("/api/items");
const secrets = resolved(parsed);
const { page, listeners } = uiPage([]);
const primary = new Error(
"page.waitForResponse: Target page has been closed",
);
vi.spyOn(page, "waitForResponse").mockRejectedValue(primary);
const cancel = new AbortController();
const remove = cancel.signal.removeEventListener.bind(cancel.signal);
const removing = vi
.spyOn(cancel.signal, "removeEventListener")
.mockImplementation((type, listener, options) => {
remove(type, listener, options);
cancel.abort("cancelled after the physical wait failed");
});
onTestFinished(() => removing.mockRestore());
const attempt = perform(page, parsed.actions[0]!, secrets, cancel.signal);
await expect(attempt).rejects.toMatchObject({
cause: primary,
message: expect.stringContaining(primary.message),
});
expect(cancel.signal.aborted).toBe(true);
expect(() => secrets.savedValue("item")).toThrow("No earlier step saved");
expect(listeners.size).toBe(0);
});
it("retains saved values when cancellation follows completed click publication", async () => {
const parsed = clickSaving("/api/items");
const { page } = uiPage([
{
method: "POST",
url: `${ORIGIN}/api/items`,
status: 201,
body: '{"id":"committed-object"}',
},
]);
const secrets = resolved(parsed);
const cancel = new AbortController();
await perform(page, parsed.actions[0]!, secrets, cancel.signal);
cancel.abort("cancelled after publication");
expect(secrets.savedValue("item")).toBe("committed-object");
});
describe("UI response body admission", () => {
const tooLarge = "too large to save values from";
const couldDecodePastLimit = "could decode past the size limit";
const unknown = "decoded response size cannot be bounded";
it.each([
{ encoding: "gzip", size: 32, length: "12000001" },
{ encoding: "deflate", size: 32 },
{ encoding: "x-gzip", size: 32 },
{ size: 0, length: "00000000000000000017" },
{ encoding: "gzip", size: 0, length: "0032" },
{ size: 12_000_001, error: tooLarge },
{
encoding: "gzip",
size: 12_000,
length: "32",
error: couldDecodePastLimit,
},
{ size: 0, length: "00012000001", error: couldDecodePastLimit },
{
encoding: "gzip",
size: 0,
length: "00012000",
error: couldDecodePastLimit,
},
{ encoding: "br", size: 32, error: unknown },
{ encoding: "gzip, zstd", size: 32, error: unknown },
{ encoding: "gzip", size: 0, error: unknown },
...[
"0000",
"+17",
"17.0",
"1.7e1",
"17, 17",
"0001000000000000000",
"0009007199254740993",
].map((length) => ({ size: 0, length, error: unknown })),
...[-1, Number.NaN].map((size) => ({ size, error: unknown })),
])(
"admits only bounded response bodies: %j",
async ({ error, ...bounds }) => {
const parsed = clickSaving("/api/items");
const secrets = resolved(parsed);
const { page, reads, listeners } = uiPage([
{
method: "POST",
url: `${ORIGIN}/api/items`,
status: 201,
body: '{"id":"record-7"}',
...bounds,
},
]);
const action = perform(page, parsed.actions[0]!, secrets);
if (error === undefined) {
await action;
expect(secrets.savedValue("item")).toBe("record-7");
expect(reads.count).toBe(1);
} else {
await expect(action).rejects.toThrow(error);
expect(() => secrets.savedValue("item")).toThrow(
"No earlier step saved",
);
expect(reads.count).toBe(0);
}
expect(listeners.size).toBe(0);
},
);
});
describe("saved response limits and deadlines", () => {
afterEach(() => {
vi.useRealTimers();
});
it.each(["deadline", "cancellation"])(
"saves nothing when %s ends an active body read",
async (end) => {
vi.useFakeTimers();
const parsed = clickSaving("/api/items");
const secrets = resolved(parsed);
const body = '{"id":"item-late"}';
let finishBody!: (value: string) => void;
const late = new Promise<string>((resolveBody) => {
finishBody = resolveBody;
});
const { page, listeners, reads } = uiPage([
{
method: "POST",
url: `${ORIGIN}/api/items`,
status: 201,
body: "",
size: Buffer.byteLength(body),
late,
},
]);
const cancel = new AbortController();
const outcome = perform(
page,
parsed.actions[0]!,
secrets,
cancel.signal,
).catch((cause: unknown) => cause);
try {
await vi.advanceTimersByTimeAsync(0);
expect(reads.count).toBe(1);
if (end === "cancellation") cancel.abort("cancelled during body read");
await vi.advanceTimersByTimeAsync(end === "deadline" ? 5000 : 0);
expect(
await Promise.race([outcome, Promise.resolve("still pending")]),
).toMatchObject({
message: expect.stringContaining(
"ended before its saved response was read",
),
});
expect(listeners.size).toBe(0);
} finally {
finishBody(body);
await outcome;
}
expect(() => secrets.savedValue("item")).toThrow("No earlier step saved");
},
);
it("saves nothing when cancellation arrives as the body wait releases its listener", async () => {
const parsed = clickSaving("/api/items");
const secrets = resolved(parsed);
const { page, listeners } = uiPage([
{
method: "POST",
url: `${ORIGIN}/api/items`,
status: 201,
body: '{"id":"late-object"}',
},
]);
const cancel = new AbortController();
const remove = cancel.signal.removeEventListener.bind(cancel.signal);
let waitsReleased = 0;
const removeListener = vi
.spyOn(cancel.signal, "removeEventListener")
.mockImplementation((type, listener, options) => {
remove(type, listener, options);
if (++waitsReleased === 2)
cancel.abort("cancelled at body wait completion");
});
onTestFinished(() => removeListener.mockRestore());
await expect(
perform(page, parsed.actions[0]!, secrets, cancel.signal),
).rejects.toThrow("ended before");
expect(() => secrets.savedValue("item")).toThrow("No earlier step saved");
expect(listeners.size).toBe(0);
});
it("reads a response whose received bytes exceed the character limit but whose text is within it", async () => {
const parsed = clickSaving("/api/items");
const secrets = resolved(parsed);
const { page } = uiPage([
{
method: "POST",
url: `${ORIGIN}/api/items`,
status: 201,
body: '{"id":"item-9"}',
// Two million three-byte characters, as CJK text spells them in UTF-8.
size: 6_000_000,
},
]);
await perform(page, parsed.actions[0]!, secrets);
expect(secrets.savedValue("item")).toBe("item-9");
});
it("fails a response whose text is longer than the character limit", async () => {
const parsed = clickSaving("/api/items");
const { page, reads } = uiPage([
{
method: "POST",
url: `${ORIGIN}/api/items`,
status: 201,
body: `{"id":"${"x".repeat(4_000_000)}"}`,
},
]);
await expect(
perform(page, parsed.actions[0]!, resolved(parsed)),
).rejects.toThrow("too large to save values from");
expect(reads.count).toBe(1);
});
});
it.each(["array", "embedded", "headers"])(
"refuses repeated large saved values in %s before expansion or browser dispatch",
async (kind) => {
const parsed = scenario([
requestStep({ save: [{ name: "large", json_pointer: "/value" }] }),
requestStep({
step_id: "expanded",
headers:
kind === "headers"
? Array.from({ length: 1000 }, (_, i) => ({
name: `X-Repeated-${i}`,
value: { source: "saved" as const, name: "large" },
}))
: [],
json:
kind === "headers"
? undefined
: kind === "array"
? Array.from({ length: 1000 }, () => "{saved:large}")
: "prefix" + "{saved:large}".repeat(1000),
}),
]);
const secrets = resolved(parsed);
secrets.save("source.large", "large", "x".repeat(3_000_000), false);
const page = { url: () => ORIGIN, evaluate: vi.fn() } as unknown as Page;
await expect(perform(page, parsed.actions[1]!, secrets)).rejects.toThrow(
"serialization allowance",
);
expect(page.evaluate).not.toHaveBeenCalled();
},
);
it.each([
["request", "raw query", "x", 2],
["request", "encoded query", "私", 0.25],
["goto", "encoded query", "私", 0.25],
] as const)(
"rejects an oversized %s %s before encoding or dispatch",
async (kind, _size, unit, allowanceFraction) => {
const repetitions = 1_000;
// One CJK code unit expands to nine ASCII bytes. The Unicode rows fit
// as raw text and exceed the current heap allowance only after encoding.
const value = unit.repeat(
Math.ceil(
(scenarioSerializationAllowance() * allowanceFraction) / repetitions,
),
);
const query = Array.from({ length: repetitions }, (_, index) => ({
name: `repeated-${index}`,
value: { source: "literal", value },
}));
const url = `${ORIGIN}/items?literal=a%20b#kept`;
const parsed = scenario([
kind === "request"
? requestStep({ query })
: { ...gotoStep(url), destination: { url, query } },
]);
const dispatch = vi.fn();
const page = {
url: () => ORIGIN,
evaluate: dispatch,
goto: dispatch,
} as unknown as Page;
const encode =
kind === "request"
? vi.spyOn(globalThis, "encodeURIComponent")
: vi.spyOn(URLSearchParams.prototype, "append");
encode.mockImplementation(() => {
throw new Error("Query encoding ran before expansion admission");
});
onTestFinished(() => encode.mockRestore());
await expect(
perform(page, parsed.actions[0]!, resolved(parsed)),
).rejects.toThrow("serialization allowance");
expect(encode).not.toHaveBeenCalled();
expect(dispatch).not.toHaveBeenCalled();
},
);
it("preserves goto form query normalization, Unicode, replacement characters and the fragment", async () => {
const parsed = scenario([
{
...gotoStep(`${ORIGIN}/items?literal=a%20b#kept`),
destination: {
url: `${ORIGIN}/items?literal=a%20b#kept`,
query: [
{
name: "q",
value: { source: "literal", value: "a b私😀!~'\ud800" },
},
],
},
},
]);
const goto = vi.fn(async () => null);
await perform(
{ goto } as unknown as Page,
parsed.actions[0]!,
resolved(parsed),
);
expect(goto).toHaveBeenCalledWith(
`${ORIGIN}/items?literal=a+b&q=a+b%E7%A7%81%F0%9F%98%80%21%7E%27%EF%BF%BD#kept`,
expect.anything(),
);
});
it("refuses repeated saved URL expansion before browser navigation", async () => {
const parsed = scenario([
requestStep({ save: [{ name: "large", json_pointer: "/value" }] }),
{
step_id: "open",
action: "goto",
destination: { url: `${ORIGIN}/` + "{saved:large}".repeat(1000) },
wait_until: "load",
},
]);
const secrets = resolved(parsed);
secrets.save("source.large", "large", "x".repeat(3_000_000), false);
const goto = vi.fn();
await expect(
perform({ goto } as unknown as Page, parsed.actions[1]!, secrets),
).rejects.toThrow("serialization allowance");
expect(goto).not.toHaveBeenCalled();
});
it.each([
["/api\\items/{*}", "/api/items/42"],
["/api/unused/../items/{*}", "/api/items/42"],
["/api/unused/%2e%2e/items/{*}", "/api/items/42"],
["/api/%7B*%7D", "/api/%7B*%7D", "/api/other"],
["/~rea-wildcard~/items/{*}", "/~rea-wildcard~/items/42", "/other/items/42"],
] as const)(
"binds only the response named by normalized path %s",
async (pattern, selected, excluded?: string) => {
const parsed = clickSaving(pattern);
const matching = {
method: "POST",
url: ORIGIN + selected,
status: 201,
body: '{"id":"42"}',
};
const { page, reads } = uiPage([
...(excluded === undefined
? []
: [{ ...matching, url: ORIGIN + excluded, body: '{"id":"other"}' }]),
matching,
]);
const secrets = resolved(parsed);
await perform(page, parsed.actions[0]!, secrets);
expect(secrets.savedValue("item")).toBe("42");
expect(reads.count).toBe(1);
},
);
it("redacts a saved secret as a parsed URL query spells it", () => {
const secrets = resolved(scenario([requestStep({})]));
secrets.save("create.token", "token", "ab'cd~ef", true);
const sent = new URL(
`${ORIGIN}/api/items?token=${encodeURIComponent("ab'cd~ef")}`,
).href;
expect(sent).toContain("ab%27cd~ef");
expect(secrets.redact(sent)).toBe(
`${ORIGIN}/api/items?token=[REDACTED:page:create.token]`,
);
});