improve coverage normalization, for now cannot properly merge v8 and istanbul coverage. See istanbuljs/v8-to-istanbul#144

Author: Damien Maillard

Diff for: src/internal/browser-launcher/executeHtmlFile.js

@@ -1,8 +1,11 @@
 import { extname } from "path"
 import { resolveUrl, assertFilePresence } from "@jsenv/util"
+import { normalizeIstanbulCoverage } from "@jsenv/core/src/internal/executing/coverage/normalizeIstanbulCoverage.js"
+import { composeIstanbulCoverages } from "@jsenv/core/src/internal/executing/coverage/composeIstanbulCoverages.js"
+
 import { evalSource } from "../runtime/createNodeRuntime/evalSource.js"
 import { escapeRegexpSpecialCharacters } from "../escapeRegexpSpecialCharacters.js"
-import { composeIstanbulCoverages } from "../executing/coverage/composeIstanbulCoverages.js"
+import { projectDirectoryUrl } from "@jsenv/core/jsenv.config.js"
 
 export const executeHtmlFile = async (
   fileRelativeUrl,
@@ -91,12 +94,19 @@ export const executeHtmlFile = async (
 }
 
 const generateCoverageForPage = (fileExecutionResultMap) => {
-  const coverageMap = composeIstanbulCoverages(
-    ...Object.keys(fileExecutionResultMap).map((fileRelativeUrl) => {
-      return fileExecutionResultMap[fileRelativeUrl].coverageMap || {}
-    }),
-  )
-  return coverageMap
+  const istanbulCoverages = []
+  Object.keys(fileExecutionResultMap).forEach((fileRelativeUrl) => {
+    const istanbulCoverage = fileExecutionResultMap[fileRelativeUrl].coverageMap
+    if (istanbulCoverage) {
+      const istanbulCoverageNormalized = normalizeIstanbulCoverage(
+        istanbulCoverage,
+        projectDirectoryUrl,
+      )
+      istanbulCoverages.push(istanbulCoverageNormalized)
+    }
+  })
+  const istanbulCoverage = composeIstanbulCoverages(...istanbulCoverages)
+  return istanbulCoverage
 }
 
 const evalException = (exceptionSource, { projectDirectoryUrl, compileServerOrigin }) => {

Diff for: src/internal/executing/coverage/composeIstanbulCoverages.js

@@ -1,24 +1,18 @@
 import { require } from "../../require.js"
 
-const { createFileCoverage } = require("istanbul-lib-coverage")
+const { createCoverageMap } = require("istanbul-lib-coverage")
 
 // https://github.com/istanbuljs/istanbuljs/blob/5405550c3868712b14fd8bfe0cbd6f2e7ac42279/packages/istanbul-lib-coverage/lib/coverage-map.js#L43
 export const composeIstanbulCoverages = (...istanbulCoverages) => {
-  const istanbulCoverageComposed = {}
+  const istanbulCoverageMap = createCoverageMap()
   istanbulCoverages.forEach((istanbulCoverage) => {
-    Object.keys(istanbulCoverage).forEach((filename) => {
-      const fileCoverage = istanbulCoverage[filename]
-      istanbulCoverageComposed[filename] =
-        filename in istanbulCoverageComposed
-          ? merge(istanbulCoverageComposed[filename], fileCoverage)
-          : fileCoverage
-    })
+    istanbulCoverageMap.merge(istanbulCoverage)
   })
-  return istanbulCoverageComposed
-}
 
-const merge = (coverageA, coverageB) => {
-  const fileCoverage = createFileCoverage(coverageA)
-  fileCoverage.merge(coverageB)
-  return fileCoverage.toJSON()
+  const istanbulCoverageComposed = {}
+  const coverageMap = istanbulCoverageMap.toJSON()
+  Object.keys(coverageMap).forEach((key) => {
+    istanbulCoverageComposed[key] = coverageMap[key].toJSON()
+  })
+  return istanbulCoverageComposed
 }

Diff for: src/internal/executing/coverage/ensureRelativePathsInCoverage.js

@@ -9,7 +9,7 @@ import {
 } from "@jsenv/util"
 import { require } from "@jsenv/core/src/internal/require.js"
 import { composeIstanbulCoverages } from "./composeIstanbulCoverages.js"
-import { makeIstanbulCoverageRelative } from "./makeIstanbulCoverageRelative.js"
+import { normalizeIstanbulCoverage } from "./normalizeIstanbulCoverage.js"
 
 const { mergeProcessCovs } = require("@c88/v8-coverage")
 
@@ -37,13 +37,11 @@ export const istanbulCoverageFromV8Coverage = async ({
   })
 
   const coverageReport = mergeCoverageReports(coverageReportsFiltered)
-  const instanbulCoverage = await convertV8CoverageToIstanbul(coverageReport, { sourceMapCache })
-  const istanbulCoverageRelative = makeIstanbulCoverageRelative(
-    instanbulCoverage,
+  const istanbulCoverage = await convertV8CoverageToIstanbul(coverageReport, {
     projectDirectoryUrl,
-  )
-
-  return istanbulCoverageRelative
+    sourceMapCache,
+  })
+  return istanbulCoverage
 }
 
 const readV8CoverageReportsFromDirectory = async (coverageDirectory) => {
@@ -93,11 +91,14 @@ const mergeCoverageReports = (coverageReports) => {
   return coverageReport
 }
 
-const convertV8CoverageToIstanbul = async (coverageReport, { sourceMapCache }) => {
+const convertV8CoverageToIstanbul = async (
+  coverageReport,
+  { projectDirectoryUrl, sourceMapCache },
+) => {
   const istanbulCoverages = await Promise.all(
-    coverageReport.result.map(async (fileReport) => {
-      const sources = sourcesFromSourceMapCache(fileReport.url, sourceMapCache)
-      const path = urlToFileSystemPath(fileReport.url)
+    coverageReport.result.map(async (fileV8Coverage) => {
+      const sources = sourcesFromSourceMapCache(fileV8Coverage.url, sourceMapCache)
+      const path = urlToFileSystemPath(fileV8Coverage.url)
       const converter = v8ToIstanbul(
         path,
         // wrapperLength is undefined we don't need it
@@ -107,14 +108,18 @@ const convertV8CoverageToIstanbul = async (coverageReport, { sourceMapCache }) =
       )
       await converter.load()
 
-      converter.applyCoverage(fileReport.functions)
-      const istanbulFileCoverage = converter.toIstanbul()
-      return istanbulFileCoverage
+      converter.applyCoverage(fileV8Coverage.functions)
+      const istanbulCoverage = converter.toIstanbul()
+      const istanbulCoverageNormalized = normalizeIstanbulCoverage(
+        istanbulCoverage,
+        projectDirectoryUrl,
+      )
+      return istanbulCoverageNormalized
     }),
   )
 
-  const istanbulCoverage = composeIstanbulCoverages(...istanbulCoverages)
-  return istanbulCoverage
+  const istanbulCoverageComposed = composeIstanbulCoverages(...istanbulCoverages)
+  return istanbulCoverageComposed
 }
 
 const sourcesFromSourceMapCache = (url, sourceMapCache) => {

Diff for: src/internal/executing/coverage/istanbulCoverageFromV8Coverage.js

@@ -0,0 +1,21 @@
+import { urlToRelativeUrl, fileSystemPathToUrl, isFileSystemPath, resolveUrl } from "@jsenv/util"
+
+export const normalizeIstanbulCoverage = (istanbulCoverage, projectDirectoryUrl) => {
+  const istanbulCoverageNormalized = {}
+
+  Object.keys(istanbulCoverage).forEach((key) => {
+    const fileCoverage = istanbulCoverage[key]
+    const { path } = fileCoverage
+    const url = isFileSystemPath(path)
+      ? fileSystemPathToUrl(path)
+      : resolveUrl(path, projectDirectoryUrl)
+    const relativeUrl = urlToRelativeUrl(url, projectDirectoryUrl)
+
+    istanbulCoverageNormalized[`./${relativeUrl}`] = {
+      ...fileCoverage,
+      path: `./${relativeUrl}`,
+    }
+  })
+
+  return istanbulCoverageNormalized
+}

Diff for: src/internal/executing/coverage/makeIstanbulCoverageRelative.js

@@ -1,7 +1,7 @@
 import { collectFiles } from "@jsenv/util"
 import { relativeUrlToEmptyCoverage } from "./relativeUrlToEmptyCoverage.js"
 import { composeIstanbulCoverages } from "./composeIstanbulCoverages.js"
-import { ensureRelativePathsInCoverage } from "./ensureRelativePathsInCoverage.js"
+import { normalizeIstanbulCoverage } from "./normalizeIstanbulCoverage.js"
 
 export const reportToCoverageMap = async (
   report,
@@ -16,7 +16,7 @@ export const reportToCoverageMap = async (
   const coverageMapForReport = executionReportToCoverageMap(report)
 
   if (!coverageIncludeMissing) {
-    return ensureRelativePathsInCoverage(coverageMapForReport)
+    return coverageMapForReport
   }
 
   const relativeFileUrlToCoverArray = await listRelativeFileUrlToCover({
@@ -26,7 +26,10 @@ export const reportToCoverageMap = async (
   })
 
   const relativeFileUrlMissingCoverageArray = relativeFileUrlToCoverArray.filter(
-    (relativeFileUrlToCover) => relativeFileUrlToCover in coverageMapForReport === false,
+    (relativeFileUrlToCover) =>
+      Object.keys(coverageMapForReport).every((key) => {
+        return key !== `./${relativeFileUrlToCover}`
+      }),
   )
 
   const coverageMapForMissedFiles = {}
@@ -42,10 +45,10 @@ export const reportToCoverageMap = async (
     }),
   )
 
-  return ensureRelativePathsInCoverage({
-    ...coverageMapForReport,
-    ...coverageMapForMissedFiles,
-  })
+  return {
+    ...coverageMapForReport, // already normalized
+    ...normalizeIstanbulCoverage(coverageMapForMissedFiles, projectDirectoryUrl),
+  }
 }
 
 const listRelativeFileUrlToCover = async ({
@@ -101,6 +104,7 @@ const executionReportToCoverageMap = (report) => {
     })
   })
 
+  debugger
   const executionCoverageMap = composeIstanbulCoverages(...coverageMapArray)
 
   return executionCoverageMap

Diff for: src/internal/executing/coverage/normalizeIstanbulCoverage.js

@@ -22,20 +22,20 @@ const testPlan = {
     chromium: {
       launch: launchChromium,
     },
-    firefox: {
-      launch: launchFirefox,
-    },
-    webkit: {
-      launch: launchWebkit,
-    },
+    // firefox: {
+    //   launch: launchFirefox,
+    // },
+    // webkit: {
+    //   launch: launchWebkit,
+    // },
   },
   [fileRelativeUrl]: {
     node: {
       launch: launchNode,
     },
-    node2: {
-      launch: launchNode,
-    },
+    // node2: {
+    //   launch: launchNode,
+    // },
   },
 }
 
@@ -47,10 +47,13 @@ const { coverageMap } = await executeTestPlan({
   coverageConfig: {
     [`./${testDirectoryRelativeUrl}file.js`]: true,
   },
+  // concurrencyLimit: 1,
+  logLevel: "info",
+  coverageHtmlDirectory: true,
 })
 const actual = coverageMap
 const expected = {
-  [`${testDirectoryRelativeUrl}file.js`]: {
+  [`./${testDirectoryRelativeUrl}file.js`]: {
     ...coverageMap[`${testDirectoryRelativeUrl}file.js`],
     path: `./${testDirectoryRelativeUrl}file.js`,
     s: { 0: 5, 1: 3, 2: 2, 3: 2, 4: 0 },

Diff for: src/internal/executing/coverage/reportToCoverageMap.js

@@ -1,4 +1,4 @@
-/* eslint-env browser */
+/* eslint-env browser, node */
 if (typeof window === "object") {
   console.log("browser")
 } else if (typeof process === "object") {