@specific.dev/spectest 0.60.0 → 0.60.2

package/dist/daemon.js

@@ -3115,6 +3115,26 @@ async function runCoverageAdapters(svc) {
         clearTimeout(timer);
     }
 }
+/** Container name → its working directory, read once per container
+ *  (`docker inspect`); forks with the env like the rest of module memory.
+ *  Empty when the image sets none (paths are then reported from `/`). */
+const COVERAGE_ROOTS = new Map();
+async function coverageRoot(service) {
+    const cached = COVERAGE_ROOTS.get(service);
+    if (cached !== undefined)
+        return cached;
+    let root = "";
+    try {
+        const r = await docker(["inspect", "-f", "{{.Config.WorkingDir}}", service], 10_000);
+        if (r.code === 0)
+            root = r.stdout.trim();
+    }
+    catch {
+        // Best-effort: the tree then falls back to a common-prefix guess.
+    }
+    COVERAGE_ROOTS.set(service, root);
+    return root;
+}
 async function captureServiceCoverage() {
     const l = loaded;
     if (!l)
@@ -3130,6 +3150,9 @@ async function captureServiceCoverage() {
         if (error)
             return { service: svc.name, reports: [], error };
         const read = await readCoverageDir(svc.name, coverageHostDir(WORKSPACE, svc.name));
+        const root = await coverageRoot(svc.name);
+        if (root)
+            read.root = root;
         // What ships is what ran during this capture, whatever the tool
         // counts: cumulative lcov is subtracted against the previous
         // capture (module memory, forks with the env); a delta adapter's

package/dist/harness/coverage.d.ts

@@ -17,6 +17,12 @@ export interface CoverageReport {
 export interface ServiceCoverageCapture {
     service: string;
     reports: CoverageReport[];
+    /** The container's working directory (`docker inspect`), the root
+     *  the reported container paths are relative to for a `COPY . <dir>`
+     *  image. The server strips it to draw a project-relative tree; it
+     *  never has to fetch code to do so. Absent for a container it could
+     *  not be read from. */
+    root?: string;
     /** Set when the capture failed: the command failed, the directory was
      *  empty, no file held an `SF:` record, or the reports were too large.
      *  A case with an error here fails — a hole in the coverage data must
@@ -92,13 +98,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.2",
   "description": "Spectest SDK for defining test environments in TypeScript.",
   "type": "module",
   "main": "./dist/index.js",

package/src/daemon.ts

@@ -3759,6 +3759,25 @@ async function runCoverageAdapters(
   }
 }
 
+/** Container name → its working directory, read once per container
+ *  (`docker inspect`); forks with the env like the rest of module memory.
+ *  Empty when the image sets none (paths are then reported from `/`). */
+const COVERAGE_ROOTS = new Map<string, string>();
+
+async function coverageRoot(service: string): Promise<string> {
+  const cached = COVERAGE_ROOTS.get(service);
+  if (cached !== undefined) return cached;
+  let root = "";
+  try {
+    const r = await docker(["inspect", "-f", "{{.Config.WorkingDir}}", service], 10_000);
+    if (r.code === 0) root = r.stdout.trim();
+  } catch {
+    // Best-effort: the tree then falls back to a common-prefix guess.
+  }
+  COVERAGE_ROOTS.set(service, root);
+  return root;
+}
+
 async function captureServiceCoverage(): Promise<ServiceCoverageCapture[]> {
   const l = loaded;
   if (!l) return [];
@@ -3771,6 +3790,8 @@ async function captureServiceCoverage(): Promise<ServiceCoverageCapture[]> {
       const { error, deltaReports } = await runCoverageAdapters(svc);
       if (error) return { service: svc.name, reports: [], error };
       const read = await readCoverageDir(svc.name, coverageHostDir(WORKSPACE, svc.name));
+      const root = await coverageRoot(svc.name);
+      if (root) read.root = root;
       // What ships is what ran during this capture, whatever the tool
       // counts: cumulative lcov is subtracted against the previous
       // capture (module memory, forks with the env); a delta adapter's

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

@@ -57,6 +57,12 @@ export interface CoverageReport {
 export interface ServiceCoverageCapture {
   service: string;
   reports: CoverageReport[];
+  /** The container's working directory (`docker inspect`), the root
+   *  the reported container paths are relative to for a `COPY . <dir>`
+   *  image. The server strips it to draw a project-relative tree; it
+   *  never has to fetch code to do so. Absent for a container it could
+   *  not be read from. */
+  root?: string;
   /** Set when the capture failed: the command failed, the directory was
    *  empty, no file held an `SF:` record, or the reports were too large.
    *  A case with an error here fails — a hole in the coverage data must
@@ -277,31 +283,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 +393,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 };
 }