chore: extract HTTP prep for BiDi network module (#9840)

packages/puppeteer-core/src/api/HTTPRequest.ts

@@ -0,0 +1,567 @@
+/**
+ * Copyright 2020 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+import {Protocol} from 'devtools-protocol';
+
+import {CDPSession} from '../common/Connection.js';
+import {Frame} from '../common/Frame.js';
+
+import {HTTPResponse} from './HTTPResponse.js';
+
+/**
+ * @public
+ */
+export interface ContinueRequestOverrides {
+  /**
+   * If set, the request URL will change. This is not a redirect.
+   */
+  url?: string;
+  method?: string;
+  postData?: string;
+  headers?: Record<string, string>;
+}
+
+/**
+ * @public
+ */
+export interface InterceptResolutionState {
+  action: InterceptResolutionAction;
+  priority?: number;
+}
+
+/**
+ * Required response data to fulfill a request with.
+ *
+ * @public
+ */
+export interface ResponseForRequest {
+  status: number;
+  /**
+   * Optional response headers. All values are converted to strings.
+   */
+  headers: Record<string, unknown>;
+  contentType: string;
+  body: string | Buffer;
+}
+
+/**
+ * Resource types for HTTPRequests as perceived by the rendering engine.
+ *
+ * @public
+ */
+export type ResourceType = Lowercase<Protocol.Network.ResourceType>;
+
+/**
+ * The default cooperative request interception resolution priority
+ *
+ * @public
+ */
+export const DEFAULT_INTERCEPT_RESOLUTION_PRIORITY = 0;
+
+/**
+ * Represents an HTTP request sent by a page.
+ * @remarks
+ *
+ * Whenever the page sends a request, such as for a network resource, the
+ * following events are emitted by Puppeteer's `page`:
+ *
+ * - `request`: emitted when the request is issued by the page.
+ * - `requestfinished` - emitted when the response body is downloaded and the
+ *   request is complete.
+ *
+ * If request fails at some point, then instead of `requestfinished` event the
+ * `requestfailed` event is emitted.
+ *
+ * All of these events provide an instance of `HTTPRequest` representing the
+ * request that occurred:
+ *
+ * ```
+ * page.on('request', request => ...)
+ * ```
+ *
+ * NOTE: HTTP Error responses, such as 404 or 503, are still successful
+ * responses from HTTP standpoint, so request will complete with
+ * `requestfinished` event.
+ *
+ * If request gets a 'redirect' response, the request is successfully finished
+ * with the `requestfinished` event, and a new request is issued to a
+ * redirected url.
+ *
+ * @public
+ */
+export class HTTPRequest {
+  /**
+   * @internal
+   */
+  _requestId = '';
+  /**
+   * @internal
+   */
+  _interceptionId: string | undefined;
+  /**
+   * @internal
+   */
+  _failureText: string | null = null;
+  /**
+   * @internal
+   */
+  _response: HTTPResponse | null = null;
+  /**
+   * @internal
+   */
+  _fromMemoryCache = false;
+  /**
+   * @internal
+   */
+  _redirectChain: HTTPRequest[] = [];
+
+  /**
+   * Warning! Using this client can break Puppeteer. Use with caution.
+   *
+   * @experimental
+   */
+  get client(): CDPSession {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @internal
+   */
+  constructor() {}
+
+  /**
+   * @returns the URL of the request
+   */
+  url(): string {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns the `ContinueRequestOverrides` that will be used
+   * if the interception is allowed to continue (ie, `abort()` and
+   * `respond()` aren't called).
+   */
+  continueRequestOverrides(): ContinueRequestOverrides {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns The `ResponseForRequest` that gets used if the
+   * interception is allowed to respond (ie, `abort()` is not called).
+   */
+  responseForRequest(): Partial<ResponseForRequest> | null {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns the most recent reason for aborting the request
+   */
+  abortErrorReason(): Protocol.Network.ErrorReason | null {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns An InterceptResolutionState object describing the current resolution
+   * action and priority.
+   *
+   * InterceptResolutionState contains:
+   * action: InterceptResolutionAction
+   * priority?: number
+   *
+   * InterceptResolutionAction is one of: `abort`, `respond`, `continue`,
+   * `disabled`, `none`, or `already-handled`.
+   */
+  interceptResolutionState(): InterceptResolutionState {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns `true` if the intercept resolution has already been handled,
+   * `false` otherwise.
+   */
+  isInterceptResolutionHandled(): boolean {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * Adds an async request handler to the processing queue.
+   * Deferred handlers are not guaranteed to execute in any particular order,
+   * but they are guaranteed to resolve before the request interception
+   * is finalized.
+   */
+  enqueueInterceptAction(
+    pendingHandler: () => void | PromiseLike<unknown>
+  ): void;
+  enqueueInterceptAction(): void {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * Awaits pending interception handlers and then decides how to fulfill
+   * the request interception.
+   */
+  async finalizeInterceptions(): Promise<void> {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * Contains the request's resource type as it was perceived by the rendering
+   * engine.
+   */
+  resourceType(): ResourceType {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns the method used (`GET`, `POST`, etc.)
+   */
+  method(): string {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns the request's post body, if any.
+   */
+  postData(): string | undefined {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns an object with HTTP headers associated with the request. All
+   * header names are lower-case.
+   */
+  headers(): Record<string, string> {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns A matching `HTTPResponse` object, or null if the response has not
+   * been received yet.
+   */
+  response(): HTTPResponse | null {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns the frame that initiated the request, or null if navigating to
+   * error pages.
+   */
+  frame(): Frame | null {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns true if the request is the driver of the current frame's navigation.
+   */
+  isNavigationRequest(): boolean {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns the initiator of the request.
+   */
+  initiator(): Protocol.Network.Initiator {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * A `redirectChain` is a chain of requests initiated to fetch a resource.
+   * @remarks
+   *
+   * `redirectChain` is shared between all the requests of the same chain.
+   *
+   * For example, if the website `http://example.com` has a single redirect to
+   * `https://example.com`, then the chain will contain one request:
+   *
+   * ```ts
+   * const response = await page.goto('http://example.com');
+   * const chain = response.request().redirectChain();
+   * console.log(chain.length); // 1
+   * console.log(chain[0].url()); // 'http://example.com'
+   * ```
+   *
+   * If the website `https://google.com` has no redirects, then the chain will be empty:
+   *
+   * ```ts
+   * const response = await page.goto('https://google.com');
+   * const chain = response.request().redirectChain();
+   * console.log(chain.length); // 0
+   * ```
+   *
+   * @returns the chain of requests - if a server responds with at least a
+   * single redirect, this chain will contain all requests that were redirected.
+   */
+  redirectChain(): HTTPRequest[] {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * Access information about the request's failure.
+   *
+   * @remarks
+   *
+   * @example
+   *
+   * Example of logging all failed requests:
+   *
+   * ```ts
+   * page.on('requestfailed', request => {
+   *   console.log(request.url() + ' ' + request.failure().errorText);
+   * });
+   * ```
+   *
+   * @returns `null` unless the request failed. If the request fails this can
+   * return an object with `errorText` containing a human-readable error
+   * message, e.g. `net::ERR_FAILED`. It is not guaranteed that there will be
+   * failure text if the request fails.
+   */
+  failure(): {errorText: string} | null {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * Continues request with optional request overrides.
+   *
+   * @remarks
+   *
+   * To use this, request
+   * interception should be enabled with {@link Page.setRequestInterception}.
+   *
+   * Exception is immediately thrown if the request interception is not enabled.
+   *
+   * @example
+   *
+   * ```ts
+   * await page.setRequestInterception(true);
+   * page.on('request', request => {
+   *   // Override headers
+   *   const headers = Object.assign({}, request.headers(), {
+   *     foo: 'bar', // set "foo" header
+   *     origin: undefined, // remove "origin" header
+   *   });
+   *   request.continue({headers});
+   * });
+   * ```
+   *
+   * @param overrides - optional overrides to apply to the request.
+   * @param priority - If provided, intercept is resolved using
+   * cooperative handling rules. Otherwise, intercept is resolved
+   * immediately.
+   */
+  async continue(
+    overrides?: ContinueRequestOverrides,
+    priority?: number
+  ): Promise<void>;
+  async continue(): Promise<void> {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * Fulfills a request with the given response.
+   *
+   * @remarks
+   *
+   * To use this, request
+   * interception should be enabled with {@link Page.setRequestInterception}.
+   *
+   * Exception is immediately thrown if the request interception is not enabled.
+   *
+   * @example
+   * An example of fulfilling all requests with 404 responses:
+   *
+   * ```ts
+   * await page.setRequestInterception(true);
+   * page.on('request', request => {
+   *   request.respond({
+   *     status: 404,
+   *     contentType: 'text/plain',
+   *     body: 'Not Found!',
+   *   });
+   * });
+   * ```
+   *
+   * NOTE: Mocking responses for dataURL requests is not supported.
+   * Calling `request.respond` for a dataURL request is a noop.
+   *
+   * @param response - the response to fulfill the request with.
+   * @param priority - If provided, intercept is resolved using
+   * cooperative handling rules. Otherwise, intercept is resolved
+   * immediately.
+   */
+  async respond(
+    response: Partial<ResponseForRequest>,
+    priority?: number
+  ): Promise<void>;
+  async respond(): Promise<void> {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * Aborts a request.
+   *
+   * @remarks
+   * To use this, request interception should be enabled with
+   * {@link Page.setRequestInterception}. If it is not enabled, this method will
+   * throw an exception immediately.
+   *
+   * @param errorCode - optional error code to provide.
+   * @param priority - If provided, intercept is resolved using
+   * cooperative handling rules. Otherwise, intercept is resolved
+   * immediately.
+   */
+  async abort(errorCode?: ErrorCode, priority?: number): Promise<void>;
+  async abort(): Promise<void> {
+    throw new Error('Not implemented');
+  }
+}
+
+/**
+ * @public
+ */
+export enum InterceptResolutionAction {
+  Abort = 'abort',
+  Respond = 'respond',
+  Continue = 'continue',
+  Disabled = 'disabled',
+  None = 'none',
+  AlreadyHandled = 'already-handled',
+}
+
+/**
+ * @public
+ *
+ * @deprecated please use {@link InterceptResolutionAction} instead.
+ */
+export type InterceptResolutionStrategy = InterceptResolutionAction;
+
+/**
+ * @public
+ */
+export type ErrorCode =
+  | 'aborted'
+  | 'accessdenied'
+  | 'addressunreachable'
+  | 'blockedbyclient'
+  | 'blockedbyresponse'
+  | 'connectionaborted'
+  | 'connectionclosed'
+  | 'connectionfailed'
+  | 'connectionrefused'
+  | 'connectionreset'
+  | 'internetdisconnected'
+  | 'namenotresolved'
+  | 'timedout'
+  | 'failed';
+
+/**
+ * @public
+ */
+export type ActionResult = 'continue' | 'abort' | 'respond';
+
+/**
+ * @internal
+ */
+export function headersArray(
+  headers: Record<string, string | string[]>
+): Array<{name: string; value: string}> {
+  const result = [];
+  for (const name in headers) {
+    const value = headers[name];
+
+    if (!Object.is(value, undefined)) {
+      const values = Array.isArray(value) ? value : [value];
+
+      result.push(
+        ...values.map(value => {
+          return {name, value: value + ''};
+        })
+      );
+    }
+  }
+  return result;
+}
+
+/**
+ * @internal
+ *
+ * @remarks
+ * List taken from {@link https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml}
+ * with extra 306 and 418 codes.
+ */
+export const STATUS_TEXTS: {[key: string]: string | undefined} = {
+  '100': 'Continue',
+  '101': 'Switching Protocols',
+  '102': 'Processing',
+  '103': 'Early Hints',
+  '200': 'OK',
+  '201': 'Created',
+  '202': 'Accepted',
+  '203': 'Non-Authoritative Information',
+  '204': 'No Content',
+  '205': 'Reset Content',
+  '206': 'Partial Content',
+  '207': 'Multi-Status',
+  '208': 'Already Reported',
+  '226': 'IM Used',
+  '300': 'Multiple Choices',
+  '301': 'Moved Permanently',
+  '302': 'Found',
+  '303': 'See Other',
+  '304': 'Not Modified',
+  '305': 'Use Proxy',
+  '306': 'Switch Proxy',
+  '307': 'Temporary Redirect',
+  '308': 'Permanent Redirect',
+  '400': 'Bad Request',
+  '401': 'Unauthorized',
+  '402': 'Payment Required',
+  '403': 'Forbidden',
+  '404': 'Not Found',
+  '405': 'Method Not Allowed',
+  '406': 'Not Acceptable',
+  '407': 'Proxy Authentication Required',
+  '408': 'Request Timeout',
+  '409': 'Conflict',
+  '410': 'Gone',
+  '411': 'Length Required',
+  '412': 'Precondition Failed',
+  '413': 'Payload Too Large',
+  '414': 'URI Too Long',
+  '415': 'Unsupported Media Type',
+  '416': 'Range Not Satisfiable',
+  '417': 'Expectation Failed',
+  '418': "I'm a teapot",
+  '421': 'Misdirected Request',
+  '422': 'Unprocessable Entity',
+  '423': 'Locked',
+  '424': 'Failed Dependency',
+  '425': 'Too Early',
+  '426': 'Upgrade Required',
+  '428': 'Precondition Required',
+  '429': 'Too Many Requests',
+  '431': 'Request Header Fields Too Large',
+  '451': 'Unavailable For Legal Reasons',
+  '500': 'Internal Server Error',
+  '501': 'Not Implemented',
+  '502': 'Bad Gateway',
+  '503': 'Service Unavailable',
+  '504': 'Gateway Timeout',
+  '505': 'HTTP Version Not Supported',
+  '506': 'Variant Also Negotiates',
+  '507': 'Insufficient Storage',
+  '508': 'Loop Detected',
+  '510': 'Not Extended',
+  '511': 'Network Authentication Required',
+} as const;

packages/puppeteer-core/src/api/HTTPResponse.ts

@@ -0,0 +1,169 @@
+/**
+ * Copyright 2023 Google Inc. All rights reserved.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import Protocol from 'devtools-protocol';
+
+import {Frame} from '../common/Frame.js';
+import {SecurityDetails} from '../common/SecurityDetails.js';
+
+import {HTTPRequest} from './HTTPRequest.js';
+
+/**
+ * @public
+ */
+export interface RemoteAddress {
+  ip?: string;
+  port?: number;
+}
+
+/**
+ * The HTTPResponse class represents responses which are received by the
+ * {@link Page} class.
+ *
+ * @public
+ */
+export class HTTPResponse {
+  /**
+   * @internal
+   */
+  constructor() {}
+
+  /**
+   * @internal
+   */
+  _resolveBody(_err: Error | null): void {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns The IP address and port number used to connect to the remote
+   * server.
+   */
+  remoteAddress(): RemoteAddress {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns The URL of the response.
+   */
+  url(): string {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns True if the response was successful (status in the range 200-299).
+   */
+  ok(): boolean {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns The status code of the response (e.g., 200 for a success).
+   */
+  status(): number {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns The status text of the response (e.g. usually an "OK" for a
+   * success).
+   */
+  statusText(): string {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns An object with HTTP headers associated with the response. All
+   * header names are lower-case.
+   */
+  headers(): Record<string, string> {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns {@link SecurityDetails} if the response was received over the
+   * secure connection, or `null` otherwise.
+   */
+  securityDetails(): SecurityDetails | null {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns Timing information related to the response.
+   */
+  timing(): Protocol.Network.ResourceTiming | null {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns Promise which resolves to a buffer with response body.
+   */
+  buffer(): Promise<Buffer> {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns Promise which resolves to a text representation of response body.
+   */
+  async text(): Promise<string> {
+    const content = await this.buffer();
+    return content.toString('utf8');
+  }
+
+  /**
+   *
+   * @returns Promise which resolves to a JSON representation of response body.
+   *
+   * @remarks
+   *
+   * This method will throw if the response body is not parsable via
+   * `JSON.parse`.
+   */
+  async json(): Promise<any> {
+    const content = await this.text();
+    return JSON.parse(content);
+  }
+
+  /**
+   * @returns A matching {@link HTTPRequest} object.
+   */
+  request(): HTTPRequest {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns True if the response was served from either the browser's disk
+   * cache or memory cache.
+   */
+  fromCache(): boolean {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns True if the response was served by a service worker.
+   */
+  fromServiceWorker(): boolean {
+    throw new Error('Not implemented');
+  }
+
+  /**
+   * @returns A {@link Frame} that initiated this response, or `null` if
+   * navigating to error pages.
+   */
+  frame(): Frame | null {
+    throw new Error('Not implemented');
+  }
+}

packages/puppeteer-core/src/api/Page.ts

@@ -18,6 +18,8 @@ import type {Readable} from 'stream';
 
 import {Protocol} from 'devtools-protocol';
 
+import type {HTTPRequest} from '../api/HTTPRequest.js';
+import type {HTTPResponse} from '../api/HTTPResponse.js';
 import type {Accessibility} from '../common/Accessibility.js';
 import type {ConsoleMessage} from '../common/ConsoleMessage.js';
 import type {Coverage} from '../common/Coverage.js';
@@ -31,8 +33,6 @@ import type {
   FrameAddStyleTagOptions,
   FrameWaitForFunctionOptions,
 } from '../common/Frame.js';
-import type {HTTPRequest} from '../common/HTTPRequest.js';
-import type {HTTPResponse} from '../common/HTTPResponse.js';
 import type {
   Keyboard,
   Mouse,

packages/puppeteer-core/src/api/api.ts

@@ -19,3 +19,5 @@ export * from './BrowserContext.js';
 export * from './Page.js';
 export * from './JSHandle.js';
 export * from './ElementHandle.js';
+export * from './HTTPResponse.js';
+export * from './HTTPRequest.js';

packages/puppeteer-core/src/common/Frame.ts

@@ -17,6 +17,7 @@
 import {Protocol} from 'devtools-protocol';
 
 import {ElementHandle} from '../api/ElementHandle.js';
+import {HTTPResponse} from '../api/HTTPResponse.js';
 import {Page} from '../api/Page.js';
 import {isErrorLike} from '../util/ErrorLike.js';
 
@@ -24,7 +25,6 @@ import {CDPSession} from './Connection.js';
 import {ExecutionContext} from './ExecutionContext.js';
 import {FrameManager} from './FrameManager.js';
 import {getQueryHandlerAndSelector} from './GetQueryHandler.js';
-import {HTTPResponse} from './HTTPResponse.js';
 import {MouseButton} from './Input.js';
 import {
   IsolatedWorld,

packages/puppeteer-core/src/common/HTTPRequest.ts

@@ -15,120 +15,35 @@
  */
 import {Protocol} from 'devtools-protocol';
 
+import {
+  ContinueRequestOverrides,
+  ErrorCode,
+  headersArray,
+  HTTPRequest as BaseHTTPRequest,
+  InterceptResolutionAction,
+  InterceptResolutionState,
+  ResourceType,
+  ResponseForRequest,
+  STATUS_TEXTS,
+} from '../api/HTTPRequest.js';
+import {HTTPResponse} from '../api/HTTPResponse.js';
 import {assert} from '../util/assert.js';
 
 import {CDPSession} from './Connection.js';
 import {ProtocolError} from './Errors.js';
 import {Frame} from './Frame.js';
-import {HTTPResponse} from './HTTPResponse.js';
 import {debugError, isString} from './util.js';
 
 /**
- * @public
+ * @internal
  */
-export interface ContinueRequestOverrides {
+export class HTTPRequest extends BaseHTTPRequest {
-  /**
+  override _requestId: string;
-   * If set, the request URL will change. This is not a redirect.
+  override _interceptionId: string | undefined;
-   */
+  override _failureText: string | null = null;
-  url?: string;
+  override _response: HTTPResponse | null = null;
-  method?: string;
+  override _fromMemoryCache = false;
-  postData?: string;
+  override _redirectChain: HTTPRequest[];
-  headers?: Record<string, string>;
-}
-
-/**
- * @public
- */
-export interface InterceptResolutionState {
-  action: InterceptResolutionAction;
-  priority?: number;
-}
-
-/**
- * Required response data to fulfill a request with.
- *
- * @public
- */
-export interface ResponseForRequest {
-  status: number;
-  /**
-   * Optional response headers. All values are converted to strings.
-   */
-  headers: Record<string, unknown>;
-  contentType: string;
-  body: string | Buffer;
-}
-
-/**
- * Resource types for HTTPRequests as perceived by the rendering engine.
- *
- * @public
- */
-export type ResourceType = Lowercase<Protocol.Network.ResourceType>;
-
-/**
- * The default cooperative request interception resolution priority
- *
- * @public
- */
-export const DEFAULT_INTERCEPT_RESOLUTION_PRIORITY = 0;
-
-/**
- * Represents an HTTP request sent by a page.
- * @remarks
- *
- * Whenever the page sends a request, such as for a network resource, the
- * following events are emitted by Puppeteer's `page`:
- *
- * - `request`: emitted when the request is issued by the page.
- * - `requestfinished` - emitted when the response body is downloaded and the
- *   request is complete.
- *
- * If request fails at some point, then instead of `requestfinished` event the
- * `requestfailed` event is emitted.
- *
- * All of these events provide an instance of `HTTPRequest` representing the
- * request that occurred:
- *
- * ```
- * page.on('request', request => ...)
- * ```
- *
- * NOTE: HTTP Error responses, such as 404 or 503, are still successful
- * responses from HTTP standpoint, so request will complete with
- * `requestfinished` event.
- *
- * If request gets a 'redirect' response, the request is successfully finished
- * with the `requestfinished` event, and a new request is issued to a
- * redirected url.
- *
- * @public
- */
-export class HTTPRequest {
-  /**
-   * @internal
-   */
-  _requestId: string;
-  /**
-   * @internal
-   */
-  _interceptionId: string | undefined;
-  /**
-   * @internal
-   */
-  _failureText: string | null = null;
-  /**
-   * @internal
-   */
-  _response: HTTPResponse | null = null;
-  /**
-   * @internal
-   */
-  _fromMemoryCache = false;
-  /**
-   * @internal
-   */
-  _redirectChain: HTTPRequest[];
 
   #client: CDPSession;
   #isNavigationRequest: boolean;
@@ -150,18 +65,10 @@ export class HTTPRequest {
   #interceptHandlers: Array<() => void | PromiseLike<any>>;
   #initiator: Protocol.Network.Initiator;
 
-  /**
+  override get client(): CDPSession {
-   * Warning! Using this client can break Puppeteer. Use with caution.
-   *
-   * @experimental
-   */
-  get client(): CDPSession {
     return this.#client;
   }
 
-  /**
-   * @internal
-   */
   constructor(
     client: CDPSession,
     frame: Frame | null,
@@ -170,6 +77,7 @@ export class HTTPRequest {
     event: Protocol.Network.RequestWillBeSentEvent,
     redirectChain: HTTPRequest[]
   ) {
+    super();
     this.#client = client;
     this._requestId = event.requestId;
     this.#isNavigationRequest =
@@ -191,52 +99,26 @@ export class HTTPRequest {
     }
   }
 
-  /**
+  override url(): string {
-   * @returns the URL of the request
-   */
-  url(): string {
     return this.#url;
   }
 
-  /**
+  override continueRequestOverrides(): ContinueRequestOverrides {
-   * @returns the `ContinueRequestOverrides` that will be used
-   * if the interception is allowed to continue (ie, `abort()` and
-   * `respond()` aren't called).
-   */
-  continueRequestOverrides(): ContinueRequestOverrides {
     assert(this.#allowInterception, 'Request Interception is not enabled!');
     return this.#continueRequestOverrides;
   }
 
-  /**
+  override responseForRequest(): Partial<ResponseForRequest> | null {
-   * @returns The `ResponseForRequest` that gets used if the
-   * interception is allowed to respond (ie, `abort()` is not called).
-   */
-  responseForRequest(): Partial<ResponseForRequest> | null {
     assert(this.#allowInterception, 'Request Interception is not enabled!');
     return this.#responseForRequest;
   }
 
-  /**
+  override abortErrorReason(): Protocol.Network.ErrorReason | null {
-   * @returns the most recent reason for aborting the request
-   */
-  abortErrorReason(): Protocol.Network.ErrorReason | null {
     assert(this.#allowInterception, 'Request Interception is not enabled!');
     return this.#abortErrorReason;
   }
 
-  /**
+  override interceptResolutionState(): InterceptResolutionState {
-   * @returns An InterceptResolutionState object describing the current resolution
-   * action and priority.
-   *
-   * InterceptResolutionState contains:
-   * action: InterceptResolutionAction
-   * priority?: number
-   *
-   * InterceptResolutionAction is one of: `abort`, `respond`, `continue`,
-   * `disabled`, `none`, or `already-handled`.
-   */
-  interceptResolutionState(): InterceptResolutionState {
     if (!this.#allowInterception) {
       return {action: InterceptResolutionAction.Disabled};
     }
@@ -246,31 +128,17 @@ export class HTTPRequest {
     return {...this.#interceptResolutionState};
   }
 
-  /**
+  override isInterceptResolutionHandled(): boolean {
-   * @returns `true` if the intercept resolution has already been handled,
-   * `false` otherwise.
-   */
-  isInterceptResolutionHandled(): boolean {
     return this.#interceptionHandled;
   }
 
-  /**
+  override enqueueInterceptAction(
-   * Adds an async request handler to the processing queue.
-   * Deferred handlers are not guaranteed to execute in any particular order,
-   * but they are guaranteed to resolve before the request interception
-   * is finalized.
-   */
-  enqueueInterceptAction(
     pendingHandler: () => void | PromiseLike<unknown>
   ): void {
     this.#interceptHandlers.push(pendingHandler);
   }
 
-  /**
+  override async finalizeInterceptions(): Promise<void> {
-   * Awaits pending interception handlers and then decides how to fulfill
-   * the request interception.
-   */
-  async finalizeInterceptions(): Promise<void> {
     await this.#interceptHandlers.reduce((promiseChain, interceptAction) => {
       return promiseChain.then(interceptAction);
     }, Promise.resolve());
@@ -288,94 +156,39 @@ export class HTTPRequest {
     }
   }
 
-  /**
+  override resourceType(): ResourceType {
-   * Contains the request's resource type as it was perceived by the rendering
-   * engine.
-   */
-  resourceType(): ResourceType {
     return this.#resourceType;
   }
 
-  /**
+  override method(): string {
-   * @returns the method used (`GET`, `POST`, etc.)
-   */
-  method(): string {
     return this.#method;
   }
 
-  /**
+  override postData(): string | undefined {
-   * @returns the request's post body, if any.
-   */
-  postData(): string | undefined {
     return this.#postData;
   }
 
-  /**
+  override headers(): Record<string, string> {
-   * @returns an object with HTTP headers associated with the request. All
-   * header names are lower-case.
-   */
-  headers(): Record<string, string> {
     return this.#headers;
   }
 
-  /**
+  override response(): HTTPResponse | null {
-   * @returns A matching `HTTPResponse` object, or null if the response has not
-   * been received yet.
-   */
-  response(): HTTPResponse | null {
     return this._response;
   }
 
-  /**
+  override frame(): Frame | null {
-   * @returns the frame that initiated the request, or null if navigating to
-   * error pages.
-   */
-  frame(): Frame | null {
     return this.#frame;
   }
 
-  /**
+  override isNavigationRequest(): boolean {
-   * @returns true if the request is the driver of the current frame's navigation.
-   */
-  isNavigationRequest(): boolean {
     return this.#isNavigationRequest;
   }
 
-  /**
+  override initiator(): Protocol.Network.Initiator {
-   * @returns the initiator of the request.
-   */
-  initiator(): Protocol.Network.Initiator {
     return this.#initiator;
   }
 
-  /**
+  override redirectChain(): HTTPRequest[] {
-   * A `redirectChain` is a chain of requests initiated to fetch a resource.
-   * @remarks
-   *
-   * `redirectChain` is shared between all the requests of the same chain.
-   *
-   * For example, if the website `http://example.com` has a single redirect to
-   * `https://example.com`, then the chain will contain one request:
-   *
-   * ```ts
-   * const response = await page.goto('http://example.com');
-   * const chain = response.request().redirectChain();
-   * console.log(chain.length); // 1
-   * console.log(chain[0].url()); // 'http://example.com'
-   * ```
-   *
-   * If the website `https://google.com` has no redirects, then the chain will be empty:
-   *
-   * ```ts
-   * const response = await page.goto('https://google.com');
-   * const chain = response.request().redirectChain();
-   * console.log(chain.length); // 0
-   * ```
-   *
-   * @returns the chain of requests - if a server responds with at least a
-   * single redirect, this chain will contain all requests that were redirected.
-   */
-  redirectChain(): HTTPRequest[] {
     return this._redirectChain.slice();
   }
 
@@ -399,7 +212,7 @@ export class HTTPRequest {
    * message, e.g. `net::ERR_FAILED`. It is not guaranteed that there will be
    * failure text if the request fails.
    */
-  failure(): {errorText: string} | null {
+  override failure(): {errorText: string} | null {
     if (!this._failureText) {
       return null;
     }
@@ -437,7 +250,7 @@ export class HTTPRequest {
    * cooperative handling rules. Otherwise, intercept is resolved
    * immediately.
    */
-  async continue(
+  override async continue(
     overrides: ContinueRequestOverrides = {},
     priority?: number
   ): Promise<void> {
@@ -501,39 +314,7 @@ export class HTTPRequest {
       });
   }
 
-  /**
+  override async respond(
-   * Fulfills a request with the given response.
-   *
-   * @remarks
-   *
-   * To use this, request
-   * interception should be enabled with {@link Page.setRequestInterception}.
-   *
-   * Exception is immediately thrown if the request interception is not enabled.
-   *
-   * @example
-   * An example of fulfilling all requests with 404 responses:
-   *
-   * ```ts
-   * await page.setRequestInterception(true);
-   * page.on('request', request => {
-   *   request.respond({
-   *     status: 404,
-   *     contentType: 'text/plain',
-   *     body: 'Not Found!',
-   *   });
-   * });
-   * ```
-   *
-   * NOTE: Mocking responses for dataURL requests is not supported.
-   * Calling `request.respond` for a dataURL request is a noop.
-   *
-   * @param response - the response to fulfill the request with.
-   * @param priority - If provided, intercept is resolved using
-   * cooperative handling rules. Otherwise, intercept is resolved
-   * immediately.
-   */
-  async respond(
     response: Partial<ResponseForRequest>,
     priority?: number
   ): Promise<void> {
@@ -614,20 +395,7 @@ export class HTTPRequest {
       });
   }
 
-  /**
+  override async abort(
-   * Aborts a request.
-   *
-   * @remarks
-   * To use this, request interception should be enabled with
-   * {@link Page.setRequestInterception}. If it is not enabled, this method will
-   * throw an exception immediately.
-   *
-   * @param errorCode - optional error code to provide.
-   * @param priority - If provided, intercept is resolved using
-   * cooperative handling rules. Otherwise, intercept is resolved
-   * immediately.
-   */
-  async abort(
     errorCode: ErrorCode = 'failed',
     priority?: number
   ): Promise<void> {
@@ -673,44 +441,6 @@ export class HTTPRequest {
   }
 }
 
-/**
- * @public
- */
-export enum InterceptResolutionAction {
-  Abort = 'abort',
-  Respond = 'respond',
-  Continue = 'continue',
-  Disabled = 'disabled',
-  None = 'none',
-  AlreadyHandled = 'already-handled',
-}
-
-/**
- * @public
- *
- * @deprecated please use {@link InterceptResolutionAction} instead.
- */
-export type InterceptResolutionStrategy = InterceptResolutionAction;
-
-/**
- * @public
- */
-export type ErrorCode =
-  | 'aborted'
-  | 'accessdenied'
-  | 'addressunreachable'
-  | 'blockedbyclient'
-  | 'blockedbyresponse'
-  | 'connectionaborted'
-  | 'connectionclosed'
-  | 'connectionfailed'
-  | 'connectionrefused'
-  | 'connectionreset'
-  | 'internetdisconnected'
-  | 'namenotresolved'
-  | 'timedout'
-  | 'failed';
-
 const errorReasons: Record<ErrorCode, Protocol.Network.ErrorReason> = {
   aborted: 'Aborted',
   accessdenied: 'AccessDenied',
@@ -728,31 +458,6 @@ const errorReasons: Record<ErrorCode, Protocol.Network.ErrorReason> = {
   failed: 'Failed',
 } as const;
 
-/**
- * @public
- */
-export type ActionResult = 'continue' | 'abort' | 'respond';
-
-function headersArray(
-  headers: Record<string, string | string[]>
-): Array<{name: string; value: string}> {
-  const result = [];
-  for (const name in headers) {
-    const value = headers[name];
-
-    if (!Object.is(value, undefined)) {
-      const values = Array.isArray(value) ? value : [value];
-
-      result.push(
-        ...values.map(value => {
-          return {name, value: value + ''};
-        })
-      );
-    }
-  }
-  return result;
-}
-
 async function handleError(error: ProtocolError) {
   if (['Invalid header'].includes(error.originalMessage)) {
     throw error;
@@ -762,72 +467,3 @@ async function handleError(error: ProtocolError) {
   // errors.
   debugError(error);
 }
-
-// List taken from
-// https://www.iana.org/assignments/http-status-codes/http-status-codes.xhtml
-// with extra 306 and 418 codes.
-const STATUS_TEXTS: {[key: string]: string | undefined} = {
-  '100': 'Continue',
-  '101': 'Switching Protocols',
-  '102': 'Processing',
-  '103': 'Early Hints',
-  '200': 'OK',
-  '201': 'Created',
-  '202': 'Accepted',
-  '203': 'Non-Authoritative Information',
-  '204': 'No Content',
-  '205': 'Reset Content',
-  '206': 'Partial Content',
-  '207': 'Multi-Status',
-  '208': 'Already Reported',
-  '226': 'IM Used',
-  '300': 'Multiple Choices',
-  '301': 'Moved Permanently',
-  '302': 'Found',
-  '303': 'See Other',
-  '304': 'Not Modified',
-  '305': 'Use Proxy',
-  '306': 'Switch Proxy',
-  '307': 'Temporary Redirect',
-  '308': 'Permanent Redirect',
-  '400': 'Bad Request',
-  '401': 'Unauthorized',
-  '402': 'Payment Required',
-  '403': 'Forbidden',
-  '404': 'Not Found',
-  '405': 'Method Not Allowed',
-  '406': 'Not Acceptable',
-  '407': 'Proxy Authentication Required',
-  '408': 'Request Timeout',
-  '409': 'Conflict',
-  '410': 'Gone',
-  '411': 'Length Required',
-  '412': 'Precondition Failed',
-  '413': 'Payload Too Large',
-  '414': 'URI Too Long',
-  '415': 'Unsupported Media Type',
-  '416': 'Range Not Satisfiable',
-  '417': 'Expectation Failed',
-  '418': "I'm a teapot",
-  '421': 'Misdirected Request',
-  '422': 'Unprocessable Entity',
-  '423': 'Locked',
-  '424': 'Failed Dependency',
-  '425': 'Too Early',
-  '426': 'Upgrade Required',
-  '428': 'Precondition Required',
-  '429': 'Too Many Requests',
-  '431': 'Request Header Fields Too Large',
-  '451': 'Unavailable For Legal Reasons',
-  '500': 'Internal Server Error',
-  '501': 'Not Implemented',
-  '502': 'Bad Gateway',
-  '503': 'Service Unavailable',
-  '504': 'Gateway Timeout',
-  '505': 'HTTP Version Not Supported',
-  '506': 'Variant Also Negotiates',
-  '507': 'Insufficient Storage',
-  '508': 'Loop Detected',
-  '510': 'Not Extended',
-  '511': 'Network Authentication Required',
-} as const;

packages/puppeteer-core/src/common/HTTPResponse.ts

@@ -15,6 +15,11 @@
  */
 import {Protocol} from 'devtools-protocol';
 
+import {
+  HTTPResponse as BaseHTTPResponse,
+  RemoteAddress,
+} from '../api/HTTPResponse.js';
+
 import {CDPSession} from './Connection.js';
 import {ProtocolError} from './Errors.js';
 import {Frame} from './Frame.js';
@@ -22,20 +27,9 @@ import {HTTPRequest} from './HTTPRequest.js';
 import {SecurityDetails} from './SecurityDetails.js';
 
 /**
- * @public
+ * @internal
  */
-export interface RemoteAddress {
+export class HTTPResponse extends BaseHTTPResponse {
-  ip?: string;
-  port?: number;
-}
-
-/**
- * The HTTPResponse class represents responses which are received by the
- * {@link Page} class.
- *
- * @public
- */
-export class HTTPResponse {
   #client: CDPSession;
   #request: HTTPRequest;
   #contentPromise: Promise<Buffer> | null = null;
@@ -51,15 +45,13 @@ export class HTTPResponse {
   #securityDetails: SecurityDetails | null;
   #timing: Protocol.Network.ResourceTiming | null;
 
-  /**
-   * @internal
-   */
   constructor(
     client: CDPSession,
     request: HTTPRequest,
     responsePayload: Protocol.Network.Response,
     extraInfo: Protocol.Network.ResponseReceivedExtraInfoEvent | null
   ) {
+    super();
     this.#client = client;
     this.#request = request;
 
@@ -111,81 +103,47 @@ export class HTTPResponse {
     return statusText;
   }
 
-  /**
+  override _resolveBody(err: Error | null): void {
-   * @internal
-   */
-  _resolveBody(err: Error | null): void {
     if (err) {
       return this.#bodyLoadedPromiseFulfill(err);
     }
     return this.#bodyLoadedPromiseFulfill();
   }
 
-  /**
+  override remoteAddress(): RemoteAddress {
-   * @returns The IP address and port number used to connect to the remote
-   * server.
-   */
-  remoteAddress(): RemoteAddress {
     return this.#remoteAddress;
   }
 
-  /**
+  override url(): string {
-   * @returns The URL of the response.
-   */
-  url(): string {
     return this.#url;
   }
 
-  /**
+  override ok(): boolean {
-   * @returns True if the response was successful (status in the range 200-299).
-   */
-  ok(): boolean {
     // TODO: document === 0 case?
     return this.#status === 0 || (this.#status >= 200 && this.#status <= 299);
   }
 
-  /**
+  override status(): number {
-   * @returns The status code of the response (e.g., 200 for a success).
-   */
-  status(): number {
     return this.#status;
   }
 
-  /**
+  override statusText(): string {
-   * @returns The status text of the response (e.g. usually an "OK" for a
-   * success).
-   */
-  statusText(): string {
     return this.#statusText;
   }
 
-  /**
+  override headers(): Record<string, string> {
-   * @returns An object with HTTP headers associated with the response. All
-   * header names are lower-case.
-   */
-  headers(): Record<string, string> {
     return this.#headers;
   }
 
-  /**
+  override securityDetails(): SecurityDetails | null {
-   * @returns {@link SecurityDetails} if the response was received over the
-   * secure connection, or `null` otherwise.
-   */
-  securityDetails(): SecurityDetails | null {
     return this.#securityDetails;
   }
 
-  /**
+  override timing(): Protocol.Network.ResourceTiming | null {
-   * @returns Timing information related to the response.
-   */
-  timing(): Protocol.Network.ResourceTiming | null {
     return this.#timing;
   }
 
-  /**
+  override buffer(): Promise<Buffer> {
-   * @returns Promise which resolves to a buffer with response body.
-   */
-  buffer(): Promise<Buffer> {
     if (!this.#contentPromise) {
       this.#contentPromise = this.#bodyLoadedPromise.then(async error => {
         if (error) {
@@ -216,55 +174,19 @@ export class HTTPResponse {
     return this.#contentPromise;
   }
 
-  /**
+  override request(): HTTPRequest {
-   * @returns Promise which resolves to a text representation of response body.
-   */
-  async text(): Promise<string> {
-    const content = await this.buffer();
-    return content.toString('utf8');
-  }
-
-  /**
-   *
-   * @returns Promise which resolves to a JSON representation of response body.
-   *
-   * @remarks
-   *
-   * This method will throw if the response body is not parsable via
-   * `JSON.parse`.
-   */
-  async json(): Promise<any> {
-    const content = await this.text();
-    return JSON.parse(content);
-  }
-
-  /**
-   * @returns A matching {@link HTTPRequest} object.
-   */
-  request(): HTTPRequest {
     return this.#request;
   }
 
-  /**
+  override fromCache(): boolean {
-   * @returns True if the response was served from either the browser's disk
-   * cache or memory cache.
-   */
-  fromCache(): boolean {
     return this.#fromDiskCache || this.#request._fromMemoryCache;
   }
 
-  /**
+  override fromServiceWorker(): boolean {
-   * @returns True if the response was served by a service worker.
-   */
-  fromServiceWorker(): boolean {
     return this.#fromServiceWorker;
   }
 
-  /**
+  override frame(): Frame | null {
-   * @returns A {@link Frame} that initiated this response, or `null` if
-   * navigating to error pages.
-   */
-  frame(): Frame | null {
     return this.#request.frame();
   }
 }

packages/puppeteer-core/src/common/LifecycleWatcher.ts

@@ -14,6 +14,7 @@
  * limitations under the License.
  */
 
+import {HTTPResponse} from '../api/HTTPResponse.js';
 import {assert} from '../util/assert.js';
 import {
   DeferredPromise,
@@ -25,7 +26,6 @@ import {TimeoutError} from './Errors.js';
 import {Frame} from './Frame.js';
 import {FrameManager, FrameManagerEmittedEvents} from './FrameManager.js';
 import {HTTPRequest} from './HTTPRequest.js';
-import {HTTPResponse} from './HTTPResponse.js';
 import {NetworkManagerEmittedEvents} from './NetworkManager.js';
 import {
   addEventListener,

packages/puppeteer-core/src/common/Page.ts

@@ -21,6 +21,7 @@ import {Protocol} from 'devtools-protocol';
 import type {Browser} from '../api/Browser.js';
 import type {BrowserContext} from '../api/BrowserContext.js';
 import {ElementHandle} from '../api/ElementHandle.js';
+import {HTTPResponse} from '../api/HTTPResponse.js';
 import {JSHandle} from '../api/JSHandle.js';
 import {
   GeolocationOptions,
@@ -60,7 +61,6 @@ import {
 } from './Frame.js';
 import {FrameManager, FrameManagerEmittedEvents} from './FrameManager.js';
 import {HTTPRequest} from './HTTPRequest.js';
-import {HTTPResponse} from './HTTPResponse.js';
 import {Keyboard, Mouse, MouseButton, Touchscreen} from './Input.js';
 import {WaitForSelectorOptions} from './IsolatedWorld.js';
 import {MAIN_WORLD} from './IsolatedWorlds.js';

packages/puppeteer-core/src/common/bidi/Page.ts

@@ -16,13 +16,13 @@
 
 import * as Bidi from 'chromium-bidi/lib/cjs/protocol/protocol.js';
 
+import {HTTPResponse} from '../../api/HTTPResponse.js';
 import {
   Page as PageBase,
   PageEmittedEvents,
   WaitForOptions,
 } from '../../api/Page.js';
 import {ConsoleMessage, ConsoleMessageLocation} from '../ConsoleMessage.js';
-import {HTTPResponse} from '../HTTPResponse.js';
 import {EvaluateFunc, HandleFor} from '../types.js';
 
 import {Context, getBidiHandle} from './Context.js';

packages/puppeteer-core/src/common/common.ts

@@ -40,8 +40,6 @@ export * from './FirefoxTargetManager.js';
 export * from './Frame.js';
 export * from './FrameManager.js';
 export * from './FrameTree.js';
-export * from './HTTPRequest.js';
-export * from './HTTPResponse.js';
 export * from './Input.js';
 export * from './IsolatedWorld.js';
 export * from './IsolatedWorlds.js';

test/src/NetworkManager.spec.ts

@@ -15,10 +15,10 @@
  */
 
 import expect from 'expect';
+import {HTTPRequest} from 'puppeteer-core/internal/api/HTTPRequest.js';
+import {HTTPResponse} from 'puppeteer-core/internal/api/HTTPResponse.js';
 import {EventEmitter} from 'puppeteer-core/internal/common/EventEmitter.js';
 import {Frame} from 'puppeteer-core/internal/common/Frame.js';
-import {HTTPRequest} from 'puppeteer-core/internal/common/HTTPRequest.js';
-import {HTTPResponse} from 'puppeteer-core/internal/common/HTTPResponse.js';
 import {
   NetworkManager,
   NetworkManagerEmittedEvents,

test/src/ignorehttpserrors.spec.ts

@@ -19,8 +19,8 @@ import {TLSSocket} from 'tls';
 import expect from 'expect';
 import {Browser} from 'puppeteer-core/internal/api/Browser.js';
 import {BrowserContext} from 'puppeteer-core/internal/api/BrowserContext.js';
+import {HTTPResponse} from 'puppeteer-core/internal/api/HTTPResponse.js';
 import {Page} from 'puppeteer-core/internal/api/Page.js';
-import {HTTPResponse} from 'puppeteer-core/internal/common/HTTPResponse.js';
 
 import {getTestState} from './mocha-utils.js';
 

test/src/navigation.spec.ts

@@ -18,7 +18,7 @@ import {ServerResponse} from 'http';
 
 import expect from 'expect';
 import {TimeoutError} from 'puppeteer';
-import {HTTPRequest} from 'puppeteer-core/internal/common/HTTPRequest.js';
+import {HTTPRequest} from 'puppeteer-core/internal/api/HTTPRequest.js';
 
 import {
   getTestState,

test/src/network.spec.ts

@@ -19,8 +19,8 @@ import {ServerResponse} from 'http';
 import path from 'path';
 
 import expect from 'expect';
-import {HTTPRequest} from 'puppeteer-core/internal/common/HTTPRequest.js';
+import {HTTPRequest} from 'puppeteer-core/internal/api/HTTPRequest.js';
-import {HTTPResponse} from 'puppeteer-core/internal/common/HTTPResponse.js';
+import {HTTPResponse} from 'puppeteer-core/internal/api/HTTPResponse.js';
 
 import {
   getTestState,

test/src/requestinterception-experimental.spec.ts

@@ -18,12 +18,12 @@ import fs from 'fs';
 import path from 'path';
 
 import expect from 'expect';
-import {ConsoleMessage} from 'puppeteer-core/internal/common/ConsoleMessage.js';
 import {
   ActionResult,
   HTTPRequest,
   InterceptResolutionAction,
-} from 'puppeteer-core/internal/common/HTTPRequest.js';
+} from 'puppeteer-core/internal/api/HTTPRequest.js';
+import {ConsoleMessage} from 'puppeteer-core/internal/common/ConsoleMessage.js';
 
 import {
   getTestState,

test/src/requestinterception.spec.ts

@@ -18,8 +18,8 @@ import fs from 'fs';
 import path from 'path';
 
 import expect from 'expect';
+import {HTTPRequest} from 'puppeteer-core/internal/api/HTTPRequest.js';
 import {ConsoleMessage} from 'puppeteer-core/internal/common/ConsoleMessage.js';
-import {HTTPRequest} from 'puppeteer-core/internal/common/HTTPRequest.js';
 
 import {
   getTestState,