@specific.dev/spectest 0.90.2 → 0.90.3

package/dist/browser-coverage.d.ts

@@ -22,10 +22,10 @@ export declare function foldBrowserCoverage(service: string, files: FileCounts):
 /** Harvest every live session, so a capture sees the counters of code
  *  that ran since the last browser op. */
 export declare function harvestAllBrowserCoverage(): Promise<void>;
-/** One lcov document per service that has any browser coverage — and
- *  the totals are cleared, so the next capture holds only what runs
- *  from now on. Module memory forks with the environment, so a forked
- *  child starts from its parent's last capture, empty. */
-export declare function takeBrowserCoverageReports(): Map<string, string>;
+/** Take one service's lcov report and clear only its totals. Other
+ *  services retain their coverage until their own capture. Each capture
+ *  is a delta; after every service is captured, a forked child inherits
+ *  empty totals from its parent. */
+export declare function takeBrowserCoverageReport(service: string): string;
 /** The current totals, without clearing them (tests). */
 export declare function browserCoverageReports(): Map<string, string>;

package/dist/browser-coverage.js

@@ -12,8 +12,8 @@
 //
 // Harvest runs before every browser step (a click that navigates
 // cross-site replaces the renderer, and the old counters with it) and at
-// every coverage capture. `browserCoverageReports` renders the totals as
-// one lcov per service for the `case-coverage` bundle.
+// every coverage capture. `takeBrowserCoverageReport` renders and clears
+// one service's totals for the `case-coverage` bundle.
 //
 // Configured by the daemon at /load with the host → service table; a
 // project with no `coverage: { browser: true }` service never attaches
@@ -196,18 +196,15 @@ function parseDataUrl(ref) {
 export async function harvestAllBrowserCoverage() {
     await Promise.all([...LIVE_COLLECTORS].map((c) => harvestBrowserCoverage(c.cdp)));
 }
-/** One lcov document per service that has any browser coverage — and
- *  the totals are cleared, so the next capture holds only what runs
- *  from now on. Module memory forks with the environment, so a forked
- *  child starts from its parent's last capture, empty. */
-export function takeBrowserCoverageReports() {
-    const out = new Map();
-    for (const [service, files] of TOTALS) {
-        if (files.size > 0)
-            out.set(service, lcovDocument(files));
-    }
-    TOTALS.clear();
-    return out;
+/** Take one service's lcov report and clear only its totals. Other
+ *  services retain their coverage until their own capture. Each capture
+ *  is a delta; after every service is captured, a forked child inherits
+ *  empty totals from its parent. */
+export function takeBrowserCoverageReport(service) {
+    const files = TOTALS.get(service);
+    const report = files ? lcovDocument(files) : "TN:\n";
+    TOTALS.delete(service);
+    return report;
 }
 /** The current totals, without clearing them (tests). */
 export function browserCoverageReports() {

package/dist/coverage.d.ts

@@ -294,7 +294,7 @@ export declare function collectNodeReports(dir: string): Promise<NodeReportStats
  * loads from this service's origins, maps it back to source through the
  * served source map, and writes one lcov per capture (`browser.lcov`)
  * holding what ran since the previous capture: every live session is
- * harvested first, and the totals are taken and cleared. Nothing ran ⇒
+ * harvested first, and only this service's totals are taken and cleared. Nothing ran ⇒
  * an lcov with no records, which is a report saying so.
  */
 export declare function browser(): CoverageAdapter;

package/dist/coverage.js

@@ -27,7 +27,7 @@
 //   import * as coverage from "@specific.dev/spectest/coverage";
 //   coverage: { adapters: [coverage.node(), coverage.browser()] }
 import { createHash } from "node:crypto";
-import { harvestAllBrowserCoverage, takeBrowserCoverageReports } from "./browser-coverage.js";
+import { harvestAllBrowserCoverage, takeBrowserCoverageReport } from "./browser-coverage.js";
 import { COVERAGE_CONTAINER_DIR } from "./harness/coverage.js";
 export { COVERAGE_CONTAINER_DIR };
 /** Where `node()` mounts its hook inside the container. */
@@ -810,7 +810,7 @@ export async function collectNodeReports(dir) {
  * loads from this service's origins, maps it back to source through the
  * served source map, and writes one lcov per capture (`browser.lcov`)
  * holding what ran since the previous capture: every live session is
- * harvested first, and the totals are taken and cleared. Nothing ran ⇒
+ * harvested first, and only this service's totals are taken and cleared. Nothing ran ⇒
  * an lcov with no records, which is a report saying so.
  */
 export function browser() {
@@ -822,7 +822,7 @@ export function browser() {
         },
         async capture(ctx) {
             await harvestAllBrowserCoverage();
-            const lcov = takeBrowserCoverageReports().get(ctx.service) ?? "TN:\n";
+            const lcov = takeBrowserCoverageReport(ctx.service);
             await ctx.writeReport("browser.lcov", lcov);
         },
     };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@specific.dev/spectest",
-  "version": "0.90.2",
+  "version": "0.90.3",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",

package/src/browser-coverage.ts

@@ -12,8 +12,8 @@
 //
 // Harvest runs before every browser step (a click that navigates
 // cross-site replaces the renderer, and the old counters with it) and at
-// every coverage capture. `browserCoverageReports` renders the totals as
-// one lcov per service for the `case-coverage` bundle.
+// every coverage capture. `takeBrowserCoverageReport` renders and clears
+// one service's totals for the `case-coverage` bundle.
 //
 // Configured by the daemon at /load with the host → service table; a
 // project with no `coverage: { browser: true }` service never attaches
@@ -220,17 +220,15 @@ export async function harvestAllBrowserCoverage(): Promise<void> {
   await Promise.all([...LIVE_COLLECTORS].map((c) => harvestBrowserCoverage(c.cdp)));
 }
 
-/** One lcov document per service that has any browser coverage — and
- *  the totals are cleared, so the next capture holds only what runs
- *  from now on. Module memory forks with the environment, so a forked
- *  child starts from its parent's last capture, empty. */
-export function takeBrowserCoverageReports(): Map<string, string> {
-  const out = new Map<string, string>();
-  for (const [service, files] of TOTALS) {
-    if (files.size > 0) out.set(service, lcovDocument(files));
-  }
-  TOTALS.clear();
-  return out;
+/** Take one service's lcov report and clear only its totals. Other
+ *  services retain their coverage until their own capture. Each capture
+ *  is a delta; after every service is captured, a forked child inherits
+ *  empty totals from its parent. */
+export function takeBrowserCoverageReport(service: string): string {
+  const files = TOTALS.get(service);
+  const report = files ? lcovDocument(files) : "TN:\n";
+  TOTALS.delete(service);
+  return report;
 }
 
 /** The current totals, without clearing them (tests). */

package/src/coverage.test.ts

@@ -135,6 +135,56 @@ describe("units", () => {
 });
 
 describe("browserCoverage", () => {
+  for (const order of ["dashboard first", "admin first", "concurrent"] as const) {
+    test(`services retain their own coverage and deltas: ${order}`, async () => {
+      const reports = new Map<string, string>();
+      const contexts = ["dashboard", "admin"].map((service): CoverageCaptureContext => ({
+        ...fakeCtx("unused"),
+        service,
+        async writeReport(name, content) {
+          expect(name).toBe("browser.lcov");
+          reports.set(service, content);
+        },
+      }));
+      if (order === "admin first") contexts.reverse();
+      const capture = async () => {
+        if (order === "concurrent") {
+          await Promise.all(contexts.map((ctx) => browser().capture!(ctx)));
+        } else {
+          for (const ctx of contexts) await browser().capture!(ctx);
+        }
+      };
+      foldBrowserCoverage("dashboard", new Map([["src/dashboard.ts", new Map([[1, 2]])]]));
+      foldBrowserCoverage("admin", new Map([["src/admin.ts", new Map([[3, 4]])]]));
+      await capture();
+      expect(reports.get("dashboard")).toBe("TN:\nSF:src/dashboard.ts\nDA:1,2\nLF:1\nLH:1\nend_of_record\n");
+      expect(reports.get("admin")).toBe("TN:\nSF:src/admin.ts\nDA:3,4\nLF:1\nLH:1\nend_of_record\n");
+
+      await capture();
+      expect(reports.get("dashboard")).toBe("TN:\n");
+      expect(reports.get("admin")).toBe("TN:\n");
+
+      foldBrowserCoverage("admin", new Map([["src/admin.ts", new Map([[3, 1]])]]));
+      await capture();
+      expect(reports.get("dashboard")).toBe("TN:\n");
+      expect(reports.get("admin")).toBe("TN:\nSF:src/admin.ts\nDA:3,1\nLF:1\nLH:1\nend_of_record\n");
+    });
+  }
+
+  test("capturing a service with no coverage preserves other services' totals", async () => {
+    const reports = new Map<string, string>();
+    foldBrowserCoverage("dashboard", new Map([["src/dashboard.ts", new Map([[1, 2]])]]));
+    for (const service of ["admin", "dashboard"]) {
+      await browser().capture!({
+        ...fakeCtx("unused"),
+        service,
+        async writeReport(_name, content) { reports.set(service, content); },
+      });
+    }
+    expect(reports.get("admin")).toBe("TN:\n");
+    expect(reports.get("dashboard")).toBe("TN:\nSF:src/dashboard.ts\nDA:1,2\nLF:1\nLH:1\nend_of_record\n");
+  });
+
   test("writes an empty lcov when nothing ran for the service", async () => {
     const dir = await fs.mkdtemp(path.join(os.tmpdir(), "spectest-cov-"));
     await browser().capture!(fakeCtx(dir));

package/src/coverage.ts

@@ -30,7 +30,7 @@
 import { createHash } from "node:crypto";
 
 import type { ServiceConfig } from "./index.js";
-import { harvestAllBrowserCoverage, takeBrowserCoverageReports } from "./browser-coverage.js";
+import { harvestAllBrowserCoverage, takeBrowserCoverageReport } from "./browser-coverage.js";
 
 import { COVERAGE_CONTAINER_DIR, type CoverageReportsMode } from "./harness/coverage.js";
 export { COVERAGE_CONTAINER_DIR, type CoverageReportsMode };
@@ -969,7 +969,7 @@ export async function collectNodeReports(dir: string): Promise<NodeReportStats>
  * loads from this service's origins, maps it back to source through the
  * served source map, and writes one lcov per capture (`browser.lcov`)
  * holding what ran since the previous capture: every live session is
- * harvested first, and the totals are taken and cleared. Nothing ran ⇒
+ * harvested first, and only this service's totals are taken and cleared. Nothing ran ⇒
  * an lcov with no records, which is a report saying so.
  */
 export function browser(): CoverageAdapter {
@@ -981,7 +981,7 @@ export function browser(): CoverageAdapter {
     },
     async capture(ctx) {
       await harvestAllBrowserCoverage();
-      const lcov = takeBrowserCoverageReports().get(ctx.service) ?? "TN:\n";
+      const lcov = takeBrowserCoverageReport(ctx.service);
       await ctx.writeReport("browser.lcov", lcov);
     },
   };