@brillout/test-e2e 0.5.8 → 0.5.10

package/dist/Logs.d.ts

@@ -1,4 +1,4 @@
-export { expectError };
+export { expectLog };
 export declare const Logs: {
     add: typeof add;
     flushLogs: typeof flushLogs;
@@ -25,4 +25,4 @@ declare function add({ logSource, logText, loggedAfterExit, }: {
     logText: string;
     loggedAfterExit?: boolean;
 }): void;
-declare function expectError(logFilter: (browserLog: LogEntry) => boolean): void;
+declare function expectLog(logText: string, logFilter?: (logEntry: LogEntry) => boolean): void;

package/dist/Logs.js

@@ -3,7 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.Logs = exports.expectError = void 0;
+exports.Logs = exports.expectLog = void 0;
 exports.Logs = {
     add,
     flushLogs,
@@ -17,6 +17,7 @@ const picocolors_1 = __importDefault(require("picocolors"));
 const getCurrentTest_1 = require("./getCurrentTest");
 const logSection_1 = require("./logSection");
 const isTolerateError_1 = require("./Logs/isTolerateError");
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
 let logEntries = [];
 function hasFailLogs(failOnWarning) {
     const failLogs = getErrorLogs(failOnWarning);
@@ -74,18 +75,25 @@ function add({ logSource, logText, loggedAfterExit = false, }) {
         printLog(logEntry);
     }
 }
-function expectError(logFilter) {
-    const logFounds = logEntries.filter((logEntry) => {
-        if (logFilter(logEntry)) {
+function expectLog(logText, logFilter) {
+    const logsFound = logEntries.filter((logEntry) => {
+        if ((0, strip_ansi_1.default)(logEntry.logText).includes(logText)) {
             logEntry.isNotFailure = true;
             return true;
         }
         return false;
     });
-    //expect(logFounds.length).not.toBe(0)
-    (0, utils_1.assert)(logFounds.length > 0);
+    const logsFoundWithFilter = logsFound.filter((logEntry) => logFilter?.(logEntry));
+    if (logsFoundWithFilter.length === 0) {
+        if (logsFound.length === 0) {
+            throw new Error(`The following log was expected but wasn't logged: "${logText}"`);
+        }
+        else {
+            throw new Error(`The following log was logged as expected, but it didn't match the logFilter() you provided`);
+        }
+    }
 }
-exports.expectError = expectError;
+exports.expectLog = expectLog;
 function getTimestamp() {
     const now = new Date();
     const time = now.toTimeString().split(' ')[0];

package/dist/TIMEOUTS.d.ts

@@ -0,0 +1,5 @@
+export declare const TIMEOUT_NPM_SCRIPT: number;
+export declare const TIMEOUT_TEST_FUNCTION: number;
+export declare const TIMEOUT_PROCESS_TERMINATION: number;
+export declare const TIMEOUT_AUTORETRY: number;
+export declare const TIMEOUT_PLAYWRIGHT: number;

package/dist/TIMEOUTS.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TIMEOUT_PLAYWRIGHT = exports.TIMEOUT_AUTORETRY = exports.TIMEOUT_PROCESS_TERMINATION = exports.TIMEOUT_TEST_FUNCTION = exports.TIMEOUT_NPM_SCRIPT = void 0;
+const platform_1 = require("./utils/platform");
+exports.TIMEOUT_NPM_SCRIPT = 2 * 60 * 1000 * (!(0, platform_1.isCI)() ? 1 : (0, platform_1.isWindows)() ? 2 : 1);
+exports.TIMEOUT_TEST_FUNCTION = 60 * 1000 * (!(0, platform_1.isCI)() ? 1 : (0, platform_1.isWindows)() ? 5 : 3);
+exports.TIMEOUT_PROCESS_TERMINATION = 10 * 1000 * (!(0, platform_1.isCI)() ? 1 : (0, platform_1.isWindows)() ? 3 : !(0, platform_1.isLinux)() ? 3 : 1);
+exports.TIMEOUT_AUTORETRY = exports.TIMEOUT_TEST_FUNCTION / 2;
+exports.TIMEOUT_PLAYWRIGHT = exports.TIMEOUT_TEST_FUNCTION / 2;

package/dist/autoRetry.d.ts

@@ -0,0 +1,4 @@
+export { autoRetry };
+declare function autoRetry(test: () => void | Promise<void>, { timeout }?: {
+    timeout?: number;
+}): Promise<void>;

package/dist/autoRetry.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.autoRetry = void 0;
+const TIMEOUTS_1 = require("./TIMEOUTS");
+const utils_1 = require("./utils");
+async function autoRetry(test, { timeout = TIMEOUTS_1.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;

package/dist/buildTs.js

@@ -17,7 +17,7 @@ async function buildTs(entry, outfile) {
         outfile,
         logLevel: 'warning',
         format: 'esm',
-        target: 'es2020',
+        target: 'es2022',
         bundle: true,
         packages: 'external',
         minify: false,

package/dist/cli.js

@@ -30,6 +30,7 @@ function initUserExitHandler() {
         Logs_1.Logs.flushLogs();
     });
 }
+// Much simpler alternative: https://github.com/brillout/vite-plugin-ssr/blob/77b1b0e8b6c1ed4efe3e3039f7c0b23a00651663/vite-plugin-ssr/node/plugin/plugins/importUserCode/v1-design/transpileAndLoadFile.ts#L200-L208
 function initSourceMap() {
     source_map_support_1.default.install({
         retrieveSourceMap: function (source) {

package/dist/fetch.d.ts

@@ -0,0 +1,5 @@
+export { fetch };
+export { fetchHtml };
+import fetch_ from 'node-fetch';
+declare function fetchHtml(pathname: string): Promise<string>;
+declare function fetch(...args: Parameters<typeof fetch_>): Promise<import("node-fetch").Response>;

package/dist/fetch.js

@@ -0,0 +1,30 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fetchHtml = exports.fetch = void 0;
+const getCurrentTest_1 = require("./getCurrentTest");
+const node_fetch_1 = __importDefault(require("node-fetch"));
+const Logs_1 = require("./Logs");
+async function fetchHtml(pathname) {
+    const response = await fetch((0, getCurrentTest_1.getServerUrl)() + 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({
+            logSource: 'Connection Error',
+            logText: `Couldn't connect to \`${args[0]}\`. Args: \`${JSON.stringify(args.slice(1))}\`. Err: \`${
+            // @ts-ignore
+            err.message}\``,
+        });
+        throw new Error("Couldn't connect to server. See `Connection Error` log for more details.");
+    }
+}
+exports.fetch = fetch;

package/dist/getCurrentTest.d.ts

@@ -1,6 +1,10 @@
 export { getCurrentTest };
 export { getCurrentTestOptional };
 export { setCurrentTest };
+export { getRunInfo };
+export { setRunInfo };
+export { getCwd };
+export { getServerUrl };
 export type { TestInfo };
 import type { Page } from 'playwright-chromium';
 declare type TestInfo = {
@@ -10,17 +14,18 @@ declare type TestInfo = {
         testDesc: string;
         testFn: Function;
     }[];
+    testOptions?: {
+        doNotFailOnWarning: boolean;
+        testFunctionTimeout: number;
+        isFlaky: boolean;
+    };
     runInfo?: {
         cmd: string;
-        cwd: string;
-        testFunctionTimeout: number;
-        additionalTimeout: number;
-        serverIsReadyMessage?: string | ((log: string) => boolean);
-        serverIsReadyDelay: number;
-        inspect: boolean;
-        doNotFailOnWarning: boolean;
         serverUrl: string;
+        doNotFailOnWarning: boolean;
+        testFunctionTimeout: number;
         isFlaky: boolean;
+        isRunCommandThatTerminates: boolean;
     };
     hasStartedRunning?: boolean;
     skipped?: {
@@ -34,3 +39,21 @@ declare type TestInfo = {
 declare function getCurrentTest(): TestInfo;
 declare function getCurrentTestOptional(): null | TestInfo;
 declare function setCurrentTest(testFile: null | string): void;
+declare function getRunInfo(): {
+    cmd: string;
+    serverUrl: string;
+    doNotFailOnWarning: boolean;
+    testFunctionTimeout: number;
+    isFlaky: boolean;
+    isRunCommandThatTerminates: boolean;
+};
+declare function setRunInfo({ cmd, serverUrl, additionalTimeout, doNotFailOnWarning, isFlaky, isRunCommandThatTerminates, }: {
+    cmd: string;
+    serverUrl?: string;
+    additionalTimeout?: number;
+    doNotFailOnWarning?: boolean;
+    isFlaky?: boolean;
+    isRunCommandThatTerminates?: boolean;
+}): void;
+declare function getCwd(): string;
+declare function getServerUrl(): string;

package/dist/getCurrentTest.js

@@ -3,9 +3,10 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setCurrentTest = exports.getCurrentTestOptional = exports.getCurrentTest = void 0;
+exports.getServerUrl = exports.getCwd = exports.setRunInfo = exports.getRunInfo = exports.setCurrentTest = exports.getCurrentTestOptional = exports.getCurrentTest = void 0;
 const utils_1 = require("./utils");
 const path_1 = __importDefault(require("path"));
+const TIMEOUTS_1 = require("./TIMEOUTS");
 let testInfo = null;
 function getCurrentTest() {
     (0, utils_1.assert)(testInfo);
@@ -42,3 +43,35 @@ function removeRootDir(filePath) {
     (0, utils_1.assert)(filePath.startsWith(rootDir));
     return filePath.slice(rootDir.length);
 }
+function getRunInfo() {
+    const testInfo = getCurrentTest();
+    (0, utils_1.assert)(testInfo.runInfo);
+    return testInfo.runInfo;
+}
+exports.getRunInfo = getRunInfo;
+const serverUrlDefault = 'http://localhost:3000';
+function setRunInfo({ cmd, serverUrl = serverUrlDefault, additionalTimeout = 0, doNotFailOnWarning = false, isFlaky = false, isRunCommandThatTerminates = false, }) {
+    const testInfo = getCurrentTest();
+    const testFunctionTimeout = TIMEOUTS_1.TIMEOUT_TEST_FUNCTION + additionalTimeout;
+    testInfo.runInfo = {
+        cmd,
+        serverUrl,
+        testFunctionTimeout,
+        doNotFailOnWarning,
+        isFlaky,
+        isRunCommandThatTerminates,
+    };
+}
+exports.setRunInfo = setRunInfo;
+function getCwd() {
+    const { testFile } = getCurrentTest();
+    const cwd = path_1.default.dirname(testFile);
+    return cwd;
+}
+exports.getCwd = getCwd;
+function getServerUrl() {
+    const testInfo = getCurrentTest();
+    const serverUrl = testInfo.runInfo?.serverUrl;
+    return serverUrl;
+}
+exports.getServerUrl = getServerUrl;

package/dist/index.d.ts

@@ -1,6 +1,14 @@
-export * from './setup';
 export { expect } from './chai/expect';
 export { test } from './test';
 export { page } from './page';
 export { editFile, editFileRevert } from './editFile';
 export { testScreenshotFixture } from './testScreenshotFixture';
+export { partRegex } from '@brillout/part-regex';
+export { autoRetry } from './autoRetry';
+export { fetch, fetchHtml } from './fetch';
+export { expectLog } from './Logs';
+export { run } from './run';
+export { skip } from './skip';
+export { isMinNodeVersion, isCI, isLinux, isWindows, isMac, sleep } from './utils';
+export { getServerUrl } from './getCurrentTest';
+export { runCommandThatTerminates } from './runCommandThatTerminates';

package/dist/index.js

@@ -1,21 +1,6 @@
 "use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.testScreenshotFixture = exports.editFileRevert = exports.editFile = exports.page = exports.test = exports.expect = void 0;
-__exportStar(require("./setup"), exports);
+exports.runCommandThatTerminates = exports.getServerUrl = exports.sleep = exports.isMac = exports.isWindows = exports.isLinux = exports.isCI = exports.isMinNodeVersion = exports.skip = exports.run = exports.expectLog = exports.fetchHtml = exports.fetch = exports.autoRetry = exports.partRegex = exports.testScreenshotFixture = exports.editFileRevert = exports.editFile = exports.page = exports.test = exports.expect = void 0;
 var expect_1 = require("./chai/expect");
 Object.defineProperty(exports, "expect", { enumerable: true, get: function () { return expect_1.expect; } });
 var test_1 = require("./test");
@@ -27,3 +12,27 @@ Object.defineProperty(exports, "editFile", { enumerable: true, get: function ()
 Object.defineProperty(exports, "editFileRevert", { enumerable: true, get: function () { return editFile_1.editFileRevert; } });
 var testScreenshotFixture_1 = require("./testScreenshotFixture");
 Object.defineProperty(exports, "testScreenshotFixture", { enumerable: true, get: function () { return testScreenshotFixture_1.testScreenshotFixture; } });
+var part_regex_1 = require("@brillout/part-regex");
+Object.defineProperty(exports, "partRegex", { enumerable: true, get: function () { return part_regex_1.partRegex; } });
+var autoRetry_1 = require("./autoRetry");
+Object.defineProperty(exports, "autoRetry", { enumerable: true, get: function () { return autoRetry_1.autoRetry; } });
+var fetch_1 = require("./fetch");
+Object.defineProperty(exports, "fetch", { enumerable: true, get: function () { return fetch_1.fetch; } });
+Object.defineProperty(exports, "fetchHtml", { enumerable: true, get: function () { return fetch_1.fetchHtml; } });
+var Logs_1 = require("./Logs");
+Object.defineProperty(exports, "expectLog", { enumerable: true, get: function () { return Logs_1.expectLog; } });
+var run_1 = require("./run");
+Object.defineProperty(exports, "run", { enumerable: true, get: function () { return run_1.run; } });
+var skip_1 = require("./skip");
+Object.defineProperty(exports, "skip", { enumerable: true, get: function () { return skip_1.skip; } });
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "isMinNodeVersion", { enumerable: true, get: function () { return utils_1.isMinNodeVersion; } });
+Object.defineProperty(exports, "isCI", { enumerable: true, get: function () { return utils_1.isCI; } });
+Object.defineProperty(exports, "isLinux", { enumerable: true, get: function () { return utils_1.isLinux; } });
+Object.defineProperty(exports, "isWindows", { enumerable: true, get: function () { return utils_1.isWindows; } });
+Object.defineProperty(exports, "isMac", { enumerable: true, get: function () { return utils_1.isMac; } });
+Object.defineProperty(exports, "sleep", { enumerable: true, get: function () { return utils_1.sleep; } });
+var getCurrentTest_1 = require("./getCurrentTest");
+Object.defineProperty(exports, "getServerUrl", { enumerable: true, get: function () { return getCurrentTest_1.getServerUrl; } });
+var runCommandThatTerminates_1 = require("./runCommandThatTerminates");
+Object.defineProperty(exports, "runCommandThatTerminates", { enumerable: true, get: function () { return runCommandThatTerminates_1.runCommandThatTerminates; } });

package/dist/logTestStatus.js

@@ -51,8 +51,11 @@ function getStatusTags() {
     return { PASS, FAIL, WARN, BOOT };
 }
 function logBoot() {
+    if (!utils_1.isTTY)
+        return;
     const { testFile } = (0, getCurrentTest_1.getCurrentTest)();
     const { BOOT } = getStatusTags();
+    console.log();
     console.log(`${BOOT} ${testFile}`);
 }
 exports.logBoot = logBoot;

package/dist/run.d.ts

@@ -0,0 +1,12 @@
+export { run };
+declare function run(cmd: string, { additionalTimeout, serverIsReadyMessage, serverIsReadyDelay, inspect, cwd, doNotFailOnWarning, serverUrl, isFlaky, }?: {
+    additionalTimeout?: number;
+    serverIsReadyMessage?: string | ((log: string) => boolean);
+    serverIsReadyDelay?: number;
+    inspect?: boolean;
+    /** deprecated */
+    cwd?: string;
+    doNotFailOnWarning?: boolean;
+    serverUrl?: string;
+    isFlaky?: boolean;
+}): void;

package/dist/run.js

@@ -0,0 +1,188 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.run = void 0;
+const utils_1 = require("./utils");
+const utils_2 = require("./utils");
+const Logs_1 = require("./Logs");
+const editFile_1 = require("./editFile");
+const getCurrentTest_1 = require("./getCurrentTest");
+const page_1 = require("./page");
+const TIMEOUTS_1 = require("./TIMEOUTS");
+function run(cmd, { 
+//baseUrl = '',
+additionalTimeout = 0, serverIsReadyMessage, serverIsReadyDelay = 1000, inspect = utils_1.cliConfig.inspect, cwd, doNotFailOnWarning, serverUrl, isFlaky, } = {}) {
+    (0, utils_2.assert)(cwd === undefined);
+    additionalTimeout += serverIsReadyDelay;
+    (0, getCurrentTest_1.setRunInfo)({
+        cmd,
+        serverUrl,
+        additionalTimeout,
+        doNotFailOnWarning,
+        isFlaky,
+    });
+    if (inspect) {
+        Logs_1.Logs.logEagerly = true;
+    }
+    const testInfo = (0, getCurrentTest_1.getCurrentTest)();
+    let runProcess = null;
+    testInfo.startServer = async () => {
+        runProcess = await startProcess({
+            cmd,
+            additionalTimeout,
+            serverIsReadyMessage,
+            serverIsReadyDelay,
+        });
+        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(TIMEOUTS_1.TIMEOUT_PLAYWRIGHT + additionalTimeout);
+        /*
+        await bailOnTimeout(
+          async () => {
+            await page.goto(getServerUrl() + baseUrl)
+          },
+          { timeout: TIMEOUT_PAGE_LOAD + additionalTimeout },
+        )
+        */
+    };
+    testInfo.afterEach = (hasFailed) => {
+        if (!hasFailed) {
+            (0, editFile_1.editFileAssertReverted)();
+        }
+        else {
+            (0, editFile_1.editFileRevert)();
+        }
+    };
+    testInfo.terminateServer = async () => {
+        Logs_1.Logs.add({
+            logSource: 'run()',
+            logText: 'Terminate server.',
+        });
+        page_1.page.off('console', onConsole);
+        page_1.page.off('pageerror', onPageError);
+        // runProcess is undefined if startProcess() failed
+        if (runProcess) {
+            await runProcess.terminate();
+        }
+    };
+    return;
+    // Also called when the page throws an error or a warning
+    function onConsole(msg) {
+        const type = msg.type();
+        Logs_1.Logs.add({
+            logSource: (() => {
+                if (type === 'error') {
+                    return 'Browser Error';
+                }
+                if (type === 'warning') {
+                    return 'Browser Warning';
+                }
+                return 'Browser Log';
+            })(),
+            logText: JSON.stringify({
+                type,
+                text: msg.text(),
+                location: msg.location(),
+                args: msg.args(),
+            }, null, 2),
+        });
+    }
+    // For uncaught exceptions
+    function onPageError(err) {
+        Logs_1.Logs.add({
+            logSource: 'Browser Error',
+            logText: JSON.stringify({
+                text: err.message,
+                location: err.stack,
+            }, null, 2),
+        });
+    }
+}
+exports.run = run;
+async function startProcess({ serverIsReadyMessage, serverIsReadyDelay, additionalTimeout, cmd, }) {
+    const cwd = (0, getCurrentTest_1.getCwd)();
+    if (!serverIsReadyMessage) {
+        serverIsReadyMessage = (log) => {
+            const serverIsReady = 
+            // Express.js server
+            log.includes('Server running at') ||
+                // npm package `serve`
+                log.includes('Accepting connections at') ||
+                // Vite
+                (log.includes('Local:') && log.includes('http://localhost:3000/'));
+            return serverIsReady;
+        };
+    }
+    Logs_1.Logs.add({
+        logSource: 'run()',
+        logText: `Spawn command \`${cmd}\``,
+    });
+    const done = (0, utils_1.logProgress)(`[run] ${cmd}`);
+    const { terminate, isReadyPromise } = (0, utils_1.runCommandLongRunning)({
+        cmd,
+        cwd,
+        isReadyLog: serverIsReadyMessage,
+        isReadyTimeout: TIMEOUTS_1.TIMEOUT_NPM_SCRIPT + additionalTimeout,
+        killPort: process.env.CI || !(0, utils_1.isLinux)() ? false : getServerPort(),
+        onStderr(data, { loggedAfterExit }) {
+            Logs_1.Logs.add({
+                logSource: 'stderr',
+                logText: data,
+                loggedAfterExit,
+            });
+        },
+        onStdout(data, { loggedAfterExit }) {
+            Logs_1.Logs.add({
+                logSource: 'stdout',
+                logText: data,
+                loggedAfterExit,
+            });
+        },
+        onExit(errMsg) {
+            if (!errMsg) {
+                Logs_1.Logs.add({
+                    logSource: 'run()',
+                    logText: `Process termination (expected)`,
+                });
+            }
+            else {
+                Logs_1.Logs.add({
+                    logSource: 'run() failure',
+                    logText: errMsg,
+                });
+            }
+        },
+        onTerminationError(errMsg) {
+            Logs_1.Logs.add({
+                logSource: 'run() failure',
+                logText: errMsg,
+            });
+        },
+        terminationTimeout: TIMEOUTS_1.TIMEOUT_PROCESS_TERMINATION,
+    });
+    let err;
+    try {
+        await isReadyPromise;
+    }
+    catch (err_) {
+        err = err_;
+        (0, utils_2.assert)(err);
+    }
+    done(!!err);
+    if (err)
+        throw err;
+    Logs_1.Logs.add({
+        logSource: 'run()',
+        logText: 'Server is ready.',
+    });
+    await (0, utils_1.sleep)(serverIsReadyDelay);
+    return { terminate };
+}
+function getServerPort() {
+    const serverUrl = (0, getCurrentTest_1.getServerUrl)();
+    const portStr = serverUrl.split(':').slice(-1)[0].split('/')[0];
+    (0, utils_2.assert)(/\d+/.test(portStr), { serverUrl });
+    const port = parseInt(portStr, 10);
+    return port;
+}

package/dist/runAll.js

@@ -59,25 +59,48 @@ async function buildAndTest(testFile, browser, isSecondAttempt) {
     (0, utils_1.assert)(testFileJs.endsWith('.mjs'));
     const cleanBuild = await (0, buildTs_1.buildTs)(testFile, testFileJs);
     (0, getCurrentTest_2.setCurrentTest)(testFile);
+    (0, logTestStatus_1.logBoot)();
+    let execErr;
     try {
         await import((0, utils_2.fsWindowsBugWorkaround)(testFileJs) + `?cacheBuster=${Date.now()}`);
     }
+    catch (err) {
+        (0, utils_1.assert)(err);
+        execErr = err;
+    }
     finally {
         cleanBuild();
     }
-    const success = await runServerAndTests(browser, isSecondAttempt);
-    (0, getCurrentTest_2.setCurrentTest)(null);
-    return success;
-}
-async function runServerAndTests(browser, isSecondAttempt) {
+    if (execErr) {
+        (0, logTestStatus_1.logFail)(`an error was thrown while executing the file ${testFile}`, true);
+        (0, logError_1.logError)(execErr);
+        return false;
+    }
+    // When user calls skip()
     const testInfo = (0, getCurrentTest_1.getCurrentTest)();
-    // Set when user calls `skip()`
     if (testInfo.skipped) {
         assertSkipUsage(testInfo);
         (0, logTestStatus_1.logWarn)(testInfo.skipped.reason);
         return true;
     }
-    // Set when user calls `run()`
+    else {
+        // Set when user calls run() or runCommandThatTerminates()
+        (0, utils_1.assert)(testInfo.runInfo);
+    }
+    // When user calls run runCommandThatTerminates()
+    if (testInfo.runInfo.isRunCommandThatTerminates) {
+        (0, utils_1.assertUsage)(!testInfo.tests, "Can't call test() when calling runCommandThatTerminates()");
+        (0, utils_1.assertUsage)(!testInfo.startServer, "Can't call run() when calling runCommandThatTerminates()");
+        (0, logTestStatus_1.logPass)();
+        return true;
+    }
+    const success = await runServerAndTests(browser, isSecondAttempt);
+    (0, getCurrentTest_2.setCurrentTest)(null);
+    return success;
+}
+async function runServerAndTests(browser, isSecondAttempt) {
+    const testInfo = (0, getCurrentTest_1.getCurrentTest)();
+    // Set when user calls run()
     (0, utils_1.assert)(testInfo.runInfo);
     (0, utils_1.assert)(testInfo.startServer);
     (0, utils_1.assert)(testInfo.terminateServer);
@@ -104,7 +127,7 @@ async function runServerAndTests(browser, isSecondAttempt) {
     if (success) {
         const failOnWarning = true;
         if (Logs_1.Logs.hasFailLogs(failOnWarning) &&
-            // See comments about taskkill in src/setup.ts
+            // See comments about taskkill in src/utils/runCommandLongRunning.ts
             !(0, utils_1.isWindows)()) {
             logFailure(null, `${getErrorType(failOnWarning)} occurred during server termination`, isFinalAttempt);
             success = false;
@@ -123,9 +146,12 @@ async function runTests(testInfo, isFinalAttempt) {
     // Set when user calls `run()`
     (0, utils_1.assert)(testInfo.runInfo);
     (0, utils_1.assert)(testInfo.afterEach);
-    // Set when user calls `test()`
-    (0, utils_1.assert)(testInfo.tests);
-    for (const { testDesc, testFn } of testInfo.tests) {
+    const tests = 
+    // Set when user calls test()
+    testInfo.tests ??
+        // When user hasn't any test() call
+        [];
+    for (const { testDesc, testFn } of tests) {
         Logs_1.Logs.add({
             logSource: 'test()',
             logText: testDesc,

package/dist/runCommandThatTerminates.d.ts

@@ -0,0 +1,4 @@
+export { runCommandThatTerminates };
+declare function runCommandThatTerminates(cmd: string, { timeout }?: {
+    timeout?: number;
+}): Promise<void>;

package/dist/runCommandThatTerminates.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommandThatTerminates = void 0;
+const getCurrentTest_1 = require("./getCurrentTest");
+const utils_1 = require("./utils");
+async function runCommandThatTerminates(cmd, { timeout = 2 * 60 * 1000 } = {}) {
+    (0, getCurrentTest_1.setRunInfo)({ cmd, isRunCommandThatTerminates: true });
+    const cwd = (0, getCurrentTest_1.getCwd)();
+    await (0, utils_1.runCommand)(cmd, { timeout, cwd });
+}
+exports.runCommandThatTerminates = runCommandThatTerminates;

package/dist/skip.d.ts

@@ -0,0 +1,2 @@
+export { skip };
+declare function skip(reason: string): void;