@jsenv/test 1.5.2 → 1.6.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/test",
-  "version": "1.5.2",
+  "version": "1.6.1",
   "license": "MIT",
   "repository": {
     "type": "git",

package/src/execution/execute.js

@@ -14,6 +14,7 @@ import { Abort, raceProcessTeardownEvents } from "@jsenv/abort";
 import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem";
 import { createLogger } from "@jsenv/log";
 
+import { createTeardown } from "../helpers/teardown.js";
 import { assertAndNormalizeWebServer } from "./web_server_param.js";
 import { run } from "./run.js";
 
@@ -44,6 +45,7 @@ export const execute = async ({
     rootDirectoryUrl,
     "rootDirectoryUrl",
   );
+  const teardown = createTeardown();
   const executeOperation = Abort.startOperation();
   executeOperation.addAbortSignal(signal);
   if (handleSIGINT) {
@@ -58,7 +60,7 @@ export const execute = async ({
   }
 
   if (runtime.type === "browser") {
-    await assertAndNormalizeWebServer(webServer);
+    await assertAndNormalizeWebServer(webServer, { signal, teardown, logger });
   }
 
   let resultTransformer = (result) => result;
@@ -67,6 +69,7 @@ export const execute = async ({
     webServer,
     fileRelativeUrl,
     importMap,
+    teardown,
     ...runtimeParams,
   };
 
@@ -106,6 +109,7 @@ export const execute = async ({
     }
     return result;
   } finally {
+    await teardown.trigger();
     await executeOperation.end();
   }
 };

package/src/execution/execute_steps.js

@@ -4,7 +4,7 @@ import { takeCoverage } from "node:v8";
 import stripAnsi from "strip-ansi";
 import { urlToFileSystemPath } from "@jsenv/urls";
 import { createLog, startSpinner } from "@jsenv/log";
-import { Abort, raceProcessTeardownEvents } from "@jsenv/abort";
+import { Abort } from "@jsenv/abort";
 import { ensureEmptyDirectory, writeFileSync } from "@jsenv/filesystem";
 
 import { reportToCoverage } from "../coverage/report_to_coverage.js";
@@ -16,7 +16,7 @@ export const executeSteps = async (
   executionSteps,
   {
     signal,
-    handleSIGINT,
+    teardown,
     logger,
     logRefresh,
     logRuntime,
@@ -56,23 +56,9 @@ export const executeSteps = async (
   const executePlanReturnValue = {};
   const report = {};
   const callbacks = [];
-  const stopAfterAllSignal = { notify: () => {} };
 
   const multipleExecutionsOperation = Abort.startOperation();
   multipleExecutionsOperation.addAbortSignal(signal);
-  if (handleSIGINT) {
-    multipleExecutionsOperation.addAbortSource((abort) => {
-      return raceProcessTeardownEvents(
-        {
-          SIGINT: true,
-        },
-        () => {
-          logger.debug(`SIGINT abort`);
-          abort();
-        },
-      );
-    });
-  }
   const failFastAbortController = new AbortController();
   if (failFast) {
     multipleExecutionsOperation.addAbortSignal(failFastAbortController.signal);
@@ -125,7 +111,8 @@ export const executeSteps = async (
       coverageConfig,
       coverageMethodForBrowsers,
       coverageMethodForNodeJs,
-      stopAfterAllSignal,
+      isTestPlan: true,
+      teardown,
     };
 
     if (logMergeForCompletedExecutions && !process.stdout.isTTY) {
@@ -323,8 +310,8 @@ export const executeSteps = async (
       },
     });
     if (!keepRunning) {
-      logger.debug("stopAfterAllSignal.notify()");
-      await stopAfterAllSignal.notify();
+      logger.debug("trigger test plan teardown");
+      await teardown.trigger();
     }
 
     counters.cancelled = counters.total - counters.done;
@@ -346,10 +333,9 @@ export const executeSteps = async (
     executePlanReturnValue.aborted = multipleExecutionsOperation.signal.aborted;
     executePlanReturnValue.planSummary = summary;
     executePlanReturnValue.planReport = report;
-    await callbacks.reduce(async (previous, callback) => {
-      await previous;
+    for (const callback of callbacks) {
       await callback();
-    }, Promise.resolve());
+    }
     return executePlanReturnValue;
   } finally {
     await multipleExecutionsOperation.end();

package/src/execution/execute_test_plan.js

@@ -1,4 +1,5 @@
 import { existsSync } from "node:fs";
+import { Abort, raceProcessTeardownEvents } from "@jsenv/abort";
 import { URL_META } from "@jsenv/url-meta";
 import { urlToFileSystemPath, urlToRelativeUrl } from "@jsenv/urls";
 import {
@@ -8,6 +9,7 @@ import {
 } from "@jsenv/filesystem";
 import { createLogger, createDetailedMessage } from "@jsenv/log";
 
+import { createTeardown } from "../helpers/teardown.js";
 import { generateCoverageJsonFile } from "../coverage/coverage_reporter_json_file.js";
 import { generateCoverageHtmlDirectory } from "../coverage/coverage_reporter_html_directory.js";
 import { generateCoverageTextLog } from "../coverage/coverage_reporter_text_log.js";
@@ -103,6 +105,25 @@ export const executeTestPlan = async ({
   coverageReportHtmlDirectoryUrl,
   ...rest
 }) => {
+  const teardown = createTeardown();
+
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
+  if (handleSIGINT) {
+    operation.addAbortSource((abort) => {
+      return raceProcessTeardownEvents(
+        {
+          SIGINT: true,
+        },
+        () => {
+          logger.debug(`SIGINT abort`);
+          abort();
+        },
+      );
+    });
+  }
+
+  let logger;
   let someNeedsServer = false;
   let someHasCoverageV8 = false;
   let someNodeRuntime = false;
@@ -126,6 +147,8 @@ export const executeTestPlan = async ({
       throw new Error(`testPlan must be an object, got ${testPlan}`);
     }
 
+    logger = createLogger({ logLevel });
+
     Object.keys(testPlan).forEach((filePattern) => {
       const filePlan = testPlan[filePattern];
       if (!filePlan) return;
@@ -148,7 +171,11 @@ export const executeTestPlan = async ({
     });
 
     if (someNeedsServer) {
-      await assertAndNormalizeWebServer(webServer);
+      await assertAndNormalizeWebServer(webServer, {
+        signal: operation.signal,
+        teardown,
+        logger,
+      });
     }
 
     if (coverageEnabled) {
@@ -233,7 +260,6 @@ export const executeTestPlan = async ({
     }
   }
 
-  const logger = createLogger({ logLevel });
   logger.debug(
     createDetailedMessage(`Prepare executing plan`, {
       runtimes: JSON.stringify(runtimes, null, "  "),
@@ -288,7 +314,7 @@ export const executeTestPlan = async ({
 
   const result = await executeSteps(executionSteps, {
     signal,
-    handleSIGINT,
+    teardown,
     logger,
     logRefresh,
     logSummary,

package/src/execution/web_server/start_using_command.js

@@ -0,0 +1,132 @@
+import { spawn, spawnSync } from "node:child_process";
+import { Abort } from "@jsenv/abort";
+
+import { pingServer } from "../../helpers/ping_server.js";
+
+export const startServerUsingCommand = async (
+  webServer,
+  { signal, allocatedMs, logger, teardown },
+) => {
+  const spawnedProcess = spawn(webServer.command, [], {
+    // On non-windows platforms, `detached: true` makes child process a leader of a new
+    // process group, making it possible to kill child process tree with `.kill(-pid)` command.
+    // @see https://nodejs.org/api/child_process.html#child_process_options_detached
+    detached: process.platform !== "win32",
+    stdio: ["pipe", "pipe", "pipe"],
+    shell: true,
+    cwd: webServer.cwd,
+  });
+  if (!spawnedProcess.pid) {
+    await new Promise((resolve, reject) => {
+      spawnedProcess.once("error", (error) => {
+        reject(new Error(`Failed to launch: ${error}`));
+      });
+    });
+  }
+
+  let errorReceived = false;
+  const errorPromise = new Promise((resolve, reject) => {
+    spawnedProcess.on("error", (e) => {
+      errorReceived = true;
+      reject(e);
+    });
+  });
+
+  // const stdout = readline.createInterface({ input: spawnedProcess.stdout });
+  // stdout.on("line", () => {
+  //   logger.debug(`[pid=${spawnedProcess.pid}][out] ${data}`);
+  // });
+  // const stderr = readline.createInterface({ input: spawnedProcess.stderr });
+  // stderr.on("line", (data) => {
+  //   logger.debug(`[pid=${spawnedProcess.pid}][err] ${data}`);
+  // });
+  let processClosed = false;
+  const closedPromise = new Promise((resolve) => {
+    spawnedProcess.once("exit", (exitCode, signal) => {
+      logger.info(
+        `[pid=${spawnedProcess.pid}] <process did exit: exitCode=${exitCode}, signal=${signal}>`,
+      );
+      processClosed = true;
+      resolve();
+    });
+  });
+  const killProcess = async () => {
+    logger.info(`[pid=${spawnedProcess.pid}] <kill>`);
+    if (!spawnedProcess.pid || spawnedProcess.killed || processClosed) {
+      logger.info(
+        `[pid=${spawnedProcess.pid}] <skipped force kill spawnedProcess.killed=${spawnedProcess.killed} processClosed=${processClosed}>`,
+      );
+      return;
+    }
+    logger.info(`[pid=${spawnedProcess.pid}] <will force kill>`);
+    // Force kill the browser.
+    try {
+      if (process.platform === "win32") {
+        const taskkillProcess = spawnSync(
+          `taskkill /pid ${spawnedProcess.pid} /T /F`,
+          { shell: true },
+        );
+        const [stdout, stderr] = [
+          taskkillProcess.stdout.toString(),
+          taskkillProcess.stderr.toString(),
+        ];
+        if (stdout)
+          logger.info(`[pid=${spawnedProcess.pid}] taskkill stdout: ${stdout}`);
+        if (stderr)
+          logger.info(`[pid=${spawnedProcess.pid}] taskkill stderr: ${stderr}`);
+      } else {
+        process.kill(-spawnedProcess.pid, "SIGKILL");
+      }
+    } catch (e) {
+      logger.info(
+        `[pid=${spawnedProcess.pid}] exception while trying to kill process: ${e}`,
+      );
+      // the process might have already stopped
+    }
+    await closedPromise;
+  };
+
+  const startOperation = Abort.startOperation();
+  startOperation.addAbortSignal(signal);
+  const timeoutAbortSource = startOperation.timeout(allocatedMs);
+  startOperation.addAbortCallback(killProcess);
+  teardown.addCallback(killProcess);
+
+  const startedPromise = (async () => {
+    const logScale = [100, 250, 500];
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      if (errorReceived) {
+        break;
+      }
+      const connected = await pingServer(webServer.origin);
+      if (connected) {
+        break;
+      }
+      startOperation.throwIfAborted();
+      const delay = logScale.shift() || 1000;
+      logger.debug(`Waiting ${delay}ms`);
+      await new Promise((x) => setTimeout(x, delay));
+    }
+  })();
+
+  try {
+    await Promise.race([errorPromise, startedPromise]);
+  } catch (e) {
+    if (Abort.isAbortError(e)) {
+      if (timeoutAbortSource.signal.aborted) {
+        // aborted by timeout
+        throw new Error(
+          `"${webServer.command}" command did not start a server in less than ${allocatedMs}ms (webServer.command)`,
+        );
+      }
+      if (signal.aborted) {
+        // aborted from outside
+        return;
+      }
+    }
+    throw e;
+  } finally {
+    await startOperation.end();
+  }
+};

package/src/execution/web_server/start_using_module_url.js

@@ -0,0 +1,79 @@
+import { existsSync } from "node:fs";
+import { Worker } from "node:worker_threads";
+import { Abort } from "@jsenv/abort";
+
+import { pingServer } from "../../helpers/ping_server.js";
+
+export const startServerUsingModuleUrl = async (
+  webServer,
+  { signal, teardown, logger, allocatedMs },
+) => {
+  if (!existsSync(new URL(webServer.moduleUrl))) {
+    throw new Error(
+      `webServer.moduleUrl does not lead to a file at "${webServer.moduleUrl}"`,
+    );
+  }
+  const worker = new Worker(webServer.moduleUrl, {
+    env: {
+      // IMPORTED_BY_TEST_PLAN: "1",
+    },
+    stdin: true,
+    stdout: true,
+  });
+  let errorReceived = false;
+  const errorPromise = new Promise((resolve, reject) => {
+    worker.on("error", (e) => {
+      errorReceived = true;
+      reject(e);
+    });
+  });
+
+  const killWorker = async () => {
+    await worker.terminate();
+  };
+
+  const startOperation = Abort.startOperation();
+  startOperation.addAbortSignal(signal);
+  const timeoutAbortSource = startOperation.timeout(allocatedMs);
+  startOperation.addAbortCallback(killWorker);
+  teardown.addCallback(killWorker);
+
+  const startedPromise = (async () => {
+    const logScale = [100, 250, 500];
+    // eslint-disable-next-line no-constant-condition
+    while (true) {
+      if (errorReceived) {
+        break;
+      }
+      const connected = await pingServer(webServer.origin);
+      if (connected) {
+        break;
+      }
+
+      startOperation.throwIfAborted();
+      const delay = logScale.shift() || 1000;
+      logger.debug(`Waiting ${delay}ms`);
+      await new Promise((x) => setTimeout(x, delay));
+    }
+  })();
+
+  try {
+    await Promise.race([errorPromise, startedPromise]);
+  } catch (e) {
+    if (Abort.isAbortError(e)) {
+      if (timeoutAbortSource.signal.aborted) {
+        // aborted by timeout
+        throw new Error(
+          `"${webServer.moduleUrl}" did not start a server in less than ${allocatedMs}ms (webServer.moduleUrl)`,
+        );
+      }
+      if (signal.aborted) {
+        // aborted from outside
+        return;
+      }
+    }
+    throw e;
+  } finally {
+    await startOperation.end();
+  }
+};

package/src/execution/web_server/worker_importing_module_starting_web_server.mjs

@@ -0,0 +1,5 @@
+import { parentPort, workerData } from "node:worker_threads";
+
+const { url } = workerData;
+await import(url);
+parentPort.postMessage("done");

package/src/execution/web_server_param.js

@@ -1,53 +1,43 @@
-import { fileURLToPath } from "node:url";
 import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem";
 
+import { startServerUsingModuleUrl } from "./web_server/start_using_module_url.js";
+import { startServerUsingCommand } from "./web_server/start_using_command.js";
 import { pingServer } from "../helpers/ping_server.js";
 import { basicFetch } from "../helpers/basic_fetch.js";
 
-export const assertAndNormalizeWebServer = async (webServer) => {
+export const assertAndNormalizeWebServer = async (
+  webServer,
+  { signal, logger, teardown },
+) => {
   if (!webServer) {
     throw new TypeError(
       `webServer is required when running tests on browser(s)`,
     );
   }
   const unexpectedParamNames = Object.keys(webServer).filter((key) => {
-    return !["origin", "moduleUrl", "rootDirectoryUrl"].includes(key);
+    return ![
+      "origin",
+      "moduleUrl",
+      "command",
+      "cwd",
+      "rootDirectoryUrl",
+    ].includes(key);
   });
   if (unexpectedParamNames.length > 0) {
     throw new TypeError(
       `${unexpectedParamNames.join(",")}: there is no such param to webServer`,
     );
   }
-
-  let aServerIsListening = await pingServer(webServer.origin);
-  if (!aServerIsListening) {
-    if (!webServer.moduleUrl) {
-      throw new TypeError(
-        `webServer.moduleUrl is required as there is no server listening "${webServer.origin}"`,
-      );
-    }
-    try {
-      process.env.IMPORTED_BY_TEST_PLAN = "1";
-      await import(webServer.moduleUrl);
-      delete process.env.IMPORTED_BY_TEST_PLAN;
-    } catch (e) {
-      if (
-        e.code === "ERR_MODULE_NOT_FOUND" &&
-        e.message.includes(fileURLToPath(webServer.moduleUrl))
-      ) {
-        throw new Error(
-          `webServer.moduleUrl does not lead to a file at "${webServer.moduleUrl}"`,
-        );
-      }
-      throw e;
-    }
-    aServerIsListening = await pingServer(webServer.origin);
-    if (!aServerIsListening) {
-      throw new Error(
-        `webServer.moduleUrl did not start a server listening at "${webServer.origin}", check file at "${webServer.moduleUrl}"`,
-      );
-    }
+  if (typeof webServer.origin !== "string") {
+    throw new TypeError(
+      `webServer.origin must be a string, got ${webServer.origin}`,
+    );
   }
+  await ensureWebServerIsStarted(webServer, {
+    signal,
+    teardown,
+    logger,
+  });
   const { headers } = await basicFetch(webServer.origin, {
     method: "GET",
     rejectUnauthorized: false,
@@ -76,3 +66,34 @@ export const assertAndNormalizeWebServer = async (webServer) => {
     );
   }
 };
+
+export const ensureWebServerIsStarted = async (
+  webServer,
+  { signal, teardown, logger, allocatedMs = 5_000 },
+) => {
+  const aServerIsListening = await pingServer(webServer.origin);
+  if (aServerIsListening) {
+    return;
+  }
+  if (webServer.moduleUrl) {
+    await startServerUsingModuleUrl(webServer, {
+      signal,
+      allocatedMs,
+      teardown,
+      logger,
+    });
+    return;
+  }
+  if (webServer.command) {
+    await startServerUsingCommand(webServer, {
+      signal,
+      allocatedMs,
+      teardown,
+      logger,
+    });
+    return;
+  }
+  throw new TypeError(
+    `webServer.moduleUrl or webServer.command is required as there is no server listening "${webServer.origin}"`,
+  );
+};

package/src/helpers/teardown.js

@@ -0,0 +1,15 @@
+export const createTeardown = () => {
+  const teardownCallbackSet = new Set();
+  return {
+    addCallback: (callback) => {
+      teardownCallbackSet.add(callback);
+    },
+    trigger: async () => {
+      await Promise.all(
+        Array.from(teardownCallbackSet.values()).map(async (callback) => {
+          await callback();
+        }),
+      );
+    },
+  };
+};

package/src/runtime_browsers/using_playwright.js

@@ -52,7 +52,8 @@ export const createRuntimeUsingPlaywright = ({
     coverageMethodForBrowsers,
     coverageFileUrl,
 
-    stopAfterAllSignal,
+    teardown,
+    isTestPlan,
     stopSignal,
     keepRunning,
     onConsole,
@@ -71,7 +72,7 @@ export const createRuntimeUsingPlaywright = ({
       await cleanupCallbackList.notify({ reason });
     });
 
-    const isBrowserDedicatedToExecution = isolatedTab || !stopAfterAllSignal;
+    const isBrowserDedicatedToExecution = isolatedTab || !isTestPlan;
     let browserAndContextPromise = isBrowserDedicatedToExecution
       ? null
       : browserPromiseCache.get(label);
@@ -320,15 +321,11 @@ export const createRuntimeUsingPlaywright = ({
               cleanupCallbackList.add(() => {
                 browser.removeListener("disconnected", disconnectedCallback);
               });
-              const notifyPrevious = stopAfterAllSignal.notify;
-              stopAfterAllSignal.notify = async () => {
-                await notifyPrevious();
+              teardown.addCallback(async () => {
                 browser.removeListener("disconnected", disconnectedCallback);
-                logger.debug(
-                  `stopAfterAllSignal notified -> closing ${browserName}`,
-                );
+                logger.debug(`testPlan teardown -> closing ${browserName}`);
                 await closeBrowser();
-              };
+              });
             }
           },
           response: async (cb) => {