@antelopejs/dms-mailing 0.2.2

package/src/test/antelope.test.ts

@@ -0,0 +1,188 @@
+import { mkdtemp, rm } from "node:fs/promises";
+import { createServer, type Server, type Socket } from "node:net";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { defineConfig } from "@antelopejs/interface-core/config";
+import { MongoMemoryReplSet } from "mongodb-memory-server-core";
+import { SHARED_MODULE_SOURCES } from "../antelope-modules";
+
+const API_PORT = 5019;
+const JWT_SECRET = "test-jwt-secret";
+const MONGO_BINARY_VERSION = "8.0.8";
+const SMTP_HOST = "127.0.0.1";
+const EPHEMERAL_PORT = 0;
+const TEST_SENDER = "dms-mailing@test.local";
+const SMTP_RESPONSES: Record<string, string> = {
+  EHLO: "250-dms-mailing.test\r\n250 PIPELINING\r\n",
+  HELO: "250 dms-mailing.test\r\n",
+  MAIL: "250 OK\r\n",
+  RCPT: "250 OK\r\n",
+  DATA: "354 End data with <CR><LF>.<CR><LF>\r\n",
+  RSET: "250 OK\r\n",
+  NOOP: "250 OK\r\n",
+  QUIT: "221 Bye\r\n",
+};
+
+interface SmtpConnectionState {
+  pending: string;
+  isReadingData: boolean;
+}
+
+let mongod: MongoMemoryReplSet;
+let storageDir: string;
+let smtpServer: Server;
+
+function processSmtpLine(
+  socket: Socket,
+  state: SmtpConnectionState,
+  line: string,
+): void {
+  if (state.isReadingData) {
+    if (line === ".") {
+      state.isReadingData = false;
+      socket.write("250 Queued\r\n");
+    }
+    return;
+  }
+  const command = line.split(" ", 1)[0]?.toUpperCase() ?? "";
+  state.isReadingData = command === "DATA";
+  const response = SMTP_RESPONSES[command] ?? "250 OK\r\n";
+  if (command === "QUIT") socket.end(response);
+  else socket.write(response);
+}
+
+function createSmtpFixture(): Server {
+  return createServer((socket) => {
+    const state: SmtpConnectionState = { pending: "", isReadingData: false };
+    socket.setEncoding("utf8");
+    socket.write("220 dms-mailing.test ESMTP\r\n");
+    socket.on("data", (chunk) => {
+      state.pending += chunk;
+      const lines = state.pending.split(/\r?\n/);
+      state.pending = lines.pop() ?? "";
+      for (const line of lines) processSmtpLine(socket, state, line);
+    });
+  });
+}
+
+async function startSmtpFixture(): Promise<number> {
+  smtpServer = createSmtpFixture();
+  await new Promise<void>((resolve, reject) => {
+    const onError = (error: Error) => reject(error);
+    smtpServer.once("error", onError);
+    smtpServer.listen(EPHEMERAL_PORT, SMTP_HOST, () => {
+      smtpServer.off("error", onError);
+      resolve();
+    });
+  });
+  const address = smtpServer.address();
+  if (!address || typeof address === "string")
+    throw new Error("Invalid SMTP address");
+  return address.port;
+}
+
+function stopSmtpFixture(): Promise<void> {
+  if (!smtpServer) return Promise.resolve();
+  return new Promise((resolve, reject) => {
+    smtpServer.close((error) => (error ? reject(error) : resolve()));
+  });
+}
+
+export default defineConfig({
+  name: "dms-mailing-test",
+  cacheFolder: ".antelope/cache",
+  logging: {
+    channelFilter: {
+      "*": "warn",
+    },
+  },
+  modules: {
+    local: {
+      source: {
+        type: "local",
+        path: ".",
+        installCommand: ["pnpm build"],
+      },
+      config: { useHtmlRender: false },
+    },
+    dms: {
+      source: SHARED_MODULE_SOURCES.dms,
+      config: {
+        auth: {
+          jwtSecret: JWT_SECRET,
+        },
+      },
+    },
+    mongodb: {
+      source: SHARED_MODULE_SOURCES.mongodb,
+    },
+    "auth-jwt": {
+      source: SHARED_MODULE_SOURCES["auth-jwt"],
+      config: {
+        secret: JWT_SECRET,
+      },
+    },
+    api: {
+      source: SHARED_MODULE_SOURCES.api,
+      config: {
+        servers: [{ protocol: "http", host: "127.0.0.1", port: API_PORT }],
+      },
+    },
+    "file-storage-local": {
+      source: SHARED_MODULE_SOURCES["file-storage-local"],
+    },
+    nodemailer: {
+      source: SHARED_MODULE_SOURCES.nodemailer,
+      config: {
+        host: SMTP_HOST,
+        port: EPHEMERAL_PORT,
+        secure: false,
+        defaults: { from: TEST_SENDER },
+      },
+    },
+  },
+  test: {
+    folder: process.env.DMS_MAILING_TEST_DIR ?? "dist/test",
+    async setup() {
+      const smtpPort = await startSmtpFixture();
+      mongod = await MongoMemoryReplSet.create({
+        replSet: { count: 1 },
+        binary: { version: MONGO_BINARY_VERSION },
+      });
+      storageDir = await mkdtemp(join(tmpdir(), "dms-mailing-test-storage-"));
+
+      const mongoUrl = mongod.getUri();
+      process.env.TEST_MONGO_URL = mongoUrl;
+      process.env.TEST_API_BASE_URL = `http://127.0.0.1:${API_PORT}`;
+      process.env.TEST_JWT_SECRET = JWT_SECRET;
+
+      return {
+        modules: {
+          mongodb: {
+            config: { url: mongoUrl, database: "dms-mailing-test" },
+          },
+          "file-storage-local": {
+            config: {
+              storagePath: storageDir,
+              baseUrl: `http://127.0.0.1:${API_PORT}`,
+              defaultVisibility: "private",
+            },
+          },
+          nodemailer: {
+            config: { port: smtpPort },
+          },
+        },
+      };
+    },
+    async cleanup() {
+      try {
+        await Promise.all([
+          mongod ? mongod.stop() : Promise.resolve(),
+          stopSmtpFixture(),
+        ]);
+      } finally {
+        if (storageDir) await rm(storageDir, { recursive: true, force: true });
+      }
+    },
+  },
+});

package/src/test/helpers/http.ts

@@ -0,0 +1,23 @@
+import axios, { type AxiosInstance } from "axios";
+
+const DEFAULT_BASE_URL = "http://127.0.0.1:5019";
+
+export function getBaseUrl(): string {
+  return process.env.TEST_API_BASE_URL ?? DEFAULT_BASE_URL;
+}
+
+export function createClient(): AxiosInstance {
+  return axios.create({
+    baseURL: getBaseUrl(),
+    validateStatus: () => true,
+    headers: {
+      "x-antelopejs-namespace": "default",
+    },
+  });
+}
+
+export function authorizedClient(token: string): AxiosInstance {
+  const client = createClient();
+  client.defaults.headers.common.Authorization = `Bearer ${token}`;
+  return client;
+}

package/src/test/helpers/owner.ts

@@ -0,0 +1,37 @@
+import { createClient } from "./http";
+
+const OWNER_EMAIL = "owner@test.local";
+const OWNER_PASSWORD = "TestPassw0rd!";
+const OWNER_NAME = "Test Owner";
+const HTTP_BAD_REQUEST = 400;
+
+export interface OwnerSession {
+  accessToken: string;
+  email: string;
+}
+
+export async function ensureOwnerSession(): Promise<OwnerSession> {
+  const client = createClient();
+  const registration = await client.post("/api/onboarding/register", {
+    name: OWNER_NAME,
+    email: OWNER_EMAIL,
+    password: OWNER_PASSWORD,
+  });
+  const isRegistered = registration.status < HTTP_BAD_REQUEST;
+  const isAlreadyRegistered = registration.status === HTTP_BAD_REQUEST;
+  if (!isRegistered && !isAlreadyRegistered) {
+    throw new Error(
+      `Onboarding failed [${registration.status}]: ${JSON.stringify(registration.data)}`,
+    );
+  }
+  const login = await client.post("/api/auth/login", {
+    email: OWNER_EMAIL,
+    password: OWNER_PASSWORD,
+  });
+  if (login.status >= HTTP_BAD_REQUEST) {
+    throw new Error(
+      `Login failed [${login.status}]: ${JSON.stringify(login.data)}`,
+    );
+  }
+  return { accessToken: login.data.access_token, email: OWNER_EMAIL };
+}

package/src/test/integration/events.test.ts

@@ -0,0 +1,136 @@
+import { expect } from "chai";
+import {
+  clearEmailEventSubscriptions,
+  emailEventTrigger,
+} from "../../automation/email-event-trigger";
+import { authorizedClient } from "../helpers/http";
+import { ensureOwnerSession } from "../helpers/owner";
+
+const HTTP_OK = 200;
+const HTTP_FORBIDDEN = 403;
+const TABLE = "/api/mailing/tables/templates";
+
+interface EventRow {
+  type: string;
+}
+
+describe("[integration] events", () => {
+  it("records a webhook event against the send that carries the provider message id", async () => {
+    const session = await ensureOwnerSession();
+    const client = authorizedClient(session.accessToken);
+    const settings = await client.get("/api/mailing/settings");
+    const created = await client.post(`${TABLE}/new`, {
+      slug: "event-target",
+      name: "Event target",
+      category: "orders",
+    });
+    expect(created.status, JSON.stringify(created.data)).to.equal(HTTP_OK);
+    const sent = await client.post(
+      `/api/mailing/templates/${created.data[0]}/test-send`,
+      { to: ["events@example.test"], locale: "en", data: {} },
+    );
+    expect(sent.status, JSON.stringify(sent.data)).to.equal(HTTP_OK);
+    const sendId = sent.data.results[0].sendId as string;
+
+    const detail = await client.get(`/api/mailing/sends/${sendId}`);
+    const messageId = detail.data.send.providerMessageId as string;
+    expect(messageId, "provider message id").to.be.a("string");
+    expect(messageId.length, "provider message id").to.be.greaterThan(0);
+
+    const hook = await client.post(
+      "/api/mailing/events/manual",
+      { messageId, type: "opened", details: { userAgent: "test" } },
+      { headers: { "x-mailing-webhook-secret": settings.data.webhookSecret } },
+    );
+    expect(hook.status, JSON.stringify(hook.data)).to.equal(HTTP_OK);
+    expect(hook.data.recorded).to.equal(true);
+
+    const after = await client.get(`/api/mailing/sends/${sendId}`);
+    expect(after.data.send.status).to.equal("opened");
+    expect(after.data.send.opens).to.equal(1);
+    expect(after.data.events.map((event: EventRow) => event.type)).to.include(
+      "opened",
+    );
+
+    const rejected = await client.post("/api/mailing/events/manual", {
+      messageId,
+      type: "opened",
+    });
+    expect(rejected.status).to.equal(HTTP_FORBIDDEN);
+  });
+
+  it("records the event even when an automation subscription throws", async () => {
+    const session = await ensureOwnerSession();
+    const client = authorizedClient(session.accessToken);
+    const settings = await client.get("/api/mailing/settings");
+    const created = await client.post(`${TABLE}/new`, {
+      slug: "throwing-subscriber",
+      name: "Throwing subscriber",
+      category: "orders",
+    });
+    expect(created.status, JSON.stringify(created.data)).to.equal(HTTP_OK);
+    const sent = await client.post(
+      `/api/mailing/templates/${created.data[0]}/test-send`,
+      { to: ["throwing@example.test"], locale: "en", data: {} },
+    );
+    expect(sent.status, JSON.stringify(sent.data)).to.equal(HTTP_OK);
+    const sendId = sent.data.results[0].sendId as string;
+    const detail = await client.get(`/api/mailing/sends/${sendId}`);
+    const messageId = detail.data.send.providerMessageId as string;
+
+    await emailEventTrigger.activate({}, () => {
+      throw new Error("subscriber exploded");
+    });
+    try {
+      const hook = await client.post(
+        "/api/mailing/events/manual",
+        { messageId, type: "delivered" },
+        {
+          headers: { "x-mailing-webhook-secret": settings.data.webhookSecret },
+        },
+      );
+      expect(hook.status, JSON.stringify(hook.data)).to.equal(HTTP_OK);
+      expect(hook.data.recorded).to.equal(true);
+    } finally {
+      clearEmailEventSubscriptions();
+    }
+
+    const after = await client.get(`/api/mailing/sends/${sendId}`);
+    expect(after.data.send.status).to.equal("delivered");
+  });
+});
+
+describe("[integration] send event purge", () => {
+  // The retention cron deletes a send's events in one filtered statement. A
+  // wrong predicate there would take another send's history with it, so pin
+  // that it removes exactly one send's rows.
+  it("deletes only the events of the send it targets", async () => {
+    const { GetModel } =
+      await import("@antelopejs/interface-database-decorators");
+    const { DEFAULT_TENANT_ID } =
+      await import("@antelopejs/interface-dms/constants");
+    const { SendEventModel } = await import("../../db");
+    const events = GetModel(SendEventModel, DEFAULT_TENANT_ID);
+
+    const kept = `keep-${Date.now()}`;
+    const purged = `purge-${Date.now()}`;
+    await events.insert({
+      sendId: purged,
+      type: "delivered",
+      at: new Date(),
+      json_details: "{}",
+    });
+    await events.insert({
+      sendId: kept,
+      type: "opened",
+      at: new Date(),
+      json_details: "{}",
+    });
+
+    const removed = await events.deleteBySend(purged);
+
+    expect(removed).to.equal(1);
+    expect(await events.getBySend(purged)).to.have.lengthOf(0);
+    expect(await events.getBySend(kept)).to.have.lengthOf(1);
+  });
+});