@jsenv/core 23.4.1 → 23.5.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "23.4.1",
+  "version": "23.5.2",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "repository": {
@@ -11,8 +11,7 @@
     "node": ">=14.9.0"
   },
   "publishConfig": {
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
+    "access": "public"
   },
   "type": "module",
   "exports": {
@@ -63,12 +62,12 @@
     "@babel/plugin-syntax-numeric-separator": "7.10.4",
     "@babel/plugin-transform-modules-systemjs": "7.15.4",
     "@c88/v8-coverage": "0.1.1",
-    "@jsenv/abort": "4.0.0",
-    "@jsenv/filesystem": "2.5.0",
+    "@jsenv/abort": "4.1.1",
+    "@jsenv/filesystem": "2.5.1",
     "@jsenv/importmap": "1.1.0",
-    "@jsenv/log": "1.1.0",
+    "@jsenv/log": "1.4.0",
     "@jsenv/logger": "4.0.1",
-    "@jsenv/server": "10.0.0",
+    "@jsenv/server": "10.0.4",
     "@jsenv/uneval": "1.6.0",
     "@jsenv/workers": "1.2.0",
     "@rollup/plugin-commonjs": "21.0.0",

package/src/execute.js

@@ -27,11 +27,8 @@ export const execute = async ({
   runtimeParams,
 
   allocatedMs,
-  measureDuration,
   mirrorConsole = true,
   captureConsole,
-  collectRuntimeName,
-  collectRuntimeVersion,
   inheritCoverage,
   collectCoverage,
   measurePerformance,
@@ -139,11 +136,8 @@ export const execute = async ({
       },
 
       allocatedMs,
-      measureDuration,
       mirrorConsole,
       captureConsole,
-      collectRuntimeName,
-      collectRuntimeVersion,
       inheritCoverage,
       collectCoverage,
       measurePerformance,

package/src/executeTestPlan.js

@@ -33,13 +33,13 @@ export const executeTestPlan = async ({
 
   testPlan,
   defaultMsAllocatedPerExecution,
+  cooldownBetweenExecutions,
 
   maxExecutionsInParallel,
 
   completedExecutionLogAbbreviation = false,
   completedExecutionLogMerging = false,
   logSummary = true,
-  measureGlobalDuration = true,
   updateProcessExitCode = true,
 
   coverage = process.argv.includes("--cover") ||
@@ -144,10 +144,10 @@ export const executeTestPlan = async ({
 
     defaultMsAllocatedPerExecution,
     maxExecutionsInParallel,
+    cooldownBetweenExecutions,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
     logSummary,
-    measureGlobalDuration,
 
     coverage,
     coverageConfig,
@@ -225,6 +225,7 @@ export const executeTestPlan = async ({
   }
 
   return {
+    testPlanAborted: result.aborted,
     testPlanSummary: result.planSummary,
     testPlanReport: result.planReport,
     testPlanCoverage: planCoverage,

package/src/internal/compiling/createCompiledFileService.js

@@ -71,7 +71,10 @@ export const createCompiledFileService = ({
 
   return (request) => {
     const { origin, ressource } = request
-    const requestUrl = `${origin}${ressource}`
+    // we use "ressourceToPathname" to remove eventual query param from the url
+    // Without this a pattern like "**/*.js" would not match "file.js?t=1"
+    // This would result in file not being compiled when they should
+    const requestUrl = `${origin}${ressourceToPathname(ressource)}`
 
     const requestCompileInfo = serverUrlToCompileInfo(requestUrl, {
       outDirectoryRelativeUrl,
@@ -276,3 +279,12 @@ const babelPluginMapFromCompileId = (
 
   return babelPluginMapForGroup
 }
+
+const ressourceToPathname = (ressource) => {
+  const searchSeparatorIndex = ressource.indexOf("?")
+  const pathname =
+    searchSeparatorIndex === -1
+      ? ressource
+      : ressource.slice(0, searchSeparatorIndex)
+  return pathname
+}

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

@@ -1,4 +1,5 @@
 import { readFile } from "@jsenv/filesystem"
+import { Abort } from "@jsenv/abort"
 
 import {
   visitNodeV8Directory,
@@ -9,13 +10,12 @@ import { composeTwoFileByFileIstanbulCoverages } from "../coverage_utils/istanbu
 import { v8CoverageToIstanbul } from "../coverage_utils/v8_coverage_to_istanbul.js"
 import { composeV8AndIstanbul } from "../coverage_utils/v8_and_istanbul.js"
 import { normalizeFileByFileCoveragePaths } from "../coverage_utils/file_by_file_coverage.js"
-import { listRelativeFileUrlToCover } from "../coverage_empty/list_files_not_covered.js"
-import { relativeUrlToEmptyCoverage } from "../coverage_empty/relativeUrlToEmptyCoverage.js"
+import { getMissingFileByFileCoverage } from "../coverage_missing/missing_coverage.js"
 
 export const reportToCoverage = async (
   report,
   {
-    multipleExecutionsOperation,
+    signal,
     logger,
     projectDirectoryUrl,
     babelPluginMap,
@@ -26,70 +26,39 @@ export const reportToCoverage = async (
     coverageV8ConflictWarning,
   },
 ) => {
-  let v8Coverage
-  let fileByFileIstanbulCoverage
-
   // collect v8 and istanbul coverage from executions
-  await Object.keys(report).reduce(async (previous, file) => {
-    await previous
-
-    const executionResultForFile = report[file]
-    await Object.keys(executionResultForFile).reduce(
-      async (previous, executionName) => {
-        await previous
-
-        const executionResultForFileOnRuntime =
-          executionResultForFile[executionName]
-        const { status, coverageFileUrl } = executionResultForFileOnRuntime
-        if (!coverageFileUrl) {
-          // 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 (status === "completed") {
-            logger.debug(
-              `No execution.coverageFileUrl from execution named "${executionName}" of ${file}`,
-            )
-          }
-          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())
+  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") {
+        logger.debug(
+          `No execution.coverageFileUrl from execution named "${executionName}" of ${file}`,
+        )
+      }
+    },
+  })
 
   if (!coverageForceIstanbul && process.env.NODE_V8_COVERAGE) {
     await visitNodeV8Directory({
-      signal: multipleExecutionsOperation.signal,
+      signal,
       NODE_V8_COVERAGE: process.env.NODE_V8_COVERAGE,
       onV8Coverage: (nodeV8Coverage) => {
         const nodeV8CoverageLight = filterV8Coverage(nodeV8Coverage, {
@@ -105,7 +74,9 @@ export const reportToCoverage = async (
   // try to merge v8 with istanbul, if any
   let fileByFileCoverage
   if (v8Coverage) {
-    let v8FileByFileCoverage = await v8CoverageToIstanbul(v8Coverage)
+    let v8FileByFileCoverage = await v8CoverageToIstanbul(v8Coverage, {
+      signal,
+    })
 
     v8FileByFileCoverage = normalizeFileByFileCoveragePaths(
       v8FileByFileCoverage,
@@ -140,34 +111,77 @@ export const reportToCoverage = async (
 
   // now add coverage for file not covered
   if (coverageIncludeMissing) {
-    const relativeUrlsToCover = await listRelativeFileUrlToCover({
-      multipleExecutionsOperation,
+    const missingFileByFileCoverage = await getMissingFileByFileCoverage({
+      signal,
       projectDirectoryUrl,
       coverageConfig,
+      fileByFileCoverage,
+      babelPluginMap,
     })
+    Object.assign(fileByFileCoverage, missingFileByFileCoverage)
+  }
 
-    const relativeUrlsMissing = relativeUrlsToCover.filter(
-      (relativeUrlToCover) =>
-        Object.keys(fileByFileCoverage).every((key) => {
-          return key !== `./${relativeUrlToCover}`
-        }),
-    )
+  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
+          }
 
-    await relativeUrlsMissing.reduce(async (previous, relativeUrlMissing) => {
-      const emptyCoverage = await relativeUrlToEmptyCoverage(
-        relativeUrlMissing,
-        {
-          multipleExecutionsOperation,
-          projectDirectoryUrl,
-          babelPluginMap,
+          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(),
       )
-      fileByFileCoverage[`./${relativeUrlMissing}`] = emptyCoverage
-      return emptyCoverage
     }, Promise.resolve())
-  }
 
-  return fileByFileCoverage
+    return {
+      v8Coverage,
+      fileByFileIstanbulCoverage,
+    }
+  } finally {
+    await operation.end()
+  }
 }
 
 const isV8Coverage = (coverage) => Boolean(coverage.result)

package/src/internal/executing/{coverage_empty → coverage_missing}/list_files_not_covered.js

@@ -1,7 +1,7 @@
 import { collectFiles } from "@jsenv/filesystem"
 
 export const listRelativeFileUrlToCover = async ({
-  multipleExecutionsOperation,
+  signal,
   projectDirectoryUrl,
   coverageConfig,
 }) => {
@@ -10,7 +10,7 @@ export const listRelativeFileUrlToCover = async ({
   }
 
   const matchingFileResultArray = await collectFiles({
-    signal: multipleExecutionsOperation.signal,
+    signal,
     directoryUrl: projectDirectoryUrl,
     structuredMetaMap: structuredMetaMapForCoverage,
     predicate: ({ cover }) => cover,

package/src/internal/executing/coverage_missing/missing_coverage.js

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

package/src/internal/executing/{coverage_empty → coverage_missing}/relativeUrlToEmptyCoverage.js

@@ -1,4 +1,5 @@
 import { resolveUrl, urlToFileSystemPath, readFile } from "@jsenv/filesystem"
+import { Abort } from "@jsenv/abort"
 
 import {
   babelPluginsFromBabelPluginMap,
@@ -9,22 +10,23 @@ import { createEmptyCoverage } from "./createEmptyCoverage.js"
 
 export const relativeUrlToEmptyCoverage = async (
   relativeUrl,
-  { multipleExecutionsOperation, projectDirectoryUrl, babelPluginMap },
+  { signal, projectDirectoryUrl, babelPluginMap },
 ) => {
-  const { transformAsync } = await import("@babel/core")
-
-  const fileUrl = resolveUrl(relativeUrl, projectDirectoryUrl)
-  multipleExecutionsOperation.throwIfAborted()
-  const source = await readFile(fileUrl)
+  const operation = Abort.startOperation()
+  operation.addAbortSignal(signal)
 
   try {
+    const { transformAsync } = await import("@babel/core")
+    const fileUrl = resolveUrl(relativeUrl, projectDirectoryUrl)
+    const source = await readFile(fileUrl)
+
     babelPluginMap = {
       ...getMinimalBabelPluginMap(),
       ...babelPluginMap,
       "transform-instrument": [babelPluginInstrument, { projectDirectoryUrl }],
     }
 
-    multipleExecutionsOperation.throwIfAborted()
+    operation.throwIfAborted()
     const { metadata } = await transformAsync(source, {
       filename: urlToFileSystemPath(fileUrl),
       filenameRelative: relativeUrl,
@@ -55,5 +57,7 @@ export const relativeUrlToEmptyCoverage = async (
       return createEmptyCoverage(relativeUrl)
     }
     throw e
+  } finally {
+    await operation.end()
   }
 }

package/src/internal/executing/coverage_utils/v8_coverage_from_directory.js

@@ -5,12 +5,16 @@ import {
   resolveUrl,
 } from "@jsenv/filesystem"
 import { createDetailedMessage } from "@jsenv/logger"
+import { Abort } from "@jsenv/abort"
 
 export const visitNodeV8Directory = async ({
-  // signal
+  signal,
   NODE_V8_COVERAGE,
   onV8Coverage,
 }) => {
+  const operation = Abort.startOperation()
+  operation.addAbortSignal(signal)
+
   const tryReadDirectory = async () => {
     const dirContent = await readDirectory(NODE_V8_COVERAGE)
     if (dirContent.length > 0) {
@@ -19,38 +23,47 @@ export const visitNodeV8Directory = async ({
     console.warn(`v8 coverage directory is empty at ${NODE_V8_COVERAGE}`)
     return dirContent
   }
-  const dirContent = await tryReadDirectory()
 
-  const coverageDirectoryUrl = assertAndNormalizeDirectoryUrl(NODE_V8_COVERAGE)
-  await dirContent.reduce(async (previous, dirEntry) => {
-    await previous
+  try {
+    operation.throwIfAborted()
+    const dirContent = await tryReadDirectory()
 
-    const dirEntryUrl = resolveUrl(dirEntry, coverageDirectoryUrl)
-    const tryReadJsonFile = async () => {
-      const fileContent = await readFile(dirEntryUrl, { as: "string" })
-      if (fileContent === "") {
-        return null
-      }
+    const coverageDirectoryUrl =
+      assertAndNormalizeDirectoryUrl(NODE_V8_COVERAGE)
+    await dirContent.reduce(async (previous, dirEntry) => {
+      operation.throwIfAborted()
+      await previous
 
-      try {
-        const fileAsJson = JSON.parse(fileContent)
-        return fileAsJson
-      } catch (e) {
-        console.warn(
-          createDetailedMessage(`Error while reading coverage file`, {
-            "error stack": e.stack,
-            "file": dirEntryUrl,
-          }),
-        )
-        return null
+      const dirEntryUrl = resolveUrl(dirEntry, coverageDirectoryUrl)
+      const tryReadJsonFile = async () => {
+        const fileContent = await readFile(dirEntryUrl, { as: "string" })
+        if (fileContent === "") {
+          console.warn(`Coverage JSON file is empty at ${dirEntryUrl}`)
+          return null
+        }
+
+        try {
+          const fileAsJson = JSON.parse(fileContent)
+          return fileAsJson
+        } catch (e) {
+          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())
+      const fileContent = await tryReadJsonFile()
+      if (fileContent) {
+        onV8Coverage(fileContent)
+      }
+    }, Promise.resolve())
+  } finally {
+    await operation.end()
+  }
 }
 
 export const filterV8Coverage = (v8Coverage, { coverageIgnorePredicate }) => {

package/src/internal/executing/coverage_utils/v8_coverage_to_istanbul.js

@@ -1,53 +1,63 @@
 import { urlToFileSystemPath } from "@jsenv/filesystem"
+import { Abort } from "@jsenv/abort"
 
 import { require } from "@jsenv/core/src/internal/require.js"
 
 import { composeTwoFileByFileIstanbulCoverages } from "./istanbul_coverage_composition.js"
 
-export const v8CoverageToIstanbul = async (v8Coverage) => {
-  const v8ToIstanbul = require("v8-to-istanbul")
-  const sourcemapCache = v8Coverage["source-map-cache"]
-  let istanbulCoverageComposed = null
-  await v8Coverage.result.reduce(async (previous, fileV8Coverage) => {
-    await previous
+export const v8CoverageToIstanbul = async (v8Coverage, { signal }) => {
+  const operation = Abort.startOperation()
+  operation.addAbortSignal(signal)
 
-    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)
+  try {
+    const v8ToIstanbul = require("v8-to-istanbul")
+    const sourcemapCache = v8Coverage["source-map-cache"]
+    let istanbulCoverageComposed = null
 
-    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()
+    await v8Coverage.result.reduce(async (previous, fileV8Coverage) => {
+      operation.throwIfAborted()
+      await previous
 
-    converter.applyCoverage(fileV8Coverage.functions)
-    const istanbulCoverage = converter.toIstanbul()
+      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)
 
-    istanbulCoverageComposed = istanbulCoverageComposed
-      ? composeTwoFileByFileIstanbulCoverages(
-          istanbulCoverageComposed,
-          istanbulCoverage,
-        )
-      : istanbulCoverage
-  }, Promise.resolve())
+      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()
 
-  if (!istanbulCoverageComposed) {
-    return {}
+      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()
   }
-  istanbulCoverageComposed = markAsConvertedFromV8(istanbulCoverageComposed)
-  return istanbulCoverageComposed
 }
 
 const markAsConvertedFromV8 = (fileByFileCoverage) => {