@jsenv/core 27.0.0-alpha.7 → 27.0.0-alpha.70

package/src/test/execute_plan.js

@@ -3,37 +3,27 @@ import { memoryUsage } from "node:process"
 import wrapAnsi from "wrap-ansi"
 import stripAnsi from "strip-ansi"
 import cuid from "cuid"
+import { URL_META, urlToFileSystemPath } from "@jsenv/urls"
+import { createDetailedMessage, loggerToLevels } from "@jsenv/logger"
+import { createLog, startSpinner } from "@jsenv/log"
+import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
 import {
-  urlToFileSystemPath,
   writeDirectory,
   ensureEmptyDirectory,
-  normalizeStructuredMetaMap,
-  urlToMeta,
-  writeFile,
+  writeFileSync,
 } from "@jsenv/filesystem"
-import {
-  createLogger,
-  createDetailedMessage,
-  loggerToLevels,
-} from "@jsenv/logger"
-import { createLog, startSpinner } from "@jsenv/log"
-import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
 
 import { babelPluginInstrument } from "@jsenv/utils/coverage/babel_plugin_instrument.js"
 import { reportToCoverage } from "@jsenv/utils/coverage/report_to_coverage.js"
 import { createUrlGraph } from "@jsenv/core/src/omega/url_graph.js"
-import { getCorePlugins } from "@jsenv/core/src/omega/core_plugins.js"
+import { getCorePlugins } from "@jsenv/core/src/plugins/plugins.js"
 import { createKitchen } from "@jsenv/core/src/omega/kitchen.js"
 import { startOmegaServer } from "@jsenv/core/src/omega/omega_server.js"
 import { run } from "@jsenv/core/src/execute/run.js"
 
 import { ensureGlobalGc } from "./gc.js"
 import { generateExecutionSteps } from "./execution_steps.js"
-import {
-  formatExecuting,
-  formatExecutionResult,
-  createSummaryLog,
-} from "./logs_file_execution.js"
+import { createExecutionLog, createSummaryLog } from "./logs_file_execution.js"
 
 export const executePlan = async (
   plan,
@@ -42,6 +32,7 @@ export const executePlan = async (
     handleSIGINT,
     logger,
     logSummary,
+    logTimeUsage,
     logMemoryHeapUsage,
     logFileRelativeUrl,
     completedExecutionLogMerging,
@@ -62,9 +53,14 @@ export const executePlan = async (
     coverageV8ConflictWarning,
     coverageTempDirectoryRelativeUrl,
 
-    plugins = [],
-    scenario = "test",
-    sourcemaps = "inline",
+    scenario,
+    sourcemaps,
+    plugins,
+    injectedGlobals,
+    nodeEsmResolution,
+    fileSystemMagicResolution,
+    transpilation,
+    writeGeneratedFiles,
 
     protocol,
     privateKey,
@@ -132,12 +128,29 @@ export const executePlan = async (
         logger,
         rootDirectoryUrl,
         urlGraph,
+        scenario,
+        sourcemaps,
+        runtimeCompat: runtimes,
+        writeGeneratedFiles,
         plugins: [
           ...plugins,
           ...getCorePlugins({
-            babel: {
-              getCustomBabelPlugins: ({ runtimeSupport }) => {
-                if (coverage && Object.keys(runtimeSupport)[0] !== "chrome") {
+            rootDirectoryUrl,
+            urlGraph,
+            scenario,
+            runtimeCompat: runtimes,
+
+            htmlSupervisor: true,
+            nodeEsmResolution,
+            fileSystemMagicResolution,
+            injectedGlobals,
+            transpilation: {
+              ...transpilation,
+              getCustomBabelPlugins: ({ clientRuntimeCompat }) => {
+                if (
+                  coverage &&
+                  Object.keys(clientRuntimeCompat)[0] !== "chrome"
+                ) {
                   return {
                     "transform-instrument": [
                       babelPluginInstrument,
@@ -153,13 +166,10 @@ export const executePlan = async (
             },
           }),
         ],
-        scenario,
-        sourcemaps,
       })
-      const serverLogger = createLogger({ logLevel: "warn" })
       const server = await startOmegaServer({
         signal: multipleExecutionsOperation.signal,
-        logger: serverLogger,
+        logLevel: "warn",
         rootDirectoryUrl,
         urlGraph,
         kitchen,
@@ -196,7 +206,13 @@ export const executePlan = async (
     const debugLogsEnabled = loggerToLevels(logger).debug
     const executionLogsEnabled = loggerToLevels(logger).info
     const executionSpinner =
-      !debugLogsEnabled && executionLogsEnabled && process.stdout.isTTY
+      !debugLogsEnabled &&
+      executionLogsEnabled &&
+      process.stdout.isTTY &&
+      // if there is an error during execution npm will mess up the output
+      // (happens when npm runs several command in a workspace)
+      // so we enable spinner only when !process.exitCode (no error so far)
+      process.exitCode !== 1
 
     const startMs = Date.now()
     const report = {}
@@ -213,17 +229,16 @@ export const executePlan = async (
     ).href
 
     if (coverage) {
-      const structuredMetaMapForCover = normalizeStructuredMetaMap(
-        {
-          cover: coverageConfig,
-        },
+      const associations = URL_META.resolveAssociations(
+        { cover: coverageConfig },
         rootDirectoryUrl,
       )
       const urlShouldBeCovered = (url) => {
-        return urlToMeta({
+        const { cover } = URL_META.applyAssociations({
           url: new URL(url, rootDirectoryUrl).href,
-          structuredMetaMap: structuredMetaMapForCover,
-        }).cover
+          associations,
+        })
+        return cover
       }
       runtimeParams.urlShouldBeCovered = urlShouldBeCovered
 
@@ -307,17 +322,29 @@ export const executePlan = async (
           runtimeVersion,
           executionIndex,
           executionParams,
+          startMs: Date.now(),
+          executionResult: {
+            status: "executing",
+          },
         }
         let spinner
         if (executionSpinner) {
-          spinner = startSpinner({
-            log: executionLog,
-            text: formatExecuting(beforeExecutionInfo, {
+          const renderSpinnerText = () =>
+            createExecutionLog(beforeExecutionInfo, {
               counters,
+              ...(logTimeUsage
+                ? {
+                    timeEllapsed: Date.now() - startMs,
+                  }
+                : {}),
               ...(logMemoryHeapUsage
                 ? { memoryHeap: memoryUsage().heapUsed }
                 : {}),
-            }),
+            })
+          spinner = startSpinner({
+            log: executionLog,
+            text: renderSpinnerText(),
+            update: renderSpinnerText,
           })
         }
         beforeExecutionCallback(beforeExecutionInfo)
@@ -349,10 +376,15 @@ export const executePlan = async (
           }
         }
         counters.done++
-        if (fileRelativeUrl in report === false) {
-          report[fileRelativeUrl] = {}
+        const fileReport = report[fileRelativeUrl]
+        if (fileReport) {
+          fileReport[executionName] = executionResult
+        } else {
+          report[fileRelativeUrl] = {
+            [executionName]: executionResult,
+          }
         }
-        report[fileRelativeUrl][executionName] = executionResult
+
         const afterExecutionInfo = {
           ...beforeExecutionInfo,
           endMs: Date.now(),
@@ -373,9 +405,14 @@ export const executePlan = async (
           global.gc()
         }
         if (executionLogsEnabled) {
-          let log = formatExecutionResult(afterExecutionInfo, {
+          let log = createExecutionLog(afterExecutionInfo, {
             completedExecutionLogAbbreviation,
             counters,
+            ...(logTimeUsage
+              ? {
+                  timeEllapsed: Date.now() - startMs,
+                }
+              : {}),
             ...(logMemoryHeapUsage
               ? { memoryHeap: memoryUsage().heapUsed }
               : {}),
@@ -433,7 +470,7 @@ export const executePlan = async (
     }
     if (summary.counters.total !== summary.counters.completed) {
       const logFileUrl = new URL(logFileRelativeUrl, rootDirectoryUrl).href
-      writeFile(logFileUrl, rawOutput)
+      writeFileSync(logFileUrl, rawOutput)
       logger.info(`-> ${urlToFileSystemPath(logFileUrl)}`)
     }
     const result = await transformReturnValue({

package/src/test/execute_test_plan.js

@@ -1,9 +1,6 @@
+import { urlToFileSystemPath, resolveDirectoryUrl, URL_META } from "@jsenv/urls"
 import {
-  normalizeStructuredMetaMap,
-  urlToFileSystemPath,
   ensureEmptyDirectory,
-  resolveDirectoryUrl,
-  urlToMeta,
   assertAndNormalizeDirectoryUrl,
 } from "@jsenv/filesystem"
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
@@ -13,6 +10,14 @@ import { generateCoverageHtmlDirectory } from "@jsenv/utils/coverage/coverage_re
 import { generateCoverageTextLog } from "@jsenv/utils/coverage/coverage_reporter_text_log.js"
 import { executePlan } from "./execute_plan.js"
 
+export const defaultCoverageConfig = {
+  "./index.js": true,
+  "./main.js": true,
+  "./src/**/*.js": true,
+  "./**/*.test.*": false, // contains .test. -> nope
+  "./**/test/": false, // inside a test folder -> nope,
+}
+
 /**
  * Execute a list of files and log how it goes
  * @param {Object} testPlanParameters
@@ -34,6 +39,7 @@ export const executeTestPlan = async ({
   handleSIGINT = true,
   logLevel = "info",
   logSummary = true,
+  logTimeUsage = false,
   logMemoryHeapUsage = false,
   logFileRelativeUrl = ".jsenv/test_plan_debug.txt",
   completedExecutionLogAbbreviation = false,
@@ -57,13 +63,7 @@ export const executeTestPlan = async ({
   coverage = process.argv.includes("--cover") ||
     process.argv.includes("--coverage"),
   coverageTempDirectoryRelativeUrl = "./.coverage/tmp/",
-  coverageConfig = {
-    "./index.js": true,
-    "./main.js": true,
-    "./src/**/*.js": true,
-    "./**/*.test.*": false, // contains .test. -> nope
-    "./**/test/": false, // inside a test folder -> nope,
-  },
+  coverageConfig = defaultCoverageConfig,
   coverageIncludeMissing = true,
   coverageAndExecutionAllowed = false,
   coverageForceIstanbul = false,
@@ -80,6 +80,13 @@ export const executeTestPlan = async ({
   // skip full means file with 100% coverage won't appear in coverage reports (log and html)
   coverageSkipFull = false,
 
+  sourcemaps = "inline",
+  plugins = [],
+  injectedGlobals,
+  nodeEsmResolution,
+  fileSystemMagicResolution,
+  writeGeneratedFiles = false,
+
   protocol,
   privateKey,
   certificate,
@@ -103,25 +110,22 @@ export const executeTestPlan = async ({
       )
     }
     if (!coverageAndExecutionAllowed) {
-      const structuredMetaMapForExecute = normalizeStructuredMetaMap(
-        {
-          execute: testPlan,
-        },
+      const associationsForExecute = URL_META.resolveAssociations(
+        { execute: testPlan },
         "file:///",
       )
-      const structuredMetaMapForCover = normalizeStructuredMetaMap(
-        {
-          cover: coverageConfig,
-        },
+      const associationsForCover = URL_META.resolveAssociations(
+        { cover: coverageConfig },
         "file:///",
       )
       const patternsMatchingCoverAndExecute = Object.keys(
-        structuredMetaMapForExecute.execute,
+        associationsForExecute.execute,
       ).filter((testPlanPattern) => {
-        return urlToMeta({
+        const { cover } = URL_META.applyAssociations({
           url: testPlanPattern,
-          structuredMetaMap: structuredMetaMapForCover,
-        }).cover
+          associations: associationsForCover,
+        })
+        return cover
       })
       if (patternsMatchingCoverAndExecute.length) {
         // It would be strange, for a given file to be both covered and executed
@@ -139,12 +143,13 @@ export const executeTestPlan = async ({
     logger,
     logLevel,
     logSummary,
+    logTimeUsage,
     logMemoryHeapUsage,
     logFileRelativeUrl,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
-
     rootDirectoryUrl,
+
     maxExecutionsInParallel,
     defaultMsAllocatedPerExecution,
     failFast,
@@ -159,6 +164,14 @@ export const executeTestPlan = async ({
     coverageV8ConflictWarning,
     coverageTempDirectoryRelativeUrl,
 
+    scenario: "test",
+    sourcemaps,
+    plugins,
+    injectedGlobals,
+    nodeEsmResolution,
+    fileSystemMagicResolution,
+    writeGeneratedFiles,
+
     protocol,
     privateKey,
     certificate,

package/src/test/execution_steps.js

@@ -5,13 +5,10 @@ export const generateExecutionSteps = async (
   plan,
   { signal, rootDirectoryUrl },
 ) => {
-  const structuredMetaMap = {
-    filePlan: plan,
-  }
   const fileResultArray = await collectFiles({
     signal,
     directoryUrl: rootDirectoryUrl,
-    structuredMetaMap,
+    associations: { filePlan: plan },
     predicate: ({ filePlan }) => filePlan,
   })
   const executionSteps = []

package/src/test/logs_file_execution.js

@@ -1,32 +1,14 @@
-import { ANSI, UNICODE } from "@jsenv/log"
-
-import { msAsDuration } from "@jsenv/utils/logs/duration_log.js"
-import { byteAsMemoryUsage } from "@jsenv/utils/logs/size_log.js"
+import {
+  ANSI,
+  UNICODE,
+  msAsEllapsedTime,
+  msAsDuration,
+  byteAsMemoryUsage,
+} from "@jsenv/log"
 
 import { EXECUTION_COLORS } from "./execution_colors.js"
 
-export const formatExecuting = (
-  { executionIndex },
-  { counters, memoryHeap },
-) => {
-  const description = ANSI.color(
-    `executing ${executionIndex + 1} of ${counters.total}`,
-    EXECUTION_COLORS.executing,
-  )
-  const summary =
-    executionIndex === 0
-      ? ""
-      : `(${createIntermediateSummary({
-          executionIndex,
-          counters,
-          memoryHeap,
-        })})`
-  return formatExecution({
-    label: `${description} ${summary}`,
-  })
-}
-
-export const formatExecutionResult = (
+export const createExecutionLog = (
   {
     executionIndex,
     fileRelativeUrl,
@@ -34,34 +16,41 @@ export const formatExecutionResult = (
     runtimeVersion,
     executionParams,
     executionResult,
+    startMs,
+    endMs,
   },
-  { completedExecutionLogAbbreviation, counters, memoryHeap },
+  { completedExecutionLogAbbreviation, counters, timeEllapsed, memoryHeap },
 ) => {
   const { status } = executionResult
-  const description = descriptionFormatters[status]({
+  const descriptionFormatter = descriptionFormatters[status]
+  const description = descriptionFormatter({
     index: executionIndex,
     total: counters.total,
     executionParams,
   })
-  const summary = `(${createIntermediateSummary({
+  const summary = createIntermediateSummary({
     executionIndex,
     counters,
+    timeEllapsed,
     memoryHeap,
-  })})`
+  })
   if (completedExecutionLogAbbreviation && status === "completed") {
-    return `${description} ${summary}`
+    return `${description}${summary}`
   }
-  const { consoleCalls = [], error, duration } = executionResult
-  const console = formatConsoleCalls(consoleCalls)
+  const { consoleCalls = [], error } = executionResult
+  const consoleOutput = formatConsoleCalls(consoleCalls)
   return formatExecution({
-    label: `${description} ${summary}`,
+    label: `${description}${summary}`,
     details: {
       file: fileRelativeUrl,
       runtime: `${runtimeName}/${runtimeVersion}`,
-      duration: msAsDuration(duration),
-      ...(error ? { error: error.stack } : {}),
+      duration:
+        status === "executing"
+          ? msAsEllapsedTime(Date.now() - startMs)
+          : msAsDuration(endMs - startMs),
+      ...(error ? { error: error.stack || error.message || error } : {}),
     },
-    console,
+    consoleOutput,
   })
 }
 
@@ -87,17 +76,29 @@ const createIntermediateSummary = ({
   executionIndex,
   counters,
   memoryHeap,
+  timeEllapsed,
 }) => {
-  let intermediateSummary = createStatusSummary({
-    counters: {
-      ...counters,
-      total: executionIndex + 1,
-    },
-  })
+  const parts = []
+  if (executionIndex > 0 || counters.done > 0) {
+    parts.push(
+      createStatusSummary({
+        counters: {
+          ...counters,
+          total: executionIndex + 1,
+        },
+      }),
+    )
+  }
+  if (timeEllapsed) {
+    parts.push(`duration: ${msAsEllapsedTime(timeEllapsed)}`)
+  }
   if (memoryHeap) {
-    intermediateSummary += ` / memory heap: ${byteAsMemoryUsage(memoryHeap)}`
+    parts.push(`memory heap: ${byteAsMemoryUsage(memoryHeap)}`)
   }
-  return intermediateSummary
+  if (parts.length === 0) {
+    return ""
+  }
+  return ` (${parts.join(` / `)})`
 }
 
 const createStatusSummary = ({ counters }) => {
@@ -161,6 +162,12 @@ const createMixedDetails = ({ counters }) => {
 }
 
 const descriptionFormatters = {
+  executing: ({ index, total }) => {
+    return ANSI.color(
+      `executing ${index + 1} of ${total}`,
+      EXECUTION_COLORS.executing,
+    )
+  },
   aborted: ({ index, total }) => {
     return ANSI.color(
       `${UNICODE.FAILURE_RAW} execution ${index + 1} of ${total} aborted`,
@@ -203,21 +210,21 @@ const formatConsoleCalls = (consoleCalls) => {
   if (consoleOutputTrimmed === "") {
     return ""
   }
-  return `${ANSI.color(`-------- console --------`, ANSI.GREY)}
+  return `${ANSI.color(`-------- console output --------`, ANSI.GREY)}
 ${consoleOutputTrimmed}
 ${ANSI.color(`-------------------------`, ANSI.GREY)}`
 }
 
-const formatExecution = ({ label, details = {}, console }) => {
+const formatExecution = ({ label, details = {}, consoleOutput }) => {
   let message = ``
   message += label
   Object.keys(details).forEach((key) => {
     message += `
 ${key}: ${details[key]}`
   })
-  if (console) {
+  if (consoleOutput) {
     message += `
-${console}`
+${consoleOutput}`
   }
   return message
 }