test: tighten signal outbound assertions

extensions/signal/src/core.test.ts

@@ -103,14 +103,13 @@ describe("probeSignal", () => {
     };
 
     const expected = await probeSignal("http://127.0.0.1:8080", 1000);
-    await expect(signalPlugin.status!.probeAccount!(params)).resolves.toEqual(
-      expect.objectContaining({
-        ok: expected.ok,
-        status: expected.status,
-        error: expected.error,
-        version: expected.version,
-      }),
-    );
+    const result = await signalPlugin.status!.probeAccount!(params);
+
+    expect(result.ok).toBe(expected.ok);
+    expect(result.status).toBe(expected.status);
+    expect(result.error).toBe(expected.error);
+    expect(result.version).toBe(expected.version);
+    expect(result.elapsedMs).toBeGreaterThanOrEqual(0);
   });
 
   it("extracts version from {version} result", async () => {
@@ -235,52 +234,61 @@ describe("signal outbound", () => {
     });
     const deps = { signal: send };
 
-    await expect(
-      verifyChannelMessageAdapterCapabilityProofs({
-        adapterName: "signal",
-        adapter: signalPlugin.message!,
-        proofs: {
-          text: async () => {
-            const result = await signalPlugin.message?.send?.text?.({
-              cfg: {} as OpenClawConfig,
-              to: "signal:+15555550123",
-              text: "hello",
-              deps,
-            } as Parameters<NonNullable<typeof signalPlugin.message.send.text>>[0] & {
-              deps: typeof deps;
-            });
-            expect(send).toHaveBeenCalledWith(
-              "signal:+15555550123",
-              "hello",
-              expect.objectContaining({ cfg: {} }),
-            );
-            expect(result?.receipt.platformMessageIds).toEqual(["signal-text-1"]);
-          },
-          media: async () => {
-            const result = await signalPlugin.message?.send?.media?.({
-              cfg: {} as OpenClawConfig,
-              to: "signal:+15555550123",
-              text: "image",
-              mediaUrl: "https://example.com/image.png",
-              deps,
-            } as Parameters<NonNullable<typeof signalPlugin.message.send.media>>[0] & {
-              deps: typeof deps;
-            });
-            expect(send).toHaveBeenCalledWith(
-              "signal:+15555550123",
-              "image",
-              expect.objectContaining({ mediaUrl: "https://example.com/image.png" }),
-            );
-            expect(result?.receipt.platformMessageIds).toEqual(["signal-media-1"]);
-          },
+    const proofResults = await verifyChannelMessageAdapterCapabilityProofs({
+      adapterName: "signal",
+      adapter: signalPlugin.message!,
+      proofs: {
+        text: async () => {
+          const result = await signalPlugin.message?.send?.text?.({
+            cfg: {} as OpenClawConfig,
+            to: "signal:+15555550123",
+            text: "hello",
+            deps,
+          } as Parameters<NonNullable<typeof signalPlugin.message.send.text>>[0] & {
+            deps: typeof deps;
+          });
+          expect(send).toHaveBeenCalledWith("signal:+15555550123", "hello", {
+            cfg: {},
+            maxBytes: undefined,
+            accountId: undefined,
+          });
+          expect(result?.receipt.platformMessageIds).toEqual(["signal-text-1"]);
         },
-      }),
-    ).resolves.toEqual(
-      expect.arrayContaining([
-        { capability: "text", status: "verified" },
-        { capability: "media", status: "verified" },
-      ]),
-    );
+        media: async () => {
+          const result = await signalPlugin.message?.send?.media?.({
+            cfg: {} as OpenClawConfig,
+            to: "signal:+15555550123",
+            text: "image",
+            mediaUrl: "https://example.com/image.png",
+            deps,
+          } as Parameters<NonNullable<typeof signalPlugin.message.send.media>>[0] & {
+            deps: typeof deps;
+          });
+          expect(send).toHaveBeenCalledWith("signal:+15555550123", "image", {
+            cfg: {},
+            mediaUrl: "https://example.com/image.png",
+            maxBytes: undefined,
+            accountId: undefined,
+          });
+          expect(result?.receipt.platformMessageIds).toEqual(["signal-media-1"]);
+        },
+      },
+    });
+
+    expect(proofResults).toEqual([
+      { capability: "text", status: "verified" },
+      { capability: "media", status: "verified" },
+      { capability: "payload", status: "not_declared" },
+      { capability: "silent", status: "not_declared" },
+      { capability: "replyTo", status: "not_declared" },
+      { capability: "thread", status: "not_declared" },
+      { capability: "nativeQuote", status: "not_declared" },
+      { capability: "messageSendingHooks", status: "not_declared" },
+      { capability: "batch", status: "not_declared" },
+      { capability: "reconcileUnknownSend", status: "not_declared" },
+      { capability: "afterSendSuccess", status: "not_declared" },
+      { capability: "afterCommit", status: "not_declared" },
+    ]);
   });
 });
 

extensions/signal/src/send-reactions.test.ts

@@ -53,8 +53,22 @@ describe("sendReactionSignal", () => {
       cfg: SIGNAL_TEST_CFG,
     });
 
+    expect(rpcMock).toHaveBeenCalledWith(
+      "sendReaction",
+      {
+        emoji: "🔥",
+        targetTimestamp: 123,
+        targetAuthor: "123e4567-e89b-12d3-a456-426614174000",
+        recipients: ["123e4567-e89b-12d3-a456-426614174000"],
+        account: "+15550001111",
+      },
+      {
+        baseUrl: "http://signal.local",
+        timeoutMs: undefined,
+        apiMode: undefined,
+      },
+    );
     const params = rpcMock.mock.calls[0]?.[1] as Record<string, unknown>;
-    expect(rpcMock).toHaveBeenCalledWith("sendReaction", expect.any(Object), expect.any(Object));
     expect(params.recipients).toEqual(["123e4567-e89b-12d3-a456-426614174000"]);
     expect(params.groupIds).toBeUndefined();
     expect(params.targetAuthor).toBe("123e4567-e89b-12d3-a456-426614174000");