test: share cron telegram delivery failure assertions

src/cron/isolated-agent.skips-delivery-without-whatsapp-recipient-besteffortdeliver-true.test.ts

@@ -84,18 +84,13 @@ async function expectStructuredTelegramFailure(params: {
         },
       });
 
-      expect(res.status).toBe(params.expectedStatus);
-      if (params.expectedStatus === "ok") {
-        expect(res.delivered).toBe(false);
-      }
-      if (params.expectDeliveryAttempted !== undefined) {
-        expect(res.deliveryAttempted).toBe(params.expectDeliveryAttempted);
-      }
-      if (params.expectedErrorFragment) {
-        expect(res.error).toContain(params.expectedErrorFragment);
-      }
-      expect(runSubagentAnnounceFlow).not.toHaveBeenCalled();
-      expect(deps.sendMessageTelegram).toHaveBeenCalledTimes(1);
+      expectFailedTelegramDeliveryResult({
+        res,
+        deps,
+        expectedStatus: params.expectedStatus,
+        expectedErrorFragment: params.expectedErrorFragment,
+        expectDeliveryAttempted: params.expectDeliveryAttempted,
+      });
     },
     {
       deps: {
@@ -105,6 +100,29 @@ async function expectStructuredTelegramFailure(params: {
   );
 }
 
+function expectFailedTelegramDeliveryResult(params: {
+  res: Awaited<ReturnType<typeof runCronIsolatedAgentTurn>>;
+  deps: CliDeps;
+  expectedStatus: "ok" | "error";
+  expectedErrorFragment?: string;
+  expectDeliveryAttempted?: boolean;
+}) {
+  expect(params.res.status).toBe(params.expectedStatus);
+  if (params.expectedStatus === "ok") {
+    expect(params.res.delivered).toBe(false);
+  } else {
+    expect(params.res.delivered).toBeUndefined();
+  }
+  if (params.expectDeliveryAttempted !== undefined) {
+    expect(params.res.deliveryAttempted).toBe(params.expectDeliveryAttempted);
+  }
+  if (params.expectedErrorFragment) {
+    expect(params.res.error).toContain(params.expectedErrorFragment);
+  }
+  expect(runSubagentAnnounceFlow).not.toHaveBeenCalled();
+  expect(params.deps.sendMessageTelegram).toHaveBeenCalledTimes(1);
+}
+
 async function runTelegramDeliveryResult(bestEffort: boolean) {
   let outcome:
     | {
@@ -112,19 +130,7 @@ async function runTelegramDeliveryResult(bestEffort: boolean) {
         deps: CliDeps;
       }
     | undefined;
-  await withTelegramAnnounceFixture(async ({ home, storePath, deps }) => {
-    mockAgentPayloads([{ text: "hello from cron" }]);
-    const res = await runTelegramAnnounceTurn({
-      home,
-      storePath,
-      deps,
-      delivery: {
-        mode: "announce",
-        channel: "telegram",
-        to: "123",
-        bestEffort,
-      },
-    });
+  await withTelegramTextDelivery({ bestEffort }, async ({ res, deps }) => {
     outcome = { res, deps };
   });
   if (!outcome) {
@@ -143,6 +149,57 @@ function expectSuccessfulTelegramTextDelivery(params: {
   expect(runSubagentAnnounceFlow).not.toHaveBeenCalled();
 }
 
+async function withTelegramTextDelivery(
+  params: { bestEffort: boolean },
+  run: (params: {
+    home: string;
+    storePath: string;
+    deps: CliDeps;
+    res: Awaited<ReturnType<typeof runCronIsolatedAgentTurn>>;
+  }) => Promise<void>,
+  fixtureParams?: Parameters<typeof withTelegramAnnounceFixture>[1],
+) {
+  await withTelegramAnnounceFixture(async ({ home, storePath, deps }) => {
+    mockAgentPayloads([{ text: "hello from cron" }]);
+    const res = await runTelegramAnnounceTurn({
+      home,
+      storePath,
+      deps,
+      delivery: {
+        mode: "announce",
+        channel: "telegram",
+        to: "123",
+        bestEffort: params.bestEffort,
+      },
+    });
+    await run({ home, storePath, deps, res });
+  }, fixtureParams);
+}
+
+async function expectTelegramTextDeliveryFailure(params: {
+  bestEffort: boolean;
+  expectedStatus: "ok" | "error";
+  expectedErrorFragment?: string;
+}) {
+  await withTelegramTextDelivery(
+    { bestEffort: params.bestEffort },
+    async ({ deps, res }) => {
+      expectFailedTelegramDeliveryResult({
+        res,
+        deps,
+        expectedStatus: params.expectedStatus,
+        expectedErrorFragment: params.expectedErrorFragment,
+        expectDeliveryAttempted: true,
+      });
+    },
+    {
+      deps: {
+        sendMessageTelegram: vi.fn().mockRejectedValue(new Error("boom")),
+      },
+    },
+  );
+}
+
 async function runSignalDeliveryResult(bestEffort: boolean) {
   let outcome:
     | {
@@ -358,34 +415,10 @@ describe("runCronIsolatedAgentTurn", () => {
   });
 
   it("reports not-delivered when text direct delivery fails and best-effort is enabled", async () => {
-    await withTelegramAnnounceFixture(
-      async ({ home, storePath, deps }) => {
-        mockAgentPayloads([{ text: "hello from cron" }]);
-
-        const res = await runTelegramAnnounceTurn({
-          home,
-          storePath,
-          deps,
-          delivery: {
-            mode: "announce",
-            channel: "telegram",
-            to: "123",
-            bestEffort: true,
-          },
-        });
-
-        expect(res.status).toBe("ok");
-        expect(res.delivered).toBe(false);
-        expect(res.deliveryAttempted).toBe(true);
-        expect(runSubagentAnnounceFlow).not.toHaveBeenCalled();
-        expect(deps.sendMessageTelegram).toHaveBeenCalledTimes(1);
-      },
-      {
-        deps: {
-          sendMessageTelegram: vi.fn().mockRejectedValue(new Error("boom")),
-        },
-      },
-    );
+    await expectTelegramTextDeliveryFailure({
+      bestEffort: true,
+      expectedStatus: "ok",
+    });
   });
 
   it("delivers text directly when best-effort is disabled", async () => {
@@ -398,57 +431,20 @@ describe("runCronIsolatedAgentTurn", () => {
   });
 
   it("returns error when text direct delivery fails and best-effort is disabled", async () => {
-    await withTelegramAnnounceFixture(
-      async ({ home, storePath, deps }) => {
-        mockAgentPayloads([{ text: "hello from cron" }]);
-
-        const res = await runTelegramAnnounceTurn({
-          home,
-          storePath,
-          deps,
-          delivery: {
-            mode: "announce",
-            channel: "telegram",
-            to: "123",
-            bestEffort: false,
-          },
-        });
-
-        expect(res.status).toBe("error");
-        expect(res.delivered).toBeUndefined();
-        expect(res.deliveryAttempted).toBe(true);
-        expect(res.error).toContain("boom");
-        expect(runSubagentAnnounceFlow).not.toHaveBeenCalled();
-        expect(deps.sendMessageTelegram).toHaveBeenCalledTimes(1);
-      },
-      {
-        deps: {
-          sendMessageTelegram: vi.fn().mockRejectedValue(new Error("boom")),
-        },
-      },
-    );
+    await expectTelegramTextDeliveryFailure({
+      bestEffort: false,
+      expectedStatus: "error",
+      expectedErrorFragment: "boom",
+    });
   });
 
   it("retries transient text direct delivery failures before succeeding", async () => {
     const previousFastMode = process.env.OPENCLAW_TEST_FAST;
     process.env.OPENCLAW_TEST_FAST = "1";
     try {
-      await withTelegramAnnounceFixture(
-        async ({ home, storePath, deps }) => {
-          mockAgentPayloads([{ text: "hello from cron" }]);
-
-          const res = await runTelegramAnnounceTurn({
-            home,
-            storePath,
-            deps,
-            delivery: {
-              mode: "announce",
-              channel: "telegram",
-              to: "123",
-              bestEffort: false,
-            },
-          });
-
+      await withTelegramTextDelivery(
+        { bestEffort: false },
+        async ({ deps, res }) => {
           expectSuccessfulTelegramTextDelivery({ res, deps });
           expect(deps.sendMessageTelegram).toHaveBeenCalledTimes(2);
           expect(deps.sendMessageTelegram).toHaveBeenLastCalledWith(