@jsenv/test 1.1.2 → 1.1.4

package/src/execution/run.js

@@ -10,9 +10,9 @@
  * - File execution result is returned, it contains status/errors/namespace/consoleCalls
  */
 
-import { createId } from "@paralleldrive/cuid2"
-import { Abort, raceCallbacks } from "@jsenv/abort"
-import { ensureParentDirectories } from "@jsenv/filesystem"
+import { createId } from "@paralleldrive/cuid2";
+import { Abort, raceCallbacks } from "@jsenv/abort";
+import { ensureParentDirectories } from "@jsenv/filesystem";
 
 export const run = async ({
   signal = new AbortController().signal,
@@ -31,16 +31,16 @@ export const run = async ({
     status: "pending",
     errors: [],
     namespace: null,
-  }
-  const callbacks = []
+  };
+  const callbacks = [];
 
-  const onConsoleRef = { current: () => {} }
-  const stopSignal = { notify: () => {} }
-  const runtimeLabel = `${runtime.name}/${runtime.version}`
+  const onConsoleRef = { current: () => {} };
+  const stopSignal = { notify: () => {} };
+  const runtimeLabel = `${runtime.name}/${runtime.version}`;
 
-  const runOperation = Abort.startOperation()
-  runOperation.addAbortSignal(signal)
-  let timeoutAbortSource
+  const runOperation = Abort.startOperation();
+  runOperation.addAbortSignal(signal);
+  let timeoutAbortSource;
   if (
     // ideally we would rather log than the timeout is ignored
     // when keepRunning is true
@@ -48,59 +48,59 @@ export const run = async ({
     typeof allocatedMs === "number" &&
     allocatedMs !== Infinity
   ) {
-    timeoutAbortSource = runOperation.timeout(allocatedMs)
+    timeoutAbortSource = runOperation.timeout(allocatedMs);
   }
-  const consoleCalls = []
+  const consoleCalls = [];
   onConsoleRef.current = ({ type, text }) => {
     if (mirrorConsole) {
       if (type === "error") {
-        process.stderr.write(text)
+        process.stderr.write(text);
       } else {
-        process.stdout.write(text)
+        process.stdout.write(text);
       }
     }
     if (collectConsole) {
-      consoleCalls.push({ type, text })
+      consoleCalls.push({ type, text });
     }
-  }
+  };
   if (collectConsole) {
-    result.consoleCalls = consoleCalls
+    result.consoleCalls = consoleCalls;
   }
 
   // we do not keep coverage in memory, it can grow very big
   // instead we store it on the filesystem
   // and they can be read later at "coverageFileUrl"
-  let coverageFileUrl
+  let coverageFileUrl;
   if (coverageEnabled) {
     coverageFileUrl = new URL(
       `./${runtime.name}/${createId()}.json`,
       coverageTempDirectoryUrl,
-    ).href
-    await ensureParentDirectories(coverageFileUrl)
+    ).href;
+    await ensureParentDirectories(coverageFileUrl);
     if (coverageEnabled) {
-      result.coverageFileUrl = coverageFileUrl
+      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()
+  const startMs = Date.now();
   callbacks.push(() => {
-    result.duration = Date.now() - startMs
-  })
+    result.duration = Date.now() - startMs;
+  });
 
   try {
-    logger.debug(`run() ${runtimeLabel}`)
-    runOperation.throwIfAborted()
+    logger.debug(`run() ${runtimeLabel}`);
+    runOperation.throwIfAborted();
     const winnerPromise = new Promise((resolve) => {
       raceCallbacks(
         {
           aborted: (cb) => {
-            runOperation.signal.addEventListener("abort", cb)
+            runOperation.signal.addEventListener("abort", cb);
             return () => {
-              runOperation.signal.removeEventListener("abort", cb)
-            }
+              runOperation.signal.removeEventListener("abort", cb);
+            };
           },
           runned: async (cb) => {
             try {
@@ -114,47 +114,47 @@ export const run = async ({
                 keepRunning,
                 stopSignal,
                 onConsole: (log) => onConsoleRef.current(log),
-              })
-              cb(runResult)
+              });
+              cb(runResult);
             } catch (e) {
               cb({
                 status: "failed",
                 errors: [e],
-              })
+              });
             }
           },
         },
         resolve,
-      )
-    })
-    const winner = await winnerPromise
+      );
+    });
+    const winner = await winnerPromise;
     if (winner.name === "aborted") {
-      runOperation.throwIfAborted()
+      runOperation.throwIfAborted();
     }
-    const { status, namespace, errors, performance } = winner.data
-    result.status = status
-    result.errors.push(...errors)
-    result.namespace = namespace
+    const { status, namespace, errors, performance } = winner.data;
+    result.status = status;
+    result.errors.push(...errors);
+    result.namespace = namespace;
     if (collectPerformance) {
-      result.performance = performance
+      result.performance = performance;
     }
   } catch (e) {
     if (Abort.isAbortError(e)) {
       if (timeoutAbortSource && timeoutAbortSource.signal.aborted) {
-        result.status = "timedout"
+        result.status = "timedout";
       } else {
-        result.status = "aborted"
+        result.status = "aborted";
       }
     } else {
-      result.status = "failed"
-      result.errors.push(e)
+      result.status = "failed";
+      result.errors.push(e);
     }
   } finally {
-    await runOperation.end()
+    await runOperation.end();
   }
 
   callbacks.forEach((callback) => {
-    callback()
-  })
-  return result
-}
+    callback();
+  });
+  return result;
+};

package/src/execution/web_server_param.js

@@ -1,46 +1,46 @@
-import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-import { pingServer } from "@jsenv/core/src/helpers/ping_server.js"
-import { basicFetch } from "@jsenv/core/src/helpers/basic_fetch.js"
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem";
+import { pingServer } from "@jsenv/core/src/helpers/ping_server.js";
+import { basicFetch } from "@jsenv/core/src/helpers/basic_fetch.js";
 
 export const assertAndNormalizeWebServer = async (webServer) => {
   if (!webServer) {
     throw new TypeError(
       `webServer is required when running tests on browser(s)`,
-    )
+    );
   }
   const unexpectedParamNames = Object.keys(webServer).filter((key) => {
-    return !["origin", "moduleUrl", "rootDirectoryUrl"].includes(key)
-  })
+    return !["origin", "moduleUrl", "rootDirectoryUrl"].includes(key);
+  });
   if (unexpectedParamNames.length > 0) {
     throw new TypeError(
       `${unexpectedParamNames.join(",")}: there is no such param to webServer`,
-    )
+    );
   }
 
-  let aServerIsListening = await pingServer(webServer.origin)
+  let aServerIsListening = await pingServer(webServer.origin);
   if (!aServerIsListening) {
     if (!webServer.moduleUrl) {
       throw new TypeError(
         `webServer.moduleUrl is required as there is no server listening "${webServer.origin}"`,
-      )
+      );
     }
     try {
-      process.env.IMPORTED_BY_TEST_PLAN = "1"
-      await import(webServer.moduleUrl)
-      delete process.env.IMPORTED_BY_TEST_PLAN
+      process.env.IMPORTED_BY_TEST_PLAN = "1";
+      await import(webServer.moduleUrl);
+      delete process.env.IMPORTED_BY_TEST_PLAN;
     } catch (e) {
       if (e.code === "ERR_MODULE_NOT_FOUND") {
         throw new Error(
           `webServer.moduleUrl does not lead to a file at "${webServer.moduleUrl}"`,
-        )
+        );
       }
-      throw e
+      throw e;
     }
-    aServerIsListening = await pingServer(webServer.origin)
+    aServerIsListening = await pingServer(webServer.origin);
     if (!aServerIsListening) {
       throw new Error(
         `webServer.moduleUrl did not start a server listening at "${webServer.origin}", check file at "${webServer.moduleUrl}"`,
-      )
+      );
     }
   }
   const { headers } = await basicFetch(webServer.origin, {
@@ -49,25 +49,25 @@ export const assertAndNormalizeWebServer = async (webServer) => {
     headers: {
       "x-server-inspect": "1",
     },
-  })
+  });
   if (String(headers["server"]).includes("jsenv_dev_server")) {
-    webServer.isJsenvDevServer = true
+    webServer.isJsenvDevServer = true;
     const { json } = await basicFetch(`${webServer.origin}/__params__.json`, {
       rejectUnauthorized: false,
-    })
+    });
     if (webServer.rootDirectoryUrl === undefined) {
-      const jsenvDevServerParams = await json()
-      webServer.rootDirectoryUrl = jsenvDevServerParams.sourceDirectoryUrl
+      const jsenvDevServerParams = await json();
+      webServer.rootDirectoryUrl = jsenvDevServerParams.sourceDirectoryUrl;
     } else {
       webServer.rootDirectoryUrl = assertAndNormalizeDirectoryUrl(
         webServer.rootDirectoryUrl,
         "webServer.rootDirectoryUrl",
-      )
+      );
     }
   } else {
     webServer.rootDirectoryUrl = assertAndNormalizeDirectoryUrl(
       webServer.rootDirectoryUrl,
       "webServer.rootDirectoryUrl",
-    )
+    );
   }
-}
+};

package/src/main.js

@@ -1,10 +1,10 @@
 // test
-export { executeTestPlan } from "./execution/execute_test_plan.js"
+export { executeTestPlan } from "./execution/execute_test_plan.js";
 // runtimes (used to execute tests)
-export { chromium, chromiumIsolatedTab } from "./runtime_browsers/chromium.js"
-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"
+export { chromium, chromiumIsolatedTab } from "./runtime_browsers/chromium.js";
+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";
 // advanced
-export { execute } from "./execution/execute.js"
+export { execute } from "./execution/execute.js";

package/src/runtime_browsers/chromium.js

@@ -1,15 +1,15 @@
-import { createRuntimeUsingPlaywright } from "./using_playwright.js"
+import { createRuntimeUsingPlaywright } from "./using_playwright.js";
 
 export const chromium = (params) => {
-  return createChromiumRuntine(params)
-}
+  return createChromiumRuntine(params);
+};
 
 export const chromiumIsolatedTab = (params) => {
   return createChromiumRuntine({
     ...params,
     isolatedTab: true,
-  })
-}
+  });
+};
 
 const createChromiumRuntine = (params) => {
   return createRuntimeUsingPlaywright({
@@ -19,5 +19,5 @@ const createChromiumRuntine = (params) => {
     browserVersion: "unset",
     coveragePlaywrightAPIAvailable: true,
     ...params,
-  })
-}
+  });
+};

package/src/runtime_browsers/firefox.js

@@ -1,15 +1,15 @@
-import { createRuntimeUsingPlaywright } from "./using_playwright.js"
+import { createRuntimeUsingPlaywright } from "./using_playwright.js";
 
 export const firefox = (params) => {
-  return createFirefoxRuntime(params)
-}
+  return createFirefoxRuntime(params);
+};
 
 export const firefoxIsolatedTab = (params) => {
   return createRuntimeUsingPlaywright({
     ...params,
     isolatedTab: true,
-  })
-}
+  });
+};
 
 const createFirefoxRuntime = ({
   disableOnWindowsBecauseFlaky,
@@ -22,13 +22,13 @@ const createFirefoxRuntime = ({
         `Windows + firefox detected: executions on firefox will be ignored  (firefox is flaky on windows).
 To disable this warning, use disableOnWindowsBecauseFlaky: true
 To ignore potential flakyness, use disableOnWindowsBecauseFlaky: false`,
-      )
-      disableOnWindowsBecauseFlaky = true
+      );
+      disableOnWindowsBecauseFlaky = true;
     }
     if (disableOnWindowsBecauseFlaky) {
       return {
         disabled: true,
-      }
+      };
     }
   }
 
@@ -39,5 +39,5 @@ To ignore potential flakyness, use disableOnWindowsBecauseFlaky: false`,
     browserVersion: "unset",
     isolatedTab: true,
     ...params,
-  })
-}
+  });
+};

package/src/runtime_browsers/middleware_istanbul.js

@@ -1,9 +1,9 @@
-import { URL_META } from "@jsenv/url-meta"
-import { applyBabelPlugins } from "@jsenv/ast"
-import { SOURCEMAP, generateSourcemapDataUrl } from "@jsenv/sourcemap"
-import { WEB_URL_CONVERTER } from "@jsenv/core/src/helpers/web_url_converter.js"
+import { URL_META } from "@jsenv/url-meta";
+import { applyBabelPlugins } from "@jsenv/ast";
+import { SOURCEMAP, generateSourcemapDataUrl } from "@jsenv/sourcemap";
+import { WEB_URL_CONVERTER } from "@jsenv/core/src/helpers/web_url_converter.js";
 
-import { babelPluginInstrument } from "../coverage/babel_plugin_instrument.js"
+import { babelPluginInstrument } from "../coverage/babel_plugin_instrument.js";
 
 export const initIstanbulMiddleware = async (
   page,
@@ -12,21 +12,21 @@ export const initIstanbulMiddleware = async (
   const associations = URL_META.resolveAssociations(
     { cover: coverageConfig },
     rootDirectoryUrl,
-  )
+  );
   await page.route("**", async (route) => {
-    const request = route.request()
-    const url = request.url() // transform into a local url
-    const fileUrl = WEB_URL_CONVERTER.asFileUrl(url, webServer)
+    const request = route.request();
+    const url = request.url(); // transform into a local url
+    const fileUrl = WEB_URL_CONVERTER.asFileUrl(url, webServer);
     const needsInstrumentation = URL_META.applyAssociations({
       url: fileUrl,
       associations,
-    }).cover
+    }).cover;
     if (!needsInstrumentation) {
-      route.fallback()
-      return
+      route.fallback();
+      return;
     }
-    const response = await route.fetch()
-    const originalBody = await response.text()
+    const response = await route.fetch();
+    const originalBody = await response.text();
     try {
       const result = await applyBabelPlugins({
         babelPlugins: [babelPluginInstrument],
@@ -38,13 +38,13 @@ export const initIstanbulMiddleware = async (
           type: "js_module",
           content: originalBody,
         },
-      })
-      let code = result.code
+      });
+      let code = result.code;
       code = SOURCEMAP.writeComment({
         contentType: "text/javascript",
         content: code,
         specifier: generateSourcemapDataUrl(result.map),
-      })
+      });
       route.fulfill({
         response,
         body: code,
@@ -52,14 +52,14 @@ export const initIstanbulMiddleware = async (
           ...response.headers(),
           "content-length": Buffer.byteLength(code),
         },
-      })
+      });
     } catch (e) {
       if (e.code === "PARSE_ERROR") {
-        route.fulfill({ response })
+        route.fulfill({ response });
       } else {
-        console.error(e)
-        route.fulfill({ response })
+        console.error(e);
+        route.fulfill({ response });
       }
     }
-  })
-}
+  });
+};

package/src/runtime_browsers/middleware_js_supervisor.js

@@ -1,19 +1,19 @@
-import { readFileSync } from "node:fs"
-import { urlToExtension } from "@jsenv/urls"
+import { readFileSync } from "node:fs";
+import { urlToExtension } from "@jsenv/urls";
 import {
   injectSupervisorIntoHTML,
   supervisorFileUrl,
-} from "@jsenv/core/src/plugins/supervisor/html_supervisor_injection.js"
+} from "@jsenv/core/src/plugins/supervisor/html_supervisor_injection.js";
 
 export const initJsSupervisorMiddleware = async (
   page,
   { webServer, fileUrl, fileServerUrl },
 ) => {
-  const inlineScriptContents = new Map()
+  const inlineScriptContents = new Map();
 
   const interceptHtmlToExecute = async ({ route }) => {
-    const response = await route.fetch()
-    const originalBody = await response.text()
+    const response = await route.fetch();
+    const originalBody = await response.text();
     const injectionResult = await injectSupervisorIntoHTML(
       {
         content: originalBody,
@@ -27,11 +27,11 @@ export const initJsSupervisorMiddleware = async (
         inlineAsRemote: true,
         webServer,
         onInlineScript: ({ src, textContent }) => {
-          const inlineScriptWebUrl = new URL(src, `${webServer.origin}/`).href
-          inlineScriptContents.set(inlineScriptWebUrl, textContent)
+          const inlineScriptWebUrl = new URL(src, `${webServer.origin}/`).href;
+          inlineScriptContents.set(inlineScriptWebUrl, textContent);
         },
       },
-    )
+    );
     route.fulfill({
       response,
       body: injectionResult.content,
@@ -39,11 +39,11 @@ export const initJsSupervisorMiddleware = async (
         ...response.headers(),
         "content-length": Buffer.byteLength(injectionResult.content),
       },
-    })
-  }
+    });
+  };
 
   const interceptInlineScript = ({ url, route }) => {
-    const inlineScriptContent = inlineScriptContents.get(url)
+    const inlineScriptContent = inlineScriptContents.get(url);
     route.fulfill({
       status: 200,
       body: inlineScriptContent,
@@ -51,14 +51,14 @@ export const initJsSupervisorMiddleware = async (
         "content-type": "text/javascript",
         "content-length": Buffer.byteLength(inlineScriptContent),
       },
-    })
-  }
+    });
+  };
 
   const interceptFileSystemUrl = ({ url, route }) => {
-    const relativeUrl = url.slice(webServer.origin.length)
-    const fsPath = relativeUrl.slice("/@fs/".length)
-    const fsUrl = `file:///${fsPath}`
-    const fileContent = readFileSync(new URL(fsUrl), "utf8")
+    const relativeUrl = url.slice(webServer.origin.length);
+    const fsPath = relativeUrl.slice("/@fs/".length);
+    const fsUrl = `file:///${fsPath}`;
+    const fileContent = readFileSync(new URL(fsUrl), "utf8");
     route.fulfill({
       status: 200,
       body: fileContent,
@@ -66,33 +66,33 @@ export const initJsSupervisorMiddleware = async (
         "content-type": "text/javascript",
         "content-length": Buffer.byteLength(fileContent),
       },
-    })
-  }
+    });
+  };
 
   await page.route("**", async (route) => {
-    const request = route.request()
-    const url = request.url()
+    const request = route.request();
+    const url = request.url();
     if (url === fileServerUrl && urlToExtension(url) === ".html") {
       interceptHtmlToExecute({
         url,
         request,
         route,
-      })
-      return
+      });
+      return;
     }
     if (inlineScriptContents.has(url)) {
       interceptInlineScript({
         url,
         request,
         route,
-      })
-      return
+      });
+      return;
     }
-    const fsServerUrl = new URL("/@fs/", webServer.origin)
+    const fsServerUrl = new URL("/@fs/", webServer.origin);
     if (url.startsWith(fsServerUrl)) {
-      interceptFileSystemUrl({ url, request, route })
-      return
+      interceptFileSystemUrl({ url, request, route });
+      return;
     }
-    route.fallback()
-  })
-}
+    route.fallback();
+  });
+};