@antelopejs/dms-mailing 0.3.4 → 0.4.0

package/src/test/integration/settings.test.ts

@@ -1,128 +0,0 @@
-import { expect } from "chai";
-import { authorizedClient } from "../helpers/http";
-import { ensureOwnerSession } from "../helpers/owner";
-
-const HTTP_OK = 200;
-const HTTP_BAD_REQUEST = 400;
-const DEFAULT_CATEGORY_COUNT = 5;
-const DEFAULT_RETENTION_DAYS = 90;
-const UPDATED_RETENTION_DAYS = 30;
-const INVALID_RETENTION_DAYS = 0;
-
-describe("[integration] settings", () => {
-  it("returns defaults, accepts an update and rejects an invalid retention", async () => {
-    const session = await ensureOwnerSession();
-    const client = authorizedClient(session.accessToken);
-    const initial = await client.get("/api/mailing/settings");
-    expect(initial.status).to.equal(HTTP_OK);
-    expect(initial.data.fallbackLocale).to.equal("en");
-    expect(initial.data.logRetentionDays).to.equal(DEFAULT_RETENTION_DAYS);
-    expect(initial.data.categories).to.have.length(DEFAULT_CATEGORY_COUNT);
-
-    const update = await client.post("/api/mailing/settings", {
-      ...initial.data,
-      fallbackLocale: "fr",
-      logRetentionDays: UPDATED_RETENTION_DAYS,
-      blockOnMissingVariables: true,
-    });
-    expect(update.status).to.equal(HTTP_OK);
-    const after = await client.get("/api/mailing/settings");
-    expect(after.data.fallbackLocale).to.equal("fr");
-    expect(after.data.blockOnMissingVariables).to.equal(true);
-
-    const invalid = await client.post("/api/mailing/settings", {
-      ...after.data,
-      logRetentionDays: INVALID_RETENTION_DAYS,
-    });
-    expect(invalid.status).to.equal(HTTP_BAD_REQUEST);
-
-    // Blanking the secret would leave the unauthenticated event endpoint with
-    // no gate, so the write has to be refused rather than silently accepted.
-    const blankSecret = await client.post("/api/mailing/settings", {
-      ...after.data,
-      webhookSecret: "",
-    });
-    expect(blankSecret.status).to.equal(HTTP_BAD_REQUEST);
-
-    const restored = await client.post("/api/mailing/settings", initial.data);
-    expect(restored.status).to.equal(HTTP_OK);
-  });
-});
-
-const CONCURRENT_READERS = 5;
-const LEGACY_RETENTION_DAYS = 45;
-const LEGACY_SECRET = "l".repeat(48);
-
-async function loadSettingsModules() {
-  const { GetModel } =
-    await import("@antelopejs/interface-database-decorators");
-  const { SettingsModel } = await import("../../db");
-  const settings = await import("../../services/settings");
-  return {
-    ...settings,
-    rowsOf: (tenantId: string) => GetModel(SettingsModel, tenantId).getAll(),
-    insertLegacyRow: (tenantId: string) =>
-      GetModel(SettingsModel, tenantId).insert({
-        fallbackLocale: "en",
-        logRetentionDays: LEGACY_RETENTION_DAYS,
-        blockOnMissingVariables: false,
-        senderName: "",
-        senderEmail: "",
-        replyTo: "",
-        json_categories: "[]",
-        webhookSecret: LEGACY_SECRET,
-      }),
-  };
-}
-
-describe("[integration] settings row per tenant", () => {
-  // Every request path reads the settings, so a tenant's first reads arrive
-  // together. Each used to insert its own default row with its own webhook
-  // secret; the row is now keyed by the tenant id so only one can land.
-  it("creates a single row when first readers race", async () => {
-    const { getSettings, rowsOf } = await loadSettingsModules();
-    const tenantId = `settings-race-${Date.now()}`;
-
-    const reads = await Promise.all(
-      Array.from({ length: CONCURRENT_READERS }, () => getSettings(tenantId)),
-    );
-
-    const rows = await rowsOf(tenantId);
-    expect(rows).to.have.lengthOf(1);
-    expect(rows[0]?._id).to.equal(tenantId);
-    for (const read of reads) {
-      expect(read.webhookSecret).to.equal(rows[0]?.webhookSecret);
-    }
-  });
-
-  it("keeps reading and updating a row written before the key existed", async () => {
-    const { getSettings, saveSettings, rowsOf, insertLegacyRow } =
-      await loadSettingsModules();
-    const tenantId = `settings-legacy-${Date.now()}`;
-    await insertLegacyRow(tenantId);
-
-    const read = await getSettings(tenantId);
-    expect(read.webhookSecret).to.equal(LEGACY_SECRET);
-    await saveSettings(tenantId, {
-      ...read,
-      logRetentionDays: UPDATED_RETENTION_DAYS,
-    });
-
-    const rows = await rowsOf(tenantId);
-    expect(rows).to.have.lengthOf(1);
-    expect(rows[0]?.logRetentionDays).to.equal(UPDATED_RETENTION_DAYS);
-  });
-
-  it("saves a tenant's first settings under the tenant id", async () => {
-    const { getSettings, saveSettings, rowsOf } = await loadSettingsModules();
-    const tenantId = `settings-first-save-${Date.now()}`;
-    const values = await getSettings(`settings-template-${Date.now()}`);
-
-    await saveSettings(tenantId, { ...values, webhookSecret: LEGACY_SECRET });
-
-    const rows = await rowsOf(tenantId);
-    expect(rows).to.have.lengthOf(1);
-    expect(rows[0]?._id).to.equal(tenantId);
-    expect(rows[0]?.webhookSecret).to.equal(LEGACY_SECRET);
-  });
-});

package/src/test/integration/setup.test.ts

@@ -1,35 +0,0 @@
-import { createClient } from "../helpers/http";
-
-const READY_TIMEOUT_MS = 30_000;
-const POLL_INTERVAL_MS = 100;
-const HTTP_OK = 200;
-
-function delay(ms: number): Promise<void> {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-async function waitFor(
-  description: string,
-  check: () => Promise<boolean>,
-): Promise<void> {
-  const deadline = Date.now() + READY_TIMEOUT_MS;
-  while (Date.now() < deadline) {
-    if (await check()) return;
-    await delay(POLL_INTERVAL_MS);
-  }
-  throw new Error(`Timed out waiting for ${description}`);
-}
-
-before(async function () {
-  this.timeout(READY_TIMEOUT_MS + 5_000);
-
-  const client = createClient();
-  await waitFor("the DMS runtime to accept onboarding calls", async () => {
-    try {
-      const response = await client.get("/api/onboarding/informations");
-      return response.status === HTTP_OK;
-    } catch {
-      return false;
-    }
-  });
-});

package/src/test/integration/templates.test.ts

@@ -1,272 +0,0 @@
-import { expect } from "chai";
-import { authorizedClient } from "../helpers/http";
-import { ensureOwnerSession } from "../helpers/owner";
-
-const HTTP_OK = 200;
-const HTTP_BAD_REQUEST = 400;
-const HTTP_NOT_FOUND = 404;
-const HTTP_CONFLICT = 409;
-const TABLE = "/api/mailing/tables/templates";
-
-interface TemplateRow {
-  _id: string;
-  slug: string;
-  status: string;
-  locales: string;
-}
-
-interface BlockRow {
-  type: string;
-}
-
-describe("[integration] templates table", () => {
-  it("creates a blank template with only a footer and lists it", async () => {
-    const session = await ensureOwnerSession();
-    const client = authorizedClient(session.accessToken);
-    const created = await client.post(`${TABLE}/new`, {
-      slug: "order-confirmed",
-      name: "Order confirmed",
-      category: "orders",
-    });
-    expect(created.status, JSON.stringify(created.data)).to.equal(HTTP_OK);
-
-    const list = await client.get(`${TABLE}/list`);
-    expect(list.status).to.equal(HTTP_OK);
-    const row = list.data.results.find(
-      (item: TemplateRow) => item.slug === "order-confirmed",
-    ) as TemplateRow;
-    expect(row.status).to.equal("draft");
-    expect(row.locales).to.equal("en");
-
-    const content = await client.get(
-      `/api/mailing/templates/${row._id}/content`,
-    );
-    expect(content.status).to.equal(HTTP_OK);
-    expect(
-      content.data.content.locales.en.blocks.map(
-        (block: BlockRow) => block.type,
-      ),
-    ).to.deep.equal(["footer"]);
-    expect(content.data.content.locales.en.subject).to.equal("");
-    expect(content.data.variables).to.deep.equal([]);
-  });
-
-  it("creates from an existing template by copying its content", async () => {
-    const session = await ensureOwnerSession();
-    const client = authorizedClient(session.accessToken);
-    const source = await client.post(`${TABLE}/new`, {
-      slug: "copy-source",
-      name: "Copy source",
-      category: "orders",
-    });
-    const sourceId = source.data[0] as string;
-    await client.post(`/api/mailing/templates/${sourceId}/content`, {
-      content: {
-        locales: {
-          en: {
-            subject: "Hello {{customer.firstName}}",
-            preheader: "",
-            blocks: [],
-          },
-        },
-      },
-    });
-    await client.post(`/api/mailing/templates/${sourceId}/variables`, {
-      variables: [
-        { path: "customer.firstName", type: "string", required: true },
-      ],
-    });
-
-    const copy = await client.post(`${TABLE}/new`, {
-      slug: "copy-target",
-      name: "Copy target",
-      sourceTemplateId: sourceId,
-    });
-    expect(copy.status, JSON.stringify(copy.data)).to.equal(HTTP_OK);
-    const content = await client.get(
-      `/api/mailing/templates/${copy.data[0] as string}/content`,
-    );
-    expect(content.data.content.locales.en.subject).to.equal(
-      "Hello {{customer.firstName}}",
-    );
-    expect(content.data.variables).to.deep.equal([
-      { path: "customer.firstName", type: "string", required: true },
-    ]);
-  });
-
-  it("keeps the slug when only the name and category are edited", async () => {
-    const session = await ensureOwnerSession();
-    const client = authorizedClient(session.accessToken);
-    const created = await client.post(`${TABLE}/new`, {
-      slug: "keeps-slug",
-      name: "Keeps slug",
-      category: "orders",
-    });
-    const id = created.data[0] as string;
-    // The data-api `edit` route replaces the writable fields: a body missing
-    // one nulls it. The editor must send the whole writable set.
-    const edited = await client.put(`${TABLE}/edit?id=${id}`, {
-      slug: "keeps-slug",
-      name: "Renamed",
-      category: "billing",
-    });
-    expect(edited.status, JSON.stringify(edited.data)).to.equal(HTTP_OK);
-    const row = await client.get(`${TABLE}/get?id=${id}`);
-    expect(row.data.slug).to.equal("keeps-slug");
-    expect(row.data.name).to.equal("Renamed");
-    expect(row.data.category).to.equal("billing");
-  });
-
-  // Sends resolve a template by slug and only the create paths check it is
-  // free, so an edit must neither move it nor, by omitting it, clear it.
-  it("refuses a slug change on edit and keeps the slug when it is omitted", async () => {
-    const session = await ensureOwnerSession();
-    const client = authorizedClient(session.accessToken);
-    const created = await client.post(`${TABLE}/new`, {
-      slug: "fixed-slug",
-      name: "Fixed slug",
-      category: "orders",
-    });
-    const id = created.data[0] as string;
-
-    const moved = await client.put(`${TABLE}/edit?id=${id}`, {
-      slug: "order-confirmed",
-      name: "Fixed slug",
-      category: "orders",
-    });
-    expect(moved.status).to.equal(HTTP_CONFLICT);
-    expect(JSON.stringify(moved.data)).to.contain("slug_immutable");
-
-    const omitted = await client.put(`${TABLE}/edit?id=${id}`, {
-      name: "Renamed without slug",
-      category: "orders",
-    });
-    expect(omitted.status, JSON.stringify(omitted.data)).to.equal(HTTP_OK);
-    const row = await client.get(`${TABLE}/get?id=${id}`);
-    expect(row.data.slug).to.equal("fixed-slug");
-    expect(row.data.name).to.equal("Renamed without slug");
-
-    const { GetModel } =
-      await import("@antelopejs/interface-database-decorators");
-    const { DEFAULT_TENANT_ID } =
-      await import("@antelopejs/interface-dms/constants");
-    const { TemplateModel } = await import("../../db");
-    await GetModel(TemplateModel, DEFAULT_TENANT_ID).delete(id);
-  });
-
-  it("refuses an unknown source template", async () => {
-    const session = await ensureOwnerSession();
-    const client = authorizedClient(session.accessToken);
-    const created = await client.post(`${TABLE}/new`, {
-      slug: "copy-missing",
-      name: "Copy missing",
-      sourceTemplateId: "does-not-exist",
-    });
-    expect(created.status).to.equal(HTTP_NOT_FOUND);
-    expect(JSON.stringify(created.data)).to.contain("template_not_found");
-  });
-
-  it("rejects a duplicate slug", async () => {
-    const session = await ensureOwnerSession();
-    const client = authorizedClient(session.accessToken);
-    const dup = await client.post(`${TABLE}/new`, {
-      slug: "order-confirmed",
-      name: "Again",
-      category: "orders",
-    });
-    expect(dup.status).to.be.at.least(HTTP_BAD_REQUEST);
-  });
-});
-
-describe("[integration] template content and status", () => {
-  async function createTemplate(
-    client: ReturnType<typeof authorizedClient>,
-    slug: string,
-  ): Promise<string> {
-    const created = await client.post(`${TABLE}/new`, {
-      slug,
-      name: slug,
-      category: "orders",
-    });
-    expect(created.status, JSON.stringify(created.data)).to.equal(HTTP_OK);
-    return created.data[0] as string;
-  }
-
-  it("replaces the content, publishes and duplicates", async () => {
-    const session = await ensureOwnerSession();
-    const client = authorizedClient(session.accessToken);
-    const id = await createTemplate(client, "welcome");
-    const before = await client.get(`/api/mailing/templates/${id}/content`);
-    const content = before.data.content;
-    content.locales.en.subject = "Welcome {{customer.firstName}}";
-    const saved = await client.post(`/api/mailing/templates/${id}/content`, {
-      content,
-    });
-    expect(saved.status, JSON.stringify(saved.data)).to.equal(HTTP_OK);
-    expect(saved.data.saved).to.equal(true);
-
-    const publish = await client.post(
-      `/api/mailing/templates/${id}/publish`,
-      {},
-    );
-    expect(publish.status).to.equal(HTTP_OK);
-    const after = await client.get(`/api/mailing/templates/${id}/content`);
-    expect(after.data.template.status).to.equal("live");
-    expect(after.data.content.locales.en.subject).to.equal(
-      "Welcome {{customer.firstName}}",
-    );
-
-    const variables = await client.post(
-      `/api/mailing/templates/${id}/variables`,
-      {
-        variables: [
-          { path: "customer.firstName", type: "string", required: false },
-        ],
-      },
-    );
-    expect(variables.status).to.equal(HTTP_OK);
-    const testData = await client.post(
-      `/api/mailing/templates/${id}/test-data`,
-      { data: { customer: { firstName: "Sofie" } } },
-    );
-    expect(testData.status).to.equal(HTTP_OK);
-
-    const duplicate = await client.post(
-      `/api/mailing/templates/${id}/duplicate`,
-      { slug: "welcome-copy", name: "Welcome copy" },
-    );
-    expect(duplicate.status, JSON.stringify(duplicate.data)).to.equal(HTTP_OK);
-    const copy = await client.get(
-      `/api/mailing/templates/${duplicate.data.id}/content`,
-    );
-    expect(copy.data.template.status).to.equal("draft");
-    expect(copy.data.content.locales.en.subject).to.equal(
-      "Welcome {{customer.firstName}}",
-    );
-    expect(copy.data.variables).to.have.length(1);
-  });
-
-  it("previews the current content with test data and reports missing variables", async () => {
-    const session = await ensureOwnerSession();
-    const client = authorizedClient(session.accessToken);
-    // Looked up by slug rather than on the table's first page, which other
-    // tests fill with their own templates.
-    const { GetModel } =
-      await import("@antelopejs/interface-database-decorators");
-    const { DEFAULT_TENANT_ID } =
-      await import("@antelopejs/interface-dms/constants");
-    const { TemplateModel } = await import("../../db");
-    const welcome = await GetModel(TemplateModel, DEFAULT_TENANT_ID).getBySlug(
-      "welcome",
-    );
-    const id = welcome?._id as string;
-    const preview = await client.post(`/api/mailing/templates/${id}/preview`, {
-      locale: "en",
-      data: {},
-    });
-    expect(preview.status, JSON.stringify(preview.data)).to.equal(HTTP_OK);
-    expect(preview.data.html).to.include("<!DOCTYPE html>");
-    expect(preview.data.missing).to.include("customer.firstName");
-    expect(preview.data.subject).to.equal("Welcome {{customer.firstName}}");
-  });
-});

package/src/test/integration/tenant-export.test.ts

@@ -1,125 +0,0 @@
-import type { Readable } from "node:stream";
-import { DEFAULT_TENANT_ID } from "@antelopejs/interface-dms/constants";
-import type { TenantExportArchive } from "@antelopejs/interface-dms/hooks";
-import { expect } from "chai";
-import {
-  contributeTenantExport,
-  type ExportedCollection,
-  exportedCollections,
-  jsonArrayChunks,
-} from "../../hooks/tenant-export";
-import { authorizedClient } from "../helpers/http";
-import { ensureOwnerSession } from "../helpers/owner";
-
-const HTTP_OK = 200;
-const TABLE = "/api/mailing/tables/templates";
-const TEMPLATES_ENTRY = "templates.json";
-const SETTINGS_ENTRY = "settings.json";
-const EXPORTED_SLUG = "exported-template";
-const SINGLE_ROW_PAGE = 1;
-const LIST_ALL = 100;
-
-interface TemplateRow {
-  slug: string;
-}
-
-class CollectingArchive implements TenantExportArchive {
-  readonly entries = new Map<string, string>();
-
-  addJson(path: string, data: unknown): Promise<void> {
-    this.entries.set(path, JSON.stringify(data));
-    return Promise.resolve();
-  }
-
-  addFile(path: string): Promise<void> {
-    return Promise.reject(new Error(`Unexpected file entry "${path}"`));
-  }
-
-  async addStream(path: string, stream: Readable): Promise<void> {
-    let text = "";
-    for await (const chunk of stream) text += String(chunk);
-    this.entries.set(path, text);
-  }
-}
-
-function parsed<T>(archive: CollectingArchive, entry: string): T {
-  return JSON.parse(archive.entries.get(entry) as string) as T;
-}
-
-describe("[integration] tenant export", () => {
-  it("streams the mailing data into the archive instead of one blob", async () => {
-    const session = await ensureOwnerSession();
-    const client = authorizedClient(session.accessToken);
-    const created = await client.post(`${TABLE}/new`, {
-      slug: EXPORTED_SLUG,
-      name: "Exported template",
-      category: "orders",
-    });
-    expect(created.status, JSON.stringify(created.data)).to.equal(HTTP_OK);
-
-    const archive = new CollectingArchive();
-    const contribution = await contributeTenantExport(
-      DEFAULT_TENANT_ID,
-      archive,
-      new AbortController().signal,
-    );
-
-    expect(contribution).to.equal(undefined);
-    expect([...archive.entries.keys()]).to.have.members([
-      TEMPLATES_ENTRY,
-      SETTINGS_ENTRY,
-    ]);
-    const templates = parsed<TemplateRow[]>(archive, TEMPLATES_ENTRY);
-    expect(templates.map((template) => template.slug)).to.include(
-      EXPORTED_SLUG,
-    );
-    expect(archive.entries.get(SETTINGS_ENTRY)).to.not.contain("webhookSecret");
-  });
-
-  it("stops contributing when the export is aborted", async () => {
-    const archive = new CollectingArchive();
-    const controller = new AbortController();
-    controller.abort();
-
-    let aborted = false;
-    try {
-      await contributeTenantExport(
-        DEFAULT_TENANT_ID,
-        archive,
-        controller.signal,
-      );
-    } catch {
-      aborted = true;
-    }
-
-    expect(aborted).to.equal(true);
-    expect(archive.entries.size).to.equal(0);
-  });
-
-  it("pages the reads without skipping or repeating a row", async () => {
-    const session = await ensureOwnerSession();
-    const client = authorizedClient(session.accessToken);
-    // The list answers 10 rows unless told otherwise; the export reads them all.
-    const list = await client.get(`${TABLE}/list?limit=${LIST_ALL}`);
-    expect(list.status, JSON.stringify(list.data)).to.equal(HTTP_OK);
-    const slugs = (list.data.results as TemplateRow[]).map(
-      (template) => template.slug,
-    );
-    const [templates] = exportedCollections(DEFAULT_TENANT_ID);
-
-    let text = "";
-    for await (const chunk of jsonArrayChunks(
-      (templates as ExportedCollection).load,
-      new AbortController().signal,
-      SINGLE_ROW_PAGE,
-    )) {
-      text += chunk;
-    }
-
-    const paged = (JSON.parse(text) as TemplateRow[]).map(
-      (template) => template.slug,
-    );
-    expect(paged).to.have.members(slugs);
-    expect(new Set(paged).size).to.equal(paged.length);
-  });
-});

package/src/test/unit/attention.test.ts

@@ -1,129 +0,0 @@
-import { expect } from "chai";
-import type { MailingSend, MailingTemplate } from "../../db";
-import {
-  type AttentionItem,
-  buildAttentionItems,
-} from "../../services/attention";
-
-const send = (isTest: boolean): MailingSend =>
-  ({ status: "sent", templateSlug: "welcome", isTest }) as MailingSend;
-
-const NO_TEMPLATES: MailingTemplate[] = [];
-
-const findExcluded = (items: AttentionItem[]) =>
-  items.find((item) => item.id === "test-only-window");
-
-describe("[unit] services/attention test-only window", () => {
-  it("explains the empty figures when every send in the window is a test", () => {
-    const items = buildAttentionItems({
-      templates: NO_TEMPLATES,
-      sends: [],
-      excluded: [send(true), send(true)],
-      tracking: null,
-    });
-    const item = findExcluded(items);
-    expect(item).to.not.equal(undefined);
-    expect(item).to.deep.include({
-      tone: "neutral",
-      title: "$dms_mailing.attention.test_only_window.title",
-      description: "$dms_mailing.attention.test_only_window.description",
-    });
-    expect(item?.params).to.deep.equal({ count: 2 });
-  });
-
-  it("stays quiet when the window holds real sends too", () => {
-    const items = buildAttentionItems({
-      templates: NO_TEMPLATES,
-      sends: [send(false)],
-      excluded: [send(true)],
-      tracking: null,
-    });
-    expect(findExcluded(items)).to.equal(undefined);
-  });
-
-  it("stays quiet when the window is genuinely empty", () => {
-    const items = buildAttentionItems({
-      templates: NO_TEMPLATES,
-      sends: [],
-      excluded: [],
-      tracking: null,
-    });
-    expect(findExcluded(items)).to.equal(undefined);
-  });
-});
-
-const findUntracked = (items: AttentionItem[]) =>
-  items.find((item) => item.id === "untracked-rates");
-
-const TRACKS_NOTHING = {
-  name: "smtp",
-  openTracking: false,
-  clickTracking: false,
-};
-const TRACKS_EVERYTHING = {
-  name: "postmark",
-  openTracking: true,
-  clickTracking: true,
-};
-
-describe("[unit] services/attention untracked rates", () => {
-  it("explains the flat rates when the provider reports neither opens nor clicks", () => {
-    const items = buildAttentionItems({
-      templates: NO_TEMPLATES,
-      sends: [send(false)],
-      excluded: [],
-      tracking: TRACKS_NOTHING,
-    });
-    const item = findUntracked(items);
-    expect(item).to.not.equal(undefined);
-    expect(item).to.deep.include({
-      tone: "neutral",
-      title: "$dms_mailing.attention.untracked_rates.title",
-      description: "$dms_mailing.attention.untracked_rates.description",
-    });
-    expect(item?.params).to.deep.equal({ provider: "smtp" });
-  });
-
-  it("stays quiet when the provider tracks both", () => {
-    const items = buildAttentionItems({
-      templates: NO_TEMPLATES,
-      sends: [send(false)],
-      excluded: [],
-      tracking: TRACKS_EVERYTHING,
-    });
-    expect(findUntracked(items)).to.equal(undefined);
-  });
-
-  it("still fires when only one of the two is tracked, since a rate stays flat", () => {
-    const items = buildAttentionItems({
-      templates: NO_TEMPLATES,
-      sends: [send(false)],
-      excluded: [],
-      tracking: { ...TRACKS_NOTHING, openTracking: true },
-    });
-    expect(findUntracked(items)).to.not.equal(undefined);
-  });
-
-  // The notice explains figures the window actually shows. With nothing sent
-  // there are no rates on screen to explain, and it would just be noise.
-  it("stays quiet when the window holds no send at all", () => {
-    const items = buildAttentionItems({
-      templates: NO_TEMPLATES,
-      sends: [],
-      excluded: [],
-      tracking: TRACKS_NOTHING,
-    });
-    expect(findUntracked(items)).to.equal(undefined);
-  });
-
-  // The provider may be unreachable; that is the provider card's business.
-  it("stays quiet when the provider capabilities are unknown", () => {
-    const items = buildAttentionItems({
-      templates: NO_TEMPLATES,
-      sends: [send(false)],
-      excluded: [],
-      tracking: null,
-    });
-    expect(findUntracked(items)).to.equal(undefined);
-  });
-});