@jsenv/core 26.0.1 → 27.0.0-alpha.2

package/src/{execute_test_plan.js → test/execute_test_plan.js}

@@ -4,23 +4,19 @@ import {
   ensureEmptyDirectory,
   resolveDirectoryUrl,
   urlToMeta,
-  resolveUrl,
+  assertAndNormalizeDirectoryUrl,
 } from "@jsenv/filesystem"
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
 
-import {
-  assertProjectDirectoryUrl,
-  assertProjectDirectoryExists,
-} from "@jsenv/core/src/internal/jsenv_params_assertions.js"
-import { executePlan } from "./internal/executing/execute_plan.js"
-import { generateCoverageJsonFile } from "./internal/coverage/coverage_reporter_json_file.js"
-import { generateCoverageHtmlDirectory } from "./internal/coverage/coverage_reporter_html_directory.js"
-import { generateCoverageTextLog } from "./internal/coverage/coverage_reporter_text_log.js"
+import { generateCoverageJsonFile } from "@jsenv/utils/coverage/coverage_reporter_json_file.js"
+import { generateCoverageHtmlDirectory } from "@jsenv/utils/coverage/coverage_reporter_html_directory.js"
+import { generateCoverageTextLog } from "@jsenv/utils/coverage/coverage_reporter_text_log.js"
+import { executePlan } from "./execute_plan.js"
 
 /**
  * Execute a list of files and log how it goes
  * @param {Object} testPlanParameters
- * @param {string|url} testPlanParameters.projectDirectoryUrl Root directory of the project
+ * @param {string|url} testPlanParameters.rootDirectoryUrl Root directory of the project
  * @param {Object} testPlanParameters.testPlan Object associating patterns leading to files to runtimes where they should be executed
  * @param {boolean} [testPlanParameters.completedExecutionLogAbbreviation=false] Abbreviate completed execution information to shorten terminal output
  * @param {boolean} [testPlanParameters.completedExecutionLogMerging=false] Merge completed execution logs to shorten terminal output
@@ -37,39 +33,30 @@ export const executeTestPlan = async ({
   signal = new AbortController().signal,
   handleSIGINT = true,
   logLevel = "info",
-  compileServerLogLevel = "warn",
-  launchAndExecuteLogLevel = "warn",
-
-  projectDirectoryUrl,
-  jsenvDirectoryRelativeUrl,
-  importResolutionMethod,
-  importDefaultExtension,
-
-  testPlan,
-
   logSummary = true,
   logMemoryHeapUsage = false,
   logFileRelativeUrl = ".jsenv/test_plan_debug.txt",
   completedExecutionLogAbbreviation = false,
   completedExecutionLogMerging = false,
-  updateProcessExitCode = true,
-  windowsProcessExitFix = true,
+  rootDirectoryUrl,
 
+  testPlan,
+  updateProcessExitCode = true,
   maxExecutionsInParallel = 1,
   defaultMsAllocatedPerExecution = 30000,
   failFast = false,
-  // stopAfterExecute: true to ensure runtime is stopped once executed
+  // keepRunning: false to ensure runtime is stopped once executed
   // because we have what we wants: execution is completed and
-  // we have associated coverage and capturedConsole
-  // passsing false means all node process and browsers launched stays opened
+  // we have associated coverage and console output
+  // passsing true means all node process and browsers launched stays opened
   // (can eventually be used for debug)
-  stopAfterExecute = true,
+  keepRunning = false,
   cooldownBetweenExecutions = 0,
   gcBetweenExecutions = logMemoryHeapUsage,
 
   coverage = process.argv.includes("--cover") ||
     process.argv.includes("--coverage"),
-  coverageTempDirectoryRelativeUrl = "./coverage/tmp/",
+  coverageTempDirectoryRelativeUrl = "./.coverage/tmp/",
   coverageConfig = {
     "./index.js": true,
     "./main.js": true,
@@ -84,9 +71,9 @@ export const executeTestPlan = async ({
   coverageTextLog = true,
   coverageJsonFile = Boolean(process.env.CI),
   coverageJsonFileLog = true,
-  coverageJsonFileRelativeUrl = "./coverage/coverage.json",
+  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,
@@ -98,20 +85,9 @@ export const executeTestPlan = async ({
   certificate,
   ip,
   port,
-  compileServerCanReadFromFilesystem,
-  compileServerCanWriteOnFilesystem,
-  babelPluginMap,
-  babelConfigFileUrl,
-  preservedUrls,
-  workers,
-  serviceWorkers,
-  importMapInWebWorkers,
-  customCompilers,
-  jsenvDirectoryClean,
 }) => {
   const logger = createLogger({ logLevel })
-  projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
-  await assertProjectDirectoryExists({ projectDirectoryUrl })
+  rootDirectoryUrl = assertAndNormalizeDirectoryUrl(rootDirectoryUrl)
   if (typeof testPlan !== "object") {
     throw new Error(`testPlan must be an object, got ${testPlan}`)
   }
@@ -147,10 +123,8 @@ export const executeTestPlan = async ({
           structuredMetaMap: structuredMetaMapForCover,
         }).cover
       })
-
       if (patternsMatchingCoverAndExecute.length) {
-        // I think it is an error, it would be strange, for a given file
-        // to be both covered and executed
+        // It would be strange, for a given file to be both covered and executed
         throw new Error(
           createDetailedMessage(`some file will be both covered and executed`, {
             patterns: patternsMatchingCoverAndExecute,
@@ -162,28 +136,19 @@ export const executeTestPlan = async ({
   const result = await executePlan(testPlan, {
     signal,
     handleSIGINT,
-
     logger,
     logLevel,
-    compileServerLogLevel,
-    launchAndExecuteLogLevel,
-
-    projectDirectoryUrl,
-    jsenvDirectoryRelativeUrl,
-
-    importResolutionMethod,
-    importDefaultExtension,
-
     logSummary,
     logMemoryHeapUsage,
     logFileRelativeUrl,
     completedExecutionLogMerging,
     completedExecutionLogAbbreviation,
 
+    rootDirectoryUrl,
     maxExecutionsInParallel,
     defaultMsAllocatedPerExecution,
     failFast,
-    stopAfterExecute,
+    keepRunning,
     cooldownBetweenExecutions,
     gcBetweenExecutions,
 
@@ -194,25 +159,15 @@ export const executeTestPlan = async ({
     coverageV8ConflictWarning,
     coverageTempDirectoryRelativeUrl,
 
-    jsenvDirectoryClean,
     protocol,
     privateKey,
     certificate,
     ip,
     port,
-    compileServerCanReadFromFilesystem,
-    compileServerCanWriteOnFilesystem,
-    babelPluginMap,
-    babelConfigFileUrl,
-    preservedUrls,
-    workers,
-    serviceWorkers,
-    importMapInWebWorkers,
-    customCompilers,
   })
   if (
     updateProcessExitCode &&
-    result.planSummary.executionCount !== result.planSummary.completedCount
+    result.planSummary.counters.total !== result.planSummary.counters.completed
   ) {
     process.exitCode = 1
   }
@@ -226,7 +181,7 @@ export const executeTestPlan = async ({
     if (coverage && coverageHtmlDirectory) {
       const coverageHtmlDirectoryUrl = resolveDirectoryUrl(
         coverageHtmlDirectoryRelativeUrl,
-        projectDirectoryUrl,
+        rootDirectoryUrl,
       )
       await ensureEmptyDirectory(coverageHtmlDirectoryUrl)
       if (coverageHtmlDirectoryIndexLog) {
@@ -237,16 +192,16 @@ export const executeTestPlan = async ({
       }
       promises.push(
         generateCoverageHtmlDirectory(planCoverage, {
-          projectDirectoryUrl,
+          rootDirectoryUrl,
           coverageHtmlDirectoryRelativeUrl,
         }),
       )
     }
     if (coverage && coverageJsonFile) {
-      const coverageJsonFileUrl = resolveUrl(
+      const coverageJsonFileUrl = new URL(
         coverageJsonFileRelativeUrl,
-        projectDirectoryUrl,
-      )
+        rootDirectoryUrl,
+      ).href
       promises.push(
         generateCoverageJsonFile({
           coverage: result.planCoverage,
@@ -266,16 +221,6 @@ export const executeTestPlan = async ({
     }
     await Promise.all(promises)
   }
-  // Sometimes on windows test plan scripts never ends
-  // I suspect it's some node process keeping the process alive
-  // because not properly killed for some reason.
-  // (It can be reproduced on @jsenv/importmap-node-module where playwright is not involved)
-  // The hotfix for now is to manually call process.exit() in on windows
-  if (process.platform === "win32" && windowsProcessExitFix) {
-    setTimeout(() => {
-      process.exit()
-    }, 2000).unref()
-  }
   return {
     testPlanAborted: result.aborted,
     testPlanSummary: result.planSummary,

package/src/{internal/executing → test}/execution_steps.js

@@ -3,19 +3,17 @@ import { createDetailedMessage } from "@jsenv/logger"
 
 export const generateExecutionSteps = async (
   plan,
-  { signal, projectDirectoryUrl },
+  { signal, rootDirectoryUrl },
 ) => {
   const structuredMetaMap = {
     filePlan: plan,
   }
-
   const fileResultArray = await collectFiles({
     signal,
-    directoryUrl: projectDirectoryUrl,
+    directoryUrl: rootDirectoryUrl,
     structuredMetaMap,
     predicate: ({ filePlan }) => filePlan,
   })
-
   const executionSteps = []
   fileResultArray.forEach(({ relativeUrl, meta }) => {
     const fileExecutionSteps = generateFileExecutionSteps({
@@ -29,13 +27,11 @@ export const generateExecutionSteps = async (
 
 export const generateFileExecutionSteps = ({ fileRelativeUrl, filePlan }) => {
   const fileExecutionSteps = []
-
   Object.keys(filePlan).forEach((executionName) => {
     const stepConfig = filePlan[executionName]
     if (stepConfig === null || stepConfig === undefined) {
       return
     }
-
     if (typeof stepConfig !== "object") {
       throw new TypeError(
         createDetailedMessage(
@@ -48,13 +44,11 @@ export const generateFileExecutionSteps = ({ fileRelativeUrl, filePlan }) => {
         ),
       )
     }
-
     fileExecutionSteps.push({
       executionName,
       fileRelativeUrl,
       ...stepConfig,
     })
   })
-
   return fileExecutionSteps
 }

package/src/test/logs_file_execution.js

@@ -0,0 +1,223 @@
+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 { 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 = (
+  {
+    executionIndex,
+    fileRelativeUrl,
+    runtimeName,
+    runtimeVersion,
+    executionParams,
+    executionResult,
+  },
+  { completedExecutionLogAbbreviation, counters, memoryHeap },
+) => {
+  const { status } = executionResult
+  const description = descriptionFormatters[status]({
+    index: executionIndex,
+    total: counters.total,
+    executionParams,
+  })
+  const summary = `(${createIntermediateSummary({
+    executionIndex,
+    counters,
+    memoryHeap,
+  })})`
+  if (completedExecutionLogAbbreviation && status === "completed") {
+    return `${description} ${summary}`
+  }
+  const { consoleCalls = [], error, duration } = executionResult
+  const console = formatConsoleCalls(consoleCalls)
+  return formatExecution({
+    label: `${description} ${summary}`,
+    details: {
+      file: fileRelativeUrl,
+      runtime: `${runtimeName}/${runtimeVersion}`,
+      duration: msAsDuration(duration),
+      ...(error ? { error: error.stack } : {}),
+    },
+    console,
+  })
+}
+
+export const createSummaryLog = (
+  summary,
+) => `-------------- summary -----------------
+${createAllExecutionsSummary(summary)}
+total duration: ${msAsDuration(summary.duration)}
+----------------------------------------`
+
+const createAllExecutionsSummary = ({ counters }) => {
+  if (counters.total === 0) {
+    return `no execution`
+  }
+  const executionLabel =
+    counters.total === 1 ? `1 execution` : `${counters.total} executions`
+  return `${executionLabel}: ${createStatusSummary({
+    counters,
+  })}`
+}
+
+const createIntermediateSummary = ({
+  executionIndex,
+  counters,
+  memoryHeap,
+}) => {
+  let intermediateSummary = createStatusSummary({
+    counters: {
+      ...counters,
+      total: executionIndex + 1,
+    },
+  })
+  if (memoryHeap) {
+    intermediateSummary += ` / memory heap: ${byteAsMemoryUsage(memoryHeap)}`
+  }
+  return intermediateSummary
+}
+
+const createStatusSummary = ({ counters }) => {
+  if (counters.aborted === counters.total) {
+    return `all ${ANSI.color(`aborted`, EXECUTION_COLORS.aborted)}`
+  }
+  if (counters.timedout === counters.total) {
+    return `all ${ANSI.color(`timed out`, EXECUTION_COLORS.timedout)}`
+  }
+  if (counters.errored === counters.total) {
+    return `all ${ANSI.color(`errored`, EXECUTION_COLORS.errored)}`
+  }
+  if (counters.completed === counters.total) {
+    return `all ${ANSI.color(`completed`, EXECUTION_COLORS.completed)}`
+  }
+  if (counters.cancelled === counters.total) {
+    return `all ${ANSI.color(`cancelled`, EXECUTION_COLORS.cancelled)}`
+  }
+  return createMixedDetails({
+    counters,
+  })
+}
+
+const createMixedDetails = ({ counters }) => {
+  const parts = []
+  if (counters.timedout) {
+    parts.push(
+      `${counters.timedout} ${ANSI.color(
+        `timed out`,
+        EXECUTION_COLORS.timedout,
+      )}`,
+    )
+  }
+  if (counters.errored) {
+    parts.push(
+      `${counters.errored} ${ANSI.color(`errored`, EXECUTION_COLORS.errored)}`,
+    )
+  }
+  if (counters.completed) {
+    parts.push(
+      `${counters.completed} ${ANSI.color(
+        `completed`,
+        EXECUTION_COLORS.completed,
+      )}`,
+    )
+  }
+  if (counters.aborted) {
+    parts.push(
+      `${counters.aborted} ${ANSI.color(`aborted`, EXECUTION_COLORS.aborted)}`,
+    )
+  }
+  if (counters.cancelled) {
+    parts.push(
+      `${counters.cancelled} ${ANSI.color(
+        `cancelled`,
+        EXECUTION_COLORS.cancelled,
+      )}`,
+    )
+  }
+  return `${parts.join(", ")}`
+}
+
+const descriptionFormatters = {
+  aborted: ({ index, total }) => {
+    return ANSI.color(
+      `${UNICODE.FAILURE_RAW} execution ${index + 1} of ${total} aborted`,
+      EXECUTION_COLORS.aborted,
+    )
+  },
+  timedout: ({ index, total, executionParams }) => {
+    return ANSI.color(
+      `${UNICODE.FAILURE_RAW} execution ${
+        index + 1
+      } of ${total} timeout after ${executionParams.allocatedMs}ms`,
+      EXECUTION_COLORS.timedout,
+    )
+  },
+  errored: ({ index, total }) => {
+    return ANSI.color(
+      `${UNICODE.FAILURE_RAW} execution ${index + 1} of ${total} errored`,
+      EXECUTION_COLORS.errored,
+    )
+  },
+  completed: ({ index, total }) => {
+    return ANSI.color(
+      `${UNICODE.OK_RAW} execution ${index + 1} of ${total} completed`,
+      EXECUTION_COLORS.completed,
+    )
+  },
+  cancelled: ({ index, total }) => {
+    return ANSI.color(
+      `${UNICODE.FAILURE_RAW} execution ${index + 1} of ${total} cancelled`,
+      EXECUTION_COLORS.cancelled,
+    )
+  },
+}
+
+const formatConsoleCalls = (consoleCalls) => {
+  const consoleOutput = consoleCalls.reduce((previous, { text }) => {
+    return `${previous}${text}`
+  }, "")
+  const consoleOutputTrimmed = consoleOutput.trim()
+  if (consoleOutputTrimmed === "") {
+    return ""
+  }
+  return `${ANSI.color(`-------- console --------`, ANSI.GREY)}
+${consoleOutputTrimmed}
+${ANSI.color(`-------------------------`, ANSI.GREY)}`
+}
+
+const formatExecution = ({ label, details = {}, console }) => {
+  let message = ``
+  message += label
+  Object.keys(details).forEach((key) => {
+    message += `
+${key}: ${details[key]}`
+  })
+  if (console) {
+    message += `
+${console}`
+  }
+  return message
+}

package/dist/browser_client/asset-manifest.json

@@ -1,4 +0,0 @@
-{
-  "browser_client.js": "browser_client_fb33eaa4.js",
-  "browser_client.js.map": "browser_client_fb33eaa4.js.map"
-}