Strengthen CLI benchmark verification

src/apps/cli/testdeno/test-benchmark-contract.ts

@@ -1,5 +1,20 @@
 import { assert, assertEquals, assertStringIncludes } from "@std/assert";
 import { type BenchmarkCase, buildCases } from "./bench-network-cases.ts";
+import { startCouchdbProxy } from "./bench-couchdb.ts";
+import {
+    parseBenchmarkVerificationMode,
+    selectVerificationEntries,
+} from "./helpers/benchmarkVerification.ts";
+import type { DatasetEntry } from "./helpers/dataset.ts";
+
+function getFreePort(): number {
+    const listener = Deno.listen({ hostname: "127.0.0.1", port: 0 });
+    try {
+        return (listener.addr as Deno.NetAddr).port;
+    } finally {
+        listener.close();
+    }
+}
 
 function getCase(cases: BenchmarkCase[], name: string): BenchmarkCase {
     const found = cases.find((testCase) => testCase.name === name);
@@ -56,9 +71,76 @@ Deno.test("benchmark cases record scope and limitations for paper use", () => {
             testCase.measurementScope,
         );
         assertEquals(parsedLimitations(testCase), testCase.limitations);
+        assertEquals(
+            testCase.env.BENCH_VERIFY_MODE,
+            "all",
+            `${testCase.name} must verify the complete dataset`,
+        );
     }
 });
 
+Deno.test("CouchDB latency proxy applies half the requested RTT in each direction", async () => {
+    const backendPort = getFreePort();
+    const proxyPort = getFreePort();
+    const delays: number[] = [];
+    const backend = Deno.serve(
+        {
+            hostname: "127.0.0.1",
+            port: backendPort,
+            onListen() {},
+        },
+        () => new Response("ok"),
+    );
+    const proxy = startCouchdbProxy({
+        backendUri: `http://127.0.0.1:${backendPort}`,
+        proxyUri: `http://127.0.0.1:${proxyPort}`,
+        requestedRttMs: 20,
+        delay: (milliseconds) => {
+            delays.push(milliseconds);
+            return Promise.resolve();
+        },
+    });
+
+    try {
+        const response = await fetch(`http://127.0.0.1:${proxyPort}/probe`);
+        assertEquals(await response.text(), "ok");
+        assertEquals(proxy.directionalDelayMs, 10);
+        assertEquals(delays, [10, 10]);
+    } finally {
+        await proxy.stop();
+        await backend.shutdown();
+    }
+
+    const halfMillisecondProxy = startCouchdbProxy({
+        backendUri: "http://127.0.0.1:1",
+        proxyUri: `http://127.0.0.1:${getFreePort()}`,
+        requestedRttMs: 1,
+        delay: () => Promise.resolve(),
+    });
+    try {
+        assertEquals(halfMillisecondProxy.directionalDelayMs, 0.5);
+    } finally {
+        await halfMillisecondProxy.stop();
+    }
+});
+
+Deno.test("benchmark verification mode selects either all files or a labelled sample", () => {
+    const entries: DatasetEntry[] = [
+        { kind: "md", relativePath: "a.md", absolutePath: "/a", size: 1 },
+        { kind: "md", relativePath: "b.md", absolutePath: "/b", size: 1 },
+        { kind: "bin", relativePath: "c.bin", absolutePath: "/c", size: 1 },
+        { kind: "md", relativePath: "d.md", absolutePath: "/d", size: 1 },
+        { kind: "bin", relativePath: "e.bin", absolutePath: "/e", size: 1 },
+    ];
+
+    assertEquals(parseBenchmarkVerificationMode("ALL"), "all");
+    assertEquals(selectVerificationEntries(entries, "all").length, entries.length);
+    const sample = selectVerificationEntries(entries, "sample");
+    assert(sample.length > 0 && sample.length < entries.length);
+    assert(sample.some((entry) => entry.kind === "md"));
+    assert(sample.some((entry) => entry.kind === "bin"));
+});
+
 Deno.test("P2P signalling-shim cases do not claim to shape the note-data path", () => {
     const cases = buildCases();
     for (
@@ -77,6 +159,13 @@ Deno.test("P2P signalling-shim cases do not claim to shape the note-data path",
         );
         assertStringIncludes(testCase.dataPath, "WebRTC DataChannel");
         assertStringIncludes(testCase.dataPath, "Nostr signalling");
+        assertStringIncludes(testCase.measurementScope, "fresh CLI p2p-sync");
+        assert(
+            testCase.limitations.some((limitation) =>
+                limitation.includes("connection establishment")
+            ),
+            `${name} must state that connection establishment is timed`,
+        );
         assert(
             testCase.limitations.some((limitation) =>
                 limitation.includes("does not shape the selected WebRTC")