vultr/openclaw
1
0
Fork 0
mirror of https://github.com/openclaw/openclaw.git synced 2026-04-05 22:32:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

test: trim whatsapp channel test barrels

Browse Source
This commit is contained in:
Shakker
2026-04-02 09:08:09 +01:00
committed by Shakker
parent 6d6060d3ec
commit 4615ddf89b
3 changed files with 18 additions and 163 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
extensions/shared/resolve-target-test-helpers.ts
View File

@@ -1 +0,0 @@
export { installCommonResolveTargetErrorCases } from "openclaw/plugin-sdk/testing";

17
extensions/whatsapp/src/channel.test.ts
View File

@@ -185,6 +185,23 @@ describe("whatsappPlugin outbound sendMedia", () => {
});
});
describe("whatsappPlugin outbound resolveTarget", () => {
it("delegates direct target normalization to the outbound resolver", () => {
const outbound = whatsappPlugin.outbound;
if (!outbound?.resolveTarget) {
throw new Error("whatsapp outbound resolveTarget is unavailable");
}
expect(
outbound.resolveTarget({
to: "whatsapp:+15551234567",
allowFrom: [],
mode: "explicit",
}),
).toEqual({ ok: true, to: "+15551234567" });
});
});
describe("whatsappPlugin outbound sendPoll", () => {
beforeEach(async () => {
vi.resetModules();

163
extensions/whatsapp/src/resolve-target.test.ts
View File

@@ -1,171 +1,10 @@
import { beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
import { installCommonResolveTargetErrorCases } from "../../../src/test-helpers/resolve-target-error-cases.js";
import { describe, expect, it } from "vitest";
import {
isWhatsAppGroupJid,
isWhatsAppUserTarget,
normalizeWhatsAppTarget,
} from "./normalize-target.js";
vi.mock("./runtime-api.js", async () => {
const actual = await vi.importActual<typeof import("./runtime-api.js")>("./runtime-api.js");
const normalizeWhatsAppTarget = (value: string) => {
if (value === "invalid-target") return null;
// Simulate E.164 normalization: strip leading + and whatsapp: prefix.
const stripped = value.replace(/^whatsapp:/i, "").replace(/^\+/, "");
return stripped.includes("@g.us") ? stripped : `${stripped}@s.whatsapp.net`;
};
return {
...actual,
getChatChannelMeta: () => ({ id: "whatsapp", label: "WhatsApp" }),
normalizeWhatsAppTarget,
isWhatsAppGroupJid: (value: string) => value.endsWith("@g.us"),
resolveWhatsAppOutboundTarget: ({
to,
allowFrom,
mode,
}: {
to?: string;
allowFrom: string[];
mode: "explicit" | "implicit";
}) => {
const raw = typeof to === "string" ? to.trim() : "";
if (!raw) {
return { ok: false, error: new Error("missing target") };
}
const normalized = normalizeWhatsAppTarget(raw);
if (!normalized) {
return { ok: false, error: new Error("invalid target") };
}
if (mode === "implicit" && !normalized.endsWith("@g.us")) {
const allowAll = allowFrom.includes("*");
const allowExact = allowFrom.some((entry) => {
if (!entry) {
return false;
}
const normalizedEntry = normalizeWhatsAppTarget(entry.trim());
return normalizedEntry?.toLowerCase() === normalized.toLowerCase();
});
if (!allowAll && !allowExact) {
return { ok: false, error: new Error("target not allowlisted") };
}
}
return { ok: true, to: normalized };
},
missingTargetError: (provider: string, hint: string) =>
new Error(`Delivering to ${provider} requires target ${hint}`),
};
});
vi.mock("./runtime.js", () => ({
getWhatsAppRuntime: vi.fn(() => ({
channel: {
text: { chunkText: vi.fn() },
whatsapp: {
sendMessageWhatsApp: vi.fn(),
createLoginTool: vi.fn(),
},
},
})),
}));
let resolveTarget: NonNullable<
NonNullable<NonNullable<typeof import("./channel.js").whatsappPlugin.outbound>["resolveTarget"]>
>;
describe("whatsapp resolveTarget", () => {
beforeAll(async () => {
const outbound = (await import("./channel.js")).whatsappPlugin.outbound;
if (!outbound?.resolveTarget) {
throw new Error("expected whatsapp outbound resolveTarget");
}
resolveTarget = outbound.resolveTarget;
});
beforeEach(() => {
vi.clearAllMocks();
});
it("should resolve valid target in explicit mode", () => {
const result = resolveTarget({
to: "5511999999999",
mode: "explicit",
allowFrom: [],
});
expect(result.ok).toBe(true);
if (!result.ok) {
throw result.error;
}
expect(result.to).toBe("5511999999999@s.whatsapp.net");
});
it("should resolve target in implicit mode with wildcard", () => {
const result = resolveTarget({
to: "5511999999999",
mode: "implicit",
allowFrom: ["*"],
});
expect(result.ok).toBe(true);
if (!result.ok) {
throw result.error;
}
expect(result.to).toBe("5511999999999@s.whatsapp.net");
});
it("should resolve target in implicit mode when in allowlist", () => {
const result = resolveTarget({
to: "5511999999999",
mode: "implicit",
allowFrom: ["5511999999999"],
});
expect(result.ok).toBe(true);
if (!result.ok) {
throw result.error;
}
expect(result.to).toBe("5511999999999@s.whatsapp.net");
});
it("should allow group JID regardless of allowlist", () => {
const result = resolveTarget({
to: "120363123456789@g.us",
mode: "implicit",
allowFrom: ["5511999999999"],
});
expect(result.ok).toBe(true);
if (!result.ok) {
throw result.error;
}
expect(result.to).toBe("120363123456789@g.us");
});
it("should error when target not in allowlist (implicit mode)", () => {
const result = resolveTarget({
to: "5511888888888",
mode: "implicit",
allowFrom: ["5511999999999", "5511777777777"],
});
expect(result.ok).toBe(false);
if (result.ok) {
throw new Error("expected resolution to fail");
}
expect(result.error).toBeDefined();
});
describe("common error cases", () => {
installCommonResolveTargetErrorCases({
resolveTarget: (...args) => resolveTarget(...args),
implicitAllowFrom: ["5511999999999"],
});
});
});
describe("normalizeWhatsAppTarget", () => {
it("preserves group JIDs", () => {
expect(normalizeWhatsAppTarget("120363401234567890@g.us")).toBe("120363401234567890@g.us");