Files
HiveGrid-Wireframes/03 Quellen und Referenzen/hivegrid-cloud/packages/mail/src/mailjet.test.ts
T

355 lines
14 KiB
TypeScript

import { describe, expect, test, vi } from "vitest";
import { createMailjetProviderFromEnv, MailjetProvider } from "./mailjet.js";
import { MailProviderError } from "./types.js";
function basicAuth(apiKey: string, secretKey: string): string {
return `Basic ${Buffer.from(`${apiKey}:${secretKey}`, "utf8").toString("base64")}`;
}
function jsonResponse(body: unknown, init: ResponseInit = {}) {
return new Response(JSON.stringify(body), {
headers: { "content-type": "application/json", ...init.headers },
...init,
});
}
function successBody(messageUuid = "uuid-123") {
return { Messages: [{ Status: "success", To: [{ Email: "to@example.com", MessageID: 456, MessageUUID: messageUuid, MessageHref: "https://api.mailjet.com/v3/message/456" }] }] };
}
function captureError(fn: () => unknown): unknown {
try {
fn();
} catch (error) {
return error;
}
throw new Error("Expected function to throw.");
}
function expectRedacted(error: unknown) {
const serialized = JSON.stringify(error, Object.getOwnPropertyNames(error));
expect(serialized).not.toContain("super-secret-secret-key");
}
describe("MailjetProvider", () => {
test("maps send input to the Mailjet v3.1 payload and returns provider diagnostics", async () => {
const fetchMock = vi.fn(async () => jsonResponse(successBody("uuid-123"), { status: 200 }));
const provider = new MailjetProvider({
apiKey: "api_key",
secretKey: "secret_key",
fromEmail: "default@example.com",
fromName: "Default Sender",
baseUrl: "https://mail.example.com/",
fetch: fetchMock as unknown as typeof fetch,
});
const sendAt = new Date("2026-05-05T12:00:00.000Z");
await expect(
provider.send({
from: { email: "sender@example.com", name: "Sender" },
to: ["user@example.com", { email: "named@example.com", name: "Named Recipient" }],
cc: [{ email: "cc@example.com", name: "CC" }],
bcc: ["bcc@example.com"],
replyTo: { email: "reply@example.com", name: "Reply" },
subject: "Welcome",
text: "Plain text",
html: "<p>Hello</p>",
templateId: "12345",
attachments: [{ content: "YWJj", filename: "file.txt", id: "attachment_1" }],
tags: ["signup"],
personalization: [{ email: "user@example.com", data: { firstName: "Ada" } }],
precedenceBulk: true,
sendAt, // not supported by Mailjet v3.1 send → intentionally dropped
inReplyTo: "previous-message",
references: ["reference-message"],
settings: { trackClicks: true, trackOpens: false, trackContent: true },
headers: [{ name: "X-Test", value: "yes" }],
listUnsubscribe: "<mailto:unsubscribe@example.com>",
})
).resolves.toEqual({
provider: "mailjet",
status: "queued",
messageId: "uuid-123",
});
expect(provider.id).toBe("mailjet");
expect(fetchMock).toHaveBeenCalledTimes(1);
expect(fetchMock).toHaveBeenCalledWith("https://mail.example.com/v3.1/send", {
method: "POST",
headers: {
Authorization: basicAuth("api_key", "secret_key"),
"Content-Type": "application/json",
Accept: "application/json",
},
signal: expect.any(AbortSignal),
body: JSON.stringify({
Messages: [
{
From: { Email: "sender@example.com", Name: "Sender" },
To: [{ Email: "user@example.com" }, { Email: "named@example.com", Name: "Named Recipient" }],
Cc: [{ Email: "cc@example.com", Name: "CC" }],
Bcc: [{ Email: "bcc@example.com" }],
ReplyTo: { Email: "reply@example.com", Name: "Reply" },
Subject: "Welcome",
TextPart: "Plain text",
HTMLPart: "<p>Hello</p>",
TemplateID: 12345,
TemplateLanguage: true,
Attachments: [{ ContentType: "text/plain", Filename: "file.txt", Base64Content: "YWJj" }],
Headers: {
"X-Test": "yes",
"In-Reply-To": "previous-message",
References: "reference-message",
"List-Unsubscribe": "<mailto:unsubscribe@example.com>",
Precedence: "bulk",
},
CustomCampaign: "signup",
TrackOpens: "disabled",
TrackClicks: "enabled",
Variables: { firstName: "Ada" },
},
],
}),
});
});
test("creates providers only from explicit Mailjet fixture env", async () => {
const fetchMock = vi.fn(async () => jsonResponse(successBody("msg_fixture"), { status: 200 }));
const provider = createMailjetProviderFromEnv({
MAILJET_API_KEY: "fixture_api_key",
MAILJET_SECRET_KEY: "fixture_secret_key",
MAILJET_FROM_EMAIL: "sender@example.com",
MAILJET_FROM_NAME: "Fixture Sender",
}) as MailjetProvider;
Object.defineProperty(provider, "fetchImpl", { value: fetchMock });
await expect(provider.send({ to: ["user@example.com"], subject: "Welcome", text: "Hello" })).resolves.toMatchObject({
provider: "mailjet",
status: "queued",
messageId: "msg_fixture",
});
expect(fetchMock).toHaveBeenCalledWith(
"https://api.mailjet.com/v3.1/send",
expect.objectContaining({
headers: expect.objectContaining({ Authorization: basicAuth("fixture_api_key", "fixture_secret_key") }),
body: expect.stringContaining("Fixture Sender"),
})
);
});
test("maps idempotency keys to Mailjet CustomID", async () => {
const fetchMock = vi.fn(async () => jsonResponse(successBody("msg_idempotent"), { status: 200 }));
const provider = new MailjetProvider({
apiKey: "api_key",
secretKey: "secret_key",
fromEmail: "sender@example.com",
fetch: fetchMock as unknown as typeof fetch,
});
await provider.send({
to: ["user@example.com"],
subject: "Welcome",
text: "Hello",
idempotencyKey: "notification-delivery:delivery_1",
});
expect(fetchMock).toHaveBeenCalledWith(
"https://api.mailjet.com/v3.1/send",
expect.objectContaining({
body: expect.stringContaining('"CustomID":"notification-delivery:delivery_1"'),
})
);
});
test("adds the SandboxMode flag when sandbox is enabled", async () => {
const fetchMock = vi.fn(async () => jsonResponse(successBody(), { status: 200 }));
const provider = new MailjetProvider({
apiKey: "api_key",
secretKey: "secret_key",
fromEmail: "sender@example.com",
sandbox: true,
fetch: fetchMock as unknown as typeof fetch,
});
await provider.send({ to: ["user@example.com"], subject: "Welcome", text: "Hello" });
expect(fetchMock).toHaveBeenCalledWith(
"https://api.mailjet.com/v3.1/send",
expect.objectContaining({ body: expect.stringContaining('"SandboxMode":true') })
);
});
test("validates required Mailjet environment variables with key-only reporting", () => {
const missingApiKey = captureError(() => createMailjetProviderFromEnv({ MAILJET_SECRET_KEY: "s", MAILJET_FROM_EMAIL: "sender@example.com" }));
const missingSecretKey = captureError(() => createMailjetProviderFromEnv({ MAILJET_API_KEY: "k", MAILJET_FROM_EMAIL: "sender@example.com" }));
const missingFromEmail = captureError(() => createMailjetProviderFromEnv({ MAILJET_API_KEY: "k", MAILJET_SECRET_KEY: "super-secret-secret-key" }));
expect(missingApiKey).toMatchObject({ message: "MAILJET_API_KEY is required for Mailjet email delivery." });
expect(missingSecretKey).toMatchObject({ message: "MAILJET_SECRET_KEY is required for Mailjet email delivery." });
expect(missingFromEmail).toMatchObject({ message: "MAILJET_FROM_EMAIL is required for Mailjet email delivery." });
expectRedacted(missingFromEmail);
});
test("rejects an empty recipient list before calling Mailjet", async () => {
const fetchMock = vi.fn();
const provider = new MailjetProvider({
apiKey: "api_key",
secretKey: "secret_key",
fromEmail: "sender@example.com",
fetch: fetchMock as unknown as typeof fetch,
});
await expect(provider.send({ to: [], subject: "Welcome", text: "Hello" })).rejects.toMatchObject({
provider: "mailjet",
message: "At least one recipient is required.",
});
expect(fetchMock).not.toHaveBeenCalled();
});
test("rejects non-numeric template ids before calling Mailjet", async () => {
const fetchMock = vi.fn();
const provider = new MailjetProvider({
apiKey: "api_key",
secretKey: "secret_key",
fromEmail: "sender@example.com",
fetch: fetchMock as unknown as typeof fetch,
});
await expect(provider.send({ to: ["user@example.com"], templateId: "welcome" })).rejects.toMatchObject({
provider: "mailjet",
message: "Mailjet TemplateID must be numeric.",
});
expect(fetchMock).not.toHaveBeenCalled();
});
test("includes status and response body for failed HTTP responses", async () => {
const responseBody = { ErrorMessage: "Unauthorized", StatusCode: 401 };
const provider = new MailjetProvider({
apiKey: "api_key",
secretKey: "secret_key",
fromEmail: "sender@example.com",
fetch: vi.fn(async () => jsonResponse(responseBody, { status: 401 })) as unknown as typeof fetch,
});
await expect(provider.send({ to: ["bad@example.com"], subject: "Welcome", text: "Hello" })).rejects.toMatchObject({
name: "MailProviderError",
provider: "mailjet",
statusCode: 401,
responseBody,
message: "Mailjet email request failed with 401.",
} satisfies Partial<MailProviderError>);
});
test("treats per-message errors in a 200 response as a failure", async () => {
const responseBody = { Messages: [{ Status: "error", Errors: [{ ErrorMessage: "Invalid email" }] }] };
const provider = new MailjetProvider({
apiKey: "api_key",
secretKey: "secret_key",
fromEmail: "sender@example.com",
fetch: vi.fn(async () => jsonResponse(responseBody, { status: 200 })) as unknown as typeof fetch,
});
await expect(provider.send({ to: ["bad@example.com"], subject: "Welcome", text: "Hello" })).rejects.toMatchObject({
provider: "mailjet",
message: "Mailjet rejected at least one message.",
responseBody,
});
});
test("caps failed response bodies before adding provider diagnostics", async () => {
const provider = new MailjetProvider({
apiKey: "api_key",
secretKey: "secret_key",
fromEmail: "sender@example.com",
responseBodyLimitBytes: 16,
fetch: vi.fn(async () => new Response("safe-prefix-token=secret-tail", { status: 500 })) as unknown as typeof fetch,
});
await expect(provider.send({ to: ["bad@example.com"], subject: "Welcome", text: "Hello" })).rejects.toMatchObject({
provider: "mailjet",
statusCode: 500,
responseBody: "safe-prefix-toke",
});
});
test("converts aborts into bounded Mailjet timeout errors", async () => {
const abortError = new Error("aborted");
abortError.name = "AbortError";
const provider = new MailjetProvider({
apiKey: "api_key",
secretKey: "secret_key",
fromEmail: "sender@example.com",
timeoutMs: 1,
fetch: vi.fn(async () => {
throw abortError;
}) as unknown as typeof fetch,
});
await expect(provider.send({ to: ["bad@example.com"], subject: "Welcome", text: "Hello" })).rejects.toMatchObject({
provider: "mailjet",
message: "Mailjet email request timed out.",
});
});
test("emits onMetric with status=delivered on a fully accepted send", async () => {
const fetchMock = vi.fn(async () => jsonResponse(successBody(), { status: 200 }));
const samples: Array<{ provider: string; status: string }> = [];
const provider = new MailjetProvider({
apiKey: "api_key",
secretKey: "secret_key",
fromEmail: "sender@example.com",
fetch: fetchMock as unknown as typeof fetch,
onMetric: (s) => samples.push(s),
});
await provider.send({ to: ["to@example.com"], subject: "x", text: "y" });
expect(samples).toEqual([{ provider: "mailjet", status: "delivered" }]);
});
test("emits onMetric with status=failed on non-2xx response", async () => {
const fetchMock = vi.fn(async () => jsonResponse({ ErrorMessage: "bad" }, { status: 422 }));
const samples: Array<{ provider: string; status: string }> = [];
const provider = new MailjetProvider({
apiKey: "api_key",
secretKey: "secret_key",
fromEmail: "sender@example.com",
fetch: fetchMock as unknown as typeof fetch,
onMetric: (s) => samples.push(s),
});
await expect(provider.send({ to: ["to@example.com"], subject: "x", text: "y" })).rejects.toBeInstanceOf(MailProviderError);
expect(samples).toEqual([{ provider: "mailjet", status: "failed" }]);
});
test("emits onMetric with status=failed when fetch throws", async () => {
const samples: Array<{ provider: string; status: string }> = [];
const provider = new MailjetProvider({
apiKey: "api_key",
secretKey: "secret_key",
fromEmail: "sender@example.com",
fetch: (async () => {
throw new Error("network down");
}) as unknown as typeof fetch,
onMetric: (s) => samples.push(s),
});
await expect(provider.send({ to: ["to@example.com"], subject: "x", text: "y" })).rejects.toThrow("network down");
expect(samples).toEqual([{ provider: "mailjet", status: "failed" }]);
});
test("a throwing onMetric does not block delivery", async () => {
const fetchMock = vi.fn(async () => jsonResponse(successBody(), { status: 200 }));
const provider = new MailjetProvider({
apiKey: "api_key",
secretKey: "secret_key",
fromEmail: "sender@example.com",
fetch: fetchMock as unknown as typeof fetch,
onMetric: () => {
throw new Error("metric write failed");
},
});
const result = await provider.send({ to: ["to@example.com"], subject: "x", text: "y" });
expect(result.status).toBe("queued");
});
});