@brillout/test-e2e 0.5.8 → 0.5.9

package/dist/utils/runCommand.js

@@ -2,45 +2,25 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runCommand = void 0;
 const child_process_1 = require("child_process");
-function runCommand(cmd, { swallowError = false, timeout = 5000, cwd = process.cwd(), } = {}) {
-    const { promise, resolvePromise, rejectPromise } = genPromise();
+const genPromise_1 = require("./genPromise");
+const humanizeTime_1 = require("./humanizeTime");
+function runCommand(cmd, { timeout, cwd }) {
+    const { promise, resolve, reject } = (0, genPromise_1.genPromise)();
     const t = setTimeout(() => {
-        console.error(`Command call \`${cmd}\` timeout [${timeout / 1000} seconds][${cwd}].`);
-        rejectPromise();
+        reject(new Error(`Command call \`${cmd}\` (${cwd}) timed out after ${(0, humanizeTime_1.humanizeTime)(timeout)}`));
     }, timeout);
-    const options = { cwd };
-    (0, child_process_1.exec)(cmd, options, (err, stdout, stderr) => {
+    (0, child_process_1.exec)(cmd, { cwd }, (err, _stdout, stderr) => {
         clearTimeout(t);
-        if (err || stderr) {
-            if (swallowError) {
-                resolvePromise('SWALLOWED_ERROR');
-            }
-            else {
-                if (stdout) {
-                    console.log(stdout);
-                }
-                if (stderr) {
-                    console.error(stderr);
-                }
-                if (err) {
-                    console.error(err);
-                }
-                throw new Error(`Command \`${cmd}\` failed [cwd: ${cwd}]`);
-            }
+        if (stderr) {
+            reject(new Error(stderr));
+        }
+        else if (err) {
+            reject(err);
         }
         else {
-            resolvePromise(stdout);
+            resolve(undefined);
         }
     });
     return promise;
 }
 exports.runCommand = runCommand;
-function genPromise() {
-    let resolvePromise;
-    let rejectPromise;
-    const promise = new Promise((resolve, reject) => {
-        resolvePromise = resolve;
-        rejectPromise = reject;
-    });
-    return { promise, resolvePromise, rejectPromise };
-}

package/dist/utils/runCommandLongRunning.d.ts

@@ -0,0 +1,20 @@
+export { runCommandLongRunning };
+declare function runCommandLongRunning({ cmd, cwd, killPort, isReadyLog, isReadyTimeout, onStdout, onStderr, onExit, onTerminationError, terminationTimeout, }: {
+    cmd: string;
+    cwd: string;
+    killPort: false | number;
+    isReadyLog: string | ((log: string) => boolean);
+    isReadyTimeout: number;
+    onStdout: (log: string, info: {
+        loggedAfterExit: boolean;
+    }) => void;
+    onStderr: (log: string, info: {
+        loggedAfterExit: boolean;
+    }) => void;
+    onExit: (errMsg?: string) => void;
+    onTerminationError: (errMsg: string) => void;
+    terminationTimeout: number;
+}): {
+    terminate: (force?: true) => Promise<void>;
+    isReadyPromise: Promise<void>;
+};

package/dist/utils/runCommandLongRunning.js

@@ -0,0 +1,232 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommandLongRunning = void 0;
+const child_process_1 = require("child_process");
+const strip_ansi_1 = __importDefault(require("strip-ansi"));
+const utils_1 = require("../utils");
+function runCommandLongRunning({ cmd, cwd, killPort, isReadyLog, isReadyTimeout, onStdout, onStderr, onExit, onTerminationError, terminationTimeout, }) {
+    if (killPort)
+        killByPort(killPort);
+    let onError;
+    let onReady;
+    let isReady = false;
+    const isReadyPromise = new Promise((resolve_, reject_) => {
+        onReady = () => {
+            clearTimeout(isReadyPromiseTimeout);
+            (0, utils_1.assert)(!procExited);
+            isReady = true;
+            resolve_();
+        };
+        onError = async (err, alreadyTerminated) => {
+            clearTimeout(isReadyPromiseTimeout);
+            // We reject before terminating the process in order to preserve log order. (This order is fine because the test runner doesn't exit upon test failure.)
+            reject_(err);
+            if (!alreadyTerminated) {
+                (0, utils_1.assert)(!procExited);
+                await terminateProc(true);
+            }
+            (0, utils_1.assert)(procExited);
+        };
+    });
+    let isReadyPromiseTimedOut = false;
+    const isReadyPromiseTimeout = setTimeout(async () => {
+        isReadyPromiseTimedOut = true;
+        let errMsg = `Command \`${cmd}\` not ready after ${(0, utils_1.humanizeTime)(isReadyTimeout)}.`;
+        if (typeof isReadyLog === 'string') {
+            errMsg += ` The stdout of the command did not (yet?) include "${isReadyLog}".`;
+        }
+        onError(new Error(errMsg));
+    }, isReadyTimeout);
+    let [command, ...args] = cmd.split(' ');
+    let detached = true;
+    if ((0, utils_1.isWindows)()) {
+        detached = false;
+        if (command === 'npm' || command === 'pnpm') {
+            command = command + '.cmd';
+        }
+    }
+    const proc = (0, child_process_1.spawn)(command, args, { cwd, detached });
+    let procExited = false;
+    proc.stdin.on('data', async (chunk) => {
+        const data = String(chunk);
+        onError(new Error(`Command \`${cmd}\` (${cwd}) is invoking stdin which is forbidden. The stdin data: ${data}`));
+    });
+    proc.stdout.on('data', (chunk) => {
+        const log = String(chunk);
+        onStdout(log, { loggedAfterExit: procExited });
+        {
+            const logCleaned = (0, strip_ansi_1.default)(log);
+            let isMatch = false;
+            if (typeof isReadyLog === 'string') {
+                isMatch = logCleaned.includes(isReadyLog);
+            }
+            else if ((0, utils_1.isCallable)(isReadyLog)) {
+                isMatch = isReadyLog(logCleaned);
+            }
+            else {
+                (0, utils_1.assert)(false);
+            }
+            if (isMatch)
+                onReady();
+        }
+    });
+    proc.stderr.on('data', async (chunk) => {
+        const log = String(chunk);
+        onStderr(log, { loggedAfterExit: procExited });
+        if (log.includes('EADDRINUSE')) {
+            onError(new Error('Port conflict? Port already in use EADDRINUSE.'));
+        }
+    });
+    let exitPromiseResolve;
+    const exitPromise = new Promise((r) => (exitPromiseResolve = r));
+    proc.on('exit', (code) => {
+        procExited = true;
+        let errMsg;
+        {
+            const exitIsExpected = isReady === true || isReadyPromiseTimedOut;
+            if (!isSuccessCode(code)) {
+                errMsg = `Unexpected termination of command \`${cmd}\` with exit code ${code}`;
+            }
+            else if (!exitIsExpected) {
+                errMsg = `Unexpected premature termination of command \`${cmd}\` (with success exit code ${code})`;
+            }
+        }
+        // We add errMsg to onExit() because isReadyPromise may have already returned
+        onExit(errMsg);
+        if (errMsg) {
+            onError(new Error(errMsg), true);
+        }
+        else {
+            (0, utils_1.assert)(isReady);
+        }
+        exitPromiseResolve();
+    });
+    return {
+        isReadyPromise,
+        async terminate() {
+            if (procExited)
+                return;
+            await terminateProc();
+        },
+    };
+    async function terminateProc(force) {
+        let resolve;
+        let reject;
+        const promise = new Promise((resolve_, reject_) => {
+            resolve = async () => {
+                resolve_();
+            };
+            reject = () => {
+                reject_();
+            };
+        });
+        const terminateTimeout = setTimeout(() => {
+            const errMsg = 'Process termination timeout. Cmd: ' + cmd;
+            onTerminationError(errMsg);
+            /* Don't interrupt the test runner, as the test runner may recover thanks to killByPort() (EDIT: this is actually inaccurate since killByPort() isn't called in CI. Maybe we should reject?)
+            reject(new Error(errMsg))
+            */
+            resolve();
+        }, terminationTimeout);
+        (0, utils_1.assert)(proc);
+        await stopProcess({
+            proc,
+            cwd,
+            cmd,
+            force,
+            onTerminationError,
+        });
+        clearTimeout(terminateTimeout);
+        await exitPromise;
+        resolve();
+        return promise;
+    }
+}
+exports.runCommandLongRunning = runCommandLongRunning;
+function stopProcess({ proc, cwd, cmd, force, onTerminationError, }) {
+    let resolve;
+    const promise = new Promise((_resolve, _reject) => {
+        resolve = _resolve;
+    });
+    const onProcessClose = (code) => {
+        if (!isSuccessCode(code)) {
+            onTerminationError(`Command \`${cmd}\` (${cwd}) terminated with non-0 error code ${code}`);
+        }
+        resolve();
+    };
+    proc.on('close', onProcessClose);
+    proc.on('exit', onProcessClose);
+    const { pid } = proc;
+    (0, utils_1.assert)(pid);
+    if ((0, utils_1.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
+        // - taskkill seems to be buggy in many ways:
+        //   - taskkill seems to make the process exit with code `1`
+        //   - Because process exits with code `1`, Node.js/npm complains:
+        //     ```
+        //     [15:36:10.626][\examples\react][npm run preview][stderr] npm
+        //     [15:36:10.626][\examples\react][npm run preview][stderr]
+        //     [15:36:10.626][\examples\react][npm run preview][stderr] ERR!
+        //     [15:36:10.626][\examples\react][npm run preview][stderr]
+        //     [15:36:10.626][\examples\react][npm run preview][stderr] code
+        //     [15:36:10.626][\examples\react][npm run preview][stderr] ELIFECYCLE
+        //     ```
+        //     Because stderr isn't empty, runTests() believes that the termination failed.
+        //   - taskkill sometimes throws:
+        //     ```
+        //     ERROR: The process with PID 6052 (child process of PID 3184) could not be terminated.
+        //     Reason: There is no running instance of the task.
+        //     ```
+        //     ```
+        //     ERROR: The process "6564" not found.
+        //     ```
+        //     There doesn't seem to be an option to suppress these errors: https://learn.microsoft.com/en-us/windows-server/administration/windows-commands/taskkill#parameters
+        (0, utils_1.assert)(typeof pid === 'number');
+        (0, child_process_1.spawn)('taskkill', ['/pid', String(pid), '/f', '/t'], {
+            stdio: [
+                'ignore',
+                // Ignore following log to avoid polluting non-error logs. (Setting 'inherit' instead of 'ignore' attaches stdout to the root process and not to `proc` which is why the stdout of taskkill isn't intercepted by `proc.stdout.on('data', () => /* ... */)`.)
+                // ```
+                // SUCCESS: The process with PID 6932 (child process of PID 2744) has been terminated.
+                // ```
+                'ignore',
+                // Ignoring stderr doesn't solve the problem that taskkill makes the process exit with code 1
+                'inherit', // stderr
+            ],
+        });
+    }
+    else {
+        (0, utils_1.assert)(typeof pid === 'number');
+        const processGroup = -1 * pid;
+        const signal = force ? 'SIGKILL' : 'SIGTERM';
+        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;
+}
+async function killByPort(port) {
+    (0, utils_1.assert)((0, utils_1.isLinux)());
+    (0, utils_1.assert)(port);
+    await (0, utils_1.runCommandShortLived)(`fuser -k ${port}/tcp`, { swallowError: true, timeout: 10 * 1000 });
+}
+function isSuccessCode(code) {
+    return code === 0 || code === null || (code === 1 && (0, utils_1.isWindows)());
+}

package/dist/utils/runCommandShortLived.d.ts

@@ -0,0 +1,6 @@
+export { runCommandShortLived };
+declare function runCommandShortLived(cmd: string, { swallowError, timeout, cwd, }?: {
+    swallowError?: boolean;
+    timeout?: number;
+    cwd?: string;
+}): Promise<string>;

package/dist/utils/runCommandShortLived.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runCommandShortLived = void 0;
+const child_process_1 = require("child_process");
+const genPromise_1 = require("./genPromise");
+const humanizeTime_1 = require("./humanizeTime");
+function runCommandShortLived(cmd, { swallowError = false, timeout = 5000, cwd = process.cwd(), } = {}) {
+    const { promise, resolve, reject } = (0, genPromise_1.genPromise)();
+    const t = setTimeout(() => {
+        console.error(`Command call \`${cmd}\` (${cwd}) timed out after ${(0, humanizeTime_1.humanizeTime)(timeout)}`);
+        reject();
+    }, timeout);
+    const options = { cwd };
+    (0, child_process_1.exec)(cmd, options, (err, stdout, stderr) => {
+        clearTimeout(t);
+        if (err || stderr) {
+            if (swallowError) {
+                resolve('SWALLOWED_ERROR');
+            }
+            else {
+                if (stdout) {
+                    console.log(stdout);
+                }
+                if (stderr) {
+                    console.error(stderr);
+                }
+                if (err) {
+                    console.error(err);
+                }
+                throw new Error(`Command \`${cmd}\` failed [cwd: ${cwd}]`);
+            }
+        }
+        else {
+            resolve(stdout);
+        }
+    });
+    return promise;
+}
+exports.runCommandShortLived = runCommandShortLived;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@brillout/test-e2e",
-  "version": "0.5.8",
+  "version": "0.5.9",
   "bin": "./bin.js",
   "main": "./dist/index.js",
   "scripts": {