355 lines
14 KiB
TypeScript
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");
|
|
});
|
|
});
|