@jsenv/core 34.3.0 → 35.0.1

package/src/test/coverage/list_files_not_covered.js

@@ -1,15 +0,0 @@
-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

@@ -1,41 +0,0 @@
-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

@@ -1,198 +0,0 @@
-import { readFileSync } from "node:fs"
-import { Abort } from "@jsenv/abort"
-
-import { filterV8Coverage } from "./v8_coverage.js"
-import { readNodeV8CoverageDirectory } from "./v8_coverage_node_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,
-    coverageMethodForNodeJs,
-    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.type === "node" &&
-        coverageMethodForNodeJs !== "NODE_V8_COVERAGE"
-      ) {
-        logger.warn(
-          `"${executionName}" execution of ${file} did not properly write coverage into ${executionResult.coverageFileUrl}`,
-        )
-      }
-    },
-  })
-
-  if (coverageMethodForNodeJs === "NODE_V8_COVERAGE") {
-    await readNodeV8CoverageDirectory({
-      logger,
-      signal,
-      onV8Coverage: async (nodeV8Coverage) => {
-        const nodeV8CoverageLight = await filterV8Coverage(nodeV8Coverage, {
-          rootDirectoryUrl,
-          coverageConfig,
-        })
-        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
-          let executionCoverage
-          try {
-            executionCoverage = JSON.parse(
-              String(readFileSync(new URL(coverageFileUrl))),
-            )
-          } catch (e) {
-            if (e.code === "ENOENT" || e.name === "SyntaxError") {
-              onMissing({
-                executionName,
-                file,
-                executionResult: executionResultForFileOnRuntime,
-              })
-              return
-            }
-            throw e
-          }
-
-          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

@@ -1,37 +0,0 @@
-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.js

@@ -1,26 +0,0 @@
-import { URL_META } from "@jsenv/url-meta"
-
-export const filterV8Coverage = async (
-  v8Coverage,
-  { rootDirectoryUrl, coverageConfig },
-) => {
-  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
-  }
-
-  const v8CoverageFiltered = {
-    ...v8Coverage,
-    result: v8Coverage.result.filter((fileReport) =>
-      urlShouldBeCovered(fileReport.url),
-    ),
-  }
-  return v8CoverageFiltered
-}

package/src/test/coverage/v8_coverage_composition.js

@@ -1,24 +0,0 @@
-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_node_directory.js

@@ -1,85 +0,0 @@
-import { readFileSync, readdirSync } from "node:fs"
-import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-import { createDetailedMessage } from "@jsenv/log"
-import { Abort } from "@jsenv/abort"
-
-export const readNodeV8CoverageDirectory = async ({
-  logger,
-  signal,
-  onV8Coverage,
-  maxMsWaitingForNodeToWriteCoverageFile = 2000,
-}) => {
-  const NODE_V8_COVERAGE = process.env.NODE_V8_COVERAGE
-  const operation = Abort.startOperation()
-  operation.addAbortSignal(signal)
-
-  let timeSpentTrying = 0
-  const tryReadDirectory = async () => {
-    const dirContent = readdirSync(NODE_V8_COVERAGE)
-    if (dirContent.length > 0) {
-      return dirContent
-    }
-    if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
-      await new Promise((resolve) => setTimeout(resolve, 200))
-      timeSpentTrying += 200
-      logger.debug("retry to read coverage directory")
-      return tryReadDirectory()
-    }
-    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,
-      "NODE_V8_COVERAGE",
-    )
-
-    await dirContent.reduce(async (previous, dirEntry) => {
-      operation.throwIfAborted()
-      await previous
-
-      const dirEntryUrl = new URL(dirEntry, coverageDirectoryUrl)
-      const tryReadJsonFile = async () => {
-        const fileContent = String(readFileSync(dirEntryUrl))
-        if (fileContent === "") {
-          if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
-            await new Promise((resolve) => setTimeout(resolve, 200))
-            timeSpentTrying += 200
-            return tryReadJsonFile()
-          }
-          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))
-            timeSpentTrying += 200
-            return tryReadJsonFile()
-          }
-          console.warn(
-            createDetailedMessage(`Error while reading coverage file`, {
-              "error stack": e.stack,
-              "file": dirEntryUrl,
-            }),
-          )
-          return null
-        }
-      }
-
-      const fileContent = await tryReadJsonFile()
-      if (fileContent) {
-        await onV8Coverage(fileContent)
-      }
-    }, Promise.resolve())
-  } finally {
-    await operation.end()
-  }
-}

package/src/test/coverage/v8_coverage_to_istanbul.js

@@ -1,99 +0,0 @@
-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
-}