@jsenv/core 23.2.2 → 23.4.2

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

@@ -1,8 +1,16 @@
-import { collectFiles } from "@jsenv/filesystem"
-
-import { relativeUrlToEmptyCoverage } from "./relativeUrlToEmptyCoverage.js"
-import { istanbulCoverageFromCoverages } from "./istanbulCoverageFromCoverages.js"
-import { normalizeIstanbulCoverage } from "./normalizeIstanbulCoverage.js"
+import { readFile } from "@jsenv/filesystem"
+
+import {
+  visitNodeV8Directory,
+  filterV8Coverage,
+} from "../coverage_utils/v8_coverage_from_directory.js"
+import { composeTwoV8Coverages } from "../coverage_utils/v8_coverage_composition.js"
+import { composeTwoFileByFileIstanbulCoverages } from "../coverage_utils/istanbul_coverage_composition.js"
+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"
 
 export const reportToCoverage = async (
   report,
@@ -13,134 +21,153 @@ export const reportToCoverage = async (
     babelPluginMap,
     coverageConfig,
     coverageIncludeMissing,
-    coverageV8MergeConflictIsExpected,
+    coverageIgnorePredicate,
+    coverageForceIstanbul,
+    coverageV8ConflictWarning,
   },
 ) => {
-  // here we should forward multipleExecutionsOperation.signal
-  // to allow aborting this too
-  const istanbulCoverageFromExecution = await executionReportToCoverage(
-    report,
-    {
-      logger,
-      projectDirectoryUrl,
-      coverageV8MergeConflictIsExpected,
-    },
-  )
+  let v8Coverage
+  let fileByFileIstanbulCoverage
 
-  if (!coverageIncludeMissing) {
-    return istanbulCoverageFromExecution
-  }
+  // collect v8 and istanbul coverage from executions
+  await Object.keys(report).reduce(async (previous, file) => {
+    await previous
 
-  const relativeFileUrlToCoverArray = await listRelativeFileUrlToCover({
-    multipleExecutionsOperation,
-    projectDirectoryUrl,
-    coverageConfig,
-  })
+    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 relativeFileUrlMissingCoverageArray =
-    relativeFileUrlToCoverArray.filter((relativeFileUrlToCover) =>
-      Object.keys(istanbulCoverageFromExecution).every((key) => {
-        return key !== `./${relativeFileUrlToCover}`
-      }),
+        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(),
     )
-
-  const istanbulCoverageFromMissedFiles = {}
-  // maybe we should prefer reduce over Promise.all here
-  // because it creates a LOT of things to do
-  await Promise.all(
-    relativeFileUrlMissingCoverageArray.map(
-      async (relativeFileUrlMissingCoverage) => {
-        const emptyCoverage = await relativeUrlToEmptyCoverage(
-          relativeFileUrlMissingCoverage,
-          {
-            multipleExecutionsOperation,
-            projectDirectoryUrl,
-            babelPluginMap,
-          },
-        )
-        istanbulCoverageFromMissedFiles[relativeFileUrlMissingCoverage] =
-          emptyCoverage
-        return emptyCoverage
+  }, Promise.resolve())
+
+  if (!coverageForceIstanbul && process.env.NODE_V8_COVERAGE) {
+    await visitNodeV8Directory({
+      signal: multipleExecutionsOperation.signal,
+      NODE_V8_COVERAGE: process.env.NODE_V8_COVERAGE,
+      onV8Coverage: (nodeV8Coverage) => {
+        const nodeV8CoverageLight = filterV8Coverage(nodeV8Coverage, {
+          coverageIgnorePredicate,
+        })
+        v8Coverage = v8Coverage
+          ? composeTwoV8Coverages(v8Coverage, nodeV8CoverageLight)
+          : nodeV8CoverageLight
       },
-    ),
-  )
-
-  return {
-    ...istanbulCoverageFromExecution, // already normalized
-    ...normalizeIstanbulCoverage(
-      istanbulCoverageFromMissedFiles,
-      projectDirectoryUrl,
-    ),
-  }
-}
-
-const listRelativeFileUrlToCover = async ({
-  multipleExecutionsOperation,
-  projectDirectoryUrl,
-  coverageConfig,
-}) => {
-  const structuredMetaMapForCoverage = {
-    cover: coverageConfig,
+    })
   }
 
-  const matchingFileResultArray = await collectFiles({
-    signal: multipleExecutionsOperation.signal,
-    directoryUrl: projectDirectoryUrl,
-    structuredMetaMap: structuredMetaMapForCoverage,
-    predicate: ({ cover }) => cover,
-  })
-
-  return matchingFileResultArray.map(({ relativeUrl }) => relativeUrl)
-}
+  // try to merge v8 with istanbul, if any
+  let fileByFileCoverage
+  if (v8Coverage) {
+    let v8FileByFileCoverage = await v8CoverageToIstanbul(v8Coverage)
 
-const executionReportToCoverage = async (
-  report,
-  { logger, projectDirectoryUrl, coverageV8MergeConflictIsExpected },
-) => {
-  const coverages = []
+    v8FileByFileCoverage = normalizeFileByFileCoveragePaths(
+      v8FileByFileCoverage,
+      projectDirectoryUrl,
+    )
 
-  Object.keys(report).forEach((file) => {
-    const executionResultForFile = report[file]
-    Object.keys(executionResultForFile).forEach((executionName) => {
-      const executionResultForFileOnRuntime =
-        executionResultForFile[executionName]
-
-      const { status, coverage } = executionResultForFileOnRuntime
-      if (!coverage) {
-        // 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.warn(
-            `No execution.coverage from execution named "${executionName}" of ${file}`,
-          )
-        }
-        return
-      }
+    if (fileByFileIstanbulCoverage) {
+      fileByFileIstanbulCoverage = normalizeFileByFileCoveragePaths(
+        fileByFileIstanbulCoverage,
+        projectDirectoryUrl,
+      )
+      fileByFileCoverage = composeV8AndIstanbul(
+        v8FileByFileCoverage,
+        fileByFileIstanbulCoverage,
+        { coverageV8ConflictWarning },
+      )
+    } else {
+      fileByFileCoverage = v8FileByFileCoverage
+    }
+  }
+  // get istanbul only
+  else if (fileByFileIstanbulCoverage) {
+    fileByFileCoverage = normalizeFileByFileCoveragePaths(
+      fileByFileIstanbulCoverage,
+      projectDirectoryUrl,
+    )
+  }
+  // no coverage found in execution (or zero file where executed)
+  else {
+    fileByFileCoverage = {}
+  }
 
-      coverages.push(coverage)
+  // now add coverage for file not covered
+  if (coverageIncludeMissing) {
+    const relativeUrlsToCover = await listRelativeFileUrlToCover({
+      multipleExecutionsOperation,
+      projectDirectoryUrl,
+      coverageConfig,
     })
-  })
 
-  const istanbulCoverage = await istanbulCoverageFromCoverages(coverages, {
-    projectDirectoryUrl,
-    coverageV8MergeConflictIsExpected,
-  })
+    const relativeUrlsMissing = relativeUrlsToCover.filter(
+      (relativeUrlToCover) =>
+        Object.keys(fileByFileCoverage).every((key) => {
+          return key !== `./${relativeUrlToCover}`
+        }),
+    )
+
+    await relativeUrlsMissing.reduce(async (previous, relativeUrlMissing) => {
+      const emptyCoverage = await relativeUrlToEmptyCoverage(
+        relativeUrlMissing,
+        {
+          multipleExecutionsOperation,
+          projectDirectoryUrl,
+          babelPluginMap,
+        },
+      )
+      fileByFileCoverage[`./${relativeUrlMissing}`] = emptyCoverage
+      return emptyCoverage
+    }, Promise.resolve())
+  }
 
-  return istanbulCoverage
+  return fileByFileCoverage
 }
+
+const isV8Coverage = (coverage) => Boolean(coverage.result)

package/src/internal/executing/coverage_empty/list_files_not_covered.js

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

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

@@ -1,11 +1,10 @@
 import { resolveUrl, urlToFileSystemPath, readFile } from "@jsenv/filesystem"
 
-import { Abortable } from "@jsenv/core/src/abort/main.js"
 import {
   babelPluginsFromBabelPluginMap,
   getMinimalBabelPluginMap,
 } from "@jsenv/core/src/internal/compiling/babel_plugins.js"
-import { babelPluginInstrument } from "./babel_plugin_instrument.js"
+import { babelPluginInstrument } from "../coverage/babel_plugin_instrument.js"
 import { createEmptyCoverage } from "./createEmptyCoverage.js"
 
 export const relativeUrlToEmptyCoverage = async (
@@ -15,7 +14,7 @@ export const relativeUrlToEmptyCoverage = async (
   const { transformAsync } = await import("@babel/core")
 
   const fileUrl = resolveUrl(relativeUrl, projectDirectoryUrl)
-  Abortable.throwIfAborted(multipleExecutionsOperation)
+  multipleExecutionsOperation.throwIfAborted()
   const source = await readFile(fileUrl)
 
   try {
@@ -25,7 +24,7 @@ export const relativeUrlToEmptyCoverage = async (
       "transform-instrument": [babelPluginInstrument, { projectDirectoryUrl }],
     }
 
-    Abortable.throwIfAborted(multipleExecutionsOperation)
+    multipleExecutionsOperation.throwIfAborted()
     const { metadata } = await transformAsync(source, {
       filename: urlToFileSystemPath(fileUrl),
       filenameRelative: relativeUrl,

package/src/internal/executing/{coverage/generateCoverageHtmlDirectory.js → coverage_reporter/coverage_reporter_html_directory.js}

@@ -1,13 +1,17 @@
-import { readFileSync } from "fs"
+import { readFileSync } from "node:fs"
 import { resolveUrl, urlToFileSystemPath } from "@jsenv/filesystem"
 
 import { require } from "../../require.js"
-
 import { istanbulCoverageMapFromCoverage } from "./istanbulCoverageMapFromCoverage.js"
 
 export const generateCoverageHtmlDirectory = async (
   coverage,
-  { projectDirectoryUrl, coverageHtmlDirectoryRelativeUrl, coverageSkipEmpty, coverageSkipFull },
+  {
+    projectDirectoryUrl,
+    coverageHtmlDirectoryRelativeUrl,
+    coverageSkipEmpty,
+    coverageSkipFull,
+  },
 ) => {
   const libReport = require("istanbul-lib-report")
   const reports = require("istanbul-reports")
@@ -16,7 +20,10 @@ export const generateCoverageHtmlDirectory = async (
     dir: urlToFileSystemPath(projectDirectoryUrl),
     coverageMap: istanbulCoverageMapFromCoverage(coverage),
     sourceFinder: (path) => {
-      return readFileSync(urlToFileSystemPath(resolveUrl(path, projectDirectoryUrl)), "utf8")
+      return readFileSync(
+        urlToFileSystemPath(resolveUrl(path, projectDirectoryUrl)),
+        "utf8",
+      )
     },
   })
 

package/src/internal/executing/{coverage/generateCoverageTextLog.js → coverage_reporter/coverage_reporter_text_log.js}

@@ -1,8 +1,10 @@
 import { require } from "../../require.js"
-
 import { istanbulCoverageMapFromCoverage } from "./istanbulCoverageMapFromCoverage.js"
 
-export const generateCoverageTextLog = (coverage, { coverageSkipEmpty, coverageSkipFull }) => {
+export const generateCoverageTextLog = (
+  coverage,
+  { coverageSkipEmpty, coverageSkipFull },
+) => {
   const libReport = require("istanbul-lib-report")
   const reports = require("istanbul-reports")
 

package/src/internal/executing/{coverage/normalizeIstanbulCoverage.js → coverage_utils/file_by_file_coverage.js}

@@ -5,22 +5,24 @@ import {
   resolveUrl,
 } from "@jsenv/filesystem"
 
-export const normalizeIstanbulCoverage = (istanbulCoverage, projectDirectoryUrl) => {
-  const istanbulCoverageNormalized = {}
+export const normalizeFileByFileCoveragePaths = (
+  fileByFileCoverage,
+  projectDirectoryUrl,
+) => {
+  const fileByFileNormalized = {}
 
-  Object.keys(istanbulCoverage).forEach((key) => {
-    const fileCoverage = istanbulCoverage[key]
+  Object.keys(fileByFileCoverage).forEach((key) => {
+    const fileCoverage = fileByFileCoverage[key]
     const { path } = fileCoverage
     const url = isFileSystemPath(path)
       ? fileSystemPathToUrl(path)
       : resolveUrl(path, projectDirectoryUrl)
     const relativeUrl = urlToRelativeUrl(url, projectDirectoryUrl)
-
-    istanbulCoverageNormalized[`./${relativeUrl}`] = {
+    fileByFileNormalized[`./${relativeUrl}`] = {
       ...fileCoverage,
       path: `./${relativeUrl}`,
     }
   })
 
-  return istanbulCoverageNormalized
+  return fileByFileNormalized
 }

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

@@ -0,0 +1,28 @@
+import { require } from "../../require.js"
+
+export const composeTwoFileByFileIstanbulCoverages = (
+  firstFileByFileIstanbulCoverage,
+  secondFileByFileIstanbulCoverage,
+) => {
+  const fileByFileIstanbulCoverage = {}
+  Object.keys(firstFileByFileIstanbulCoverage).forEach((key) => {
+    fileByFileIstanbulCoverage[key] = firstFileByFileIstanbulCoverage[key]
+  })
+  Object.keys(secondFileByFileIstanbulCoverage).forEach((key) => {
+    const firstCoverage = firstFileByFileIstanbulCoverage[key]
+    const secondCoverage = secondFileByFileIstanbulCoverage[key]
+    fileByFileIstanbulCoverage[key] = firstCoverage
+      ? merge(firstCoverage, secondCoverage)
+      : secondCoverage
+  })
+
+  return fileByFileIstanbulCoverage
+}
+
+const merge = (firstIstanbulCoverage, secondIstanbulCoverage) => {
+  const { createFileCoverage } = require("istanbul-lib-coverage")
+  const istanbulFileCoverageObject = createFileCoverage(firstIstanbulCoverage)
+  istanbulFileCoverageObject.merge(secondIstanbulCoverage)
+  const istanbulCoverage = istanbulFileCoverageObject.toJSON()
+  return istanbulCoverage
+}

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

@@ -0,0 +1,38 @@
+import { createDetailedMessage } from "@jsenv/logger"
+
+export const composeV8AndIstanbul = (
+  v8FileByFileCoverage,
+  istanbulFileByFileCoverage,
+  { coverageV8ConflictWarning },
+) => {
+  const fileByFileCoverage = {}
+  const v8Files = Object.keys(v8FileByFileCoverage)
+  const istanbulFiles = Object.keys(istanbulFileByFileCoverage)
+
+  v8Files.forEach((key) => {
+    fileByFileCoverage[key] = v8FileByFileCoverage[key]
+  })
+  istanbulFiles.forEach((key) => {
+    const v8Coverage = v8FileByFileCoverage[key]
+    if (v8Coverage) {
+      if (coverageV8ConflictWarning) {
+        console.warn(
+          createDetailedMessage(
+            `Coverage conflict on "${key}", found two coverage that cannot be merged together: v8 and istanbul. The istanbul coverage will be ignored.`,
+            {
+              "details": `This happens when a file is executed on a runtime using v8 coverage (node or chromium) and on runtime using istanbul coverage (firefox or webkit)`,
+              "suggestion":
+                "You can disable this warning with coverageV8ConflictWarning: false",
+              "suggestion 2": `You can force usage of istanbul to prevent this conflict with coverageForceIstanbul: true`,
+            },
+          ),
+        )
+      }
+      fileByFileCoverage[key] = v8Coverage
+    } else {
+      fileByFileCoverage[key] = istanbulFileByFileCoverage[key]
+    }
+  })
+
+  return fileByFileCoverage
+}

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

@@ -0,0 +1,23 @@
+import { require } from "@jsenv/core/src/internal/require.js"
+
+export const composeTwoV8Coverages = (firstV8Coverage, secondV8Coverage) => {
+  if (secondV8Coverage.result.length === 0) {
+    return firstV8Coverage
+  }
+
+  const { mergeProcessCovs } = require("@c88/v8-coverage")
+  // "mergeProcessCovs" do not preserves source-map-cache during the merge
+  // so we store sourcemap cache now
+  const sourceMapCache = {}
+  const visit = (coverageReport) => {
+    if (coverageReport["source-map-cache"]) {
+      Object.assign(sourceMapCache, coverageReport["source-map-cache"])
+    }
+  }
+  visit(firstV8Coverage)
+  visit(secondV8Coverage)
+  const v8Coverage = mergeProcessCovs([firstV8Coverage, secondV8Coverage])
+  v8Coverage["source-map-cache"] = sourceMapCache
+
+  return v8Coverage
+}

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

@@ -0,0 +1,65 @@
+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 () => {
+      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())
+}
+
+export const filterV8Coverage = (v8Coverage, { coverageIgnorePredicate }) => {
+  const v8CoverageFiltered = {
+    ...v8Coverage,
+    result: v8Coverage.result.filter((fileReport) => {
+      return !coverageIgnorePredicate(fileReport.url)
+    }),
+  }
+  return v8CoverageFiltered
+}