system-testing 1.0.35 → 1.0.37

package/build/system-test.js

@@ -0,0 +1,696 @@
+// @ts-check
+import { Builder, By } from "selenium-webdriver";
+import chrome from "selenium-webdriver/chrome.js";
+import { digg } from "diggerize";
+import fs from "node:fs/promises";
+import logging from "selenium-webdriver/lib/logging.js";
+import moment from "moment";
+import { prettify } from "htmlfy";
+import Server from "scoundrel-remote-eval/build/server/index.js";
+import ServerWebSocket from "scoundrel-remote-eval/build/server/connections/web-socket/index.js";
+import SystemTestCommunicator from "./system-test-communicator.js";
+import SystemTestHttpServer from "./system-test-http-server.js";
+import { wait, waitFor } from "awaitery";
+import { WebSocketServer } from "ws";
+class ElementNotFoundError extends Error {
+}
+class SystemTest {
+    /**
+     * Gets the current system test instance
+     * @param {object} [args]
+     * @param {string} [args.host]
+     * @param {number} [args.port]
+     * @returns {SystemTest}
+     */
+    static current(args) {
+        if (!globalThis.systemTest) {
+            globalThis.systemTest = new SystemTest(args);
+        }
+        return globalThis.systemTest;
+    }
+    /** @returns {SystemTestCommunicator} */
+    getCommunicator() {
+        if (!this.communicator) {
+            throw new Error("Communicator hasn't been initialized yet");
+        }
+        return this.communicator;
+    }
+    /**
+     * Runs a system test
+     * @param {function(SystemTest): Promise<void>} callback
+     * @returns {Promise<void>}
+     */
+    static async run(callback) {
+        const systemTest = this.current();
+        await systemTest.getCommunicator().sendCommand({ type: "initialize" });
+        await systemTest.dismissTo(SystemTest.rootPath);
+        try {
+            await systemTest.findByTestID("blankText", { useBaseSelector: false });
+            await callback(systemTest);
+        }
+        catch (error) {
+            await systemTest.takeScreenshot();
+            throw error;
+        }
+    }
+    /**
+     * Creates a new SystemTest instance
+     * @param {object} [args]
+     * @param {string} [args.host]
+     * @param {number} [args.port]
+     */
+    constructor({ host = "localhost", port = 8081, ...restArgs } = { host: "localhost", port: 8081 }) {
+        /** @type {SystemTestCommunicator | undefined} */
+        this.communicator = undefined;
+        /** @type {import("selenium-webdriver").WebDriver | undefined} */
+        this.driver = undefined;
+        this._started = false;
+        this._driverTimeouts = 5000;
+        this._timeouts = 5000;
+        /**
+         * Handles a command received from the browser
+         * @param {{data: {message: string, backtrace: string, type: string, value: any[]}}} args
+         * @returns {Promise<any>}
+         */
+        this.onCommandReceived = async ({ data }) => {
+            const type = data.type;
+            let result;
+            if (type == "console.error") {
+                const errorMessage = data.value[0];
+                let showMessage = true;
+                if (errorMessage.includes("Minified React error #419")) {
+                    showMessage = false;
+                }
+                if (showMessage) {
+                    console.error("Browser error", ...data.value);
+                }
+            }
+            else if (type == "console.log") {
+                console.log("Browser log", ...data.value);
+            }
+            else if (type == "error" || data.type == "unhandledrejection") {
+                this.handleError(data);
+            }
+            else if (this._onCommandCallback) {
+                result = await this._onCommandCallback({ data, type });
+            }
+            else {
+                console.error(`onWebSocketClientMessage unknown data (type ${type})`, data);
+            }
+            return result;
+        };
+        /**
+         * Handles a new web socket connection
+         * @param {WebSocket} ws
+         * @returns {Promise<void>}
+         */
+        this.onWebSocketConnection = async (ws) => {
+            this.ws = ws;
+            this.getCommunicator().ws = ws;
+            this.getCommunicator().onOpen();
+            // @ts-expect-error
+            this.ws.on("error", digg(this, "communicator", "onError"));
+            // @ts-expect-error
+            this.ws.on("message", digg(this, "communicator", "onMessage"));
+            if (this.waitForClientWebSocketPromiseResolve) {
+                this.waitForClientWebSocketPromiseResolve();
+                delete this.waitForClientWebSocketPromiseResolve;
+            }
+        };
+        /** @returns {void} */
+        this.onWebSocketClose = () => {
+            this.ws = null;
+            this.getCommunicator().ws = null;
+        };
+        const restArgsKeys = Object.keys(restArgs);
+        if (restArgsKeys.length > 0) {
+            throw new Error(`Unknown arguments: ${restArgsKeys.join(", ")}`);
+        }
+        this._host = host;
+        this._port = port;
+        /** @type {Record<number, object>} */
+        this._responses = {};
+        this._sendCount = 0;
+        this.startScoundrel();
+        this.communicator = new SystemTestCommunicator({ onCommand: this.onCommandReceived });
+    }
+    /**
+     * Gets the base selector for scoping element searches
+     * @returns {string | undefined}
+     */
+    getBaseSelector() { return this._baseSelector; }
+    /** @returns {import("selenium-webdriver").WebDriver} */
+    getDriver() {
+        if (!this)
+            throw new Error("No this?");
+        if (!this.driver)
+            throw new Error("Driver hasn't been initialized yet");
+        return this.driver;
+    }
+    /**
+     * Sets the base selector for scoping element searches
+     * @param {string} baseSelector
+     */
+    setBaseSelector(baseSelector) { this._baseSelector = baseSelector; }
+    /**
+     * Gets a selector scoped to the base selector
+     * @param {string} selector
+     * @returns {string}
+     */
+    getSelector(selector) {
+        return this.getBaseSelector() ? `${this.getBaseSelector()} ${selector}` : selector;
+    }
+    /**
+     * Starts Scoundrel server which the browser connects to for remote evaluation in the browser
+     * @returns {void}
+     */
+    startScoundrel() {
+        if (this.wss)
+            throw new Error("Scoundrel server already started");
+        this.wss = new WebSocketServer({ port: 8090 });
+        this.serverWebSocket = new ServerWebSocket(this.wss);
+        this.server = new Server(this.serverWebSocket);
+    }
+    /**
+     * @returns {void}
+     */
+    stopScoundrel() {
+        this.server?.close();
+        this.wss?.close();
+    }
+    /**
+     * 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[]>}
+     */
+    async all(selector, args = {}) {
+        const { visible = true, timeout, useBaseSelector = true, ...restArgs } = args;
+        const restArgsKeys = Object.keys(restArgs);
+        let actualTimeout;
+        if (timeout === undefined) {
+            actualTimeout = this._driverTimeouts;
+        }
+        else {
+            actualTimeout = timeout;
+        }
+        if (restArgsKeys.length > 0)
+            throw new Error(`Unknown arguments: ${restArgsKeys.join(", ")}`);
+        const actualSelector = useBaseSelector ? this.getSelector(selector) : selector;
+        const getElements = async () => await this.getDriver().findElements(By.css(actualSelector));
+        let elements = [];
+        if (actualTimeout == 0) {
+            elements = await getElements();
+        }
+        else {
+            await this.getDriver().wait(async () => {
+                elements = await getElements();
+                return elements.length > 0;
+            }, actualTimeout);
+        }
+        const activeElements = [];
+        for (const element of elements) {
+            let keep = true;
+            if (visible === true || visible === false) {
+                const isDisplayed = await element.isDisplayed();
+                if (visible && !isDisplayed)
+                    keep = false;
+                if (!visible && isDisplayed)
+                    keep = false;
+            }
+            if (keep)
+                activeElements.push(element);
+        }
+        return activeElements;
+    }
+    /**
+     * 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>}
+     */
+    async click(elementOrIdentifier) {
+        let tries = 0;
+        while (true) {
+            tries++;
+            try {
+                const element = await this._findElement(elementOrIdentifier);
+                const actions = this.getDriver().actions({ async: true });
+                await actions.move({ origin: element }).click().perform();
+                break;
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    if (error.constructor.name === "ElementNotInteractableError") {
+                        if (tries >= 3) {
+                            throw new Error(`Element ${elementOrIdentifier.constructor.name} click failed after ${tries} tries - ${error.constructor.name}: ${error.message}`);
+                        }
+                        else {
+                            await wait(50);
+                        }
+                    }
+                    else {
+                        // Re-throw with un-corrupted stack trace
+                        throw new Error(`Element ${elementOrIdentifier.constructor.name} click failed - ${error.constructor.name}: ${error.message}`);
+                    }
+                }
+                else {
+                    throw new Error(`Element ${elementOrIdentifier.constructor.name} click failed - ${typeof error}: ${error}`);
+                }
+            }
+        }
+    }
+    /**
+     * Finds a single element by CSS selector
+     * @param {string} selector
+     * @param {object} [args]
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    async find(selector, args = {}) {
+        let elements = [];
+        try {
+            elements = await this.all(selector, args);
+        }
+        catch (error) {
+            // Re-throw to recover stack trace
+            if (error instanceof Error) {
+                if (error.message.startsWith("Wait timed out after")) {
+                    elements = [];
+                }
+                throw new Error(`${error.message} (selector: ${this.getSelector(selector)})`);
+            }
+            else {
+                throw new Error(`${error} (selector: ${this.getSelector(selector)})`);
+            }
+        }
+        if (elements.length > 1) {
+            throw new Error(`More than 1 elements (${elements.length}) was found by CSS: ${this.getSelector(selector)}`);
+        }
+        if (!elements[0]) {
+            throw new ElementNotFoundError(`Element couldn't be found after ${(this.getTimeouts() / 1000).toFixed(2)}s by CSS: ${this.getSelector(selector)}`);
+        }
+        return elements[0];
+    }
+    /**
+     * Finds a single element by test ID
+     * @param {string} testID
+     * @param {object} [args]
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    async findByTestID(testID, args) { return await this.find(`[data-testid='${testID}']`, args); }
+    /**
+     * @param {string|import("selenium-webdriver").WebElement} elementOrIdentifier
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    async _findElement(elementOrIdentifier) {
+        let element;
+        if (typeof elementOrIdentifier == "string") {
+            element = await this.find(elementOrIdentifier);
+        }
+        else {
+            element = elementOrIdentifier;
+        }
+        return element;
+    }
+    /**
+     * Finds a single element by CSS selector without waiting
+     * @param {string} selector
+     * @param {object} [args]
+     * @returns {Promise<import("selenium-webdriver").WebElement>}
+     */
+    async findNoWait(selector, args) {
+        await this.driverSetTimeouts(0);
+        try {
+            return await this.find(selector, args);
+        }
+        finally {
+            await this.restoreTimeouts();
+        }
+    }
+    /**
+     * Gets browser logs
+     * @returns {Promise<string[]>}
+     */
+    async getBrowserLogs() {
+        const entries = await this.getDriver().manage().logs().get(logging.Type.BROWSER);
+        const browserLogs = [];
+        for (const entry of entries) {
+            const messageMatch = entry.message.match(/^(.+) (\d+):(\d+) (.+)$/);
+            let message;
+            if (messageMatch) {
+                message = messageMatch[4];
+            }
+            else {
+                message = entry.message;
+            }
+            browserLogs.push(`${entry.level.name}: ${message}`);
+        }
+        return browserLogs;
+    }
+    /** @returns {Promise<string>} */
+    async getCurrentUrl() {
+        return await this.getDriver().getCurrentUrl();
+    }
+    /** @returns {number} */
+    getTimeouts() { return this._timeouts; }
+    /**
+     * 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>}
+     */
+    async interact(elementOrIdentifier, methodName, ...args) {
+        let tries = 0;
+        while (true) {
+            tries++;
+            const element = await this._findElement(elementOrIdentifier);
+            if (!element[methodName]) {
+                throw new Error(`${element.constructor.name} hasn't an attribute named: ${methodName}`);
+            }
+            else if (typeof element[methodName] != "function") {
+                throw new Error(`${element.constructor.name}#${methodName} is not a function`);
+            }
+            try {
+                // Dont call with candidate, because that will bind the function wrong.
+                return await element[methodName](...args);
+            }
+            catch (error) {
+                if (error instanceof Error) {
+                    if (error.constructor.name === "ElementNotInteractableError") {
+                        // Retry finding the element and interacting with it
+                        if (tries >= 3) {
+                            let elementDescription;
+                            if (typeof elementOrIdentifier == "string") {
+                                elementDescription = `CSS selector ${elementOrIdentifier}`;
+                            }
+                            else {
+                                elementDescription = `${element.constructor.name}`;
+                            }
+                            throw new Error(`${elementDescription} ${methodName} failed after ${tries} tries - ${error.constructor.name}: ${error.message}`);
+                        }
+                        else {
+                            await wait(50);
+                        }
+                    }
+                    else {
+                        // Re-throw with un-corrupted stack trace
+                        throw new Error(`${element.constructor.name} ${methodName} failed - ${error.constructor.name}: ${error.message}`);
+                    }
+                }
+                else {
+                    throw new Error(`${element.constructor.name} ${methodName} failed - ${typeof error}: ${error}`);
+                }
+            }
+        }
+    }
+    /**
+     * Expects no element to be found by CSS selector
+     * @param {string} selector
+     * @returns {Promise<void>}
+     */
+    async expectNoElement(selector) {
+        let found = false;
+        try {
+            await this.findNoWait(selector);
+            found = true;
+        }
+        catch (error) {
+            if (error instanceof Error && error.message.startsWith("Element couldn't be found after ")) {
+                // Ignore
+            }
+            else {
+                throw error;
+            }
+        }
+        if (found) {
+            throw new Error(`Expected not to find: ${selector}`);
+        }
+    }
+    /**
+     * @param {string} selector
+     * @param {object} [args]
+     * @param {boolean} [args.useBaseSelector]
+     * @returns {Promise<void>}
+     */
+    async waitForNoSelector(selector, args) {
+        const { useBaseSelector, ...restArgs } = args;
+        if (Object.keys(restArgs).length > 0) {
+            throw new Error(`Unexpected args: ${Object.keys(restArgs).join(", ")}`);
+        }
+        const actualSelector = useBaseSelector ? this.getSelector(selector) : selector;
+        await this.getDriver().wait(async () => {
+            const elements = await this.getDriver().findElements(By.css(actualSelector));
+            // Not found at all
+            if (elements.length === 0) {
+                return true;
+            }
+            // Found but not visible
+            const isDisplayed = await elements[0].isDisplayed();
+            return !isDisplayed;
+        }, this.getTimeouts());
+    }
+    /**
+     * Gets notification messages
+     * @returns {Promise<string[]>}
+     */
+    async notificationMessages() {
+        const notificationMessageElements = await this.all("[data-class='notification-message']", { useBaseSelector: false });
+        const notificationMessageTexts = [];
+        for (const notificationMessageElement of notificationMessageElements) {
+            const text = await notificationMessageElement.getText();
+            notificationMessageTexts.push(text);
+        }
+        return notificationMessageTexts;
+    }
+    /**
+     * Expects a notification message to appear and waits for it if necessary.
+     * @param {string} expectedNotificationMessage
+     * @returns {Promise<void>}
+     */
+    async expectNotificationMessage(expectedNotificationMessage) {
+        /** @type {string[]} */
+        const allDetectedNotificationMessages = [];
+        let foundNotificationMessageElement;
+        await waitFor(async () => {
+            const notificationMessageElements = await this.all("[data-class='notification-message']", { useBaseSelector: false });
+            for (const notificationMessageElement of notificationMessageElements) {
+                const notificationMessage = await notificationMessageElement.getText();
+                if (!allDetectedNotificationMessages.includes(notificationMessage)) {
+                    allDetectedNotificationMessages.push(notificationMessage);
+                }
+                if (notificationMessage == expectedNotificationMessage) {
+                    foundNotificationMessageElement = notificationMessageElement;
+                    return;
+                }
+            }
+            throw new Error(`Notification message ${expectedNotificationMessage} wasn't included in: ${allDetectedNotificationMessages.join(", ")}`);
+        });
+        if (foundNotificationMessageElement) {
+            await this.interact(foundNotificationMessageElement, "click"); // Dismiss the notification message
+        }
+    }
+    /** @returns {Promise<void>} */
+    async dismissNotificationMessages() {
+        const notificationMessageElements = await this.all("[data-class='notification-message']", { useBaseSelector: false });
+        for (const notificationMessageElement of notificationMessageElements) {
+            await this.interact(notificationMessageElement, "click");
+        }
+        await this.waitForNoSelector("[data-class='notification-message']", { useBaseSelector: false });
+    }
+    /**
+     * Indicates whether the system test has been started
+     * @returns {boolean}
+     */
+    isStarted() { return this._started; }
+    /**
+     * Gets the HTML of the current page
+     * @returns {Promise<string>}
+     */
+    async getHTML() { return await this.getDriver().getPageSource(); }
+    /**
+     * Starts the system test
+     * @returns {Promise<void>}
+     */
+    async start() {
+        if (process.env.SYSTEM_TEST_HOST == "expo-dev-server") {
+            this.currentUrl = `http://${this._host}:${this._port}`;
+        }
+        else if (process.env.SYSTEM_TEST_HOST == "dist") {
+            this.currentUrl = `http://${this._host}:1984`;
+            this.systemTestHttpServer = new SystemTestHttpServer();
+            await this.systemTestHttpServer.start();
+        }
+        else {
+            throw new Error("Please set SYSTEM_TEST_HOST to 'expo-dev-server' or 'dist'");
+        }
+        const options = new chrome.Options();
+        options.addArguments("--disable-dev-shm-usage");
+        options.addArguments("--disable-gpu");
+        options.addArguments("--headless=new");
+        options.addArguments("--no-sandbox");
+        options.addArguments("--window-size=1920,1080");
+        this.driver = new Builder()
+            .forBrowser("chrome")
+            .setChromeOptions(options)
+            // @ts-expect-error
+            .setCapability("goog:loggingPrefs", { browser: "ALL" })
+            .build();
+        await this.setTimeouts(5000);
+        // Web socket server to communicate with browser
+        await this.startWebSocketServer();
+        // Visit the root page and wait for Expo to be loaded and the app to appear
+        await this.driverVisit(SystemTest.rootPath);
+        try {
+            await this.find("body > #root", { useBaseSelector: false });
+            await this.find("[data-testid='systemTestingComponent']", { visible: null, useBaseSelector: false });
+        }
+        catch (error) {
+            await this.takeScreenshot();
+            throw error;
+        }
+        // Wait for client to connect
+        await this.waitForClientWebSocket();
+        this._started = true;
+        this.setBaseSelector("[data-testid='systemTestingComponent'][data-focussed='true']");
+    }
+    /**
+     * Restores previously set timeouts
+     * @returns {Promise<void>}
+     */
+    async restoreTimeouts() {
+        if (!this.getTimeouts()) {
+            throw new Error("Timeouts haven't previously been set");
+        }
+        await this.driverSetTimeouts(this.getTimeouts());
+    }
+    /**
+     * Sets driver timeouts
+     * @param {number} newTimeout
+     * @returns {Promise<void>}
+     */
+    async driverSetTimeouts(newTimeout) {
+        this._driverTimeouts = newTimeout;
+        await this.getDriver().manage().setTimeouts({ implicit: newTimeout });
+    }
+    /**
+     * Sets timeouts and stores the previous timeouts
+     * @param {number} newTimeout
+     * @returns {Promise<void>}
+     */
+    async setTimeouts(newTimeout) {
+        this._timeouts = newTimeout;
+        await this.restoreTimeouts();
+    }
+    /**
+     * Waits for the client web socket to connect
+     * @returns {Promise<void>}
+     */
+    waitForClientWebSocket() {
+        return new Promise((resolve) => {
+            if (this.ws) {
+                resolve();
+            }
+            this.waitForClientWebSocketPromiseResolve = resolve;
+        });
+    }
+    /**
+     * Starts the web socket server
+     * @returns {void}
+     */
+    startWebSocketServer() {
+        this.wss = new WebSocketServer({ port: 1985 });
+        this.wss.on("connection", this.onWebSocketConnection);
+        this.wss.on("close", this.onWebSocketClose);
+    }
+    /**
+     * Sets the on command callback
+     * @param {function({type: string, data: Record<string, any>}): Promise<void>} callback
+     * @returns {void}
+     */
+    onCommand(callback) {
+        this._onCommandCallback = callback;
+    }
+    /**
+     * Handles an error reported from the browser
+     * @param {object} data
+     * @param {string} data.message
+     * @param {string} [data.backtrace]
+     * @returns {void}
+     */
+    handleError(data) {
+        if (data.message.includes("Minified React error #419")) {
+            // Ignore this error message
+            return;
+        }
+        const error = new Error(`Browser error: ${data.message}`);
+        if (data.backtrace) {
+            error.stack = `${error.message}\n${data.backtrace}`;
+        }
+        console.error(error);
+    }
+    /**
+     * Stops the system test
+     * @returns {Promise<void>}
+     */
+    async stop() {
+        this.stopScoundrel();
+        this.systemTestHttpServer?.close();
+        this.wss?.close();
+        await this.driver?.quit();
+    }
+    /**
+     * Visits a path in the browser
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    async driverVisit(path) {
+        const url = `${this.currentUrl}${path}`;
+        await this.getDriver().get(url);
+    }
+    /**
+     * Takes a screenshot, saves HTML and browser logs
+     * @returns {Promise<void>}
+     */
+    async takeScreenshot() {
+        const path = `${process.cwd()}/tmp/screenshots`;
+        await fs.mkdir(path, { recursive: true });
+        const imageContent = await this.getDriver().takeScreenshot();
+        const now = new Date();
+        const screenshotPath = `${path}/${moment(now).format("YYYY-MM-DD-HH-MM-SS")}.png`;
+        const htmlPath = `${path}/${moment(now).format("YYYY-MM-DD-HH-MM-SS")}.html`;
+        const logsPath = `${path}/${moment(now).format("YYYY-MM-DD-HH-MM-SS")}.logs.txt`;
+        const logsText = await this.getBrowserLogs();
+        const html = await this.getHTML();
+        const htmlPretty = prettify(html);
+        await fs.writeFile(htmlPath, htmlPretty);
+        await fs.writeFile(logsPath, logsText.join("\n"));
+        await fs.writeFile(screenshotPath, imageContent, "base64");
+        console.log("Current URL:", await this.getCurrentUrl());
+        console.log("Logs:", logsPath);
+        console.log("Screenshot:", screenshotPath);
+        console.log("HTML:", htmlPath);
+    }
+    /**
+     * Visits a path in the browser
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    async visit(path) {
+        await this.getCommunicator().sendCommand({ type: "visit", path });
+    }
+    /**
+     * Dismisses to a path in the browser
+     * @param {string} path
+     * @returns {Promise<void>}
+     */
+    async dismissTo(path) {
+        await this.getCommunicator().sendCommand({ type: "dismissTo", path });
+    }
+}
+SystemTest.rootPath = "/blank?systemTest=true";
+export default SystemTest;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"system-test.js","sourceRoot":"","sources":["../src/system-test.js"],"names":[],"mappings":"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","sourcesContent":["// @ts-check\n\nimport {Builder, By} from \"selenium-webdriver\"\nimport chrome from \"selenium-webdriver/chrome.js\"\nimport {digg} from \"diggerize\"\nimport fs from \"node:fs/promises\"\nimport logging from \"selenium-webdriver/lib/logging.js\"\nimport moment from \"moment\"\nimport {prettify} from \"htmlfy\"\nimport Server from \"scoundrel-remote-eval/build/server/index.js\"\nimport ServerWebSocket from \"scoundrel-remote-eval/build/server/connections/web-socket/index.js\"\nimport SystemTestCommunicator from \"./system-test-communicator.js\"\nimport SystemTestHttpServer from \"./system-test-http-server.js\"\nimport {wait, waitFor} from \"awaitery\"\nimport {WebSocketServer} from \"ws\"\n\nclass ElementNotFoundError extends Error { }\n\nexport default class SystemTest {\n  static rootPath = \"/blank?systemTest=true\"\n\n  /** @type {SystemTestCommunicator | undefined} */\n  communicator = undefined\n\n  /** @type {import(\"selenium-webdriver\").WebDriver | undefined} */\n  driver = undefined\n\n  _started = false\n  _driverTimeouts = 5000\n  _timeouts = 5000\n\n  /**\n   * Gets the current system test instance\n   * @param {object} [args]\n   * @param {string} [args.host]\n   * @param {number} [args.port]\n   * @returns {SystemTest}\n   */\n  static current(args) {\n    if (!globalThis.systemTest) {\n      globalThis.systemTest = new SystemTest(args)\n    }\n\n    return globalThis.systemTest\n  }\n\n  /** @returns {SystemTestCommunicator} */\n  getCommunicator() {\n    if (!this.communicator) {\n      throw new Error(\"Communicator hasn't been initialized yet\")\n    }\n\n    return this.communicator\n  }\n\n  /**\n   * Runs a system test\n   * @param {function(SystemTest): Promise<void>} callback\n   * @returns {Promise<void>}\n   */\n  static async run(callback) {\n    const systemTest = this.current()\n\n    await systemTest.getCommunicator().sendCommand({type: \"initialize\"})\n    await systemTest.dismissTo(SystemTest.rootPath)\n\n    try {\n      await systemTest.findByTestID(\"blankText\", {useBaseSelector: false})\n      await callback(systemTest)\n    } catch (error) {\n      await systemTest.takeScreenshot()\n\n      throw error\n    }\n  }\n\n  /**\n   * Creates a new SystemTest instance\n   * @param {object} [args]\n   * @param {string} [args.host]\n   * @param {number} [args.port]\n   */\n  constructor({host = \"localhost\", port = 8081, ...restArgs} = {host: \"localhost\", port: 8081}) {\n    const restArgsKeys = Object.keys(restArgs)\n\n    if (restArgsKeys.length > 0) {\n      throw new Error(`Unknown arguments: ${restArgsKeys.join(\", \")}`)\n    }\n\n    this._host = host\n    this._port = port\n\n    /** @type {Record<number, object>} */\n    this._responses = {}\n\n    this._sendCount = 0\n    this.startScoundrel()\n    this.communicator = new SystemTestCommunicator({onCommand: this.onCommandReceived})\n  }\n\n  /**\n   * Gets the base selector for scoping element searches\n   * @returns {string | undefined}\n   */\n  getBaseSelector() { return this._baseSelector }\n\n  /** @returns {import(\"selenium-webdriver\").WebDriver} */\n  getDriver() {\n    if (!this) throw new Error(\"No this?\")\n    if (!this.driver) throw new Error(\"Driver hasn't been initialized yet\")\n\n    return this.driver\n  }\n\n  /**\n   * Sets the base selector for scoping element searches\n   * @param {string} baseSelector\n   */\n  setBaseSelector(baseSelector) { this._baseSelector = baseSelector }\n\n  /**\n   * Gets a selector scoped to the base selector\n   * @param {string} selector\n   * @returns {string}\n   */\n  getSelector(selector) {\n    return this.getBaseSelector() ? `${this.getBaseSelector()} ${selector}` : selector\n  }\n\n  /**\n   * Starts Scoundrel server which the browser connects to for remote evaluation in the browser\n   * @returns {void}\n   */\n  startScoundrel() {\n    if (this.wss) throw new Error(\"Scoundrel server already started\")\n\n    this.wss = new WebSocketServer({port: 8090})\n    this.serverWebSocket = new ServerWebSocket(this.wss)\n    this.server = new Server(this.serverWebSocket)\n  }\n\n  /**\n   * @returns {void}\n   */\n  stopScoundrel() {\n    this.server?.close()\n    this.wss?.close()\n  }\n\n  /**\n   * Finds all elements by CSS selector\n   * @param {string} selector\n   * @param {object} [args]\n   * @param {number} [args.timeout]\n   * @param {boolean} [args.visible]\n   * @param {boolean} [args.useBaseSelector]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement[]>}\n   */\n  async all(selector, args = {}) {\n    const {visible = true, timeout, useBaseSelector = true, ...restArgs} = args\n    const restArgsKeys = Object.keys(restArgs)\n    let actualTimeout\n\n    if (timeout === undefined) {\n      actualTimeout = this._driverTimeouts\n    } else {\n      actualTimeout = timeout\n    }\n\n    if (restArgsKeys.length > 0) throw new Error(`Unknown arguments: ${restArgsKeys.join(\", \")}`)\n\n    const actualSelector = useBaseSelector ? this.getSelector(selector) : selector\n    const getElements = async () => await this.getDriver().findElements(By.css(actualSelector))\n    let elements = []\n\n    if (actualTimeout == 0) {\n      elements = await getElements()\n    } else {\n      await this.getDriver().wait(async () => {\n        elements = await getElements()\n\n        return elements.length > 0\n      }, actualTimeout)\n    }\n\n    const activeElements = []\n\n    for (const element of elements) {\n      let keep = true\n\n      if (visible === true || visible === false) {\n        const isDisplayed = await element.isDisplayed()\n\n        if (visible && !isDisplayed) keep = false\n        if (!visible && isDisplayed) keep = false\n      }\n\n      if (keep) activeElements.push(element)\n    }\n\n    return activeElements\n  }\n\n  /**\n   * Clicks an element that has children which fills out the element and would otherwise have caused a ElementClickInterceptedError\n   * @param {string|import(\"selenium-webdriver\").WebElement} elementOrIdentifier\n   * @returns {Promise<void>}\n   */\n  async click(elementOrIdentifier) {\n    let tries = 0\n\n    while (true) {\n      tries++\n\n      try {\n        const element = await this._findElement(elementOrIdentifier)\n        const actions = this.getDriver().actions({async: true})\n\n        await actions.move({origin: element}).click().perform()\n        break\n      } catch (error) {\n        if (error instanceof Error) {\n          if (error.constructor.name === \"ElementNotInteractableError\") {\n            if (tries >= 3) {\n              throw new Error(`Element ${elementOrIdentifier.constructor.name} click failed after ${tries} tries - ${error.constructor.name}: ${error.message}`)\n            } else {\n              await wait(50)\n            }\n          } else {\n            // Re-throw with un-corrupted stack trace\n            throw new Error(`Element ${elementOrIdentifier.constructor.name} click failed - ${error.constructor.name}: ${error.message}`)\n          }\n        } else {\n          throw new Error(`Element ${elementOrIdentifier.constructor.name} click failed - ${typeof error}: ${error}`)\n        }\n      }\n    }\n  }\n\n  /**\n   * Finds a single element by CSS selector\n   * @param {string} selector\n   * @param {object} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async find(selector, args = {}) {\n    let elements = []\n\n    try {\n      elements = await this.all(selector, args)\n    } catch (error) {\n      // Re-throw to recover stack trace\n      if (error instanceof Error) {\n        if (error.message.startsWith(\"Wait timed out after\")) {\n          elements = []\n        }\n\n        throw new Error(`${error.message} (selector: ${this.getSelector(selector)})`)\n      } else {\n        throw new Error(`${error} (selector: ${this.getSelector(selector)})`)\n      }\n    }\n\n    if (elements.length > 1) {\n      throw new Error(`More than 1 elements (${elements.length}) was found by CSS: ${this.getSelector(selector)}`)\n    }\n\n    if (!elements[0]) {\n      throw new ElementNotFoundError(`Element couldn't be found after ${(this.getTimeouts() / 1000).toFixed(2)}s by CSS: ${this.getSelector(selector)}`)\n    }\n\n    return elements[0]\n  }\n\n  /**\n   * Finds a single element by test ID\n   * @param {string} testID\n   * @param {object} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async findByTestID(testID, args) { return await this.find(`[data-testid='${testID}']`, args) }\n\n\n  /**\n   * @param {string|import(\"selenium-webdriver\").WebElement} elementOrIdentifier\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async _findElement(elementOrIdentifier) {\n    let element\n\n    if (typeof elementOrIdentifier == \"string\") {\n      element = await this.find(elementOrIdentifier)\n    } else {\n      element = elementOrIdentifier\n    }\n\n    return element\n  }\n\n  /**\n   * Finds a single element by CSS selector without waiting\n   * @param {string} selector\n   * @param {object} [args]\n   * @returns {Promise<import(\"selenium-webdriver\").WebElement>}\n   */\n  async findNoWait(selector, args) {\n    await this.driverSetTimeouts(0)\n\n    try {\n      return await this.find(selector, args)\n    } finally {\n      await this.restoreTimeouts()\n    }\n  }\n\n  /**\n   * Gets browser logs\n   * @returns {Promise<string[]>}\n   */\n  async getBrowserLogs() {\n    const entries = await this.getDriver().manage().logs().get(logging.Type.BROWSER)\n    const browserLogs = []\n\n    for (const entry of entries) {\n      const messageMatch = entry.message.match(/^(.+) (\\d+):(\\d+) (.+)$/)\n      let message\n\n      if (messageMatch) {\n        message = messageMatch[4]\n      } else {\n        message = entry.message\n      }\n\n      browserLogs.push(`${entry.level.name}: ${message}`)\n    }\n\n    return browserLogs\n  }\n\n  /** @returns {Promise<string>} */\n  async getCurrentUrl() {\n    return await this.getDriver().getCurrentUrl()\n  }\n\n  /** @returns {number} */\n  getTimeouts() { return this._timeouts }\n\n  /**\n   * Interacts with an element by calling a method on it with the given arguments.\n   * Retrying on ElementNotInteractableError.\n   * @param {import(\"selenium-webdriver\").WebElement|string} elementOrIdentifier The element or a CSS selector to find the element.\n   * @param {string} methodName The method name to call on the element.\n   * @param {...any} args Arguments to pass to the method.\n   * @returns {Promise<any>}\n   */\n  async interact(elementOrIdentifier, methodName, ...args) {\n    let tries = 0\n\n    while (true) {\n      tries++\n\n      const element = await this._findElement(elementOrIdentifier)\n\n      if (!element[methodName]) {\n        throw new Error(`${element.constructor.name} hasn't an attribute named: ${methodName}`)\n      } else if (typeof element[methodName] != \"function\") {\n        throw new Error(`${element.constructor.name}#${methodName} is not a function`)\n      }\n\n      try {\n        // Dont call with candidate, because that will bind the function wrong.\n        return await element[methodName](...args)\n      } catch (error) {\n        if (error instanceof Error) {\n          if (error.constructor.name === \"ElementNotInteractableError\") {\n            // Retry finding the element and interacting with it\n            if (tries >= 3) {\n              let elementDescription\n\n              if (typeof elementOrIdentifier == \"string\") {\n                elementDescription = `CSS selector ${elementOrIdentifier}`\n              } else {\n                elementDescription = `${element.constructor.name}`\n              }\n\n              throw new Error(`${elementDescription} ${methodName} failed after ${tries} tries - ${error.constructor.name}: ${error.message}`)\n            } else {\n              await wait(50)\n            }\n          } else {\n            // Re-throw with un-corrupted stack trace\n            throw new Error(`${element.constructor.name} ${methodName} failed - ${error.constructor.name}: ${error.message}`)\n          }\n        } else {\n          throw new Error(`${element.constructor.name} ${methodName} failed - ${typeof error}: ${error}`)\n        }\n      }\n    }\n  }\n\n  /**\n   * Expects no element to be found by CSS selector\n   * @param {string} selector\n   * @returns {Promise<void>}\n   */\n  async expectNoElement(selector) {\n    let found = false\n\n    try {\n      await this.findNoWait(selector)\n      found = true\n    } catch (error) {\n      if (error instanceof Error && error.message.startsWith(\"Element couldn't be found after \")) {\n        // Ignore\n      } else {\n        throw error\n      }\n    }\n\n    if (found) {\n      throw new Error(`Expected not to find: ${selector}`)\n    }\n  }\n\n  /**\n   * @param {string} selector\n   * @param {object} [args]\n   * @param {boolean} [args.useBaseSelector]\n   * @returns {Promise<void>}\n   */\n  async waitForNoSelector(selector, args) {\n    const {useBaseSelector, ...restArgs} = args\n\n    if (Object.keys(restArgs).length > 0) {\n      throw new Error(`Unexpected args: ${Object.keys(restArgs).join(\", \")}`)\n    }\n\n    const actualSelector = useBaseSelector ? this.getSelector(selector) : selector\n\n    await this.getDriver().wait(\n      async () => {\n        const elements = await this.getDriver().findElements(By.css(actualSelector))\n\n        // Not found at all\n        if (elements.length === 0) {\n          return true\n        }\n\n        // Found but not visible\n        const isDisplayed = await elements[0].isDisplayed()\n\n        return !isDisplayed\n      },\n      this.getTimeouts()\n    )\n  }\n\n  /**\n   * Gets notification messages\n   * @returns {Promise<string[]>}\n   */\n  async notificationMessages() {\n    const notificationMessageElements = await this.all(\"[data-class='notification-message']\", {useBaseSelector: false})\n    const notificationMessageTexts = []\n\n    for (const notificationMessageElement of notificationMessageElements) {\n      const text = await notificationMessageElement.getText()\n\n      notificationMessageTexts.push(text)\n    }\n\n    return notificationMessageTexts\n  }\n\n  /**\n   * Expects a notification message to appear and waits for it if necessary.\n   * @param {string} expectedNotificationMessage\n   * @returns {Promise<void>}\n   */\n  async expectNotificationMessage(expectedNotificationMessage) {\n    /** @type {string[]} */\n    const allDetectedNotificationMessages = []\n    let foundNotificationMessageElement\n\n    await waitFor(async () => {\n      const notificationMessageElements = await this.all(\"[data-class='notification-message']\", {useBaseSelector: false})\n\n      for (const notificationMessageElement of notificationMessageElements) {\n        const notificationMessage = await notificationMessageElement.getText()\n\n        if (!allDetectedNotificationMessages.includes(notificationMessage)) {\n          allDetectedNotificationMessages.push(notificationMessage)\n        }\n\n        if (notificationMessage == expectedNotificationMessage) {\n          foundNotificationMessageElement = notificationMessageElement\n          return\n        }\n      }\n\n      throw new Error(`Notification message ${expectedNotificationMessage} wasn't included in: ${allDetectedNotificationMessages.join(\", \")}`)\n    })\n\n    if (foundNotificationMessageElement) {\n      await this.interact(foundNotificationMessageElement, \"click\") // Dismiss the notification message\n    }\n  }\n\n  /** @returns {Promise<void>} */\n  async dismissNotificationMessages() {\n    const notificationMessageElements = await this.all(\"[data-class='notification-message']\", {useBaseSelector: false})\n\n    for (const notificationMessageElement of notificationMessageElements) {\n      await this.interact(notificationMessageElement, \"click\")\n    }\n\n    await this.waitForNoSelector(\"[data-class='notification-message']\", {useBaseSelector: false})\n  }\n\n  /**\n   * Indicates whether the system test has been started\n   * @returns {boolean}\n   */\n  isStarted() { return this._started }\n\n  /**\n   * Gets the HTML of the current page\n   * @returns {Promise<string>}\n   */\n  async getHTML() { return await this.getDriver().getPageSource() }\n\n  /**\n   * Starts the system test\n   * @returns {Promise<void>}\n   */\n  async start() {\n    if (process.env.SYSTEM_TEST_HOST == \"expo-dev-server\") {\n      this.currentUrl = `http://${this._host}:${this._port}`\n    } else if (process.env.SYSTEM_TEST_HOST == \"dist\") {\n      this.currentUrl = `http://${this._host}:1984`\n      this.systemTestHttpServer = new SystemTestHttpServer()\n\n      await this.systemTestHttpServer.start()\n    } else {\n      throw new Error(\"Please set SYSTEM_TEST_HOST to 'expo-dev-server' or 'dist'\")\n    }\n\n    const options = new chrome.Options()\n\n    options.addArguments(\"--disable-dev-shm-usage\")\n    options.addArguments(\"--disable-gpu\")\n    options.addArguments(\"--headless=new\")\n    options.addArguments(\"--no-sandbox\")\n    options.addArguments(\"--window-size=1920,1080\")\n\n    this.driver = new Builder()\n      .forBrowser(\"chrome\")\n      .setChromeOptions(options)\n      // @ts-expect-error\n      .setCapability(\"goog:loggingPrefs\", {browser: \"ALL\"})\n      .build()\n\n    await this.setTimeouts(5000)\n\n    // Web socket server to communicate with browser\n    await this.startWebSocketServer()\n\n    // Visit the root page and wait for Expo to be loaded and the app to appear\n    await this.driverVisit(SystemTest.rootPath)\n\n    try {\n      await this.find(\"body > #root\", {useBaseSelector: false})\n      await this.find(\"[data-testid='systemTestingComponent']\", {visible: null, useBaseSelector: false})\n    } catch (error) {\n      await this.takeScreenshot()\n      throw error\n    }\n\n    // Wait for client to connect\n    await this.waitForClientWebSocket()\n\n    this._started = true\n    this.setBaseSelector(\"[data-testid='systemTestingComponent'][data-focussed='true']\")\n  }\n\n  /**\n   * Restores previously set timeouts\n   * @returns {Promise<void>}\n   */\n  async restoreTimeouts() {\n    if (!this.getTimeouts()) {\n      throw new Error(\"Timeouts haven't previously been set\")\n    }\n\n    await this.driverSetTimeouts(this.getTimeouts())\n  }\n\n  /**\n   * Sets driver timeouts\n   * @param {number} newTimeout\n   * @returns {Promise<void>}\n   */\n  async driverSetTimeouts(newTimeout) {\n    this._driverTimeouts = newTimeout\n    await this.getDriver().manage().setTimeouts({implicit: newTimeout})\n  }\n\n  /**\n   * Sets timeouts and stores the previous timeouts\n   * @param {number} newTimeout\n   * @returns {Promise<void>}\n   */\n  async setTimeouts(newTimeout) {\n    this._timeouts = newTimeout\n    await this.restoreTimeouts()\n  }\n\n  /**\n   * Waits for the client web socket to connect\n   * @returns {Promise<void>}\n   */\n  waitForClientWebSocket() {\n    return new Promise((resolve) => {\n      if (this.ws) {\n        resolve()\n      }\n\n      this.waitForClientWebSocketPromiseResolve = resolve\n    })\n  }\n\n  /**\n   * Starts the web socket server\n   * @returns {void}\n   */\n  startWebSocketServer() {\n    this.wss = new WebSocketServer({port: 1985})\n    this.wss.on(\"connection\", this.onWebSocketConnection)\n    this.wss.on(\"close\", this.onWebSocketClose)\n  }\n\n  /**\n   * Sets the on command callback\n   * @param {function({type: string, data: Record<string, any>}): Promise<void>} callback\n   * @returns {void}\n   */\n  onCommand(callback) {\n    this._onCommandCallback = callback\n  }\n\n  /**\n   * Handles a command received from the browser\n   * @param {{data: {message: string, backtrace: string, type: string, value: any[]}}} args\n   * @returns {Promise<any>}\n   */\n  onCommandReceived = async ({data}) => {\n    const type = data.type\n    let result\n\n    if (type == \"console.error\") {\n      const errorMessage = data.value[0]\n      let showMessage = true\n\n      if (errorMessage.includes(\"Minified React error #419\")) {\n        showMessage = false\n      }\n\n      if (showMessage) {\n        console.error(\"Browser error\", ...data.value)\n      }\n    } else if (type == \"console.log\") {\n      console.log(\"Browser log\", ...data.value)\n    } else if (type == \"error\" || data.type == \"unhandledrejection\") {\n      this.handleError(data)\n    } else if (this._onCommandCallback) {\n      result = await this._onCommandCallback({data, type})\n    } else {\n      console.error(`onWebSocketClientMessage unknown data (type ${type})`, data)\n    }\n\n    return result\n  }\n\n  /**\n   * Handles a new web socket connection\n   * @param {WebSocket} ws\n   * @returns {Promise<void>}\n   */\n  onWebSocketConnection = async (ws) => {\n    this.ws = ws\n    this.getCommunicator().ws = ws\n    this.getCommunicator().onOpen()\n\n    // @ts-expect-error\n    this.ws.on(\"error\", digg(this, \"communicator\", \"onError\"))\n\n    // @ts-expect-error\n    this.ws.on(\"message\", digg(this, \"communicator\", \"onMessage\"))\n\n    if (this.waitForClientWebSocketPromiseResolve) {\n      this.waitForClientWebSocketPromiseResolve()\n      delete this.waitForClientWebSocketPromiseResolve\n    }\n  }\n\n  /** @returns {void} */\n  onWebSocketClose = () => {\n    this.ws = null\n    this.getCommunicator().ws = null\n  }\n\n  /**\n   * Handles an error reported from the browser\n   * @param {object} data\n   * @param {string} data.message\n   * @param {string} [data.backtrace]\n   * @returns {void}\n   */\n  handleError(data) {\n    if (data.message.includes(\"Minified React error #419\")) {\n      // Ignore this error message\n      return\n    }\n\n    const error = new Error(`Browser error: ${data.message}`)\n\n    if (data.backtrace) {\n      error.stack = `${error.message}\\n${data.backtrace}`\n    }\n\n    console.error(error)\n  }\n\n  /**\n   * Stops the system test\n   * @returns {Promise<void>}\n   */\n  async stop() {\n    this.stopScoundrel()\n    this.systemTestHttpServer?.close()\n    this.wss?.close()\n    await this.driver?.quit()\n  }\n\n  /**\n   * Visits a path in the browser\n   * @param {string} path\n   * @returns {Promise<void>}\n   */\n  async driverVisit(path) {\n    const url = `${this.currentUrl}${path}`\n\n    await this.getDriver().get(url)\n  }\n\n  /**\n   * Takes a screenshot, saves HTML and browser logs\n   * @returns {Promise<void>}\n   */\n  async takeScreenshot() {\n    const path = `${process.cwd()}/tmp/screenshots`\n\n    await fs.mkdir(path, {recursive: true})\n\n    const imageContent = await this.getDriver().takeScreenshot()\n    const now = new Date()\n    const screenshotPath = `${path}/${moment(now).format(\"YYYY-MM-DD-HH-MM-SS\")}.png`\n    const htmlPath = `${path}/${moment(now).format(\"YYYY-MM-DD-HH-MM-SS\")}.html`\n    const logsPath = `${path}/${moment(now).format(\"YYYY-MM-DD-HH-MM-SS\")}.logs.txt`\n    const logsText = await this.getBrowserLogs()\n    const html = await this.getHTML()\n    const htmlPretty = prettify(html)\n\n    await fs.writeFile(htmlPath, htmlPretty)\n    await fs.writeFile(logsPath, logsText.join(\"\\n\"))\n    await fs.writeFile(screenshotPath, imageContent, \"base64\")\n\n    console.log(\"Current URL:\", await this.getCurrentUrl())\n    console.log(\"Logs:\", logsPath)\n    console.log(\"Screenshot:\", screenshotPath)\n    console.log(\"HTML:\", htmlPath)\n  }\n\n  /**\n   * Visits a path in the browser\n   * @param {string} path\n   * @returns {Promise<void>}\n   */\n  async visit(path) {\n    await this.getCommunicator().sendCommand({type: \"visit\", path})\n  }\n\n  /**\n   * Dismisses to a path in the browser\n   * @param {string} path\n   * @returns {Promise<void>}\n   */\n  async dismissTo(path) {\n    await this.getCommunicator().sendCommand({type: \"dismissTo\", path})\n  }\n}\n"]}