@jsenv/test 2.1.3 → 3.0.1

package/src/execution/run.js

@@ -14,6 +14,8 @@ import crypto from "node:crypto";
 import { Abort, raceCallbacks } from "@jsenv/abort";
 import { ensureParentDirectories } from "@jsenv/filesystem";
 
+import { createException } from "./exception.js";
+
 export const run = async ({
   signal = new AbortController().signal,
   logger,
@@ -21,19 +23,43 @@ export const run = async ({
   keepRunning = false,
   mirrorConsole = false,
   collectConsole = false,
+  measureMemoryUsage = false,
+  onMeasureMemoryAvailable,
+  collectPerformance = false,
   coverageEnabled = false,
   coverageTempDirectoryUrl,
-  collectPerformance = false,
   runtime,
   runtimeParams,
 }) => {
+  if (keepRunning) {
+    allocatedMs = Infinity;
+  }
+  if (allocatedMs === Infinity) {
+    allocatedMs = 0;
+  }
+
+  const timingOrigin = Date.now();
   const result = {
     status: "pending",
     errors: [],
     namespace: null,
+    consoleCalls: null,
+    timings: {
+      origin: timingOrigin,
+      start: 0,
+      runtimeStart: null,
+      executionStart: null,
+      executionEnd: null,
+      runtimeEnd: null,
+      end: null,
+    },
+    memoryUsage: null,
+    performance: null,
+    coverageFileUrl: null,
+  };
+  const takeTiming = (ms = Date.now()) => {
+    return ms - timingOrigin;
   };
-  const callbacks = [];
-
   const onConsoleRef = { current: () => {} };
   const stopSignal = { notify: () => {} };
   const runtimeLabel = `${runtime.name}/${runtime.version}`;
@@ -41,13 +67,7 @@ export const run = async ({
   const runOperation = Abort.startOperation();
   runOperation.addAbortSignal(signal);
   let timeoutAbortSource;
-  if (
-    // ideally we would rather log than the timeout is ignored
-    // when keepRunning is true
-    !keepRunning &&
-    typeof allocatedMs === "number" &&
-    allocatedMs !== Infinity
-  ) {
+  if (allocatedMs) {
     timeoutAbortSource = runOperation.timeout(allocatedMs);
   }
   const consoleCalls = [];
@@ -77,19 +97,12 @@ export const run = async ({
       coverageTempDirectoryUrl,
     ).href;
     await ensureParentDirectories(coverageFileUrl);
-    if (coverageEnabled) {
-      result.coverageFileUrl = coverageFileUrl;
-      // written within the child_process/worker_thread or during runtime.run()
-      // for browsers
-      // (because it takes time to serialize and transfer the coverage object)
-    }
+    result.coverageFileUrl = coverageFileUrl;
+    // written within the child_process/worker_thread or during runtime.run()
+    // for browsers
+    // (because it takes time to serialize and transfer the coverage object)
   }
 
-  const startMs = Date.now();
-  callbacks.push(() => {
-    result.duration = Date.now() - startMs;
-  });
-
   try {
     logger.debug(`run() ${runtimeLabel}`);
     runOperation.throwIfAborted();
@@ -103,17 +116,29 @@ export const run = async ({
             };
           },
           runned: async (cb) => {
+            let runtimeStatus = "starting";
             try {
               const runResult = await runtime.run({
                 signal: runOperation.signal,
                 logger,
                 ...runtimeParams,
                 collectConsole,
+                measureMemoryUsage,
+                onMeasureMemoryAvailable,
                 collectPerformance,
                 coverageFileUrl,
                 keepRunning,
                 stopSignal,
                 onConsole: (log) => onConsoleRef.current(log),
+                onRuntimeStarted: () => {
+                  runtimeStatus = "started";
+                  result.timings.runtimeStart = takeTiming();
+                },
+                onRuntimeStopped: () => {
+                  if (runtimeStatus === "stopped") return; // ignore double calls
+                  runtimeStatus = "stopped";
+                  result.timings.runtimeEnd = takeTiming();
+                },
               });
               cb(runResult);
             } catch (e) {
@@ -131,13 +156,35 @@ export const run = async ({
     if (winner.name === "aborted") {
       runOperation.throwIfAborted();
     }
-    const { status, namespace, errors, performance } = winner.data;
+    const {
+      status,
+      errors,
+      namespace,
+      timings = {},
+      memoryUsage,
+      performance,
+    } = winner.data;
     result.status = status;
-    result.errors.push(...errors);
+    for (let error of errors) {
+      const errorProxy = normalizeRuntimeError(error);
+      result.errors.push(errorProxy);
+    }
     result.namespace = namespace;
-    if (collectPerformance) {
-      result.performance = performance;
+    if (timings) {
+      if (timings.start) {
+        result.timings.executionStart = Math.max(takeTiming(timings.start), 0);
+      }
+      if (timings.end) {
+        result.timings.executionEnd = Math.max(takeTiming(timings.end), 0);
+      }
     }
+    result.memoryUsage =
+      typeof memoryUsage === "number"
+        ? memoryUsage < 0
+          ? 0
+          : memoryUsage
+        : memoryUsage;
+    result.performance = performance;
   } catch (e) {
     if (Abort.isAbortError(e)) {
       if (timeoutAbortSource && timeoutAbortSource.signal.aborted) {
@@ -151,10 +198,25 @@ export const run = async ({
     }
   } finally {
     await runOperation.end();
+    result.timings.end = takeTiming();
+    return result;
   }
-
-  callbacks.forEach((callback) => {
-    callback();
-  });
-  return result;
+};
+const normalizeRuntimeError = (runtimeError) => {
+  // the goal here is to obtain a "regular error"
+  // that can be thrown using "throw" keyword
+  // so we wrap the error hapenning inside the runtime
+  // into "errorProxy" and put .stack property on it
+  // the other properties are set by defineProperty so they are not enumerable
+  // otherwise they would pollute the error displayed by Node.js
+  const errorProxy = new Error(runtimeError.message);
+  const exception = createException(runtimeError);
+  for (const ownPropertyName of Object.getOwnPropertyNames(exception)) {
+    Object.defineProperty(errorProxy, ownPropertyName, {
+      writable: true,
+      configurable: true,
+      value: runtimeError[ownPropertyName],
+    });
+  }
+  return errorProxy;
 };

package/src/execution/web_server/start_using_command.js

@@ -5,7 +5,7 @@ import { pingServer } from "../../helpers/ping_server.js";
 
 export const startServerUsingCommand = async (
   webServer,
-  { signal, allocatedMs, logger, teardown },
+  { signal, allocatedMs, logger, teardownCallbackSet },
 ) => {
   const spawnedProcess = spawn(webServer.command, [], {
     // On non-windows platforms, `detached: true` makes child process a leader of a new
@@ -92,7 +92,7 @@ export const startServerUsingCommand = async (
   startOperation.addAbortSignal(signal);
   const timeoutAbortSource = startOperation.timeout(allocatedMs);
   startOperation.addAbortCallback(killProcess);
-  teardown.addCallback(killProcess);
+  teardownCallbackSet.add(killProcess);
 
   const startedPromise = (async () => {
     const logScale = [100, 250, 500];

package/src/execution/web_server_param.js

@@ -7,7 +7,7 @@ import { basicFetch } from "../helpers/basic_fetch.js";
 
 export const assertAndNormalizeWebServer = async (
   webServer,
-  { signal, logger, teardown },
+  { signal, logger, teardownCallbackSet },
 ) => {
   if (!webServer) {
     throw new TypeError(
@@ -35,7 +35,7 @@ export const assertAndNormalizeWebServer = async (
   }
   await ensureWebServerIsStarted(webServer, {
     signal,
-    teardown,
+    teardownCallbackSet,
     logger,
   });
   const { headers } = await basicFetch(webServer.origin, {
@@ -69,7 +69,7 @@ export const assertAndNormalizeWebServer = async (
 
 export const ensureWebServerIsStarted = async (
   webServer,
-  { signal, teardown, logger, allocatedMs = 5_000 },
+  { signal, teardownCallbackSet, logger, allocatedMs = 5_000 },
 ) => {
   const aServerIsListening = await pingServer(webServer.origin);
   if (aServerIsListening) {
@@ -79,7 +79,7 @@ export const ensureWebServerIsStarted = async (
     await startServerUsingModuleUrl(webServer, {
       signal,
       allocatedMs,
-      teardown,
+      teardownCallbackSet,
       logger,
     });
     return;
@@ -88,7 +88,7 @@ export const ensureWebServerIsStarted = async (
     await startServerUsingCommand(webServer, {
       signal,
       allocatedMs,
-      teardown,
+      teardownCallbackSet,
       logger,
     });
     return;

package/src/helpers/cpu_usage.js

@@ -0,0 +1,142 @@
+// https://gist.github.com/GaetanoPiazzolla/c40e1ebb9f709d091208e89baf9f4e00
+
+import { cpus } from "node:os";
+
+export const startMeasuringCpuUsage = () => {
+  let previousCpuArray = cpus();
+  let previousMs = Date.now();
+
+  const overall = {
+    inactive: 100,
+    active: 0,
+    system: 0,
+    user: 0,
+  };
+  const details = previousCpuArray.map(() => {
+    return {
+      inactive: 100,
+      active: 0,
+      system: 0,
+      user: 0,
+    };
+  });
+
+  const samples = [];
+  const interval = setInterval(() => {
+    let cpuArray = cpus();
+    const ms = Date.now();
+    const ellapsedMs = ms - previousMs;
+    const cpuUsagesSample = [];
+    let overallSystemMs = 0;
+    let overallUserMs = 0;
+    let overallInactiveMs = 0;
+    let overallActiveMs = 0;
+    let overallMsEllapsed = 0;
+    let index = 0;
+    for (const cpu of cpuArray) {
+      const previousCpuTimes = previousCpuArray[index].times;
+      const cpuTimes = cpu.times;
+      const systemMs = cpuTimes.sys - previousCpuTimes.sys;
+      const userMs = cpuTimes.user - previousCpuTimes.user;
+      const activeMs = systemMs + userMs;
+      const inactiveMs = ellapsedMs - activeMs;
+      const cpuUsageSample = {
+        inactive: inactiveMs / ellapsedMs,
+        active: activeMs / ellapsedMs,
+        system: systemMs / ellapsedMs,
+        user: userMs / ellapsedMs,
+      };
+      cpuUsagesSample.push(cpuUsageSample);
+
+      overallSystemMs += systemMs;
+      overallUserMs += userMs;
+      overallInactiveMs += inactiveMs;
+      overallActiveMs += activeMs;
+      overallMsEllapsed += ellapsedMs;
+      index++;
+    }
+    const overallUsageSample = {
+      inactive: overallInactiveMs / overallMsEllapsed,
+      active: overallActiveMs / overallMsEllapsed,
+      system: overallSystemMs / overallMsEllapsed,
+      user: overallUserMs / overallMsEllapsed,
+    };
+    previousCpuArray = cpuArray;
+    previousMs = ms;
+    samples.push({
+      cpuUsagesSample,
+      overallUsageSample,
+    });
+
+    if (samples.length === 10) {
+      let index = 0;
+      for (const detail of details) {
+        let systemSum = 0;
+        let userSum = 0;
+        let inactiveSum = 0;
+        let activeSum = 0;
+        for (const sample of samples) {
+          const { cpuUsagesSample } = sample;
+          const cpuUsageSample = cpuUsagesSample[index];
+          inactiveSum += cpuUsageSample.inactive;
+          activeSum += cpuUsageSample.active;
+          systemSum += cpuUsageSample.system;
+          userSum += cpuUsageSample.user;
+        }
+        Object.assign(detail, {
+          inactive: inactiveSum / samples.length,
+          active: activeSum / samples.length,
+          system: systemSum / samples.length,
+          user: userSum / samples.length,
+        });
+        index++;
+      }
+
+      let overallSystemSum = 0;
+      let overallUserSum = 0;
+      let overallInactiveSum = 0;
+      let overallActiveSum = 0;
+      for (const sample of samples) {
+        const { overallUsageSample } = sample;
+        overallSystemSum += overallUsageSample.system;
+        overallUserSum += overallUsageSample.user;
+        overallInactiveSum += overallUsageSample.inactive;
+        overallActiveSum += overallUsageSample.active;
+      }
+      Object.assign(overall, {
+        inactive: overallInactiveSum / samples.length,
+        active: overallActiveSum / samples.length,
+        system: overallSystemSum / samples.length,
+        user: overallUserSum / samples.length,
+      });
+      // console.log(formatUsage(globalUsageInfo));
+      samples.length = 0;
+    }
+  }, 15);
+  interval.unref();
+
+  return {
+    overall,
+    details,
+    stop: () => {
+      clearInterval(interval);
+    },
+  };
+};
+
+export const formatUsage = (usageInfo) => {
+  const { active, inactive, system, user } = usageInfo;
+
+  return `${ratioAsPercentage(active)} (system: ${ratioAsPercentage(
+    system,
+  )}, user: ${ratioAsPercentage(user)}), inactive: ${ratioAsPercentage(
+    inactive,
+  )}`;
+};
+
+export const ratioAsPercentage = (ratio) => {
+  const percentageAsNumber = ratio * 100;
+  const percentageAsNumberRounded = Math.round(percentageAsNumber);
+  const percentage = `${percentageAsNumberRounded}%`;
+  return percentage;
+};

package/src/helpers/cpu_usage.test_manual.js

@@ -0,0 +1,7 @@
+import { startMeasuringCpuUsage, formatUsage } from "./cpu_usage.js";
+
+const cpuUsage = startMeasuringCpuUsage();
+
+setInterval(() => {
+  console.log(formatUsage(cpuUsage.overall));
+}, 400);

package/src/main.js

@@ -6,5 +6,13 @@ export { firefox, firefoxIsolatedTab } from "./runtime_browsers/firefox.js";
 export { webkit, webkitIsolatedTab } from "./runtime_browsers/webkit.js";
 export { nodeChildProcess } from "./runtime_node/node_child_process.js";
 export { nodeWorkerThread } from "./runtime_node/node_worker_thread.js";
+// coverage
+export { reportCoverageInConsole } from "./coverage/report_coverage_in_console.js";
+export { reportCoverageAsJson } from "./coverage/report_coverage_as_json.js";
+export { reportCoverageAsHtml } from "./coverage/report_coverage_as_html.js";
+// reporters
+export { reporterList } from "./execution/reporters/reporter_list.js";
+// other
+export { reportAsJunitXml } from "./execution/junit_xml_file/report_as_junit_xml.js";
 // advanced
 export { execute } from "./execution/execute.js";

package/src/runtime_browsers/chromium.js

@@ -14,10 +14,8 @@ export const chromiumIsolatedTab = (params) => {
 const createChromiumRuntine = (params) => {
   return createRuntimeUsingPlaywright({
     browserName: "chromium",
-    // browserVersion will be set by "browser._initializer.version"
-    // see also https://github.com/microsoft/playwright/releases
-    browserVersion: "unset",
     coveragePlaywrightAPIAvailable: true,
+    memoryUsageAPIAvailable: true,
     ...params,
   });
 };

package/src/runtime_browsers/firefox.js

@@ -34,9 +34,6 @@ To ignore potential flakyness, use disableOnWindowsBecauseFlaky: false`,
 
   return createRuntimeUsingPlaywright({
     browserName: "firefox",
-    // browserVersion will be set by "browser._initializer.version"
-    // see also https://github.com/microsoft/playwright/releases
-    browserVersion: "unset",
     isolatedTab: true,
     ...params,
   });

package/src/runtime_browsers/middleware_istanbul.js

@@ -7,10 +7,10 @@ import { babelPluginInstrument } from "../coverage/babel_plugin_instrument.js";
 
 export const initIstanbulMiddleware = async (
   page,
-  { webServer, rootDirectoryUrl, coverageConfig },
+  { webServer, rootDirectoryUrl, coverageInclude },
 ) => {
   const associations = URL_META.resolveAssociations(
-    { cover: coverageConfig },
+    { cover: coverageInclude },
     rootDirectoryUrl,
   );
   await page.route("**", async (route) => {