Skip to content

Chrome DevTools for coding agents

30.7 KB
Raw Blame
/**
 * @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 {NetworkOverrideManager} from '../src/NetworkOverrideManager.js';
import {CdpFrame} from '../src/third_party/index.js';
import {
  createMockHTTPRequest,
  createMockPuppeteerPage,
  createMockServerConfig,
} from './mocks.js';
import {NetworkOverridesFormatter} from '../src/formatters/NetworkOverridesFormatter.js';
import {settle} from './utils.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();
    pptrPage.emit('request', request);
    await settle();
    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');
    pptrPage.emit('request', request);
    await settle();
    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();
    pptrPage.emit('request', request);
    await settle();
    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();
    pptrPage.emit('request', request);
    await settle();
    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,
      createMockServerConfig(),
    );
    const initial = await manager.mock({
      kind: 'file',
      urlPattern: '*://*:*/*app.js',
      resourceType: 'script',
      responseFilePath: '/tmp/replacement.js',
      loadResponseFile: async () => new Uint8Array(),
    });
    const request = createMockHTTPRequest();
    pptrPage.emit('request', request);
    const unmatched = createMockHTTPRequest({resourceType: 'fetch'});
    pptrPage.emit('request', unmatched);
    await settle();
    assert.deepEqual(manager.list()[0]?.diagnostics, {
      hits: 1,
      errors: 0,
      navigations: 0,
    });
    assert.equal(initial.diagnostics.hits, 0);
    sinon.assert.calledOnceWithExactly(request.respond, {
      status: 200,
      contentType: 'application/javascript; charset=utf-8',
      headers: {'Cache-Control': 'no-store'},
      body: new Uint8Array(),
    });
    sinon.assert.calledOnceWithExactly(unmatched.continue);
    sinon.assert.notCalled(request.continue);
    await manager.dispose();
  });

  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,
      createMockServerConfig(),
    );
    await manager.mock({
      kind: 'file',
      urlPattern: '*://*:*/*missing.js',
      responseFilePath: '/tmp/replacement.js',
      loadResponseFile: async () => new Uint8Array(),
    });
    assert.match(
      new NetworkOverridesFormatter(manager.list()).toString(),
      /Navigate or reload/,
    );
    pptrPage.emit('framenavigated', pptrPage.mainFrame());
    const mainFrame = pptrPage.mainFrame();
    const childFrame = createMockPuppeteerPage().mainFrame();
    assert.ok(mainFrame instanceof CdpFrame);
    assert.ok(childFrame instanceof CdpFrame);
    const subframe = createMockHTTPRequest({resourceType: 'document'});
    subframe.frame.returns(childFrame);
    pptrPage.emit('request', subframe);
    const script = createMockHTTPRequest();
    script.frame.returns(mainFrame);
    pptrPage.emit('request', script);
    await settle();
    assert.equal(manager.list()[0]?.diagnostics.navigations, 0);
    assert.doesNotMatch(
      new NetworkOverridesFormatter(manager.list()).toString(),
      /Warning: no requests matched after navigation/,
    );
    const document = createMockHTTPRequest({resourceType: 'document'});
    document.frame.returns(mainFrame);
    pptrPage.emit('request', document);
    await settle();
    assert.equal(manager.list()[0]?.diagnostics.navigations, 1);
    assert.match(
      new NetworkOverridesFormatter(manager.list()).toString(),
      /Warning: no requests matched after navigation/,
    );
    assert.equal(manager.list()[0]?.diagnostics.hits, 0);
    sinon.assert.calledOnceWithExactly(document.continue);
    sinon.assert.notCalled(document.respond);
    await manager.dispose();
    assert.equal(pptrPage.listenerCount('request'), 0);
  });

  for (const route of [
    'https://example.com/app.js',
    '*://*:*/app.js',
    'https://example.com/app.js?v=*',
  ]) {
    it('matches query strings using URLPattern: ' + route, async () => {
      const pptrPage = createMockPuppeteerPage();
      const manager = new NetworkOverrideManager(
        pptrPage,
        createMockServerConfig(),
      );
      await manager.mock({
        kind: 'file',
        urlPattern: route,
        responseFilePath: '/tmp/app.js',
        loadResponseFile: async () => new Uint8Array(),
      });
      const request = createMockHTTPRequest({
        url: 'https://example.com/app.js?v=1',
      });
      pptrPage.emit('request', request);
      await settle();
      sinon.assert.calledOnceWithExactly(request.respond, {
        status: 200,
        contentType: 'application/javascript; charset=utf-8',
        headers: {'Cache-Control': 'no-store'},
        body: new Uint8Array(),
      });
      sinon.assert.notCalled(request.continue);
      const unmatched = createMockHTTPRequest({
        url: 'https://example.com/app.jsxv=1',
      });
      pptrPage.emit('request', unmatched);
      await settle();
      sinon.assert.calledOnceWithExactly(unmatched.continue);
      sinon.assert.notCalled(unmatched.respond);
      await manager.dispose();
    });
  }

  it('reports the local file and error when a previously readable file fails', async () => {
    const pptrPage = createMockPuppeteerPage();
    const manager = new NetworkOverrideManager(
      pptrPage,
      createMockServerConfig(),
    );
    const loadResponseFile = sinon
      .stub()
      .onFirstCall()
      .resolves(new Uint8Array())
      .onSecondCall()
      .rejects({message: 'ENOENT: file was removed'});
    await manager.mock({
      kind: 'file',
      urlPattern: '*://*:*/*app.js',
      responseFilePath: '/tmp/app.js',
      loadResponseFile,
    });
    const request = createMockHTTPRequest();
    pptrPage.emit('request', request);
    await settle();
    assert.deepEqual(manager.list()[0]?.diagnostics, {
      hits: 1,
      errors: 1,
      navigations: 0,
      lastError: 'Failed to load /tmp/app.js: ENOENT: file was removed',
    });
    assert.match(
      new NetworkOverridesFormatter(manager.list()).toString(),
      /Last error: Failed to load \/tmp\/app.js: ENOENT/,
    );
    sinon.assert.calledOnceWithExactly(request.abort, 'failed');
    sinon.assert.notCalled(request.respond);
    await manager.dispose();
  });
  it('updates one rule without replacing unrelated rules or restarting interception', async () => {
    const pptrPage = createMockPuppeteerPage();
    const manager = new NetworkOverrideManager(
      pptrPage,
      createMockServerConfig(),
    );
    const unrelated = await manager.mock({
      kind: 'file',
      urlPattern: '*://*:*/*old.js',
      responseFilePath: '/tmp/old.js',
      loadResponseFile: async () => new Uint8Array(),
    });
    const previous = await manager.mock({
      kind: 'file',
      urlPattern: '*://*:*/*new.js',
      responseFilePath: '/tmp/new.js',
      loadResponseFile: async () => new Uint8Array(),
    });
    const updated = await manager.mock({
      kind: 'file',
      urlPattern: '*://*:*/*new.js',
      responseFilePath: '/tmp/updated.js',
      loadResponseFile: async () => new Uint8Array(),
    });
    assert.deepEqual(manager.list(), [unrelated, updated]);
    assert.equal(updated.id, previous.id);
    assert.equal(updated.kind, 'file');
    sinon.assert.calledOnceWithExactly(pptrPage.setRequestInterception, true);
    await manager.dispose();
  });

  it('updates abort while preserving the rule id and response source', async () => {
    const pptrPage = createMockPuppeteerPage();
    const manager = new NetworkOverrideManager(
      pptrPage,
      createMockServerConfig(),
    );
    const previous = await manager.mock({
      kind: 'file',
      urlPattern: '*://*:*/*app.js',
      responseFilePath: '/tmp/app.js',
      loadResponseFile: async () => new Uint8Array(),
    });
    const updated = await manager.mock({
      urlPattern: '*://*:*/*app.js',
      abort: true,
    });
    assert.deepEqual(updated, {...previous, abort: true});
    assert.deepEqual(manager.list(), [updated]);
    sinon.assert.calledOnceWithExactly(pptrPage.setRequestInterception, true);
    await manager.dispose();
  });

  it('validates a local file before updating an existing rule', async () => {
    const pptrPage = createMockPuppeteerPage();
    const manager = new NetworkOverrideManager(
      pptrPage,
      createMockServerConfig(),
    );
    const previous = await manager.mock({
      kind: 'file',
      urlPattern: '*://*:*/*app.js',
      responseFilePath: '/tmp/app.js',
      loadResponseFile: async () => new Uint8Array(),
    });
    const loadResponseFile = sinon.stub().rejects(new Error('File unreadable'));
    await assert.rejects(
      manager.mock({
        kind: 'file',
        urlPattern: '*://*:*/*app.js',
        responseFilePath: '/tmp/app.js',
        loadResponseFile,
      }),
      /File unreadable/,
    );
    assert.deepEqual(manager.list(), [previous]);
    sinon.assert.calledOnceWithExactly(loadResponseFile);
    sinon.assert.calledOnceWithExactly(pptrPage.setRequestInterception, true);
    await manager.dispose();
  });

  it('infers local file content types after validating the file', async () => {
    const pptrPage = createMockPuppeteerPage();
    const manager = new NetworkOverrideManager(
      pptrPage,
      createMockServerConfig(),
    );
    const loadResponseFile = sinon.stub().resolves(new Uint8Array());
    assert.deepEqual(
      await manager.mock({
        kind: 'file',
        urlPattern: '*://*:*/*app.js',
        responseFilePath: '/tmp/app.js',
        loadResponseFile,
      }),
      {
        id: 1,
        diagnostics: {hits: 0, errors: 0, navigations: 0},
        kind: 'file',
        urlPattern: '*://*:*/*app.js',
        resourceType: undefined,
        abort: false,
        allowOrigin: undefined,
        responseFilePath: '/tmp/app.js',
        contentType: 'application/javascript; charset=utf-8',
      },
    );
    sinon.assert.calledOnceWithExactly(loadResponseFile);
    await manager.dispose();
  });

  it('rolls back the rule set when activation fails', async () => {
    const pptrPage = createMockPuppeteerPage();
    const manager = new NetworkOverrideManager(
      pptrPage,
      createMockServerConfig(),
    );
    pptrPage.setRequestInterception
      .withArgs(true)
      .rejects(new Error('Target closed'));
    await assert.rejects(
      manager.mock({
        kind: 'file',
        urlPattern: '*://*:*/*app.js',
        responseFilePath: '/tmp/app.js',
        loadResponseFile: async () => new Uint8Array(),
      }),
      /Target closed/,
    );
    assert.deepEqual(manager.list(), []);
    sinon.assert.calledWithExactly(
      pptrPage.setRequestInterception.secondCall,
      false,
    );
    sinon.assert.calledWithExactly(pptrPage.setCacheEnabled.secondCall, true);
    await manager.dispose();
  });

  it('retains the rules when clearing interception fails', async () => {
    const pptrPage = createMockPuppeteerPage();
    const manager = new NetworkOverrideManager(
      pptrPage,
      createMockServerConfig(),
    );
    const previous = await manager.mock({
      kind: 'file',
      urlPattern: '*://*:*/*app.js',
      responseFilePath: '/tmp/app.js',
      loadResponseFile: async () => new Uint8Array(),
    });
    pptrPage.setRequestInterception
      .withArgs(false)
      .rejects(new Error('Cannot disable'));
    await assert.rejects(manager.remove({}), /Cannot disable/);
    assert.deepEqual(manager.list(), [previous]);
    sinon.assert.calledOnceWithExactly(pptrPage.setCacheEnabled, false);
    pptrPage.setRequestInterception.withArgs(false).resolves();
    await manager.dispose();
  });

  it('filters and removes exact routes and resource types while preserving other mocks', async () => {
    const pptrPage = createMockPuppeteerPage();
    const manager = new NetworkOverrideManager(
      pptrPage,
      createMockServerConfig(),
    );
    const script = await manager.mock({
      urlPattern: '*://*:*/*app.js',
      resourceType: 'script',
      kind: 'file',
      responseFilePath: '/tmp/app.js',
      loadResponseFile: async () => new Uint8Array(),
    });
    const fetch = await manager.mock({
      urlPattern: '*://*:*/*app.js',
      resourceType: 'fetch',
      kind: 'file',
      responseFilePath: '/tmp/app.js',
      loadResponseFile: async () => new Uint8Array(),
    });
    const other = await manager.mock({
      urlPattern: '*://*:*/*other.js',
      kind: 'file',
      responseFilePath: '/tmp/app.js',
      loadResponseFile: async () => new Uint8Array(),
    });
    assert.deepEqual(manager.list({urlPattern: '*://*:*/*app.js'}), [
      script,
      fetch,
    ]);
    assert.deepEqual(manager.list({resourceType: 'script'}), [script]);
    assert.equal(
      await manager.remove({
        urlPattern: '*://*:*/*app.js',
        resourceType: 'script',
      }),
      1,
    );
    assert.deepEqual(manager.list(), [fetch, other]);
    assert.equal(await manager.remove({urlPattern: '*://*:*/*app*'}), 0);
    sinon.assert.calledOnceWithExactly(pptrPage.setRequestInterception, true);
    assert.equal(await manager.remove({}), 2);
    assert.deepEqual(manager.list(), []);
    sinon.assert.calledWithExactly(
      pptrPage.setRequestInterception.secondCall,
      false,
    );
    sinon.assert.calledWithExactly(pptrPage.setCacheEnabled.secondCall, true);
    await manager.dispose();
  });

  it('restores interception and retains mocks when restoring the cache fails during removal', async () => {
    const pptrPage = createMockPuppeteerPage();
    const manager = new NetworkOverrideManager(
      pptrPage,
      createMockServerConfig(),
    );
    const previous = await manager.mock({
      urlPattern: '*://*:*/*app.js',
      abort: true,
    });
    pptrPage.setCacheEnabled
      .withArgs(true)
      .onFirstCall()
      .rejects(new Error('Cannot restore cache'));
    await assert.rejects(manager.remove({}), /Cannot restore cache/);
    assert.deepEqual(manager.list(), [previous]);
    sinon.assert.calledWithExactly(
      pptrPage.setRequestInterception.secondCall,
      false,
    );
    sinon.assert.calledWithExactly(
      pptrPage.setRequestInterception.thirdCall,
      true,
    );
    assert.equal(pptrPage.listenerCount('request'), 1);
    const request = createMockHTTPRequest();
    pptrPage.emit('request', request);
    await settle();
    sinon.assert.calledOnceWithExactly(request.abort, 'failed');
    sinon.assert.notCalled(request.continue);
    await manager.dispose();
  });

  it('uses all URLs when route is omitted and updates only the exact filter pair', async () => {
    const pptrPage = createMockPuppeteerPage();
    const manager = new NetworkOverrideManager(
      pptrPage,
      createMockServerConfig(),
    );
    const scripts = await manager.mock({resourceType: 'script', abort: true});
    const all = await manager.mock({abort: true});
    const updated = await manager.mock({resourceType: 'script', abort: false});
    assert.equal(scripts.urlPattern, '*://*:*/*');
    assert.equal(updated.id, scripts.id);
    assert.deepEqual(manager.list(), [all, updated]);
    const request = createMockHTTPRequest({
      url: 'http://localhost:8080/app.js?v=1',
    });
    pptrPage.emit('request', request);
    await settle();
    sinon.assert.calledOnceWithExactly(request.continue);
    sinon.assert.notCalled(request.abort);
    assert.equal(
      manager.list({resourceType: 'script'})[0]?.diagnostics.hits,
      1,
    );
    assert.equal(manager.list()[0]?.diagnostics.hits, 0);
    await manager.dispose();
  });

  it('aborts matching requests without recording a replacement error and restores the source with abort false', async () => {
    const pptrPage = createMockPuppeteerPage();
    const manager = new NetworkOverrideManager(
      pptrPage,
      createMockServerConfig(),
    );
    const loadResponseFile = sinon
      .stub()
      .resolves(new TextEncoder().encode('replacement'));
    await manager.mock({
      kind: 'file',
      urlPattern: '*://*:*/*app.js',
      responseFilePath: '/tmp/app.js',
      loadResponseFile,
    });
    await manager.mock({urlPattern: '*://*:*/*app.js', abort: true});
    const blocked = createMockHTTPRequest();
    pptrPage.emit('request', blocked);
    await settle();
    sinon.assert.calledOnceWithExactly(blocked.abort, 'failed');
    sinon.assert.notCalled(blocked.respond);
    sinon.assert.calledOnceWithExactly(loadResponseFile);
    assert.deepEqual(manager.list()[0]?.diagnostics, {
      hits: 1,
      errors: 0,
      navigations: 0,
    });
    assert.match(
      new NetworkOverridesFormatter(manager.list()).toString(),
      /Requests are aborted/,
    );
    await manager.mock({urlPattern: '*://*:*/*app.js', abort: false});
    const restored = createMockHTTPRequest();
    pptrPage.emit('request', restored);
    await settle();
    sinon.assert.calledOnceWithExactly(restored.respond, {
      status: 200,
      contentType: 'application/javascript; charset=utf-8',
      headers: {'Cache-Control': 'no-store'},
      body: new TextEncoder().encode('replacement'),
    });
    sinon.assert.notCalled(restored.abort);
    await manager.dispose();
  });

  it('sets allow-origin for a local body and retains it when the body is updated', async () => {
    const pptrPage = createMockPuppeteerPage();
    const manager = new NetworkOverrideManager(
      pptrPage,
      createMockServerConfig(),
    );
    const loadResponseFile = sinon
      .stub()
      .resolves(new TextEncoder().encode('replacement'));
    await manager.mock({
      kind: 'file',
      urlPattern: '*://*:*/*app.js',
      responseFilePath: '/tmp/app.js',
      loadResponseFile,
      allowOrigin: 'https://consumer.example',
    });
    await manager.mock({
      kind: 'file',
      urlPattern: '*://*:*/*app.js',
      responseFilePath: '/tmp/app.js',
      loadResponseFile,
    });
    const request = createMockHTTPRequest();
    pptrPage.emit('request', request);
    await settle();
    sinon.assert.calledOnceWithExactly(request.respond, {
      status: 200,
      contentType: 'application/javascript; charset=utf-8',
      headers: {
        'Cache-Control': 'no-store',
        'Access-Control-Allow-Origin': 'https://consumer.example',
      },
      body: new TextEncoder().encode('replacement'),
    });
    assert.match(
      new NetworkOverridesFormatter(manager.list()).toString(),
      /Access-Control-Allow-Origin: https:\/\/consumer.example/,
    );
    await manager.dispose();
  });

  it('rejects allowOrigin without a body or upstream before activating interception', async () => {
    const pptrPage = createMockPuppeteerPage();
    const manager = new NetworkOverrideManager(
      pptrPage,
      createMockServerConfig(),
    );
    for (const abort of [undefined, true, false]) {
      await assert.rejects(
        manager.mock({allowOrigin: '*', abort}),
        /allowOrigin requires a body or upstream/,
      );
    }
    assert.deepEqual(manager.list(), []);
    sinon.assert.notCalled(pptrPage.setCacheEnabled);
    await manager.dispose();
  });

  it('rejects allowOrigin updates to a rule without a source and preserves its state', async () => {
    const pptrPage = createMockPuppeteerPage();
    const manager = new NetworkOverrideManager(
      pptrPage,
      createMockServerConfig(),
    );
    const previous = await manager.mock({abort: true});
    await assert.rejects(
      manager.mock({allowOrigin: '*', abort: false}),
      /allowOrigin requires a body or upstream/,
    );
    assert.deepEqual(manager.list(), [previous]);
    await manager.dispose();
  });

  it('does not retry a rejected abort or record a replacement error', async () => {
    const pptrPage = createMockPuppeteerPage();
    const manager = new NetworkOverrideManager(
      pptrPage,
      createMockServerConfig(),
    );
    await manager.mock({abort: true});
    const request = createMockHTTPRequest();
    request.abort.rejects(new Error('Request is already handled'));
    pptrPage.emit('request', request);
    await settle();
    sinon.assert.calledOnceWithExactly(request.abort, 'failed');
    sinon.assert.notCalled(request.respond);
    sinon.assert.notCalled(request.continue);
    assert.deepEqual(manager.list()[0]?.diagnostics, {
      hits: 1,
      errors: 0,
      navigations: 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();
    pptrPage.emit('request', request);
    await settle();
    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',
        }),
      );
      pptrPage.emit('request', request);
      await settle();
      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();
    pptrPage.emit('request', request);
    await settle();
    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('updates allow-origin on an existing upstream source and fulfills decoded 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',
    });
    await manager.mock({urlPattern: '*://*:*/*app.js', allowOrigin: '*'});
    sinon.stub(globalThis, 'fetch').resolves(
      new Response('decoded', {
        headers: {
          'content-encoding': 'gzip',
          'content-length': '123',
          'content-type': 'text/javascript',
        },
      }),
    );
    const request = createMockHTTPRequest();
    pptrPage.emit('request', request);
    await settle();
    sinon.assert.calledOnceWithExactly(request.respond, {
      status: 200,
      headers: {
        'content-type': 'text/javascript',
        'access-control-allow-origin': '*',
      },
      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');
    pptrPage.emit('request', request);
    await settle();
    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();
  });
});