@jsenv/test 1.8.1 → 2.1.0

package/dist/js/v8_coverage.js

@@ -39,6 +39,7 @@ const isWindowsPathnameSpecifier = (specifier) => {
 const hasScheme = (specifier) => /^[a-zA-Z]+:/.test(specifier);
 
 const resolveAssociations = (associations, baseUrl) => {
+  if (baseUrl && typeof baseUrl.href === "string") baseUrl = baseUrl.href;
   assertUrlLike(baseUrl, "baseUrl");
   const associationsResolved = {};
   Object.keys(associations).forEach((key) => {
@@ -122,6 +123,7 @@ const asFlatAssociations = (associations) => {
  */
 const applyPatternMatching = ({ url, pattern }) => {
   assertUrlLike(pattern, "pattern");
+  if (url && typeof url.href === "string") url = url.href;
   assertUrlLike(url, "url");
   const { matched, patternIndex, index, groups } = applyMatching(pattern, url);
   const matchGroups = [];
@@ -369,6 +371,7 @@ const skipUntilMatch = ({ pattern, string, canSkipSlash }) => {
 };
 
 const applyAssociations = ({ url, associations }) => {
+  if (url && typeof url.href === "string") url = url.href;
   assertUrlLike(url);
   const flatAssociations = asFlatAssociations(associations);
   return Object.keys(flatAssociations).reduce((previousValue, pattern) => {
@@ -418,6 +421,7 @@ const applyAliases = ({ url, aliases }) => {
 };
 
 const urlChildMayMatch = ({ url, associations, predicate }) => {
+  if (url && typeof url.href === "string") url = url.href;
   assertUrlLike(url, "url");
   // the function was meants to be used on url ending with '/'
   if (!url.endsWith("/")) {

package/dist/jsenv_test.js

@@ -1,12 +1,12 @@
-import { chmod, stat, lstat, readdir, promises, unlink, openSync, closeSync, rmdir, readFile as readFile$1, writeFile as writeFile$1, writeFileSync as writeFileSync$1, mkdirSync, readFileSync, readdirSync, existsSync } from "node:fs";
+import os from "node:os";
+import { readdir, chmod, stat, lstat, promises, readFile as readFile$1, writeFile as writeFile$1, writeFileSync as writeFileSync$1, mkdirSync, unlink, openSync, closeSync, rmdir, readFileSync, readdirSync, existsSync } from "node:fs";
 import process$1, { memoryUsage } from "node:process";
 import v8, { takeCoverage } from "node:v8";
 import stripAnsi from "strip-ansi";
 import { URL_META, filterV8Coverage } from "./js/v8_coverage.js";
 import { pathToFileURL, fileURLToPath } from "node:url";
-import crypto from "node:crypto";
 import { dirname } from "node:path";
-import os from "node:os";
+import crypto from "node:crypto";
 import tty from "node:tty";
 import stringWidth from "string-width";
 import { readGitHubWorkflowEnv, startGithubCheckRun } from "@jsenv/github-check-run";
@@ -17,7 +17,7 @@ import { createServer } from "node:net";
 import wrapAnsi from "wrap-ansi";
 import { runInNewContext } from "node:vm";
 import { injectSupervisorIntoHTML, supervisorFileUrl } from "@jsenv/plugin-supervisor";
-import { SOURCEMAP, generateSourcemapDataUrl } from "@jsenv/sourcemap";
+import { generateSourcemapDataUrl, SOURCEMAP } from "@jsenv/sourcemap";
 import { findFreePort } from "@jsenv/server";
 import { Worker } from "node:worker_threads";
 
@@ -865,15 +865,158 @@ const assertAndNormalizeFileUrl = (
   return value;
 };
 
-const statsToType = (stats) => {
-  if (stats.isFile()) return "file";
-  if (stats.isDirectory()) return "directory";
-  if (stats.isSymbolicLink()) return "symbolic-link";
-  if (stats.isFIFO()) return "fifo";
-  if (stats.isSocket()) return "socket";
-  if (stats.isCharacterDevice()) return "character-device";
-  if (stats.isBlockDevice()) return "block-device";
-  return undefined;
+const comparePathnames = (leftPathame, rightPathname) => {
+  const leftPartArray = leftPathame.split("/");
+  const rightPartArray = rightPathname.split("/");
+
+  const leftLength = leftPartArray.length;
+  const rightLength = rightPartArray.length;
+
+  const maxLength = Math.max(leftLength, rightLength);
+  let i = 0;
+  while (i < maxLength) {
+    const leftPartExists = i in leftPartArray;
+    const rightPartExists = i in rightPartArray;
+
+    // longer comes first
+    if (!leftPartExists) {
+      return +1;
+    }
+    if (!rightPartExists) {
+      return -1;
+    }
+
+    const leftPartIsLast = i === leftPartArray.length - 1;
+    const rightPartIsLast = i === rightPartArray.length - 1;
+    // folder comes first
+    if (leftPartIsLast && !rightPartIsLast) {
+      return +1;
+    }
+    if (!leftPartIsLast && rightPartIsLast) {
+      return -1;
+    }
+
+    const leftPart = leftPartArray[i];
+    const rightPart = rightPartArray[i];
+    i++;
+    // local comparison comes first
+    const comparison = leftPart.localeCompare(rightPart);
+    if (comparison !== 0) {
+      return comparison;
+    }
+  }
+
+  if (leftLength < rightLength) {
+    return +1;
+  }
+  if (leftLength > rightLength) {
+    return -1;
+  }
+  return 0;
+};
+
+const isWindows$2 = process.platform === "win32";
+const baseUrlFallback = fileSystemPathToUrl(process.cwd());
+
+/**
+ * Some url might be resolved or remapped to url without the windows drive letter.
+ * For instance
+ * new URL('/foo.js', 'file:///C:/dir/file.js')
+ * resolves to
+ * 'file:///foo.js'
+ *
+ * But on windows it becomes a problem because we need the drive letter otherwise
+ * url cannot be converted to a filesystem path.
+ *
+ * ensureWindowsDriveLetter ensure a resolved url still contains the drive letter.
+ */
+
+const ensureWindowsDriveLetter = (url, baseUrl) => {
+  try {
+    url = String(new URL(url));
+  } catch (e) {
+    throw new Error(`absolute url expected but got ${url}`);
+  }
+
+  if (!isWindows$2) {
+    return url;
+  }
+
+  try {
+    baseUrl = String(new URL(baseUrl));
+  } catch (e) {
+    throw new Error(
+      `absolute baseUrl expected but got ${baseUrl} to ensure windows drive letter on ${url}`,
+    );
+  }
+
+  if (!url.startsWith("file://")) {
+    return url;
+  }
+  const afterProtocol = url.slice("file://".length);
+  // we still have the windows drive letter
+  if (extractDriveLetter(afterProtocol)) {
+    return url;
+  }
+
+  // drive letter was lost, restore it
+  const baseUrlOrFallback = baseUrl.startsWith("file://")
+    ? baseUrl
+    : baseUrlFallback;
+  const driveLetter = extractDriveLetter(
+    baseUrlOrFallback.slice("file://".length),
+  );
+  if (!driveLetter) {
+    throw new Error(
+      `drive letter expected on baseUrl but got ${baseUrl} to ensure windows drive letter on ${url}`,
+    );
+  }
+  return `file:///${driveLetter}:${afterProtocol}`;
+};
+
+const extractDriveLetter = (resource) => {
+  // we still have the windows drive letter
+  if (/[a-zA-Z]/.test(resource[1]) && resource[2] === ":") {
+    return resource[1];
+  }
+  return null;
+};
+
+const readDirectory = async (url, { emfileMaxWait = 1000 } = {}) => {
+  const directoryUrl = assertAndNormalizeDirectoryUrl(url);
+  const directoryUrlObject = new URL(directoryUrl);
+  const startMs = Date.now();
+  let attemptCount = 0;
+
+  const attempt = async () => {
+    try {
+      const names = await new Promise((resolve, reject) => {
+        readdir(directoryUrlObject, (error, names) => {
+          if (error) {
+            reject(error);
+          } else {
+            resolve(names);
+          }
+        });
+      });
+      return names.map(encodeURIComponent);
+    } catch (e) {
+      // https://nodejs.org/dist/latest-v13.x/docs/api/errors.html#errors_common_system_errors
+      if (e.code === "EMFILE" || e.code === "ENFILE") {
+        attemptCount++;
+        const nowMs = Date.now();
+        const timeSpentWaiting = nowMs - startMs;
+        if (timeSpentWaiting > emfileMaxWait) {
+          throw e;
+        }
+        await new Promise((resolve) => setTimeout(resolve), attemptCount);
+        return await attempt();
+      }
+      throw e;
+    }
+  };
+
+  return attempt();
 };
 
 // https://github.com/coderaiser/cloudcmd/issues/63#issuecomment-195478143
@@ -996,7 +1139,7 @@ const getPermissionOrComputeDefault = (action, subject, permissions) => {
  */
 
 
-const isWindows$2 = process.platform === "win32";
+const isWindows$1 = process.platform === "win32";
 
 const readEntryStat = async (
   source,
@@ -1016,7 +1159,7 @@ const readEntryStat = async (
   return readStat(sourcePath, {
     followLink,
     ...handleNotFoundOption,
-    ...(isWindows$2
+    ...(isWindows$1
       ? {
           // Windows can EPERM on stat
           handlePermissionDeniedError: async (error) => {
@@ -1081,93 +1224,6 @@ const readStat = (
   });
 };
 
-const readDirectory = async (url, { emfileMaxWait = 1000 } = {}) => {
-  const directoryUrl = assertAndNormalizeDirectoryUrl(url);
-  const directoryUrlObject = new URL(directoryUrl);
-  const startMs = Date.now();
-  let attemptCount = 0;
-
-  const attempt = async () => {
-    try {
-      const names = await new Promise((resolve, reject) => {
-        readdir(directoryUrlObject, (error, names) => {
-          if (error) {
-            reject(error);
-          } else {
-            resolve(names);
-          }
-        });
-      });
-      return names.map(encodeURIComponent);
-    } catch (e) {
-      // https://nodejs.org/dist/latest-v13.x/docs/api/errors.html#errors_common_system_errors
-      if (e.code === "EMFILE" || e.code === "ENFILE") {
-        attemptCount++;
-        const nowMs = Date.now();
-        const timeSpentWaiting = nowMs - startMs;
-        if (timeSpentWaiting > emfileMaxWait) {
-          throw e;
-        }
-        await new Promise((resolve) => setTimeout(resolve), attemptCount);
-        return await attempt();
-      }
-      throw e;
-    }
-  };
-
-  return attempt();
-};
-
-const comparePathnames = (leftPathame, rightPathname) => {
-  const leftPartArray = leftPathame.split("/");
-  const rightPartArray = rightPathname.split("/");
-
-  const leftLength = leftPartArray.length;
-  const rightLength = rightPartArray.length;
-
-  const maxLength = Math.max(leftLength, rightLength);
-  let i = 0;
-  while (i < maxLength) {
-    const leftPartExists = i in leftPartArray;
-    const rightPartExists = i in rightPartArray;
-
-    // longer comes first
-    if (!leftPartExists) {
-      return +1;
-    }
-    if (!rightPartExists) {
-      return -1;
-    }
-
-    const leftPartIsLast = i === leftPartArray.length - 1;
-    const rightPartIsLast = i === rightPartArray.length - 1;
-    // folder comes first
-    if (leftPartIsLast && !rightPartIsLast) {
-      return +1;
-    }
-    if (!leftPartIsLast && rightPartIsLast) {
-      return -1;
-    }
-
-    const leftPart = leftPartArray[i];
-    const rightPart = rightPartArray[i];
-    i++;
-    // local comparison comes first
-    const comparison = leftPart.localeCompare(rightPart);
-    if (comparison !== 0) {
-      return comparison;
-    }
-  }
-
-  if (leftLength < rightLength) {
-    return +1;
-  }
-  if (leftLength > rightLength) {
-    return -1;
-  }
-  return 0;
-};
-
 const collectFiles = async ({
   signal = new AbortController().signal,
   directoryUrl,
@@ -1259,39 +1315,130 @@ const collectFiles = async ({
   }
 };
 
-// https://nodejs.org/dist/latest-v13.x/docs/api/fs.html#fs_fspromises_mkdir_path_options
-const { mkdir } = promises;
-
-const writeDirectory = async (
-  destination,
-  { recursive = true, allowUseless = false } = {},
-) => {
-  const destinationUrl = assertAndNormalizeDirectoryUrl(destination);
-  const destinationPath = urlToFileSystemPath(destinationUrl);
-
-  const destinationStats = await readEntryStat(destinationUrl, {
-    nullIfNotFound: true,
-    followLink: false,
-  });
-
-  if (destinationStats) {
-    if (destinationStats.isDirectory()) {
-      if (allowUseless) {
-        return;
-      }
-      throw new Error(`directory already exists at ${destinationPath}`);
+const statsToType = (stats) => {
+  if (stats.isFile()) return "file";
+  if (stats.isDirectory()) return "directory";
+  if (stats.isSymbolicLink()) return "symbolic-link";
+  if (stats.isFIFO()) return "fifo";
+  if (stats.isSocket()) return "socket";
+  if (stats.isCharacterDevice()) return "character-device";
+  if (stats.isBlockDevice()) return "block-device";
+  return undefined;
+};
+
+// https://nodejs.org/dist/latest-v13.x/docs/api/fs.html#fs_fspromises_mkdir_path_options
+const { mkdir } = promises;
+
+const writeDirectory = async (
+  destination,
+  { recursive = true, allowUseless = false } = {},
+) => {
+  const destinationUrl = assertAndNormalizeDirectoryUrl(destination);
+  const destinationPath = urlToFileSystemPath(destinationUrl);
+
+  const destinationStats = await readEntryStat(destinationUrl, {
+    nullIfNotFound: true,
+    followLink: false,
+  });
+
+  if (destinationStats) {
+    if (destinationStats.isDirectory()) {
+      if (allowUseless) {
+        return;
+      }
+      throw new Error(`directory already exists at ${destinationPath}`);
+    }
+
+    const destinationType = statsToType(destinationStats);
+    throw new Error(
+      `cannot write directory at ${destinationPath} because there is a ${destinationType}`,
+    );
+  }
+
+  try {
+    await mkdir(destinationPath, { recursive });
+  } catch (error) {
+    if (allowUseless && error.code === "EEXIST") {
+      return;
+    }
+    throw error;
+  }
+};
+
+const ensureParentDirectories = async (destination) => {
+  const destinationUrl = assertAndNormalizeFileUrl(destination);
+  const destinationPath = urlToFileSystemPath(destinationUrl);
+  const destinationParentPath = dirname(destinationPath);
+
+  await writeDirectory(destinationParentPath, {
+    recursive: true,
+    allowUseless: true,
+  });
+};
+
+const readFile = async (value, { as = "buffer" } = {}) => {
+  const fileUrl = assertAndNormalizeFileUrl(value);
+  const buffer = await new Promise((resolve, reject) => {
+    readFile$1(new URL(fileUrl), (error, buffer) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve(buffer);
+      }
+    });
+  });
+  if (as === "buffer") {
+    return buffer;
+  }
+  if (as === "string") {
+    return buffer.toString();
+  }
+  if (as === "json") {
+    return JSON.parse(buffer.toString());
+  }
+  throw new Error(
+    `"as" must be one of "buffer","string","json" received "${as}"`,
+  );
+};
+
+const writeFile = async (destination, content = "") => {
+  const destinationUrl = assertAndNormalizeFileUrl(destination);
+  const destinationUrlObject = new URL(destinationUrl);
+  try {
+    await writeFileNaive(destinationUrlObject, content);
+  } catch (error) {
+    if (error.code === "ENOENT") {
+      await ensureParentDirectories(destinationUrl);
+      await writeFileNaive(destinationUrlObject, content);
+      return;
     }
-
-    const destinationType = statsToType(destinationStats);
-    throw new Error(
-      `cannot write directory at ${destinationPath} because there is a ${destinationType}`,
-    );
+    throw error;
   }
+};
+
+const writeFileNaive = (urlObject, content) => {
+  return new Promise((resolve, reject) => {
+    writeFile$1(urlObject, content, (error) => {
+      if (error) {
+        reject(error);
+      } else {
+        resolve();
+      }
+    });
+  });
+};
 
+const writeFileSync = (destination, content = "") => {
+  const destinationUrl = assertAndNormalizeFileUrl(destination);
+  const destinationUrlObject = new URL(destinationUrl);
   try {
-    await mkdir(destinationPath, { recursive });
+    writeFileSync$1(destinationUrlObject, content);
   } catch (error) {
-    if (allowUseless && error.code === "EEXIST") {
+    if (error.code === "ENOENT") {
+      mkdirSync(new URL("./", destinationUrlObject), {
+        recursive: true,
+      });
+      writeFileSync$1(destinationUrlObject, content);
       return;
     }
     throw error;
@@ -1543,6 +1690,18 @@ const removeDirectoryNaive = (
   });
 };
 
+process.platform === "win32";
+
+/*
+ * - stats object documentation on Node.js
+ *   https://nodejs.org/docs/latest-v13.x/api/fs.html#fs_class_fs_stats
+ */
+
+
+process.platform === "win32";
+
+process.platform === "win32";
+
 const ensureEmptyDirectory = async (source) => {
   const stats = await readEntryStat(source, {
     nullIfNotFound: true,
@@ -1550,15 +1709,17 @@ const ensureEmptyDirectory = async (source) => {
   });
   if (stats === null) {
     // if there is nothing, create a directory
-    return writeDirectory(source, { allowUseless: true });
+    await writeDirectory(source, { allowUseless: true });
+    return;
   }
   if (stats.isDirectory()) {
     // if there is a directory remove its content and done
-    return removeEntry(source, {
+    await removeEntry(source, {
       allowUseless: true,
       recursive: true,
       onlyContent: true,
     });
+    return;
   }
 
   const sourceType = statsToType(stats);
@@ -1568,159 +1729,10 @@ const ensureEmptyDirectory = async (source) => {
   );
 };
 
-const ensureParentDirectories = async (destination) => {
-  const destinationUrl = assertAndNormalizeFileUrl(destination);
-  const destinationPath = urlToFileSystemPath(destinationUrl);
-  const destinationParentPath = dirname(destinationPath);
-
-  return writeDirectory(destinationParentPath, {
-    recursive: true,
-    allowUseless: true,
-  });
-};
-
-const isWindows$1 = process.platform === "win32";
-const baseUrlFallback = fileSystemPathToUrl(process.cwd());
-
-/**
- * Some url might be resolved or remapped to url without the windows drive letter.
- * For instance
- * new URL('/foo.js', 'file:///C:/dir/file.js')
- * resolves to
- * 'file:///foo.js'
- *
- * But on windows it becomes a problem because we need the drive letter otherwise
- * url cannot be converted to a filesystem path.
- *
- * ensureWindowsDriveLetter ensure a resolved url still contains the drive letter.
- */
-
-const ensureWindowsDriveLetter = (url, baseUrl) => {
-  try {
-    url = String(new URL(url));
-  } catch (e) {
-    throw new Error(`absolute url expected but got ${url}`);
-  }
-
-  if (!isWindows$1) {
-    return url;
-  }
-
-  try {
-    baseUrl = String(new URL(baseUrl));
-  } catch (e) {
-    throw new Error(
-      `absolute baseUrl expected but got ${baseUrl} to ensure windows drive letter on ${url}`,
-    );
-  }
-
-  if (!url.startsWith("file://")) {
-    return url;
-  }
-  const afterProtocol = url.slice("file://".length);
-  // we still have the windows drive letter
-  if (extractDriveLetter(afterProtocol)) {
-    return url;
-  }
-
-  // drive letter was lost, restore it
-  const baseUrlOrFallback = baseUrl.startsWith("file://")
-    ? baseUrl
-    : baseUrlFallback;
-  const driveLetter = extractDriveLetter(
-    baseUrlOrFallback.slice("file://".length),
-  );
-  if (!driveLetter) {
-    throw new Error(
-      `drive letter expected on baseUrl but got ${baseUrl} to ensure windows drive letter on ${url}`,
-    );
-  }
-  return `file:///${driveLetter}:${afterProtocol}`;
-};
-
-const extractDriveLetter = (resource) => {
-  // we still have the windows drive letter
-  if (/[a-zA-Z]/.test(resource[1]) && resource[2] === ":") {
-    return resource[1];
-  }
-  return null;
-};
-
-process.platform === "win32";
-
-const readFile = async (value, { as = "buffer" } = {}) => {
-  const fileUrl = assertAndNormalizeFileUrl(value);
-  const buffer = await new Promise((resolve, reject) => {
-    readFile$1(new URL(fileUrl), (error, buffer) => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve(buffer);
-      }
-    });
-  });
-  if (as === "buffer") {
-    return buffer;
-  }
-  if (as === "string") {
-    return buffer.toString();
-  }
-  if (as === "json") {
-    return JSON.parse(buffer.toString());
-  }
-  throw new Error(
-    `"as" must be one of "buffer","string","json" received "${as}"`,
-  );
-};
-
 process.platform === "win32";
 
 process.platform === "linux";
 
-const writeFile = async (destination, content = "") => {
-  const destinationUrl = assertAndNormalizeFileUrl(destination);
-  const destinationUrlObject = new URL(destinationUrl);
-  try {
-    await writeFileNaive(destinationUrlObject, content);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      await ensureParentDirectories(destinationUrl);
-      await writeFileNaive(destinationUrlObject, content);
-      return;
-    }
-    throw error;
-  }
-};
-
-const writeFileNaive = (urlObject, content) => {
-  return new Promise((resolve, reject) => {
-    writeFile$1(urlObject, content, (error) => {
-      if (error) {
-        reject(error);
-      } else {
-        resolve();
-      }
-    });
-  });
-};
-
-const writeFileSync = (destination, content = "") => {
-  const destinationUrl = assertAndNormalizeFileUrl(destination);
-  const destinationUrlObject = new URL(destinationUrl);
-  try {
-    writeFileSync$1(destinationUrlObject, content);
-  } catch (error) {
-    if (error.code === "ENOENT") {
-      mkdirSync(new URL("./", destinationUrlObject), {
-        recursive: true,
-      });
-      writeFileSync$1(destinationUrlObject, content);
-      return;
-    }
-    throw error;
-  }
-};
-
 const LOG_LEVEL_OFF = "off";
 
 const LOG_LEVEL_DEBUG = "debug";
@@ -4636,7 +4648,7 @@ const ensureGlobalGc = () => {
  * @param {Object} testPlanParameters.testPlan Object associating files with runtimes where they will be executed
  * @param {boolean} [testPlanParameters.logShortForCompletedExecutions=false] Abbreviate completed execution information to shorten terminal output
  * @param {boolean} [testPlanParameters.logMergeForCompletedExecutions=false] Merge completed execution logs to shorten terminal output
- * @param {number} [testPlanParameters.maxExecutionsInParallel=1] Maximum amount of execution in parallel
+ * @param {boolean|number} [testPlanParameters.concurrency=false] Maximum amount of execution running at the same time
  * @param {number} [testPlanParameters.defaultMsAllocatedPerExecution=30000] Milliseconds after which execution is aborted and considered as failed by timeout
  * @param {boolean} [testPlanParameters.failFast=false] Fails immediatly when a test execution fails
  * @param {number} [testPlanParameters.cooldownBetweenExecutions=0] Millisecond to wait between each execution
@@ -4663,7 +4675,7 @@ const executeTestPlan = async ({
   webServer,
   testPlan,
   updateProcessExitCode = true,
-  maxExecutionsInParallel = 1,
+  concurrency = false,
   defaultMsAllocatedPerExecution = 30_000,
   failFast = false,
   // keepRunning: false to ensure runtime is stopped once executed
@@ -4930,6 +4942,10 @@ To fix this warning:
         }
       }
     }
+
+    if (typeof concurrency !== "boolean" && typeof concurrency !== "number") {
+      throw new TypeError(`concurrency must be a boolean or a number`);
+    }
   }
 
   logger.debug(
@@ -4968,6 +4984,25 @@ To fix this warning:
         }
       }
     }
+    if (cooldownBetweenExecutions) {
+      if (cooldownBetweenExecutions < 0) {
+        cooldownBetweenExecutions = 0;
+      }
+      if (cooldownBetweenExecutions === Infinity) {
+        cooldownBetweenExecutions = 0;
+      }
+    }
+    if (concurrency === true) {
+      const availableCpus = os.cpus().length;
+      concurrency =
+        availableCpus > 2
+          ? // One CPU is used to run this code so we do availableCpus - 1
+            availableCpus - 1
+          : 1;
+    }
+    if (concurrency === false) {
+      concurrency = 1;
+    }
   }
 
   testPlan = {
@@ -5107,7 +5142,7 @@ To fix this warning:
     const executionLogsEnabled = logger.levels.info;
     const executionSpinner =
       logRefresh &&
-      maxExecutionsInParallel === 1 &&
+      concurrency === 1 &&
       !debugLogsEnabled &&
       executionLogsEnabled &&
       process.stdout.isTTY &&
@@ -5130,9 +5165,9 @@ To fix this warning:
 
     const callWhenPreviousExecutionAreDone = createCallOrderer();
 
-    await executeInParallel({
+    await executeConcurrently({
       multipleExecutionsOperation,
-      maxExecutionsInParallel,
+      concurrency,
       cooldownBetweenExecutions,
       executionSteps,
       start: async (paramsFromStep) => {
@@ -5405,57 +5440,50 @@ const canOverwriteLogGetter = ({
   return true;
 };
 
-const executeInParallel = async ({
+const executeConcurrently = async ({
   multipleExecutionsOperation,
-  maxExecutionsInParallel,
+  concurrency,
   cooldownBetweenExecutions,
   executionSteps,
   start,
 }) => {
-  const executionResults = [];
   let progressionIndex = 0;
-  let remainingExecutionCount = executionSteps.length;
+  let remainingExecutionToStart = executionSteps.length;
 
-  const nextChunk = async () => {
-    if (multipleExecutionsOperation.signal.aborted) {
+  const startNext = async () => {
+    if (remainingExecutionToStart === 0) {
       return;
     }
-    const outputPromiseArray = [];
-    let previousExecPromise = Promise.resolve();
-    while (
-      remainingExecutionCount > 0 &&
-      outputPromiseArray.length < maxExecutionsInParallel
-    ) {
-      remainingExecutionCount--;
-      const outputPromise = executeOne(progressionIndex, previousExecPromise);
-      previousExecPromise = outputPromise;
-      progressionIndex++;
-      outputPromiseArray.push(outputPromise);
-    }
-    if (outputPromiseArray.length) {
-      await Promise.all(outputPromiseArray);
-      if (remainingExecutionCount > 0) {
-        await nextChunk();
-      }
-    }
-  };
-
-  const executeOne = async (index, previousExecPromise) => {
-    const input = executionSteps[index];
-    const output = await start(input, previousExecPromise);
-    if (!multipleExecutionsOperation.signal.aborted) {
-      executionResults[index] = output;
+    remainingExecutionToStart--;
+    const input = executionSteps[progressionIndex];
+    progressionIndex++;
+    await start(input);
+    if (multipleExecutionsOperation.signal.aborted) {
+      return;
     }
     if (cooldownBetweenExecutions) {
-      await new Promise((resolve) =>
-        setTimeout(resolve, cooldownBetweenExecutions),
-      );
+      await new Promise((resolve) => {
+        const timeoutId = setTimeout(() => {
+          removeClearTimeoutOnAbort();
+          resolve();
+        }, cooldownBetweenExecutions);
+        const removeClearTimeoutOnAbort =
+          multipleExecutionsOperation.signal.addAbortCallback(() => {
+            clearTimeout(timeoutId);
+          });
+      });
+      if (multipleExecutionsOperation.signal.aborted) {
+        return;
+      }
     }
+    await startNext();
   };
 
-  await nextChunk();
-
-  return executionResults;
+  const promises = [];
+  while (concurrency--) {
+    promises.push(startNext());
+  }
+  await Promise.all(promises);
 };
 
 const memoize = (compute) => {
@@ -6864,9 +6892,12 @@ const nodeChildProcess = ({
             );
             return;
           }
+          if (code === null || code === 0) {
+            result.status = "completed";
+            result.namespace = {};
+            return;
+          }
           if (
-            code === null ||
-            code === 0 ||
             code === EXIT_CODES.SIGINT ||
             code === EXIT_CODES.SIGTERM ||
             code === EXIT_CODES.SIGABORT
@@ -7170,9 +7201,12 @@ const nodeWorkerThread = ({
             );
             return;
           }
+          if (code === null || code === 0) {
+            result.status = "completed";
+            result.namespace = {};
+            return;
+          }
           if (
-            code === null ||
-            code === 0 ||
             code === EXIT_CODES.SIGINT ||
             code === EXIT_CODES.SIGTERM ||
             code === EXIT_CODES.SIGABORT

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/test",
-  "version": "1.8.1",
+  "version": "2.1.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -35,13 +35,13 @@
   "dependencies": {
     "@jsenv/abort": "4.2.4",
     "@jsenv/ast": "6.0.1",
-    "@jsenv/filesystem": "4.3.2",
+    "@jsenv/filesystem": "4.4.0",
     "@jsenv/log": "3.4.3",
     "@jsenv/plugin-supervisor": "1.3.9",
     "@jsenv/urls": "2.2.1",
-    "@jsenv/url-meta": "8.1.0",
+    "@jsenv/url-meta": "8.2.0",
     "@jsenv/utils": "2.0.1",
-    "@jsenv/github-check-run": "0.1.4",
+    "@jsenv/github-check-run": "0.1.5",
     "v8-to-istanbul": "9.1.3",
     "istanbul-lib-coverage": "3.2.2",
     "istanbul-lib-instrument": "6.0.1",

package/src/execution/execute_test_plan.js

@@ -1,3 +1,4 @@
+import os from "node:os";
 import { existsSync } from "node:fs";
 import { memoryUsage } from "node:process";
 import { takeCoverage } from "node:v8";
@@ -48,7 +49,7 @@ import { ensureGlobalGc } from "./gc.js";
  * @param {Object} testPlanParameters.testPlan Object associating files with runtimes where they will be executed
  * @param {boolean} [testPlanParameters.logShortForCompletedExecutions=false] Abbreviate completed execution information to shorten terminal output
  * @param {boolean} [testPlanParameters.logMergeForCompletedExecutions=false] Merge completed execution logs to shorten terminal output
- * @param {number} [testPlanParameters.maxExecutionsInParallel=1] Maximum amount of execution in parallel
+ * @param {boolean|number} [testPlanParameters.concurrency=false] Maximum amount of execution running at the same time
  * @param {number} [testPlanParameters.defaultMsAllocatedPerExecution=30000] Milliseconds after which execution is aborted and considered as failed by timeout
  * @param {boolean} [testPlanParameters.failFast=false] Fails immediatly when a test execution fails
  * @param {number} [testPlanParameters.cooldownBetweenExecutions=0] Millisecond to wait between each execution
@@ -75,7 +76,7 @@ export const executeTestPlan = async ({
   webServer,
   testPlan,
   updateProcessExitCode = true,
-  maxExecutionsInParallel = 1,
+  concurrency = false,
   defaultMsAllocatedPerExecution = 30_000,
   failFast = false,
   // keepRunning: false to ensure runtime is stopped once executed
@@ -342,6 +343,10 @@ To fix this warning:
         }
       }
     }
+
+    if (typeof concurrency !== "boolean" && typeof concurrency !== "number") {
+      throw new TypeError(`concurrency must be a boolean or a number`);
+    }
   }
 
   logger.debug(
@@ -380,6 +385,25 @@ To fix this warning:
         }
       }
     }
+    if (cooldownBetweenExecutions) {
+      if (cooldownBetweenExecutions < 0) {
+        cooldownBetweenExecutions = 0;
+      }
+      if (cooldownBetweenExecutions === Infinity) {
+        cooldownBetweenExecutions = 0;
+      }
+    }
+    if (concurrency === true) {
+      const availableCpus = os.cpus().length;
+      concurrency =
+        availableCpus > 2
+          ? // One CPU is used to run this code so we do availableCpus - 1
+            availableCpus - 1
+          : 1;
+    }
+    if (concurrency === false) {
+      concurrency = 1;
+    }
   }
 
   testPlan = {
@@ -519,7 +543,7 @@ To fix this warning:
     const executionLogsEnabled = logger.levels.info;
     const executionSpinner =
       logRefresh &&
-      maxExecutionsInParallel === 1 &&
+      concurrency === 1 &&
       !debugLogsEnabled &&
       executionLogsEnabled &&
       process.stdout.isTTY &&
@@ -542,9 +566,9 @@ To fix this warning:
 
     const callWhenPreviousExecutionAreDone = createCallOrderer();
 
-    await executeInParallel({
+    await executeConcurrently({
       multipleExecutionsOperation,
-      maxExecutionsInParallel,
+      concurrency,
       cooldownBetweenExecutions,
       executionSteps,
       start: async (paramsFromStep) => {
@@ -817,55 +841,48 @@ const canOverwriteLogGetter = ({
   return true;
 };
 
-const executeInParallel = async ({
+const executeConcurrently = async ({
   multipleExecutionsOperation,
-  maxExecutionsInParallel,
+  concurrency,
   cooldownBetweenExecutions,
   executionSteps,
   start,
 }) => {
-  const executionResults = [];
   let progressionIndex = 0;
-  let remainingExecutionCount = executionSteps.length;
+  let remainingExecutionToStart = executionSteps.length;
 
-  const nextChunk = async () => {
-    if (multipleExecutionsOperation.signal.aborted) {
+  const startNext = async () => {
+    if (remainingExecutionToStart === 0) {
       return;
     }
-    const outputPromiseArray = [];
-    let previousExecPromise = Promise.resolve();
-    while (
-      remainingExecutionCount > 0 &&
-      outputPromiseArray.length < maxExecutionsInParallel
-    ) {
-      remainingExecutionCount--;
-      const outputPromise = executeOne(progressionIndex, previousExecPromise);
-      previousExecPromise = outputPromise;
-      progressionIndex++;
-      outputPromiseArray.push(outputPromise);
-    }
-    if (outputPromiseArray.length) {
-      await Promise.all(outputPromiseArray);
-      if (remainingExecutionCount > 0) {
-        await nextChunk();
-      }
-    }
-  };
-
-  const executeOne = async (index, previousExecPromise) => {
-    const input = executionSteps[index];
-    const output = await start(input, previousExecPromise);
-    if (!multipleExecutionsOperation.signal.aborted) {
-      executionResults[index] = output;
+    remainingExecutionToStart--;
+    const input = executionSteps[progressionIndex];
+    progressionIndex++;
+    await start(input);
+    if (multipleExecutionsOperation.signal.aborted) {
+      return;
     }
     if (cooldownBetweenExecutions) {
-      await new Promise((resolve) =>
-        setTimeout(resolve, cooldownBetweenExecutions),
-      );
+      await new Promise((resolve) => {
+        const timeoutId = setTimeout(() => {
+          removeClearTimeoutOnAbort();
+          resolve();
+        }, cooldownBetweenExecutions);
+        const removeClearTimeoutOnAbort =
+          multipleExecutionsOperation.signal.addAbortCallback(() => {
+            clearTimeout(timeoutId);
+          });
+      });
+      if (multipleExecutionsOperation.signal.aborted) {
+        return;
+      }
     }
+    await startNext();
   };
 
-  await nextChunk();
-
-  return executionResults;
+  const promises = [];
+  while (concurrency--) {
+    promises.push(startNext());
+  }
+  await Promise.all(promises);
 };

package/src/runtime_node/node_child_process.js

@@ -256,9 +256,12 @@ export const nodeChildProcess = ({
             );
             return;
           }
+          if (code === null || code === 0) {
+            result.status = "completed";
+            result.namespace = {};
+            return;
+          }
           if (
-            code === null ||
-            code === 0 ||
             code === EXIT_CODES.SIGINT ||
             code === EXIT_CODES.SIGTERM ||
             code === EXIT_CODES.SIGABORT

package/src/runtime_node/node_worker_thread.js

@@ -202,9 +202,12 @@ export const nodeWorkerThread = ({
             );
             return;
           }
+          if (code === null || code === 0) {
+            result.status = "completed";
+            result.namespace = {};
+            return;
+          }
           if (
-            code === null ||
-            code === 0 ||
             code === EXIT_CODES.SIGINT ||
             code === EXIT_CODES.SIGTERM ||
             code === EXIT_CODES.SIGABORT