@jsenv/core 23.3.0 → 23.4.0

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

@@ -0,0 +1,59 @@
+import {
+  assertAndNormalizeDirectoryUrl,
+  readDirectory,
+  readFile,
+  resolveUrl,
+} from "@jsenv/filesystem"
+import { createDetailedMessage } from "@jsenv/logger"
+
+export const visitNodeV8Directory = async ({
+  // signal
+  NODE_V8_COVERAGE,
+  onV8Coverage,
+}) => {
+  const tryReadDirectory = async () => {
+    const dirContent = await readDirectory(NODE_V8_COVERAGE)
+    if (dirContent.length > 0) {
+      return dirContent
+    }
+    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
+
+    const dirEntryUrl = resolveUrl(dirEntry, coverageDirectoryUrl)
+    const tryReadJsonFile = async () => {
+      try {
+        const fileContent = await readFile(dirEntryUrl, { as: "json" })
+        return fileContent
+      } 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())
+}
+
+export const filterV8Coverage = (v8Coverage, { coverageIgnorePredicate }) => {
+  const v8CoverageFiltered = {
+    ...v8Coverage,
+    result: v8Coverage.result.filter((fileReport) => {
+      return !coverageIgnorePredicate(fileReport.url)
+    }),
+  }
+  return v8CoverageFiltered
+}

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

@@ -0,0 +1,90 @@
+import { urlToFileSystemPath } from "@jsenv/filesystem"
+
+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
+
+    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)
+
+    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()
+
+    converter.applyCoverage(fileV8Coverage.functions)
+    const istanbulCoverage = converter.toIstanbul()
+
+    istanbulCoverageComposed = istanbulCoverageComposed
+      ? composeTwoFileByFileIstanbulCoverages(
+          istanbulCoverageComposed,
+          istanbulCoverage,
+        )
+      : istanbulCoverage
+  }, Promise.resolve())
+
+  if (!istanbulCoverageComposed) {
+    return {}
+  }
+  istanbulCoverageComposed = markAsConvertedFromV8(istanbulCoverageComposed)
+  return istanbulCoverageComposed
+}
+
+const markAsConvertedFromV8 = (fileByFileCoverage) => {
+  const fileByFileMarked = {}
+  Object.keys(fileByFileCoverage).forEach((key) => {
+    const fileCoverage = fileByFileCoverage[key]
+    fileByFileMarked[key] = {
+      ...fileCoverage,
+      fromV8: true,
+    }
+  })
+  return fileByFileMarked
+}
+
+const sourcesFromSourceMapCache = (url, sourceMapCache) => {
+  const sourceMapAndLineLengths = sourceMapCache[url]
+  if (!sourceMapAndLineLengths) {
+    return {}
+  }
+
+  const { data, lineLengths } = sourceMapAndLineLengths
+  // See: https://github.com/nodejs/node/pull/34305
+  if (!data) {
+    return undefined
+  }
+
+  const sources = {
+    sourcemap: data,
+    ...(lineLengths ? { source: sourcesFromLineLengths(lineLengths) } : {}),
+  }
+  return sources
+}
+
+const sourcesFromLineLengths = (lineLengths) => {
+  let source = ""
+  lineLengths.forEach((length) => {
+    source += `${"".padEnd(length, ".")}\n`
+  })
+  return source
+}

package/src/internal/executing/createSummaryLog.js

@@ -21,7 +21,9 @@ const createSummaryMessage = ({
     return `no execution`
   }
 
-  return `${executionCount} execution: ${createSummaryDetails({
+  const executionLabel =
+    executionCount === 1 ? `1 execution` : `${executionCount} executions`
+  return `${executionLabel}: ${createSummaryDetails({
     executionCount,
     abortedCount,
     timedoutCount,

package/src/internal/executing/executeConcurrently.js

@@ -1,8 +1,17 @@
 import { stat } from "node:fs"
 import wrapAnsi from "wrap-ansi"
+import cuid from "cuid"
 import { loggerToLevels, createDetailedMessage } from "@jsenv/logger"
-import { urlToFileSystemPath } from "@jsenv/filesystem"
+import {
+  urlToFileSystemPath,
+  resolveUrl,
+  writeDirectory,
+  ensureEmptyDirectory,
+  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"
@@ -33,7 +42,9 @@ export const executeConcurrently = async (
     coverageConfig,
     coverageIncludeMissing,
     coverageForceIstanbul,
-    coverageV8MergeConflictIsExpected,
+    coverageV8ConflictWarning,
+    coverageTempDirectoryRelativeUrl,
+    runtimeSupport,
 
     mainFileNotFoundCallback = ({ fileRelativeUrl }) => {
       logger.error(
@@ -55,6 +66,73 @@ export const executeConcurrently = async (
   const report = {}
   const executionCount = executionSteps.length
 
+  let transformReturnValue = (value) => value
+
+  const coverageTempDirectoryUrl = resolveUrl(
+    coverageTempDirectoryRelativeUrl,
+    projectDirectoryUrl,
+  )
+
+  const structuredMetaMapForCover = normalizeStructuredMetaMap(
+    {
+      cover: coverageConfig,
+    },
+    projectDirectoryUrl,
+  )
+  const coverageIgnorePredicate = (url) => {
+    return !urlToMeta({
+      url: resolveUrl(url, projectDirectoryUrl),
+      structuredMetaMap: structuredMetaMapForCover,
+    }).cover
+  }
+
+  if (coverage) {
+    // 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 (runtimeSupport.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 = resolveUrl(
+          `./node_v8/${cuid()}`,
+          coverageTempDirectoryUrl,
+        )
+        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, {
+          multipleExecutionsOperation,
+          logger,
+          projectDirectoryUrl,
+          babelPluginMap,
+          coverageConfig,
+          coverageIncludeMissing,
+          coverageForceIstanbul,
+          coverageIgnorePredicate,
+          coverageV8ConflictWarning,
+        })
+      } catch (e) {
+        if (Abort.isAbortError(e)) {
+          return value
+        }
+        throw e
+      }
+      return value
+    }
+  }
+
   let previousExecutionResult
   let previousExecutionLog
   let abortedCount = 0
@@ -116,12 +194,13 @@ export const executeConcurrently = async (
 
         ...executionParams,
         collectCoverage: coverage,
+        coverageTempDirectoryUrl,
         runtimeParams: {
           projectDirectoryUrl,
           compileServerOrigin,
           outDirectoryRelativeUrl,
           collectCoverage: coverage,
-          coverageConfig,
+          coverageIgnorePredicate,
           coverageForceIstanbul,
           ...executionParams.runtimeParams,
         },
@@ -129,7 +208,7 @@ export const executeConcurrently = async (
           fileRelativeUrl,
           ...executionParams.executeParams,
         },
-        coverageV8MergeConflictIsExpected,
+        coverageV8ConflictWarning,
       })
       const afterExecutionInfo = {
         ...beforeExecutionInfo,
@@ -208,31 +287,10 @@ export const executeConcurrently = async (
     logger.info(createSummaryLog(summary))
   }
 
-  if (multipleExecutionsOperation.signal.aborted) {
-    // don't try to do the coverage stuff
-    return {
-      summary,
-      report,
-    }
-  }
-
-  return {
+  return transformReturnValue({
     summary,
     report,
-    ...(coverage
-      ? {
-          coverage: await reportToCoverage(report, {
-            multipleExecutionsOperation,
-            logger,
-            projectDirectoryUrl,
-            babelPluginMap,
-            coverageConfig,
-            coverageIncludeMissing,
-            coverageV8MergeConflictIsExpected,
-          }),
-        }
-      : {}),
-  }
+  })
 }
 
 const executeInParallel = async ({

package/src/internal/executing/executePlan.js

@@ -34,7 +34,8 @@ export const executePlan = async (
     coverageConfig,
     coverageIncludeMissing,
     coverageForceIstanbul,
-    coverageV8MergeConflictIsExpected,
+    coverageV8ConflictWarning,
+    coverageTempDirectoryRelativeUrl,
 
     compileServerProtocol,
     compileServerPrivateKey,
@@ -156,7 +157,9 @@ export const executePlan = async (
       coverageConfig,
       coverageIncludeMissing,
       coverageForceIstanbul,
-      coverageV8MergeConflictIsExpected,
+      coverageV8ConflictWarning,
+      coverageTempDirectoryRelativeUrl,
+      runtimeSupport,
     })
 
     return {

package/src/internal/executing/launchAndExecute.js

@@ -1,7 +1,9 @@
+import cuid from "cuid"
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
 import { Abort, raceCallbacks } from "@jsenv/abort"
+import { resolveUrl, writeFile } from "@jsenv/filesystem"
 
-import { composeIstanbulCoverages } from "./coverage/composeIstanbulCoverages.js"
+import { composeTwoFileByFileIstanbulCoverages } from "./coverage_utils/istanbul_coverage_composition.js"
 
 export const launchAndExecute = async ({
   signal = new AbortController().signal,
@@ -19,6 +21,7 @@ export const launchAndExecute = async ({
   collectRuntimeVersion = false,
   inheritCoverage = false,
   collectCoverage = false,
+  coverageTempDirectoryUrl,
   measurePerformance,
   collectPerformance = false,
 
@@ -39,8 +42,6 @@ export const launchAndExecute = async ({
     // by default throw on error after execution
     throw error
   },
-
-  coverageV8MergeConflictIsExpected,
 } = {}) => {
   const logger = createLogger({ logLevel: launchAndExecuteLogLevel })
 
@@ -131,40 +132,61 @@ export const launchAndExecute = async ({
     executionResultTransformer = composeTransformer(
       executionResultTransformer,
       (executionResult) => {
-        const { coverage, ...rest } = executionResult
-        // ensure the coverage of the executed file is taken into account
-        global.__coverage__ = composeIstanbulCoverages([
+        const { coverage } = executionResult
+        // propagate coverage from execution to this process
+        global.__coverage__ = composeTwoFileByFileIstanbulCoverages(
           global.__coverage__ || {},
           coverage || {},
-        ])
-        if (collectCoverageSaved) {
-          return executionResult
+        )
+
+        if (!collectCoverageSaved) {
+          delete executionResult.coverage
         }
-        return rest
+
+        return executionResult
       },
     )
   }
 
-  // indirectCoverage is a feature making possible to collect
-  // coverage generated by executing a node process which executes
-  // a browser. The coverage coming the browser executionwould be lost
-  // if not propagated somehow.
-  // This is possible if the node process collect the browser coverage
-  // and write it into global.__indirectCoverage__
-  // This is used by jsenv during tests execution
   if (collectCoverage) {
     executionResultTransformer = composeTransformer(
       executionResultTransformer,
-      (executionResult) => {
-        const { coverage = {}, indirectCoverage } = executionResult
+      async (executionResult) => {
+        // we do not keep coverage in memory, it can grow very big
+        // instead we store it on the filesystem, they will be read and merged together later on
+        // in "executeConcurrently"
+        const { coverage } = executionResult
+        if (coverage) {
+          const coverageFileUrl = resolveUrl(
+            `./${runtime.name}/${cuid()}`,
+            coverageTempDirectoryUrl,
+          )
+          await writeFile(coverageFileUrl, JSON.stringify(coverage, null, "  "))
+          executionResult.coverageFileUrl = coverageFileUrl
+          delete executionResult.coverage
+        }
+
+        // indirectCoverage is a feature making possible to collect
+        // coverage generated by executing a node process which executes
+        // a browser. The coverage coming the browser execution would be lost
+        // if not propagated somehow.
+        // This is possible if the node process collect the browser coverage
+        // and write it into global.__indirectCoverage__
+        // This is used by jsenv during tests execution
+        const { indirectCoverage } = executionResult
         if (indirectCoverage) {
-          executionResult.coverage = composeIstanbulCoverages(
-            [coverage, indirectCoverage],
-            {
-              coverageV8MergeConflictIsExpected,
-            },
+          const indirectCoverageFileUrl = resolveUrl(
+            `./${runtime.name}/${cuid()}`,
+            coverageTempDirectoryUrl,
           )
+          await writeFile(
+            indirectCoverageFileUrl,
+            JSON.stringify(indirectCoverage, null, "  "),
+          )
+          executionResult.indirectCoverageFileUrl = indirectCoverageFileUrl
+          delete executionResult.indirectCoverage
         }
+
         return executionResult
       },
     )
@@ -176,6 +198,7 @@ export const launchAndExecute = async ({
         // executionResult.coverage is undefined or {}
         // we delete it just to have a cleaner object
         delete executionResult.coverage
+        delete executionResult.indirectCoverage
         return executionResult
       },
     )

package/src/launchBrowser.js

@@ -37,7 +37,7 @@ chromiumRuntime.launch = async ({
   collectPerformance,
   measurePerformance,
   collectCoverage,
-  coverageConfig,
+  coverageIgnorePredicate,
   coverageForceIstanbul,
 
   headless = true,
@@ -115,7 +115,7 @@ chromiumRuntime.launch = async ({
     collectPerformance,
     measurePerformance,
     collectCoverage,
-    coverageConfig,
+    coverageIgnorePredicate,
     coverageForceIstanbul,
     coveragePlaywrightAPIAvailable: true,
   })
@@ -151,7 +151,7 @@ firefoxRuntime.launch = async ({
   collectPerformance,
   measurePerformance,
   collectCoverage,
-  coverageConfig,
+  coverageIgnorePredicate,
   coverageForceIstanbul,
 
   headless = true,
@@ -194,7 +194,7 @@ firefoxRuntime.launch = async ({
     collectPerformance,
     measurePerformance,
     collectCoverage,
-    coverageConfig,
+    coverageIgnorePredicate,
     coverageForceIstanbul,
   })
 
@@ -229,7 +229,7 @@ webkitRuntime.launch = async ({
   collectPerformance,
   measurePerformance,
   collectCoverage,
-  coverageConfig,
+  coverageIgnorePredicate,
   coverageForceIstanbul,
 
   headless = true,
@@ -272,7 +272,7 @@ webkitRuntime.launch = async ({
     collectPerformance,
     measurePerformance,
     collectCoverage,
-    coverageConfig,
+    coverageIgnorePredicate,
     coverageForceIstanbul,
     ignoreErrorHook: (error) => {
       // we catch error during execution but safari throw unhandled rejection
@@ -378,7 +378,7 @@ const browserToRuntimeHooks = (
     collectPerformance,
     measurePerformance,
     collectCoverage,
-    coverageConfig,
+    coverageIgnorePredicate,
     coverageForceIstanbul,
     coveragePlaywrightAPIAvailable = false,
     ignoreErrorHook = () => false,
@@ -451,9 +451,9 @@ const browserToRuntimeHooks = (
       measurePerformance,
       collectPerformance,
       collectCoverage,
-      coverageConfig,
       coverageForceIstanbul,
       coveragePlaywrightAPIAvailable,
+      coverageIgnorePredicate,
       transformErrorHook,
     })
     return result

package/src/launchNode.js

@@ -1,18 +1,9 @@
 import { Script } from "node:vm"
-import cuid from "cuid"
 import { loggerToLogLevel } from "@jsenv/logger"
-import {
-  writeDirectory,
-  resolveUrl,
-  urlToFileSystemPath,
-  removeFileSystemNode,
-  moveDirectoryContent,
-} from "@jsenv/filesystem"
 
 import { jsenvCoreDirectoryUrl } from "@jsenv/core/src/internal/jsenvCoreDirectoryUrl.js"
 import { escapeRegexpSpecialCharacters } from "./internal/escapeRegexpSpecialCharacters.js"
 import { createControllableNodeProcess } from "./internal/node-launcher/createControllableNodeProcess.js"
-import { v8CoverageFromNodeV8Directory } from "./internal/executing/coverage/v8CoverageFromNodeV8Directory.js"
 
 export const nodeRuntime = {
   name: "node",
@@ -30,8 +21,8 @@ nodeRuntime.launch = async ({
   measurePerformance,
   collectPerformance,
   collectCoverage = false,
-  coverageConfig,
   coverageForceIstanbul,
+  coverageConfig,
 
   debugPort,
   debugMode,
@@ -69,59 +60,10 @@ nodeRuntime.launch = async ({
     JSENV: true,
   }
 
-  let finalizeExecutionResult
-
-  if (collectCoverage) {
-    // v8 coverage is written in a directoy and auto propagate to subprocesses
-    // through process.env.NODE_V8_COVERAGE.
-
-    if (coverageForceIstanbul) {
-      // if we want to force istanbul, we will set process.env.NODE_V8_COVERAGE = ''
-      // into the child_process
-      env.NODE_V8_COVERAGE = ""
-    }
-    // } else if (process.env.NODE_V8_COVERAGE) {
-    //   // The V8_COVERAGE was already set by a parent process or command line.
-    //   // It's the caller that is interested into coverage, it's not anymore this script
-    //   // responsability to set process.env.NODE_V8_COVERAGE nor to read
-    //   // coverage files in the v8 directory.
-    // }
-    // In fact it is so that it's possible to go coverageception:
-    // jsenv collect coverage for tests
-    // which are testing that coverage can be collected for tests
-    // this is possible because we overriding the child process NODE_V8_COVERAGE
-    else {
-      const NODE_V8_COVERAGE = await getNodeV8CoverageDir({
-        projectDirectoryUrl,
-      })
-      env.NODE_V8_COVERAGE = NODE_V8_COVERAGE
-
-      // the v8 coverage directory is available once the child process is disconnected
-      finalizeExecutionResult = async (executionResult) => {
-        if (
-          executionResult.status === "timedout" ||
-          executionResult.status === "aborted"
-        ) {
-          return executionResult
-        }
-
-        const coverage = await ensureV8CoverageDirClean(async () => {
-          // prefer istanbul if available
-          if (executionResult.coverage) {
-            return executionResult.coverage
-          }
-
-          const v8Coverage = await v8CoverageFromNodeV8Directory({
-            projectDirectoryUrl,
-            NODE_V8_COVERAGE,
-            coverageConfig,
-          })
-          return v8Coverage
-        }, NODE_V8_COVERAGE)
-        executionResult.coverage = coverage
-        return executionResult
-      }
-    }
+  if (coverageForceIstanbul) {
+    // if we want to force istanbul, we will set process.env.NODE_V8_COVERAGE = ''
+    // into the child_process
+    env.NODE_V8_COVERAGE = ""
   }
 
   commandLineOptions = [
@@ -198,39 +140,9 @@ nodeRuntime.launch = async ({
     outputCallbackList,
     stop,
     execute,
-    finalizeExecutionResult,
   }
 }
 
-const ensureV8CoverageDirClean = async (fn, NODE_V8_COVERAGE) => {
-  try {
-    return await fn()
-  } finally {
-    if (process.env.NODE_V8_COVERAGE === NODE_V8_COVERAGE) {
-      // do not try to remove or copy coverage
-    } else if (process.env.NODE_V8_COVERAGE) {
-      await moveDirectoryContent({
-        from: NODE_V8_COVERAGE,
-        to: process.env.NODE_V8_COVERAGE,
-      })
-      await removeFileSystemNode(NODE_V8_COVERAGE, {})
-    } else {
-      await removeFileSystemNode(NODE_V8_COVERAGE, {
-        recursive: true,
-      })
-    }
-  }
-}
-
-const getNodeV8CoverageDir = async ({ projectDirectoryUrl }) => {
-  const v8CoverageDirectory = resolveUrl(
-    `./coverage-v8/${cuid()}`,
-    projectDirectoryUrl,
-  )
-  await writeDirectory(v8CoverageDirectory, { allowUseless: true })
-  return urlToFileSystemPath(v8CoverageDirectory)
-}
-
 const transformExecutionResult = (
   executionResult,
   { compileServerOrigin, projectDirectoryUrl },