@jsenv/core 23.3.0 → 23.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jsenv/core",
-  "version": "23.3.0",
+  "version": "23.5.0",
   "description": "Tool to develop, test and build js projects",
   "license": "MIT",
   "repository": {
@@ -63,12 +63,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.1",
     "@jsenv/uneval": "1.6.0",
     "@jsenv/workers": "1.2.0",
     "@rollup/plugin-commonjs": "21.0.0",

package/readme.md

@@ -99,16 +99,16 @@ executeTestPlan({
 ✔ execution 1 of 2 completed (all completed)
 file: animals.test.html
 runtime: chromium/82.0.4057.0
-duration: 1.28 seconds
+duration: 1.2 seconds
 
 ✔ execution 2 of 2 completed (all completed)
 file: animals.test.html
 runtime: firefox/73.0b13
-duration: 2.42 seconds
+duration: 2.4 seconds
 
 -------------- summary -----------------
-2 execution: all completed
-total duration: 3.72 seconds
+2 executions: all completed
+total duration: 3.6 seconds
 ----------------------------------------
 ```
 

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

@@ -14,9 +14,9 @@ import {
 } from "./internal/argUtils.js"
 import { executePlan } from "./internal/executing/executePlan.js"
 import { executionIsPassed } from "./internal/executing/executionIsPassed.js"
-import { generateCoverageJsonFile } from "./internal/executing/coverage/generateCoverageJsonFile.js"
-import { generateCoverageHtmlDirectory } from "./internal/executing/coverage/generateCoverageHtmlDirectory.js"
-import { generateCoverageTextLog } from "./internal/executing/coverage/generateCoverageTextLog.js"
+import { generateCoverageJsonFile } from "./internal/executing/coverage_reporter/coverage_reporter_json_file.js"
+import { generateCoverageHtmlDirectory } from "./internal/executing/coverage_reporter/coverage_reporter_html_directory.js"
+import { generateCoverageTextLog } from "./internal/executing/coverage_reporter/coverage_reporter_text_log.js"
 import { jsenvCoverageConfig } from "./jsenvCoverageConfig.js"
 
 export const executeTestPlan = async ({
@@ -33,29 +33,29 @@ export const executeTestPlan = async ({
 
   testPlan,
   defaultMsAllocatedPerExecution,
+  cooldownBetweenExecutions,
 
   maxExecutionsInParallel,
 
   completedExecutionLogAbbreviation = false,
   completedExecutionLogMerging = false,
   logSummary = true,
-  measureGlobalDuration = true,
   updateProcessExitCode = true,
 
   coverage = process.argv.includes("--cover") ||
     process.argv.includes("--coverage"),
+  coverageTempDirectoryRelativeUrl = "./coverage/tmp/",
   coverageConfig = jsenvCoverageConfig,
   coverageIncludeMissing = true,
   coverageAndExecutionAllowed = false,
   coverageForceIstanbul = false,
-  coverageV8MergeConflictIsExpected = false,
-
+  coverageV8ConflictWarning = true,
   coverageTextLog = true,
   coverageJsonFile = Boolean(process.env.CI),
   coverageJsonFileLog = true,
   coverageJsonFileRelativeUrl = "./coverage/coverage.json",
   coverageHtmlDirectory = !process.env.CI,
-  coverageHtmlDirectoryRelativeUrl = "./coverage",
+  coverageHtmlDirectoryRelativeUrl = "./coverage/",
   coverageHtmlDirectoryIndexLog = true,
   // skip empty means empty files won't appear in the coverage reports (log and html)
   coverageSkipEmpty = false,
@@ -144,16 +144,17 @@ export const executeTestPlan = async ({
 
     defaultMsAllocatedPerExecution,
     maxExecutionsInParallel,
+    cooldownBetweenExecutions,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
     logSummary,
-    measureGlobalDuration,
 
     coverage,
     coverageConfig,
     coverageIncludeMissing,
     coverageForceIstanbul,
-    coverageV8MergeConflictIsExpected,
+    coverageV8ConflictWarning,
+    coverageTempDirectoryRelativeUrl,
 
     jsenvDirectoryClean,
     compileServerProtocol,
@@ -173,7 +174,7 @@ export const executeTestPlan = async ({
   }
 
   const planCoverage = result.planCoverage
-  // planCoverage can be null when execution is abortes
+  // planCoverage can be null when execution is aborted
   if (planCoverage) {
     const promises = []
     // keep this one first because it does ensureEmptyDirectory
@@ -224,6 +225,7 @@ export const executeTestPlan = async ({
   }
 
   return {
+    testPlanAborted: result.aborted,
     testPlanSummary: result.planSummary,
     testPlanReport: result.planReport,
     testPlanCoverage: planCoverage,

package/src/internal/browser-launcher/executeHtmlFile.js

@@ -6,8 +6,8 @@ import {
 } from "@jsenv/filesystem"
 
 import { jsenvCompileProxyHtmlFileInfo } from "@jsenv/core/src/internal/jsenvInternalFiles.js"
-import { v8CoverageFromAllV8Coverages } from "@jsenv/core/src/internal/executing/coverage/v8CoverageFromAllV8Coverages.js"
-import { composeIstanbulCoverages } from "@jsenv/core/src/internal/executing/coverage/composeIstanbulCoverages.js"
+import { filterV8Coverage } from "@jsenv/core/src/internal/executing/coverage_utils/v8_coverage_from_directory.js"
+import { composeTwoFileByFileIstanbulCoverages } from "@jsenv/core/src/internal/executing/coverage_utils/istanbul_coverage_composition.js"
 import { evalSource } from "../runtime/createNodeRuntime/evalSource.js"
 import { escapeRegexpSpecialCharacters } from "../escapeRegexpSpecialCharacters.js"
 
@@ -23,7 +23,7 @@ export const executeHtmlFile = async (
     // measurePerformance,
     collectPerformance,
     collectCoverage,
-    coverageConfig,
+    coverageIgnorePredicate,
     coverageForceIstanbul,
     coveragePlaywrightAPIAvailable,
     transformErrorHook,
@@ -76,7 +76,7 @@ export const executeHtmlFile = async (
         fileRelativeUrl,
         page,
         collectCoverage,
-        coverageConfig,
+        coverageIgnorePredicate,
         transformErrorHook,
       })
     } else {
@@ -149,7 +149,7 @@ const executeSource = async ({
   fileRelativeUrl,
   page,
   collectCoverage,
-  coverageConfig,
+  coverageIgnorePredicate,
   transformErrorHook,
 }) => {
   let transformResult = (result) => result
@@ -175,11 +175,12 @@ const executeSource = async ({
           }
         },
       )
-      const allV8Coverages = [{ result: v8CoveragesWithFsUrls }]
-      const coverage = v8CoverageFromAllV8Coverages(allV8Coverages, {
-        coverageRootUrl: projectDirectoryUrl,
-        coverageConfig,
-      })
+      const coverage = filterV8Coverage(
+        { result: v8CoveragesWithFsUrls },
+        {
+          coverageIgnorePredicate,
+        },
+      )
       return {
         ...result,
         coverage,
@@ -297,15 +298,18 @@ const executeCompiledVersion = async ({
 }
 
 const generateCoverageForPage = (fileExecutionResultMap) => {
-  const istanbulCoverages = []
+  let istanbulCoverageComposed = null
   Object.keys(fileExecutionResultMap).forEach((fileRelativeUrl) => {
     const istanbulCoverage = fileExecutionResultMap[fileRelativeUrl].coverage
-    if (istanbulCoverage) {
-      istanbulCoverages.push(istanbulCoverage)
-    }
+    istanbulCoverageComposed = istanbulCoverageComposed
+      ? composeTwoFileByFileIstanbulCoverages(
+          istanbulCoverageComposed,
+          istanbulCoverage,
+        )
+      : istanbulCoverage
   })
-  const istanbulCoverage = composeIstanbulCoverages(istanbulCoverages)
-  return istanbulCoverage
+
+  return istanbulCoverageComposed
 }
 
 const evalException = (

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/babel_plugin_instrument.js

@@ -3,6 +3,7 @@ import {
   normalizeStructuredMetaMap,
   urlToMeta,
 } from "@jsenv/filesystem"
+
 import { require } from "../../require.js"
 
 // https://github.com/istanbuljs/babel-plugin-istanbul/blob/321740f7b25d803f881466ea819d870f7ed6a254/src/index.js

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

@@ -1,146 +1,187 @@
-import { collectFiles } from "@jsenv/filesystem"
-
-import { relativeUrlToEmptyCoverage } from "./relativeUrlToEmptyCoverage.js"
-import { istanbulCoverageFromCoverages } from "./istanbulCoverageFromCoverages.js"
-import { normalizeIstanbulCoverage } from "./normalizeIstanbulCoverage.js"
+import { readFile } from "@jsenv/filesystem"
+import { Abort } from "@jsenv/abort"
+
+import {
+  visitNodeV8Directory,
+  filterV8Coverage,
+} from "../coverage_utils/v8_coverage_from_directory.js"
+import { composeTwoV8Coverages } from "../coverage_utils/v8_coverage_composition.js"
+import { composeTwoFileByFileIstanbulCoverages } from "../coverage_utils/istanbul_coverage_composition.js"
+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 { getMissingFileByFileCoverage } from "../coverage_missing/missing_coverage.js"
 
 export const reportToCoverage = async (
   report,
   {
-    multipleExecutionsOperation,
+    signal,
     logger,
     projectDirectoryUrl,
     babelPluginMap,
     coverageConfig,
     coverageIncludeMissing,
-    coverageV8MergeConflictIsExpected,
+    coverageIgnorePredicate,
+    coverageForceIstanbul,
+    coverageV8ConflictWarning,
   },
 ) => {
-  // here we should forward multipleExecutionsOperation.signal
-  // to allow aborting this too
-  const istanbulCoverageFromExecution = await executionReportToCoverage(
+  // collect v8 and istanbul coverage from executions
+  let { v8Coverage, fileByFileIstanbulCoverage } = await getCoverageFromReport({
+    signal,
     report,
-    {
-      logger,
-      projectDirectoryUrl,
-      coverageV8MergeConflictIsExpected,
+    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 (!coverageIncludeMissing) {
-    return istanbulCoverageFromExecution
+  if (!coverageForceIstanbul && process.env.NODE_V8_COVERAGE) {
+    await visitNodeV8Directory({
+      signal,
+      NODE_V8_COVERAGE: process.env.NODE_V8_COVERAGE,
+      onV8Coverage: (nodeV8Coverage) => {
+        const nodeV8CoverageLight = filterV8Coverage(nodeV8Coverage, {
+          coverageIgnorePredicate,
+        })
+        v8Coverage = v8Coverage
+          ? composeTwoV8Coverages(v8Coverage, nodeV8CoverageLight)
+          : nodeV8CoverageLight
+      },
+    })
   }
 
-  const relativeFileUrlToCoverArray = await listRelativeFileUrlToCover({
-    multipleExecutionsOperation,
-    projectDirectoryUrl,
-    coverageConfig,
-  })
+  // try to merge v8 with istanbul, if any
+  let fileByFileCoverage
+  if (v8Coverage) {
+    let v8FileByFileCoverage = await v8CoverageToIstanbul(v8Coverage, {
+      signal,
+    })
 
-  const relativeFileUrlMissingCoverageArray =
-    relativeFileUrlToCoverArray.filter((relativeFileUrlToCover) =>
-      Object.keys(istanbulCoverageFromExecution).every((key) => {
-        return key !== `./${relativeFileUrlToCover}`
-      }),
+    v8FileByFileCoverage = normalizeFileByFileCoveragePaths(
+      v8FileByFileCoverage,
+      projectDirectoryUrl,
     )
 
-  const istanbulCoverageFromMissedFiles = {}
-  // maybe we should prefer reduce over Promise.all here
-  // because it creates a LOT of things to do
-  await Promise.all(
-    relativeFileUrlMissingCoverageArray.map(
-      async (relativeFileUrlMissingCoverage) => {
-        const emptyCoverage = await relativeUrlToEmptyCoverage(
-          relativeFileUrlMissingCoverage,
-          {
-            multipleExecutionsOperation,
-            projectDirectoryUrl,
-            babelPluginMap,
-          },
-        )
-        istanbulCoverageFromMissedFiles[relativeFileUrlMissingCoverage] =
-          emptyCoverage
-        return emptyCoverage
-      },
-    ),
-  )
-
-  return {
-    ...istanbulCoverageFromExecution, // already normalized
-    ...normalizeIstanbulCoverage(
-      istanbulCoverageFromMissedFiles,
+    if (fileByFileIstanbulCoverage) {
+      fileByFileIstanbulCoverage = normalizeFileByFileCoveragePaths(
+        fileByFileIstanbulCoverage,
+        projectDirectoryUrl,
+      )
+      fileByFileCoverage = composeV8AndIstanbul(
+        v8FileByFileCoverage,
+        fileByFileIstanbulCoverage,
+        { coverageV8ConflictWarning },
+      )
+    } else {
+      fileByFileCoverage = v8FileByFileCoverage
+    }
+  }
+  // get istanbul only
+  else if (fileByFileIstanbulCoverage) {
+    fileByFileCoverage = normalizeFileByFileCoveragePaths(
+      fileByFileIstanbulCoverage,
       projectDirectoryUrl,
-    ),
+    )
   }
-}
-
-const listRelativeFileUrlToCover = async ({
-  multipleExecutionsOperation,
-  projectDirectoryUrl,
-  coverageConfig,
-}) => {
-  const structuredMetaMapForCoverage = {
-    cover: coverageConfig,
+  // no coverage found in execution (or zero file where executed)
+  else {
+    fileByFileCoverage = {}
   }
 
-  const matchingFileResultArray = await collectFiles({
-    signal: multipleExecutionsOperation.signal,
-    directoryUrl: projectDirectoryUrl,
-    structuredMetaMap: structuredMetaMapForCoverage,
-    predicate: ({ cover }) => cover,
-  })
-
-  return matchingFileResultArray.map(({ relativeUrl }) => relativeUrl)
-}
-
-const executionReportToCoverage = async (
-  report,
-  { logger, projectDirectoryUrl, coverageV8MergeConflictIsExpected },
-) => {
-  const coverages = []
-
-  Object.keys(report).forEach((file) => {
-    const executionResultForFile = report[file]
-    Object.keys(executionResultForFile).forEach((executionName) => {
-      const executionResultForFileOnRuntime =
-        executionResultForFile[executionName]
-
-      const { status, coverage } = executionResultForFileOnRuntime
-      if (!coverage) {
-        // 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.warn(
-            `No execution.coverage from execution named "${executionName}" of ${file}`,
-          )
-        }
-        return
-      }
-
-      coverages.push(coverage)
+  // now add coverage for file not covered
+  if (coverageIncludeMissing) {
+    const missingFileByFileCoverage = await getMissingFileByFileCoverage({
+      signal,
+      projectDirectoryUrl,
+      coverageConfig,
+      fileByFileCoverage,
+      babelPluginMap,
     })
-  })
+    Object.assign(fileByFileCoverage, missingFileByFileCoverage)
+  }
 
-  const istanbulCoverage = await istanbulCoverageFromCoverages(coverages, {
-    projectDirectoryUrl,
-    coverageV8MergeConflictIsExpected,
-  })
+  return fileByFileCoverage
+}
 
-  return istanbulCoverage
+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
+          }
+
+          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())
+
+    return {
+      v8Coverage,
+      fileByFileIstanbulCoverage,
+    }
+  } finally {
+    await operation.end()
+  }
 }
+
+const isV8Coverage = (coverage) => Boolean(coverage.result)

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

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

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
+}