test: dedupe line and whatsapp target resolution tests

src/whatsapp/resolve-outbound-target.test.ts

@@ -7,73 +7,46 @@ vi.mock("../infra/outbound/target-errors.js", () => ({
   missingTargetError: (platform: string, format: string) => new Error(`${platform}: ${format}`),
 }));
 
+type ResolveParams = Parameters<typeof resolveWhatsAppOutboundTarget>[0];
+
+function expectResolutionError(params: ResolveParams) {
+  const result = resolveWhatsAppOutboundTarget(params);
+  expect(result.ok).toBe(false);
+  if (result.ok) {
+    throw new Error("expected resolution to fail");
+  }
+  expect(result.error.message).toContain("WhatsApp");
+}
+
+function expectResolutionOk(params: ResolveParams, expectedTarget: string) {
+  const result = resolveWhatsAppOutboundTarget(params);
+  expect(result).toEqual({ ok: true, to: expectedTarget });
+}
+
 describe("resolveWhatsAppOutboundTarget", () => {
   beforeEach(() => {
     vi.resetAllMocks();
   });
 
   describe("empty/missing to parameter", () => {
-    it("returns error when to is null", () => {
-      const result = resolveWhatsAppOutboundTarget({
-        to: null,
-        allowFrom: undefined,
-        mode: undefined,
-      });
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error.message).toContain("WhatsApp");
-      }
-    });
-
-    it("returns error when to is undefined", () => {
-      const result = resolveWhatsAppOutboundTarget({
-        to: undefined,
-        allowFrom: undefined,
-        mode: undefined,
-      });
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error.message).toContain("WhatsApp");
-      }
-    });
-
-    it("returns error when to is empty string", () => {
-      const result = resolveWhatsAppOutboundTarget({
-        to: "",
-        allowFrom: undefined,
-        mode: undefined,
-      });
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error.message).toContain("WhatsApp");
-      }
-    });
-
-    it("returns error when to is whitespace only", () => {
-      const result = resolveWhatsAppOutboundTarget({
-        to: "   ",
-        allowFrom: undefined,
-        mode: undefined,
-      });
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error.message).toContain("WhatsApp");
-      }
+    it.each([
+      ["null", null],
+      ["undefined", undefined],
+      ["empty string", ""],
+      ["whitespace only", "   "],
+    ])("returns error when to is %s", (_label, to) => {
+      expectResolutionError({ to, allowFrom: undefined, mode: undefined });
     });
   });
 
   describe("normalization failures", () => {
     it("returns error when normalizeWhatsAppTarget returns null/undefined", () => {
       vi.mocked(normalize.normalizeWhatsAppTarget).mockReturnValueOnce(null);
-      const result = resolveWhatsAppOutboundTarget({
+      expectResolutionError({
         to: "+1234567890",
         allowFrom: undefined,
         mode: undefined,
       });
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error.message).toContain("WhatsApp");
-      }
     });
   });
 
@@ -82,30 +55,28 @@ describe("resolveWhatsAppOutboundTarget", () => {
       vi.mocked(normalize.normalizeWhatsAppTarget).mockReturnValueOnce("120363123456789@g.us");
       vi.mocked(normalize.isWhatsAppGroupJid).mockReturnValueOnce(true);
 
-      const result = resolveWhatsAppOutboundTarget({
-        to: "120363123456789@g.us",
-        allowFrom: undefined,
-        mode: "implicit",
-      });
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.to).toBe("120363123456789@g.us");
-      }
+      expectResolutionOk(
+        {
+          to: "120363123456789@g.us",
+          allowFrom: undefined,
+          mode: "implicit",
+        },
+        "120363123456789@g.us",
+      );
     });
 
     it("returns success for group JID in heartbeat mode", () => {
       vi.mocked(normalize.normalizeWhatsAppTarget).mockReturnValueOnce("120363999888777@g.us");
       vi.mocked(normalize.isWhatsAppGroupJid).mockReturnValueOnce(true);
 
-      const result = resolveWhatsAppOutboundTarget({
-        to: "120363999888777@g.us",
-        allowFrom: undefined,
-        mode: "heartbeat",
-      });
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.to).toBe("120363999888777@g.us");
-      }
+      expectResolutionOk(
+        {
+          to: "120363999888777@g.us",
+          allowFrom: undefined,
+          mode: "heartbeat",
+        },
+        "120363999888777@g.us",
+      );
     });
   });
 
@@ -116,15 +87,14 @@ describe("resolveWhatsAppOutboundTarget", () => {
         .mockReturnValueOnce("+11234567890");
       vi.mocked(normalize.isWhatsAppGroupJid).mockReturnValueOnce(false);
 
-      const result = resolveWhatsAppOutboundTarget({
-        to: "+11234567890",
-        allowFrom: ["*"],
-        mode: "implicit",
-      });
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.to).toBe("+11234567890");
-      }
+      expectResolutionOk(
+        {
+          to: "+11234567890",
+          allowFrom: ["*"],
+          mode: "implicit",
+        },
+        "+11234567890",
+      );
     });
 
     it("allows message when allowList is empty", () => {
@@ -133,15 +103,14 @@ describe("resolveWhatsAppOutboundTarget", () => {
         .mockReturnValueOnce("+11234567890");
       vi.mocked(normalize.isWhatsAppGroupJid).mockReturnValueOnce(false);
 
-      const result = resolveWhatsAppOutboundTarget({
-        to: "+11234567890",
-        allowFrom: [],
-        mode: "implicit",
-      });
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.to).toBe("+11234567890");
-      }
+      expectResolutionOk(
+        {
+          to: "+11234567890",
+          allowFrom: [],
+          mode: "implicit",
+        },
+        "+11234567890",
+      );
     });
 
     it("allows message when target is in allowList", () => {
@@ -150,15 +119,14 @@ describe("resolveWhatsAppOutboundTarget", () => {
         .mockReturnValueOnce("+11234567890");
       vi.mocked(normalize.isWhatsAppGroupJid).mockReturnValueOnce(false);
 
-      const result = resolveWhatsAppOutboundTarget({
-        to: "+11234567890",
-        allowFrom: ["+11234567890"],
-        mode: "implicit",
-      });
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.to).toBe("+11234567890");
-      }
+      expectResolutionOk(
+        {
+          to: "+11234567890",
+          allowFrom: ["+11234567890"],
+          mode: "implicit",
+        },
+        "+11234567890",
+      );
     });
 
     it("denies message when target is not in allowList", () => {
@@ -167,15 +135,11 @@ describe("resolveWhatsAppOutboundTarget", () => {
         .mockReturnValueOnce("+19876543210");
       vi.mocked(normalize.isWhatsAppGroupJid).mockReturnValueOnce(false);
 
-      const result = resolveWhatsAppOutboundTarget({
+      expectResolutionError({
         to: "+11234567890",
         allowFrom: ["+19876543210"],
         mode: "implicit",
       });
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error.message).toContain("WhatsApp");
-      }
     });
 
     it("handles mixed numeric and string allowList entries", () => {
@@ -185,15 +149,14 @@ describe("resolveWhatsAppOutboundTarget", () => {
         .mockReturnValueOnce("+11234567890"); // for allowFrom[1]
       vi.mocked(normalize.isWhatsAppGroupJid).mockReturnValueOnce(false);
 
-      const result = resolveWhatsAppOutboundTarget({
-        to: "+11234567890",
-        allowFrom: [1234567890, "+11234567890"],
-        mode: "implicit",
-      });
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.to).toBe("+11234567890");
-      }
+      expectResolutionOk(
+        {
+          to: "+11234567890",
+          allowFrom: [1234567890, "+11234567890"],
+          mode: "implicit",
+        },
+        "+11234567890",
+      );
     });
 
     it("filters out invalid normalized entries from allowList", () => {
@@ -203,15 +166,14 @@ describe("resolveWhatsAppOutboundTarget", () => {
         .mockReturnValueOnce("+11234567890"); // for 'to' param (processed last)
       vi.mocked(normalize.isWhatsAppGroupJid).mockReturnValueOnce(false);
 
-      const result = resolveWhatsAppOutboundTarget({
-        to: "+11234567890",
-        allowFrom: ["invalid", "+11234567890"],
-        mode: "implicit",
-      });
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.to).toBe("+11234567890");
-      }
+      expectResolutionOk(
+        {
+          to: "+11234567890",
+          allowFrom: ["invalid", "+11234567890"],
+          mode: "implicit",
+        },
+        "+11234567890",
+      );
     });
   });
 
@@ -222,15 +184,14 @@ describe("resolveWhatsAppOutboundTarget", () => {
         .mockReturnValueOnce("+11234567890");
       vi.mocked(normalize.isWhatsAppGroupJid).mockReturnValueOnce(false);
 
-      const result = resolveWhatsAppOutboundTarget({
-        to: "+11234567890",
-        allowFrom: ["+11234567890"],
-        mode: "heartbeat",
-      });
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.to).toBe("+11234567890");
-      }
+      expectResolutionOk(
+        {
+          to: "+11234567890",
+          allowFrom: ["+11234567890"],
+          mode: "heartbeat",
+        },
+        "+11234567890",
+      );
     });
 
     it("denies message when target is not in allowList in heartbeat mode", () => {
@@ -239,15 +200,11 @@ describe("resolveWhatsAppOutboundTarget", () => {
         .mockReturnValueOnce("+19876543210");
       vi.mocked(normalize.isWhatsAppGroupJid).mockReturnValueOnce(false);
 
-      const result = resolveWhatsAppOutboundTarget({
+      expectResolutionError({
         to: "+11234567890",
         allowFrom: ["+19876543210"],
         mode: "heartbeat",
       });
-      expect(result.ok).toBe(false);
-      if (!result.ok) {
-        expect(result.error.message).toContain("WhatsApp");
-      }
     });
   });
 
@@ -256,30 +213,28 @@ describe("resolveWhatsAppOutboundTarget", () => {
       vi.mocked(normalize.normalizeWhatsAppTarget).mockReturnValueOnce("+11234567890");
       vi.mocked(normalize.isWhatsAppGroupJid).mockReturnValueOnce(false);
 
-      const result = resolveWhatsAppOutboundTarget({
-        to: "+11234567890",
-        allowFrom: undefined,
-        mode: null,
-      });
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.to).toBe("+11234567890");
-      }
+      expectResolutionOk(
+        {
+          to: "+11234567890",
+          allowFrom: undefined,
+          mode: null,
+        },
+        "+11234567890",
+      );
     });
 
     it("allows message in undefined mode", () => {
       vi.mocked(normalize.normalizeWhatsAppTarget).mockReturnValueOnce("+11234567890");
       vi.mocked(normalize.isWhatsAppGroupJid).mockReturnValueOnce(false);
 
-      const result = resolveWhatsAppOutboundTarget({
-        to: "+11234567890",
-        allowFrom: undefined,
-        mode: undefined,
-      });
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.to).toBe("+11234567890");
-      }
+      expectResolutionOk(
+        {
+          to: "+11234567890",
+          allowFrom: undefined,
+          mode: undefined,
+        },
+        "+11234567890",
+      );
     });
 
     it("allows message in custom mode string", () => {
@@ -288,15 +243,14 @@ describe("resolveWhatsAppOutboundTarget", () => {
         .mockReturnValueOnce("+11234567890"); // for 'to' param (happens second)
       vi.mocked(normalize.isWhatsAppGroupJid).mockReturnValueOnce(false);
 
-      const result = resolveWhatsAppOutboundTarget({
-        to: "+11234567890",
-        allowFrom: ["+19876543210"],
-        mode: "broadcast",
-      });
-      expect(result.ok).toBe(true);
-      if (result.ok) {
-        expect(result.to).toBe("+11234567890");
-      }
+      expectResolutionOk(
+        {
+          to: "+11234567890",
+          allowFrom: ["+19876543210"],
+          mode: "broadcast",
+        },
+        "+11234567890",
+      );
     });
   });
 
@@ -305,12 +259,14 @@ describe("resolveWhatsAppOutboundTarget", () => {
       vi.mocked(normalize.normalizeWhatsAppTarget).mockReturnValueOnce("+11234567890");
       vi.mocked(normalize.isWhatsAppGroupJid).mockReturnValueOnce(false);
 
-      const result = resolveWhatsAppOutboundTarget({
-        to: "  +11234567890  ",
-        allowFrom: undefined,
-        mode: undefined,
-      });
-      expect(result.ok).toBe(true);
+      expectResolutionOk(
+        {
+          to: "  +11234567890  ",
+          allowFrom: undefined,
+          mode: undefined,
+        },
+        "+11234567890",
+      );
       expect(vi.mocked(normalize.normalizeWhatsAppTarget)).toHaveBeenCalledWith("+11234567890");
     });