@jsenv/core 23.1.1 → 23.2.0

package/src/execute.js

@@ -1,10 +1,8 @@
 import {
-  createCancellationToken,
-  composeCancellationToken,
-} from "@jsenv/cancellation"
-
+  Abortable,
+  raceProcessTeardownEvents,
+} from "@jsenv/core/src/abort/main.js"
 import { normalizeRuntimeSupport } from "@jsenv/core/src/internal/generateGroupMap/runtime_support.js"
-import { executeJsenvAsyncFunction } from "./internal/executeJsenvAsyncFunction.js"
 import {
   assertProjectDirectoryUrl,
   assertProjectDirectoryExists,
@@ -13,11 +11,12 @@ import { startCompileServer } from "./internal/compiling/startCompileServer.js"
 import { launchAndExecute } from "./internal/executing/launchAndExecute.js"
 
 export const execute = async ({
+  signal = new AbortController().signal,
+  handleSIGINT = true,
+
   logLevel = "warn",
   compileServerLogLevel = logLevel,
   launchAndExecuteLogLevel = logLevel,
-  cancellationToken = createCancellationToken(),
-  cancelOnSIGINT = true,
 
   projectDirectoryUrl,
   jsenvDirectoryRelativeUrl,
@@ -59,119 +58,121 @@ export const execute = async ({
   runtimeStartedCallback,
   runtimeStoppedCallback,
   runtimeErrorAfterExecutionCallback,
-  runtimeDisconnectCallback,
+  runtimeDisconnectCallback = () => {},
 }) => {
-  const jsenvExecutionFunction = async ({ jsenvCancellationToken }) => {
-    cancellationToken = composeCancellationToken(
-      cancellationToken,
-      jsenvCancellationToken,
+  projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
+  await assertProjectDirectoryExists({ projectDirectoryUrl })
+
+  if (typeof fileRelativeUrl !== "string") {
+    throw new TypeError(
+      `fileRelativeUrl must be a string, got ${fileRelativeUrl}`,
     )
+  }
+  fileRelativeUrl = fileRelativeUrl.replace(/\\/g, "/")
 
-    projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
-    await assertProjectDirectoryExists({ projectDirectoryUrl })
+  if (typeof runtime !== "object") {
+    throw new TypeError(`runtime must be an object, got ${runtime}`)
+  }
+  if (typeof runtime.launch !== "function") {
+    throw new TypeError(
+      `runtime.launch must be a function, got ${runtime.launch}`,
+    )
+  }
 
-    if (typeof fileRelativeUrl !== "string") {
-      throw new TypeError(
-        `fileRelativeUrl must be a string, got ${fileRelativeUrl}`,
-      )
-    }
-    fileRelativeUrl = fileRelativeUrl.replace(/\\/g, "/")
+  const executeOperation = Abortable.fromSignal(signal)
+  if (handleSIGINT) {
+    Abortable.effect(executeOperation, (cb) =>
+      raceProcessTeardownEvents(
+        {
+          SIGINT: true,
+        },
+        cb,
+      ),
+    )
+  }
 
-    if (typeof runtime !== "object") {
-      throw new TypeError(`runtime must be an object, got ${runtime}`)
-    }
-    if (typeof runtime.launch !== "function") {
-      throw new TypeError(
-        `runtime.launch must be a function, got ${runtime.launch}`,
-      )
-    }
+  const {
+    outDirectoryRelativeUrl,
+    origin: compileServerOrigin,
+    stop,
+  } = await startCompileServer({
+    signal: executeOperation.signal,
+    compileServerLogLevel,
+
+    projectDirectoryUrl,
+    jsenvDirectoryRelativeUrl,
+    jsenvDirectoryClean,
+    outDirectoryName: "out-dev",
+
+    importDefaultExtension,
+
+    compileServerProtocol,
+    compileServerPrivateKey,
+    compileServerCertificate,
+    compileServerIp,
+    compileServerPort,
+    babelPluginMap,
+    customCompilers,
+    runtimeSupport: normalizeRuntimeSupport({
+      [runtime.name]: runtime.version,
+    }),
+    compileServerCanReadFromFilesystem,
+    compileServerCanWriteOnFilesystem,
+  })
+  executeOperation.cleaner.addCallback(() => {
+    return stop()
+  })
 
-    const {
-      outDirectoryRelativeUrl,
-      origin: compileServerOrigin,
-      stop,
-    } = await startCompileServer({
-      cancellationToken,
-      compileServerLogLevel,
+  const result = await launchAndExecute({
+    signal: executeOperation.signal,
+    launchAndExecuteLogLevel,
 
+    runtime,
+    runtimeParams: {
       projectDirectoryUrl,
-      jsenvDirectoryRelativeUrl,
-      jsenvDirectoryClean,
-      outDirectoryName: "out-dev",
-
-      importDefaultExtension,
-
-      compileServerProtocol,
-      compileServerPrivateKey,
-      compileServerCertificate,
-      compileServerIp,
-      compileServerPort,
-      babelPluginMap,
-      customCompilers,
-      runtimeSupport: normalizeRuntimeSupport({
-        [runtime.name]: runtime.version,
-      }),
-      compileServerCanReadFromFilesystem,
-      compileServerCanWriteOnFilesystem,
-    })
-
-    const result = await launchAndExecute({
-      launchAndExecuteLogLevel,
-      cancellationToken,
-
-      runtime,
-      runtimeParams: {
-        projectDirectoryUrl,
-        compileServerOrigin,
-        outDirectoryRelativeUrl,
-        ...runtimeParams,
-      },
-      executeParams: {
-        fileRelativeUrl,
-      },
-
-      allocatedMs,
-      measureDuration,
-      mirrorConsole,
-      captureConsole,
-      collectRuntimeName,
-      collectRuntimeVersion,
-      inheritCoverage,
-      collectCoverage,
-      measurePerformance,
-      collectPerformance,
-
-      stopAfterExecute,
-      stopAfterExecuteReason,
-      gracefulStopAllocatedMs,
-
-      runtimeConsoleCallback,
-      runtimeStartedCallback,
-      runtimeStoppedCallback,
-      runtimeErrorAfterExecutionCallback,
-      runtimeDisconnectCallback,
-    })
-
-    stop("single-execution-done")
-
-    if (collectCompileServerInfo) {
-      result.outDirectoryRelativeUrl = outDirectoryRelativeUrl
-      result.compileServerOrigin = compileServerOrigin
-    }
-
-    return result
-  }
-
-  const executionPromise = executeJsenvAsyncFunction(jsenvExecutionFunction, {
-    cancelOnSIGINT,
+      compileServerOrigin,
+      outDirectoryRelativeUrl,
+      ...runtimeParams,
+    },
+    executeParams: {
+      fileRelativeUrl,
+    },
+
+    allocatedMs,
+    measureDuration,
+    mirrorConsole,
+    captureConsole,
+    collectRuntimeName,
+    collectRuntimeVersion,
+    inheritCoverage,
+    collectCoverage,
+    measurePerformance,
+    collectPerformance,
+
+    stopAfterExecute,
+    stopAfterExecuteReason,
+    gracefulStopAllocatedMs,
+
+    runtimeConsoleCallback,
+    runtimeStartedCallback,
+    runtimeStoppedCallback,
+    runtimeErrorAfterExecutionCallback,
+    runtimeDisconnectCallback: () => {
+      // stop server when runtime disconnects
+      executeOperation.cleaner.clean("runtime-stopped")
+      runtimeDisconnectCallback()
+    },
   })
 
-  if (ignoreError) {
-    return executionPromise
+  if (collectCompileServerInfo) {
+    result.outDirectoryRelativeUrl = outDirectoryRelativeUrl
+    result.compileServerOrigin = compileServerOrigin
   }
 
-  const result = await executionPromise
   if (result.status === "errored") {
+    if (ignoreError) {
+      return result
+    }
     /*
     Warning: when node launched with --unhandled-rejections=strict, despites
     this promise being rejected by throw result.error node will compltely ignore it.

package/src/executeTestPlan.js

@@ -1,8 +1,3 @@
-/* eslint-disable import/max-dependencies */
-import {
-  createCancellationToken,
-  composeCancellationToken,
-} from "@jsenv/cancellation"
 import {
   normalizeStructuredMetaMap,
   urlToFileSystemPath,
@@ -13,7 +8,6 @@ import {
 } from "@jsenv/filesystem"
 import { createLogger, createDetailedMessage } from "@jsenv/logger"
 
-import { executeJsenvAsyncFunction } from "./internal/executeJsenvAsyncFunction.js"
 import {
   assertProjectDirectoryUrl,
   assertProjectDirectoryExists,
@@ -26,11 +20,11 @@ import { generateCoverageTextLog } from "./internal/executing/coverage/generateC
 import { jsenvCoverageConfig } from "./jsenvCoverageConfig.js"
 
 export const executeTestPlan = async ({
+  signal = new AbortController().signal,
+  handleSIGINT = true,
   logLevel = "info",
   compileServerLogLevel = "warn",
   launchAndExecuteLogLevel = "warn",
-  cancellationToken = createCancellationToken(),
-  cancelOnSIGINT = false,
 
   projectDirectoryUrl,
   jsenvDirectoryRelativeUrl,
@@ -40,7 +34,7 @@ export const executeTestPlan = async ({
   testPlan,
   defaultMsAllocatedPerExecution,
 
-  concurrencyLimit,
+  maxExecutionsInParallel,
 
   completedExecutionLogAbbreviation = false,
   completedExecutionLogMerging = false,
@@ -80,117 +74,107 @@ export const executeTestPlan = async ({
   customCompilers,
   jsenvDirectoryClean,
 }) => {
-  const jsenvExecuteTestPlanFunction = async ({ jsenvCancellationToken }) => {
-    cancellationToken = composeCancellationToken(
-      cancellationToken,
-      jsenvCancellationToken,
-    )
-
-    const logger = createLogger({ logLevel })
+  const logger = createLogger({ logLevel })
 
-    cancellationToken.register((cancelError) => {
-      if (cancelError.reason === "process SIGINT") {
-        logger.info(`process SIGINT -> cancelling test execution`)
-      }
-    })
+  projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
+  await assertProjectDirectoryExists({ projectDirectoryUrl })
 
-    projectDirectoryUrl = assertProjectDirectoryUrl({ projectDirectoryUrl })
-    await assertProjectDirectoryExists({ projectDirectoryUrl })
+  if (typeof testPlan !== "object") {
+    throw new Error(`testPlan must be an object, got ${testPlan}`)
+  }
 
-    if (typeof testPlan !== "object") {
-      throw new Error(`testPlan must be an object, got ${testPlan}`)
+  if (coverage) {
+    if (typeof coverageConfig !== "object") {
+      throw new TypeError(
+        `coverageConfig must be an object, got ${coverageConfig}`,
+      )
     }
-
-    if (coverage) {
-      if (typeof coverageConfig !== "object") {
-        throw new TypeError(
-          `coverageConfig must be an object, got ${coverageConfig}`,
-        )
-      }
-      if (Object.keys(coverageConfig).length === 0) {
-        logger.warn(
-          `coverageConfig is an empty object. Nothing will be instrumented for coverage so your coverage will be empty`,
-        )
-      }
-      if (!coverageAndExecutionAllowed) {
-        const structuredMetaMapForExecute = normalizeStructuredMetaMap(
-          {
-            execute: testPlan,
-          },
-          "file:///",
-        )
-        const structuredMetaMapForCover = normalizeStructuredMetaMap(
-          {
-            cover: coverageConfig,
-          },
-          "file:///",
+    if (Object.keys(coverageConfig).length === 0) {
+      logger.warn(
+        `coverageConfig is an empty object. Nothing will be instrumented for coverage so your coverage will be empty`,
+      )
+    }
+    if (!coverageAndExecutionAllowed) {
+      const structuredMetaMapForExecute = normalizeStructuredMetaMap(
+        {
+          execute: testPlan,
+        },
+        "file:///",
+      )
+      const structuredMetaMapForCover = normalizeStructuredMetaMap(
+        {
+          cover: coverageConfig,
+        },
+        "file:///",
+      )
+      const patternsMatchingCoverAndExecute = Object.keys(
+        structuredMetaMapForExecute.execute,
+      ).filter((testPlanPattern) => {
+        return urlToMeta({
+          url: testPlanPattern,
+          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
+        throw new Error(
+          createDetailedMessage(`some file will be both covered and executed`, {
+            patterns: patternsMatchingCoverAndExecute,
+          }),
         )
-        const patternsMatchingCoverAndExecute = Object.keys(
-          structuredMetaMapForExecute.execute,
-        ).filter((testPlanPattern) => {
-          return urlToMeta({
-            url: testPlanPattern,
-            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
-          throw new Error(
-            createDetailedMessage(
-              `some file will be both covered and executed`,
-              {
-                patterns: patternsMatchingCoverAndExecute,
-              },
-            ),
-          )
-        }
       }
     }
+  }
 
-    const result = await executePlan(testPlan, {
-      logger,
-      compileServerLogLevel,
-      launchAndExecuteLogLevel,
-      cancellationToken,
-
-      projectDirectoryUrl,
-      jsenvDirectoryRelativeUrl,
-
-      importResolutionMethod,
-      importDefaultExtension,
-
-      defaultMsAllocatedPerExecution,
-      concurrencyLimit,
-      completedExecutionLogMerging,
-      completedExecutionLogAbbreviation,
-      logSummary,
-      measureGlobalDuration,
-
-      coverage,
-      coverageConfig,
-      coverageIncludeMissing,
-      coverageForceIstanbul,
-      coverageV8MergeConflictIsExpected,
-
-      jsenvDirectoryClean,
-      compileServerProtocol,
-      compileServerPrivateKey,
-      compileServerCertificate,
-      compileServerIp,
-      compileServerPort,
-      compileServerCanReadFromFilesystem,
-      compileServerCanWriteOnFilesystem,
-      babelPluginMap,
-      babelConfigFileUrl,
-      customCompilers,
-    })
-
-    if (updateProcessExitCode && !executionIsPassed(result)) {
-      process.exitCode = 1
-    }
+  const result = await executePlan(testPlan, {
+    signal,
+    handleSIGINT,
+
+    logger,
+    compileServerLogLevel,
+    launchAndExecuteLogLevel,
+
+    projectDirectoryUrl,
+    jsenvDirectoryRelativeUrl,
+
+    importResolutionMethod,
+    importDefaultExtension,
+
+    defaultMsAllocatedPerExecution,
+    maxExecutionsInParallel,
+    completedExecutionLogMerging,
+    completedExecutionLogAbbreviation,
+    logSummary,
+    measureGlobalDuration,
+
+    coverage,
+    coverageConfig,
+    coverageIncludeMissing,
+    coverageForceIstanbul,
+    coverageV8MergeConflictIsExpected,
+
+    jsenvDirectoryClean,
+    compileServerProtocol,
+    compileServerPrivateKey,
+    compileServerCertificate,
+    compileServerIp,
+    compileServerPort,
+    compileServerCanReadFromFilesystem,
+    compileServerCanWriteOnFilesystem,
+    babelPluginMap,
+    babelConfigFileUrl,
+    customCompilers,
+  })
 
+  if (updateProcessExitCode && !executionIsPassed(result)) {
+    process.exitCode = 1
+  }
+
+  const planCoverage = result.planCoverage
+  // planCoverage can be null when execution is abortes
+  if (planCoverage) {
     const promises = []
     // keep this one first because it does ensureEmptyDirectory
     // and in case coverage json file gets written in the same directory
@@ -208,7 +192,7 @@ export const executeTestPlan = async ({
         )
       }
       promises.push(
-        generateCoverageHtmlDirectory(result.planCoverage, {
+        generateCoverageHtmlDirectory(planCoverage, {
           projectDirectoryUrl,
           coverageHtmlDirectoryRelativeUrl,
         }),
@@ -235,15 +219,11 @@ export const executeTestPlan = async ({
       )
     }
     await Promise.all(promises)
-
-    return {
-      testPlanSummary: result.planSummary,
-      testPlanReport: result.planReport,
-      testPlanCoverage: result.planCoverage,
-    }
   }
 
-  return executeJsenvAsyncFunction(jsenvExecuteTestPlanFunction, {
-    cancelOnSIGINT,
-  })
+  return {
+    testPlanSummary: result.planSummary,
+    testPlanReport: result.planReport,
+    testPlanCoverage: planCoverage,
+  }
 }

package/src/importUsingChildProcess.js

@@ -36,10 +36,11 @@ export const importUsingChildProcess = async (
 
         return {
           ...controllableNodeProcess,
-          execute: async () => {
+          execute: async ({ signal }) => {
             try {
               const namespace =
                 await controllableNodeProcess.requestActionOnChildProcess({
+                  signal,
                   actionType: "execute-using-import",
                   actionParams: { fileUrl },
                 })

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

@@ -5,6 +5,7 @@ import {
   urlToExtension,
 } from "@jsenv/filesystem"
 
+import { Abortable } from "@jsenv/core/src/abort/main.js"
 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"
@@ -14,7 +15,7 @@ import { escapeRegexpSpecialCharacters } from "../escapeRegexpSpecialCharacters.
 export const executeHtmlFile = async (
   fileRelativeUrl,
   {
-    cancellationToken,
+    launchBrowserOperation,
     projectDirectoryUrl,
     compileServerOrigin,
     outDirectoryRelativeUrl,
@@ -45,11 +46,13 @@ export const executeHtmlFile = async (
     compileProxyProjectRelativeUrl,
     compileServerOrigin,
   )
+  Abortable.throwIfAborted(launchBrowserOperation)
   await page.goto(compileProxyClientUrl)
 
   const coverageHandledFromOutside =
     coveragePlaywrightAPIAvailable && !coverageForceIstanbul
 
+  Abortable.throwIfAborted(launchBrowserOperation)
   const browserRuntimeFeaturesReport = await page.evaluate(
     /* istanbul ignore next */
     ({ coverageHandledFromOutside }) => {
@@ -65,6 +68,7 @@ export const executeHtmlFile = async (
   try {
     let executionResult
     const { canAvoidCompilation, compileId } = browserRuntimeFeaturesReport
+    Abortable.throwIfAborted(launchBrowserOperation)
     if (canAvoidCompilation) {
       executionResult = await executeSource({
         projectDirectoryUrl,
@@ -114,19 +118,27 @@ export const executeHtmlFile = async (
     }
 
     return executionResult
-  } catch (e) {
-    // if browser is closed due to cancellation
+  } catch (error) {
+    // if browser is closed due to abort
     // before it is able to finish evaluate we can safely ignore
-    // and rethrow with current cancelError
-    if (
-      e.message.match(/^Protocol error \(.*?\): Target closed/) &&
-      cancellationToken.cancellationRequested
-    ) {
-      cancellationToken.throwIfRequested()
+    // and rethrow with current abort error
+    if (launchBrowserOperation.signal.aborted && isBrowserClosedError(error)) {
+      Abortable.throwIfAborted(launchBrowserOperation)
     }
+    throw error
+  }
+}
 
-    throw e
+const isBrowserClosedError = (error) => {
+  if (error.message.match(/browserContext.newPage: Browser closed/)) {
+    return true
   }
+
+  if (error.message.match(/^Protocol error \(.*?\): Target closed/)) {
+    return true
+  }
+
+  return false
 }
 
 const executeSource = async ({

package/src/internal/browser-utils/fetch-browser.js

@@ -1,36 +1,11 @@
-import { createCancellationToken } from "@jsenv/cancellation/main.browser.js"
 import { fetchUsingXHR } from "./fetchUsingXHR.js"
 
-const fetchNative = async (
-  url,
-  {
-    cancellationToken = createCancellationToken(),
-    mode = "cors",
-    ...options
-  } = {},
-) => {
-  const abortController = new AbortController()
-
-  let cancelError
-  cancellationToken.register((reason) => {
-    cancelError = reason
-    abortController.abort(reason)
+const fetchNative = async (url, { mode = "cors", ...options } = {}) => {
+  const response = await window.fetch(url, {
+    mode,
+    ...options,
   })
 
-  let response
-  try {
-    response = await window.fetch(url, {
-      signal: abortController.signal,
-      mode,
-      ...options,
-    })
-  } catch (e) {
-    if (cancelError && e.name === "AbortError") {
-      throw cancelError
-    }
-    throw e
-  }
-
   return {
     url: response.url,
     status: response.status,

package/src/internal/browser-utils/fetchUsingXHR.js

@@ -1,13 +1,9 @@
-import { createCancellationToken } from "@jsenv/cancellation/main.browser.js"
 import { createDetailedMessage } from "@jsenv/logger"
-// ideally we should do some window.fetch detection (ensuring it has cancellation) and accordingly
-// fallback to this polyfill (or even use an existing polyfill would be better)
-// https://github.com/github/fetch/blob/master/fetch.js
 
 export const fetchUsingXHR = async (
   url,
   {
-    cancellationToken = createCancellationToken(),
+    signal,
     method = "GET",
     credentials = "same-origin",
     headers = {},
@@ -52,9 +48,11 @@ export const fetchUsingXHR = async (
     bodyPromise.resolve()
   }
 
-  cancellationToken.register((cancelError) => {
+  signal.addEventListener("abort", () => {
     xhr.abort()
-    failure(cancelError)
+    const abortError = new Error("aborted")
+    abortError.name = "AbortError"
+    failure(abortError)
   })
 
   xhr.onreadystatechange = () => {