@brillout/test-e2e 0.1.3

package/dist/runTests.js

@@ -0,0 +1,111 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runTests = void 0;
+const getTestInfo_1 = require("./getTestInfo");
+const logProgress_1 = require("./logProgress");
+const Logs_1 = require("./Logs");
+const utils_1 = require("./utils");
+const expect_1 = require("./chai/expect");
+const iconWarning = '⚠️';
+const iconSuccess = '✅';
+const iconFailure = '❌';
+async function runTests(browser) {
+    const testInfo = (0, getTestInfo_1.getTestInfo)();
+    if (utils_1.isTTY) {
+        console.log();
+        console.log(testInfo.testFile);
+    }
+    const page = await browser.newPage();
+    testInfo.page = page;
+    // Set when user calls `skip()`
+    if (testInfo.skipped) {
+        (0, utils_1.assertUsage)(!testInfo.runWasCalled, 'You cannot call `run()` after calling `skip()`');
+        (0, utils_1.assertUsage)(testInfo.tests === undefined, 'You cannot call `test()` after calling `skip()`');
+        logTestSuiteResult(false);
+        return;
+    }
+    // Set when user calls `run()`
+    (0, utils_1.assert)(testInfo.runWasCalled);
+    (0, utils_1.assert)(testInfo.beforeAll);
+    (0, utils_1.assert)(testInfo.afterAll);
+    (0, utils_1.assert)(testInfo.afterEach);
+    (0, utils_1.assert)(testInfo.testTimeout);
+    // Set when user calls `test()`
+    (0, utils_1.assert)(testInfo.tests);
+    await testInfo.beforeAll();
+    for (const { testDesc, testFn } of testInfo.tests) {
+        const done = (0, logProgress_1.logProgress)(`[test] ${testDesc}`);
+        let err;
+        try {
+            await runTest(testFn, testInfo.testTimeout);
+        }
+        catch (err_) {
+            err = err_;
+        }
+        done(!!err);
+        testInfo.afterEach(!!err);
+        const browserErrors = Logs_1.Logs.getBrowserErrors();
+        const isFailure = err || browserErrors.length > 0;
+        if (isFailure) {
+            Logs_1.Logs.flush();
+        }
+        Logs_1.Logs.clear();
+        if (isFailure) {
+            logTestSuiteResult(false);
+            if (browserErrors.length === 0) {
+                throw err;
+            }
+            else {
+                if (err) {
+                    console.error(err);
+                }
+                // Display all browser errors
+                (0, expect_1.expect)(browserErrors).deep.equal([]);
+                (0, utils_1.assert)(false);
+            }
+        }
+    }
+    await testInfo.afterAll();
+    await page.close();
+    logTestSuiteResult(true);
+}
+exports.runTests = runTests;
+function runTest(testFn, testTimeout) {
+    let resolve;
+    let reject;
+    const promise = new Promise((resolve_, reject_) => {
+        resolve = resolve_;
+        reject = reject_;
+    });
+    const timeout = setTimeout(() => {
+        reject(new Error(`[test][timeout after ${(0, utils_1.humanizeTime)(testTimeout)}]`));
+    }, testTimeout);
+    const ret = testFn();
+    (async () => {
+        try {
+            await ret;
+            resolve();
+        }
+        catch (err) {
+            reject(err);
+        }
+        finally {
+            clearTimeout(timeout);
+        }
+    })();
+    return promise;
+}
+function logTestSuiteResult(success) {
+    const testInfo = (0, getTestInfo_1.getTestInfo)();
+    if (success) {
+        (0, utils_1.assert)(!testInfo.skipped);
+        console.log(`${iconSuccess} ${testInfo.testFile} (SUCCESS)`);
+        return;
+    }
+    if (testInfo.skipped) {
+        console.log(`${iconWarning} ${testInfo.testFile} (SKIPPED: ${testInfo.skipped})`);
+    }
+    else {
+        console.log(`${iconFailure} ${testInfo.testFile} (FAILURE)`);
+    }
+}

package/dist/setup.d.ts

@@ -0,0 +1,36 @@
+import { sleep } from './utils';
+import fetch_ from 'node-fetch';
+export { partRegex } from '@brillout/part-regex';
+export { autoRetry };
+export { fetchHtml };
+export { fetch };
+export { expectBrowserError } from './Logs';
+export { run };
+export { skip };
+export { isMinNodeVersion };
+export { isGithubAction };
+export { isLinux };
+export { isWindows };
+export { isMac };
+export { sleep };
+export declare let urlBase: string;
+export declare const urlBaseChange: (url: string) => string;
+export { editFile, editFileRevert } from './editFile';
+declare function skip(reason: string): void;
+declare function run(cmd: string, { additionalTimeout, serverIsReadyMessage, serverIsReadyDelay, debug, cwd, }?: {
+    additionalTimeout?: number;
+    serverIsReadyMessage?: string;
+    serverIsReadyDelay?: number;
+    debug?: boolean;
+    cwd?: string;
+}): void;
+declare function autoRetry(test: () => void | Promise<void>, { timeout }?: {
+    timeout?: number;
+}): Promise<void>;
+declare function fetchHtml(pathname: string): Promise<string>;
+declare function fetch(...args: Parameters<typeof fetch_>): Promise<import("node-fetch").Response>;
+declare function isMinNodeVersion(minNodeVersion: 14): boolean;
+declare function isWindows(): boolean;
+declare function isLinux(): boolean;
+declare function isMac(): boolean;
+declare function isGithubAction(): boolean;

package/dist/setup.js

@@ -0,0 +1,465 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.editFileRevert = exports.editFile = exports.urlBaseChange = exports.urlBase = exports.sleep = exports.isMac = exports.isWindows = exports.isLinux = exports.isGithubAction = exports.isMinNodeVersion = exports.skip = exports.run = exports.expectBrowserError = exports.fetch = exports.fetchHtml = exports.autoRetry = exports.partRegex = void 0;
+const child_process_1 = require("child_process");
+const path_1 = require("path");
+const utils_1 = require("./utils");
+Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return utils_1.sleep; } });
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const utils_2 = require("./utils");
+const Logs_1 = require("./Logs");
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
+const editFile_1 = require("./editFile");
+const getTestInfo_1 = require("./getTestInfo");
+const page_1 = require("./page");
+const logProgress_1 = require("./logProgress");
+var part_regex_1 = require("@brillout/part-regex");
+Object.defineProperty(exports, "partRegex", { enumerable: true, get: function () { return part_regex_1.partRegex; } });
+var Logs_2 = require("./Logs");
+Object.defineProperty(exports, "expectBrowserError", { enumerable: true, get: function () { return Logs_2.expectBrowserError; } });
+exports.urlBase = 'http://localhost:3000';
+const urlBaseChange = (url) => (exports.urlBase = url);
+exports.urlBaseChange = urlBaseChange;
+var editFile_2 = require("./editFile");
+Object.defineProperty(exports, "editFile", { enumerable: true, get: function () { return editFile_2.editFile; } });
+Object.defineProperty(exports, "editFileRevert", { enumerable: true, get: function () { return editFile_2.editFileRevert; } });
+const TIMEOUT_NPM_SCRIPT = 30 * 1000 * (!isGithubAction() ? 1 : isLinux() ? 1 : isWindows() ? 5 : 4);
+const TIMEOUT_JEST = 30 * 1000 * (!isGithubAction() ? 1 : isWindows() ? 10 : 6);
+const TIMEOUT_AUTORETRY = 10 * 1000 * (!isGithubAction() || isLinux() ? 1 : 20); // TODO reduce `20`
+const TIMEOUT_PROCESS_TERMINATION = 10 * 1000 * (!isGithubAction() ? 1 : isLinux() ? 1 : 4);
+const TIMEOUT_PLAYWRIGHT = TIMEOUT_JEST;
+function skip(reason) {
+    const testInfo = (0, getTestInfo_1.getTestInfo)();
+    testInfo.skipped = reason;
+}
+exports.skip = skip;
+function run(cmd, { 
+//baseUrl = '',
+additionalTimeout = 0, serverIsReadyMessage, serverIsReadyDelay = 1000, debug = !!process.env.DEBUG, cwd, } = {}) {
+    additionalTimeout += serverIsReadyDelay;
+    const testInfo = (0, getTestInfo_1.getTestInfo)();
+    testInfo.runWasCalled = true;
+    testInfo.testCmd = cmd;
+    testInfo.testTimeout = TIMEOUT_JEST + additionalTimeout;
+    /*
+    const browser = await getBrowser()
+    const page = await browser.newPage()
+    testInfo.page = page
+  
+    const { page } = testInfo
+    // Set by `./runTests`
+    assert(page)
+    */
+    if (debug) {
+        Logs_1.Logs.flushEagerly = true;
+    }
+    const testContext = {
+        cmd,
+        cwd: cwd || getCwd(),
+        testName: getTestName(),
+        additionalTimeout,
+        serverIsReadyMessage,
+        serverIsReadyDelay,
+        debug,
+    };
+    logJestStep('run start');
+    let runProcess = null;
+    testInfo.beforeAll = async () => {
+        logJestStep('beforeAll start');
+        runProcess = await start(testContext);
+        logJestStep('run done');
+        page_1.page.on('console', onConsole);
+        page_1.page.on('pageerror', onPageError);
+        // This setting will change the default maximum time for all the methods accepting timeout option.
+        // https://playwright.dev/docs/api/class-page#page-set-default-timeout
+        page_1.page.setDefaultTimeout(TIMEOUT_PLAYWRIGHT + additionalTimeout);
+        /*
+        await bailOnTimeout(
+          async () => {
+            await page.goto(urlBase + baseUrl)
+          },
+          { timeout: TIMEOUT_PAGE_LOAD + additionalTimeout },
+        )
+        */
+        logJestStep('beforeAll end');
+    };
+    testInfo.afterEach = (hasFailed) => {
+        if (!hasFailed) {
+            (0, editFile_1.editFileAssertReverted)();
+        }
+        else {
+            (0, editFile_1.editFileRevert)();
+        }
+    };
+    testInfo.afterAll = async () => {
+        logJestStep('afterAll start');
+        page_1.page.off('console', onConsole);
+        page_1.page.off('pageerror', onPageError);
+        // `runProcess` is `undefined` if `start()` failed.
+        if (runProcess) {
+            await runProcess.terminate('SIGINT');
+        }
+        logJestStep('afterAll end');
+    };
+    // return { page }
+    return;
+    // Also called when the page throws an error or a warning
+    function onConsole(msg) {
+        const type = msg.type();
+        Logs_1.Logs.add({
+            logType: type === 'error' ? 'Browser Error' : 'Browser Log',
+            logText: JSON.stringify({
+                type,
+                text: msg.text(),
+                location: msg.location(),
+                args: msg.args(),
+            }, null, 2),
+            testContext,
+        });
+    }
+    // For uncaught exceptions
+    function onPageError(err) {
+        Logs_1.Logs.add({
+            logType: 'Browser Error',
+            logText: JSON.stringify({
+                text: err.message,
+                location: err.stack,
+            }, null, 2),
+            testContext,
+        });
+    }
+    function logJestStep(stepName) {
+        if (!debug) {
+            return;
+        }
+        Logs_1.Logs.add({
+            logType: 'Jest',
+            logText: stepName,
+            testContext,
+        });
+    }
+}
+exports.run = run;
+async function start(testContext) {
+    const { cmd, additionalTimeout, serverIsReadyMessage, serverIsReadyDelay } = testContext;
+    let hasStarted = false;
+    let resolveServerStart;
+    let rejectServerStart;
+    const promise = new Promise((_resolve, _reject) => {
+        resolveServerStart = () => {
+            hasStarted = true;
+            clearTimeout(serverStartTimeout);
+            const runProcess = { terminate };
+            _resolve(runProcess);
+        };
+        rejectServerStart = async (err) => {
+            done(true);
+            Logs_1.Logs.add({
+                logType: 'stderr',
+                logText: String(err),
+                testContext,
+            });
+            clearTimeout(serverStartTimeout);
+            try {
+                await terminate('SIGKILL');
+            }
+            catch (err) {
+                Logs_1.Logs.add({
+                    logType: 'process',
+                    logText: String(err),
+                    testContext,
+                });
+            }
+            _reject(err);
+        };
+    });
+    const timeoutTotal = TIMEOUT_NPM_SCRIPT + additionalTimeout;
+    const serverStartTimeout = setTimeout(() => {
+        let errMsg = '';
+        errMsg += `Server still didn't start after ${timeoutTotal / 1000} seconds of running the npm script \`${cmd}\`.`;
+        if (serverIsReadyMessage) {
+            errMsg += ` (The stdout of the npm script did not include: "${serverIsReadyMessage}".)`;
+        }
+        rejectServerStart(new Error(errMsg));
+    }, timeoutTotal);
+    // Kill any process that listens to port `3000`
+    if (!process.env.CI && isLinux()) {
+        await (0, utils_1.runCommand)('fuser -k 3000/tcp', { swallowError: true, timeout: 10 * 1000 });
+    }
+    const done = (0, logProgress_1.logProgress)(`[run] ${cmd}`);
+    const { terminate } = startScript(cmd, testContext, {
+        onError(err) {
+            rejectServerStart(err);
+        },
+        onExit() {
+            const exitIsExpected = hasStarted === true;
+            return exitIsExpected;
+        },
+        async onStdout(data) {
+            const text = (0, strip_ansi_1.default)(data);
+            const isServerReady = 
+            // Custom
+            (serverIsReadyMessage && text.includes(serverIsReadyMessage)) ||
+                // Express.js server
+                text.includes('Server running at') ||
+                // npm package `serve`
+                text.includes('Accepting connections at') ||
+                // Vite
+                (text.includes('Local:') && text.includes('http://localhost:3000/'));
+            if (isServerReady) {
+                (0, utils_2.assert)(serverIsReadyDelay);
+                await (0, utils_1.sleep)(serverIsReadyDelay);
+                resolveServerStart();
+                done();
+            }
+        },
+        onStderr(data) {
+            if (data.includes('EADDRINUSE')) {
+                rejectServerStart(new Error('Port conflict? Port already in use EADDRINUSE.'));
+            }
+        },
+    });
+    return promise;
+}
+function stopProcess({ proc, cwd, cmd, signal, }) {
+    const prefix = `[Run Stop][${cwd}][${cmd}]`;
+    let resolve;
+    let reject;
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+        reject = _reject;
+    });
+    const onProcessClose = (code) => {
+        if (code === 0 || code === null || (code === 1 && isWindows())) {
+            resolve();
+        }
+        else {
+            reject(new Error(`${prefix} Terminated with non-0 error code ${code}`));
+        }
+    };
+    proc.on('close', onProcessClose);
+    proc.on('exit', onProcessClose);
+    if (isWindows()) {
+        // - https://github.com/nodejs/node/issues/3617#issuecomment-377731194
+        // - https://stackoverflow.com/questions/23706055/why-can-i-not-kill-my-child-process-in-nodejs-on-windows/28163919#28163919
+        (0, child_process_1.spawn)('taskkill', ['/pid', String(proc.pid), '/f', '/t'], { stdio: ['ignore', 'ignore', 'inherit'] });
+    }
+    else {
+        (0, utils_2.assert)(proc.pid);
+        const processGroup = -1 * proc.pid;
+        process.kill(processGroup, signal);
+        /*
+          try {
+            process.kill(-proc.pid, signal)
+          } catch (err: unknown) {
+            // ESRCH: No process or process group can be found corresponding to that specified by pid.
+            //  => probably means that the process was killed already.
+            if (typeof err === 'object' && err !== null && 'code' in err && err['code'] === 'ESRCH') {
+              printLog('stdout', '=============== swallowError')
+              return
+            } else {
+              printLog('stdout', '=============== no swallowError')
+              throw err
+            }
+          }
+          */
+    }
+    return promise;
+}
+function startScript(cmd, testContext, { onStdout, onStderr, onError, onExit, }) {
+    let [command, ...args] = cmd.split(' ');
+    let detached = true;
+    if (isWindows()) {
+        detached = false;
+        if (command === 'npm' || command === 'pnpm') {
+            command = command + '.cmd';
+        }
+    }
+    const { cwd } = testContext;
+    const proc = (0, child_process_1.spawn)(command, args, { cwd, detached });
+    const prefix = `[Run Start][${cwd}][${cmd}]`;
+    proc.stdin.on('data', async (data) => {
+        onError(new Error(`Command is \`${cmd}\` (${cwd}) is invoking \`stdin\`: ${data}.`));
+    });
+    proc.stdout.on('data', async (data) => {
+        data = data.toString();
+        Logs_1.Logs.add({
+            logType: 'stdout',
+            logText: data,
+            testContext,
+        });
+        onStdout?.(data);
+    });
+    proc.stderr.on('data', async (data) => {
+        data = data.toString();
+        Logs_1.Logs.add({
+            logType: 'stderr',
+            logText: data,
+            testContext,
+        });
+        onStderr?.(data);
+    });
+    proc.on('exit', async (code) => {
+        const exitIsExpected = onExit();
+        const isSuccessCode = [0, null].includes(code) || (isWindows() && code === 1);
+        const isExpected = isSuccessCode && exitIsExpected;
+        if (!isExpected) {
+            const errMsg = `${prefix} Unexpected premature process termination, exit code: ${code}`;
+            Logs_1.Logs.add({
+                logText: errMsg,
+                logType: 'stderr',
+                testContext,
+            });
+            onError(new Error(errMsg));
+            /*
+            try {
+              await terminate('SIGKILL')
+            } catch (err: unknown) {
+              if( !err.code === 'ESRCH' ) {
+                onError(err as Error)
+              }
+            }
+            */
+        }
+        else {
+            Logs_1.Logs.add({
+                logText: `${prefix} Process termination. (Nominal. Exit code: ${code}.)`,
+                logType: 'process',
+                testContext,
+            });
+        }
+    });
+    return { terminate };
+    async function terminate(signal) {
+        let resolve;
+        let reject;
+        const promise = new Promise((_resolve, _reject) => {
+            resolve = _resolve;
+            reject = _reject;
+        });
+        const timeout = setTimeout(() => {
+            reject(new Error('Process termination timeout. Cmd: ' + cmd));
+        }, TIMEOUT_PROCESS_TERMINATION);
+        (0, utils_2.assert)(proc);
+        await stopProcess({
+            proc,
+            cwd,
+            cmd,
+            signal,
+        });
+        clearTimeout(timeout);
+        resolve();
+        return promise;
+    }
+}
+async function autoRetry(test, { timeout = TIMEOUT_AUTORETRY } = {}) {
+    const period = 100;
+    const numberOfTries = timeout / period;
+    let i = 0;
+    while (true) {
+        try {
+            await test();
+            return;
+        }
+        catch (err) {
+            i = i + 1;
+            if (i > numberOfTries) {
+                throw err;
+            }
+        }
+        await (0, utils_1.sleep)(period);
+    }
+}
+exports.autoRetry = autoRetry;
+async function fetchHtml(pathname) {
+    const response = await fetch(exports.urlBase + pathname);
+    const html = await response.text();
+    return html;
+}
+exports.fetchHtml = fetchHtml;
+async function fetch(...args) {
+    try {
+        return await (0, node_fetch_1.default)(...args);
+    }
+    catch (err) {
+        Logs_1.Logs.add({
+            logType: 'Connection Error',
+            logText: `Couldn't connect to \`${args[0]}\`. Args: \`${JSON.stringify(args.slice(1))}\`. Err: \`${
+            // @ts-ignore
+            err.message}\``,
+            testContext: null,
+        });
+        throw new Error("Couldn't connect to server. See `Connection Error` log for more details.");
+    }
+}
+exports.fetch = fetch;
+/*
+async function bailOnTimeout(asyncFunc: () => Promise<void>, { timeout }: { timeout: number }) {
+  let resolve: () => void
+  let reject: (err: Error) => void
+  const promise = new Promise<void>((_resolve, _reject) => {
+    resolve = _resolve
+    reject = _reject
+  })
+
+  const t = setTimeout(() => {
+    reject(new Error(`Function timeout.`))
+  }, timeout)
+  await asyncFunc()
+  clearTimeout(t)
+  resolve()
+
+  return promise
+}
+*/
+function isMinNodeVersion(minNodeVersion) {
+    const { version } = process;
+    (0, utils_2.assert)(version.startsWith('v'));
+    const major = parseInt(version[1] + version[2], 10);
+    (0, utils_2.assert)(12 <= major && major <= 50);
+    return major >= minNodeVersion;
+}
+exports.isMinNodeVersion = isMinNodeVersion;
+function isWindows() {
+    return process.platform === 'win32';
+}
+exports.isWindows = isWindows;
+function isLinux() {
+    return process.platform === 'linux';
+}
+exports.isLinux = isLinux;
+function isMac() {
+    if (process.platform === 'darwin') {
+        return true;
+    }
+    (0, utils_2.assert)(isLinux() || isWindows());
+    return false;
+}
+exports.isMac = isMac;
+function isGithubAction() {
+    return !!process.env.CI;
+}
+exports.isGithubAction = isGithubAction;
+function getCwd() {
+    const { testFile } = (0, getTestInfo_1.getTestInfo)();
+    const cwd = (0, path_1.dirname)(testFile);
+    return cwd;
+}
+function getTestName() {
+    const { testFile } = (0, getTestInfo_1.getTestInfo)();
+    const pathRelative = removeRootDir(testFile);
+    if (testFile.includes('examples')) {
+        return (0, path_1.dirname)(pathRelative);
+    }
+    else {
+        return pathRelative;
+    }
+}
+function removeRootDir(filePath) {
+    const rootDir = process.cwd();
+    (0, utils_2.assert)(filePath.startsWith(rootDir));
+    return filePath.slice(rootDir.length);
+}

package/dist/test.d.ts

@@ -0,0 +1,2 @@
+export { test };
+declare function test(testDesc: string, testFn: () => void | Promise<void>): void;

package/dist/test.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.test = void 0;
+const utils_1 = require("./utils");
+const getTestInfo_1 = require("./getTestInfo");
+function test(testDesc, testFn) {
+    const testInfo = (0, getTestInfo_1.getTestInfo)();
+    (0, utils_1.assert)(!testInfo.hasStartedRunning);
+    testInfo.tests = testInfo.tests ?? [];
+    testInfo.tests.push({
+        testDesc,
+        testFn,
+    });
+}
+exports.test = test;

package/dist/utils/assert.d.ts

@@ -0,0 +1,14 @@
+export { assert };
+export { assertUsage };
+export { assertWarning };
+export { assertInfo };
+export { getProjectError };
+export { errorPrefix as projectErrorPrefix };
+declare const errorPrefix: string;
+declare function assert(condition: unknown, debugInfo?: unknown): asserts condition;
+declare function assertUsage(condition: unknown, errorMessage: string): asserts condition;
+declare function getProjectError(errorMessage: string): Error;
+declare function assertWarning(condition: unknown, errorMessage: string, { onlyOnce }: {
+    onlyOnce: boolean | string;
+}): void;
+declare function assertInfo(condition: unknown, errorMessage: string): void;