@specific.dev/spectest 0.60.0 → 0.60.1

package/dist/harness/coverage.d.ts

@@ -92,13 +92,22 @@ export interface LcovRecordCounts {
  *  path are merged (a tool may split a file across records). */
 export declare function parseLcovCounts(text: string): Map<string, LcovRecordCounts>;
 /**
- * `now` minus `prev`, per line and per function. A count that went
- * *down* is a counter that restarted (the process was replaced): the
- * new value stands on its own. A file not in `prev` is new: everything
- * in it counts. Only records with at least one execution are kept — a
- * file with nothing new in it did not run.
+ * `now` minus `prev`, per line and per function. A file not in `prev`
+ * is new: everything in it counts. A **record in which any count went
+ * down** is a process that restarted (a restart resets every counter of
+ * that process at once): the whole record stands as-is, never
+ * subtracted — per line would report a line that ran exactly as often
+ * again as "not executed", and the restarted boot set (1 − 1) would
+ * vanish. Per record, not per report: a combined coverage.py file can
+ * hold several processes. A restart in which no counter dropped is not
+ * detectable from counts and is accepted as the residual (a service
+ * restarting mid-test is an anomaly already). Lines with a zero delta
+ * stay in the record: the server distinguishes "ran 0 times" from "not
+ * a counted line". Only records with at least one execution are kept —
+ * a file with nothing new in it did not run. `restarted` receives the
+ * paths of the records taken as-is.
  */
-export declare function subtractLcovCounts(now: Map<string, LcovRecordCounts>, prev: Map<string, LcovRecordCounts>): Map<string, LcovRecordCounts>;
+export declare function subtractLcovCounts(now: Map<string, LcovRecordCounts>, prev: Map<string, LcovRecordCounts>, restarted?: string[]): Map<string, LcovRecordCounts>;
 /** Counts rendered back to lcov, records in path order. */
 export declare function renderLcovCounts(counts: Map<string, LcovRecordCounts>): string;
 /** Forget every previous capture (tests). */

package/dist/harness/coverage.js

@@ -215,29 +215,41 @@ export function parseLcovCounts(text) {
     return out;
 }
 /**
- * `now` minus `prev`, per line and per function. A count that went
- * *down* is a counter that restarted (the process was replaced): the
- * new value stands on its own. A file not in `prev` is new: everything
- * in it counts. Only records with at least one execution are kept — a
- * file with nothing new in it did not run.
+ * `now` minus `prev`, per line and per function. A file not in `prev`
+ * is new: everything in it counts. A **record in which any count went
+ * down** is a process that restarted (a restart resets every counter of
+ * that process at once): the whole record stands as-is, never
+ * subtracted — per line would report a line that ran exactly as often
+ * again as "not executed", and the restarted boot set (1 − 1) would
+ * vanish. Per record, not per report: a combined coverage.py file can
+ * hold several processes. A restart in which no counter dropped is not
+ * detectable from counts and is accepted as the residual (a service
+ * restarting mid-test is an anomaly already). Lines with a zero delta
+ * stay in the record: the server distinguishes "ran 0 times" from "not
+ * a counted line". Only records with at least one execution are kept —
+ * a file with nothing new in it did not run. `restarted` receives the
+ * paths of the records taken as-is.
  */
-export function subtractLcovCounts(now, prev) {
+export function subtractLcovCounts(now, prev, restarted) {
     const out = new Map();
     for (const [file, rec] of now) {
         const before = prev.get(file);
+        const dropped = !!before &&
+            ([...rec.lines].some(([l, h]) => h < (before.lines.get(l) ?? 0)) ||
+                [...rec.functions].some(([n, h]) => h < (before.functions.get(n) ?? 0)));
+        if (dropped)
+            restarted?.push(file);
         const lines = new Map();
         const functions = new Map();
         let executed = false;
         for (const [l, h] of rec.lines) {
-            const b = before?.lines.get(l) ?? 0;
-            const d = h < b ? h : h - b;
+            const d = dropped ? h : h - (before?.lines.get(l) ?? 0);
             lines.set(l, d);
             if (d > 0)
                 executed = true;
         }
         for (const [name, h] of rec.functions) {
-            const b = before?.functions.get(name) ?? 0;
-            const d = h < b ? h : h - b;
+            const d = dropped ? h : h - (before?.functions.get(name) ?? 0);
             functions.set(name, d);
             if (d > 0)
                 executed = true;
@@ -309,7 +321,11 @@ export function applyCoverageDelta(capture, mode, deltaReports) {
         const now = parseLcovCounts(r.content);
         const prev = prevByName.get(r.name) ?? new Map();
         prevByName.set(r.name, now);
-        reports.push({ name: r.name, content: renderLcovCounts(subtractLcovCounts(now, prev)) });
+        const restarted = [];
+        reports.push({ name: r.name, content: renderLcovCounts(subtractLcovCounts(now, prev, restarted)) });
+        if (restarted.length > 0) {
+            console.warn(`[coverage] service "${capture.service}" report ${r.name}: counters dropped in ${restarted.length} file(s) (${restarted.slice(0, 3).join(", ")}) — a process restarted; those records count whole`);
+        }
     }
     return { ...capture, reports };
 }

package/package.json

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

package/src/harness/coverage.test.ts

@@ -159,8 +159,21 @@ describe("coverage delta", () => {
     expect(d.get("/app/a.py")!.lines.get(1)).toBe(0);
     expect(d.get("/app/a.py")!.functions.get("main")).toBe(0);
     expect(d.get("/app/c.py")!.lines.get(1)).toBe(2);
-    const restarted = subtractLcovCounts(parseLcovCounts("SF:/app/b.py\nDA:1,2\nend_of_record\n"), parseLcovCounts(boot));
+    const names: string[] = [];
+    const restarted = subtractLcovCounts(parseLcovCounts("SF:/app/b.py\nDA:1,2\nend_of_record\n"), parseLcovCounts(boot), names);
     expect(restarted.get("/app/b.py")!.lines.get(1)).toBe(2);
+    expect(names).toEqual(["/app/b.py"]);
+    // A restart is per record: one dropped counter means every count in
+    // that record stands, including a line that ran exactly as often
+    // again (the boot line: 1 before, 1 now — not 0). Other records in
+    // the same report still subtract.
+    const mixed = subtractLcovCounts(
+      parseLcovCounts("SF:/app/a.py\nFNDA:1,main\nDA:1,1\nDA:2,1\nDA:3,0\nend_of_record\nSF:/app/b.py\nDA:1,3\nend_of_record\n"),
+      parseLcovCounts("SF:/app/a.py\nFNDA:1,main\nDA:1,1\nDA:2,1\nDA:3,7\nend_of_record\nSF:/app/b.py\nDA:1,1\nend_of_record\n"),
+    );
+    expect(mixed.get("/app/a.py")!.lines.get(1)).toBe(1);
+    expect(mixed.get("/app/a.py")!.functions.get("main")).toBe(1);
+    expect(mixed.get("/app/b.py")!.lines.get(1)).toBe(2);
     // A record with no counts at all: presence is its signal, new only once.
     const bare = "SF:/app/bare.py\nend_of_record\n";
     expect(subtractLcovCounts(parseLcovCounts(bare), new Map()).has("/app/bare.py")).toBe(true);

package/src/harness/coverage.ts

@@ -277,31 +277,44 @@ export function parseLcovCounts(text: string): Map<string, LcovRecordCounts> {
 }
 
 /**
- * `now` minus `prev`, per line and per function. A count that went
- * *down* is a counter that restarted (the process was replaced): the
- * new value stands on its own. A file not in `prev` is new: everything
- * in it counts. Only records with at least one execution are kept — a
- * file with nothing new in it did not run.
+ * `now` minus `prev`, per line and per function. A file not in `prev`
+ * is new: everything in it counts. A **record in which any count went
+ * down** is a process that restarted (a restart resets every counter of
+ * that process at once): the whole record stands as-is, never
+ * subtracted — per line would report a line that ran exactly as often
+ * again as "not executed", and the restarted boot set (1 − 1) would
+ * vanish. Per record, not per report: a combined coverage.py file can
+ * hold several processes. A restart in which no counter dropped is not
+ * detectable from counts and is accepted as the residual (a service
+ * restarting mid-test is an anomaly already). Lines with a zero delta
+ * stay in the record: the server distinguishes "ran 0 times" from "not
+ * a counted line". Only records with at least one execution are kept —
+ * a file with nothing new in it did not run. `restarted` receives the
+ * paths of the records taken as-is.
  */
 export function subtractLcovCounts(
   now: Map<string, LcovRecordCounts>,
   prev: Map<string, LcovRecordCounts>,
+  restarted?: string[],
 ): Map<string, LcovRecordCounts> {
   const out = new Map<string, LcovRecordCounts>();
   for (const [file, rec] of now) {
     const before = prev.get(file);
+    const dropped =
+      !!before &&
+      ([...rec.lines].some(([l, h]) => h < (before.lines.get(l) ?? 0)) ||
+        [...rec.functions].some(([n, h]) => h < (before.functions.get(n) ?? 0)));
+    if (dropped) restarted?.push(file);
     const lines = new Map<number, number>();
     const functions = new Map<string, number>();
     let executed = false;
     for (const [l, h] of rec.lines) {
-      const b = before?.lines.get(l) ?? 0;
-      const d = h < b ? h : h - b;
+      const d = dropped ? h : h - (before?.lines.get(l) ?? 0);
       lines.set(l, d);
       if (d > 0) executed = true;
     }
     for (const [name, h] of rec.functions) {
-      const b = before?.functions.get(name) ?? 0;
-      const d = h < b ? h : h - b;
+      const d = dropped ? h : h - (before?.functions.get(name) ?? 0);
       functions.set(name, d);
       if (d > 0) executed = true;
     }
@@ -374,7 +387,13 @@ export function applyCoverageDelta(
     const now = parseLcovCounts(r.content);
     const prev = prevByName.get(r.name) ?? new Map<string, LcovRecordCounts>();
     prevByName.set(r.name, now);
-    reports.push({ name: r.name, content: renderLcovCounts(subtractLcovCounts(now, prev)) });
+    const restarted: string[] = [];
+    reports.push({ name: r.name, content: renderLcovCounts(subtractLcovCounts(now, prev, restarted)) });
+    if (restarted.length > 0) {
+      console.warn(
+        `[coverage] service "${capture.service}" report ${r.name}: counters dropped in ${restarted.length} file(s) (${restarted.slice(0, 3).join(", ")}) — a process restarted; those records count whole`,
+      );
+    }
   }
   return { ...capture, reports };
 }