@jsenv/test 1.8.0 → 2.0.0

package/dist/jsenv_test.js

@@ -1,3 +1,4 @@
+import os from "node:os";
 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 process$1, { memoryUsage } from "node:process";
 import v8, { takeCoverage } from "node:v8";
@@ -6,7 +7,6 @@ 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 tty from "node:tty";
 import stringWidth from "string-width";
 import { readGitHubWorkflowEnv, startGithubCheckRun } from "@jsenv/github-check-run";
@@ -2515,6 +2515,7 @@ const createLog = ({
   const { columns = 80, rows = 24 } = stream;
 
   const log = {
+    destroyed: false,
     onVerticalOverflow: () => {},
   };
 
@@ -2579,6 +2580,9 @@ const createLog = ({
   };
 
   const write = (string, outputFromOutside = streamOutputSpy()) => {
+    if (log.destroyed) {
+      throw new Error("Cannot write log after destroy");
+    }
     if (!lastOutput) {
       doWrite(string);
       return;
@@ -2599,6 +2603,7 @@ const createLog = ({
   };
 
   const destroy = () => {
+    log.destroyed = true;
     if (streamOutputSpy) {
       streamOutputSpy(); // this uninstalls the spy
       streamOutputSpy = null;
@@ -2724,6 +2729,46 @@ const createTeardown = () => {
   };
 };
 
+const createCallOrderer = () => {
+  const queue = [];
+  const callWhenPreviousExecutionAreDone = (executionIndex, callback) => {
+    if (queue[executionIndex]) {
+      throw new Error(`${executionIndex} already used`);
+    }
+
+    let allBeforeAreDone = true;
+    if (executionIndex > 0) {
+      let beforeIndex = executionIndex - 1;
+      do {
+        const value = queue[beforeIndex];
+        if (!value) {
+          allBeforeAreDone = false;
+          break;
+        }
+      } while (beforeIndex--);
+    }
+    if (!allBeforeAreDone) {
+      queue[executionIndex] = callback;
+      return;
+    }
+    queue[executionIndex] = true;
+    callback();
+    let afterIndex = executionIndex + 1;
+    while (afterIndex < queue.length) {
+      const value = queue[afterIndex];
+      if (value === undefined) {
+        break;
+      }
+      if (typeof value === "function") {
+        queue[afterIndex] = true;
+        value();
+      }
+      afterIndex++;
+    }
+  };
+  return callWhenPreviousExecutionAreDone;
+};
+
 const readNodeV8CoverageDirectory = async ({
   logger,
   signal,
@@ -4591,7 +4636,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
@@ -4618,7 +4663,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
@@ -4686,6 +4731,13 @@ const executeTestPlan = async ({
 }) => {
   const teardown = createTeardown();
 
+  const beforeExecutionCallbackSet = new Set();
+  const afterExecutionCallbackSet = new Set();
+  const afterAllExecutionCallbackSet = new Set();
+  beforeExecutionCallbackSet.add(beforeExecutionCallback);
+  afterExecutionCallbackSet.add(afterExecutionCallback);
+  afterAllExecutionCallbackSet.add(afterAllExecutionCallback);
+
   const operation = Abort.startOperation();
   operation.addAbortSignal(signal);
   if (handleSIGINT) {
@@ -4878,6 +4930,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(
@@ -4916,6 +4972,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 = {
@@ -4943,9 +5018,7 @@ To fix this warning:
       checkSummary: `${executionSteps.length} files will be executed`,
     });
     const annotations = [];
-    const afterExecutionCallbackPrevious = afterExecutionCallback;
-    afterExecutionCallback = (afterExecutionInfo) => {
-      afterExecutionCallbackPrevious(afterExecutionInfo);
+    afterExecutionCallbackSet.add((afterExecutionInfo) => {
       const { executionResult } = afterExecutionInfo;
       const { errors = [] } = executionResult;
       for (const error of errors) {
@@ -4955,10 +5028,8 @@ To fix this warning:
         });
         annotations.push(annotation);
       }
-    };
-    const afterAllExecutionCallbackPrevious = afterAllExecutionCallback;
-    afterAllExecutionCallback = async (returnValue) => {
-      afterAllExecutionCallbackPrevious(returnValue);
+    });
+    afterAllExecutionCallbackSet.add(async (returnValue) => {
       const { summary } = returnValue;
       const title = "Jsenv test results";
       const summaryText = stripAnsi(formatSummary(summary));
@@ -4975,7 +5046,7 @@ To fix this warning:
         summary: summaryText,
         annotations,
       });
-    };
+    });
   }
 
   executionSteps = executionSteps.filter(
@@ -5059,6 +5130,7 @@ To fix this warning:
     const executionLogsEnabled = logger.levels.info;
     const executionSpinner =
       logRefresh &&
+      concurrency === 1 &&
       !debugLogsEnabled &&
       executionLogsEnabled &&
       process.stdout.isTTY &&
@@ -5078,9 +5150,12 @@ To fix this warning:
       completed: 0,
       done: 0,
     };
-    await executeInParallel({
+
+    const callWhenPreviousExecutionAreDone = createCallOrderer();
+
+    await executeConcurrently({
       multipleExecutionsOperation,
-      maxExecutionsInParallel,
+      concurrency,
       cooldownBetweenExecutions,
       executionSteps,
       start: async (paramsFromStep) => {
@@ -5133,8 +5208,9 @@ To fix this warning:
             },
           });
         }
-        beforeExecutionCallback(beforeExecutionInfo);
-
+        for (const beforeExecutionCallback of beforeExecutionCallbackSet) {
+          beforeExecutionCallback(beforeExecutionInfo);
+        }
         const fileUrl = `${rootDirectoryUrl}${fileRelativeUrl}`;
         let executionResult;
         if (existsSync(new URL(fileUrl))) {
@@ -5143,7 +5219,7 @@ To fix this warning:
             logger,
             allocatedMs: executionParams.allocatedMs,
             keepRunning,
-            mirrorConsole: false, // file are executed in parallel, log would be a mess to read
+            mirrorConsole: false, // might be executed in parallel: log would be a mess to read
             collectConsole: executionParams.collectConsole,
             coverageEnabled,
             coverageTempDirectoryUrl,
@@ -5163,7 +5239,6 @@ To fix this warning:
             ],
           };
         }
-        counters.done++;
         const fileReport = report[fileRelativeUrl];
         if (fileReport) {
           fileReport[executionName] = executionResult;
@@ -5180,58 +5255,65 @@ To fix this warning:
           executionResult,
         };
 
-        if (executionResult.status === "aborted") {
-          counters.aborted++;
-        } else if (executionResult.status === "timedout") {
-          counters.timedout++;
-        } else if (executionResult.status === "failed") {
-          counters.failed++;
-        } else if (executionResult.status === "completed") {
-          counters.completed++;
-        }
         if (gcBetweenExecutions) {
           global.gc();
         }
-        if (executionLogsEnabled) {
-          const log = createExecutionLog(afterExecutionInfo, {
-            logShortForCompletedExecutions,
-            logRuntime,
-            logEachDuration,
-            ...(logTimeUsage
-              ? {
-                  timeEllapsed: Date.now() - startMs,
-                }
-              : {}),
-            ...(logMemoryHeapUsage
-              ? { memoryHeap: memoryUsage().heapUsed }
-              : {}),
-          });
-          // replace spinner with this execution result
-          if (spinner) spinner.stop();
-          executionLog.write(log);
-          rawOutput += stripAnsi(log);
-
-          const canOverwriteLog = canOverwriteLogGetter({
-            logMergeForCompletedExecutions,
-            executionResult,
-          });
-          if (canOverwriteLog) {
-            // nothing to do, we reuse the current executionLog object
-          } else {
-            executionLog.destroy();
-            executionLog = createLog({ newLine: "" });
+
+        const timeEllapsed = Date.now() - startMs;
+        const memoryHeap = memoryUsage().heapUsed;
+        callWhenPreviousExecutionAreDone(executionIndex, () => {
+          counters.done++;
+          if (executionResult.status === "aborted") {
+            counters.aborted++;
+          } else if (executionResult.status === "timedout") {
+            counters.timedout++;
+          } else if (executionResult.status === "failed") {
+            counters.failed++;
+          } else if (executionResult.status === "completed") {
+            counters.completed++;
+          }
+
+          if (executionLogsEnabled) {
+            // replace spinner with this execution result
+            if (spinner) {
+              spinner.stop();
+              spinner = null;
+            }
+
+            const log = createExecutionLog(afterExecutionInfo, {
+              logShortForCompletedExecutions,
+              logRuntime,
+              logEachDuration,
+              ...(logTimeUsage ? { timeEllapsed } : {}),
+              ...(logMemoryHeapUsage ? { memoryHeap } : {}),
+            });
+
+            executionLog.write(log);
+            rawOutput += stripAnsi(log);
+            const canOverwriteLog = canOverwriteLogGetter({
+              logMergeForCompletedExecutions,
+              executionResult,
+            });
+            if (canOverwriteLog) {
+              // nothing to do, we reuse the current executionLog object
+            } else {
+              executionLog.destroy();
+              executionLog = createLog({ newLine: "" });
+            }
+            const isLastExecutionLog =
+              executionIndex === executionSteps.length - 1;
+            if (isLastExecutionLog && logger.levels.info) {
+              executionLog.write("\n");
+            }
           }
+        });
+        for (const afterExecutionCallback of afterExecutionCallbackSet) {
+          afterExecutionCallback(afterExecutionInfo);
         }
-        afterExecutionCallback(afterExecutionInfo);
-        const isLastExecutionLog = executionIndex === executionSteps.length - 1;
         const cancelRemaining =
           failFast &&
           executionResult.status !== "completed" &&
           counters.done < counters.total;
-        if (isLastExecutionLog && logger.levels.info) {
-          executionLog.write("\n");
-        }
-
         if (cancelRemaining) {
           logger.info(`"failFast" enabled -> cancel remaining executions`);
           failFastAbortController.abort();
@@ -5320,7 +5402,9 @@ To fix this warning:
     await Promise.all(promises);
   }
 
-  await afterAllExecutionCallback(returnValue);
+  for (const afterAllExecutionCallback of afterAllExecutionCallbackSet) {
+    await afterAllExecutionCallback(returnValue);
+  }
   return returnValue;
 };
 
@@ -5344,55 +5428,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 = [];
-    while (
-      remainingExecutionCount > 0 &&
-      outputPromiseArray.length < maxExecutionsInParallel
-    ) {
-      remainingExecutionCount--;
-      const outputPromise = executeOne(progressionIndex);
-      progressionIndex++;
-      outputPromiseArray.push(outputPromise);
-    }
-    if (outputPromiseArray.length) {
-      await Promise.all(outputPromiseArray);
-      if (remainingExecutionCount > 0) {
-        await nextChunk();
-      }
-    }
-  };
-
-  const executeOne = async (index) => {
-    const input = executionSteps[index];
-    const output = await start(input);
-    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) => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/test",
-  "version": "1.8.0",
+  "version": "2.0.0",
   "license": "MIT",
   "repository": {
     "type": "git",
@@ -36,12 +36,12 @@
     "@jsenv/abort": "4.2.4",
     "@jsenv/ast": "6.0.1",
     "@jsenv/filesystem": "4.3.2",
-    "@jsenv/log": "3.4.2",
+    "@jsenv/log": "3.4.3",
     "@jsenv/plugin-supervisor": "1.3.9",
     "@jsenv/urls": "2.2.1",
     "@jsenv/url-meta": "8.1.0",
     "@jsenv/utils": "2.0.1",
-    "@jsenv/github-check-run": "0.1.3",
+    "@jsenv/github-check-run": "0.1.4",
     "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";
@@ -24,6 +25,7 @@ import {
 } from "@jsenv/github-check-run";
 
 import { createTeardown } from "../helpers/teardown.js";
+import { createCallOrderer } from "../helpers/call_orderer.js";
 import { reportToCoverage } from "../coverage/report_to_coverage.js";
 import { generateCoverageJsonFile } from "../coverage/coverage_reporter_json_file.js";
 import { generateCoverageHtmlDirectory } from "../coverage/coverage_reporter_html_directory.js";
@@ -47,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
@@ -74,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
@@ -142,6 +144,13 @@ export const executeTestPlan = async ({
 }) => {
   const teardown = createTeardown();
 
+  const beforeExecutionCallbackSet = new Set();
+  const afterExecutionCallbackSet = new Set();
+  const afterAllExecutionCallbackSet = new Set();
+  beforeExecutionCallbackSet.add(beforeExecutionCallback);
+  afterExecutionCallbackSet.add(afterExecutionCallback);
+  afterAllExecutionCallbackSet.add(afterAllExecutionCallback);
+
   const operation = Abort.startOperation();
   operation.addAbortSignal(signal);
   if (handleSIGINT) {
@@ -334,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(
@@ -372,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 = {
@@ -399,9 +431,7 @@ To fix this warning:
       checkSummary: `${executionSteps.length} files will be executed`,
     });
     const annotations = [];
-    const afterExecutionCallbackPrevious = afterExecutionCallback;
-    afterExecutionCallback = (afterExecutionInfo) => {
-      afterExecutionCallbackPrevious(afterExecutionInfo);
+    afterExecutionCallbackSet.add((afterExecutionInfo) => {
       const { executionResult } = afterExecutionInfo;
       const { errors = [] } = executionResult;
       for (const error of errors) {
@@ -411,10 +441,8 @@ To fix this warning:
         });
         annotations.push(annotation);
       }
-    };
-    const afterAllExecutionCallbackPrevious = afterAllExecutionCallback;
-    afterAllExecutionCallback = async (returnValue) => {
-      afterAllExecutionCallbackPrevious(returnValue);
+    });
+    afterAllExecutionCallbackSet.add(async (returnValue) => {
       const { summary } = returnValue;
       const title = "Jsenv test results";
       const summaryText = stripAnsi(formatSummary(summary));
@@ -431,7 +459,7 @@ To fix this warning:
         summary: summaryText,
         annotations,
       });
-    };
+    });
   }
 
   executionSteps = executionSteps.filter(
@@ -515,6 +543,7 @@ To fix this warning:
     const executionLogsEnabled = logger.levels.info;
     const executionSpinner =
       logRefresh &&
+      concurrency === 1 &&
       !debugLogsEnabled &&
       executionLogsEnabled &&
       process.stdout.isTTY &&
@@ -534,9 +563,12 @@ To fix this warning:
       completed: 0,
       done: 0,
     };
-    await executeInParallel({
+
+    const callWhenPreviousExecutionAreDone = createCallOrderer();
+
+    await executeConcurrently({
       multipleExecutionsOperation,
-      maxExecutionsInParallel,
+      concurrency,
       cooldownBetweenExecutions,
       executionSteps,
       start: async (paramsFromStep) => {
@@ -589,8 +621,9 @@ To fix this warning:
             },
           });
         }
-        beforeExecutionCallback(beforeExecutionInfo);
-
+        for (const beforeExecutionCallback of beforeExecutionCallbackSet) {
+          beforeExecutionCallback(beforeExecutionInfo);
+        }
         const fileUrl = `${rootDirectoryUrl}${fileRelativeUrl}`;
         let executionResult;
         if (existsSync(new URL(fileUrl))) {
@@ -599,7 +632,7 @@ To fix this warning:
             logger,
             allocatedMs: executionParams.allocatedMs,
             keepRunning,
-            mirrorConsole: false, // file are executed in parallel, log would be a mess to read
+            mirrorConsole: false, // might be executed in parallel: log would be a mess to read
             collectConsole: executionParams.collectConsole,
             coverageEnabled,
             coverageTempDirectoryUrl,
@@ -619,7 +652,6 @@ To fix this warning:
             ],
           };
         }
-        counters.done++;
         const fileReport = report[fileRelativeUrl];
         if (fileReport) {
           fileReport[executionName] = executionResult;
@@ -636,58 +668,65 @@ To fix this warning:
           executionResult,
         };
 
-        if (executionResult.status === "aborted") {
-          counters.aborted++;
-        } else if (executionResult.status === "timedout") {
-          counters.timedout++;
-        } else if (executionResult.status === "failed") {
-          counters.failed++;
-        } else if (executionResult.status === "completed") {
-          counters.completed++;
-        }
         if (gcBetweenExecutions) {
           global.gc();
         }
-        if (executionLogsEnabled) {
-          const log = createExecutionLog(afterExecutionInfo, {
-            logShortForCompletedExecutions,
-            logRuntime,
-            logEachDuration,
-            ...(logTimeUsage
-              ? {
-                  timeEllapsed: Date.now() - startMs,
-                }
-              : {}),
-            ...(logMemoryHeapUsage
-              ? { memoryHeap: memoryUsage().heapUsed }
-              : {}),
-          });
-          // replace spinner with this execution result
-          if (spinner) spinner.stop();
-          executionLog.write(log);
-          rawOutput += stripAnsi(log);
-
-          const canOverwriteLog = canOverwriteLogGetter({
-            logMergeForCompletedExecutions,
-            executionResult,
-          });
-          if (canOverwriteLog) {
-            // nothing to do, we reuse the current executionLog object
-          } else {
-            executionLog.destroy();
-            executionLog = createLog({ newLine: "" });
+
+        const timeEllapsed = Date.now() - startMs;
+        const memoryHeap = memoryUsage().heapUsed;
+        callWhenPreviousExecutionAreDone(executionIndex, () => {
+          counters.done++;
+          if (executionResult.status === "aborted") {
+            counters.aborted++;
+          } else if (executionResult.status === "timedout") {
+            counters.timedout++;
+          } else if (executionResult.status === "failed") {
+            counters.failed++;
+          } else if (executionResult.status === "completed") {
+            counters.completed++;
+          }
+
+          if (executionLogsEnabled) {
+            // replace spinner with this execution result
+            if (spinner) {
+              spinner.stop();
+              spinner = null;
+            }
+
+            const log = createExecutionLog(afterExecutionInfo, {
+              logShortForCompletedExecutions,
+              logRuntime,
+              logEachDuration,
+              ...(logTimeUsage ? { timeEllapsed } : {}),
+              ...(logMemoryHeapUsage ? { memoryHeap } : {}),
+            });
+
+            executionLog.write(log);
+            rawOutput += stripAnsi(log);
+            const canOverwriteLog = canOverwriteLogGetter({
+              logMergeForCompletedExecutions,
+              executionResult,
+            });
+            if (canOverwriteLog) {
+              // nothing to do, we reuse the current executionLog object
+            } else {
+              executionLog.destroy();
+              executionLog = createLog({ newLine: "" });
+            }
+            const isLastExecutionLog =
+              executionIndex === executionSteps.length - 1;
+            if (isLastExecutionLog && logger.levels.info) {
+              executionLog.write("\n");
+            }
           }
+        });
+        for (const afterExecutionCallback of afterExecutionCallbackSet) {
+          afterExecutionCallback(afterExecutionInfo);
         }
-        afterExecutionCallback(afterExecutionInfo);
-        const isLastExecutionLog = executionIndex === executionSteps.length - 1;
         const cancelRemaining =
           failFast &&
           executionResult.status !== "completed" &&
           counters.done < counters.total;
-        if (isLastExecutionLog && logger.levels.info) {
-          executionLog.write("\n");
-        }
-
         if (cancelRemaining) {
           logger.info(`"failFast" enabled -> cancel remaining executions`);
           failFastAbortController.abort();
@@ -776,7 +815,9 @@ To fix this warning:
     await Promise.all(promises);
   }
 
-  await afterAllExecutionCallback(returnValue);
+  for (const afterAllExecutionCallback of afterAllExecutionCallbackSet) {
+    await afterAllExecutionCallback(returnValue);
+  }
   return returnValue;
 };
 
@@ -800,53 +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 = [];
-    while (
-      remainingExecutionCount > 0 &&
-      outputPromiseArray.length < maxExecutionsInParallel
-    ) {
-      remainingExecutionCount--;
-      const outputPromise = executeOne(progressionIndex);
-      progressionIndex++;
-      outputPromiseArray.push(outputPromise);
-    }
-    if (outputPromiseArray.length) {
-      await Promise.all(outputPromiseArray);
-      if (remainingExecutionCount > 0) {
-        await nextChunk();
-      }
-    }
-  };
-
-  const executeOne = async (index) => {
-    const input = executionSteps[index];
-    const output = await start(input);
-    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/helpers/call_orderer.js

@@ -0,0 +1,39 @@
+export const createCallOrderer = () => {
+  const queue = [];
+  const callWhenPreviousExecutionAreDone = (executionIndex, callback) => {
+    if (queue[executionIndex]) {
+      throw new Error(`${executionIndex} already used`);
+    }
+
+    let allBeforeAreDone = true;
+    if (executionIndex > 0) {
+      let beforeIndex = executionIndex - 1;
+      do {
+        const value = queue[beforeIndex];
+        if (!value) {
+          allBeforeAreDone = false;
+          break;
+        }
+      } while (beforeIndex--);
+    }
+    if (!allBeforeAreDone) {
+      queue[executionIndex] = callback;
+      return;
+    }
+    queue[executionIndex] = true;
+    callback();
+    let afterIndex = executionIndex + 1;
+    while (afterIndex < queue.length) {
+      const value = queue[afterIndex];
+      if (value === undefined) {
+        break;
+      }
+      if (typeof value === "function") {
+        queue[afterIndex] = true;
+        value();
+      }
+      afterIndex++;
+    }
+  };
+  return callWhenPreviousExecutionAreDone;
+};