unchanged
"; + const [block] = scriptBlocks(html); + assert.deepEqual(block, { + id: "probe", + src: "/runtime.js?x=1&y=2", + content: '\r\nconst value = "<&";\r\n', + startOffset: prefix.length, + endOffset: prefix.length + tag.length, + }); + assert.equal(html.slice(block.startOffset, block.endOffset), tag); + assert.equal( + withoutScripts(html, (script) => script.id === "probe"), + prefix + "\r\nunchanged
", + ); +}); + +test("renderer removal accepts HTML tag syntax while matching ID values exactly", () => { + const keep = + ''; + for (const close of ["", "", ""]) { + const selected = + '" + + "" + + ''; + assert.deepEqual( + scriptBlocks(html).map((script) => script.id), + ["other"], + ); + assert.equal(withoutEarlyRenderer(html), html); +}); + +test("probe and runtime removal preserve every unselected script byte", () => { + const before = '\r\n'; + const probe = + ''; + const runtime = ""; + const after = ""; + const html = before + probe + runtime + after; + assert.equal( + withoutScripts(html, (script) => + script.content.trimStart().startsWith("window.fixtureEarly="), + ), + before + runtime + after, + ); + assert.equal( + withoutScripts(html, (script) => script.id === "trustedserver-js"), + before + probe + after, + ); +}); + +test("an unclosed HTML script extends to EOF when jsdom leaves its end bound unset", () => { + for (const prefix of ["", "before
"]) { + const content = "const value = 'open';"; + const html = prefix + "'; + const [script] = scriptBlocks(html); + assert.equal(script.content, ""); + assert.equal(script.endOffset, html.indexOf("")); + assert.equal( + withoutScripts(html, (block) => block.id === "a"), + "after
", + ); + assert.equal( + withoutScripts(html, () => true), + "after
", + ); +}); + +test("table foster parenting does not reorder physical source splices", () => { + const html = + "keep
", () => true), + "keep
", + ); + assert.equal( + withoutScripts(nested, (script) => script.id === "inner"), + "", + ); +}); + +test("CSS-only control copies only the exact production reservation stylesheet", () => { + const css = + ''; + const html = + "" + + css + + ''; + assert.deepEqual(reservationStyles(html), [css]); + assert.deepEqual(reservationStyles(""), []); +}); + +test("deferred regression control adds only the actual runtime defer attribute", () => { + const prefix = + '\r\n'; + const suffix = + 'No runtime
"), "No runtime
"); +}); diff --git a/crates/trusted-server-integration-tests/browser/cwv/metrics.cjs b/crates/trusted-server-integration-tests/browser/cwv/metrics.cjs new file mode 100644 index 0000000000..6cd6fd0647 --- /dev/null +++ b/crates/trusted-server-integration-tests/browser/cwv/metrics.cjs @@ -0,0 +1,182 @@ +// Chromium layout-shift entries use navigation-relative milliseconds. +function sessionCls(entries) { + let maximum = 0; + let value = 0; + let first = 0; + let previous = 0; + for (const entry of entries) { + if (entry.hadRecentInput) continue; + if ( + value && + entry.startTime - previous < 1000 && + entry.startTime - first < 5000 + ) { + value += entry.value; + } else { + value = entry.value; + first = entry.startTime; + } + previous = entry.startTime; + maximum = Math.max(maximum, value); + } + return maximum; +} + +function distribution(values) { + const sorted = values.filter(Number.isFinite).sort((a, b) => a - b); + if (!sorted.length) return { count: 0, median: null, min: null, max: null }; + const middle = Math.floor(sorted.length / 2); + return { + count: sorted.length, + median: + sorted.length % 2 + ? sorted[middle] + : (sorted[middle - 1] + sorted[middle]) / 2, + min: sorted[0], + max: sorted.at(-1), + }; +} + +function observePage() { + const state = (window.cwv = { + supported: PerformanceObserver.supportedEntryTypes, + paint: [], + lcp: [], + shifts: [], + resources: [], + scriptLoads: [], + geometry: [], + firstVisibleEstimateMs: null, + delivered: false, + errors: [], + cspViolations: [], + }); + // Capturing native load events distinguishes parser-blocking from defer even + // when a 0ms response or a cache hit finishes before the first paint. + document.addEventListener( + "load", + (event) => { + if (event.target?.tagName !== "SCRIPT") return; + state.scriptLoads.push({ + id: event.target.id, + src: event.target.src, + time: performance.now(), + readyState: document.readyState, + articlePresent: !!document.getElementById("article"), + }); + }, + true, + ); + const observers = []; + const identifier = (node) => node?.id || node?.tagName || null; + const record = (type, entries) => { + for (const entry of entries) { + if (type === "paint") state.paint.push(entry.toJSON()); + if (type === "resource") state.resources.push(entry.toJSON()); + if (type === "largest-contentful-paint") { + state.lcp.push({ + ...entry.toJSON(), + element: identifier(entry.element), + }); + } + if (type === "layout-shift") { + state.shifts.push({ + startTime: entry.startTime, + value: entry.value, + hadRecentInput: entry.hadRecentInput, + sources: (entry.sources || []).map((source) => ({ + node: identifier(source.node), + withinArticle: !!source.node?.closest?.("#article"), + previousRect: source.previousRect.toJSON(), + currentRect: source.currentRect.toJSON(), + })), + }); + } + } + }; + for (const type of [ + "paint", + "largest-contentful-paint", + "layout-shift", + "resource", + ]) { + if (!state.supported.includes(type)) continue; + const observer = new PerformanceObserver((list) => + record(type, list.getEntries()), + ); + observer.observe({ type, buffered: true }); + observers.push({ type, observer }); + } + state.geometrySnapshot = (phase) => { + const wrapper = document.getElementById("fixture-ad-space"); + const article = document.getElementById("article"); + state.geometry.push({ + phase, + time: performance.now(), + wrapper: wrapper?.getBoundingClientRect().toJSON() ?? null, + minHeight: wrapper ? getComputedStyle(wrapper).minHeight : null, + article: article?.getBoundingClientRect().toJSON() ?? null, + }); + }; + state.finish = () => { + for (const { type, observer } of observers) + record(type, observer.takeRecords()); + state.geometrySnapshot("finished"); + return { + ...state, + navigation: performance + .getEntriesByType("navigation") + .map((entry) => entry.toJSON()), + observationEndMs: performance.now(), + fixture: window.fixture && { + requests: fixture.requests, + trace: fixture.trace, + creatives: fixture.creatives, + }, + early: window.fixtureEarly, + apis: { + methods: Object.fromEntries( + [ + "setConfig", + "getConfig", + "requestAds", + "addAdUnits", + "renderAdUnit", + "renderAllAdUnits", + "adInit", + "scheduleInitialAdInit", + "registerPublisherSlot", + ].map((name) => [name, typeof window.tsjs?.[name]]), + ), + shim: typeof window.__tsjs_installGptShim, + registrationVersion: + window.tsjs?.publisherSlotRegistrationVersion ?? null, + rendererVersion: window.tsjs?.tsRenderBridgeVersion ?? null, + }, + registration: window.fixtureHandle?.getStatus(), + rendererVersion: window.tsjs?.tsRenderBridgeVersion, + candidateAdId: window.tsjs?.bids?.["fixture-header"]?.hb_adid, + registeredNative: window.fixturePublisherSlot + ? fixture.nativeSlots.indexOf(window.fixturePublisherSlot) + : null, + }; + }; + window.addEventListener("securitypolicyviolation", (event) => { + state.cspViolations.push({ + blockedURI: event.blockedURI, + violatedDirective: event.violatedDirective, + disposition: event.disposition, + }); + }); + window.addEventListener("error", (event) => { + if (event.message) state.errors.push(event.message); + }); + document.addEventListener("DOMContentLoaded", () => { + state.geometrySnapshot("parsed"); + requestAnimationFrame(() => + requestAnimationFrame(() => state.geometrySnapshot("first-frames")), + ); + }); +} + +module.exports = { sessionCls, distribution, observePage }; diff --git a/crates/trusted-server-integration-tests/browser/cwv/metrics.test.cjs b/crates/trusted-server-integration-tests/browser/cwv/metrics.test.cjs new file mode 100644 index 0000000000..6695f2e724 --- /dev/null +++ b/crates/trusted-server-integration-tests/browser/cwv/metrics.test.cjs @@ -0,0 +1,84 @@ +const { test } = require("node:test"); +const assert = require("node:assert/strict"); +const { JSDOM } = require("jsdom"); +const { sessionCls, distribution, observePage } = require("./metrics.cjs"); +const shift = (startTime, value, hadRecentInput = false) => ({ + startTime, + value, + hadRecentInput, +}); + +test("CLS excludes recent input and selects the largest session, not the total", () => { + assert.equal( + sessionCls([ + shift(0, 0.1), + shift(500, 0.2), + shift(600, 9, true), + shift(1600, 0.4), + ]), + 0.4, + ); + assert.equal(sessionCls([]), 0); +}); +test("CLS starts a new session at the one-second gap", () => { + assert.equal( + sessionCls([shift(0, 0.1), shift(999, 0.2)]), + 0.30000000000000004, + ); + assert.equal(sessionCls([shift(0, 0.1), shift(1000, 0.2)]), 0.2); +}); +test("CLS session cannot extend beyond five seconds even with short gaps", () => { + const entries = Array.from({ length: 7 }, (_, i) => shift(i * 900, 0.1)); + assert(Math.abs(sessionCls(entries) - 0.6) < 1e-10); +}); +test("recent input does not bridge otherwise separated sessions", () => { + assert.equal( + sessionCls([shift(0, 0.1), shift(800, 9, true), shift(1500, 0.2)]), + 0.2, + ); +}); +test("distribution retains all finite samples, medians and ranges", () => { + assert.deepEqual(distribution([3, 1, 7, 5]), { + count: 4, + median: 4, + min: 1, + max: 7, + }); + assert.equal(distribution([3, 1, 2]).median, 2); + assert.deepEqual(distribution([null, undefined, NaN]), { + count: 0, + median: null, + min: null, + max: null, + }); +}); + +test("script load capture attaches to Document, the resource load event path endpoint", () => { + const dom = new JSDOM( + '', + { + url: "http://publisher.example.com/", + runScripts: "outside-only", + pretendToBeVisual: true, + }, + ); + try { + dom.window.PerformanceObserver = class { + static supportedEntryTypes = []; + }; + dom.window.eval(`(${observePage.toString()})()`); + const script = dom.window.document.getElementById("trustedserver-js"); + script.dispatchEvent(new dom.window.Event("load")); + assert.equal(dom.window.cwv.scriptLoads.length, 1); + assert.equal( + dom.window.cwv.scriptLoads[0].src, + "http://publisher.example.com/runtime.js", + ); + assert.equal(dom.window.cwv.scriptLoads[0].articlePresent, true); + dom.window.document.getElementById("article").remove(); + script.dispatchEvent(new dom.window.Event("load")); + assert.equal(dom.window.cwv.scriptLoads[1].articlePresent, false); + } finally { + dom.window.close(); + } +}); diff --git a/crates/trusted-server-integration-tests/browser/cwv/options.cjs b/crates/trusted-server-integration-tests/browser/cwv/options.cjs new file mode 100644 index 0000000000..6ce5d1ab55 --- /dev/null +++ b/crates/trusted-server-integration-tests/browser/cwv/options.cjs @@ -0,0 +1,118 @@ +const assert = require("node:assert/strict"); +const { parseArgs } = require("node:util"); + +function parseOptions(args = process.argv.slice(2)) { + const { values } = parseArgs({ + args, + options: { + baseline: { type: "string" }, + loading: { type: "string" }, + combined: { type: "string" }, + out: { type: "string" }, + runs: { type: "string", default: "5" }, + "correctness-only": { type: "boolean" }, + "regressions-only": { type: "boolean" }, + "diagnostic-screen": { type: "boolean" }, + "diagnostic-outages": { type: "boolean" }, + "runtime-delay-ms": { type: "string", default: "750" }, + "cpu-rate": { type: "string", default: "1" }, + "network-latency-ms": { type: "string", default: "0" }, + "download-kbps": { type: "string", default: "0" }, + "upload-kbps": { type: "string", default: "0" }, + cache: { type: "string", default: "cold" }, + }, + }); + assert( + values.loading && values.combined && values.out, + "Required: --loading CHANGED_UNRESERVED --combined CHANGED_RESERVED --out DIR; --baseline enables four-way measurement", + ); + assert( + values.baseline || values["correctness-only"] || values["regressions-only"], + "Measurement requires --baseline; CI may use --correctness-only", + ); + assert( + !(values["correctness-only"] && values["regressions-only"]), + "Choose only one of --correctness-only and --regressions-only", + ); + if (values["diagnostic-outages"]) { + assert(values.baseline, "--diagnostic-outages requires --baseline"); + assert( + !values["diagnostic-screen"] && + !values["correctness-only"] && + !values["regressions-only"], + "--diagnostic-outages cannot select another scope", + ); + } + if (values["diagnostic-screen"]) { + assert(values.baseline, "--diagnostic-screen requires --baseline"); + assert( + !values["correctness-only"] && !values["regressions-only"], + "--diagnostic-screen cannot select full-mode correctness or regressions", + ); + } + for (const name of [ + "runs", + "runtime-delay-ms", + "cpu-rate", + "network-latency-ms", + "download-kbps", + "upload-kbps", + ]) { + assert(values[name].trim() !== "", `--${name} must be a number`); + values[name] = Number(values[name]); + assert(Number.isFinite(values[name]), `--${name} must be finite`); + } + if (values["diagnostic-screen"]) + assert.equal( + values["runtime-delay-ms"], + 0, + "--diagnostic-screen requires explicit --runtime-delay-ms 0", + ); + assert( + Number.isSafeInteger(values.runs) && values.runs > 0, + "--runs must be a positive safe integer", + ); + assert(values["cpu-rate"] >= 1, "--cpu-rate must be at least 1"); + for (const name of [ + "runtime-delay-ms", + "network-latency-ms", + "download-kbps", + "upload-kbps", + ]) + assert(values[name] >= 0, `--${name} must be nonnegative`); + // Node timers overflow beyond this limit and silently schedule a 1ms delay. + assert( + values["runtime-delay-ms"] <= 2147483647, + "--runtime-delay-ms exceeds the Node timer range", + ); + for (const name of ["download-kbps", "upload-kbps"]) + assert( + Number.isFinite((values[name] * 1000) / 8), + `--${name} exceeds the CDP throughput range`, + ); + assert( + ["cold", "warm"].includes(values.cache), + "--cache must be cold or warm", + ); + return values; +} + +function conditions(options) { + return { + runtimeDelayMs: options["runtime-delay-ms"], + cpuRate: options["cpu-rate"], + cache: options.cache, + network: { + offline: false, + latency: options["network-latency-ms"], + downloadThroughput: + options["download-kbps"] === 0 + ? -1 + : (options["download-kbps"] * 1000) / 8, + uploadThroughput: + options["upload-kbps"] === 0 ? -1 : (options["upload-kbps"] * 1000) / 8, + }, + }; +} + +module.exports = { parseOptions, conditions }; diff --git a/crates/trusted-server-integration-tests/browser/cwv/options.test.cjs b/crates/trusted-server-integration-tests/browser/cwv/options.test.cjs new file mode 100644 index 0000000000..8bb386706c --- /dev/null +++ b/crates/trusted-server-integration-tests/browser/cwv/options.test.cjs @@ -0,0 +1,144 @@ +const test = require("node:test"); +const assert = require("node:assert/strict"); +const { parseOptions, conditions } = require("./options.cjs"); +const required = [ + "--loading", + "loading", + "--combined", + "combined", + "--out", + "out", + "--correctness-only", +]; + +test("existing CI defaults keep a 750ms hold and cold unthrottled contexts", () => { + const options = parseOptions(required); + assert.equal(options.runs, 5); + assert.deepEqual(conditions(options), { + runtimeDelayMs: 750, + cpuRate: 1, + cache: "cold", + network: { + offline: false, + latency: 0, + downloadThroughput: -1, + uploadThroughput: -1, + }, + }); +}); + +test("zero delay, warm cache and explicit CPU/network conditions are retained", () => { + const options = parseOptions([ + ...required, + "--runtime-delay-ms", + "0", + "--cache", + "warm", + "--cpu-rate", + "4", + "--network-latency-ms", + "150.5", + "--download-kbps", + "1600", + "--upload-kbps", + "750", + ]); + assert.deepEqual(conditions(options), { + runtimeDelayMs: 0, + cpuRate: 4, + cache: "warm", + network: { + offline: false, + latency: 150.5, + downloadThroughput: 200000, + uploadThroughput: 93750, + }, + }); +}); + +for (const [flag, value] of [ + ["runs", "0"], + ["runs", "1.5"], + ["runs", "9007199254740992"], + ["runtime-delay-ms", "-1"], + ["runtime-delay-ms", "2147483648"], + ["runtime-delay-ms", "NaN"], + ["cpu-rate", "0.5"], + ["cpu-rate", "Infinity"], + ["network-latency-ms", "-1"], + ["download-kbps", ""], + ["upload-kbps", " "], + ["upload-kbps", "-1"], + ["download-kbps", "1e308"], + ["cache", "hot"], +]) + test(`rejects invalid --${flag} ${JSON.stringify(value)}`, () => { + assert.throws(() => parseOptions([...required, `--${flag}`, value])); + }); + +test("diagnostic screen requires baseline, zero hold and its own exclusive scope", () => { + const measurement = [...required.slice(0, -1), "--baseline", "baseline"]; + const screen = [ + ...measurement, + "--diagnostic-screen", + "--runtime-delay-ms", + "0", + ]; + const options = parseOptions(screen); + assert.equal(options["diagnostic-screen"], true); + assert.equal(options["runtime-delay-ms"], 0); + assert.equal(options.baseline, "baseline"); + assert.throws( + () => parseOptions([...measurement, "--diagnostic-screen"]), + /runtime-delay-ms 0/, + ); + assert.throws( + () => + parseOptions([ + ...required.slice(0, -1), + "--diagnostic-screen", + "--runtime-delay-ms", + "0", + ]), + /baseline/, + ); + for (const mode of ["--correctness-only", "--regressions-only"]) + assert.throws(() => parseOptions([...screen, mode]), /cannot select/); +}); + +test("outage diagnostic requires baseline and is exclusive without changing other defaults", () => { + const measurement = [...required.slice(0, -1), "--baseline", "baseline"]; + const args = [ + ...measurement, + "--diagnostic-outages", + "--runtime-delay-ms", + "0", + ]; + const options = parseOptions(args); + assert.equal(options["diagnostic-outages"], true); + assert.equal(options["diagnostic-screen"], undefined); + assert.equal(options["runtime-delay-ms"], 0); + assert.equal(options.cache, "cold"); + assert.throws( + () => parseOptions([...required.slice(0, -1), "--diagnostic-outages"]), + /baseline/, + ); + for (const mode of [ + "--diagnostic-screen", + "--correctness-only", + "--regressions-only", + ]) + assert.throws(() => parseOptions([...args, mode]), /another scope/); + assert.equal(parseOptions([...measurement, "--diagnostic-outages"]).runs, 5); +}); + +test("requires explicit measurement inputs and rejects ambiguous modes/unknown options", () => { + assert.throws(() => parseOptions([])); + assert.throws(() => parseOptions(required.slice(0, -1)), /baseline/); + assert.throws(() => parseOptions([...required, "--regressions-only"])); + assert.throws(() => parseOptions([...required, "--typo"])); + assert.equal( + parseOptions([...required.slice(0, -1), "--baseline", "baseline"]).baseline, + "baseline", + ); +}); diff --git a/crates/trusted-server-integration-tests/browser/cwv/proxy.cjs b/crates/trusted-server-integration-tests/browser/cwv/proxy.cjs new file mode 100644 index 0000000000..3a702e14e3 --- /dev/null +++ b/crates/trusted-server-integration-tests/browser/cwv/proxy.cjs @@ -0,0 +1,78 @@ +const http = require("node:http"); + +// Proxy forwarding preserves Chromium's native HTTP cache. Only the two exact +// fixture origins may reach an upstream connection, regardless of browser bypass. +function fixtureProxy(origins, record) { + const allowed = new Map(origins.map((origin) => [origin, new URL(origin)])); + const server = http.createServer((request, response) => { + let target; + try { + target = new URL(request.url); + } catch { + record({ + url: request.url, + method: request.method, + action: "rejected", + reason: "Invalid proxy URL", + }); + response.writeHead(403); + response.end("External network forbidden in CWV fixture"); + return; + } + const destination = allowed.get(target.origin); + if (!destination || target.protocol !== "http:") { + record({ + url: target.href, + method: request.method, + action: "rejected", + reason: "Origin not allowed", + }); + response.writeHead(403); + response.end("External network forbidden in CWV fixture"); + return; + } + const entry = { + url: target.href, + method: request.method, + action: "forwarded", + }; + record(entry); + const headers = { ...request.headers, host: destination.host }; + delete headers["proxy-connection"]; + // Connection fields come only from the server-created origin map. The + // request contributes a path, never an upstream hostname or port. + const upstream = http.request( + { + hostname: destination.hostname, + port: destination.port, + path: target.pathname + target.search, + method: request.method, + headers, + }, + (incoming) => { + entry.status = incoming.statusCode; + response.writeHead(incoming.statusCode, incoming.headers); + incoming.pipe(response); + }, + ); + upstream.on("error", (error) => { + entry.error = error.message; + if (!response.headersSent) response.writeHead(502); + response.end("Fixture proxy upstream failed"); + }); + request.on("aborted", () => upstream.destroy()); + request.pipe(upstream); + }); + server.on("connect", (request, socket) => { + record({ + url: request.url, + method: "CONNECT", + action: "rejected", + reason: "CONNECT forbidden", + }); + socket.end("HTTP/1.1 403 Forbidden\r\nConnection: close\r\n\r\n"); + }); + return server; +} + +module.exports = { fixtureProxy }; diff --git a/crates/trusted-server-integration-tests/browser/cwv/proxy.test.cjs b/crates/trusted-server-integration-tests/browser/cwv/proxy.test.cjs new file mode 100644 index 0000000000..ae0ec6884b --- /dev/null +++ b/crates/trusted-server-integration-tests/browser/cwv/proxy.test.cjs @@ -0,0 +1,150 @@ +const test = require("node:test"); +const assert = require("node:assert/strict"); +const http = require("node:http"); +const { fixtureProxy } = require("./proxy.cjs"); +const listen = async (server) => { + await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve)); + return `http://127.0.0.1:${server.address().port}`; +}; +const close = (server) => new Promise((resolve) => server.close(resolve)); +const request = (proxy, url, method = "GET", body = "") => + new Promise((resolve, reject) => { + const outgoing = http.request(proxy, { path: url, method }, (response) => { + let text = ""; + response.setEncoding("utf8"); + response.on("data", (chunk) => { + text += chunk; + }); + response.on("end", () => + resolve({ + status: response.statusCode, + headers: response.headers, + text, + }), + ); + }); + outgoing.on("error", reject); + outgoing.end(body); + }); + +test("proxy forwards only exact fixture origins and preserves HTTP cache headers and bodies", async () => { + const observations = []; + const upstreamRequests = []; + const upstream = http.createServer((incoming, response) => { + let body = ""; + incoming.on("data", (chunk) => { + body += chunk; + }); + incoming.on("end", () => { + upstreamRequests.push({ + method: incoming.method, + path: incoming.url, + host: incoming.headers.host, + body, + }); + response.writeHead(200, { + "Cache-Control": "public, max-age=3600", + "Content-Type": "text/plain", + }); + response.end("fixture-response"); + }); + }); + const origin = await listen(upstream); + const creative = http.createServer((_request, response) => + response.end("creative"), + ); + const creativeOrigin = await listen(creative); + let forbiddenRequests = 0; + const forbidden = http.createServer((_request, response) => { + forbiddenRequests++; + response.end("forbidden"); + }); + const forbiddenOrigin = await listen(forbidden); + const proxy = fixtureProxy([origin, creativeOrigin], (entry) => + observations.push(entry), + ); + const proxyOrigin = await listen(proxy); + try { + const response = await request( + proxyOrigin, + origin + "/runtime.js?q=1", + "POST", + "fixture-body", + ); + assert.equal(response.status, 200); + assert.equal(response.text, "fixture-response"); + assert.deepEqual(upstreamRequests, [ + { + method: "POST", + path: "/runtime.js?q=1", + host: new URL(origin).host, + body: "fixture-body", + }, + ]); + assert.equal(response.headers["content-type"], "text/plain"); + assert.equal(response.headers["cache-control"], "public, max-age=3600"); + assert.equal( + (await request(proxyOrigin, creativeOrigin + "/creative")).text, + "creative", + ); + assert.equal( + (await request(proxyOrigin, forbiddenOrigin + "/external")).status, + 403, + ); + assert.equal( + (await request(proxyOrigin, "http://publisher.example.com/external")) + .status, + 403, + ); + assert.equal((await request(proxyOrigin, "/relative")).status, 403); + const suffixHost = new URL(origin); + suffixHost.hostname = "127.0.0.1.example.com"; + assert.equal((await request(proxyOrigin, suffixHost.href)).status, 403); + const wrongProtocol = new URL(origin); + wrongProtocol.protocol = "https:"; + assert.equal((await request(proxyOrigin, wrongProtocol.href)).status, 403); + assert.equal(forbiddenRequests, 0); + assert.equal( + observations.filter((entry) => entry.action === "forwarded").length, + 2, + ); + assert.equal( + observations.filter((entry) => entry.action === "rejected").length, + 5, + ); + } finally { + await Promise.all([ + close(proxy), + close(upstream), + close(creative), + close(forbidden), + ]); + } +}); + +test("proxy rejects CONNECT without opening a tunnel", async () => { + const observations = []; + const proxy = fixtureProxy([], (entry) => observations.push(entry)); + const origin = await listen(proxy); + try { + const status = await new Promise((resolve, reject) => { + const outgoing = http.request(origin, { + method: "CONNECT", + path: "publisher.example.com:443", + }); + outgoing.on("connect", (response, socket) => { + socket.destroy(); + resolve(response.statusCode); + }); + outgoing.on("error", reject); + outgoing.end(); + }); + assert.equal(status, 403); + assert.deepEqual( + observations.map(({ method, action }) => ({ method, action })), + [{ method: "CONNECT", action: "rejected" }], + ); + } finally { + await close(proxy); + } +}); diff --git a/crates/trusted-server-integration-tests/browser/cwv/run.cjs b/crates/trusted-server-integration-tests/browser/cwv/run.cjs new file mode 100644 index 0000000000..3b632cb07a --- /dev/null +++ b/crates/trusted-server-integration-tests/browser/cwv/run.cjs @@ -0,0 +1,1293 @@ +const fs = require("node:fs"); +const path = require("node:path"); +const http = require("node:http"); +const crypto = require("node:crypto"); +const zlib = require("node:zlib"); +const assert = require("node:assert/strict"); +const { parseOptions, conditions } = require("./options.cjs"); +const { + assertRuntimeOrdering, + assertCacheUse, + assertReservationControl, + assertCspRuntimeApis, + assertCandidateRendererVersion, + assertVisibleCreative, +} = require("./evidence.cjs"); +const { sessionCls, distribution, observePage } = require("./metrics.cjs"); +const { fixtureProxy } = require("./proxy.cjs"); +const options = parseOptions(); +const diagnosticScreen = options["diagnostic-screen"]; +const diagnosticOutages = options["diagnostic-outages"]; +const unifiedDiagnostic = diagnosticScreen || diagnosticOutages; +const settings = conditions(options); +const runs = options.runs; +const out = path.resolve(options.out); +fs.mkdirSync(out, { recursive: true }); +const save = (name, value) => + fs.writeFileSync(path.join(out, name), JSON.stringify(value, null, 2)); +const acceptance = { + schemaVersion: 1, + status: "running", + scope: diagnosticScreen + ? "diagnostic-screen" + : diagnosticOutages + ? "diagnostic-outages" + : options["regressions-only"] + ? "regressions" + : options["correctness-only"] + ? "correctness" + : "measurement-and-correctness", + startedAt: new Date().toISOString(), + conditions: settings, + samples: 0, + profileSamples: {}, + negativeControls: Object.fromEntries( + ["runtime-deferred", "reservation-removed"].map((id) => [ + id, + { + status: + unifiedDiagnostic || options["regressions-only"] + ? "not-requested" + : "pending", + ...(unifiedDiagnostic || options["regressions-only"] + ? { + reason: diagnosticScreen + ? "Diagnostic synchronous-unified measurement only; deferred-runtime and reservation-removal controls are outside this screen. Full acceptance remains unexecuted." + : diagnosticOutages + ? "Four critical-runtime availability diagnostics only; deferred-runtime and reservation-removal controls are not requested. Full acceptance remains unexecuted." + : "--regressions-only selects the four review regressions, not the negative controls", + } + : {}), + }, + ]), + ), +}; +let evidence; +const saveOutcome = () => { + save("acceptance.json", acceptance); + save("artifacts.json", { ...evidence, outcome: acceptance }); +}; +const recordFailure = (error) => { + acceptance.status = + ["ENOENT", "MODULE_NOT_FOUND"].includes(error.code) || + /Executable doesn't exist/.test(error.message) + ? "blocked" + : "failed"; + acceptance.finishedAt = new Date().toISOString(); + acceptance.error = { + name: error.name, + message: error.message, + stack: error.stack, + }; + for (const control of Object.values(acceptance.negativeControls)) + if (control.status === "running") control.status = acceptance.status; + saveOutcome(); +}; +// Persist before reading exports/dependencies so a failed rerun cannot leave an +// older successful outcome in the same output directory. +saveOutcome(); +process.on("uncaughtExceptionMonitor", recordFailure); +const { chromium } = require("playwright"); +const { JSDOM } = require("jsdom"); +const { + baselineRevision, + expectedArchitecture, + assertScreenDocument, + installEarlyProbe, + assertEarlyProbe, + screenCases, + assertScreenSamples, + outageCases, + assertOutageSamples, +} = require("./diagnostic.cjs"); +const { + correctnessCases, + assertCorrectnessSamples, + unavailableErrors, + assertCspDocument, + assertUnavailableRuntime, + assertDeferredRegression, +} = require("./contract.cjs"); +if (diagnosticScreen) { + acceptance.diagnostic = { + expectedArchitecture, + expectedSamples: 8 * runs, + fullAcceptancePassed: false, + excluded: + "Full correctness, controls, framework lifecycle, CSP/outage matrix and real-GPT acceptance are not executed by this screen. Missing authorized Google inventory remains blocked outside this scope.", + }; + saveOutcome(); +} +if (diagnosticOutages) { + acceptance.diagnostic = { + expectedArchitecture, + expectedSamples: 4, + fullAcceptancePassed: false, + changedOutageBehaviorApproved: true, + excluded: + "Checks the approved critical unified availability boundary with and without enforced CSP. This limited diagnostic does not establish retry/recovery, full correctness, controller, framework or live acceptance. Missing authorized Google inventory remains blocked outside this scope.", + }; + saveOutcome(); +} +const { + reservationStyles, + withRuntimeDefer, + withoutScripts, + rendererAsset, +} = require("./html.cjs"); +const sha256 = (value) => + crypto.createHash("sha256").update(value).digest("hex"); +const sizes = (bytes) => ({ + raw: bytes.length, + gzip: zlib.gzipSync(bytes).length, + brotli: zlib.brotliCompressSync(bytes).length, +}); +const pucPath = require.resolve("prebid-universal-creative/dist/banner.js"); +const puc = fs.readFileSync(pucPath); +const fixturePath = path.join( + __dirname, + "../publisher-registration/gpt-fixture.js", +); +const fixtureSource = fs.readFileSync(fixturePath, "utf8"); + +function snapshot(directory, label) { + const root = path.resolve(directory); + const manifestBytes = fs.readFileSync(path.join(root, "manifest.json")); + const manifest = JSON.parse(manifestBytes); + assert.equal(manifest.schemaVersion, 1); + const retained = path.join(out, "inputs", label); + fs.mkdirSync(retained, { recursive: true }); + fs.writeFileSync(path.join(retained, "manifest.json"), manifestBytes); + const files = new Map(); + for (const filename of [ + ...manifest.documents.map((doc) => doc.file), + ...Object.values(manifest.assets), + "app.toml", + ]) { + const bytes = fs.readFileSync(path.join(root, filename)); + files.set(filename, bytes); + fs.mkdirSync(path.dirname(path.join(retained, filename)), { + recursive: true, + }); + fs.writeFileSync(path.join(retained, filename), bytes); + } + return { + root, + manifest, + files, + evidence: { + root, + manifestSha256: sha256(manifestBytes), + manifest, + files: Object.fromEntries( + [...files].map(([file, bytes]) => [ + file, + { sha256: sha256(bytes), ...sizes(bytes) }, + ]), + ), + }, + }; +} +const loading = snapshot(options.loading, "loading"); +const combined = snapshot(options.combined, "combined"); +const baseline = options.baseline && snapshot(options.baseline, "baseline"); +if (baseline) + assert.equal( + baseline.manifest.sourceRevision, + baselineRevision, + "Baseline must remain pinned original-main, not the failing optimized PR snapshot", + ); +const profiles = { + loading, + combined, + ...(baseline ? { baseline, reservation: baseline } : {}), +}; +evidence = { + node: process.version, + platform: process.platform, + architecture: process.arch, + command: process.argv, + startedAt: new Date().toISOString(), + settings: { + ...settings, + runs, + hostContention: "Shared host may run concurrent builds", + cacheSemantics: + options.cache === "warm" + ? "Fresh per-sample context, prime then navigate again in same page; static assets cacheable for 3600 seconds; documents and creatives no-store" + : "Fresh contexts, HTTP cache disabled, all responses no-store", + externalNetwork: + "HTTP proxy forwards only exact publisher/creative origins; all other origins and CONNECT rejected; no browser bypass or Playwright routing", + }, + inputs: { + loading: loading.evidence, + combined: combined.evidence, + ...(baseline ? { baseline: baseline.evidence } : {}), + }, + transport: { + fixtureSha256: sha256(fixtureSource), + pucSha256: sha256(puc), + pucVersion: require("prebid-universal-creative/package.json").version, + }, + runnerSha256: sha256(fs.readFileSync(__filename)), + metricsSha256: sha256(fs.readFileSync(path.join(__dirname, "metrics.cjs"))), + htmlSha256: sha256(fs.readFileSync(path.join(__dirname, "html.cjs"))), + optionsSha256: sha256(fs.readFileSync(path.join(__dirname, "options.cjs"))), + evidenceSha256: sha256(fs.readFileSync(path.join(__dirname, "evidence.cjs"))), + proxySha256: sha256(fs.readFileSync(path.join(__dirname, "proxy.cjs"))), + contractSha256: sha256(fs.readFileSync(path.join(__dirname, "contract.cjs"))), + diagnosticSha256: sha256( + fs.readFileSync(path.join(__dirname, "diagnostic.cjs")), + ), + proxyRequests: [], + interventions: [ + { + type: "runtime delay, CPU/network and HTTP cache configuration", + ...settings, + }, + ], + boundary: + "Controlled loopback lab fixture, simulated GPT and fictional bids. First-visible is an animation-frame/DOM estimate, not hardware paint, GAM impression time or field CWV.", +}; +saveOutcome(); + +function documentInput(profile, name) { + const source = profiles[profile]; + const doc = source.manifest.documents.find((entry) => entry.name === name); + assert(doc, `Missing required exported document ${profile}/${name}`); + let html = source.files.get(doc.file).toString("utf8"); + if (profile === "reservation") { + const reservedDoc = combined.manifest.documents.find( + (entry) => entry.name === name, + ); + const styles = reservationStyles( + combined.files.get(reservedDoc.file).toString("utf8"), + ); + if (doc.matched && !doc.absentWrapper) + assert(styles.length, "Reserved export must supply production CSS"); + const css = styles.join(""); + html = html.replace("", "" + css); + evidence.interventions.push({ + profile, + name, + type: "CSS-only isolation derivative", + source: combined.root, + cssSha256: sha256(css), + htmlSha256: sha256(html), + }); + } + const dom = new JSDOM(html).window.document; + const runtime = dom.querySelector("script#trustedserver-js"); + assert(runtime?.src, `${profile}/${name} must have a production runtime tag`); + const runtimeSrc = runtime.getAttribute("src"); + const inline = [...dom.querySelectorAll("script:not([src])")] + .map((script) => script.textContent) + .join("\n"); + return { + ...doc, + html, + source, + runtimeSrc, + deferred: runtime.defer, + bytes: { + html: sizes(Buffer.from(html)), + inlineScript: sizes(Buffer.from(inline)), + inlineTags: [...dom.querySelectorAll("script:not([src])")].map( + (script, index) => ({ + id: script.id || `anonymous-${index}`, + ...sizes(Buffer.from(script.textContent)), + }), + ), + runtime: sizes(source.files.get(source.manifest.assets[runtimeSrc])), + }, + }; +} + +let active; +let publisherOrigin; +let creativeOrigin; +const wait = (ms) => new Promise((resolve) => setTimeout(resolve, ms)); +async function respond(request, response) { + const url = new URL(request.url, `http://${request.headers.host}`); + const send = (type, bytes, status = 200) => { + const cacheable = + status === 200 && + (active.input.source.manifest.assets[request.url] || + ["/hero.svg", "/fixture-puc.js"].includes(url.pathname)); + active.responses.push({ + url: url.href, + status, + cacheable: !!cacheable, + phase: active.phase, + runtimeDelayMs: + request.url === active.input.runtimeSrc && active.runtimeAttempts === 1 + ? settings.runtimeDelayMs + : 0, + }); + response.writeHead(status, { + "Content-Type": type, + "Cache-Control": + options.cache === "warm" && cacheable + ? "public, max-age=3600" + : "no-store", + ...(url.pathname === active.input.requestPath + ? active.responseHeaders + : {}), + }); + response.end(bytes); + }; + if (url.pathname === "/fixture-puc.js") + return send("application/javascript", puc); + if (url.pathname === "/fixture-puc") + return send( + "text/html", + ``, + ); + if (url.pathname === "/fixture-publisher") + return send( + "text/html", + `Publisher result
`,
+ );
+ if (url.pathname === "/hero.svg")
+ return send(
+ "image/svg+xml",
+ '',
+ );
+ if (
+ url.pathname === "/favicon.ico" ||
+ url.pathname.startsWith("/fixture-notice/")
+ )
+ return send("text/plain", "", 204);
+ if (request.url === active.input.runtimeSrc) {
+ active.runtimeAttempts++;
+ const retry = active.runtimeAttempts > 1;
+ if (!retry && settings.runtimeDelayMs > 0)
+ await wait(settings.runtimeDelayMs);
+ if (!retry && ["failed", "late-runtime"].includes(active.mode))
+ return send("text/plain", "Deliberate fixture runtime failure", 404);
+ }
+ if (active.mode === "renderer-absent" && rendererAsset(url.pathname)) {
+ active.blockedRenderer.push(url.pathname);
+ return send("text/plain", "Deliberate fixture renderer absence", 404);
+ }
+ const asset = active.input.source.manifest.assets[request.url];
+ if (asset)
+ return send("application/javascript", active.input.source.files.get(asset));
+ if (url.pathname === active.input.requestPath)
+ return send("text/html", active.html);
+ active.unexpected.push(request.url);
+ return send("text/plain", "Undeclared fixture URL", 404);
+}
+const servers = [];
+async function listen() {
+ const server = http.createServer((req, res) =>
+ respond(req, res).catch((error) => {
+ console.error(error);
+ res.destroy(error);
+ }),
+ );
+ servers.push(server);
+ await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+ return `http://127.0.0.1:${server.address().port}`;
+}
+
+function installDelivery({ height, noFill }) {
+ const state = window.cwv;
+ const scheduled = new Set();
+ const schedule = () => {
+ for (const request of fixture.requests) {
+ if (scheduled.has(request.index)) continue;
+ scheduled.add(request.index);
+ setTimeout(() => {
+ state.geometrySnapshot("before-fill");
+ fixture.render(request.index, { noFill });
+ const frame = document.querySelector(
+ `iframe[data-request="${request.index}"]`,
+ );
+ if (frame) frame.height = String(height);
+ if (noFill) state.delivered = true;
+ }, 150);
+ }
+ };
+ const service = googletag.pubads();
+ for (const [object, name] of [
+ [service, "refresh"],
+ [googletag, "display"],
+ ]) {
+ const original = object[name];
+ object[name] = function (...args) {
+ const result = original.apply(this, args);
+ schedule();
+ return result;
+ };
+ }
+ window.addEventListener("message", (event) => {
+ if (event.data?.type !== "fixture-creative-ready") return;
+ requestAnimationFrame(() => {
+ const frame = document.querySelector("iframe[data-request]");
+ const rect = frame?.getBoundingClientRect();
+ if (
+ rect &&
+ rect.width > 0 &&
+ rect.height > 0 &&
+ rect.top < innerHeight &&
+ rect.bottom > 0
+ ) {
+ state.firstVisibleEstimateMs ??= performance.now();
+ state.delivered = true;
+ state.geometrySnapshot("creative-visible");
+ }
+ });
+ });
+}
+
+const samples = [];
+let stage =
+ options["correctness-only"] ||
+ options["regressions-only"] ||
+ diagnosticOutages
+ ? "correctness"
+ : "measurement";
+async function sample(
+ browser,
+ profile,
+ name,
+ viewport,
+ mode = "slow",
+ noFill = false,
+ control = null,
+) {
+ if (control) {
+ acceptance.negativeControls[control].status = "running";
+ saveOutcome();
+ }
+ const input = documentInput(profile, name);
+ if (["loading", "combined"].includes(profile)) assertCspDocument(input);
+ const initiallyUnavailable = [
+ "failed",
+ "absent",
+ "renderer-absent",
+ "late-runtime",
+ ].includes(mode);
+ const runtimeUnavailable = initiallyUnavailable && mode !== "late-runtime";
+ const deliveryExpected =
+ input.matched && !runtimeUnavailable && control !== "runtime-deferred";
+ // Preserve publisher code and declare its exact failures when the sole runtime
+ // is missing. The deferred negative control breaks only the early core probe.
+ const expectedErrors = initiallyUnavailable
+ ? unavailableErrors(input.registered)
+ : control === "runtime-deferred"
+ ? unavailableErrors(false)
+ : [];
+ assertScreenDocument(input.html, profile);
+ const index = samples.length;
+ const label = `${index}-${profile}-${name}-${viewport.width}-${mode}${noFill ? "-nofill" : ""}${control ? "-" + control : ""}`;
+ active = {
+ input,
+ mode,
+ runtimeAttempts: 0,
+ unexpected: [],
+ blockedRenderer: [],
+ responseHeaders: {},
+ responses: [],
+ phase: options.cache === "warm" ? "warmup" : "measurement",
+ html: input.html,
+ };
+ if (control === "runtime-deferred") {
+ active.html = withRuntimeDefer(input.html);
+ assert.notEqual(
+ active.html,
+ input.html,
+ "Deferred regression control must add defer to the actual synchronous runtime",
+ );
+ }
+ if (control === "reservation-removed") {
+ const styles = reservationStyles(input.html);
+ assert(
+ styles.length > 0,
+ "Reservation negative control requires production CSS",
+ );
+ for (const style of styles) active.html = active.html.replace(style, "");
+ }
+ if (control) {
+ const file = label + ".html";
+ fs.writeFileSync(path.join(out, file), active.html);
+ evidence.interventions.push({
+ index,
+ profile,
+ name,
+ type: control,
+ file,
+ htmlSha256: sha256(active.html),
+ });
+ }
+ if (input.enforcedCsp) {
+ const legacy = baseline ?? input.source;
+ const legacyDoc = legacy.manifest.documents.find(
+ (doc) => doc.name === (baseline ? "inline" : "csp"),
+ );
+ const legacyHtml = legacy.files.get(legacyDoc.file).toString("utf8");
+ assert(
+ !legacyHtml.includes('id="trustedserver-bootstrap"'),
+ "CSP hashes must not come from the new compiled inline entry",
+ );
+ const inline = [
+ ...new JSDOM(legacyHtml).window.document.querySelectorAll(
+ "script:not([src])",
+ ),
+ ].map((script) => script.textContent);
+ const hashes = [
+ ...inline,
+ ...(input.source.manifest.creativeInlineScripts ?? []),
+ ].map(
+ (script) =>
+ `'sha256-${crypto.createHash("sha256").update(script).digest("base64")}'`,
+ );
+ active.responseHeaders["Content-Security-Policy"] =
+ `script-src 'self' ${hashes.join(" ")}`;
+ evidence.interventions.push({
+ profile,
+ name,
+ type: "enforced old-inline-hash and self CSP",
+ policySource: baseline
+ ? baseline.root
+ : "current synchronous legacy-inline output",
+ responseHeaders: active.responseHeaders,
+ });
+ assert(
+ !input.html.includes('id="trustedserver-bootstrap"'),
+ "Enforced CSP must use the synchronous production runtime without inline fallback",
+ );
+ assert(
+ !input.html.includes("// Edge-injected GPT auction bootstrap."),
+ "Enforced CSP must not depend on the provisional raw bootstrap's inline hash",
+ );
+ if (runtimeUnavailable)
+ evidence.interventions.push({
+ index,
+ profile,
+ name,
+ type: "enforced-CSP critical runtime failure; no inline fallback",
+ expectedErrors,
+ });
+ }
+ if (mode === "renderer-absent") {
+ assert(
+ rendererAsset(
+ new URL(input.runtimeSrc, "http://publisher.example.com").pathname,
+ ),
+ );
+ evidence.interventions.push({
+ profile,
+ name,
+ type: "true renderer absence; sole unified runtime blocked, no inline renderer or publisher-code removal",
+ htmlSha256: sha256(active.html),
+ });
+ }
+ if (mode === "absent") {
+ active.html = withoutScripts(
+ input.html,
+ (script) => script.id === "trustedserver-js",
+ );
+ assert.notEqual(
+ active.html,
+ input.html,
+ "Absent-runtime control must remove the runtime tag",
+ );
+ evidence.interventions.push({
+ profile,
+ name,
+ type: "absent runtime tag control",
+ htmlSha256: sha256(active.html),
+ });
+ }
+ const context = await browser.newContext({
+ viewport,
+ serviceWorkers: "block",
+ });
+ let traceStarted = false;
+ let result;
+ let page;
+ let warmup = null;
+ const recovery = [];
+ const requests = new Map();
+ const errors = [];
+ const network = [];
+ try {
+ await context.tracing.start({
+ screenshots: true,
+ snapshots: true,
+ sources: true,
+ });
+ traceStarted = true;
+ // One init script preserves setup order; Playwright does not order separate init scripts.
+ await context.addInitScript({
+ content: `if(window===window.top){
+ (${observePage.toString()})();
+ (${installEarlyProbe.toString()})();
+ window.publisherFixtureOptions={initialLoad:${JSON.stringify(input.registered ? "disabled" : "enabled")}};
+ ${fixtureSource.replaceAll("https://creative.example.com", creativeOrigin)}
+ (${installDelivery.toString()})(${JSON.stringify({ height: input.creativeHeight, noFill })});
+ }`,
+ });
+ page = await context.newPage();
+ const cdp = await context.newCDPSession(page);
+ await cdp.send("Network.enable");
+ await cdp.send("Network.setCacheDisabled", {
+ cacheDisabled: options.cache === "cold",
+ });
+ await cdp.send("Emulation.setCPUThrottlingRate", {
+ rate: settings.cpuRate,
+ });
+ await cdp.send("Network.emulateNetworkConditions", settings.network);
+ cdp.on("Network.requestWillBeSent", ({ requestId, request }) => {
+ requests.set(requestId, { url: request.url, method: request.method });
+ });
+ cdp.on("Network.requestServedFromCache", ({ requestId }) => {
+ const entry = requests.get(requestId);
+ if (entry) entry.servedFromCache = true;
+ });
+ cdp.on("Network.responseReceived", ({ requestId, response }) => {
+ const entry = requests.get(requestId);
+ if (entry)
+ Object.assign(entry, {
+ status: response.status,
+ fromDiskCache: response.fromDiskCache ?? false,
+ fromServiceWorker: response.fromServiceWorker ?? false,
+ headers: response.headers,
+ });
+ });
+ page.on("pageerror", (error) => errors.push(error.message));
+ page.on("request", (request) => {
+ const url = request.url();
+ network.push({ url, method: request.method() });
+ if (
+ !url.startsWith(publisherOrigin + "/") &&
+ !url.startsWith(creativeOrigin + "/")
+ )
+ errors.push("Unexpected external request: " + url);
+ });
+ const navigate = () =>
+ page.goto(publisherOrigin + input.requestPath, {
+ waitUntil: "load",
+ timeout: 15000,
+ });
+ if (options.cache === "warm") {
+ await navigate();
+ if (deliveryExpected && !initiallyUnavailable)
+ await page.waitForFunction(() => cwv.delivered, null, {
+ timeout: 10000,
+ });
+ await wait(250);
+ assert.deepEqual(
+ errors,
+ expectedErrors,
+ "Cache priming must have only declared fixture errors",
+ );
+ assert.deepEqual(
+ active.unexpected,
+ [],
+ "Cache priming URLs must be declared",
+ );
+ warmup = {
+ requests: [...requests.values()],
+ network: [...network],
+ responses: [...active.responses],
+ raw: await page.evaluate(() => cwv.finish()),
+ };
+ requests.clear();
+ network.length = 0;
+ errors.length = 0;
+ active.runtimeAttempts = 0;
+ active.blockedRenderer = [];
+ active.responses = [];
+ active.phase = "measurement";
+ }
+ await navigate();
+ if (deliveryExpected && !initiallyUnavailable)
+ await page.waitForFunction(() => cwv.delivered, null, { timeout: 10000 });
+ if (mode === "late-runtime") {
+ const before = await page.evaluate(() => cwv.finish());
+ assertUnavailableRuntime(
+ before,
+ active.responses,
+ new URL(input.runtimeSrc, publisherOrigin).href,
+ mode,
+ );
+ assert.deepEqual(
+ errors,
+ expectedErrors,
+ "Before explicit recovery, only declared missing-runtime errors are allowed",
+ );
+ recovery.push({
+ phase: active.phase,
+ raw: before,
+ responses: [...active.responses],
+ });
+ await page.evaluate(
+ (src) =>
+ new Promise((resolve, reject) => {
+ const script = document.createElement("script");
+ script.id = "trustedserver-js-recovery";
+ script.src = src;
+ script.onload = resolve;
+ script.onerror = reject;
+ document.head.append(script);
+ }),
+ input.runtimeSrc,
+ );
+ if (input.registered)
+ await page.evaluate(() => {
+ // Explicit publisher re-registration after recovery uses the native
+ // object already created before the critical runtime failed.
+ window.fixtureHandle = tsjs.registerPublisherSlot({
+ slotId: "fixture-header",
+ gptSlot: window.fixturePublisherSlot,
+ navigationGeneration: tsjs.navGeneration || 0,
+ eligibleFormats: [[300, 250]],
+ });
+ });
+ // The original body-close scheduling call could not run during outage.
+ // Explicit publisher recovery must retry it, not pretend loading alone
+ // replays failed publisher scripts.
+ await page.evaluate(() => tsjs.scheduleInitialAdInit(tsjs.bids));
+ evidence.interventions.push({
+ index,
+ profile,
+ name,
+ type: "explicit runtime reload, publisher re-registration when applicable, and initial scheduling retry",
+ });
+ if (input.matched)
+ await page.waitForFunction(() => cwv.delivered, null, {
+ timeout: 10000,
+ });
+ }
+ // Multiple frames include fill-induced layout, then a declared quiet window.
+ await page.evaluate(
+ () =>
+ new Promise((resolve) =>
+ requestAnimationFrame(() => requestAnimationFrame(resolve)),
+ ),
+ );
+ await wait(250);
+ const raw = await page.evaluate(() => cwv.finish());
+ const cls = sessionCls(raw.shifts);
+ const fcp = raw.paint.find(
+ (entry) => entry.name === "first-contentful-paint",
+ )?.startTime;
+ const lcp = raw.lcp.at(-1)?.startTime;
+ for (const type of ["paint", "largest-contentful-paint", "layout-shift"])
+ assert(raw.supported.includes(type), `Missing ${type} observer support`);
+ assert(Number.isFinite(fcp), "FCP must be observed");
+ assert(Number.isFinite(lcp), "LCP must be observed");
+ assert.deepEqual(
+ errors,
+ expectedErrors,
+ "Only declared fixture page errors are allowed",
+ );
+ if (["loading", "combined"].includes(profile))
+ assertCspRuntimeApis(raw, !runtimeUnavailable);
+ if (runtimeUnavailable) {
+ assertUnavailableRuntime(
+ raw,
+ active.responses,
+ new URL(input.runtimeSrc, publisherOrigin).href,
+ mode,
+ );
+ assert.equal(
+ active.runtimeAttempts,
+ mode === "absent" ? 0 : 1,
+ "Unavailable critical runtime must not retry implicitly",
+ );
+ }
+ if (input.enforcedCsp)
+ assert.deepEqual(
+ raw.cspViolations,
+ [],
+ "Old-inline-hash/self CSP must permit the synchronous runtime without violations",
+ );
+ assert.deepEqual(
+ active.unexpected,
+ [],
+ "Every loopback URL must be declared",
+ );
+ if (mode === "renderer-absent") {
+ assert.equal(
+ raw.rendererVersion,
+ undefined,
+ "No actual render bridge may remain installed",
+ );
+ assert.deepEqual(
+ active.blockedRenderer,
+ [new URL(input.runtimeSrc, publisherOrigin).pathname],
+ "Actual sole unified renderer must be blocked",
+ );
+ } else if (!runtimeUnavailable) {
+ if (control !== "runtime-deferred" && mode !== "late-runtime")
+ assert(
+ raw.early.core && raw.early.queued,
+ "Direct core API and queued publisher callback must work at the first publisher script",
+ );
+ else if (mode === "late-runtime") {
+ assert.equal(
+ raw.early.core,
+ false,
+ "Recovery must not conceal the original unavailable core probe",
+ );
+ assert.equal(
+ raw.early.queued,
+ false,
+ "Recovery must not invent the failed publisher callback",
+ );
+ assert.deepEqual(
+ active.responses
+ .filter(
+ (entry) =>
+ entry.url === new URL(input.runtimeSrc, publisherOrigin).href,
+ )
+ .map((entry) => entry.status),
+ [404, 200],
+ "Recovery must follow one failure with one explicit successful request",
+ );
+ assert.equal(
+ active.runtimeAttempts,
+ 2,
+ "Recovery must not implicitly retry again",
+ );
+ assertRuntimeOrdering(
+ raw,
+ new URL(input.runtimeSrc, publisherOrigin).href,
+ true,
+ );
+ }
+ assertCandidateRendererVersion(raw, profile);
+ assertEarlyProbe(
+ raw,
+ profile,
+ control === "runtime-deferred" || mode === "late-runtime",
+ );
+ }
+ assert.equal(
+ raw.fixture.requests.length,
+ deliveryExpected ? 1 : 0,
+ "Exactly one native initial request requires a matched slot and available critical runtime",
+ );
+ if (deliveryExpected) {
+ assert.equal(
+ raw.fixture.trace.filter((entry) => entry.event === "nativeDefine")
+ .length,
+ 1,
+ "One native slot definition must survive takeover",
+ );
+ assert.equal(
+ raw.fixture.trace.filter((entry) => entry.event === "nativeDisplay")
+ .length,
+ 1,
+ "Initial delivery must display exactly once",
+ );
+ if (input.registered) {
+ const refreshes = raw.fixture.trace.filter(
+ (entry) => entry.event === "nativeRefresh",
+ );
+ assert.equal(
+ refreshes.length,
+ 1,
+ "Registered initial delivery must refresh exactly once",
+ );
+ assert(
+ refreshes[0].scoped,
+ "Registered initial refresh must remain scoped",
+ );
+ assert.deepEqual(
+ refreshes[0].natives,
+ [raw.registeredNative],
+ "Refresh must select only the publisher native object",
+ );
+ assert.equal(
+ raw.fixture.requests[0].native,
+ raw.registeredNative,
+ "Registered delivery must use the publisher native object",
+ );
+ assert.deepEqual(
+ raw.fixture.requests[0].targeting.publisher_key,
+ ["keep"],
+ "Publisher targeting must survive handoff",
+ );
+ assert.equal(
+ raw.registration.status,
+ "rendered",
+ "Registration must settle through the real renderer",
+ );
+ }
+ assert.equal(
+ raw.fixture.requests[0].targeting.hb_adid?.[0],
+ "fixture-server-ad",
+ "Candidate targeting requires an actual renderer",
+ );
+ if (!noFill) {
+ const text = await Promise.all(
+ page
+ .frames()
+ .map((frame) => frame.locator(".marker").allTextContents()),
+ );
+ assertVisibleCreative(
+ text,
+ raw.firstVisibleEstimateMs,
+ "Server result",
+ );
+ }
+ }
+ const resources = raw.resources.filter(
+ (entry) =>
+ new URL(entry.name).pathname ===
+ new URL(input.runtimeSrc, publisherOrigin).pathname,
+ );
+ const responseEnd = resources[0]?.responseEnd;
+ if (mode === "slow") {
+ assert(
+ Number.isFinite(responseEnd),
+ "Runtime resource timing must exist",
+ );
+ assertRuntimeOrdering(
+ raw,
+ new URL(input.runtimeSrc, publisherOrigin).href,
+ control === "runtime-deferred",
+ );
+ if (control === "runtime-deferred")
+ assertDeferredRegression(
+ raw,
+ new URL(input.runtimeSrc, publisherOrigin).href,
+ fcp,
+ responseEnd,
+ settings,
+ );
+ else
+ assert(
+ fcp >= responseEnd,
+ "Parser-blocking runtime must finish before FCP",
+ );
+ }
+ const cacheRequests = [...requests.values()];
+ const cacheHits =
+ options.cache === "warm"
+ ? assertCacheUse(
+ cacheRequests,
+ new URL(input.runtimeSrc, publisherOrigin).href,
+ mode === "slow",
+ )
+ : [];
+ const before = raw.geometry.find((entry) => entry.phase === "before-fill");
+ const after = raw.geometry.at(-1);
+ const expectedHeight = viewport.width >= 1024 ? 600 : 250;
+ const reserved =
+ ["combined", "reservation"].includes(profile) &&
+ control !== "reservation-removed" &&
+ input.matched &&
+ !input.absentWrapper;
+ if (reserved) {
+ assert.equal(
+ Number.parseFloat(after.minHeight),
+ expectedHeight,
+ "Responsive reservation must match viewport",
+ );
+ if (!deliveryExpected) {
+ assert.equal(
+ cls,
+ 0,
+ "Unavailable runtime or deferred-startup regression must not produce ad-induced layout shift",
+ );
+ } else if (noFill || input.creativeHeight <= expectedHeight) {
+ assert.equal(
+ after.article.top,
+ before.article.top,
+ "Reserved article must not move during compatible fill or no-fill",
+ );
+ assert.equal(
+ cls,
+ 0,
+ "Compatible reservation must prevent controlled ad-induced CLS",
+ );
+ }
+ } else if (input.absentWrapper) {
+ assert.equal(
+ after.wrapper,
+ null,
+ "Absent configured wrapper must not be synthesized",
+ );
+ } else if (after.wrapper) {
+ assert.equal(
+ after.minHeight,
+ "0px",
+ "Unmatched and unreserved wrappers must remain untouched",
+ );
+ }
+ if (control === "reservation-removed") assertReservationControl(raw, cls);
+ result = {
+ index,
+ control,
+ runtimeUnavailableBoundary: runtimeUnavailable,
+ ...(recovery.length ? { recovery } : {}),
+ ...(diagnosticOutages
+ ? {
+ diagnosticOutage: {
+ policy: input.enforcedCsp
+ ? "enforced-old-hash-self-csp"
+ : "normal",
+ expectedRuntimeAvailable: !runtimeUnavailable,
+ changedOutageBehaviorApproved: true,
+ interpretation:
+ "Approved no-inline-fallback critical-script boundary; limited diagnostic, not full acceptance or recovery proof",
+ },
+ }
+ : {}),
+ conditions: settings,
+ cache: {
+ mode: options.cache,
+ hits: cacheHits,
+ requests: cacheRequests,
+ warmup,
+ },
+ responses: active.responses,
+ stage,
+ profile,
+ name,
+ viewport,
+ mode,
+ noFill,
+ bytes: input.bytes,
+ metrics: {
+ fcp,
+ lcp,
+ cls,
+ domInteractive: raw.navigation[0].domInteractive,
+ domContentLoaded: raw.navigation[0].domContentLoadedEventEnd,
+ requestMs:
+ raw.fixture.trace.find((entry) => entry.event === "nativeRequest")
+ ?.time ?? null,
+ firstVisibleEstimateMs: raw.firstVisibleEstimateMs,
+ runtimeResponseEnd: responseEnd ?? null,
+ reservationHeight: after.wrapper?.height ?? null,
+ whitespace: after.wrapper
+ ? Math.max(
+ 0,
+ after.wrapper.height - (noFill ? 0 : input.creativeHeight),
+ )
+ : null,
+ },
+ raw,
+ errors,
+ network,
+ responseHeaders: active.responseHeaders,
+ blockedRenderer: active.blockedRenderer,
+ };
+ samples.push(result);
+ acceptance.samples = samples.length;
+ acceptance.profileSamples[profile] =
+ (acceptance.profileSamples[profile] ?? 0) + 1;
+ if (control)
+ Object.assign(acceptance.negativeControls[control], {
+ status: "passed",
+ sampleIndex: index,
+ htmlFile: label + ".html",
+ });
+ save("samples.json", samples);
+ saveOutcome();
+ console.log(JSON.stringify({ label, ...result.metrics }));
+ await page.screenshot({
+ path: path.join(out, label + ".png"),
+ fullPage: true,
+ });
+ return result;
+ } catch (error) {
+ await page
+ ?.screenshot({
+ path: path.join(out, label + "-failure.png"),
+ fullPage: true,
+ })
+ .catch(() => {});
+ save(label + "-failure.json", {
+ error: error.stack,
+ sample: result,
+ raw: await page?.evaluate(() => window.cwv?.finish()).catch(() => null),
+ conditions: settings,
+ cache: { mode: options.cache, requests: [...requests.values()], warmup },
+ errors,
+ network,
+ server: {
+ responses: active.responses,
+ runtimeAttempts: active.runtimeAttempts,
+ unexpected: active.unexpected,
+ },
+ });
+ throw error;
+ } finally {
+ if (traceStarted)
+ await context.tracing.stop({
+ path: path.join(out, label + "-trace.zip"),
+ });
+ await context.close();
+ }
+}
+
+(async () => {
+ publisherOrigin = await listen();
+ creativeOrigin = await listen();
+ let browser;
+ try {
+ const allowedOrigins = [publisherOrigin, creativeOrigin];
+ evidence.interventions.push({
+ type: "exact-origin forwarding HTTP proxy",
+ allowedOrigins,
+ rejected: "all other origins and CONNECT; no browser bypass",
+ });
+ const proxy = fixtureProxy(allowedOrigins, (entry) => {
+ evidence.proxyRequests.push(
+ Object.assign(entry, {
+ sampleIndex: samples.length,
+ phase: active?.phase ?? "startup",
+ }),
+ );
+ });
+ servers.push(proxy);
+ await new Promise((resolve) => proxy.listen(0, "127.0.0.1", resolve));
+ browser = await chromium.launch({
+ headless: true,
+ proxy: {
+ server: `http://127.0.0.1:${proxy.address().port}`,
+ },
+ });
+ evidence.browser = browser.version();
+ evidence.origins = { publisherOrigin, creativeOrigin };
+ const mobile = { width: 390, height: 844 };
+ const desktop = { width: 1280, height: 1000 };
+ if (diagnosticOutages) {
+ for (const { profile, name, viewport, mode } of outageCases())
+ await sample(browser, profile, name, viewport, mode);
+ assertOutageSamples(samples);
+ } else if (diagnosticScreen) {
+ for (const { profile, name, viewport } of screenCases(runs))
+ await sample(browser, profile, name, viewport);
+ assertScreenSamples(samples, runs);
+ assert(
+ samples
+ .filter((entry) => ["baseline", "loading"].includes(entry.profile))
+ .every((entry) => entry.metrics.cls > 0),
+ "Unreserved diagnostic arms must reproduce ad-induced layout shift",
+ );
+ } else if (!options["correctness-only"] && !options["regressions-only"]) {
+ for (const { profile, name, viewport } of screenCases(runs))
+ await sample(browser, profile, name, viewport);
+ assertScreenSamples(samples, runs);
+ const shiftControls = samples.filter((entry) =>
+ ["baseline", "loading"].includes(entry.profile),
+ );
+ assert(
+ shiftControls.every((entry) => entry.metrics.cls > 0),
+ "Unreserved controls must visibly reproduce ad-induced layout shift",
+ );
+ }
+ if (!unifiedDiagnostic) {
+ stage = "correctness";
+ if (options["correctness-only"]) {
+ for (const viewport of [mobile, desktop]) {
+ const control = await sample(browser, "loading", "inline", viewport);
+ assert(
+ control.metrics.cls > 0,
+ "Unreserved control must visibly shift after fill",
+ );
+ }
+ }
+ const correctnessStart = samples.length;
+ for (const {
+ profile,
+ name,
+ viewport,
+ mode,
+ noFill = false,
+ control = null,
+ } of correctnessCases(options["regressions-only"]))
+ await sample(browser, profile, name, viewport, mode, noFill, control);
+ assertCorrectnessSamples(
+ samples.slice(correctnessStart),
+ options["regressions-only"],
+ );
+ }
+ const groups = {};
+ for (const entry of samples) {
+ const key = `${entry.stage}/${entry.profile}/${entry.name}/${entry.viewport.width}/${entry.mode}/${entry.noFill ? "nofill" : "fill"}${entry.control ? "/" + entry.control : ""}`;
+ (groups[key] ??= []).push(entry.metrics);
+ }
+ const summary = Object.fromEntries(
+ Object.entries(groups).map(([key, entries]) => [
+ key,
+ Object.fromEntries(
+ Object.keys(entries[0]).map((metric) => [
+ metric,
+ distribution(entries.map((entry) => entry[metric])),
+ ]),
+ ),
+ ]),
+ );
+ save("summary.json", summary);
+ const comparisons = {};
+ if (baseline)
+ for (const viewport of [mobile, desktop]) {
+ const reference =
+ summary[`measurement/baseline/inline/${viewport.width}/slow/fill`];
+ for (const profile of ["loading", "reservation", "combined"]) {
+ const changed =
+ summary[
+ `measurement/${profile}/inline/${viewport.width}/slow/fill`
+ ];
+ if (!reference || !changed) continue;
+ comparisons[`${profile}/${viewport.width}`] = Object.fromEntries(
+ Object.keys(reference).map((metric) => {
+ const before = reference[metric].median;
+ const after = changed[metric].median;
+ return [
+ metric,
+ {
+ baseline: before,
+ changed: after,
+ delta:
+ before === null || after === null ? null : after - before,
+ percent:
+ before === null || after === null || before === 0
+ ? null
+ : ((after - before) / before) * 100,
+ },
+ ];
+ }),
+ );
+ }
+ }
+ save("comparisons.json", comparisons);
+ console.log(
+ diagnosticScreen
+ ? "Diagnostic screen completed; raw timings retained. Full correctness, negative controls, framework/live gates and combined acceptance remain unexecuted."
+ : diagnosticOutages
+ ? "Four availability diagnostics completed for the approved critical-runtime contract. Full acceptance remains unexecuted."
+ : "CWV functional contracts passed; raw timings and ranges retained, no timing-improvement threshold applied.",
+ );
+ } finally {
+ evidence.finishedAt = new Date().toISOString();
+ saveOutcome();
+ await browser?.close();
+ await Promise.all(
+ servers.map((server) => new Promise((resolve) => server.close(resolve))),
+ );
+ }
+ acceptance.status = "passed";
+ acceptance.finishedAt = new Date().toISOString();
+ acceptance.reports = {
+ artifacts: "artifacts.json",
+ samples: "samples.json",
+ summary: "summary.json",
+ comparisons: "comparisons.json",
+ };
+ saveOutcome();
+})().catch((error) => {
+ recordFailure(error);
+ console.error(error);
+ process.exitCode = 1;
+});
diff --git a/crates/trusted-server-integration-tests/browser/cwv/runtime-order.cjs b/crates/trusted-server-integration-tests/browser/cwv/runtime-order.cjs
new file mode 100644
index 0000000000..f0f88550da
--- /dev/null
+++ b/crates/trusted-server-integration-tests/browser/cwv/runtime-order.cjs
@@ -0,0 +1,42 @@
+const assert = require("node:assert/strict");
+const { scriptBlocks } = require("./html.cjs");
+
+function assertRuntimeOrder(html, origin, placeholderId) {
+ const scripts = scriptBlocks(html);
+ const runtimes = scripts.filter((script) => script.id === "trustedserver-js");
+ assert.equal(runtimes.length, 1);
+ const runtime = runtimes[0];
+ assert.equal(
+ new URL(runtime.src, origin).pathname,
+ "/static/tsjs=tsjs-unified.min.js",
+ );
+ assert.doesNotMatch(
+ html.slice(runtime.startOffset, runtime.endOffset),
+ /\s(?:async|defer)(?:\s|=|>)/,
+ );
+ for (const config of [
+ "window.__tsjs_gpt_enabled=true",
+ "window.__tsjs_prebid=",
+ ]) {
+ const script = scripts.find((entry) => entry.content.includes(config));
+ assert.ok(script, `${config} must precede the synchronous runtime`);
+ assert.ok(script.endOffset <= runtime.startOffset);
+ }
+ assert.ok(runtime.endOffset <= html.indexOf(`id="${placeholderId}"`));
+ assert.equal(
+ scripts.some((script) => script.id === "trustedserver-bootstrap"),
+ false,
+ );
+ for (const api of [
+ "publisherSlotRegistrationVersion",
+ "tsRenderBridgeVersion",
+ ]) {
+ assert.equal(
+ scripts.some((script) => !script.src && script.content.includes(api)),
+ false,
+ `no inline ${api} fallback`,
+ );
+ }
+}
+
+module.exports = { assertRuntimeOrder };
diff --git a/crates/trusted-server-integration-tests/browser/cwv/runtime-order.test.cjs b/crates/trusted-server-integration-tests/browser/cwv/runtime-order.test.cjs
new file mode 100644
index 0000000000..6e04adfd57
--- /dev/null
+++ b/crates/trusted-server-integration-tests/browser/cwv/runtime-order.test.cjs
@@ -0,0 +1,80 @@
+const { test } = require("node:test");
+const assert = require("node:assert/strict");
+const { assertRuntimeOrder } = require("./runtime-order.cjs");
+
+const origin = "https://publisher.example.com";
+const configs = [
+ "window.__tsjs_gpt_enabled=true",
+ "window.__tsjs_prebid={}",
+].map((content) => ``);
+const runtime =
+ '';
+
+for (const placeholderId of [
+ "fixture-header-placeholder",
+ "real-gpt-placeholder",
+]) {
+ const placeholder = ``;
+ const html = configs.join("") + runtime + placeholder;
+
+ test(`${placeholderId}: accepts the synchronous runtime with explicit origin and placeholder`, () => {
+ assert.doesNotThrow(() => assertRuntimeOrder(html, origin, placeholderId));
+ assert.doesNotThrow(() =>
+ assertRuntimeOrder(
+ html.replace('src="/static/', 'src="static/'),
+ origin,
+ placeholderId,
+ ),
+ );
+ assert.throws(() => assertRuntimeOrder(html, "", placeholderId));
+ assert.throws(() => assertRuntimeOrder(html, origin, "wrong-placeholder"));
+ for (const api of [
+ "publisherSlotRegistrationVersion",
+ "tsRenderBridgeVersion",
+ ]) {
+ assert.doesNotThrow(() =>
+ assertRuntimeOrder(
+ html + ``,
+ origin,
+ placeholderId,
+ ),
+ );
+ }
+ });
+
+ const invalid = [
+ ["missing runtime", html.replace(runtime, "")],
+ ["duplicate runtime", html + runtime],
+ ["wrong runtime path", html.replace("tsjs-unified", "tsjs-gpt")],
+ ...["async", "defer"].map((attribute) => [
+ `${attribute} runtime`,
+ html.replace(
+ 'id="trustedserver-js"',
+ `${attribute} id="trustedserver-js"`,
+ ),
+ ]),
+ ...configs.flatMap((config, index) => [
+ [`missing config ${index}`, html.replace(config, "")],
+ [`late config ${index}`, html.replace(config, "") + config],
+ ]),
+ ["late runtime", configs.join("") + placeholder + runtime],
+ ["missing placeholder", html.replace(placeholder, "")],
+ [
+ "inline bootstrap",
+ html + '',
+ ],
+ ...["publisherSlotRegistrationVersion", "tsRenderBridgeVersion"].map(
+ (api) => [
+ `inline ${api} fallback`,
+ html + ``,
+ ],
+ ),
+ ];
+ for (const [name, invalidHtml] of invalid) {
+ test(`${placeholderId}: rejects ${name}`, () => {
+ assert.throws(() =>
+ assertRuntimeOrder(invalidHtml, origin, placeholderId),
+ );
+ });
+ }
+}
diff --git a/crates/trusted-server-integration-tests/browser/helpers/infra.ts b/crates/trusted-server-integration-tests/browser/helpers/infra.ts
index 0402bb266e..0d4ca40943 100644
--- a/crates/trusted-server-integration-tests/browser/helpers/infra.ts
+++ b/crates/trusted-server-integration-tests/browser/helpers/infra.ts
@@ -1,6 +1,8 @@
import { execFileSync, spawn, type ChildProcess } from "node:child_process";
import { setTimeout as setTimeoutPromise } from "node:timers/promises";
import { createServer } from "node:net";
+import { createWriteStream, mkdirSync } from "node:fs";
+import { join } from "node:path";
import { waitForReady } from "./wait-for-ready.js";
const ORIGIN_PORT = process.env.INTEGRATION_ORIGIN_PORT || "8888";
@@ -55,7 +57,7 @@ export async function startContainer(framework: string): Promise${text}
`;
+ } else {
+ response.writeHead(404).end();
+ return;
+ }
+ response.writeHead(200, { "content-type": "text/html" });
+ response.end(`${style}${body}`);
+ });
+ servers.push(server);
+ await new Promise((resolve) => server.listen(0, "127.0.0.1", resolve));
+ origins.push(`http://127.0.0.1:${server.address().port}`);
+ }
+ browser = await chromium.launch();
+ const page = await browser.newPage({
+ viewport: { width: 900, height: 800 },
+ });
+ const external = [];
+ await page.route("**/*", (route) => {
+ if (origins.includes(new URL(route.request().url()).origin))
+ return route.continue();
+ external.push(route.request().url());
+ return route.abort();
+ });
+ for (const cross of [false, true]) {
+ await t.test(
+ cross ? "cross-origin chain" : "same-origin chain",
+ async () => {
+ for (const [y, expected] of [
+ [200, false],
+ [40, true],
+ [20, true],
+ ]) {
+ await page.goto(`${origins[0]}/top?cross=${Number(cross)}&y=${y}`);
+ const frame = page
+ .frames()
+ .find((entry) => new URL(entry.url()).pathname === "/inner");
+ assert.ok(frame);
+ assert.equal(
+ new URL(frame.parentFrame().url()).origin,
+ origins[cross ? 1 : 0],
+ );
+ const element = await frame.locator(".marker").elementHandle();
+ // The old independent viewport checks accepted this exact clipped case.
+ const locallyVisible = await element.evaluate((node) => {
+ const rect = node.getBoundingClientRect();
+ return rect.top < innerHeight && rect.bottom > 0;
+ });
+ assert.equal(locallyVisible, true);
+ assert.equal(
+ await visiblyPainted(await frame.parentFrame().frameElement()),
+ true,
+ );
+ assert.equal(
+ await visiblyPainted(element),
+ expected,
+ `marker y=${y}, cross=${cross}`,
+ );
+ assert.equal(await marker(page, text, "placement"), expected);
+ }
+ const outer = page.locator("#placement > iframe");
+ for (const css of [
+ "opacity:0",
+ "visibility:hidden",
+ "display:none",
+ "content-visibility:hidden",
+ ]) {
+ await outer.evaluate(
+ (node, css) => (node.style.cssText = `top:750px;${css}`),
+ css,
+ );
+ assert.equal(await marker(page, text, "placement"), false, css);
+ }
+ await outer.evaluate((node) => (node.style.cssText = "top:750px"));
+ assert.equal(await marker(page, text, "placement"), true);
+ await page
+ .locator("#placement")
+ .evaluate(
+ (node) =>
+ (node.style.cssText =
+ "position:absolute;top:0;height:760px;width:300px;overflow:hidden"),
+ );
+ assert.equal(
+ await marker(page, text, "placement"),
+ false,
+ "ancestor overflow clips marker but leaves part of frame visible",
+ );
+ },
+ );
+ }
+ assert.deepEqual(external, []);
+ } finally {
+ await browser?.close();
+ await Promise.all(
+ servers.map((server) => new Promise((resolve) => server.close(resolve))),
+ );
+ }
+});
diff --git a/crates/trusted-server-integration-tests/browser/publisher-registration/pages.cjs b/crates/trusted-server-integration-tests/browser/publisher-registration/pages.cjs
new file mode 100644
index 0000000000..aa6e0d3399
--- /dev/null
+++ b/crates/trusted-server-integration-tests/browser/publisher-registration/pages.cjs
@@ -0,0 +1,65 @@
+const { creative } = require("../initial-render/pages.cjs");
+
+function inlineJson(value) {
+ return JSON.stringify(value)
+ .replaceAll("<", "\\u003c")
+ .replaceAll(">", "\\u003e")
+ .replaceAll("&", "\\u0026")
+ .replaceAll("\u2028", "\\u2028")
+ .replaceAll("\u2029", "\\u2029");
+}
+
+function pucPage(publisherOrigin = "https://publisher.example.com") {
+ return ``;
+}
+
+// Direct-payload offline cases only. Framework proof must use Rust-injected data.
+function payload({ registered = true, two = false, candidate = "fit" } = {}) {
+ const slots = (two ? ["header", "sidebar"] : ["header"]).map((id) => ({
+ id,
+ gam_unit_path: "/123/example-placement",
+ div_id: "example-" + id + "-",
+ formats: [
+ [300, 250],
+ [300, 600],
+ ],
+ ...(registered ? { initialization: "publisher_registered" } : {}),
+ targeting: { example_section: ["fiction"] },
+ }));
+ const bids = Object.fromEntries(
+ slots.map((slot) => [
+ slot.id,
+ candidate === "none"
+ ? {}
+ : {
+ hb_adid: "example-ad-" + slot.id,
+ hb_bidder: "exampleServer",
+ hb_pb: "1.00",
+ ...(candidate !== "unknown"
+ ? { w: 300, h: candidate === "incompatible" ? 600 : 250 }
+ : {}),
+ adm: creative("Server result"),
+ nurl:
+ "https://publisher.example.com/fixture-notice/win?slot=" +
+ slot.id,
+ burl:
+ "https://publisher.example.com/fixture-notice/bill?slot=" +
+ slot.id,
+ },
+ ]),
+ );
+ return { slots, bids };
+}
+
+function documentPage(data = {}) {
+ return `Publisher registration contract
+`; +} + +module.exports = { inlineJson, payload, documentPage, creative, pucPage }; diff --git a/crates/trusted-server-integration-tests/browser/publisher-registration/pages.test.cjs b/crates/trusted-server-integration-tests/browser/publisher-registration/pages.test.cjs new file mode 100644 index 0000000000..3dd8f2fa3b --- /dev/null +++ b/crates/trusted-server-integration-tests/browser/publisher-registration/pages.test.cjs @@ -0,0 +1,224 @@ +const assert = require("node:assert/strict"); +const fs = require("node:fs"); +const vm = require("node:vm"); +const test = require("node:test"); +const { JSDOM } = require("jsdom"); +const { + inlineJson, + documentPage, + payload, + creative, + pucPage, +} = require("./pages.cjs"); +const source = fs.readFileSync(require.resolve("./gpt-fixture.js"), "utf8"); + +function fixture(initialLoad = "disabled") { + const elements = new Map( + ["example-header-final", "unrelated"].map((id) => [ + id, + { id, isConnected: true }, + ]), + ); + const window = { + publisherFixtureOptions: { initialLoad }, + addEventListener() {}, + }; + vm.runInNewContext(source, { + window, + document: { getElementById: (id) => elements.get(id) }, + performance: { now: () => 0 }, + }); + const g = window.googletag; + const slot = g + .defineSlot("/123/example-placement", [[300, 250]], "example-header-final") + .addService(g.pubads()); + const unrelated = g + .defineSlot("/123/unrelated", [[300, 250]], "unrelated") + .addService(g.pubads()); + g.pubads().enableSingleRequest(); + g.enableServices(); + return { g, f: window.fixture, window, slot, unrelated }; +} + +test("inline JSON cannot terminate its script, including line separators", () => { + const input = { + id: '&\u2028\u2029', + }; + assert.deepEqual(JSON.parse(inlineJson(input)), input); + assert(!/[<>&\u2028\u2029]/u.test(inlineJson(input))); + for (const id of [ + input.id, + '', + ]) { + const html = documentPage({ id }); + assert.equal((html.match(/&"; + const html = pucPage(origin); + assert.equal((html.match(/"# + ) +} + +fn origin_page(absent: bool, replacement: bool, registered: bool) -> String { + let slot = if absent { + "" + } else { + ""
+ };
+ let replacement = if replacement {
+ "document.getElementById('fixture-ad-space').innerHTML='';"
+ } else {
+ ""
+ };
+ let registration = if registered {
+ "googletag.cmd.push(function(){googletag.setConfig({disableInitialLoad:true});googletag.enableServices();var s=googletag.defineSlot('/123456789/fixture-header',[[300,250]],'fixture-ad').addService(googletag.pubads());s.setTargeting('publisher_key','keep');window.fixturePublisherSlot=s;window.fixtureHandle=tsjs.registerPublisherSlot({slotId:'fixture-header',gptSlot:s,navigationGeneration:tsjs.navGeneration||0,eligibleFormats:[[300,250]]});});"
+ } else {
+ ""
+ };
+ format!(
+ r#"
Fictional article
{slot}
Readable article content
This fixed fictional article makes ad-space movement visible.
Fixture publisher registration winner
',
+ adomain: ["advertiser.example.com"],
+ crid: `fixture-creative-300x${height}`,
+ w: 300,
+ h: height,
+ ext: { prebid: { type: "banner", bidder: "fixture-bidder" } },
+ })),
+ },
+ ],
+ };
+ exchanges.push({
+ path: request.nextUrl.pathname,
+ request: auction,
+ response,
+ mode,
+ });
+ console.log(
+ JSON.stringify({ fixtureAuction: exchanges[exchanges.length - 1] }),
+ );
+ return NextResponse.json(response);
+}
diff --git a/crates/trusted-server-integration-tests/fixtures/frameworks/nextjs/app/publisher-registration-real-gpt/RealGptPublisher.tsx b/crates/trusted-server-integration-tests/fixtures/frameworks/nextjs/app/publisher-registration-real-gpt/RealGptPublisher.tsx
new file mode 100644
index 0000000000..6fe6d4c82b
--- /dev/null
+++ b/crates/trusted-server-integration-tests/fixtures/frameworks/nextjs/app/publisher-registration-real-gpt/RealGptPublisher.tsx
@@ -0,0 +1,347 @@
+"use client";
+
+import { useLayoutEffect, useRef, useState } from "react";
+import { usePathname, useRouter } from "next/navigation";
+
+export type RealGptInventory = {
+ registered: { path: string };
+ unrelated: { path: string };
+};
+type Slot = {
+ addService(service: Service): Slot;
+ setTargeting(key: string, value: string): Slot;
+ getSlotElementId(): string;
+ getAdUnitPath(): string;
+ getTargetingKeys(): string[];
+ getTargeting(key: string): string[];
+};
+type Service = {
+ disableInitialLoad(): void;
+ enableSingleRequest(): void;
+ refresh(slots: Slot[]): void;
+ getSlots(): Slot[];
+ addEventListener(
+ type: string,
+ callback: (event: {
+ slot: Slot;
+ creativeId?: number;
+ sourceAgnosticCreativeId?: number;
+ isEmpty?: boolean;
+ size?: number[];
+ }) => void,
+ ): void;
+};
+type Handle = {
+ cancel(): void;
+ getStatus(): { status: string; reason?: string };
+};
+type Tag = {
+ cmd: { push(callback: () => void): unknown };
+ pubads(): Service;
+ defineSlot(path: string, sizes: number[][], id: string): Slot | null;
+ destroySlots(slots: Slot[]): boolean;
+ display(id: string): void;
+ enableServices(): void;
+};
+type Current = Window & {
+ googletag: Tag;
+ tsjs?: {
+ navGeneration?: number;
+ registerPublisherSlot(options: {
+ slotId: string;
+ gptSlot: Slot;
+ navigationGeneration: number;
+ eligibleFormats: number[][];
+ }): Handle;
+ };
+ pbjs?: {
+ addAdUnits(
+ units: Array<{
+ code: string;
+ mediaTypes: { banner: { sizes: number[][] } };
+ bids: Array<{ bidder: string; params: { placement: string } }>;
+ }>,
+ ): void;
+ removeAdUnit(code: string): void;
+ };
+ realGptPublisher?: Controller;
+ realGptObservation?: { events: ArrayDedicated real GPT publisher registration acceptance
+{pathname}
+ + + +
+ {placement ? (
+
+ ) : (
+
+
+
+ Publisher has not registered
+
+ )}
+ Publisher registration framework fixture
+{pathname}
+ + + + + +
+ {mounted ? (
+
+
+
+
+ Publisher has not registered
+
+ )}
+