@jsenv/test 1.0.0

package/dist/no_experimental_warnings.cjs

@@ -0,0 +1,10 @@
+// see https://github.com/nodejs/node/issues/47478
+const originalEmit = process.emit;
+process.emit = (event, error) => {
+  if (event === "warning" && error.name === "ExperimentalWarning") {
+    if (error.message.includes("--experimental-loader") || error.message.includes("Custom ESM Loaders is an experimental")) {
+      return false;
+    }
+  }
+  return originalEmit.call(process, event, error);
+};

package/package.json

@@ -0,0 +1,56 @@
+{
+  "name": "@jsenv/test",
+  "version": "1.0.0",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/jsenv/core",
+    "directory": "packages/test"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "exports": {
+    ".": {
+      "import": {
+        "development": "./src/main.js",
+        "default": "./dist/jsenv_test.js"
+      }
+    },
+    "./*": "./*"
+  },
+  "files": [
+    "/dist/",
+    "/src/"
+  ],
+  "scripts": {
+    "test": "node --conditions=development ./scripts/test.mjs",
+    "build": "node --conditions=development ./scripts/build.mjs",
+    "prepublishOnly": "npm run build"
+  },
+  "optionalDependencies": {
+    "playwright": "1.x"
+  },
+  "dependencies": {
+    "@jsenv/core": "35.0.0",
+    "@jsenv/abort": "4.2.4",
+    "@jsenv/ast": "3.0.6",
+    "@jsenv/filesystem": "4.2.3",
+    "@jsenv/log": "3.3.4",
+    "@jsenv/urls": "2.0.0",
+    "@jsenv/url-meta": "8.1.0",
+    "@jsenv/uneval": "1.6.0",
+    "@jsenv/utils": "2.0.1",
+    "v8-to-istanbul": "9.1.0",
+    "istanbul-lib-coverage": "3.2.0",
+    "istanbul-lib-instrument": "5.2.1",
+    "istanbul-lib-report": "3.0.0",
+    "istanbul-reports": "3.1.5",
+    "@paralleldrive/cuid2": "2.2.0",
+    "@c88/v8-coverage": "0.1.1",
+    "strip-ansi": "7.0.1",
+    "wrap-ansi": "8.1.0",
+    "pidtree": "0.6.0"
+  }
+}

package/src/coverage/babel_plugin_instrument.js

@@ -0,0 +1,48 @@
+import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js"
+
+// https://github.com/istanbuljs/babel-plugin-istanbul/blob/321740f7b25d803f881466ea819d870f7ed6a254/src/index.js
+
+export const babelPluginInstrument = (api, { useInlineSourceMaps = false }) => {
+  const { programVisitor } = requireFromJsenv("istanbul-lib-instrument")
+  const { types } = api
+
+  return {
+    name: "transform-instrument",
+    visitor: {
+      Program: {
+        enter(path) {
+          const { file } = this
+          const { opts } = file
+          let inputSourceMap
+          if (useInlineSourceMaps) {
+            // https://github.com/istanbuljs/babel-plugin-istanbul/commit/a9e15643d249a2985e4387e4308022053b2cd0ad#diff-1fdf421c05c1140f6d71444ea2b27638R65
+            inputSourceMap =
+              opts.inputSourceMap || file.inputMap
+                ? file.inputMap.sourcemap
+                : null
+          } else {
+            inputSourceMap = opts.inputSourceMap
+          }
+          this.__dv__ = programVisitor(
+            types,
+            opts.filenameRelative || opts.filename,
+            {
+              coverageVariable: "__coverage__",
+              inputSourceMap,
+            },
+          )
+          this.__dv__.enter(path)
+        },
+
+        exit(path) {
+          if (!this.__dv__) {
+            return
+          }
+          const object = this.__dv__.exit(path)
+          // object got two properties: fileCoverage and sourceMappingURL
+          this.file.metadata.coverage = object.fileCoverage
+        },
+      },
+    },
+  }
+}

package/src/coverage/coverage_reporter_html_directory.js

@@ -0,0 +1,32 @@
+import { fileURLToPath } from "node:url"
+import { readFileSync } from "node:fs"
+
+import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js"
+import { istanbulCoverageMapFromCoverage } from "./istanbul_coverage_map_from_coverage.js"
+
+export const generateCoverageHtmlDirectory = async (
+  coverage,
+  {
+    rootDirectoryUrl,
+    coverageHtmlDirectoryRelativeUrl,
+    coverageReportSkipEmpty,
+    coverageReportSkipFull,
+  },
+) => {
+  const libReport = requireFromJsenv("istanbul-lib-report")
+  const reports = requireFromJsenv("istanbul-reports")
+
+  const context = libReport.createContext({
+    dir: fileURLToPath(rootDirectoryUrl),
+    coverageMap: istanbulCoverageMapFromCoverage(coverage),
+    sourceFinder: (path) =>
+      readFileSync(new URL(path, rootDirectoryUrl), "utf8"),
+  })
+
+  const report = reports.create("html", {
+    skipEmpty: coverageReportSkipEmpty,
+    skipFull: coverageReportSkipFull,
+    subdir: coverageHtmlDirectoryRelativeUrl,
+  })
+  report.execute(context)
+}

package/src/coverage/coverage_reporter_json_file.js

@@ -0,0 +1,17 @@
+import { writeFile } from "@jsenv/filesystem"
+import { urlToFileSystemPath } from "@jsenv/urls"
+import { byteAsFileSize } from "@jsenv/log"
+
+export const generateCoverageJsonFile = async ({
+  coverage,
+  coverageJsonFileUrl,
+  logger,
+}) => {
+  const coverageAsText = JSON.stringify(coverage, null, "  ")
+  logger.info(
+    `-> ${urlToFileSystemPath(coverageJsonFileUrl)} (${byteAsFileSize(
+      Buffer.byteLength(coverageAsText),
+    )})`,
+  )
+  await writeFile(coverageJsonFileUrl, coverageAsText)
+}

package/src/coverage/coverage_reporter_text_log.js

@@ -0,0 +1,19 @@
+import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js"
+import { istanbulCoverageMapFromCoverage } from "./istanbul_coverage_map_from_coverage.js"
+
+export const generateCoverageTextLog = (
+  coverage,
+  { coverageReportSkipEmpty, coverageReportSkipFull },
+) => {
+  const libReport = requireFromJsenv("istanbul-lib-report")
+  const reports = requireFromJsenv("istanbul-reports")
+
+  const context = libReport.createContext({
+    coverageMap: istanbulCoverageMapFromCoverage(coverage),
+  })
+  const report = reports.create("text", {
+    skipEmpty: coverageReportSkipEmpty,
+    skipFull: coverageReportSkipFull,
+  })
+  report.execute(context)
+}

package/src/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/helpers/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],
+      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/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/coverage/istanbul_coverage_composition.js

@@ -0,0 +1,28 @@
+import { requireFromJsenv } from "@jsenv/core/src/helpers/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/coverage/istanbul_coverage_map_from_coverage.js

@@ -0,0 +1,16 @@
+import { requireFromJsenv } from "@jsenv/core/src/helpers/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/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/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/coverage/report_to_coverage.js

@@ -0,0 +1,198 @@
+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/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/coverage/v8_coverage.js

@@ -0,0 +1,26 @@
+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/coverage/v8_coverage_composition.js

@@ -0,0 +1,24 @@
+import { requireFromJsenv } from "@jsenv/core/src/helpers/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
+}