From 666ed4d88934ba7d5fefdaa8c0612890d79a0293 Mon Sep 17 00:00:00 2001
From: Peter Steinberger <steipete@gmail.com>
Date: Sat, 9 May 2026 22:36:42 +0100
Subject: [PATCH] test: tighten channel message contract assertions

---
 src/channels/message/contracts.test.ts | 222 +++++++++++++------------
 1 file changed, 114 insertions(+), 108 deletions(-)

diff --git a/src/channels/message/contracts.test.ts b/src/channels/message/contracts.test.ts
index d59beb70efa..f14d81a97c5 100644
--- a/src/channels/message/contracts.test.ts
+++ b/src/channels/message/contracts.test.ts
@@ -14,6 +14,16 @@ import {
   verifyLivePreviewFinalizerCapabilityProofs,
 } from "./contracts.js";
 
+function verifiedEntries<T extends { status: string }>(results: readonly T[]): T[] {
+  return results.filter((result) => result.status === "verified");
+}
+
+function expectOnlyVerifiedOrNotDeclared(results: readonly { status: string }[]): void {
+  expect(
+    results.every((result) => result.status === "verified" || result.status === "not_declared"),
+  ).toBe(true);
+}
+
 describe("durable final capability contracts", () => {
   it("lists declared durable-final capabilities in stable order", () => {
     expect(
@@ -32,24 +42,23 @@ describe("durable final capability contracts", () => {
     const text = vi.fn();
     const silent = vi.fn(async () => {});
 
-    await expect(
-      verifyDurableFinalCapabilityProofs({
-        adapterName: "demo",
-        capabilities: {
-          text: true,
-          silent: true,
-        },
-        proofs: {
-          text,
-          silent,
-        },
-      }),
-    ).resolves.toEqual(
-      expect.arrayContaining([
-        { capability: "text", status: "verified" },
-        { capability: "silent", status: "verified" },
-      ]),
-    );
+    const results = await verifyDurableFinalCapabilityProofs({
+      adapterName: "demo",
+      capabilities: {
+        text: true,
+        silent: true,
+      },
+      proofs: {
+        text,
+        silent,
+      },
+    });
+    expect(verifiedEntries(results)).toEqual([
+      { capability: "text", status: "verified" },
+      { capability: "silent", status: "verified" },
+    ]);
+    expect(results).toHaveLength(12);
+    expectOnlyVerifiedOrNotDeclared(results);
     expect(text).toHaveBeenCalledTimes(1);
     expect(silent).toHaveBeenCalledTimes(1);
   });
@@ -75,28 +84,27 @@ describe("durable final capability contracts", () => {
     const text = vi.fn();
     const media = vi.fn();
 
-    await expect(
-      verifyChannelMessageAdapterCapabilityProofs({
-        adapterName: "demo",
-        adapter: {
-          durableFinal: {
-            capabilities: {
-              text: true,
-              media: true,
-            },
+    const results = await verifyChannelMessageAdapterCapabilityProofs({
+      adapterName: "demo",
+      adapter: {
+        durableFinal: {
+          capabilities: {
+            text: true,
+            media: true,
           },
         },
-        proofs: {
-          text,
-          media,
-        },
-      }),
-    ).resolves.toEqual(
-      expect.arrayContaining([
-        { capability: "text", status: "verified" },
-        { capability: "media", status: "verified" },
-      ]),
-    );
+      },
+      proofs: {
+        text,
+        media,
+      },
+    });
+    expect(verifiedEntries(results)).toEqual([
+      { capability: "text", status: "verified" },
+      { capability: "media", status: "verified" },
+    ]);
+    expect(results).toHaveLength(12);
+    expectOnlyVerifiedOrNotDeclared(results);
     expect(text).toHaveBeenCalledTimes(1);
     expect(media).toHaveBeenCalledTimes(1);
   });
@@ -113,30 +121,29 @@ describe("durable final capability contracts", () => {
       }),
     ).toEqual(["finalEdit", "normalFallback"]);
 
-    await expect(
-      verifyChannelMessageLiveFinalizerProofs({
-        adapterName: "demo",
-        adapter: {
-          live: {
-            finalizer: {
-              capabilities: {
-                finalEdit: true,
-                normalFallback: true,
-              },
+    const results = await verifyChannelMessageLiveFinalizerProofs({
+      adapterName: "demo",
+      adapter: {
+        live: {
+          finalizer: {
+            capabilities: {
+              finalEdit: true,
+              normalFallback: true,
             },
           },
         },
-        proofs: {
-          finalEdit,
-          normalFallback,
-        },
-      }),
-    ).resolves.toEqual(
-      expect.arrayContaining([
-        { capability: "finalEdit", status: "verified" },
-        { capability: "normalFallback", status: "verified" },
-      ]),
-    );
+      },
+      proofs: {
+        finalEdit,
+        normalFallback,
+      },
+    });
+    expect(verifiedEntries(results)).toEqual([
+      { capability: "finalEdit", status: "verified" },
+      { capability: "normalFallback", status: "verified" },
+    ]);
+    expect(results).toHaveLength(5);
+    expectOnlyVerifiedOrNotDeclared(results);
     expect(finalEdit).toHaveBeenCalledTimes(1);
     expect(normalFallback).toHaveBeenCalledTimes(1);
   });
@@ -153,28 +160,27 @@ describe("durable final capability contracts", () => {
       }),
     ).toEqual(["draftPreview", "previewFinalization"]);
 
-    await expect(
-      verifyChannelMessageLiveCapabilityAdapterProofs({
-        adapterName: "demo",
-        adapter: {
-          live: {
-            capabilities: {
-              draftPreview: true,
-              previewFinalization: true,
-            },
+    const results = await verifyChannelMessageLiveCapabilityAdapterProofs({
+      adapterName: "demo",
+      adapter: {
+        live: {
+          capabilities: {
+            draftPreview: true,
+            previewFinalization: true,
           },
         },
-        proofs: {
-          draftPreview,
-          previewFinalization,
-        },
-      }),
-    ).resolves.toEqual(
-      expect.arrayContaining([
-        { capability: "draftPreview", status: "verified" },
-        { capability: "previewFinalization", status: "verified" },
-      ]),
-    );
+      },
+      proofs: {
+        draftPreview,
+        previewFinalization,
+      },
+    });
+    expect(verifiedEntries(results)).toEqual([
+      { capability: "draftPreview", status: "verified" },
+      { capability: "previewFinalization", status: "verified" },
+    ]);
+    expect(results).toHaveLength(5);
+    expectOnlyVerifiedOrNotDeclared(results);
     expect(draftPreview).toHaveBeenCalledTimes(1);
     expect(previewFinalization).toHaveBeenCalledTimes(1);
   });
@@ -222,26 +228,25 @@ describe("durable final capability contracts", () => {
       }),
     ).toEqual(["after_receive_record", "after_agent_dispatch"]);
 
-    await expect(
-      verifyChannelMessageReceiveAckPolicyAdapterProofs({
-        adapterName: "demo",
-        adapter: {
-          receive: {
-            defaultAckPolicy: "after_agent_dispatch",
-            supportedAckPolicies: ["after_receive_record", "after_agent_dispatch"],
-          },
+    const results = await verifyChannelMessageReceiveAckPolicyAdapterProofs({
+      adapterName: "demo",
+      adapter: {
+        receive: {
+          defaultAckPolicy: "after_agent_dispatch",
+          supportedAckPolicies: ["after_receive_record", "after_agent_dispatch"],
         },
-        proofs: {
-          after_receive_record: afterReceiveRecord,
-          after_agent_dispatch: afterAgentDispatch,
-        },
-      }),
-    ).resolves.toEqual(
-      expect.arrayContaining([
-        { policy: "after_receive_record", status: "verified" },
-        { policy: "after_agent_dispatch", status: "verified" },
-      ]),
-    );
+      },
+      proofs: {
+        after_receive_record: afterReceiveRecord,
+        after_agent_dispatch: afterAgentDispatch,
+      },
+    });
+    expect(verifiedEntries(results)).toEqual([
+      { policy: "after_receive_record", status: "verified" },
+      { policy: "after_agent_dispatch", status: "verified" },
+    ]);
+    expect(results).toHaveLength(4);
+    expectOnlyVerifiedOrNotDeclared(results);
     expect(afterReceiveRecord).toHaveBeenCalledTimes(1);
     expect(afterAgentDispatch).toHaveBeenCalledTimes(1);
   });
@@ -264,16 +269,17 @@ describe("durable final capability contracts", () => {
       }),
     ).toEqual(["manual"]);
 
-    await expect(
-      verifyChannelMessageReceiveAckPolicyProofs({
-        adapterName: "demo",
-        receive: {
-          defaultAckPolicy: "manual",
-          supportedAckPolicies: ["manual"],
-        },
-        proofs: { manual },
-      }),
-    ).resolves.toEqual(expect.arrayContaining([{ policy: "manual", status: "verified" }]));
+    const results = await verifyChannelMessageReceiveAckPolicyProofs({
+      adapterName: "demo",
+      receive: {
+        defaultAckPolicy: "manual",
+        supportedAckPolicies: ["manual"],
+      },
+      proofs: { manual },
+    });
+    expect(verifiedEntries(results)).toEqual([{ policy: "manual", status: "verified" }]);
+    expect(results).toHaveLength(4);
+    expectOnlyVerifiedOrNotDeclared(results);
     expect(manual).toHaveBeenCalledTimes(1);
   });