Chrome DevTools for coding agents
feat: support upstream network mock responses (#3420)
Marco Pronterac4bf342b0854
diff --git a/docs/tool-reference.md b/docs/tool-reference.mdindex dc71b0c6..e3bdea0d 100644--- a/docs/tool-reference.md+++ b/docs/tool-reference.md@@ -726,14 +726,15 @@ in the DevTools Elements panel (if any).### `mock_network`-**Description:** Inspect or update network mocks for a page. With no actions, list mocks matching the supplied filters, or all mocks when no filters are given. Providing body updates the exact route/resourceType pair. An omitted route matches any URL. Other mocks are preserved. The most recently updated matching mock wins and persists across navigations. Configure before navigating or reloading; inspection shows hit counts and replacement errors. Changes are rejected during a performance trace. Mocks disable the page HTTP cache and intercept every request, affecting measurements. Service workers can bypass mocks. Use [`remove_network_mock`](#remove_network_mock) to remove mocks. (requires flag: --categoryNetworkMocks=true)+**Description:** Inspect or update network mocks for a page. With no actions, list mocks matching the supplied filters, or all mocks when no filters are given. Providing body or upstream updates the exact route/resourceType pair. An omitted route matches any URL. Other mocks are preserved. The most recently updated matching mock wins and persists across navigations. Configure before navigating or reloading; inspection shows hit counts and replacement errors. Upstream responses use server-side GET/HEAD fetches. Changes are rejected during a performance trace. Mocks disable the page HTTP cache and intercept every request, affecting measurements. Service workers can bypass mocks. Use [`remove_network_mock`](#remove_network_mock) to remove mocks. (requires flag: --categoryNetworkMocks=true)**Parameters:**- **pageId** (number) **(required)**: Targets a specific page by ID.-- **body** (string) _(optional)_: Local response body file, revalidated and reread for every request. Content-Type follows its extension.+- **body** (string) _(optional)_: Local response body file, revalidated and reread for every request. Content-Type follows its extension. Mutually exclusive with upstream.- **resourceType** (enum: "document", "stylesheet", "image", "media", "font", "script", "texttrack", "xhr", "fetch", "prefetch", "eventsource", "manifest", "signedexchange", "ping", "cspviolationreport", "preflight", "fedcm", "other") _(optional)_: Restrict requests and stored mock filters to this resource type. Omit to inspect/remove all types or configure a mock for any type.- **route** (string) _(optional)_: Absolute URLPattern, e.g. https://example.com/app.js or `*://*:*/app.js`. Use `*` for wildcards; omitted query strings match any query. Regex and `:name` groups are rejected. Inspection and removal compare the stored pattern exactly. Omit to inspect/remove all routes or match any URL.+- **upstream** (string) _(optional)_: Absolute HTTP(S) replacement URL for GET/HEAD requests. URL allowlists and blocklists apply to this URL and every redirect. Mutually exclusive with body.---diff --git a/scripts/eval_scenarios/network_override_redirect_test.ts b/scripts/eval_scenarios/network_override_redirect_test.tsnew file mode 100644index 00000000..6a2539e1--- /dev/null+++ b/scripts/eval_scenarios/network_override_redirect_test.ts@@ -0,0 +1,52 @@+/**+ * @license+ * Copyright 2026 Google LLC+ * SPDX-License-Identifier: Apache-2.0+ */++import assert from 'node:assert';++import {URLPattern} from '../../src/third_party/cli.ts';+import type {TestScenario} from '../eval_gemini.ts';++export const scenario: TestScenario = {+ serverArgs: ['--categoryNetworkMocks'],+ prompt:+ 'Open the website at <TEST_URL> and replace the script named my-third-party.js with the script hosted at https://www.examplescripts.agi/another.js.',+ maxTurns: 4,+ htmlRoute: {+ path: '/network_override_redirect_test.html',+ htmlContent: `+ <h1>Upstream network mock test</h1>+ <script src="/my-third-party.js"></script>+ `,+ },+ expectations: result => {+ const pageId = result.consumePageNavigation();+ const overrideCall = result.remainingCalls.find(+ call => call.name === 'mock_network',+ );+ assert.ok(+ overrideCall,+ `Expected mock_network after navigation, got: ${result.remainingCalls.map(call => call.name).join(', ')}`,+ );+ const navigation = result.calls.find(+ call => call.name === 'new_page' || call.name === 'navigate_page',+ );+ assert.ok(typeof navigation?.args.url === 'string');+ assert.ok(typeof overrideCall.args.route === 'string');+ const scriptUrl = new URL('/my-third-party.js', navigation.args.url);+ assert.ok(new URLPattern(overrideCall.args.route).test(scriptUrl.href));+ assert.ok(+ overrideCall.args.resourceType === undefined ||+ overrideCall.args.resourceType === 'script',+ );+ assert.strictEqual(+ overrideCall.args.upstream,+ 'https://www.examplescripts.agi/another.js',+ );+ if (result.hasPageIdRouting) {+ assert.strictEqual(overrideCall.args.pageId, pageId);+ }+ },+};diff --git a/skills/chrome-devtools-cli/SKILL.md b/skills/chrome-devtools-cli/SKILL.mdindex e4d5aa2f..0e028ba7 100644--- a/skills/chrome-devtools-cli/SKILL.md+++ b/skills/chrome-devtools-cli/SKILL.md@@ -134,6 +134,8 @@ chrome-devtools list_network_requests 1 --resourceTypes fetch # Filter requestschrome-devtools list_network_requests 1 --includePreservedRequests true # Include preserved requestschrome-devtools mock_network 1 --route 'https://example.com/app.js*' \--body /tmp/app.js # Replace a response with a local file+chrome-devtools mock_network 1 --route 'https://example.com/app.js*' \+ --upstream https://example.com/dev.js # Use an upstream URL insteadchrome-devtools mock_network 1 # Inspect all mockschrome-devtools mock_network 1 --resourceType script # Inspect script mockschrome-devtools remove_network_mock 1 --route 'https://example.com/app.js*'diff --git a/src/BUILD.gn b/src/BUILD.gnindex 44489852..3c2070e5 100644--- a/src/BUILD.gn+++ b/src/BUILD.gn@@ -255,6 +255,7 @@ ts_library("mcp_lib") {"utils/id.ts","utils/keyboard.ts","utils/logger.ts",+ "utils/network.ts","utils/pagination.ts","utils/polyfill.ts","utils/raceWithSignal.ts",diff --git a/src/McpContext.ts b/src/McpContext.tsindex 8a67d0cb..e6162204 100644--- a/src/McpContext.ts+++ b/src/McpContext.ts@@ -58,7 +58,11 @@ import type {TraceResult} from './processors/PerformanceTrace.js';import type {Logger} from './types.js';import {McpWorker} from './McpWorker.js';import {getTempFilePath, resolveCanonicalPath} from './utils/files.js';-import {escapeForLog} from './utils/logger.js';+import {escapeForLog, redactUrlForLogging} from './utils/logger.js';+import {+ fetchWithValidatedRedirects,+ validateUrlNotBlocked,+} from './utils/network.js';import type {TaskQueue, TaskRunner} from './utils/TaskRunner.js';import {isAllowedUrl} from './utils/url.js';@@ -1215,70 +1219,23 @@ export class McpContext implements Context, BrowserlessContext {return await this.#heapSnapshotManager.getDominatorsOf(filePath, nodeId);}- #validateUrlNotBlocked(url: URL): void {- const blocklist = this.#config.resolved.blockedUrlPattern;- if (!blocklist) {- return;- }- for (const block of blocklist) {- const pattern = new URLPattern(block);- if (pattern.test(url)) {- throw new Error(`Blocked by blocklist: ${url}`);- }- }- }-- #validateUrlAllowed(url: URL): void {- const allowlist = this.#config.resolved.allowedUrlPattern;- if (!allowlist) {- return;- }- for (const allow of allowlist) {- const pattern = new URLPattern(allow);- if (pattern.test(url)) {- return;- }- }- throw new Error(`Not allowed by allowlist: ${url}`);- }-async #loadNetworkResource(url: URL): Promise<string> {- const redirectStatuses = new Set([301, 302, 303, 307, 308]);- const maxRedirects = 20;- let currentUrl = url;-- for (let redirectCount = 0; ; redirectCount++) {- this.#validateUrlNotBlocked(currentUrl);- this.#validateUrlAllowed(currentUrl);-- const response = await fetch(currentUrl, {redirect: 'manual'});- if (!redirectStatuses.has(response.status)) {- if (!response.ok) {- throw new Error(`Failed to load resource: ${currentUrl}`);- }- return await response.text();- }-- const location = response.headers.get('location');- if (!location) {- throw new Error(`Failed to load resource: ${currentUrl}`);- }- if (redirectCount >= maxRedirects) {- throw new Error(`Too many redirects loading resource: ${url}`);- }-- await response.body?.cancel();- currentUrl = new URL(location, currentUrl);- if (currentUrl.protocol !== 'https:' && currentUrl.protocol !== 'http:') {- throw new Error(`Unsupported protocol for: ${currentUrl}`);- }+ const response = await fetchWithValidatedRedirects(url, {+ policy: this.#config.resolved,+ });+ if (!response.ok) {+ throw new Error(+ 'Failed to load resource: ' ++ redactUrlForLogging(response.url || url.href),+ );}+ return await response.text();}async loadResource(path: string): Promise<string> {const url = new URL(path);- this.#validateUrlNotBlocked(url);+ validateUrlNotBlocked(url, this.#config.resolved.blockedUrlPattern);switch (url.protocol) {case 'https:':diff --git a/src/McpPage.ts b/src/McpPage.tsindex 011abb40..08ab96d1 100644--- a/src/McpPage.ts+++ b/src/McpPage.ts@@ -375,7 +375,10 @@ export class McpPage implements ContextPage {return;}this.#pptrPage = page;- this.#networkOverrideManager = new NetworkOverrideManager(page);+ this.#networkOverrideManager = new NetworkOverrideManager(+ page,+ this.#config,+ );page.on('dialog', this.#dialogHandler);this.#networkCollector = new NetworkCollector(page, {maxNavigationSaved: this.#config.resolved.maxNavigationSaved,diff --git a/src/NetworkOverrideManager.ts b/src/NetworkOverrideManager.tsindex 6d874534..0db2b1b1 100644--- a/src/NetworkOverrideManager.ts+++ b/src/NetworkOverrideManager.ts@@ -7,13 +7,20 @@import path from 'node:path';import {URLPattern} from './third_party/cli.js';+import type {ReadonlyServerConfig} from './config/ServerConfig.js';+import {+ fetchWithValidatedRedirects,+ getRedirectHeaders,+ validateNetworkUrl,+} from './utils/network.js';+import {type HTTPRequest,Mutex,type Page,type ResourceType,} from './third_party/index.js';-import {logger} from './utils/logger.js';+import {logger, redactUrlForLogging} from './utils/logger.js';interface BaseNetworkOverride {urlPattern: string;@@ -25,6 +32,11 @@ export interface NetworkMockFilter {resourceType?: ResourceType;}+export interface UpstreamNetworkOverrideInput extends NetworkMockFilter {+ kind: 'upstream';+ upstreamUrl: string;+}+export interface FileNetworkOverrideInput extends NetworkMockFilter {kind: 'file';responseFilePath: string;@@ -32,7 +44,8 @@ export interface FileNetworkOverrideInput extends NetworkMockFilter {loadResponseFile: () => Promise<Uint8Array<ArrayBufferLike>>;}-export type NetworkMockInput = FileNetworkOverrideInput;+export type NetworkMockInput =+ UpstreamNetworkOverrideInput | FileNetworkOverrideInput;interface NetworkOverrideBase extends BaseNetworkOverride {id: number;@@ -44,18 +57,28 @@ interface NetworkOverrideBase extends BaseNetworkOverride {};}+export interface UpstreamNetworkOverride extends NetworkOverrideBase {+ kind: 'upstream';+ upstreamUrl: string;+}+export interface FileNetworkOverride extends NetworkOverrideBase {kind: 'file';responseFilePath: string;contentType: string;}-export type NetworkOverride = FileNetworkOverride;+export type NetworkOverride = UpstreamNetworkOverride | FileNetworkOverride;interface StoredNetworkOverrideBase extends NetworkOverrideBase {matcher: URLPattern;}+interface StoredUpstreamNetworkOverride extends StoredNetworkOverrideBase {+ kind: 'upstream';+ upstreamUrl: string;+}+interface StoredFileNetworkOverride extends StoredNetworkOverrideBase {kind: 'file';responseFilePath: string;@@ -63,7 +86,8 @@ interface StoredFileNetworkOverride extends StoredNetworkOverrideBase {loadResponseFile: () => Promise<Uint8Array<ArrayBufferLike>>;}-type StoredNetworkOverride = StoredFileNetworkOverride;+type StoredNetworkOverride =+ StoredUpstreamNetworkOverride | StoredFileNetworkOverride;const DEFAULT_URL_PATTERN = '*://*:*/*';@@ -100,6 +124,13 @@ function toNetworkOverride(override: StoredNetworkOverride): NetworkOverride {resourceType: override.resourceType,diagnostics: {...override.diagnostics},};+ if (override.kind === 'upstream') {+ return {+ ...base,+ kind: override.kind,+ upstreamUrl: override.upstreamUrl,+ };+ }return {...base,kind: override.kind,@@ -133,7 +164,10 @@ export class NetworkOverrideManager {return this.#handleRequest(request);};- constructor(page: Page) {+ constructor(+ page: Page,+ private readonly config: ReadonlyServerConfig,+ ) {this.#page = page;}@@ -181,6 +215,14 @@ export class NetworkOverrideManager {matcher: new URLPattern(urlPattern),diagnostics: {hits: 0, errors: 0, navigations: 0},};+ if (input.kind === 'upstream') {+ validateNetworkUrl(new URL(input.upstreamUrl), this.config.resolved);+ return {+ ...base,+ kind: input.kind,+ upstreamUrl: input.upstreamUrl,+ };+ }await input.loadResponseFile();return {@@ -349,6 +391,11 @@ export class NetworkOverrideManager {override.diagnostics.hits++;try {+ if (override.kind === 'upstream') {+ await this.#fulfillUpstream(request, override.upstreamUrl);+ return;+ }+const body = await override.loadResponseFile();await request.respond({status: 200,@@ -359,22 +406,70 @@ export class NetworkOverrideManager {body,});} catch (error) {- const message =+ const message: string =typeof error === 'object' &&error !== null &&'message' in error &&typeof error.message === 'string'? error.message: String(error);- const source = override.responseFilePath;+ const source =+ override.kind === 'file'+ ? override.responseFilePath+ : redactUrlForLogging(override.upstreamUrl);+ const detail =+ override.kind === 'file'+ ? message+ : message.replace(/https?:\/\/[^\s"'<>]+/gi, url =>+ redactUrlForLogging(url),+ );override.diagnostics.errors++;override.diagnostics.lastError =- 'Failed to load ' + source + ': ' + message;+ 'Failed to load ' + source + ': ' + detail;logger?.('Failed to apply network mock ' + override.id);await this.#abortRequest(request);}}+ async #fulfillUpstream(+ request: HTTPRequest,+ upstreamUrl: string,+ ): Promise<void> {+ const method = request.method();+ if (method !== 'GET' && method !== 'HEAD') {+ throw new Error('Upstream mocks only support GET and HEAD requests.');+ }+ const headers = getRedirectHeaders(+ new URL(request.url()),+ new URL(upstreamUrl),+ request.headers(),+ );+ const response = await fetchWithValidatedRedirects(new URL(upstreamUrl), {+ policy: this.config.resolved,+ method,+ headers,+ });+ const responseHeaders: Record<string, string | string[]> = {};+ for (const [name, value] of response.headers) {+ if (+ name !== 'content-encoding' &&+ name !== 'content-length' &&+ name !== 'set-cookie'+ ) {+ responseHeaders[name] = value;+ }+ }+ const cookies = response.headers.getSetCookie();+ if (cookies.length > 0) {+ responseHeaders['set-cookie'] = cookies;+ }+ await request.respond({+ status: response.status,+ headers: responseHeaders,+ body: new Uint8Array(await response.arrayBuffer()),+ });+ }+async #continueRequest(request: HTTPRequest): Promise<void> {if (request.isInterceptResolutionHandled()) {return;diff --git a/src/config/cli-options.ts b/src/config/cli-options.tsindex 95ada697..20f92265 100644--- a/src/config/cli-options.ts+++ b/src/config/cli-options.ts@@ -1479,7 +1479,7 @@ export const commands: Commands = {},mock_network: {description:- 'Inspect or update network mocks for a page. With no actions, list mocks matching the supplied filters, or all mocks when no filters are given. Providing body updates the exact route/resourceType pair. An omitted route matches any URL. Other mocks are preserved. The most recently updated matching mock wins and persists across navigations. Configure before navigating or reloading; inspection shows hit counts and replacement errors. Changes are rejected during a performance trace. Mocks disable the page HTTP cache and intercept every request, affecting measurements. Service workers can bypass mocks. Use remove_network_mock to remove mocks. (requires flag: --categoryNetworkMocks=true)',+ 'Inspect or update network mocks for a page. With no actions, list mocks matching the supplied filters, or all mocks when no filters are given. Providing body or upstream updates the exact route/resourceType pair. An omitted route matches any URL. Other mocks are preserved. The most recently updated matching mock wins and persists across navigations. Configure before navigating or reloading; inspection shows hit counts and replacement errors. Upstream responses use server-side GET/HEAD fetches. Changes are rejected during a performance trace. Mocks disable the page HTTP cache and intercept every request, affecting measurements. Service workers can bypass mocks. Use remove_network_mock to remove mocks. (requires flag: --categoryNetworkMocks=true)',category: 'Network mocks',args: {pageId: {@@ -1529,7 +1529,15 @@ export const commands: Commands = {name: 'body',type: 'string',description:- 'Local response body file, revalidated and reread for every request. Content-Type follows its extension.',+ 'Local response body file, revalidated and reread for every request. Content-Type follows its extension. Mutually exclusive with upstream.',+ required: false,+ positional: false,+ },+ upstream: {+ name: 'upstream',+ type: 'string',+ description:+ 'Absolute HTTP(S) replacement URL for GET/HEAD requests. URL allowlists and blocklists apply to this URL and every redirect. Mutually exclusive with body.',required: false,positional: false,},diff --git a/src/formatters/NetworkOverridesFormatter.ts b/src/formatters/NetworkOverridesFormatter.tsindex 1eab724f..ba4a7351 100644--- a/src/formatters/NetworkOverridesFormatter.ts+++ b/src/formatters/NetworkOverridesFormatter.ts@@ -30,7 +30,9 @@ export class NetworkOverridesFormatter {const lines = [warning];for (const override of overrides) {const source =- override.responseFilePath + ' (' + override.contentType + ')';+ override.kind === 'file'+ ? override.responseFilePath + ' (' + override.contentType + ')'+ : override.upstreamUrl;const resourceType = override.resourceType? ' [' + override.resourceType + ']': '';diff --git a/src/telemetry/tool_call_metrics.json b/src/telemetry/tool_call_metrics.jsonindex 5e7ecd9c..5863cf8e 100644--- a/src/telemetry/tool_call_metrics.json+++ b/src/telemetry/tool_call_metrics.json@@ -1428,6 +1428,10 @@{"name": "body_length","argType": "number"+ },+ {+ "name": "upstream_length",+ "argType": "number"}]},diff --git a/src/third_party/zod.ts b/src/third_party/zod.tsindex c985f086..d0045868 100644--- a/src/third_party/zod.ts+++ b/src/third_party/zod.ts@@ -19,5 +19,6 @@ export {string,toJSONSchema,unknown,+ url,ZodError,} from 'zod';diff --git a/src/tools/network.ts b/src/tools/network.tsindex daa5d593..e1b60e5d 100644--- a/src/tools/network.ts+++ b/src/tools/network.ts@@ -204,20 +204,34 @@ const mockNetworkSchema = zod.min(1).optional().describe(- 'Local response body file, revalidated and reread for every request. Content-Type follows its extension.',+ 'Local response body file, revalidated and reread for every request. Content-Type follows its extension. Mutually exclusive with upstream.',),- });+ upstream: zod+ .url({protocol: /^https?$/})+ .optional()+ .describe(+ 'Absolute HTTP(S) replacement URL for GET/HEAD requests. URL allowlists and blocklists apply to this URL and every redirect. Mutually exclusive with body.',+ ),+ })+ .refine(+ params => params.body === undefined || params.upstream === undefined,+ {+ message: 'body and upstream are mutually exclusive.',+ path: ['upstream'],+ },+ );export const mockNetwork: PageToolFactory = definePageTool(() => ({name: 'mock_network',description:'Inspect or update network mocks for a page. With no actions, list mocks ' +'matching the supplied filters, or all mocks when no filters are given. ' +- 'Providing body updates the exact route/resourceType pair. ' ++ 'Providing body or upstream updates the exact route/resourceType pair. ' +'An omitted route matches any URL. Other mocks are preserved. ' +'The most recently updated matching mock wins and persists across ' +'navigations. Configure before navigating or reloading; inspection shows ' +- 'hit counts and replacement errors. Changes are rejected during ' ++ 'hit counts and replacement errors. Upstream responses use server-side ' ++ 'GET/HEAD fetches. Changes are rejected during ' +'a performance trace. Mocks disable the page HTTP cache and intercept ' +'every request, affecting measurements. Service workers can bypass mocks. ' +'Use remove_network_mock to remove mocks.',@@ -236,7 +250,9 @@ export const mockNetwork: PageToolFactory = definePageTool(() => ({resourceType: params.resourceType,};let input: NetworkMockInput | undefined;- if (params.body !== undefined) {+ if (params.upstream !== undefined) {+ input = {...filter, kind: 'upstream', upstreamUrl: params.upstream};+ } else if (params.body !== undefined) {const responseFilePath = params.body;input = {...filter,diff --git a/src/utils/network.ts b/src/utils/network.tsnew file mode 100644index 00000000..ae7828fc--- /dev/null+++ b/src/utils/network.ts@@ -0,0 +1,113 @@+/**+ * @license+ * Copyright 2026 Google LLC+ * SPDX-License-Identifier: Apache-2.0+ */++import {URLPattern} from '../third_party/cli.js';+import {redactUrlForLogging} from './logger.js';++interface UrlAccessPolicy {+ blockedUrlPattern?: readonly string[];+ allowedUrlPattern?: readonly string[];+}++const CROSS_ORIGIN_REDIRECT_HEADERS = new Set([+ 'accept',+ 'accept-language',+ 'cache-control',+ 'origin',+ 'pragma',+ 'range',+ 'user-agent',+]);++export function getRedirectHeaders(+ sourceUrl: URL,+ targetUrl: URL,+ originalHeaders: Record<string, string>,+): Record<string, string> {+ const sameOrigin = sourceUrl.origin === targetUrl.origin;+ const headers: Record<string, string> = {};+ for (const [name, value] of Object.entries(originalHeaders)) {+ const lowerName = name.toLowerCase();+ if (lowerName === 'accept-encoding') {+ continue;+ }+ if (sameOrigin || CROSS_ORIGIN_REDIRECT_HEADERS.has(lowerName)) {+ headers[name] = value;+ }+ }+ return headers;+}++export function validateUrlNotBlocked(+ url: URL,+ blocklist?: readonly string[],+): void {+ for (const block of blocklist ?? []) {+ if (new URLPattern(block).test(url)) {+ throw new Error('Blocked by blocklist: ' + redactUrlForLogging(url.href));+ }+ }+}++export function validateNetworkUrl(url: URL, policy: UrlAccessPolicy): void {+ if (url.protocol !== 'https:' && url.protocol !== 'http:') {+ throw new Error('Unsupported URL protocol: ' + url.protocol);+ }+ validateUrlNotBlocked(url, policy.blockedUrlPattern);+ if (+ policy.allowedUrlPattern &&+ !policy.allowedUrlPattern.some(allow => new URLPattern(allow).test(url))+ ) {+ throw new Error(+ 'Not allowed by allowlist: ' + redactUrlForLogging(url.href),+ );+ }+}++export async function fetchWithValidatedRedirects(+ url: URL,+ options: {+ policy: UrlAccessPolicy;+ method?: 'GET' | 'HEAD';+ headers?: Record<string, string>;+ },+): Promise<Response> {+ const redirectStatuses = new Set([301, 302, 303, 307, 308]);+ const maxRedirects = 20;+ let currentUrl = url;+ let headers = options.headers+ ? Object.fromEntries(new Headers(options.headers))+ : undefined;+ for (let redirectCount = 0; ; redirectCount++) {+ validateNetworkUrl(currentUrl, options.policy);+ const response = await fetch(currentUrl, {+ redirect: 'manual',+ ...(options.method ? {method: options.method} : {}),+ ...(headers ? {headers} : {}),+ });+ if (!redirectStatuses.has(response.status)) {+ return response;+ }+ const location = response.headers.get('location');+ await response.body?.cancel();+ if (!location) {+ throw new Error(+ 'Redirect has no Location header: ' ++ redactUrlForLogging(currentUrl.href),+ );+ }+ if (redirectCount >= maxRedirects) {+ throw new Error(+ 'Too many redirects loading resource: ' + redactUrlForLogging(url.href),+ );+ }+ const nextUrl = new URL(location, currentUrl);+ if (headers) {+ headers = getRedirectHeaders(currentUrl, nextUrl, headers);+ }+ currentUrl = nextUrl;+ }+}diff --git a/tests/BUILD.gn b/tests/BUILD.gnindex 1af6b478..efa6e1ae 100644--- a/tests/BUILD.gn+++ b/tests/BUILD.gn@@ -114,6 +114,7 @@ ts_library("tests") {"utils/id.test.ts","utils/keyboard.test.ts","utils/logger.test.ts",+ "utils/network.test.ts","utils/pagination.test.ts","utils/raceWithSignal.test.ts","utils/resourceType.test.ts",diff --git a/tests/McpContext.test.ts b/tests/McpContext.test.tsindex 3acf51e7..2f91889d 100644--- a/tests/McpContext.test.ts+++ b/tests/McpContext.test.ts@@ -1347,6 +1347,22 @@ describe('McpContext', () => {describe('loadResource', () => {describe('file protocol', () => {+ it('rejects blocked file URLs before accessing the filesystem', async () => {+ const context = await createMockContext({+ config: createMockServerConfig({blockedUrlPattern: ['file:///*']}),+ });+ const validatePath = sinon.stub(context, 'validatePath');+ try {+ await assert.rejects(+ context.loadResource('file:///tmp/blocked.map'),+ /Blocked by blocklist/,+ );+ sinon.assert.notCalled(validatePath);+ } finally {+ context.dispose();+ }+ });+it('calls validatePath', async () => {using testFile = createTempFile('test content',@@ -1380,6 +1396,27 @@ describe('McpContext', () => {});describe('https protocol', () => {+ it('rejects non-success responses and redacts the resource URL', async () => {+ const context = await createMockContext();+ const response = new Response('not found', {status: 404});+ const text = sinon.spy(response, 'text');+ sinon.stub(globalThis, 'fetch').resolves(response);+ try {+ await assert.rejects(+ context.loadResource(+ 'https://example.com/missing.map?token=secret',+ ),+ {+ message:+ 'Failed to load resource: https://example.com/missing.map?REDACTED',+ },+ );+ sinon.assert.notCalled(text);+ } finally {+ context.dispose();+ }+ });+async function createNetworkPolicyContext(options: {allowlist?: string[];blocklist?: string[];diff --git a/tests/NetworkOverrideManager.test.ts b/tests/NetworkOverrideManager.test.tsindex f4f8667c..1a58d946 100644--- a/tests/NetworkOverrideManager.test.ts+++ b/tests/NetworkOverrideManager.test.ts@@ -11,13 +11,174 @@ import sinon from 'sinon';import {NetworkOverrideManager} from '../src/NetworkOverrideManager.js';import {CdpFrame} from '../src/third_party/index.js';-import {createMockHTTPRequest, createMockPuppeteerPage} from './mocks.js';+import {+ createMockHTTPRequest,+ createMockPuppeteerPage,+ createMockServerConfig,+} from './mocks.js';import {NetworkOverridesFormatter} from '../src/formatters/NetworkOverridesFormatter.js';describe('NetworkOverrideManager', () => {+ it('retains existing rules when a replacement URL is blocked', async () => {+ const pptrPage = createMockPuppeteerPage();+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig({+ blockedUrlPattern: ['https://blocked.example/*'],+ }),+ );+ const previous = await manager.mock({+ kind: 'upstream',+ urlPattern: '*://*:*/*app.js',+ upstreamUrl: 'https://example.com/replacement.js',+ });+ await assert.rejects(+ manager.mock({+ kind: 'upstream',+ urlPattern: '*://*:*/*app.js',+ upstreamUrl: 'https://blocked.example/replacement.js',+ }),+ /Blocked by blocklist/,+ );+ assert.deepEqual(manager.list(), [previous]);+ sinon.assert.calledOnceWithExactly(pptrPage.setRequestInterception, true);+ await manager.dispose();+ });+ it('blocks cross-origin redirects to a host on blocked-url-pattern before contacting it', async () => {+ const pptrPage = createMockPuppeteerPage();+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig({+ blockedUrlPattern: ['https://blocked.example/*'],+ }),+ );+ await manager.mock({+ kind: 'upstream',+ urlPattern: '*://*:*/*app.js',+ upstreamUrl: 'https://allowed.example/replacement.js',+ });+ const fetch = sinon.stub(globalThis, 'fetch').resolves(+ new Response('upstream', {+ status: 302,+ headers: {location: 'https://blocked.example/secret'},+ }),+ );+ const request = createMockHTTPRequest();+ await pptrPage.on.firstCall.args[1](request);+ sinon.assert.calledOnceWithExactly(+ fetch,+ new URL('https://allowed.example/replacement.js'),+ {redirect: 'manual', method: 'GET', headers: {}},+ );+ sinon.assert.calledOnceWithExactly(request.abort, 'failed');+ sinon.assert.notCalled(request.respond);+ assert.match(+ manager.list()[0]?.diagnostics.lastError ?? '',+ /Blocked by blocklist: https:\/\/blocked.example\/secret/,+ );+ await manager.dispose();+ });++ it('uses updated access policies for already configured overrides', async () => {+ const config = createMockServerConfig();+ const pptrPage = createMockPuppeteerPage();+ const manager = new NetworkOverrideManager(pptrPage, config);+ await manager.mock({+ kind: 'upstream',+ urlPattern: '*://*:*/*app.js',+ upstreamUrl: 'https://example.com/replacement.js',+ });+ config.commit(+ createMockServerConfig({+ blockedUrlPattern: ['https://example.com/replacement.js'],+ }),+ );+ const request = createMockHTTPRequest();+ const fetch = sinon.stub(globalThis, 'fetch');+ await pptrPage.on.firstCall.args[1](request);+ sinon.assert.calledOnceWithExactly(request.abort, 'failed');+ sinon.assert.notCalled(request.continue);+ sinon.assert.notCalled(fetch);+ await manager.dispose();+ });++ it('fulfills an allowed redirect chain with the final response', async () => {+ const pptrPage = createMockPuppeteerPage();+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );+ await manager.mock({+ kind: 'upstream',+ urlPattern: '*://*:*/*app.js',+ upstreamUrl: 'https://cdn.example/start',+ });+ const fetch = sinon.stub(globalThis, 'fetch');+ fetch+ .onFirstCall()+ .resolves(+ new Response(null, {status: 302, headers: {location: '/final'}}),+ );+ fetch.onSecondCall().resolves(+ new Response('replacement', {+ status: 200,+ headers: {'content-type': 'text/javascript'},+ }),+ );+ const request = createMockHTTPRequest();+ await pptrPage.on.firstCall.args[1](request);+ sinon.assert.calledWithExactly(+ fetch.secondCall,+ new URL('https://cdn.example/final'),+ {redirect: 'manual', method: 'GET', headers: {}},+ );+ sinon.assert.calledOnceWithExactly(request.respond, {+ status: 200,+ headers: {'content-type': 'text/javascript'},+ body: new TextEncoder().encode('replacement'),+ });+ sinon.assert.notCalled(request.abort);+ await manager.dispose();+ });++ it('redacts userinfo and query strings in upstream replacement errors', async () => {+ const pptrPage = createMockPuppeteerPage();+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );+ const upstream = 'https://user:[email protected]/app.js?token=secret';+ await manager.mock({+ kind: 'upstream',+ urlPattern: 'https://example.com/app.js',+ upstreamUrl: upstream,+ });+ const fetch = sinon+ .stub(globalThis, 'fetch')+ .rejects(new Error('Failed to fetch ' + upstream));+ const request = createMockHTTPRequest();+ await pptrPage.on.firstCall.args[1](request);+ sinon.assert.calledOnceWithExactly(fetch, new URL(upstream), {+ redirect: 'manual',+ method: 'GET',+ headers: {},+ });+ assert.equal(+ manager.list()[0]?.diagnostics.lastError,+ 'Failed to load https://example.com/app.js?REDACTED: ' ++ 'Failed to fetch https://example.com/app.js?REDACTED',+ );+ sinon.assert.calledOnceWithExactly(request.abort, 'failed');+ sinon.assert.notCalled(request.respond);+ await manager.dispose();+ });+it('counts only matching requests and returns independent diagnostic snapshots', async () => {const pptrPage = createMockPuppeteerPage();- const manager = new NetworkOverrideManager(pptrPage);+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );const initial = await manager.mock({kind: 'file',urlPattern: '*://*:*/*app.js',@@ -49,7 +210,10 @@ describe('NetworkOverrideManager', () => {it('warns after a main-frame document request but not a hash change or subframe navigation', async () => {const pptrPage = createMockPuppeteerPage();- const manager = new NetworkOverrideManager(pptrPage);+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );await manager.mock({kind: 'file',urlPattern: '*://*:*/*missing.js',@@ -99,7 +263,10 @@ describe('NetworkOverrideManager', () => {]) {it('matches query strings using URLPattern: ' + route, async () => {const pptrPage = createMockPuppeteerPage();- const manager = new NetworkOverrideManager(pptrPage);+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );await manager.mock({kind: 'file',urlPattern: route,@@ -130,7 +297,10 @@ describe('NetworkOverrideManager', () => {it('reports the local file and error when a previously readable file fails', async () => {const pptrPage = createMockPuppeteerPage();- const manager = new NetworkOverrideManager(pptrPage);+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );const loadResponseFile = sinon.stub().onFirstCall()@@ -161,7 +331,10 @@ describe('NetworkOverrideManager', () => {});it('updates one rule without replacing unrelated rules or restarting interception', async () => {const pptrPage = createMockPuppeteerPage();- const manager = new NetworkOverrideManager(pptrPage);+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );const unrelated = await manager.mock({kind: 'file',urlPattern: '*://*:*/*old.js',@@ -189,7 +362,10 @@ describe('NetworkOverrideManager', () => {it('validates a local file before updating an existing rule', async () => {const pptrPage = createMockPuppeteerPage();- const manager = new NetworkOverrideManager(pptrPage);+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );const previous = await manager.mock({kind: 'file',urlPattern: '*://*:*/*app.js',@@ -214,7 +390,10 @@ describe('NetworkOverrideManager', () => {it('infers local file content types after validating the file', async () => {const pptrPage = createMockPuppeteerPage();- const manager = new NetworkOverrideManager(pptrPage);+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );const loadResponseFile = sinon.stub().resolves(new Uint8Array());assert.deepEqual(await manager.mock({@@ -239,7 +418,10 @@ describe('NetworkOverrideManager', () => {it('rolls back the rule set when activation fails', async () => {const pptrPage = createMockPuppeteerPage();- const manager = new NetworkOverrideManager(pptrPage);+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );pptrPage.setRequestInterception.withArgs(true).rejects(new Error('Target closed'));@@ -263,7 +445,10 @@ describe('NetworkOverrideManager', () => {it('retains the rules when clearing interception fails', async () => {const pptrPage = createMockPuppeteerPage();- const manager = new NetworkOverrideManager(pptrPage);+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );const previous = await manager.mock({kind: 'file',urlPattern: '*://*:*/*app.js',@@ -282,7 +467,10 @@ describe('NetworkOverrideManager', () => {it('filters and removes exact routes and resource types while preserving other mocks', async () => {const pptrPage = createMockPuppeteerPage();- const manager = new NetworkOverrideManager(pptrPage);+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );const script = await manager.mock({urlPattern: '*://*:*/*app.js',resourceType: 'script',@@ -330,7 +518,10 @@ describe('NetworkOverrideManager', () => {it('restores interception and retains mocks when restoring the cache fails during removal', async () => {const pptrPage = createMockPuppeteerPage();- const manager = new NetworkOverrideManager(pptrPage);+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );const previous = await manager.mock({urlPattern: '*://*:*/*app.js',kind: 'file',@@ -366,7 +557,10 @@ describe('NetworkOverrideManager', () => {it('uses all URLs when route is omitted and updates only the exact filter pair', async () => {const pptrPage = createMockPuppeteerPage();- const manager = new NetworkOverrideManager(pptrPage);+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );const scripts = await manager.mock({resourceType: 'script',kind: 'file',@@ -405,4 +599,170 @@ describe('NetworkOverrideManager', () => {assert.equal(manager.list()[0]?.diagnostics.hits, 0);await manager.dispose();});++ it('checks same-origin upstream redirects against blocked-url-pattern before contacting the target', async () => {+ const pptrPage = createMockPuppeteerPage();+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig({+ blockedUrlPattern: ['https://blocked.example/*'],+ }),+ );+ await manager.mock({+ kind: 'upstream',+ urlPattern: '*://*:*/*app.js',+ upstreamUrl: 'https://example.com/start',+ });+ const fetch = sinon.stub(globalThis, 'fetch').resolves(+ new Response(null, {+ status: 302,+ headers: {location: 'https://blocked.example/private'},+ }),+ );+ const request = createMockHTTPRequest();+ await pptrPage.on.firstCall.args[1](request);+ sinon.assert.calledOnceWithExactly(+ fetch,+ new URL('https://example.com/start'),+ {redirect: 'manual', method: 'GET', headers: {}},+ );+ sinon.assert.calledOnceWithExactly(request.abort, 'failed');+ sinon.assert.notCalled(request.continue);+ sinon.assert.notCalled(request.respond);+ await manager.dispose();+ });++ for (const {upstream, headers} of [+ {+ upstream: 'https://example.com/replacement.js',+ headers: {accept: 'text/javascript', authorization: 'secret'},+ },+ {+ upstream: 'https://cdn.example/replacement.js',+ headers: {accept: 'text/javascript'},+ },+ ]) {+ it('does not forward Accept-Encoding to ' + upstream, async () => {+ const pptrPage = createMockPuppeteerPage();+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );+ await manager.mock({+ kind: 'upstream',+ urlPattern: '*://*:*/*app.js',+ upstreamUrl: upstream,+ });+ const fetch = sinon+ .stub(globalThis, 'fetch')+ .resolves(new Response('js'));+ const request = createMockHTTPRequest();+ request.headers.returns(+ Object.freeze({+ Accept: 'text/javascript',+ 'Accept-Encoding': 'gzip, deflate, br, zstd',+ Authorization: 'secret',+ }),+ );+ await pptrPage.on.firstCall.args[1](request);+ sinon.assert.calledOnceWithExactly(fetch, new URL(upstream), {+ redirect: 'manual',+ method: 'GET',+ headers,+ });+ sinon.assert.notCalled(request.abort);+ await manager.dispose();+ });+ }++ it('preserves multiple Set-Cookie headers in upstream responses', async () => {+ const pptrPage = createMockPuppeteerPage();+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );+ await manager.mock({+ kind: 'upstream',+ urlPattern: '*://*:*/*app.js',+ upstreamUrl: 'https://example.com/replacement.js',+ });+ const cookies = [+ 'session=abc; Path=/; HttpOnly',+ 'theme=dark; Expires=Wed, 21 Oct 2037 07:28:00 GMT; Path=/',+ ];+ const headers = new Headers({'content-type': 'text/javascript'});+ for (const cookie of cookies) {+ headers.append('set-cookie', cookie);+ }+ sinon.stub(globalThis, 'fetch').resolves(new Response('js', {headers}));+ const request = createMockHTTPRequest();+ await pptrPage.on.firstCall.args[1](request);+ sinon.assert.calledOnceWithExactly(request.respond, {+ status: 200,+ headers: {+ 'content-type': 'text/javascript',+ 'set-cookie': cookies,+ },+ body: new TextEncoder().encode('js'),+ });+ sinon.assert.notCalled(request.abort);+ await manager.dispose();+ });++ it('fulfills decoded upstream bodies without stale compression headers', async () => {+ const pptrPage = createMockPuppeteerPage();+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );+ await manager.mock({+ kind: 'upstream',+ urlPattern: '*://*:*/*app.js',+ upstreamUrl: 'https://example.com/replacement.js',+ });+ sinon.stub(globalThis, 'fetch').resolves(+ new Response('decoded', {+ headers: {+ 'content-encoding': 'gzip',+ 'content-length': '123',+ 'content-type': 'text/javascript',+ },+ }),+ );+ const request = createMockHTTPRequest();+ await pptrPage.on.firstCall.args[1](request);+ sinon.assert.calledOnceWithExactly(request.respond, {+ status: 200,+ headers: {+ 'content-type': 'text/javascript',+ },+ body: new TextEncoder().encode('decoded'),+ });+ sinon.assert.notCalled(request.continue);+ await manager.dispose();+ });++ it('rejects unsupported upstream methods before fetching', async () => {+ const pptrPage = createMockPuppeteerPage();+ const manager = new NetworkOverrideManager(+ pptrPage,+ createMockServerConfig(),+ );+ await manager.mock({+ kind: 'upstream',+ urlPattern: '*://*:*/*app.js',+ upstreamUrl: 'https://example.com/replacement.js',+ });+ const fetch = sinon.stub(globalThis, 'fetch');+ const request = createMockHTTPRequest();+ request.method.returns('POST');+ await pptrPage.on.firstCall.args[1](request);+ sinon.assert.notCalled(fetch);+ sinon.assert.calledOnceWithExactly(request.abort, 'failed');+ assert.match(+ manager.list()[0]?.diagnostics.lastError ?? '',+ /only support GET and HEAD/,+ );+ await manager.dispose();+ });});diff --git a/tests/network_overrides.test.ts b/tests/network_overrides.test.tsindex 95dc9e83..acd498ae 100644--- a/tests/network_overrides.test.ts+++ b/tests/network_overrides.test.ts@@ -6,9 +6,11 @@import assert from 'node:assert';import {rm, writeFile} from 'node:fs/promises';+import type {IncomingHttpHeaders} from 'node:http';import {join} from 'node:path';import {describe, it} from 'node:test';+import {NetworkOverridesFormatter} from '../src/formatters/NetworkOverridesFormatter.js';import {mockNetwork, removeNetworkMock} from '../src/tools/network.js';import {serverHooks} from './server.js';import {createTempDir, html, withMcpContext} from './utils.js';@@ -29,6 +31,160 @@ describe('network overrides integration', () => {});}+ it('redirects matching requests across reloads until removed', async () => {+ let originalRequests = 0;+ let replacementRequests = 0;+ addJavaScriptRoute(+ '/redirect-original.js?v=42',+ "document.documentElement.dataset.overrideSource = 'original';",+ () => {+ originalRequests++;+ },+ );+ addJavaScriptRoute(+ '/redirect-replacement.js',+ "document.documentElement.dataset.overrideSource = 'replacement';",+ () => {+ replacementRequests++;+ },+ );+ server.addHtmlRoute(+ '/redirect-page',+ html`<script src="${server.getRoute('/redirect-original.js?v=42')}"></script>`,+ );++ await withMcpContext(async (response, context, args) => {+ const mcpPage = context.getSelectedMcpPage();+ const page = mcpPage.pptrPage;+ await mockNetwork(args).handler(+ {+ params: {+ route: server.baseUrl + '/redirect-original.js*',+ upstream: server.getRoute('/redirect-replacement.js'),+ },+ page: mcpPage,+ },+ response,+ context,+ );+ assert.deepStrictEqual(response.responseLines, [+ 'Network mock configured. Reload or navigate the page to apply it.',+ new NetworkOverridesFormatter(mcpPage.listNetworkMocks()).toString(),+ ]);++ await page.goto(server.getRoute('/redirect-page'));+ assert.strictEqual(+ await page.evaluate(+ () => document.documentElement.dataset.overrideSource,+ ),+ 'replacement',+ );++ await page.reload();+ assert.strictEqual(+ await page.evaluate(+ () => document.documentElement.dataset.overrideSource,+ ),+ 'replacement',+ );+ assert.strictEqual(originalRequests, 0);+ assert.strictEqual(replacementRequests, 2);++ response.resetResponseLineForTesting();+ await removeNetworkMock(args).handler(+ {params: {}, page: mcpPage},+ response,+ context,+ );+ await page.reload();+ assert.strictEqual(+ await page.evaluate(+ () => document.documentElement.dataset.overrideSource,+ ),+ 'original',+ );+ assert.strictEqual(originalRequests, 1);+ });+ });++ it('sanitizes cross-origin headers while preserving Origin', async t => {+ let replacementHeaders: IncomingHttpHeaders = {};+ server.addHtmlRoute('/cross-origin-setup', html`<main>Setup</main>`);+ addJavaScriptRoute(+ '/cross-origin-original.js',+ "document.documentElement.dataset.overrideSource = 'original';",+ );+ server.addHtmlRoute(+ '/cross-origin-page',+ html`<script src="${server.getRoute('/cross-origin-original.js')}"></script>`,+ );+ server.addRoute('/cross-origin-replacement.js', (req, res) => {+ replacementHeaders = req.headers;+ res.setHeader('Content-Type', 'application/javascript; charset=utf-8');+ res.statusCode = 200;+ res.end(+ "document.documentElement.dataset.overrideSource = 'replacement';",+ );+ });++ await withMcpContext(async (response, context, args) => {+ const mcpPage = context.getSelectedMcpPage();+ const page = mcpPage.pptrPage;+ const browserContext = page.browserContext();+ t.after(async () => {+ await browserContext.deleteMatchingCookies({+ name: 'override_secret',+ domain: new URL(server.baseUrl).hostname,+ });+ });+ await page.goto(server.getRoute('/cross-origin-setup'));+ await page.evaluate(() => {+ document.cookie = 'override_secret=cookie; path=/';+ });+ await page.setExtraHTTPHeaders({+ Authorization: 'Bearer secret',+ Origin: server.baseUrl,+ 'X-Api-Key': 'secret',+ });++ const replacementUrl =+ server.baseUrl.replace('127.0.0.1', 'localhost') ++ '/cross-origin-replacement.js';+ await mockNetwork(args).handler(+ {+ params: {+ route: server.getRoute('/cross-origin-original.js'),+ resourceType: 'script',+ upstream: replacementUrl,+ },+ page: mcpPage,+ },+ response,+ context,+ );++ await page.goto(server.getRoute('/cross-origin-page'));+ assert.strictEqual(+ await page.evaluate(+ () => document.documentElement.dataset.overrideSource,+ ),+ 'replacement',+ );+ assert.strictEqual(replacementHeaders.origin, server.baseUrl);+ assert.strictEqual(replacementHeaders.authorization, undefined);+ assert.strictEqual(replacementHeaders.cookie, undefined);+ assert.strictEqual(replacementHeaders.referer, undefined);+ assert.strictEqual(replacementHeaders['x-api-key'], undefined);++ response.resetResponseLineForTesting();+ await removeNetworkMock(args).handler(+ {params: {}, page: mcpPage},+ response,+ context,+ );+ });+ });+it('serves the latest contents of a local file when the URL has a query string', async () => {using directory = createTempDir('network-override-');const filePath = join(directory.path, 'local-override.js');diff --git a/tests/tools/network.test.ts b/tests/tools/network.test.tsindex c10f2083..4e9e1f95 100644--- a/tests/tools/network.test.ts+++ b/tests/tools/network.test.ts@@ -10,6 +10,7 @@ import {describe, it} from 'node:test';import sinon from 'sinon';+import type {NetworkOverride} from '../../src/NetworkOverrideManager.js';import {NetworkOverridesFormatter} from '../../src/formatters/NetworkOverridesFormatter.js';import {mockNetwork,@@ -45,7 +46,9 @@ describe('network', () => {});for (const params of [+ {body: './script.js', upstream: 'https://example.com/script.js'},{body: ' '},+ {upstream: 'file:///tmp/script.js'},{route: '/app.js*', body: './app.js'},{route: '*app.js*', body: './app.js'},{route: 'https://example.com/:file', body: './app.js'},@@ -68,6 +71,67 @@ describe('network', () => {);}+ it('updates an upstream mock with the exact supplied actions', async () => {+ const {page, context, response, args} = createHandlerMocks();+ const override = {+ id: 7,+ kind: 'upstream',+ urlPattern: 'https://example.com/script.js*',+ resourceType: 'script',+ upstreamUrl: 'https://example.com/replacement.js',+ diagnostics: {hits: 0, errors: 0, navigations: 0},+ } satisfies NetworkOverride;+ page.mockNetwork.resolves(override);+ await mockNetwork(args).handler(+ {+ params: {+ route: override.urlPattern,+ resourceType: 'script',+ upstream: override.upstreamUrl,+ },+ page,+ },+ response,+ context,+ );+ sinon.assert.calledOnceWithExactly(page.mockNetwork, {+ kind: 'upstream',+ urlPattern: override.urlPattern,+ resourceType: 'script',+ upstreamUrl: override.upstreamUrl,+ });+ sinon.assert.notCalled(page.listNetworkMocks);+ sinon.assert.notCalled(context.validatePath);+ sinon.assert.calledWithExactly(+ response.appendResponseLine.firstCall,+ 'Network mock configured. Reload or navigate the page to apply it.',+ );+ sinon.assert.calledWithExactly(+ response.appendResponseLine.secondCall,+ new NetworkOverridesFormatter([override]).toString(),+ );+ });++ it('propagates upstream policy failures without reporting success', async () => {+ const {page, context, response, args} = createHandlerMocks();+ page.mockNetwork.rejects(new Error('Blocked by blocklist'));+ await assert.rejects(+ mockNetwork(args).handler(+ {params: {upstream: 'https://blocked.example/script.js'}, page},+ response,+ context,+ ),+ /Blocked by blocklist/,+ );+ sinon.assert.calledOnceWithExactly(page.mockNetwork, {+ kind: 'upstream',+ urlPattern: undefined,+ resourceType: undefined,+ upstreamUrl: 'https://blocked.example/script.js',+ });+ sinon.assert.notCalled(response.appendResponseLine);+ });+it('revalidates the canonical body file before each read', async () => {const {page, context, response, args} = createHandlerMocks();context.validatePath.resolves('/tmp/script.js');@@ -162,10 +226,9 @@ describe('network', () => {{id: 2,diagnostics: {hits: 0, errors: 0, navigations: 1},- kind: 'file',+ kind: 'upstream',urlPattern: 'https://example.com/missing.js',- responseFilePath: '/tmp/replacement.js',- contentType: 'text/javascript',+ upstreamUrl: 'https://example.com/replacement.js',},]);await mockNetwork(args).handler({params: {}, page}, response, context);diff --git a/tests/utils/network.test.ts b/tests/utils/network.test.tsnew file mode 100644index 00000000..117a9756--- /dev/null+++ b/tests/utils/network.test.ts@@ -0,0 +1,177 @@+/**+ * @license+ * Copyright 2026 Google LLC+ * SPDX-License-Identifier: Apache-2.0+ */++import assert from 'node:assert/strict';+import {describe, it} from 'node:test';++import sinon from 'sinon';++import {+ fetchWithValidatedRedirects,+ validateNetworkUrl,+} from '../../src/utils/network.js';++describe('network access policy', () => {+ it('redacts userinfo and query strings in URL policy errors', () => {+ assert.throws(+ () =>+ validateNetworkUrl(+ new URL('https://user:[email protected]/private?token=secret'),+ {+ blockedUrlPattern: ['https://example.com/*'],+ },+ ),+ {message: 'Blocked by blocklist: https://example.com/private?REDACTED'},+ );+ });+});++describe('fetchWithValidatedRedirects', () => {+ for (const policy of [+ {blockedUrlPattern: ['https://blocked.example/*']},+ {allowedUrlPattern: ['https://allowed.example/*']},+ ]) {+ it('checks every redirect against ' + JSON.stringify(policy), async () => {+ const redirect = new Response('redirect body', {+ status: 302,+ headers: {location: 'https://blocked.example/private'},+ });+ assert.ok(redirect.body);+ const cancel = sinon.spy(redirect.body, 'cancel');+ const fetch = sinon.stub(globalThis, 'fetch').resolves(redirect);+ await assert.rejects(+ fetchWithValidatedRedirects(new URL('https://allowed.example/start'), {+ policy,+ }),+ /blocklist|allowlist/,+ );+ sinon.assert.calledOnceWithExactly(+ fetch,+ new URL('https://allowed.example/start'),+ {redirect: 'manual'},+ );+ sinon.assert.calledOnceWithExactly(cancel);+ });+ }++ it('rejects a blocked initial URL before sending a request', async () => {+ const fetch = sinon.stub(globalThis, 'fetch');+ await assert.rejects(+ fetchWithValidatedRedirects(new URL('https://blocked.example/start'), {+ policy: {blockedUrlPattern: ['https://blocked.example/*']},+ }),+ /Blocked by blocklist/,+ );+ sinon.assert.notCalled(fetch);+ });++ it('preserves same-origin credentials and strips private headers on cross-origin redirects', async () => {+ const final = new Response('content');+ const fetch = sinon.stub(globalThis, 'fetch');+ fetch+ .onFirstCall()+ .resolves(+ new Response(null, {status: 301, headers: {location: '/next'}}),+ );+ fetch.onSecondCall().resolves(+ new Response(null, {+ status: 307,+ headers: {location: 'https://other.example/final'},+ }),+ );+ fetch.onThirdCall().resolves(final);+ const headers = {+ authorization: 'secret',+ cookie: 'session=secret',+ 'proxy-authorization': 'secret',+ 'x-api-key': 'secret',+ referer: 'https://example.com/private?token=secret',+ accept: 'text/javascript',+ };+ const response = await fetchWithValidatedRedirects(+ new URL('https://example.com/start'),+ {+ policy: {},+ method: 'HEAD',+ headers,+ },+ );+ assert.equal(response, final);+ sinon.assert.calledWithExactly(+ fetch.firstCall,+ new URL('https://example.com/start'),+ {redirect: 'manual', method: 'HEAD', headers},+ );+ sinon.assert.calledWithExactly(+ fetch.secondCall,+ new URL('https://example.com/next'),+ {redirect: 'manual', method: 'HEAD', headers},+ );+ sinon.assert.calledWithExactly(+ fetch.thirdCall,+ new URL('https://other.example/final'),+ {+ redirect: 'manual',+ method: 'HEAD',+ headers: {accept: 'text/javascript'},+ },+ );+ });++ it('rejects a redirect to an unsupported protocol before fetching it', async () => {+ const fetch = sinon.stub(globalThis, 'fetch').resolves(+ new Response(null, {+ status: 303,+ headers: {location: 'file:///tmp/secret'},+ }),+ );+ await assert.rejects(+ fetchWithValidatedRedirects(new URL('https://example.com/start'), {+ policy: {},+ }),+ /Unsupported URL protocol: file:/,+ );+ sinon.assert.calledOnceWithExactly(+ fetch,+ new URL('https://example.com/start'),+ {redirect: 'manual'},+ );+ });++ it('cancels a redirect body when Location is missing', async () => {+ const response = new Response('body', {status: 302});+ assert.ok(response.body);+ const cancel = sinon.spy(response.body, 'cancel');+ sinon.stub(globalThis, 'fetch').resolves(response);+ await assert.rejects(+ fetchWithValidatedRedirects(new URL('https://example.com/start'), {+ policy: {},+ }),+ /Redirect has no Location header/,+ );+ sinon.assert.calledOnceWithExactly(cancel);+ });++ it('bounds redirect loops and cancels the last response body', async () => {+ const responses: Response[] = [];+ const fetch = sinon.stub(globalThis, 'fetch').callsFake(async () => {+ const response = new Response('body', {+ status: 308,+ headers: {location: '/loop'},+ });+ responses.push(response);+ return response;+ });+ await assert.rejects(+ fetchWithValidatedRedirects(new URL('https://example.com/loop'), {+ policy: {},+ }),+ /Too many redirects/,+ );+ sinon.assert.callCount(fetch, 21);+ assert.ok(responses.every(response => response.bodyUsed));+ });+});