@jsenv/test 1.1.2 → 1.1.4

package/src/coverage/v8_and_istanbul.js

@@ -1,37 +1,38 @@
-import { createDetailedMessage } from "@jsenv/log"
+import { createDetailedMessage } from "@jsenv/log";
 
 export const composeV8AndIstanbul = (
   v8FileByFileCoverage,
   istanbulFileByFileCoverage,
   { coverageV8ConflictWarning },
 ) => {
-  const fileByFileCoverage = {}
-  const v8Files = Object.keys(v8FileByFileCoverage)
-  const istanbulFiles = Object.keys(istanbulFileByFileCoverage)
+  const fileByFileCoverage = {};
+  const v8Files = Object.keys(v8FileByFileCoverage);
+  const istanbulFiles = Object.keys(istanbulFileByFileCoverage);
 
   v8Files.forEach((key) => {
-    fileByFileCoverage[key] = v8FileByFileCoverage[key]
-  })
+    fileByFileCoverage[key] = v8FileByFileCoverage[key];
+  });
   istanbulFiles.forEach((key) => {
-    const v8Coverage = v8FileByFileCoverage[key]
+    const v8Coverage = v8FileByFileCoverage[key];
     if (v8Coverage) {
       if (coverageV8ConflictWarning) {
         console.warn(
           createDetailedMessage(
             `Coverage conflict on "${key}", found two coverage that cannot be merged together: v8 and istanbul. The istanbul coverage will be ignored.`,
             {
-              details: `This happens when a file is executed on a runtime using v8 coverage (node or chromium) and on runtime using istanbul coverage (firefox or webkit)`,
-              suggestion:
-                "You can disable this warning with coverageV8ConflictWarning: false",
+              "details": `This happens when a file is executed on a runtime using v8 coverage (node or chromium) and on runtime using istanbul coverage (firefox or webkit)`,
+              "suggestion":
+                "disable this warning with coverageV8ConflictWarning: false",
+              "suggestion 2": `force coverage using istanbul with coverageMethodForBrowsers: "istanbul"`,
             },
           ),
-        )
+        );
       }
-      fileByFileCoverage[key] = v8Coverage
+      fileByFileCoverage[key] = v8Coverage;
     } else {
-      fileByFileCoverage[key] = istanbulFileByFileCoverage[key]
+      fileByFileCoverage[key] = istanbulFileByFileCoverage[key];
     }
-  })
+  });
 
-  return fileByFileCoverage
-}
+  return fileByFileCoverage;
+};

package/src/coverage/v8_coverage.js

@@ -1,4 +1,4 @@
-import { URL_META } from "@jsenv/url-meta"
+import { URL_META } from "@jsenv/url-meta";
 
 export const filterV8Coverage = async (
   v8Coverage,
@@ -7,20 +7,20 @@ export const filterV8Coverage = async (
   const associations = URL_META.resolveAssociations(
     { cover: coverageConfig },
     rootDirectoryUrl,
-  )
+  );
   const urlShouldBeCovered = (url) => {
     const { cover } = URL_META.applyAssociations({
       url: new URL(url, rootDirectoryUrl).href,
       associations,
-    })
-    return cover
-  }
+    });
+    return cover;
+  };
 
   const v8CoverageFiltered = {
     ...v8Coverage,
     result: v8Coverage.result.filter((fileReport) =>
       urlShouldBeCovered(fileReport.url),
     ),
-  }
-  return v8CoverageFiltered
-}
+  };
+  return v8CoverageFiltered;
+};

package/src/coverage/v8_coverage_composition.js

@@ -1,24 +1,24 @@
-import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js"
+import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js";
 
 export const composeTwoV8Coverages = (firstV8Coverage, secondV8Coverage) => {
   if (secondV8Coverage.result.length === 0) {
-    return firstV8Coverage
+    return firstV8Coverage;
   }
 
   // eslint-disable-next-line import/no-unresolved
-  const { mergeProcessCovs } = requireFromJsenv("@c88/v8-coverage")
+  const { mergeProcessCovs } = requireFromJsenv("@c88/v8-coverage");
   // "mergeProcessCovs" do not preserves source-map-cache during the merge
   // so we store sourcemap cache now
-  const sourceMapCache = {}
+  const sourceMapCache = {};
   const visit = (coverageReport) => {
     if (coverageReport["source-map-cache"]) {
-      Object.assign(sourceMapCache, coverageReport["source-map-cache"])
+      Object.assign(sourceMapCache, coverageReport["source-map-cache"]);
     }
-  }
-  visit(firstV8Coverage)
-  visit(secondV8Coverage)
-  const v8Coverage = mergeProcessCovs([firstV8Coverage, secondV8Coverage])
-  v8Coverage["source-map-cache"] = sourceMapCache
+  };
+  visit(firstV8Coverage);
+  visit(secondV8Coverage);
+  const v8Coverage = mergeProcessCovs([firstV8Coverage, secondV8Coverage]);
+  v8Coverage["source-map-cache"] = sourceMapCache;
 
-  return v8Coverage
-}
+  return v8Coverage;
+};

package/src/coverage/v8_coverage_node_directory.js

@@ -1,7 +1,7 @@
-import { readFileSync, readdirSync } from "node:fs"
-import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-import { createDetailedMessage } from "@jsenv/log"
-import { Abort } from "@jsenv/abort"
+import { readFileSync, readdirSync } from "node:fs";
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem";
+import { createDetailedMessage } from "@jsenv/log";
+import { Abort } from "@jsenv/abort";
 
 export const readNodeV8CoverageDirectory = async ({
   logger,
@@ -9,77 +9,77 @@ export const readNodeV8CoverageDirectory = async ({
   onV8Coverage,
   maxMsWaitingForNodeToWriteCoverageFile = 2000,
 }) => {
-  const NODE_V8_COVERAGE = process.env.NODE_V8_COVERAGE
-  const operation = Abort.startOperation()
-  operation.addAbortSignal(signal)
+  const NODE_V8_COVERAGE = process.env.NODE_V8_COVERAGE;
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
 
-  let timeSpentTrying = 0
+  let timeSpentTrying = 0;
   const tryReadDirectory = async () => {
-    const dirContent = readdirSync(NODE_V8_COVERAGE)
+    const dirContent = readdirSync(NODE_V8_COVERAGE);
     if (dirContent.length > 0) {
-      return dirContent
+      return dirContent;
     }
     if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
-      await new Promise((resolve) => setTimeout(resolve, 200))
-      timeSpentTrying += 200
-      logger.debug("retry to read coverage directory")
-      return tryReadDirectory()
+      await new Promise((resolve) => setTimeout(resolve, 200));
+      timeSpentTrying += 200;
+      logger.debug("retry to read coverage directory");
+      return tryReadDirectory();
     }
-    logger.warn(`v8 coverage directory is empty at ${NODE_V8_COVERAGE}`)
-    return dirContent
-  }
+    logger.warn(`v8 coverage directory is empty at ${NODE_V8_COVERAGE}`);
+    return dirContent;
+  };
 
   try {
-    operation.throwIfAborted()
-    const dirContent = await tryReadDirectory()
+    operation.throwIfAborted();
+    const dirContent = await tryReadDirectory();
 
     const coverageDirectoryUrl = assertAndNormalizeDirectoryUrl(
       NODE_V8_COVERAGE,
       "NODE_V8_COVERAGE",
-    )
+    );
 
     await dirContent.reduce(async (previous, dirEntry) => {
-      operation.throwIfAborted()
-      await previous
+      operation.throwIfAborted();
+      await previous;
 
-      const dirEntryUrl = new URL(dirEntry, coverageDirectoryUrl)
+      const dirEntryUrl = new URL(dirEntry, coverageDirectoryUrl);
       const tryReadJsonFile = async () => {
-        const fileContent = String(readFileSync(dirEntryUrl))
+        const fileContent = String(readFileSync(dirEntryUrl));
         if (fileContent === "") {
           if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
-            await new Promise((resolve) => setTimeout(resolve, 200))
-            timeSpentTrying += 200
-            return tryReadJsonFile()
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            timeSpentTrying += 200;
+            return tryReadJsonFile();
           }
-          console.warn(`Coverage JSON file is empty at ${dirEntryUrl}`)
-          return null
+          console.warn(`Coverage JSON file is empty at ${dirEntryUrl}`);
+          return null;
         }
 
         try {
-          const fileAsJson = JSON.parse(fileContent)
-          return fileAsJson
+          const fileAsJson = JSON.parse(fileContent);
+          return fileAsJson;
         } catch (e) {
           if (timeSpentTrying < maxMsWaitingForNodeToWriteCoverageFile) {
-            await new Promise((resolve) => setTimeout(resolve, 200))
-            timeSpentTrying += 200
-            return tryReadJsonFile()
+            await new Promise((resolve) => setTimeout(resolve, 200));
+            timeSpentTrying += 200;
+            return tryReadJsonFile();
           }
           console.warn(
             createDetailedMessage(`Error while reading coverage file`, {
               "error stack": e.stack,
               "file": dirEntryUrl,
             }),
-          )
-          return null
+          );
+          return null;
         }
-      }
+      };
 
-      const fileContent = await tryReadJsonFile()
+      const fileContent = await tryReadJsonFile();
       if (fileContent) {
-        await onV8Coverage(fileContent)
+        await onV8Coverage(fileContent);
       }
-    }, Promise.resolve())
+    }, Promise.resolve());
   } finally {
-    await operation.end()
+    await operation.end();
   }
-}
+};

package/src/coverage/v8_coverage_to_istanbul.js

@@ -1,33 +1,33 @@
-import { urlToFileSystemPath } from "@jsenv/urls"
-import { Abort } from "@jsenv/abort"
-import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js"
+import { urlToFileSystemPath } from "@jsenv/urls";
+import { Abort } from "@jsenv/abort";
+import { requireFromJsenv } from "@jsenv/core/src/helpers/require_from_jsenv.js";
 
-import { composeTwoFileByFileIstanbulCoverages } from "./istanbul_coverage_composition.js"
+import { composeTwoFileByFileIstanbulCoverages } from "./istanbul_coverage_composition.js";
 
 export const v8CoverageToIstanbul = async (v8Coverage, { signal }) => {
-  const operation = Abort.startOperation()
-  operation.addAbortSignal(signal)
+  const operation = Abort.startOperation();
+  operation.addAbortSignal(signal);
 
   try {
-    const v8ToIstanbul = requireFromJsenv("v8-to-istanbul")
-    const sourcemapCache = v8Coverage["source-map-cache"]
-    let istanbulCoverageComposed = null
+    const v8ToIstanbul = requireFromJsenv("v8-to-istanbul");
+    const sourcemapCache = v8Coverage["source-map-cache"];
+    let istanbulCoverageComposed = null;
 
     await v8Coverage.result.reduce(async (previous, fileV8Coverage) => {
-      operation.throwIfAborted()
-      await previous
+      operation.throwIfAborted();
+      await previous;
 
-      const { source } = fileV8Coverage
-      let sources
+      const { source } = fileV8Coverage;
+      let sources;
       // when v8 coverage comes from playwright (chromium) v8Coverage.source is set
       if (typeof source === "string") {
-        sources = { source }
+        sources = { source };
       }
       // when v8 coverage comes from Node.js, the source can be read from sourcemapCache
       else if (sourcemapCache) {
-        sources = sourcesFromSourceMapCache(fileV8Coverage.url, sourcemapCache)
+        sources = sourcesFromSourceMapCache(fileV8Coverage.url, sourcemapCache);
       }
-      const path = urlToFileSystemPath(fileV8Coverage.url)
+      const path = urlToFileSystemPath(fileV8Coverage.url);
 
       const converter = v8ToIstanbul(
         path,
@@ -35,65 +35,65 @@ export const v8CoverageToIstanbul = async (v8Coverage, { signal }) => {
         // https://github.com/istanbuljs/v8-to-istanbul/blob/2b54bc97c5edf8a37b39a171ec29134ba9bfd532/lib/v8-to-istanbul.js#L27
         undefined,
         sources,
-      )
-      await converter.load()
+      );
+      await converter.load();
 
-      converter.applyCoverage(fileV8Coverage.functions)
-      const istanbulCoverage = converter.toIstanbul()
+      converter.applyCoverage(fileV8Coverage.functions);
+      const istanbulCoverage = converter.toIstanbul();
 
       istanbulCoverageComposed = istanbulCoverageComposed
         ? composeTwoFileByFileIstanbulCoverages(
             istanbulCoverageComposed,
             istanbulCoverage,
           )
-        : istanbulCoverage
-    }, Promise.resolve())
+        : istanbulCoverage;
+    }, Promise.resolve());
 
     if (!istanbulCoverageComposed) {
-      return {}
+      return {};
     }
-    istanbulCoverageComposed = markAsConvertedFromV8(istanbulCoverageComposed)
-    return istanbulCoverageComposed
+    istanbulCoverageComposed = markAsConvertedFromV8(istanbulCoverageComposed);
+    return istanbulCoverageComposed;
   } finally {
-    await operation.end()
+    await operation.end();
   }
-}
+};
 
 const markAsConvertedFromV8 = (fileByFileCoverage) => {
-  const fileByFileMarked = {}
+  const fileByFileMarked = {};
   Object.keys(fileByFileCoverage).forEach((key) => {
-    const fileCoverage = fileByFileCoverage[key]
+    const fileCoverage = fileByFileCoverage[key];
     fileByFileMarked[key] = {
       ...fileCoverage,
       fromV8: true,
-    }
-  })
-  return fileByFileMarked
-}
+    };
+  });
+  return fileByFileMarked;
+};
 
 const sourcesFromSourceMapCache = (url, sourceMapCache) => {
-  const sourceMapAndLineLengths = sourceMapCache[url]
+  const sourceMapAndLineLengths = sourceMapCache[url];
   if (!sourceMapAndLineLengths) {
-    return {}
+    return {};
   }
 
-  const { data, lineLengths } = sourceMapAndLineLengths
+  const { data, lineLengths } = sourceMapAndLineLengths;
   // See: https://github.com/nodejs/node/pull/34305
   if (!data) {
-    return undefined
+    return undefined;
   }
 
   const sources = {
     sourcemap: data,
     ...(lineLengths ? { source: sourcesFromLineLengths(lineLengths) } : {}),
-  }
-  return sources
-}
+  };
+  return sources;
+};
 
 const sourcesFromLineLengths = (lineLengths) => {
-  let source = ""
+  let source = "";
   lineLengths.forEach((length) => {
-    source += `${"".padEnd(length, ".")}\n`
-  })
-  return source
-}
+    source += `${"".padEnd(length, ".")}\n`;
+  });
+  return source;
+};

package/src/execution/execute.js

@@ -10,12 +10,12 @@
  * - Most of the logic lives in "./run.js" used by executeTestPlan to run tests
  */
 
-import { Abort, raceProcessTeardownEvents } from "@jsenv/abort"
-import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem"
-import { createLogger } from "@jsenv/log"
+import { Abort, raceProcessTeardownEvents } from "@jsenv/abort";
+import { assertAndNormalizeDirectoryUrl } from "@jsenv/filesystem";
+import { createLogger } from "@jsenv/log";
 
-import { assertAndNormalizeWebServer } from "./web_server_param.js"
-import { run } from "./run.js"
+import { assertAndNormalizeWebServer } from "./web_server_param.js";
+import { run } from "./run.js";
 
 export const execute = async ({
   signal = new AbortController().signal,
@@ -39,13 +39,13 @@ export const execute = async ({
 
   ignoreError = false,
 }) => {
-  const logger = createLogger({ logLevel })
+  const logger = createLogger({ logLevel });
   rootDirectoryUrl = assertAndNormalizeDirectoryUrl(
     rootDirectoryUrl,
     "rootDirectoryUrl",
-  )
-  const executeOperation = Abort.startOperation()
-  executeOperation.addAbortSignal(signal)
+  );
+  const executeOperation = Abort.startOperation();
+  executeOperation.addAbortSignal(signal);
   if (handleSIGINT) {
     executeOperation.addAbortSource((abort) => {
       return raceProcessTeardownEvents(
@@ -53,22 +53,22 @@ export const execute = async ({
           SIGINT: true,
         },
         abort,
-      )
-    })
+      );
+    });
   }
 
   if (runtime.type === "browser") {
-    await assertAndNormalizeWebServer(webServer)
+    await assertAndNormalizeWebServer(webServer);
   }
 
-  let resultTransformer = (result) => result
+  let resultTransformer = (result) => result;
   runtimeParams = {
     rootDirectoryUrl,
     webServer,
     fileRelativeUrl,
     importMap,
     ...runtimeParams,
-  }
+  };
 
   let result = await run({
     signal: executeOperation.signal,
@@ -82,13 +82,13 @@ export const execute = async ({
     collectPerformance,
     runtime,
     runtimeParams,
-  })
-  result = resultTransformer(result)
+  });
+  result = resultTransformer(result);
 
   try {
     if (result.status === "failed") {
       if (ignoreError) {
-        return result
+        return result;
       }
       /*
   Warning: when node launched with --unhandled-rejections=strict, despites
@@ -102,10 +102,10 @@ export const execute = async ({
   ```
   But it feels like a hack.
   */
-      throw result.errors[result.errors.length - 1]
+      throw result.errors[result.errors.length - 1];
     }
-    return result
+    return result;
   } finally {
-    await executeOperation.end()
+    await executeOperation.end();
   }
-}
+};