@jsenv/core 27.0.3 → 27.2.1

package/src/test/execute_plan.js

@@ -1,10 +1,9 @@
 import { existsSync } from "node:fs"
 import { memoryUsage } from "node:process"
+import { takeCoverage } from "node:v8"
 import wrapAnsi from "wrap-ansi"
 import stripAnsi from "strip-ansi"
-import cuid from "cuid"
 
-import { URL_META } from "@jsenv/url-meta"
 import { urlToFileSystemPath } from "@jsenv/urls"
 import {
   createDetailedMessage,
@@ -13,11 +12,7 @@ import {
   startSpinner,
 } from "@jsenv/log"
 import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
-import {
-  writeDirectory,
-  ensureEmptyDirectory,
-  writeFileSync,
-} from "@jsenv/filesystem"
+import { ensureEmptyDirectory, writeFileSync } from "@jsenv/filesystem"
 
 import { babelPluginInstrument } from "./coverage/babel_plugin_instrument.js"
 import { reportToCoverage } from "./coverage/report_to_coverage.js"
@@ -37,6 +32,8 @@ export const executePlan = async (
     signal,
     handleSIGINT,
     logger,
+    logRuntime,
+    logEachDuration,
     logSummary,
     logTimeUsage,
     logMemoryHeapUsage,
@@ -52,10 +49,11 @@ export const executePlan = async (
     gcBetweenExecutions,
     cooldownBetweenExecutions,
 
-    coverage,
+    coverageEnabled,
     coverageConfig,
     coverageIncludeMissing,
-    coverageForceIstanbul,
+    coverageMethodForBrowsers,
+    coverageMethodForNodeJs,
     coverageV8ConflictWarning,
     coverageTempDirectoryRelativeUrl,
 
@@ -77,9 +75,13 @@ export const executePlan = async (
     afterExecutionCallback = () => {},
   } = {},
 ) => {
+  const executePlanReturnValue = {}
+  const report = {}
+  const callbacks = []
   const stopAfterAllSignal = { notify: () => {} }
 
   let someNeedsServer = false
+  let someNodeRuntime = false
   const runtimes = {}
   Object.keys(plan).forEach((filePattern) => {
     const filePlan = plan[filePattern]
@@ -91,6 +93,9 @@ export const executePlan = async (
         if (runtime.needsServer) {
           someNeedsServer = true
         }
+        if (runtime.type === "node") {
+          someNodeRuntime = true
+        }
       }
     })
   })
@@ -120,10 +125,76 @@ export const executePlan = async (
   }
 
   try {
+    const coverageTempDirectoryUrl = new URL(
+      coverageTempDirectoryRelativeUrl,
+      rootDirectoryUrl,
+    ).href
+    if (
+      someNodeRuntime &&
+      coverageEnabled &&
+      coverageMethodForNodeJs === "NODE_V8_COVERAGE"
+    ) {
+      if (process.env.NODE_V8_COVERAGE) {
+        // when runned multiple times, we don't want to keep previous files in this directory
+        await ensureEmptyDirectory(process.env.NODE_V8_COVERAGE)
+      } else {
+        coverageMethodForNodeJs = "Profiler"
+        logger.warn(
+          createDetailedMessage(
+            `process.env.NODE_V8_COVERAGE is required to generate coverage for Node.js subprocesses`,
+            {
+              "suggestion": `Preprend NODE_V8_COVERAGE=.coverage/node to the command executing this process`,
+              "suggestion 2": `use coverageMethodForNodeJs: "Profiler". But it means coverage for child_process and worker_thread cannot be collected`,
+            },
+          ),
+        )
+      }
+    }
+
+    if (gcBetweenExecutions) {
+      ensureGlobalGc()
+    }
+
+    if (coverageEnabled) {
+      // when runned multiple times, we don't want to keep previous files in this directory
+      await ensureEmptyDirectory(coverageTempDirectoryUrl)
+      callbacks.push(async () => {
+        if (multipleExecutionsOperation.signal.aborted) {
+          // don't try to do the coverage stuff
+          return
+        }
+        try {
+          if (coverageMethodForNodeJs === "NODE_V8_COVERAGE") {
+            takeCoverage()
+            // conceptually we don't need coverage anymore so it would be
+            // good to call v8.stopCoverage()
+            // but it logs a strange message about "result is not an object"
+          }
+          const planCoverage = await reportToCoverage(report, {
+            signal: multipleExecutionsOperation.signal,
+            logger,
+            rootDirectoryUrl,
+            coverageConfig,
+            coverageIncludeMissing,
+            coverageMethodForBrowsers,
+            coverageV8ConflictWarning,
+          })
+          executePlanReturnValue.planCoverage = planCoverage
+        } catch (e) {
+          if (Abort.isAbortError(e)) {
+            return
+          }
+          throw e
+        }
+      })
+    }
+
     let runtimeParams = {
       rootDirectoryUrl,
-      collectCoverage: coverage,
-      coverageForceIstanbul,
+      coverageEnabled,
+      coverageConfig,
+      coverageMethodForBrowsers,
+      coverageMethodForNodeJs,
       stopAfterAllSignal,
     }
     if (someNeedsServer) {
@@ -152,7 +223,7 @@ export const executePlan = async (
               ...transpilation,
               getCustomBabelPlugins: ({ clientRuntimeCompat }) => {
                 if (
-                  coverage &&
+                  coverageEnabled &&
                   Object.keys(clientRuntimeCompat)[0] !== "chrome"
                 ) {
                   return {
@@ -219,76 +290,8 @@ export const executePlan = async (
       process.exitCode !== 1
 
     const startMs = Date.now()
-    const report = {}
     let rawOutput = ""
 
-    let transformReturnValue = (value) => value
-    if (gcBetweenExecutions) {
-      ensureGlobalGc()
-    }
-
-    const coverageTempDirectoryUrl = new URL(
-      coverageTempDirectoryRelativeUrl,
-      rootDirectoryUrl,
-    ).href
-
-    if (coverage) {
-      const associations = URL_META.resolveAssociations(
-        { cover: coverageConfig },
-        rootDirectoryUrl,
-      )
-      const urlShouldBeCovered = (url) => {
-        const { cover } = URL_META.applyAssociations({
-          url: new URL(url, rootDirectoryUrl).href,
-          associations,
-        })
-        return cover
-      }
-      runtimeParams.urlShouldBeCovered = urlShouldBeCovered
-
-      // in case runned multiple times, we don't want to keep writing lot of files in this directory
-      if (!process.env.NODE_V8_COVERAGE) {
-        await ensureEmptyDirectory(coverageTempDirectoryUrl)
-      }
-      if (runtimes.node) {
-        // v8 coverage is written in a directoy and auto propagate to subprocesses
-        // through process.env.NODE_V8_COVERAGE.
-        if (!coverageForceIstanbul && !process.env.NODE_V8_COVERAGE) {
-          const v8CoverageDirectory = new URL(
-            `./node_v8/${cuid()}`,
-            coverageTempDirectoryUrl,
-          ).href
-          await writeDirectory(v8CoverageDirectory, { allowUseless: true })
-          process.env.NODE_V8_COVERAGE =
-            urlToFileSystemPath(v8CoverageDirectory)
-        }
-      }
-      transformReturnValue = async (value) => {
-        if (multipleExecutionsOperation.signal.aborted) {
-          // don't try to do the coverage stuff
-          return value
-        }
-        try {
-          value.coverage = await reportToCoverage(value.report, {
-            signal: multipleExecutionsOperation.signal,
-            logger,
-            rootDirectoryUrl,
-            coverageConfig,
-            coverageIncludeMissing,
-            coverageForceIstanbul,
-            urlShouldBeCovered,
-            coverageV8ConflictWarning,
-          })
-        } catch (e) {
-          if (Abort.isAbortError(e)) {
-            return value
-          }
-          throw e
-        }
-        return value
-      }
-    }
-
     logger.info("")
     let executionLog = createLog({ newLine: "" })
     const counters = {
@@ -307,6 +310,7 @@ export const executePlan = async (
       start: async (paramsFromStep) => {
         const executionIndex = executionSteps.indexOf(paramsFromStep)
         const { executionName, fileRelativeUrl, runtime } = paramsFromStep
+        const runtimeType = runtime.type
         const runtimeName = runtime.name
         const runtimeVersion = runtime.version
         const executionParams = {
@@ -322,6 +326,7 @@ export const executePlan = async (
         }
         const beforeExecutionInfo = {
           fileRelativeUrl,
+          runtimeType,
           runtimeName,
           runtimeVersion,
           executionIndex,
@@ -338,6 +343,8 @@ export const executePlan = async (
             render: () => {
               return createExecutionLog(beforeExecutionInfo, {
                 counters,
+                logRuntime,
+                logEachDuration,
                 ...(logTimeUsage
                   ? {
                       timeEllapsed: Date.now() - startMs,
@@ -362,7 +369,7 @@ export const executePlan = async (
             keepRunning,
             mirrorConsole: false, // file are executed in parallel, log would be a mess to read
             collectConsole: executionParams.collectConsole,
-            collectCoverage: coverage,
+            coverageEnabled,
             coverageTempDirectoryUrl,
             runtime: executionParams.runtime,
             runtimeParams: {
@@ -411,6 +418,8 @@ export const executePlan = async (
           let log = createExecutionLog(afterExecutionInfo, {
             completedExecutionLogAbbreviation,
             counters,
+            logRuntime,
+            logEachDuration,
             ...(logTimeUsage
               ? {
                   timeEllapsed: Date.now() - startMs,
@@ -477,16 +486,14 @@ export const executePlan = async (
       writeFileSync(logFileUrl, rawOutput)
       logger.info(`-> ${urlToFileSystemPath(logFileUrl)}`)
     }
-    const result = await transformReturnValue({
-      summary,
-      report,
-    })
-    return {
-      aborted: multipleExecutionsOperation.signal.aborted,
-      planSummary: result.summary,
-      planReport: result.report,
-      planCoverage: result.coverage,
-    }
+    executePlanReturnValue.aborted = multipleExecutionsOperation.signal.aborted
+    executePlanReturnValue.planSummary = summary
+    executePlanReturnValue.planReport = report
+    await callbacks.reduce(async (previous, callback) => {
+      await previous
+      await callback()
+    }, Promise.resolve())
+    return executePlanReturnValue
   } finally {
     await multipleExecutionsOperation.end()
   }

package/src/test/execute_test_plan.js

@@ -28,7 +28,7 @@ import { executePlan } from "./execute_plan.js"
  * @param {boolean} [testPlanParameters.failFast=false] Fails immediatly when a test execution fails
  * @param {number} [testPlanParameters.cooldownBetweenExecutions=0] Millisecond to wait between each execution
  * @param {boolean} [testPlanParameters.logMemoryHeapUsage=false] Add memory heap usage during logs
- * @param {boolean} [testPlanParameters.coverage=false] Controls if coverage is collected during files executions
+ * @param {boolean} [testPlanParameters.coverageEnabled=false] Controls if coverage is collected during files executions
  * @param {boolean} [testPlanParameters.coverageV8ConflictWarning=true] Warn when coverage from 2 executions cannot be merged
  * @return {Object} An object containing the result of all file executions
  */
@@ -36,6 +36,8 @@ export const executeTestPlan = async ({
   signal = new AbortController().signal,
   handleSIGINT = true,
   logLevel = "info",
+  logRuntime = true,
+  logEachDuration = true,
   logSummary = true,
   logTimeUsage = false,
   logMemoryHeapUsage = false,
@@ -58,23 +60,24 @@ export const executeTestPlan = async ({
   cooldownBetweenExecutions = 0,
   gcBetweenExecutions = logMemoryHeapUsage,
 
-  coverage = process.argv.includes("--cover") ||
+  coverageEnabled = process.argv.includes("--cover") ||
     process.argv.includes("--coverage"),
-  coverageTempDirectoryRelativeUrl = "./.coverage/tmp/",
   coverageConfig = {
     "./src/": true,
   },
   coverageIncludeMissing = true,
   coverageAndExecutionAllowed = false,
-  coverageForceIstanbul = false,
+  coverageMethodForNodeJs = "NODE_V8_COVERAGE", // "Profiler" also accepted
+  coverageMethodForBrowsers = "playwright_api", // "istanbul" also accepted
   coverageV8ConflictWarning = true,
-  coverageReportTextLog = true,
-  coverageReportJsonFile = process.env.CI ? null : "./.coverage/coverage.json",
-  coverageReportHtmlDirectory = process.env.CI ? "./.coverage/" : null,
+  coverageTempDirectoryRelativeUrl = "./.coverage/tmp/",
   // skip empty means empty files won't appear in the coverage reports (json and html)
   coverageReportSkipEmpty = false,
   // skip full means file with 100% coverage won't appear in coverage reports (json and html)
   coverageReportSkipFull = false,
+  coverageReportTextLog = true,
+  coverageReportJsonFile = process.env.CI ? null : "./.coverage/coverage.json",
+  coverageReportHtmlDirectory = process.env.CI ? "./.coverage/" : null,
 
   sourcemaps = "inline",
   plugins = [],
@@ -93,7 +96,7 @@ export const executeTestPlan = async ({
   if (typeof testPlan !== "object") {
     throw new Error(`testPlan must be an object, got ${testPlan}`)
   }
-  if (coverage) {
+  if (coverageEnabled) {
     if (typeof coverageConfig !== "object") {
       throw new TypeError(
         `coverageConfig must be an object, got ${coverageConfig}`,
@@ -138,6 +141,8 @@ export const executeTestPlan = async ({
     logger,
     logLevel,
     logSummary,
+    logRuntime,
+    logEachDuration,
     logTimeUsage,
     logMemoryHeapUsage,
     logFileRelativeUrl,
@@ -152,10 +157,11 @@ export const executeTestPlan = async ({
     cooldownBetweenExecutions,
     gcBetweenExecutions,
 
-    coverage,
+    coverageEnabled,
     coverageConfig,
     coverageIncludeMissing,
-    coverageForceIstanbul,
+    coverageMethodForBrowsers,
+    coverageMethodForNodeJs,
     coverageV8ConflictWarning,
     coverageTempDirectoryRelativeUrl,
 
@@ -185,7 +191,7 @@ export const executeTestPlan = async ({
     // keep this one first because it does ensureEmptyDirectory
     // and in case coverage json file gets written in the same directory
     // it must be done before
-    if (coverage && coverageReportHtmlDirectory) {
+    if (coverageEnabled && coverageReportHtmlDirectory) {
       const coverageHtmlDirectoryUrl = resolveDirectoryUrl(
         coverageReportHtmlDirectory,
         rootDirectoryUrl,
@@ -212,7 +218,7 @@ export const executeTestPlan = async ({
         }),
       )
     }
-    if (coverage && coverageReportJsonFile) {
+    if (coverageEnabled && coverageReportJsonFile) {
       const coverageJsonFileUrl = new URL(
         coverageReportJsonFile,
         rootDirectoryUrl,
@@ -225,7 +231,7 @@ export const executeTestPlan = async ({
         }),
       )
     }
-    if (coverage && coverageReportTextLog) {
+    if (coverageEnabled && coverageReportTextLog) {
       promises.push(
         generateCoverageTextLog(result.planCoverage, {
           coverageReportSkipEmpty,

package/src/test/logs_file_execution.js

@@ -19,7 +19,14 @@ export const createExecutionLog = (
     startMs,
     endMs,
   },
-  { completedExecutionLogAbbreviation, counters, timeEllapsed, memoryHeap },
+  {
+    completedExecutionLogAbbreviation,
+    counters,
+    logRuntime,
+    logEachDuration,
+    timeEllapsed,
+    memoryHeap,
+  },
 ) => {
   const { status } = executionResult
   const descriptionFormatter = descriptionFormatters[status]
@@ -43,11 +50,15 @@ export const createExecutionLog = (
     label: `${description}${summary}`,
     details: {
       file: fileRelativeUrl,
-      runtime: `${runtimeName}/${runtimeVersion}`,
-      duration:
-        status === "executing"
-          ? msAsEllapsedTime(Date.now() - startMs)
-          : msAsDuration(endMs - startMs),
+      ...(logRuntime ? { runtime: `${runtimeName}/${runtimeVersion}` } : {}),
+      ...(logEachDuration
+        ? {
+            duration:
+              status === "executing"
+                ? msAsEllapsedTime(Date.now() - startMs)
+                : msAsDuration(endMs - startMs),
+          }
+        : {}),
       ...(error ? { error: error.stack || error.message || error } : {}),
     },
     consoleOutput,
@@ -203,18 +214,84 @@ const descriptionFormatters = {
 }
 
 const formatConsoleCalls = (consoleCalls) => {
-  const consoleOutput = consoleCalls.reduce((previous, { text }) => {
-    return `${previous}${text}`
-  }, "")
-  const consoleOutputTrimmed = consoleOutput.trim()
-  if (consoleOutputTrimmed === "") {
+  if (consoleCalls.length === 0) {
     return ""
   }
-  return `${ANSI.color(`-------- console output --------`, ANSI.GREY)}
-${consoleOutputTrimmed}
+
+  const repartition = {
+    debug: 0,
+    info: 0,
+    warning: 0,
+    error: 0,
+    log: 0,
+  }
+  let consoleOutput = ``
+  consoleCalls.forEach((consoleCall) => {
+    repartition[consoleCall.type]++
+    const text = consoleCall.text
+    const textFormatted = prefixFirstAndIndentRemainingLines({
+      prefix: CONSOLE_ICONS[consoleCall.type],
+      text,
+      trimLastLine: consoleCall === consoleCalls[consoleCalls.length - 1],
+    })
+    consoleOutput += textFormatted
+  })
+
+  return `${ANSI.color(
+    `-------- ${formatConsoleSummary(repartition)} --------`,
+    ANSI.GREY,
+  )}
+${consoleOutput}
 ${ANSI.color(`-------------------------`, ANSI.GREY)}`
 }
 
+const CONSOLE_ICONS = {
+  debug: UNICODE.DEBUG,
+  info: UNICODE.INFO,
+  warning: UNICODE.WARNING,
+  error: UNICODE.FAILURE,
+  log: " ",
+}
+
+const formatConsoleSummary = (repartition) => {
+  const { debug, info, warning, error } = repartition
+  const parts = []
+  if (error) {
+    parts.push(`${CONSOLE_ICONS.error} ${error}`)
+  }
+  if (warning) {
+    parts.push(`${CONSOLE_ICONS.warning} ${warning}`)
+  }
+  if (info) {
+    parts.push(`${CONSOLE_ICONS.info} ${info}`)
+  }
+  if (debug) {
+    parts.push(`${CONSOLE_ICONS.debug} ${debug}`)
+  }
+  if (parts.length === 0) {
+    return `console`
+  }
+  return `console (${parts.join(" ")})`
+}
+
+const prefixFirstAndIndentRemainingLines = ({ prefix, text, trimLastLine }) => {
+  const lines = text.split(/\r?\n/)
+  const firstLine = lines.shift()
+  let result = `${prefix} ${firstLine}`
+  let i = 0
+  const indentation = `  `
+  while (i < lines.length) {
+    const line = lines[i].trim()
+    i++
+    result += line.length
+      ? `\n${indentation}${line}`
+      : trimLastLine && i === lines.length
+      ? ""
+      : `\n`
+  }
+  return result
+}
+
 const formatExecution = ({ label, details = {}, consoleOutput }) => {
   let message = ``
   message += label