webdriverio/build/utils/interception/index.d.ts

Next-gen browser and mobile automation test framework for Node.js

import type { JsonCompatible } from '@wdio/types';
import { type local, type remote } from 'webdriver';
import { URLPattern } from 'urlpattern-polyfill';
import type { MockFilterOptions, RequestWithOptions, RespondWithOptions, Response } from './types.js';
import type { WaitForOptions } from '../../types.js';
type RespondBodyValue = string | JsonCompatible | ArrayBufferView | ArrayBuffer;
type RespondBody = RespondBodyValue | ((request: local.NetworkResponseCompletedParameters) => RespondBodyValue);
/**
 * Network interception class based on a WebDriver Bidi implementation.
 *
 * Note: this code is executed in Node.js and in the browser, so make sure
 *       you use primitives that work in both environments.
 */
export default class WebDriverInterception {
    #private;
    constructor(pattern: URLPattern, mockId: string, filterOptions: MockFilterOptions, browser: WebdriverIO.Browser, isCollectingNetworkData?: boolean, sessionKey?: string, contexts?: string[]);
    static initiate(url: string | URLPattern | globalThis.URLPattern, filterOptions: MockFilterOptions, browser: WebdriverIO.Browser, scope?: {
        contexts?: string[];
        sessionKey?: string;
        test?: string;
    }): Promise<WebDriverInterception>;
    /**
     * Read a cached binary overwrite as a Buffer in Node.js or Uint8Array in browsers.
     */
    getBinaryResponse(requestId: string): Uint8Array | null;
    /**
     * Simulate a responseStarted event for testing purposes
     * @param request NetworkResponseCompletedParameters to simulate
     */
    simulateResponseStarted(request: Response): void;
    debugResponseBodies(): Map<string, remote.NetworkBytesValue>;
    /**
     * allows access to all requests made with given pattern
     */
    get calls(): Response[];
    get hasAtLeastOneResponseReceived(): boolean;
    /**
     * Resets all information stored in the `mock.calls` set.
     */
    clear(): this;
    /**
     * Does what `mock.clear()` does and makes removes custom request overrides
     * and response overwrites
     */
    reset(): this;
    /**
     * Does everything that `mock.reset()` does, and also
     * removes any mocked return values or implementations.
     * Restored mock does not emit events and could not mock responses
     */
    restore(): Promise<this>;
    /**
     * Always use request modification for the next request done by the browser.
     * @param payload  payload to overwrite the request
     * @param once     apply overwrite only once for the next request
     * @returns        this instance to chain commands
     */
    request(overwrite: RequestWithOptions, once?: boolean): this;
    /**
     * alias for `mock.request(…, true)`
     */
    requestOnce(payload: RequestWithOptions): this;
    /**
     * Always respond with same overwrite
     * @param {*}       payload  payload to overwrite the response
     * @param {*}       params   additional respond parameters to overwrite
     * @param {boolean} once     apply overwrite only once for the next request
     * @returns                  this instance to chain commands
     */
    respond(payload: RespondBody, params?: Omit<RespondWithOptions, 'body'>, once?: boolean): this;
    /**
     * alias for `mock.respond(…, true)`
     */
    respondOnce(payload: RespondBody, params?: Omit<RespondWithOptions, 'body'>): this;
    /**
     * Abort the request with an error code
     * @param {string} errorReason  error code of the response
     * @param {boolean} once        if request should be aborted only once for the next request
     */
    abort(once?: boolean): this;
    /**
     * alias for `mock.abort(true)`
     */
    abortOnce(): this;
    /**
     * Redirect request to another URL
     * @param {string} redirectUrl  URL to redirect to
     * @param {boolean} sticky      if request should be redirected for all following requests
     */
    redirect(redirectUrl: string, once?: boolean): this;
    /**
     * alias for `mock.redirect(…, true)`
     */
    redirectOnce(redirectUrl: string): this;
    on(event: 'request', callback: (request: local.NetworkBeforeRequestSentParameters) => void): WebDriverInterception;
    on(event: 'match', callback: (match: local.NetworkBeforeRequestSentParameters) => void): WebDriverInterception;
    on(event: 'continue', callback: (requestId: string) => void): WebDriverInterception;
    on(event: 'fail', callback: (requestId: string) => void): WebDriverInterception;
    on(event: 'overwrite', callback: (response: Response) => void): WebDriverInterception;
    /**
     * Whether this mock belongs to the given browser session, and to the given tab or
     * parallel test if one is passed. `SESSION_MOCKS` is shared by all instances of a
     * multi-remote browser. Compares session ids rather than objects so that a client attached
     * to the same session via `attach()` still owns mocks created by another client of that session.
     * @param browser        browser instance to check
     * @param scope.context  a tab: only mocks made for that tab match
     * @param scope.test     the window of a parallel test: only mocks that test created match, also on tabs it opened
     * @returns              `true` if this mock belongs to that browser's session (and scope)
     */
    isOwnedBy(browser: WebdriverIO.Browser, { context, test }?: {
        context?: string;
        test?: string;
    }): boolean;
    isSameDefinition(url: string | URLPattern | globalThis.URLPattern, filterOptions?: MockFilterOptions): boolean;
    waitForResponse({ timeout, interval, timeoutMsg, }?: WaitForOptions): Promise<boolean> | Promise<Promise<boolean>>;
}
export declare function parseUrlPattern(url: string | URLPattern | globalThis.URLPattern): URLPattern;
/**
 * A pattern that matches exactly the given URL: the characters that are pattern syntax in
 * `parseUrlPattern` (`+` and `:` of a query, for example) are matched literally. The request
 * the browser sends for the URL has no fragment and no credentials, so these match anything.
 */
export declare function parseLiteralUrlPattern(url: string): URLPattern;
export {};
//# sourceMappingURL=index.d.ts.map