system-testing 1.0.33 → 1.0.34

package/dist/system-test.d.ts

@@ -0,0 +1,297 @@
+export default class SystemTest {
+    static rootPath: string;
+    /**
+     * Gets the current system test instance
+     * @param {object} [args]
+     * @param {string} [args.host]
+     * @param {number} [args.port]
+     * @returns {SystemTest}
+     */
+    static current(args?: {
+        host?: string;
+        port?: number;
+    }): SystemTest;
+    /**
+     * Runs a system test
+     * @param {function(SystemTest): Promise<void>} callback
+     * @returns {Promise<void>}
+     */
+    static run(callback: (arg0: SystemTest) => Promise<void>): Promise<void>;
+    /**
+     * Creates a new SystemTest instance
+     * @param {object} [args]
+     * @param {string} [args.host]
+     * @param {number} [args.port]
+     */
+    constructor({ host, port, ...restArgs }?: {
+        host?: string;
+        port?: number;
+    });
+    /** @type {SystemTestCommunicator | undefined} */
+    communicator: SystemTestCommunicator | undefined;
+    /** @type {import("selenium-webdriver").WebDriver | undefined} */
+    driver: import("selenium-webdriver").WebDriver | undefined;
+    _started: boolean;
+    _driverTimeouts: number;
+    _timeouts: number;
+    getCommunicator(): SystemTestCommunicator;
+    _host: string;
+    _port: number;
+    /** @type {Record<number, object>} */
+    _responses: Record<number, object>;
+    _sendCount: number;
+    /**
+     * Gets the base selector for scoping element searches
+     * @returns {string | undefined}
+     */
+    getBaseSelector(): string | undefined;
+    /**
+     * @returns {import("selenium-webdriver").WebDriver}
+     */
+    getDriver(): import("selenium-webdriver").WebDriver;
+    /**
+     * Sets the base selector for scoping element searches
+     * @param {string} baseSelector
+     */
+    setBaseSelector(baseSelector: string): void;
+    _baseSelector: string;
+    /**
+     * Gets a selector scoped to the base selector
+     * @param {string} selector
+     * @returns {string}
+     */
+    getSelector(selector: string): string;
+    /**
+     * Starts Scoundrel server which the browser connects to for remote evaluation in the browser
+     * @returns {void}
+     */
+    startScoundrel(): void;
+    wss: import("ws").Server<typeof import("ws").default, typeof import("node:http").IncomingMessage>;
+    serverWebSocket: any;
+    server: any;
+    /**
+     * @returns {void}
+     */
+    stopScoundrel(): void;
+    /**
+     * Finds all elements by CSS selector
+     * @param {string} selector
+     * @param {object} args
+     * @param {number} [args.timeout]
+     * @param {boolean} [args.visible]
+     * @param {boolean} [args.useBaseSelector]
+     * @returns {Promise<import("selenium-webdriver").WebElement[]>}
+     */
+    all(selector: string, args?: {
+        timeout?: number;
+        visible?: boolean;
+        useBaseSelector?: boolean;
+    }): Promise<import("selenium-webdriver").WebElement[]>;
+    /**
+     * Clicks an element that has children which fills out the element and would otherwise have caused a ElementClickInterceptedError
+     * @param {string|import("selenium-webdriver").WebElement} elementOrIdentifier
+     * @returns {Promise<void>}
+     */
+    click(elementOrIdentifier: string | import("selenium-webdriver").WebElement): Promise<void>;
+    /**
+     * Finds a single element by CSS selector
+     * @param {string} selector
+     * @param {object} args
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    find(selector: string, args?: object): Promise<import("selenium-webdriver").WebElement>;
+    /**
+     * Finds a single element by test ID
+     * @param {string} testID
+     * @param {object} args
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    findByTestID(testID: string, args: object): Promise<import("selenium-webdriver").WebElement>;
+    /**
+     * @param {string|import("selenium-webdriver").WebElement} elementOrIdentifier
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    _findElement(elementOrIdentifier: string | import("selenium-webdriver").WebElement): Promise<import("selenium-webdriver").WebElement>;
+    /**
+     * Finds a single element by CSS selector without waiting
+     * @param {string} selector
+     * @param {object} [args]
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    findNoWait(selector: string, args?: object): Promise<import("selenium-webdriver").WebElement>;
+    /**
+     * Gets browser logs
+     * @returns {Promise<string[]>}
+     */
+    getBrowserLogs(): Promise<string[]>;
+    /**
+     * @returns {Promise<string>}
+     */
+    getCurrentUrl(): Promise<string>;
+    /**
+     * @returns {number}
+     */
+    getTimeouts(): number;
+    /**
+     * Interacts with an element by calling a method on it with the given arguments.
+     * Retrying on ElementNotInteractableError.
+     * @param {import("selenium-webdriver").WebElement|string} elementOrIdentifier - The element or a CSS selector to find the element.
+     * @param {string} methodName - The method name to call on the element.
+     * @param {...any} args - Arguments to pass to the method.
+     * @returns {Promise<any>}
+     */
+    interact(elementOrIdentifier: import("selenium-webdriver").WebElement | string, methodName: string, ...args: any[]): Promise<any>;
+    /**
+     * Expects no element to be found by CSS selector
+     * @param {string} selector
+     * @returns {Promise<void>}
+     */
+    expectNoElement(selector: string): Promise<void>;
+    /**
+     * @param {string} selector
+     * @param {object} args
+     * @param {boolean} [args.useBaseSelector]
+     * @returns {Promise<void>}
+     */
+    waitForNoSelector(selector: string, args: {
+        useBaseSelector?: boolean;
+    }): Promise<void>;
+    /**
+     * Gets notification messages
+     * @returns {Promise<string[]>}
+     */
+    notificationMessages(): Promise<string[]>;
+    /**
+     * Expects a notification message to appear and waits for it if necessary.
+     * @param {string} expectedNotificationMessage
+     * @returns {Promise<void>}
+     */
+    expectNotificationMessage(expectedNotificationMessage: string): Promise<void>;
+    /**
+     * @returns {Promise<void>}
+     */
+    dismissNotificationMessages(): Promise<void>;
+    /**
+     * Indicates whether the system test has been started
+     * @returns {boolean}
+     */
+    isStarted(): boolean;
+    /**
+     * Gets the HTML of the current page
+     * @returns {Promise<string>}
+     */
+    getHTML(): Promise<string>;
+    /**
+     * Starts the system test
+     * @returns {Promise<void>}
+     */
+    start(): Promise<void>;
+    currentUrl: string;
+    systemTestHttpServer: SystemTestHttpServer;
+    /**
+     * Restores previously set timeouts
+     * @returns {Promise<void>}
+     */
+    restoreTimeouts(): Promise<void>;
+    /**
+     * Sets driver timeouts
+     * @param {number} newTimeout
+     * @returns {Promise<void>}
+     */
+    driverSetTimeouts(newTimeout: number): Promise<void>;
+    /**
+     * Sets timeouts and stores the previous timeouts
+     * @param {number} newTimeout
+     * @returns {Promise<void>}
+     */
+    setTimeouts(newTimeout: number): Promise<void>;
+    /**
+     * Waits for the client web socket to connect
+     * @returns {Promise<void>}
+     */
+    waitForClientWebSocket(): Promise<void>;
+    waitForClientWebSocketPromiseResolve: (value: void | PromiseLike<void>) => void;
+    /**
+     * Starts the web socket server
+     * @returns {void}
+     */
+    startWebSocketServer(): void;
+    /**
+     * Sets the on command callback
+     * @param {function({type: string, data: Record<string, any>}): Promise<void>} callback
+     * @returns {void}
+     */
+    onCommand(callback: (arg0: {
+        type: string;
+        data: Record<string, any>;
+    }) => Promise<void>): void;
+    _onCommandCallback: (arg0: {
+        type: string;
+        data: Record<string, any>;
+    }) => Promise<void>;
+    /**
+     * Handles a command received from the browser
+     * @param {{data: {message: string, backtrace: string, type: string, value: any[]}}} args
+     * @returns {Promise<any>}
+     */
+    onCommandReceived: ({ data }: {
+        data: {
+            message: string;
+            backtrace: string;
+            type: string;
+            value: any[];
+        };
+    }) => Promise<any>;
+    /**
+     * Handles a new web socket connection
+     * @param {WebSocket} ws
+     * @returns {Promise<void>}
+     */
+    onWebSocketConnection: (ws: WebSocket) => Promise<void>;
+    ws: WebSocket;
+    /**
+     * @returns {void}
+     */
+    onWebSocketClose: () => void;
+    /**
+     * Handles an error reported from the browser
+     * @param {object} data
+     * @param {string} data.message
+     * @param {string} [data.backtrace]
+     * @returns {void}
+     */
+    handleError(data: {
+        message: string;
+        backtrace?: string;
+    }): void;
+    /**
+     * Stops the system test
+     * @returns {Promise<void>}
+     */
+    stop(): Promise<void>;
+    /**
+     * Visits a path in the browser
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    driverVisit(path: string): Promise<void>;
+    /**
+     * Takes a screenshot, saves HTML and browser logs
+     * @returns {Promise<void>}
+     */
+    takeScreenshot(): Promise<void>;
+    /**
+     * Visits a path in the browser
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    visit(path: string): Promise<void>;
+    /**
+     * Dismisses to a path in the browser
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    dismissTo(path: string): Promise<void>;
+}
+import SystemTestCommunicator from "./system-test-communicator.js";
+import SystemTestHttpServer from "./system-test-http-server.js";