@jsenv/core 23.3.0 → 23.5.0

package/src/internal/executing/launchAndExecute.js

@@ -1,7 +1,9 @@
+import cuid from "cuid"
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
 import { Abort, raceCallbacks } from "@jsenv/abort"
+import { resolveUrl, writeFile } from "@jsenv/filesystem"
 
-import { composeIstanbulCoverages } from "./coverage/composeIstanbulCoverages.js"
+import { composeTwoFileByFileIstanbulCoverages } from "./coverage_utils/istanbul_coverage_composition.js"
 
 export const launchAndExecute = async ({
   signal = new AbortController().signal,
@@ -12,13 +14,11 @@ export const launchAndExecute = async ({
   executeParams,
 
   allocatedMs,
-  measureDuration = false,
   mirrorConsole = false,
   captureConsole = false, // rename collectConsole ?
-  collectRuntimeName = false,
-  collectRuntimeVersion = false,
   inheritCoverage = false,
   collectCoverage = false,
+  coverageTempDirectoryUrl,
   measurePerformance,
   collectPerformance = false,
 
@@ -39,8 +39,6 @@ export const launchAndExecute = async ({
     // by default throw on error after execution
     throw error
   },
-
-  coverageV8MergeConflictIsExpected,
 } = {}) => {
   const logger = createLogger({ logLevel: launchAndExecuteLogLevel })
 
@@ -101,25 +99,14 @@ export const launchAndExecute = async ({
     )
   }
 
-  if (collectRuntimeName) {
-    executionResultTransformer = composeTransformer(
-      executionResultTransformer,
-      (executionResult) => {
-        executionResult.runtimeName = runtime.name
-        return executionResult
-      },
-    )
-  }
-
-  if (collectRuntimeVersion) {
-    executionResultTransformer = composeTransformer(
-      executionResultTransformer,
-      (executionResult) => {
-        executionResult.runtimeVersion = runtime.version
-        return executionResult
-      },
-    )
-  }
+  executionResultTransformer = composeTransformer(
+    executionResultTransformer,
+    (executionResult) => {
+      executionResult.runtimeName = runtime.name
+      executionResult.runtimeVersion = runtime.version
+      return executionResult
+    },
+  )
 
   if (
     inheritCoverage &&
@@ -131,40 +118,61 @@ export const launchAndExecute = async ({
     executionResultTransformer = composeTransformer(
       executionResultTransformer,
       (executionResult) => {
-        const { coverage, ...rest } = executionResult
-        // ensure the coverage of the executed file is taken into account
-        global.__coverage__ = composeIstanbulCoverages([
+        const { coverage } = executionResult
+        // propagate coverage from execution to this process
+        global.__coverage__ = composeTwoFileByFileIstanbulCoverages(
           global.__coverage__ || {},
           coverage || {},
-        ])
-        if (collectCoverageSaved) {
-          return executionResult
+        )
+
+        if (!collectCoverageSaved) {
+          delete executionResult.coverage
         }
-        return rest
+
+        return executionResult
       },
     )
   }
 
-  // indirectCoverage is a feature making possible to collect
-  // coverage generated by executing a node process which executes
-  // a browser. The coverage coming the browser executionwould be lost
-  // if not propagated somehow.
-  // This is possible if the node process collect the browser coverage
-  // and write it into global.__indirectCoverage__
-  // This is used by jsenv during tests execution
   if (collectCoverage) {
     executionResultTransformer = composeTransformer(
       executionResultTransformer,
-      (executionResult) => {
-        const { coverage = {}, indirectCoverage } = executionResult
+      async (executionResult) => {
+        // we do not keep coverage in memory, it can grow very big
+        // instead we store it on the filesystem, they will be read and merged together later on
+        // in "executeConcurrently"
+        const { coverage } = executionResult
+        if (coverage) {
+          const coverageFileUrl = resolveUrl(
+            `./${runtime.name}/${cuid()}`,
+            coverageTempDirectoryUrl,
+          )
+          await writeFile(coverageFileUrl, JSON.stringify(coverage, null, "  "))
+          executionResult.coverageFileUrl = coverageFileUrl
+          delete executionResult.coverage
+        }
+
+        // indirectCoverage is a feature making possible to collect
+        // coverage generated by executing a node process which executes
+        // a browser. The coverage coming the browser execution would be lost
+        // if not propagated somehow.
+        // This is possible if the node process collect the browser coverage
+        // and write it into global.__indirectCoverage__
+        // This is used by jsenv during tests execution
+        const { indirectCoverage } = executionResult
         if (indirectCoverage) {
-          executionResult.coverage = composeIstanbulCoverages(
-            [coverage, indirectCoverage],
-            {
-              coverageV8MergeConflictIsExpected,
-            },
+          const indirectCoverageFileUrl = resolveUrl(
+            `./${runtime.name}/${cuid()}`,
+            coverageTempDirectoryUrl,
+          )
+          await writeFile(
+            indirectCoverageFileUrl,
+            JSON.stringify(indirectCoverage, null, "  "),
           )
+          executionResult.indirectCoverageFileUrl = indirectCoverageFileUrl
+          delete executionResult.indirectCoverage
         }
+
         return executionResult
       },
     )
@@ -176,23 +184,20 @@ export const launchAndExecute = async ({
         // executionResult.coverage is undefined or {}
         // we delete it just to have a cleaner object
         delete executionResult.coverage
+        delete executionResult.indirectCoverage
         return executionResult
       },
     )
   }
 
-  if (measureDuration) {
-    const startMs = Date.now()
-    executionResultTransformer = composeTransformer(
-      executionResultTransformer,
-      (executionResult) => {
-        const endMs = Date.now()
-        executionResult.startMs = startMs
-        executionResult.endMs = endMs
-        return executionResult
-      },
-    )
-  }
+  const startMs = Date.now()
+  executionResultTransformer = composeTransformer(
+    executionResultTransformer,
+    (executionResult) => {
+      executionResult.duration = Date.now() - startMs
+      return executionResult
+    },
+  )
 
   try {
     const runtimeLabel = `${runtime.name}/${runtime.version}`

package/src/internal/logs/msAsDuration.js

@@ -2,10 +2,11 @@ import { require } from "../require.js"
 
 const humanizeDuration = require("humanize-duration")
 
-export const msAsDuration = (metricValue) => {
-  return humanizeDuration(metricValue, {
+export const msAsDuration = (ms) => {
+  return humanizeDuration(ms, {
     largest: 2,
-    maxDecimalPoints: metricValue < 0.1 ? 3 : metricValue < 1000 ? 2 : 1,
+    maxDecimalPoints: ms < 0.1 ? 3 : ms < 1000 ? 2 : ms < 60000 ? 1 : 0,
+    delimiter: " and ",
     // units: ["s"]
   })
 }

package/src/launchBrowser.js

@@ -37,7 +37,7 @@ chromiumRuntime.launch = async ({
   collectPerformance,
   measurePerformance,
   collectCoverage,
-  coverageConfig,
+  coverageIgnorePredicate,
   coverageForceIstanbul,
 
   headless = true,
@@ -115,7 +115,7 @@ chromiumRuntime.launch = async ({
     collectPerformance,
     measurePerformance,
     collectCoverage,
-    coverageConfig,
+    coverageIgnorePredicate,
     coverageForceIstanbul,
     coveragePlaywrightAPIAvailable: true,
   })
@@ -151,7 +151,7 @@ firefoxRuntime.launch = async ({
   collectPerformance,
   measurePerformance,
   collectCoverage,
-  coverageConfig,
+  coverageIgnorePredicate,
   coverageForceIstanbul,
 
   headless = true,
@@ -194,7 +194,7 @@ firefoxRuntime.launch = async ({
     collectPerformance,
     measurePerformance,
     collectCoverage,
-    coverageConfig,
+    coverageIgnorePredicate,
     coverageForceIstanbul,
   })
 
@@ -229,7 +229,7 @@ webkitRuntime.launch = async ({
   collectPerformance,
   measurePerformance,
   collectCoverage,
-  coverageConfig,
+  coverageIgnorePredicate,
   coverageForceIstanbul,
 
   headless = true,
@@ -272,7 +272,7 @@ webkitRuntime.launch = async ({
     collectPerformance,
     measurePerformance,
     collectCoverage,
-    coverageConfig,
+    coverageIgnorePredicate,
     coverageForceIstanbul,
     ignoreErrorHook: (error) => {
       // we catch error during execution but safari throw unhandled rejection
@@ -378,7 +378,7 @@ const browserToRuntimeHooks = (
     collectPerformance,
     measurePerformance,
     collectCoverage,
-    coverageConfig,
+    coverageIgnorePredicate,
     coverageForceIstanbul,
     coveragePlaywrightAPIAvailable = false,
     ignoreErrorHook = () => false,
@@ -451,9 +451,9 @@ const browserToRuntimeHooks = (
       measurePerformance,
       collectPerformance,
       collectCoverage,
-      coverageConfig,
       coverageForceIstanbul,
       coveragePlaywrightAPIAvailable,
+      coverageIgnorePredicate,
       transformErrorHook,
     })
     return result

package/src/launchNode.js

@@ -1,18 +1,9 @@
 import { Script } from "node:vm"
-import cuid from "cuid"
 import { loggerToLogLevel } from "@jsenv/logger"
-import {
-  writeDirectory,
-  resolveUrl,
-  urlToFileSystemPath,
-  removeFileSystemNode,
-  moveDirectoryContent,
-} from "@jsenv/filesystem"
 
 import { jsenvCoreDirectoryUrl } from "@jsenv/core/src/internal/jsenvCoreDirectoryUrl.js"
 import { escapeRegexpSpecialCharacters } from "./internal/escapeRegexpSpecialCharacters.js"
 import { createControllableNodeProcess } from "./internal/node-launcher/createControllableNodeProcess.js"
-import { v8CoverageFromNodeV8Directory } from "./internal/executing/coverage/v8CoverageFromNodeV8Directory.js"
 
 export const nodeRuntime = {
   name: "node",
@@ -30,8 +21,8 @@ nodeRuntime.launch = async ({
   measurePerformance,
   collectPerformance,
   collectCoverage = false,
-  coverageConfig,
   coverageForceIstanbul,
+  coverageConfig,
 
   debugPort,
   debugMode,
@@ -69,59 +60,10 @@ nodeRuntime.launch = async ({
     JSENV: true,
   }
 
-  let finalizeExecutionResult
-
-  if (collectCoverage) {
-    // v8 coverage is written in a directoy and auto propagate to subprocesses
-    // through process.env.NODE_V8_COVERAGE.
-
-    if (coverageForceIstanbul) {
-      // if we want to force istanbul, we will set process.env.NODE_V8_COVERAGE = ''
-      // into the child_process
-      env.NODE_V8_COVERAGE = ""
-    }
-    // } else if (process.env.NODE_V8_COVERAGE) {
-    //   // The V8_COVERAGE was already set by a parent process or command line.
-    //   // It's the caller that is interested into coverage, it's not anymore this script
-    //   // responsability to set process.env.NODE_V8_COVERAGE nor to read
-    //   // coverage files in the v8 directory.
-    // }
-    // In fact it is so that it's possible to go coverageception:
-    // jsenv collect coverage for tests
-    // which are testing that coverage can be collected for tests
-    // this is possible because we overriding the child process NODE_V8_COVERAGE
-    else {
-      const NODE_V8_COVERAGE = await getNodeV8CoverageDir({
-        projectDirectoryUrl,
-      })
-      env.NODE_V8_COVERAGE = NODE_V8_COVERAGE
-
-      // the v8 coverage directory is available once the child process is disconnected
-      finalizeExecutionResult = async (executionResult) => {
-        if (
-          executionResult.status === "timedout" ||
-          executionResult.status === "aborted"
-        ) {
-          return executionResult
-        }
-
-        const coverage = await ensureV8CoverageDirClean(async () => {
-          // prefer istanbul if available
-          if (executionResult.coverage) {
-            return executionResult.coverage
-          }
-
-          const v8Coverage = await v8CoverageFromNodeV8Directory({
-            projectDirectoryUrl,
-            NODE_V8_COVERAGE,
-            coverageConfig,
-          })
-          return v8Coverage
-        }, NODE_V8_COVERAGE)
-        executionResult.coverage = coverage
-        return executionResult
-      }
-    }
+  if (coverageForceIstanbul) {
+    // if we want to force istanbul, we will set process.env.NODE_V8_COVERAGE = ''
+    // into the child_process
+    env.NODE_V8_COVERAGE = ""
   }
 
   commandLineOptions = [
@@ -198,39 +140,9 @@ nodeRuntime.launch = async ({
     outputCallbackList,
     stop,
     execute,
-    finalizeExecutionResult,
   }
 }
 
-const ensureV8CoverageDirClean = async (fn, NODE_V8_COVERAGE) => {
-  try {
-    return await fn()
-  } finally {
-    if (process.env.NODE_V8_COVERAGE === NODE_V8_COVERAGE) {
-      // do not try to remove or copy coverage
-    } else if (process.env.NODE_V8_COVERAGE) {
-      await moveDirectoryContent({
-        from: NODE_V8_COVERAGE,
-        to: process.env.NODE_V8_COVERAGE,
-      })
-      await removeFileSystemNode(NODE_V8_COVERAGE, {})
-    } else {
-      await removeFileSystemNode(NODE_V8_COVERAGE, {
-        recursive: true,
-      })
-    }
-  }
-}
-
-const getNodeV8CoverageDir = async ({ projectDirectoryUrl }) => {
-  const v8CoverageDirectory = resolveUrl(
-    `./coverage-v8/${cuid()}`,
-    projectDirectoryUrl,
-  )
-  await writeDirectory(v8CoverageDirectory, { allowUseless: true })
-  return urlToFileSystemPath(v8CoverageDirectory)
-}
-
 const transformExecutionResult = (
   executionResult,
   { compileServerOrigin, projectDirectoryUrl },

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

@@ -1,108 +0,0 @@
-import { require } from "../../require.js"
-
-// https://github.com/istanbuljs/istanbuljs/blob/5405550c3868712b14fd8bfe0cbd6f2e7ac42279/packages/istanbul-lib-coverage/lib/coverage-map.js#L43
-export const composeIstanbulCoverages = (
-  istanbulCoverages,
-  { coverageV8MergeConflictIsExpected = false } = {},
-) => {
-  const coverageComposed = {}
-
-  // we can't merge coverage coming from code instrumented by istanbul
-  // with coverage coming from v8 and converted to istanbul, so we want to:
-  // 1. Have istanbul and v8 as long as they don't cover the same file
-  // 2. Choose istanbul or v8 depending which one cover the most
-  // To do that we first merge all v8 together and istanbul together
-  // To be able to know which one covers the most in case of merge conflict
-  const coverageFromV8Conversion = {}
-  const coverageFromIstanbul = {}
-  istanbulCoverages.forEach((istanbulCoverage) => {
-    Object.keys(istanbulCoverage).forEach((key) => {
-      const istanbulFileCoverage = istanbulCoverage[key]
-      if (istanbulFileCoverage.fromV8) {
-        const existingCoverageForFile = coverageFromV8Conversion[key]
-        if (existingCoverageForFile) {
-          coverageFromV8Conversion[key] = merge(existingCoverageForFile, istanbulFileCoverage)
-        } else {
-          coverageFromV8Conversion[key] = istanbulFileCoverage
-        }
-      } else {
-        const existingCoverageForFile = coverageFromIstanbul[key]
-        if (existingCoverageForFile) {
-          coverageFromIstanbul[key] = merge(existingCoverageForFile, istanbulFileCoverage)
-        } else {
-          coverageFromIstanbul[key] = istanbulFileCoverage
-        }
-      }
-    })
-  })
-
-  Object.keys(coverageFromV8Conversion).forEach((key) => {
-    const fileCoverageFromV8 = coverageFromV8Conversion[key]
-    const fileCoverageFromIstanbul = coverageFromIstanbul[key]
-    if (fileCoverageFromIstanbul) {
-      const v8HitCount = hitCountFromFileCoverage(fileCoverageFromV8)
-      const istanbulHitCount = hitCountFromFileCoverage(fileCoverageFromIstanbul)
-      const coverageWithMostHit =
-        v8HitCount >= istanbulHitCount ? fileCoverageFromV8 : fileCoverageFromIstanbul
-
-      if (!coverageV8MergeConflictIsExpected) {
-        // ideally when coverageV8MergeConflictIsExpected it would be a console.debug
-        console.warn(
-          formatMergeConflictBetweenV8AndIstanbulWarning({
-            fileRelativeUrl: key,
-            coverageKept: coverageWithMostHit,
-          }),
-        )
-      }
-      coverageComposed[key] = coverageWithMostHit
-    } else {
-      coverageComposed[key] = fileCoverageFromV8
-    }
-  })
-
-  Object.keys(coverageFromIstanbul).forEach((key) => {
-    const fileCoverageFromIstanbul = coverageFromIstanbul[key]
-    const fileCoverageFromV8 = coverageFromV8Conversion[key]
-    if (fileCoverageFromV8) {
-      // already handled
-    } else {
-      coverageComposed[key] = fileCoverageFromIstanbul
-    }
-  })
-
-  return coverageComposed
-}
-
-const hitCountFromFileCoverage = ({ b, s }) => {
-  const statementHitCount = Object.keys(s).reduce((previous, key) => {
-    return previous + s[key]
-  }, 0)
-
-  const branchHitCount = Object.keys(b).reduce((previous, key) => {
-    const branchCount = b[key].reduce((previous, count) => {
-      return previous + count
-    }, 0)
-    return previous + branchCount
-  }, 0)
-
-  return statementHitCount + branchHitCount
-}
-
-const merge = (istanbulFileCoverageA, istanbulFileCoverageB) => {
-  const { createFileCoverage } = require("istanbul-lib-coverage")
-  const istanbulFileCoverageObject = createFileCoverage(istanbulFileCoverageA)
-  istanbulFileCoverageObject.merge(istanbulFileCoverageB)
-  return istanbulFileCoverageObject.toJSON()
-}
-
-const formatMergeConflictBetweenV8AndIstanbulWarning = ({ fileRelativeUrl, coverageKept }) => {
-  return `Cannot merge file coverage coming from v8 and istanbul.
-The one with most branch coverage will be kept and the other ignored.
---- coverage kept ---
-${coverageKept.fromV8 ? "v8" : "istanbul"}
---- file ---
-${fileRelativeUrl}
---- suggestion ---
-If this is expected use coverageV8MergeConflictIsExpected to disable this warning
-`
-}

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

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

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

@@ -1,43 +0,0 @@
-/**
- *
- * The goal is to get an istanbul coverage from a list of coverage that are either
- * v8Coverage or istanbul coverage
- *
- */
-
-import { composeV8Coverages } from "./composeV8Coverages.js"
-import { composeIstanbulCoverages } from "./composeIstanbulCoverages.js"
-import { istanbulCoverageFromV8Coverage } from "./istanbulCoverageFromV8Coverage.js"
-import { normalizeIstanbulCoverage } from "./normalizeIstanbulCoverage.js"
-
-export const istanbulCoverageFromCoverages = async (
-  coverages,
-  { projectDirectoryUrl, coverageV8MergeConflictIsExpected },
-) => {
-  const v8Coverages = []
-  const istanbulCoverages = []
-
-  coverages.forEach((coverage) => {
-    if (coverage.result) {
-      v8Coverages.push(coverage)
-    } else {
-      istanbulCoverages.push(normalizeIstanbulCoverage(coverage, projectDirectoryUrl))
-    }
-  })
-
-  const v8CoverageComposed = composeV8Coverages(v8Coverages)
-  const istanbulCoverageComposed = composeIstanbulCoverages(istanbulCoverages)
-  const istanbulCoverageFromV8CoverageComposed = await istanbulCoverageFromV8Coverage(
-    v8CoverageComposed,
-  )
-  const istanbulCoverage = composeIstanbulCoverages(
-    [
-      istanbulCoverageComposed,
-      normalizeIstanbulCoverage(istanbulCoverageFromV8CoverageComposed, projectDirectoryUrl),
-    ],
-    {
-      coverageV8MergeConflictIsExpected,
-    },
-  )
-  return istanbulCoverage
-}

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

@@ -1,40 +0,0 @@
-import { resolveUrl, normalizeStructuredMetaMap, urlToMeta } from "@jsenv/filesystem"
-
-import { composeV8Coverages } from "./composeV8Coverages.js"
-
-export const v8CoverageFromAllV8Coverages = (
-  allV8Coverages,
-  { coverageRootUrl, coverageConfig },
-) => {
-  const v8Coverages = filterCoverageReports(allV8Coverages, {
-    coverageRootUrl,
-    coverageConfig,
-  })
-
-  const v8Coverage = composeV8Coverages(v8Coverages)
-  return v8Coverage
-}
-
-const filterCoverageReports = (coverageReports, { coverageRootUrl, coverageConfig }) => {
-  const structuredMetaMapForCover = normalizeStructuredMetaMap(
-    {
-      cover: coverageConfig,
-    },
-    coverageRootUrl,
-  )
-  const shouldIgnoreCoverage = (url) => {
-    return !urlToMeta({
-      url: resolveUrl(url, coverageRootUrl),
-      structuredMetaMap: structuredMetaMapForCover,
-    }).cover
-  }
-
-  return coverageReports.map((coverageReport) => {
-    return {
-      ...coverageReport,
-      result: coverageReport.result.filter((fileReport) => {
-        return !shouldIgnoreCoverage(fileReport.url)
-      }),
-    }
-  })
-}

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

@@ -1,67 +0,0 @@
-import {
-  assertAndNormalizeDirectoryUrl,
-  readDirectory,
-  readFile,
-  resolveUrl,
-} from "@jsenv/filesystem"
-import { createDetailedMessage } from "@jsenv/logger"
-
-import { v8CoverageFromAllV8Coverages } from "./v8CoverageFromAllV8Coverages.js"
-
-export const v8CoverageFromNodeV8Directory = async ({
-  projectDirectoryUrl,
-  NODE_V8_COVERAGE,
-  coverageConfig,
-}) => {
-  const allV8Coverages = await readV8CoverageReportsFromDirectory(
-    NODE_V8_COVERAGE,
-  )
-
-  const v8Coverage = v8CoverageFromAllV8Coverages(allV8Coverages, {
-    coverageRootUrl: projectDirectoryUrl,
-    coverageConfig,
-  })
-
-  return v8Coverage
-}
-
-const readV8CoverageReportsFromDirectory = async (coverageDirectory) => {
-  const tryReadDirectory = async () => {
-    const dirContent = await readDirectory(coverageDirectory)
-    if (dirContent.length > 0) {
-      return dirContent
-    }
-    console.warn(`v8 coverage directory is empty at ${coverageDirectory}`)
-    return dirContent
-  }
-  const dirContent = await tryReadDirectory()
-
-  const coverageReports = []
-  const coverageDirectoryUrl = assertAndNormalizeDirectoryUrl(coverageDirectory)
-  await Promise.all(
-    dirContent.map(async (dirEntry) => {
-      const dirEntryUrl = resolveUrl(dirEntry, coverageDirectoryUrl)
-      const tryReadJsonFile = async () => {
-        try {
-          const fileContent = await readFile(dirEntryUrl, { as: "json" })
-          return fileContent
-        } catch (e) {
-          console.warn(
-            createDetailedMessage(`Error while reading coverage file`, {
-              "error stack": e.stack,
-              "file": dirEntryUrl,
-            }),
-          )
-          return null
-        }
-      }
-
-      const fileContent = await tryReadJsonFile()
-      if (fileContent) {
-        coverageReports.push(fileContent)
-      }
-    }),
-  )
-
-  return coverageReports
-}