@jsenv/core 23.4.2 → 23.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "23.4.2",
+  "version": "23.5.0",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "repository": {
@@ -63,12 +63,12 @@
     "@babel/plugin-syntax-numeric-separator": "7.10.4",
     "@babel/plugin-transform-modules-systemjs": "7.15.4",
     "@c88/v8-coverage": "0.1.1",
-    "@jsenv/abort": "4.0.0",
-    "@jsenv/filesystem": "2.5.0",
+    "@jsenv/abort": "4.1.1",
+    "@jsenv/filesystem": "2.5.1",
     "@jsenv/importmap": "1.1.0",
-    "@jsenv/log": "1.1.0",
+    "@jsenv/log": "1.4.0",
     "@jsenv/logger": "4.0.1",
-    "@jsenv/server": "10.0.0",
+    "@jsenv/server": "10.0.1",
     "@jsenv/uneval": "1.6.0",
     "@jsenv/workers": "1.2.0",
     "@rollup/plugin-commonjs": "21.0.0",

package/src/execute.js

@@ -27,11 +27,8 @@ export const execute = async ({
   runtimeParams,
 
   allocatedMs,
-  measureDuration,
   mirrorConsole = true,
   captureConsole,
-  collectRuntimeName,
-  collectRuntimeVersion,
   inheritCoverage,
   collectCoverage,
   measurePerformance,
@@ -139,11 +136,8 @@ export const execute = async ({
       },
 
       allocatedMs,
-      measureDuration,
       mirrorConsole,
       captureConsole,
-      collectRuntimeName,
-      collectRuntimeVersion,
       inheritCoverage,
       collectCoverage,
       measurePerformance,

package/src/executeTestPlan.js

@@ -33,13 +33,13 @@ export const executeTestPlan = async ({
 
   testPlan,
   defaultMsAllocatedPerExecution,
+  cooldownBetweenExecutions,
 
   maxExecutionsInParallel,
 
   completedExecutionLogAbbreviation = false,
   completedExecutionLogMerging = false,
   logSummary = true,
-  measureGlobalDuration = true,
   updateProcessExitCode = true,
 
   coverage = process.argv.includes("--cover") ||
@@ -144,10 +144,10 @@ export const executeTestPlan = async ({
 
     defaultMsAllocatedPerExecution,
     maxExecutionsInParallel,
+    cooldownBetweenExecutions,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
     logSummary,
-    measureGlobalDuration,
 
     coverage,
     coverageConfig,
@@ -225,6 +225,7 @@ export const executeTestPlan = async ({
   }
 
   return {
+    testPlanAborted: result.aborted,
     testPlanSummary: result.planSummary,
     testPlanReport: result.planReport,
     testPlanCoverage: planCoverage,

package/src/internal/executing/coverage/reportToCoverage.js

@@ -1,4 +1,5 @@
 import { readFile } from "@jsenv/filesystem"
+import { Abort } from "@jsenv/abort"
 
 import {
   visitNodeV8Directory,
@@ -9,13 +10,12 @@ import { composeTwoFileByFileIstanbulCoverages } from "../coverage_utils/istanbu
 import { v8CoverageToIstanbul } from "../coverage_utils/v8_coverage_to_istanbul.js"
 import { composeV8AndIstanbul } from "../coverage_utils/v8_and_istanbul.js"
 import { normalizeFileByFileCoveragePaths } from "../coverage_utils/file_by_file_coverage.js"
-import { listRelativeFileUrlToCover } from "../coverage_empty/list_files_not_covered.js"
-import { relativeUrlToEmptyCoverage } from "../coverage_empty/relativeUrlToEmptyCoverage.js"
+import { getMissingFileByFileCoverage } from "../coverage_missing/missing_coverage.js"
 
 export const reportToCoverage = async (
   report,
   {
-    multipleExecutionsOperation,
+    signal,
     logger,
     projectDirectoryUrl,
     babelPluginMap,
@@ -26,70 +26,39 @@ export const reportToCoverage = async (
     coverageV8ConflictWarning,
   },
 ) => {
-  let v8Coverage
-  let fileByFileIstanbulCoverage
-
   // collect v8 and istanbul coverage from executions
-  await Object.keys(report).reduce(async (previous, file) => {
-    await previous
-
-    const executionResultForFile = report[file]
-    await Object.keys(executionResultForFile).reduce(
-      async (previous, executionName) => {
-        await previous
-
-        const executionResultForFileOnRuntime =
-          executionResultForFile[executionName]
-        const { status, coverageFileUrl } = executionResultForFileOnRuntime
-        if (!coverageFileUrl) {
-          // several reasons not to have coverage here:
-          // 1. the file we executed did not import an instrumented file.
-          // - a test file without import
-          // - a test file importing only file excluded from coverage
-          // - a coverDescription badly configured so that we don't realize
-          // a file should be covered
-
-          // 2. the file we wanted to executed timedout
-          // - infinite loop
-          // - too extensive operation
-          // - a badly configured or too low allocatedMs for that execution.
-
-          // 3. the file we wanted to execute contains syntax-error
-
-          // in any scenario we are fine because
-          // coverDescription will generate empty coverage for files
-          // that were suppose to be coverage but were not.
-          if (status === "completed") {
-            logger.debug(
-              `No execution.coverageFileUrl from execution named "${executionName}" of ${file}`,
-            )
-          }
-          return
-        }
-
-        const executionCoverage = await readFile(coverageFileUrl, {
-          as: "json",
-        })
-        if (isV8Coverage(executionCoverage)) {
-          v8Coverage = v8Coverage
-            ? composeTwoV8Coverages(v8Coverage, executionCoverage)
-            : executionCoverage
-        } else {
-          fileByFileIstanbulCoverage = fileByFileIstanbulCoverage
-            ? composeTwoFileByFileIstanbulCoverages(
-                fileByFileIstanbulCoverage,
-                executionCoverage,
-              )
-            : executionCoverage
-        }
-      },
-      Promise.resolve(),
-    )
-  }, Promise.resolve())
+  let { v8Coverage, fileByFileIstanbulCoverage } = await getCoverageFromReport({
+    signal,
+    report,
+    onMissing: ({ file, executionResult, executionName }) => {
+      // several reasons not to have coverage here:
+      // 1. the file we executed did not import an instrumented file.
+      // - a test file without import
+      // - a test file importing only file excluded from coverage
+      // - a coverDescription badly configured so that we don't realize
+      // a file should be covered
+
+      // 2. the file we wanted to executed timedout
+      // - infinite loop
+      // - too extensive operation
+      // - a badly configured or too low allocatedMs for that execution.
+
+      // 3. the file we wanted to execute contains syntax-error
+
+      // in any scenario we are fine because
+      // coverDescription will generate empty coverage for files
+      // that were suppose to be coverage but were not.
+      if (executionResult.status === "completed") {
+        logger.debug(
+          `No execution.coverageFileUrl from execution named "${executionName}" of ${file}`,
+        )
+      }
+    },
+  })
 
   if (!coverageForceIstanbul && process.env.NODE_V8_COVERAGE) {
     await visitNodeV8Directory({
-      signal: multipleExecutionsOperation.signal,
+      signal,
       NODE_V8_COVERAGE: process.env.NODE_V8_COVERAGE,
       onV8Coverage: (nodeV8Coverage) => {
         const nodeV8CoverageLight = filterV8Coverage(nodeV8Coverage, {
@@ -105,7 +74,9 @@ export const reportToCoverage = async (
   // try to merge v8 with istanbul, if any
   let fileByFileCoverage
   if (v8Coverage) {
-    let v8FileByFileCoverage = await v8CoverageToIstanbul(v8Coverage)
+    let v8FileByFileCoverage = await v8CoverageToIstanbul(v8Coverage, {
+      signal,
+    })
 
     v8FileByFileCoverage = normalizeFileByFileCoveragePaths(
       v8FileByFileCoverage,
@@ -140,34 +111,77 @@ export const reportToCoverage = async (
 
   // now add coverage for file not covered
   if (coverageIncludeMissing) {
-    const relativeUrlsToCover = await listRelativeFileUrlToCover({
-      multipleExecutionsOperation,
+    const missingFileByFileCoverage = await getMissingFileByFileCoverage({
+      signal,
       projectDirectoryUrl,
       coverageConfig,
+      fileByFileCoverage,
+      babelPluginMap,
     })
+    Object.assign(fileByFileCoverage, missingFileByFileCoverage)
+  }
 
-    const relativeUrlsMissing = relativeUrlsToCover.filter(
-      (relativeUrlToCover) =>
-        Object.keys(fileByFileCoverage).every((key) => {
-          return key !== `./${relativeUrlToCover}`
-        }),
-    )
+  return fileByFileCoverage
+}
+
+const getCoverageFromReport = async ({ signal, report, onMissing }) => {
+  const operation = Abort.startOperation()
+  operation.addAbortSignal(signal)
+
+  try {
+    let v8Coverage
+    let fileByFileIstanbulCoverage
+
+    // collect v8 and istanbul coverage from executions
+    await Object.keys(report).reduce(async (previous, file) => {
+      operation.throwIfAborted()
+      await previous
+
+      const executionResultForFile = report[file]
+      await Object.keys(executionResultForFile).reduce(
+        async (previous, executionName) => {
+          operation.throwIfAborted()
+          await previous
+
+          const executionResultForFileOnRuntime =
+            executionResultForFile[executionName]
+          const { coverageFileUrl } = executionResultForFileOnRuntime
+          if (!coverageFileUrl) {
+            onMissing({
+              executionName,
+              file,
+              executionResult: executionResultForFileOnRuntime,
+            })
+            return
+          }
 
-    await relativeUrlsMissing.reduce(async (previous, relativeUrlMissing) => {
-      const emptyCoverage = await relativeUrlToEmptyCoverage(
-        relativeUrlMissing,
-        {
-          multipleExecutionsOperation,
-          projectDirectoryUrl,
-          babelPluginMap,
+          const executionCoverage = await readFile(coverageFileUrl, {
+            as: "json",
+          })
+          if (isV8Coverage(executionCoverage)) {
+            v8Coverage = v8Coverage
+              ? composeTwoV8Coverages(v8Coverage, executionCoverage)
+              : executionCoverage
+          } else {
+            fileByFileIstanbulCoverage = fileByFileIstanbulCoverage
+              ? composeTwoFileByFileIstanbulCoverages(
+                  fileByFileIstanbulCoverage,
+                  executionCoverage,
+                )
+              : executionCoverage
+          }
         },
+        Promise.resolve(),
       )
-      fileByFileCoverage[`./${relativeUrlMissing}`] = emptyCoverage
-      return emptyCoverage
     }, Promise.resolve())
-  }
 
-  return fileByFileCoverage
+    return {
+      v8Coverage,
+      fileByFileIstanbulCoverage,
+    }
+  } finally {
+    await operation.end()
+  }
 }
 
 const isV8Coverage = (coverage) => Boolean(coverage.result)

package/src/internal/executing/{coverage_empty → coverage_missing}/list_files_not_covered.js

@@ -1,7 +1,7 @@
 import { collectFiles } from "@jsenv/filesystem"
 
 export const listRelativeFileUrlToCover = async ({
-  multipleExecutionsOperation,
+  signal,
   projectDirectoryUrl,
   coverageConfig,
 }) => {
@@ -10,7 +10,7 @@ export const listRelativeFileUrlToCover = async ({
   }
 
   const matchingFileResultArray = await collectFiles({
-    signal: multipleExecutionsOperation.signal,
+    signal,
     directoryUrl: projectDirectoryUrl,
     structuredMetaMap: structuredMetaMapForCoverage,
     predicate: ({ cover }) => cover,

package/src/internal/executing/coverage_missing/missing_coverage.js

@@ -0,0 +1,46 @@
+import { Abort } from "@jsenv/abort"
+
+import { listRelativeFileUrlToCover } from "./list_files_not_covered.js"
+import { relativeUrlToEmptyCoverage } from "./relativeUrlToEmptyCoverage.js"
+
+export const getMissingFileByFileCoverage = async ({
+  signal,
+  projectDirectoryUrl,
+  coverageConfig,
+  fileByFileCoverage,
+  babelPluginMap,
+}) => {
+  const relativeUrlsToCover = await listRelativeFileUrlToCover({
+    signal,
+    projectDirectoryUrl,
+    coverageConfig,
+  })
+
+  const relativeUrlsMissing = relativeUrlsToCover.filter((relativeUrlToCover) =>
+    Object.keys(fileByFileCoverage).every((key) => {
+      return key !== `./${relativeUrlToCover}`
+    }),
+  )
+
+  const operation = Abort.startOperation()
+  operation.addAbortSignal(signal)
+
+  const missingFileByFileCoverage = {}
+  await relativeUrlsMissing.reduce(async (previous, relativeUrlMissing) => {
+    operation.throwIfAborted()
+    await previous
+    await operation.withSignal(async (signal) => {
+      const emptyCoverage = await relativeUrlToEmptyCoverage(
+        relativeUrlMissing,
+        {
+          signal,
+          projectDirectoryUrl,
+          babelPluginMap,
+        },
+      )
+      missingFileByFileCoverage[`./${relativeUrlMissing}`] = emptyCoverage
+    })
+  }, Promise.resolve())
+
+  return missingFileByFileCoverage
+}

package/src/internal/executing/{coverage_empty → coverage_missing}/relativeUrlToEmptyCoverage.js

@@ -1,4 +1,5 @@
 import { resolveUrl, urlToFileSystemPath, readFile } from "@jsenv/filesystem"
+import { Abort } from "@jsenv/abort"
 
 import {
   babelPluginsFromBabelPluginMap,
@@ -9,22 +10,23 @@ import { createEmptyCoverage } from "./createEmptyCoverage.js"
 
 export const relativeUrlToEmptyCoverage = async (
   relativeUrl,
-  { multipleExecutionsOperation, projectDirectoryUrl, babelPluginMap },
+  { signal, projectDirectoryUrl, babelPluginMap },
 ) => {
-  const { transformAsync } = await import("@babel/core")
-
-  const fileUrl = resolveUrl(relativeUrl, projectDirectoryUrl)
-  multipleExecutionsOperation.throwIfAborted()
-  const source = await readFile(fileUrl)
+  const operation = Abort.startOperation()
+  operation.addAbortSignal(signal)
 
   try {
+    const { transformAsync } = await import("@babel/core")
+    const fileUrl = resolveUrl(relativeUrl, projectDirectoryUrl)
+    const source = await readFile(fileUrl)
+
     babelPluginMap = {
       ...getMinimalBabelPluginMap(),
       ...babelPluginMap,
       "transform-instrument": [babelPluginInstrument, { projectDirectoryUrl }],
     }
 
-    multipleExecutionsOperation.throwIfAborted()
+    operation.throwIfAborted()
     const { metadata } = await transformAsync(source, {
       filename: urlToFileSystemPath(fileUrl),
       filenameRelative: relativeUrl,
@@ -55,5 +57,7 @@ export const relativeUrlToEmptyCoverage = async (
       return createEmptyCoverage(relativeUrl)
     }
     throw e
+  } finally {
+    await operation.end()
   }
 }

package/src/internal/executing/coverage_utils/v8_coverage_from_directory.js

@@ -5,12 +5,16 @@ import {
   resolveUrl,
 } from "@jsenv/filesystem"
 import { createDetailedMessage } from "@jsenv/logger"
+import { Abort } from "@jsenv/abort"
 
 export const visitNodeV8Directory = async ({
-  // signal
+  signal,
   NODE_V8_COVERAGE,
   onV8Coverage,
 }) => {
+  const operation = Abort.startOperation()
+  operation.addAbortSignal(signal)
+
   const tryReadDirectory = async () => {
     const dirContent = await readDirectory(NODE_V8_COVERAGE)
     if (dirContent.length > 0) {
@@ -19,39 +23,47 @@ export const visitNodeV8Directory = async ({
     console.warn(`v8 coverage directory is empty at ${NODE_V8_COVERAGE}`)
     return dirContent
   }
-  const dirContent = await tryReadDirectory()
 
-  const coverageDirectoryUrl = assertAndNormalizeDirectoryUrl(NODE_V8_COVERAGE)
-  await dirContent.reduce(async (previous, dirEntry) => {
-    await previous
+  try {
+    operation.throwIfAborted()
+    const dirContent = await tryReadDirectory()
 
-    const dirEntryUrl = resolveUrl(dirEntry, coverageDirectoryUrl)
-    const tryReadJsonFile = async () => {
-      const fileContent = await readFile(dirEntryUrl, { as: "string" })
-      if (fileContent === "") {
-        console.warn(`Coverage JSON file is empty at ${dirEntryUrl}`)
-        return null
-      }
+    const coverageDirectoryUrl =
+      assertAndNormalizeDirectoryUrl(NODE_V8_COVERAGE)
+    await dirContent.reduce(async (previous, dirEntry) => {
+      operation.throwIfAborted()
+      await previous
 
-      try {
-        const fileAsJson = JSON.parse(fileContent)
-        return fileAsJson
-      } catch (e) {
-        console.warn(
-          createDetailedMessage(`Error while reading coverage file`, {
-            "error stack": e.stack,
-            "file": dirEntryUrl,
-          }),
-        )
-        return null
+      const dirEntryUrl = resolveUrl(dirEntry, coverageDirectoryUrl)
+      const tryReadJsonFile = async () => {
+        const fileContent = await readFile(dirEntryUrl, { as: "string" })
+        if (fileContent === "") {
+          console.warn(`Coverage JSON file is empty at ${dirEntryUrl}`)
+          return null
+        }
+
+        try {
+          const fileAsJson = JSON.parse(fileContent)
+          return fileAsJson
+        } catch (e) {
+          console.warn(
+            createDetailedMessage(`Error while reading coverage file`, {
+              "error stack": e.stack,
+              "file": dirEntryUrl,
+            }),
+          )
+          return null
+        }
       }
-    }
 
-    const fileContent = await tryReadJsonFile()
-    if (fileContent) {
-      onV8Coverage(fileContent)
-    }
-  }, Promise.resolve())
+      const fileContent = await tryReadJsonFile()
+      if (fileContent) {
+        onV8Coverage(fileContent)
+      }
+    }, Promise.resolve())
+  } finally {
+    await operation.end()
+  }
 }
 
 export const filterV8Coverage = (v8Coverage, { coverageIgnorePredicate }) => {

package/src/internal/executing/coverage_utils/v8_coverage_to_istanbul.js

@@ -1,53 +1,63 @@
 import { urlToFileSystemPath } from "@jsenv/filesystem"
+import { Abort } from "@jsenv/abort"
 
 import { require } from "@jsenv/core/src/internal/require.js"
 
 import { composeTwoFileByFileIstanbulCoverages } from "./istanbul_coverage_composition.js"
 
-export const v8CoverageToIstanbul = async (v8Coverage) => {
-  const v8ToIstanbul = require("v8-to-istanbul")
-  const sourcemapCache = v8Coverage["source-map-cache"]
-  let istanbulCoverageComposed = null
-  await v8Coverage.result.reduce(async (previous, fileV8Coverage) => {
-    await previous
+export const v8CoverageToIstanbul = async (v8Coverage, { signal }) => {
+  const operation = Abort.startOperation()
+  operation.addAbortSignal(signal)
 
-    const { source } = fileV8Coverage
-    let sources
-    // when v8 coverage comes from playwright (chromium) v8Coverage.source is set
-    if (typeof source === "string") {
-      sources = { source }
-    }
-    // when v8 coverage comes from Node.js, the source can be read from sourcemapCache
-    else if (sourcemapCache) {
-      sources = sourcesFromSourceMapCache(fileV8Coverage.url, sourcemapCache)
-    }
-    const path = urlToFileSystemPath(fileV8Coverage.url)
+  try {
+    const v8ToIstanbul = require("v8-to-istanbul")
+    const sourcemapCache = v8Coverage["source-map-cache"]
+    let istanbulCoverageComposed = null
 
-    const converter = v8ToIstanbul(
-      path,
-      // wrapperLength is undefined we don't need it
-      // https://github.com/istanbuljs/v8-to-istanbul/blob/2b54bc97c5edf8a37b39a171ec29134ba9bfd532/lib/v8-to-istanbul.js#L27
-      undefined,
-      sources,
-    )
-    await converter.load()
+    await v8Coverage.result.reduce(async (previous, fileV8Coverage) => {
+      operation.throwIfAborted()
+      await previous
 
-    converter.applyCoverage(fileV8Coverage.functions)
-    const istanbulCoverage = converter.toIstanbul()
+      const { source } = fileV8Coverage
+      let sources
+      // when v8 coverage comes from playwright (chromium) v8Coverage.source is set
+      if (typeof source === "string") {
+        sources = { source }
+      }
+      // when v8 coverage comes from Node.js, the source can be read from sourcemapCache
+      else if (sourcemapCache) {
+        sources = sourcesFromSourceMapCache(fileV8Coverage.url, sourcemapCache)
+      }
+      const path = urlToFileSystemPath(fileV8Coverage.url)
 
-    istanbulCoverageComposed = istanbulCoverageComposed
-      ? composeTwoFileByFileIstanbulCoverages(
-          istanbulCoverageComposed,
-          istanbulCoverage,
-        )
-      : istanbulCoverage
-  }, Promise.resolve())
+      const converter = v8ToIstanbul(
+        path,
+        // wrapperLength is undefined we don't need it
+        // https://github.com/istanbuljs/v8-to-istanbul/blob/2b54bc97c5edf8a37b39a171ec29134ba9bfd532/lib/v8-to-istanbul.js#L27
+        undefined,
+        sources,
+      )
+      await converter.load()
 
-  if (!istanbulCoverageComposed) {
-    return {}
+      converter.applyCoverage(fileV8Coverage.functions)
+      const istanbulCoverage = converter.toIstanbul()
+
+      istanbulCoverageComposed = istanbulCoverageComposed
+        ? composeTwoFileByFileIstanbulCoverages(
+            istanbulCoverageComposed,
+            istanbulCoverage,
+          )
+        : istanbulCoverage
+    }, Promise.resolve())
+
+    if (!istanbulCoverageComposed) {
+      return {}
+    }
+    istanbulCoverageComposed = markAsConvertedFromV8(istanbulCoverageComposed)
+    return istanbulCoverageComposed
+  } finally {
+    await operation.end()
   }
-  istanbulCoverageComposed = markAsConvertedFromV8(istanbulCoverageComposed)
-  return istanbulCoverageComposed
 }
 
 const markAsConvertedFromV8 = (fileByFileCoverage) => {

package/src/internal/executing/createSummaryLog.js

@@ -5,7 +5,8 @@ import { EXECUTION_COLORS } from "./execution_colors.js"
 
 export const createSummaryLog = (summary) => `
 -------------- summary -----------------
-${createSummaryMessage(summary)}${createTotalDurationMessage(summary)}
+${createSummaryMessage(summary)}
+total duration: ${msAsDuration(summary.duration)}
 ----------------------------------------
 `
 
@@ -114,10 +115,3 @@ const createMixedDetails = ({
 
   return `${parts.join(", ")}`
 }
-
-const createTotalDurationMessage = ({ startMs, endMs }) => {
-  if (!endMs) return ""
-
-  return `
-total duration: ${msAsDuration(endMs - startMs)}`
-}

package/src/internal/executing/executeConcurrently.js

@@ -1,7 +1,8 @@
-import { stat } from "node:fs"
+import { existsSync } from "node:fs"
 import wrapAnsi from "wrap-ansi"
 import cuid from "cuid"
-import { loggerToLevels, createDetailedMessage } from "@jsenv/logger"
+import { loggerToLevels } from "@jsenv/logger"
+import { createLog, startSpinner } from "@jsenv/log"
 import {
   urlToFileSystemPath,
   resolveUrl,
@@ -10,12 +11,11 @@ import {
   normalizeStructuredMetaMap,
   urlToMeta,
 } from "@jsenv/filesystem"
-import { createLog } from "@jsenv/log"
 import { Abort } from "@jsenv/abort"
 
 import { launchAndExecute } from "../executing/launchAndExecute.js"
 import { reportToCoverage } from "./coverage/reportToCoverage.js"
-import { createExecutionResultLog } from "./executionLogs.js"
+import { formatExecuting, formatExecutionResult } from "./executionLogs.js"
 import { createSummaryLog } from "./createSummaryLog.js"
 
 export const executeConcurrently = async (
@@ -33,10 +33,10 @@ export const executeConcurrently = async (
     babelPluginMap,
 
     defaultMsAllocatedPerExecution = 30000,
+    cooldownBetweenExecutions = 0,
     maxExecutionsInParallel = 1,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
-    measureGlobalDuration = true,
 
     coverage,
     coverageConfig,
@@ -46,21 +46,21 @@ export const executeConcurrently = async (
     coverageTempDirectoryRelativeUrl,
     runtimeSupport,
 
-    mainFileNotFoundCallback = ({ fileRelativeUrl }) => {
-      logger.error(
-        new Error(
-          createDetailedMessage(`an execution main file does not exists.`, {
-            ["file relative path"]: fileRelativeUrl,
-          }),
-        ),
-      )
-    },
     beforeExecutionCallback = () => {},
     afterExecutionCallback = () => {},
 
     logSummary,
   },
 ) => {
+  if (completedExecutionLogMerging && !process.stdout.isTTY) {
+    completedExecutionLogMerging = false
+    logger.debug(
+      `Force completedExecutionLogMerging to false because process.stdout.isTTY is false`,
+    )
+  }
+  const executionLogsEnabled = loggerToLevels(logger).info
+  const executionSpinner = executionLogsEnabled && process.stdout.isTTY
+
   const startMs = Date.now()
 
   const report = {}
@@ -113,7 +113,7 @@ export const executeConcurrently = async (
 
       try {
         value.coverage = await reportToCoverage(value.report, {
-          multipleExecutionsOperation,
+          signal: multipleExecutionsOperation.signal,
           logger,
           projectDirectoryUrl,
           babelPluginMap,
@@ -133,8 +133,7 @@ export const executeConcurrently = async (
     }
   }
 
-  let previousExecutionResult
-  let previousExecutionLog
+  let executionLog = createLog({ newLine: "around" })
   let abortedCount = 0
   let timedoutCount = 0
   let erroredCount = 0
@@ -142,18 +141,19 @@ export const executeConcurrently = async (
   const executionsDone = await executeInParallel({
     multipleExecutionsOperation,
     maxExecutionsInParallel,
+    cooldownBetweenExecutions,
     executionSteps,
     start: async (paramsFromStep) => {
       const executionIndex = executionSteps.indexOf(paramsFromStep)
-      const { executionName, fileRelativeUrl } = paramsFromStep
+      const { executionName, fileRelativeUrl, runtime } = paramsFromStep
+      const runtimeName = runtime.name
+      const runtimeVersion = runtime.version
+
       const executionParams = {
         // the params below can be overriden by executionDefaultParams
         measurePerformance: false,
         collectPerformance: false,
-        measureDuration: true,
         captureConsole: true,
-        collectRuntimeName: true,
-        collectRuntimeVersion: true,
         // stopAfterExecute: true to ensure runtime is stopped once executed
         // because we have what we wants: execution is completed and
         // we have associated coverage and capturedConsole
@@ -163,6 +163,7 @@ export const executeConcurrently = async (
         stopAfterExecuteReason: "execution-done",
         allocatedMs: defaultMsAllocatedPerExecution,
         ...paramsFromStep,
+        runtime,
         // mirrorConsole: false because file will be executed in parallel
         // so log would be a mess to read
         mirrorConsole: false,
@@ -170,48 +171,69 @@ export const executeConcurrently = async (
 
       const beforeExecutionInfo = {
         fileRelativeUrl,
+        runtimeName,
+        runtimeVersion,
         executionIndex,
         executionParams,
       }
 
+      let spinner
+      if (executionSpinner) {
+        spinner = startSpinner({
+          log: executionLog,
+          text: formatExecuting(beforeExecutionInfo, {
+            executionCount,
+            abortedCount,
+            timedoutCount,
+            erroredCount,
+            completedCount,
+          }),
+        })
+      }
+      beforeExecutionCallback(beforeExecutionInfo)
+
       const filePath = urlToFileSystemPath(
         `${projectDirectoryUrl}${fileRelativeUrl}`,
       )
-      const fileExists = await pathLeadsToFile(filePath)
-      if (!fileExists) {
-        mainFileNotFoundCallback(beforeExecutionInfo)
-        return
-      }
-
-      beforeExecutionCallback(beforeExecutionInfo)
+      let executionResult
+      if (existsSync(filePath)) {
+        executionResult = await launchAndExecute({
+          signal: multipleExecutionsOperation.signal,
+          launchAndExecuteLogLevel,
 
-      // launchAndExecute peut retourner un aborted
-      // et c'est bien, on veut le gérer, si tous les suivants sont aborted
-      // on le gere en dehors de cette boucle
-      const executionResult = await launchAndExecute({
-        signal: multipleExecutionsOperation.signal,
-        launchAndExecuteLogLevel,
-
-        ...executionParams,
-        collectCoverage: coverage,
-        coverageTempDirectoryUrl,
-        runtimeParams: {
-          projectDirectoryUrl,
-          compileServerOrigin,
-          outDirectoryRelativeUrl,
+          ...executionParams,
           collectCoverage: coverage,
-          coverageIgnorePredicate,
-          coverageForceIstanbul,
-          ...executionParams.runtimeParams,
-        },
-        executeParams: {
-          fileRelativeUrl,
-          ...executionParams.executeParams,
-        },
-        coverageV8ConflictWarning,
-      })
+          coverageTempDirectoryUrl,
+          runtimeParams: {
+            projectDirectoryUrl,
+            compileServerOrigin,
+            outDirectoryRelativeUrl,
+            collectCoverage: coverage,
+            coverageIgnorePredicate,
+            coverageForceIstanbul,
+            ...executionParams.runtimeParams,
+          },
+          executeParams: {
+            fileRelativeUrl,
+            ...executionParams.executeParams,
+          },
+          coverageV8ConflictWarning,
+        })
+      } else {
+        executionResult = {
+          status: "errored",
+          error: new Error(
+            `No file at ${fileRelativeUrl} for execution "${executionName}"`,
+          ),
+        }
+      }
+      if (fileRelativeUrl in report === false) {
+        report[fileRelativeUrl] = {}
+      }
+      report[fileRelativeUrl][executionName] = executionResult
       const afterExecutionInfo = {
         ...beforeExecutionInfo,
+        endMs: Date.now(),
         executionResult,
       }
       afterExecutionCallback(afterExecutionInfo)
@@ -226,8 +248,8 @@ export const executeConcurrently = async (
         completedCount++
       }
 
-      if (loggerToLevels(logger).info) {
-        let log = createExecutionResultLog(afterExecutionInfo, {
+      if (executionLogsEnabled) {
+        let log = formatExecutionResult(afterExecutionInfo, {
           completedExecutionLogAbbreviation,
           executionCount,
           abortedCount,
@@ -242,31 +264,21 @@ export const executeConcurrently = async (
           wordWrap: false,
         })
 
-        if (
-          previousExecutionLog &&
-          completedExecutionLogMerging &&
-          previousExecutionResult &&
-          previousExecutionResult.status === "completed" &&
-          (previousExecutionResult.consoleCalls
-            ? previousExecutionResult.consoleCalls.length === 0
-            : true) &&
-          executionResult.status === "completed"
-        ) {
-          previousExecutionLog.write(log)
+        // replace spinner with this execution result
+        if (spinner) spinner.stop()
+        executionLog.write(log)
+
+        const canOverwriteLog = canOverwriteLogGetter({
+          completedExecutionLogMerging,
+          executionResult,
+        })
+        if (canOverwriteLog) {
+          // nothing to do, we reuse the current executionLog object
         } else {
-          if (previousExecutionLog) {
-            previousExecutionLog.destroy()
-          }
-          previousExecutionLog = createLog()
-          previousExecutionLog.write(log)
+          executionLog.destroy()
+          executionLog = createLog({ newLine: "around" })
         }
       }
-
-      if (fileRelativeUrl in report === false) {
-        report[fileRelativeUrl] = {}
-      }
-      report[fileRelativeUrl][executionName] = executionResult
-      previousExecutionResult = executionResult
     },
   })
 
@@ -281,7 +293,7 @@ export const executeConcurrently = async (
       executionsDone.length -
       // we substract abortedCount because they are not pushed into executionsDone
       summaryCounts.abortedCount,
-    ...(measureGlobalDuration ? { startMs, endMs: Date.now() } : {}),
+    duration: Date.now() - startMs,
   }
   if (logSummary) {
     logger.info(createSummaryLog(summary))
@@ -293,11 +305,36 @@ export const executeConcurrently = async (
   })
 }
 
+const canOverwriteLogGetter = ({
+  completedExecutionLogMerging,
+  executionResult,
+}) => {
+  if (!completedExecutionLogMerging) {
+    return false
+  }
+
+  if (executionResult.status === "aborted") {
+    return true
+  }
+
+  if (executionResult.status !== "completed") {
+    return false
+  }
+
+  const { consoleCalls = [] } = executionResult
+  if (consoleCalls.length > 0) {
+    return false
+  }
+
+  return true
+}
+
 const executeInParallel = async ({
   multipleExecutionsOperation,
   executionSteps,
   start,
   maxExecutionsInParallel = 1,
+  cooldownBetweenExecutions,
 }) => {
   const executionResults = []
   let progressionIndex = 0
@@ -333,6 +370,11 @@ const executeInParallel = async ({
     if (!multipleExecutionsOperation.signal.aborted) {
       executionResults[index] = output
     }
+    if (cooldownBetweenExecutions) {
+      await new Promise((resolve) =>
+        setTimeout(resolve, cooldownBetweenExecutions),
+      )
+    }
   }
 
   await nextChunk()
@@ -340,22 +382,6 @@ const executeInParallel = async ({
   return executionResults
 }
 
-const pathLeadsToFile = (path) => {
-  return new Promise((resolve, reject) => {
-    stat(path, (error, stats) => {
-      if (error) {
-        if (error.code === "ENOENT") {
-          resolve(false)
-        } else {
-          reject(error)
-        }
-      } else {
-        resolve(stats.isFile())
-      }
-    })
-  })
-}
-
 const reportToSummary = (report) => {
   const fileNames = Object.keys(report)
 

package/src/internal/executing/executePlan.js

@@ -25,10 +25,10 @@ export const executePlan = async (
 
     defaultMsAllocatedPerExecution,
     maxExecutionsInParallel,
+    cooldownBetweenExecutions,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
     logSummary,
-    measureGlobalDuration,
 
     coverage,
     coverageConfig,
@@ -82,7 +82,6 @@ export const executePlan = async (
           SIGINT: true,
         },
         () => {
-          logger.info("Aborting execution (SIGINT)")
           abort()
         },
       )
@@ -148,10 +147,10 @@ export const executePlan = async (
 
       defaultMsAllocatedPerExecution,
       maxExecutionsInParallel,
+      cooldownBetweenExecutions,
       completedExecutionLogMerging,
       completedExecutionLogAbbreviation,
       logSummary,
-      measureGlobalDuration,
 
       coverage,
       coverageConfig,
@@ -163,6 +162,7 @@ export const executePlan = async (
     })
 
     return {
+      aborted: multipleExecutionsOperation.signal.aborted,
       planSummary: result.summary,
       planReport: result.report,
       planCoverage: result.coverage,

package/src/internal/executing/executionLogs.js

@@ -4,8 +4,40 @@ import { msAsDuration } from "../logs/msAsDuration.js"
 import { EXECUTION_COLORS } from "./execution_colors.js"
 import { createSummaryDetails } from "./createSummaryLog.js"
 
-export const createExecutionResultLog = (
-  { executionIndex, fileRelativeUrl, executionParams, executionResult },
+export const formatExecuting = (
+  { executionIndex },
+  { executionCount, abortedCount, timedoutCount, erroredCount, completedCount },
+) => {
+  const executionNumber = executionIndex + 1
+  const description = ANSI.color(
+    `executing ${executionNumber} of ${executionCount}`,
+    EXECUTION_COLORS.executing,
+  )
+  const summary =
+    executionIndex === 0
+      ? ""
+      : `(${createSummaryDetails({
+          executionCount: executionIndex,
+          abortedCount,
+          timedoutCount,
+          erroredCount,
+          completedCount,
+        })})`
+
+  return formatExecution({
+    label: `${description} ${summary}`,
+  })
+}
+
+export const formatExecutionResult = (
+  {
+    executionIndex,
+    fileRelativeUrl,
+    runtimeName,
+    runtimeVersion,
+    executionParams,
+    executionResult,
+  },
   {
     completedExecutionLogAbbreviation,
     executionCount,
@@ -24,6 +56,7 @@ export const createExecutionResultLog = (
     executionCount,
     allocatedMs,
   })
+
   const summary = `(${createSummaryDetails({
     executionCount: executionNumber,
     abortedCount,
@@ -33,21 +66,22 @@ export const createExecutionResultLog = (
   })})`
 
   if (completedExecutionLogAbbreviation && status === "completed") {
-    return `
-${description} ${summary}`
+    return `${description} ${summary}`
   }
 
-  const { runtimeName, runtimeVersion, consoleCalls, startMs, endMs, error } =
-    executionResult
-
-  const runtime = `${runtimeName}/${runtimeVersion}`
-  return `
-${description} ${summary}
-file: ${fileRelativeUrl}
-runtime: ${runtime}${appendDuration({
-    startMs,
-    endMs,
-  })}${appendConsole(consoleCalls)}${appendError(error)}`
+  const { consoleCalls = [], error, duration } = executionResult
+  const console = formatConsoleCalls(consoleCalls)
+
+  return formatExecution({
+    label: `${description} ${summary}`,
+    details: {
+      file: fileRelativeUrl,
+      runtime: `${runtimeName}/${runtimeVersion}`,
+      duration: msAsDuration(duration),
+      ...(error ? { error: error.stack } : {}),
+    },
+    console,
+  })
 }
 
 const descriptionFormatters = {
@@ -83,38 +117,33 @@ const descriptionFormatters = {
   },
 }
 
-const appendDuration = ({ endMs, startMs }) => {
-  if (!endMs) return ""
-
-  return `
-duration: ${msAsDuration(endMs - startMs)}`
-}
-
-const appendConsole = (consoleCalls) => {
-  if (!consoleCalls || consoleCalls.length === 0) return ""
-
+const formatConsoleCalls = (consoleCalls) => {
   const consoleOutput = consoleCalls.reduce((previous, { text }) => {
     return `${previous}${text}`
   }, "")
 
   const consoleOutputTrimmed = consoleOutput.trim()
-  if (consoleOutputTrimmed === "") return ""
+  if (consoleOutputTrimmed === "") {
+    return ""
+  }
 
-  return `
-${ANSI.color(`-------- console --------`, ANSI.GREY)}
+  return `${ANSI.color(`-------- console --------`, ANSI.GREY)}
 ${consoleOutputTrimmed}
 ${ANSI.color(`-------------------------`, ANSI.GREY)}`
 }
 
-const appendError = (error) => {
-  if (!error) {
-    return ``
+const formatExecution = ({ label, details = {}, console }) => {
+  let message = ``
+
+  message += label
+  Object.keys(details).forEach((key) => {
+    message += `
+${key}: ${details[key]}`
+  })
+  if (console) {
+    message += `
+${console}`
   }
 
-  return `
-error: ${error.stack}`
+  return message
 }
-
-// export const createShortExecutionResultLog = () => {
-//   return `Execution completed (2/9) - (all completed)`
-// }

package/src/internal/executing/execution_colors.js

@@ -1,8 +1,9 @@
 import { ANSI } from "@jsenv/log"
 
 export const EXECUTION_COLORS = {
+  executing: ANSI.BLUE,
   aborted: ANSI.MAGENTA,
-  timedout: ANSI.YELLOW,
+  timedout: ANSI.MAGENTA,
   errored: ANSI.RED,
   completed: ANSI.GREEN,
   cancelled: ANSI.GREY,

package/src/internal/executing/launchAndExecute.js

@@ -14,11 +14,8 @@ export const launchAndExecute = async ({
   executeParams,
 
   allocatedMs,
-  measureDuration = false,
   mirrorConsole = false,
   captureConsole = false, // rename collectConsole ?
-  collectRuntimeName = false,
-  collectRuntimeVersion = false,
   inheritCoverage = false,
   collectCoverage = false,
   coverageTempDirectoryUrl,
@@ -102,25 +99,14 @@ export const launchAndExecute = async ({
     )
   }
 
-  if (collectRuntimeName) {
-    executionResultTransformer = composeTransformer(
-      executionResultTransformer,
-      (executionResult) => {
-        executionResult.runtimeName = runtime.name
-        return executionResult
-      },
-    )
-  }
-
-  if (collectRuntimeVersion) {
-    executionResultTransformer = composeTransformer(
-      executionResultTransformer,
-      (executionResult) => {
-        executionResult.runtimeVersion = runtime.version
-        return executionResult
-      },
-    )
-  }
+  executionResultTransformer = composeTransformer(
+    executionResultTransformer,
+    (executionResult) => {
+      executionResult.runtimeName = runtime.name
+      executionResult.runtimeVersion = runtime.version
+      return executionResult
+    },
+  )
 
   if (
     inheritCoverage &&
@@ -204,18 +190,14 @@ export const launchAndExecute = async ({
     )
   }
 
-  if (measureDuration) {
-    const startMs = Date.now()
-    executionResultTransformer = composeTransformer(
-      executionResultTransformer,
-      (executionResult) => {
-        const endMs = Date.now()
-        executionResult.startMs = startMs
-        executionResult.endMs = endMs
-        return executionResult
-      },
-    )
-  }
+  const startMs = Date.now()
+  executionResultTransformer = composeTransformer(
+    executionResultTransformer,
+    (executionResult) => {
+      executionResult.duration = Date.now() - startMs
+      return executionResult
+    },
+  )
 
   try {
     const runtimeLabel = `${runtime.name}/${runtime.version}`

package/src/internal/logs/msAsDuration.js

@@ -2,10 +2,11 @@ import { require } from "../require.js"
 
 const humanizeDuration = require("humanize-duration")
 
-export const msAsDuration = (metricValue) => {
-  return humanizeDuration(metricValue, {
+export const msAsDuration = (ms) => {
+  return humanizeDuration(ms, {
     largest: 2,
-    maxDecimalPoints: metricValue < 0.1 ? 3 : metricValue < 1000 ? 2 : 1,
+    maxDecimalPoints: ms < 0.1 ? 3 : ms < 1000 ? 2 : ms < 60000 ? 1 : 0,
+    delimiter: " and ",
     // units: ["s"]
   })
 }