@jsenv/core 27.0.0-alpha.9 → 27.0.0-alpha.92

package/src/test/coverage/empty_coverage_factory.js

@@ -0,0 +1,52 @@
+import { readFile } from "@jsenv/filesystem"
+import { resolveUrl } from "@jsenv/urls"
+import { Abort } from "@jsenv/abort"
+import { applyBabelPlugins } from "@jsenv/ast"
+
+import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
+import { babelPluginInstrument } from "./babel_plugin_instrument.js"
+
+export const relativeUrlToEmptyCoverage = async (
+  relativeUrl,
+  { signal, rootDirectoryUrl },
+) => {
+  const operation = Abort.startOperation()
+  operation.addAbortSignal(signal)
+
+  try {
+    const fileUrl = resolveUrl(relativeUrl, rootDirectoryUrl)
+    const content = await readFile(fileUrl, { as: "string" })
+
+    operation.throwIfAborted()
+    const { metadata } = await applyBabelPlugins({
+      babelPlugins: [[babelPluginInstrument, { rootDirectoryUrl }]],
+      urlInfo: {
+        originalUrl: fileUrl,
+        content,
+      },
+    })
+    const { coverage } = metadata
+    if (!coverage) {
+      throw new Error(`missing coverage for file`)
+    }
+    // https://github.com/gotwarlost/istanbul/blob/bc84c315271a5dd4d39bcefc5925cfb61a3d174a/lib/command/common/run-with-cover.js#L229
+    Object.keys(coverage.s).forEach(function (key) {
+      coverage.s[key] = 0
+    })
+    return coverage
+  } catch (e) {
+    if (e && e.code === "PARSE_ERROR") {
+      // return an empty coverage for that file when
+      // it contains a syntax error
+      return createEmptyCoverage(relativeUrl)
+    }
+    throw e
+  } finally {
+    await operation.end()
+  }
+}
+
+const createEmptyCoverage = (relativeUrl) => {
+  const { createFileCoverage } = requireFromJsenv("istanbul-lib-coverage")
+  return createFileCoverage(relativeUrl).toJSON()
+}

package/src/test/coverage/file_by_file_coverage.js

@@ -0,0 +1,25 @@
+import {
+  urlToRelativeUrl,
+  fileSystemPathToUrl,
+  isFileSystemPath,
+} from "@jsenv/urls"
+
+export const normalizeFileByFileCoveragePaths = (
+  fileByFileCoverage,
+  rootDirectoryUrl,
+) => {
+  const fileByFileNormalized = {}
+  Object.keys(fileByFileCoverage).forEach((key) => {
+    const fileCoverage = fileByFileCoverage[key]
+    const { path } = fileCoverage
+    const url = isFileSystemPath(path)
+      ? fileSystemPathToUrl(path)
+      : new URL(path, rootDirectoryUrl).href
+    const relativeUrl = urlToRelativeUrl(url, rootDirectoryUrl)
+    fileByFileNormalized[`./${relativeUrl}`] = {
+      ...fileCoverage,
+      path: `./${relativeUrl}`,
+    }
+  })
+  return fileByFileNormalized
+}

package/src/test/coverage/istanbul_coverage_composition.js

@@ -0,0 +1,28 @@
+import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.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 } = requireFromJsenv("istanbul-lib-coverage")
+  const istanbulFileCoverageObject = createFileCoverage(firstIstanbulCoverage)
+  istanbulFileCoverageObject.merge(secondIstanbulCoverage)
+  const istanbulCoverage = istanbulFileCoverageObject.toJSON()
+  return istanbulCoverage
+}

package/src/test/coverage/istanbul_coverage_map_from_coverage.js

@@ -0,0 +1,16 @@
+import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
+
+export const istanbulCoverageMapFromCoverage = (coverage) => {
+  const { createCoverageMap } = requireFromJsenv("istanbul-lib-coverage")
+
+  const coverageAdjusted = {}
+  Object.keys(coverage).forEach((key) => {
+    coverageAdjusted[key.slice(2)] = {
+      ...coverage[key],
+      path: key.slice(2),
+    }
+  })
+
+  const coverageMap = createCoverageMap(coverageAdjusted)
+  return coverageMap
+}

package/src/test/coverage/list_files_not_covered.js

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

package/src/test/coverage/missing_coverage.js

@@ -0,0 +1,41 @@
+import { Abort } from "@jsenv/abort"
+
+import { listRelativeFileUrlToCover } from "./list_files_not_covered.js"
+import { relativeUrlToEmptyCoverage } from "./empty_coverage_factory.js"
+
+export const getMissingFileByFileCoverage = async ({
+  signal,
+  rootDirectoryUrl,
+  coverageConfig,
+  fileByFileCoverage,
+}) => {
+  const relativeUrlsToCover = await listRelativeFileUrlToCover({
+    signal,
+    rootDirectoryUrl,
+    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,
+          rootDirectoryUrl,
+        },
+      )
+      missingFileByFileCoverage[`./${relativeUrlMissing}`] = emptyCoverage
+    })
+  }, Promise.resolve())
+  return missingFileByFileCoverage
+}

package/src/test/coverage/report_to_coverage.js

@@ -0,0 +1,196 @@
+import { readFile } from "@jsenv/filesystem"
+import { Abort } from "@jsenv/abort"
+
+import {
+  visitNodeV8Directory,
+  filterV8Coverage,
+} from "./v8_coverage_from_directory.js"
+import { composeTwoV8Coverages } from "./v8_coverage_composition.js"
+import { composeTwoFileByFileIstanbulCoverages } from "./istanbul_coverage_composition.js"
+import { v8CoverageToIstanbul } from "./v8_coverage_to_istanbul.js"
+import { composeV8AndIstanbul } from "./v8_and_istanbul.js"
+import { normalizeFileByFileCoveragePaths } from "./file_by_file_coverage.js"
+import { getMissingFileByFileCoverage } from "./missing_coverage.js"
+
+export const reportToCoverage = async (
+  report,
+  {
+    signal,
+    logger,
+    rootDirectoryUrl,
+    coverageConfig,
+    coverageIncludeMissing,
+    urlShouldBeCovered,
+    coverageForceIstanbul,
+    coverageV8ConflictWarning,
+  },
+) => {
+  // collect v8 and istanbul coverage from executions
+  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" &&
+        executionResult.runtimeName !== "node" &&
+        !process.env.NODE_V8_COVERAGE
+      ) {
+        logger.warn(
+          `No execution.coverageFileUrl from execution named "${executionName}" of ${file}`,
+        )
+      }
+    },
+  })
+
+  if (!coverageForceIstanbul && process.env.NODE_V8_COVERAGE) {
+    await visitNodeV8Directory({
+      logger,
+      signal,
+      NODE_V8_COVERAGE: process.env.NODE_V8_COVERAGE,
+      onV8Coverage: (nodeV8Coverage) => {
+        const nodeV8CoverageLight = filterV8Coverage(nodeV8Coverage, {
+          urlShouldBeCovered,
+        })
+        v8Coverage = v8Coverage
+          ? composeTwoV8Coverages(v8Coverage, nodeV8CoverageLight)
+          : nodeV8CoverageLight
+      },
+    })
+  }
+
+  // try to merge v8 with istanbul, if any
+  let fileByFileCoverage
+  if (v8Coverage) {
+    let v8FileByFileCoverage = await v8CoverageToIstanbul(v8Coverage, {
+      signal,
+    })
+
+    v8FileByFileCoverage = normalizeFileByFileCoveragePaths(
+      v8FileByFileCoverage,
+      rootDirectoryUrl,
+    )
+
+    if (fileByFileIstanbulCoverage) {
+      fileByFileIstanbulCoverage = normalizeFileByFileCoveragePaths(
+        fileByFileIstanbulCoverage,
+        rootDirectoryUrl,
+      )
+      fileByFileCoverage = composeV8AndIstanbul(
+        v8FileByFileCoverage,
+        fileByFileIstanbulCoverage,
+        { coverageV8ConflictWarning },
+      )
+    } else {
+      fileByFileCoverage = v8FileByFileCoverage
+    }
+  }
+  // get istanbul only
+  else if (fileByFileIstanbulCoverage) {
+    fileByFileCoverage = normalizeFileByFileCoveragePaths(
+      fileByFileIstanbulCoverage,
+      rootDirectoryUrl,
+    )
+  }
+  // no coverage found in execution (or zero file where executed)
+  else {
+    fileByFileCoverage = {}
+  }
+
+  // now add coverage for file not covered
+  if (coverageIncludeMissing) {
+    const missingFileByFileCoverage = await getMissingFileByFileCoverage({
+      signal,
+      rootDirectoryUrl,
+      coverageConfig,
+      fileByFileCoverage,
+    })
+    Object.assign(
+      fileByFileCoverage,
+      normalizeFileByFileCoveragePaths(
+        missingFileByFileCoverage,
+        rootDirectoryUrl,
+      ),
+    )
+  }
+
+  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
+          }
+
+          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())
+
+    return {
+      v8Coverage,
+      fileByFileIstanbulCoverage,
+    }
+  } finally {
+    await operation.end()
+  }
+}
+
+const isV8Coverage = (coverage) => Boolean(coverage.result)

package/src/test/coverage/v8_and_istanbul.js

@@ -0,0 +1,37 @@
+import { createDetailedMessage } from "@jsenv/log"
+
+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",
+            },
+          ),
+        )
+      }
+      fileByFileCoverage[key] = v8Coverage
+    } else {
+      fileByFileCoverage[key] = istanbulFileByFileCoverage[key]
+    }
+  })
+
+  return fileByFileCoverage
+}

package/src/test/coverage/v8_coverage_composition.js

@@ -0,0 +1,24 @@
+import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
+
+export const composeTwoV8Coverages = (firstV8Coverage, secondV8Coverage) => {
+  if (secondV8Coverage.result.length === 0) {
+    return firstV8Coverage
+  }
+
+  // eslint-disable-next-line import/no-unresolved
+  const { mergeProcessCovs } = requireFromJsenv("@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/test/coverage/v8_coverage_from_directory.js

@@ -0,0 +1,87 @@
+import {
+  assertAndNormalizeDirectoryUrl,
+  readDirectory,
+  readFile,
+} from "@jsenv/filesystem"
+import { resolveUrl } from "@jsenv/urls"
+import { createDetailedMessage } from "@jsenv/log"
+import { Abort } from "@jsenv/abort"
+
+export const visitNodeV8Directory = async ({
+  logger,
+  signal,
+  NODE_V8_COVERAGE,
+  onV8Coverage,
+  maxMsWaitingForNodeToWriteCoverageFile = 2000,
+}) => {
+  const operation = Abort.startOperation()
+  operation.addAbortSignal(signal)
+
+  const tryReadDirectory = async () => {
+    const dirContent = await readDirectory(NODE_V8_COVERAGE)
+    if (dirContent.length > 0) {
+      return dirContent
+    }
+    logger.warn(`v8 coverage directory is empty at ${NODE_V8_COVERAGE}`)
+    return dirContent
+  }
+
+  try {
+    operation.throwIfAborted()
+    const dirContent = await tryReadDirectory()
+
+    const coverageDirectoryUrl =
+      assertAndNormalizeDirectoryUrl(NODE_V8_COVERAGE)
+    await dirContent.reduce(async (previous, dirEntry) => {
+      operation.throwIfAborted()
+      await previous
+
+      const dirEntryUrl = resolveUrl(dirEntry, coverageDirectoryUrl)
+      const tryReadJsonFile = async (timeSpentTrying = 0) => {
+        const fileContent = await readFile(dirEntryUrl, { as: "string" })
+        if (fileContent === "") {
+          if (timeSpentTrying < 400) {
+            await new Promise((resolve) => setTimeout(resolve, 200))
+            return tryReadJsonFile(timeSpentTrying + 200)
+          }
+          console.warn(`Coverage JSON file is empty at ${dirEntryUrl}`)
+          return null
+        }
+
+        try {
+          const fileAsJson = JSON.parse(fileContent)
+          return fileAsJson
+        } catch (e) {
+          if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
+            await new Promise((resolve) => setTimeout(resolve, 200))
+            return tryReadJsonFile(timeSpentTrying + 200)
+          }
+          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())
+  } finally {
+    await operation.end()
+  }
+}
+
+export const filterV8Coverage = (v8Coverage, { urlShouldBeCovered }) => {
+  const v8CoverageFiltered = {
+    ...v8Coverage,
+    result: v8Coverage.result.filter((fileReport) =>
+      urlShouldBeCovered(fileReport.url),
+    ),
+  }
+  return v8CoverageFiltered
+}

package/src/test/coverage/v8_coverage_to_istanbul.js

@@ -0,0 +1,99 @@
+import { urlToFileSystemPath } from "@jsenv/urls"
+import { Abort } from "@jsenv/abort"
+
+import { requireFromJsenv } from "@jsenv/core/src/require_from_jsenv.js"
+import { composeTwoFileByFileIstanbulCoverages } from "./istanbul_coverage_composition.js"
+
+export const v8CoverageToIstanbul = async (v8Coverage, { signal }) => {
+  const operation = Abort.startOperation()
+  operation.addAbortSignal(signal)
+
+  try {
+    const v8ToIstanbul = requireFromJsenv("v8-to-istanbul")
+    const sourcemapCache = v8Coverage["source-map-cache"]
+    let istanbulCoverageComposed = null
+
+    await v8Coverage.result.reduce(async (previous, fileV8Coverage) => {
+      operation.throwIfAborted()
+      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
+  } finally {
+    await operation.end()
+  }
+}
+
+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
+}