@omega.js/backend 0.1.0

package/test/events/notification-conversion.test.js

@@ -0,0 +1,182 @@
+/**
+ * Test: the notification subscribe/unsubscribe events are CANONICAL conversions
+ * ([#328](https://github.com/Omega-JS-Stack/omega/issues/328)).
+ *
+ * The handler used to reach `Manager.Analytics(...).event()` directly with
+ * hyphenated names of its own invention — `notification-subscribe` and
+ * `notification-unsubscribe`, which appear in no catalog and therefore in no
+ * other surface's vocabulary. Both now go through `deliverConversion`, which is
+ * what gives them the three things the raw call had none of: the catalog's
+ * name, the consent gate, and the per-provider walk (GA4 only, by catalog
+ * design — no ad platform maps a push subscription).
+ *
+ * THE DEDUPE ID IS `<event>.<token>`. The doc id IS the push token, and it is
+ * the only stable key this doc has: `owner` is null on an anonymous subscribe,
+ * so a uid-derived id would collapse every anonymous device onto one id.
+ *
+ * Real handler, real Manager, real ctx, real Firestore counter write. The
+ * `change` pair is built by hand — the trigger's own shape — so no notification
+ * doc has to exist for the branch under test.
+ *
+ * Run: npx omega test framework:events/notification-conversion
+ */
+const onWrite = require('../../dist/manager/events/firestore/notifications/on-write.js');
+const defineCases = require('../../dist/vendor/devkit/test/define-cases.js');
+
+const TOKEN = '_test-notification-conversion-token';
+
+const EVENT_CONTEXT = {
+  resource: { service: 'firestore.googleapis.com' },
+  params: { token: TOKEN },
+};
+
+// A subscription doc in the shape the client writes it.
+function subscriptionDoc({ owner = null, attribution } = {}) {
+  return {
+    token: TOKEN,
+    owner: owner,
+    tags: ['general'],
+    attribution: attribution,
+    context: { client: {} },
+  };
+}
+
+/** The Change pair the Firestore trigger hands the handler. */
+function change({ before, after }) {
+  return {
+    before: { data: () => before },
+    after: { data: () => after },
+  };
+}
+
+// Record every console call the handler makes, restoring console afterward.
+async function withConsoleRecorder(fn) {
+  const calls = { log: [], debug: [], error: [] };
+  const original = { log: console.log, debug: console.debug, error: console.error };
+
+  console.log = (...args) => calls.log.push(args);
+  console.debug = (...args) => calls.debug.push(args);
+  console.error = (...args) => calls.error.push(args);
+
+  try {
+    await fn();
+    return calls;
+  } finally {
+    console.log = original.log;
+    console.debug = original.debug;
+    console.error = original.error;
+  }
+}
+
+/** Run the real handler for one change pair; hand back its delivery lines. */
+async function runHandler({ Manager, before, after }) {
+  const ctx = Manager.RouteContext({}, { functionName: 'omega_notificationsOnWrite' });
+  const admin = Manager.libraries.admin;
+
+  const calls = await withConsoleRecorder(async () => {
+    await onWrite({
+      Manager: Manager,
+      ctx: ctx,
+      change: change({ before: before, after: after }),
+      context: EVENT_CONTEXT,
+      libraries: { admin: admin },
+    });
+  });
+
+  const delivery = calls.log
+    .map((args) => String(args[1]))
+    .filter((line) => line.startsWith('deliverConversion: '));
+
+  return { calls: calls, delivery: delivery };
+}
+
+module.exports = defineCases({
+  description: 'notifications:on-write fires canonical notification conversions',
+  type: 'group',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'a-new-subscription-fires-the-canonical-notification-subscribe',
+      async run({ assert, Manager }) {
+        const { delivery } = await runHandler({
+          Manager: Manager,
+          before: undefined,
+          after: subscriptionDoc({ owner: '_test-notification-owner' }),
+        });
+
+        assert.equal(delivery.length, 1, `expected one conversion delivery, got ${delivery.length}: ${delivery.join(' | ')}`);
+        assert.equal(delivery[0].startsWith('deliverConversion: notification_subscribe →'), true, `the canonical catalog name, not the hyphenated invention: ${delivery[0]}`);
+        assert.equal(delivery[0].includes(`(event_id=notification_subscribe.${TOKEN})`), true, `the token is the stable per-doc key: ${delivery[0]}`);
+
+        // GA4 only — no ad platform maps a push subscription, and an unmapped
+        // provider is a decision the catalog makes, not an event to invent.
+        for (const provider of ['meta', 'tiktok']) {
+          assert.equal(delivery[0].includes(`${provider} skipped (no mapping)`), true, `${provider} has no mapping for this event: ${delivery[0]}`);
+        }
+      },
+    },
+
+    {
+      name: 'a-deleted-subscription-fires-the-canonical-notification-unsubscribe',
+      async run({ assert, Manager }) {
+        const { delivery } = await runHandler({
+          Manager: Manager,
+          before: subscriptionDoc({ owner: '_test-notification-owner' }),
+          after: undefined,
+        });
+
+        assert.equal(delivery.length, 1, `expected one conversion delivery, got ${delivery.length}: ${delivery.join(' | ')}`);
+        assert.equal(delivery[0].startsWith('deliverConversion: notification_unsubscribe →'), true, `the canonical catalog name: ${delivery[0]}`);
+        assert.equal(delivery[0].includes(`(event_id=notification_unsubscribe.${TOKEN})`), true, `the token keys the unsubscribe too: ${delivery[0]}`);
+      },
+    },
+
+    {
+      name: 'an-update-fires-nothing',
+      async run({ assert, Manager }) {
+        // Re-tagging a device is not a subscription event. The handler returns
+        // at its update branch, before any tracking.
+        const { delivery } = await runHandler({
+          Manager: Manager,
+          before: subscriptionDoc(),
+          after: subscriptionDoc({ owner: '_test-notification-owner' }),
+        });
+
+        assert.equal(delivery.length, 0, `an update must fire no conversion: ${delivery.join(' | ')}`);
+      },
+    },
+
+    {
+      name: 'an-anonymous-subscribe-still-fires-and-still-keys-on-the-token',
+      async run({ assert, Manager }) {
+        // `owner: null` is the anonymous-subscribe shape the rules explicitly
+        // allow. There is no uid to key on and no identity to match — which is
+        // exactly why the doc id is the id.
+        const { delivery } = await runHandler({
+          Manager: Manager,
+          before: undefined,
+          after: subscriptionDoc({ owner: null }),
+        });
+
+        assert.equal(delivery.length, 1, `an anonymous device is still a subscription: ${delivery.join(' | ')}`);
+        assert.equal(delivery[0].includes(`(event_id=notification_subscribe.${TOKEN})`), true, delivery[0]);
+      },
+    },
+
+    {
+      name: 'a-declined-analytics-snapshot-blocks-the-fire',
+      async run({ assert, Manager }) {
+        // The gate is the whole point of routing through deliverConversion: a
+        // raw Manager.Analytics call asked nobody anything.
+        const doc = subscriptionDoc({ owner: '_test-notification-owner' });
+        doc.trackingConsent = { analytics: false, marketing: false, region: 'opt-in', version: 1 };
+
+        const { delivery } = await runHandler({ Manager: Manager, before: undefined, after: doc });
+
+        assert.equal(delivery.length, 1, delivery.join(' | '));
+        assert.equal(delivery[0].includes('ga4 skipped (consent: analytics)'), true, `an opted-out device reaches no platform: ${delivery[0]}`);
+      },
+    },
+  ],
+});

package/test/events/payments/_webhook-harness.js

@@ -0,0 +1,307 @@
+/**
+ * Shared harness for the PLAIN-NODE webhook-pipeline suites (no emulator, no
+ * network): the real payments-webhooks trigger run against a minimal in-memory
+ * Firestore stand-in.
+ *
+ * The stand-in is the honest layer for these cases. The emulator cannot produce
+ * a mid-batch write fault at all (the admin SDK bypasses rules, every write is
+ * legal), and it cannot hand one test a user doc seeded into an exact prior
+ * state without minting a persona and a payment history per permutation. The
+ * emulator suites stay the integration surface for the happy paths.
+ *
+ * `_`-prefixed, so the runner never discovers it as a suite.
+ */
+const onWrite = require('../../../dist/manager/events/firestore/payments-webhooks/on-write.js');
+
+// A contended transaction re-runs; a stand-in that re-ran forever would hang a suite
+// instead of failing it. Firestore's own client gives up too.
+const MAX_TRANSACTION_ATTEMPTS = 5;
+
+// The brand config the transformers read products out of
+const CONFIG = {
+  payment: {
+    products: [
+      { id: 'basic', name: 'Basic', type: 'subscription' },
+      { id: 'premium', name: 'Premium', type: 'subscription', prices: { monthly: 4.99 }, stripe: { productId: '_test_premium' } },
+    ],
+  },
+};
+
+/**
+ * Minimal in-memory Firestore stand-in: the doc reads/writes, the collection query
+ * the test provider's fetchResource() makes, and the write batch. `failPath` is the
+ * document path whose write rejects — mid-batch in the real world, before anything
+ * lands once the writes are batched.
+ *
+ * `authUids` is the project's auth store: the pipeline asks it whether a uid is one
+ * of ours before it will create a user doc ([#399]).
+ *
+ * @param {object} options
+ * @param {object} options.seed - Document path → data, the state the run starts from
+ * @param {string|function|null} options.failPath - The document path whose write rejects, or a
+ *   `(path, data) => boolean` predicate for a fault that depends on WHICH write it is
+ *   (the refusal stamp and the failure stamp land on the same doc — [#535])
+ * @param {string[]} options.authUids - The uids that have a Firebase auth user
+ * @param {function|null} options.onRead - Called with (path, { store, write }) the moment
+ *   ANY read of a document resolves, transactional or not — the seam a suite writes
+ *   THROUGH, to put a contending write exactly in the window between a read and the
+ *   write that acts on it. Deliberately not transaction-only: a suite proving a
+ *   read-then-write race must be able to reproduce the race against the racy shape too
+ * @returns {{ admin: object, store: Map }}
+ */
+function buildAdmin({ seed = {}, failPath = null, authUids = [], onRead = null } = {}) {
+  const store = new Map(Object.entries(seed));
+  const shouldFail = typeof failPath === 'function' ? failPath : (path) => path === failPath;
+
+  // Per-document write counter — the stand-in's version stamp, so a transaction can
+  // tell "nobody touched this since I read it" from "somebody did"
+  const versions = new Map();
+
+  const write = (path, data, options) => {
+    if (shouldFail(path, data)) {
+      throw new Error(`Firestore write to ${path} failed`);
+    }
+
+    store.set(path, options?.merge ? merge(store.get(path) || {}, data) : data);
+    versions.set(path, (versions.get(path) || 0) + 1);
+  };
+
+  // A read is a POINT-IN-TIME snapshot, captured before the seam below can move the
+  // store — anything else would hand a racy read-then-write the winner's data and
+  // hide the very race a suite is trying to reproduce.
+  const read = async (path) => {
+    const captured = store.get(path);
+    const snapshot = { exists: store.has(path), data: () => captured };
+
+    if (onRead) {
+      await onRead(path, { store, write });
+    }
+
+    return snapshot;
+  };
+
+  const doc = (path) => ({
+    path,
+    get: async () => read(path),
+    set: async (data, options) => write(path, data, options),
+  });
+
+  const query = (collection, filters) => ({
+    where: (field, op, value) => query(collection, [...filters, { field, op, value }]),
+    limit: () => query(collection, filters),
+    get: async () => {
+      const paths = [...store.keys()]
+        .filter(path => path.startsWith(`${collection}/`))
+        .filter(path => filters.every(f => matches(fieldValue(store.get(path), f.field), f.op, f.value)));
+
+      return {
+        empty: paths.length === 0,
+        size: paths.length,
+        docs: paths.map(path => ({
+          id: path.split('/').pop(),
+          ref: doc(path),
+          data: () => store.get(path),
+        })),
+      };
+    },
+  });
+
+  const admin = {
+    auth: () => ({
+      getUser: async (uid) => {
+        if (!authUids.includes(uid)) {
+          // The admin SDK's own not-found shape — the code branches on the code
+          const error = new Error(`There is no user record corresponding to the provided identifier.`);
+          error.code = 'auth/user-not-found';
+          throw error;
+        }
+
+        return { uid: uid };
+      },
+    }),
+    firestore: () => ({
+      doc,
+      collection: (name) => query(name, []),
+      batch: () => {
+        const staged = [];
+
+        return {
+          set: (ref, data, options) => staged.push([ref.path, data, options]),
+          commit: async () => {
+            // A real batch is atomic: one rejected write means none of them landed
+            for (const [path, data] of staged) {
+              if (shouldFail(path, data)) {
+                throw new Error(`Firestore batch write to ${path} failed`);
+              }
+            }
+
+            staged.forEach(args => write(...args));
+          },
+        };
+      },
+      runTransaction: async (body) => {
+        // Firestore's actual contract, which is the whole point of the caller
+        // using one: reads are versioned, writes are staged, and if any document
+        // the block READ changed before the commit, the block RE-RUNS against the
+        // new state. Modelled here rather than assumed — a guard-then-write that
+        // is only atomic because nothing raced it proves nothing.
+        for (let attempt = 0; attempt < MAX_TRANSACTION_ATTEMPTS; attempt++) {
+          const versionsRead = new Map();
+          const staged = [];
+
+          const result = await body({
+            get: async (ref) => {
+              versionsRead.set(ref.path, versions.get(ref.path) || 0);
+              return read(ref.path);
+            },
+            set: (ref, data, options) => staged.push([ref.path, data, options]),
+          });
+
+          const contended = [...versionsRead].some(([path, version]) => (versions.get(path) || 0) !== version);
+
+          if (contended) {
+            continue;
+          }
+
+          staged.forEach(args => write(...args));
+
+          return result;
+        }
+
+        throw new Error('Firestore transaction failed after too many contended attempts');
+      },
+    }),
+  };
+
+  return { admin, store };
+}
+
+/** Firestore addresses nested fields with a dotted path — `subscription.status` */
+function fieldValue(data, field) {
+  return field.split('.').reduce((node, key) => (node == null ? undefined : node[key]), data);
+}
+
+/** The query operators the suites here filter on */
+function matches(value, op, expected) {
+  if (op === '>=') { return value >= expected; }
+  if (op === '<=') { return value <= expected; }
+  if (op === '>') { return value > expected; }
+  if (op === '<') { return value < expected; }
+
+  return value === expected;
+}
+
+/** Deep-merge for the stand-in's `{ merge: true }` writes (metadata nests one level) */
+function merge(existing, data) {
+  const result = { ...existing };
+
+  for (const [key, value] of Object.entries(data)) {
+    result[key] = value && typeof value === 'object' && !Array.isArray(value)
+      ? merge(existing[key] || {}, value)
+      : value;
+  }
+
+  return result;
+}
+
+/**
+ * A Stripe-shaped active subscription — the test provider's payload shape
+ *
+ * @param {object} options - uid, orderId, resourceId
+ * @returns {object}
+ */
+function subscriptionPayload({ uid, orderId, resourceId }) {
+  const nowUNIX = Math.floor(Date.now() / 1000);
+
+  return {
+    id: resourceId,
+    object: 'subscription',
+    status: 'active',
+    metadata: { uid: uid, orderId: orderId },
+    cancel_at_period_end: false,
+    current_period_start: nowUNIX,
+    current_period_end: nowUNIX + 86400,
+    start_date: nowUNIX,
+    plan: { product: '_test_premium', interval: 'month' },
+  };
+}
+
+/**
+ * Run the real trigger over a pending webhook doc against the stand-in
+ *
+ * @param {object} options
+ * @param {string} options.uid - The subscriber the event belongs to
+ * @param {string} options.orderId - The order the event writes
+ * @param {string} options.resourceId - The subscription the event is about
+ * @param {string} options.eventId - The webhook doc id
+ * @param {string} options.eventType - The provider's event name
+ * @param {string} options.resourceType - The parsed event's resource type (a subscription-category event can ride an invoice or sale resource)
+ * @param {string} options.category - The parsed event's category ('subscription' | 'one-time')
+ * @param {object|null} options.payload - The resource the webhook envelope carries (defaults to an active subscription)
+ * @param {object|null} options.raw - The whole envelope, for a provider that nests its resource
+ *   somewhere other than Stripe's `data.object` (PayPal `resource`, Chargebee `content.<type>`)
+ * @param {string|null} options.refundId - The refund's own id, as the parser threads it ([#510])
+ * @param {object} options.seed - Extra documents the run starts from
+ * @param {string|function|null} options.failPath - The document path whose write rejects, or a
+ *   `(path, data) => boolean` predicate
+ * @param {string[]} [options.authUids] - The uids that have a Firebase auth user (default: the subscriber, as every real one does)
+ * @param {boolean} [options.reporting] - Whether a Sentry handle is configured at all (false = no DSN, `libraries.sentry` is null)
+ * @param {string} [options.provider] - The provider library the event loads (default: the test provider; a real one lets a suite stub its API at the transport boundary)
+ * @param {number|null} [options.receivedUNIX] - The second the event ARRIVED (`metadata.created`), which is the staleness clock the pipeline compares against the order
+ * @param {boolean} [options.previouslyCompleted] - Whether this doc already completed once (a redelivery, or the retry sweep re-flipping it)
+ * @returns {Promise<{ store: Map, logs: string[], captures: object[] }>}
+ */
+async function runTrigger({ uid, orderId, resourceId, eventId, eventType = 'customer.subscription.updated', resourceType = 'subscription', category = 'subscription', payload = null, raw = null, refundId = null, seed = {}, failPath = null, authUids = null, reporting = true, provider = 'test', receivedUNIX = null, previouslyCompleted = false } = {}) {
+  const resource = payload || subscriptionPayload({ uid, orderId, resourceId });
+  const envelope = raw || { id: eventId, type: eventType, data: { object: resource } };
+  const webhookDoc = {
+    id: eventId,
+    provider: provider,
+    status: 'pending',
+    raw: envelope,
+    owner: uid,
+    event: { type: eventType, category: category, resourceType: resourceType, resourceId: resourceId, refundId: refundId },
+    metadata: { created: { timestampUNIX: receivedUNIX || Math.floor(Date.now() / 1000) } },
+  };
+
+  const { admin, store } = buildAdmin({
+    seed: { [`payments-webhooks/${eventId}`]: webhookDoc, ...seed },
+    failPath: failPath,
+    authUids: authUids || [uid],
+  });
+
+  const logs = [];
+
+  // The error reporter is an external SINK, recorded rather than run — the same
+  // treatment the route harness gives `res`. `libraries.sentry` IS the backend's
+  // one capture handle (helpers/context/respond.js reads exactly this), and it is
+  // null whenever no DSN is configured, which `reporting: false` reproduces.
+  const captures = [];
+  const sentry = reporting
+    ? { captureMessage: (message, context) => captures.push({ message, ...context }) }
+    : null;
+
+  const Manager = { config: CONFIG, libraries: { admin, sentry } };
+  const ctx = {
+    Manager,
+    isTesting: () => true,
+    log: (...args) => logs.push(args.join(' ')),
+    warn: (...args) => logs.push(args.join(' ')),
+    error: (...args) => logs.push(args.join(' ')),
+  };
+
+  // `before` is what the trigger reads to decide a doc is being REPROCESSED — a
+  // redelivery, or the retry sweep putting a failed doc back to pending. Same doc
+  // by default (no prior completion), the completed shape when a suite asks.
+  const before = previouslyCompleted ? { ...webhookDoc, status: 'completed' } : webhookDoc;
+
+  await onWrite({
+    ctx,
+    change: { before: { data: () => before }, after: { data: () => webhookDoc } },
+    context: { params: { eventId: eventId } },
+  });
+
+  return { store, logs, captures };
+}
+
+module.exports = { CONFIG, buildAdmin, merge, subscriptionPayload, runTrigger };

package/test/events/payments/abandoned-cart-activity.test.js

@@ -0,0 +1,135 @@
+/**
+ * Test: a cart with checkout activity inside its window is not abandoned
+ * ([#655](https://github.com/Omega-JS-Stack/omega/issues/655)).
+ *
+ * Seen in the playground logs: the sweep mailed "Complete your … checkout" at
+ * 01:50:28Z, the intent POST followed at 01:52:54Z and the purchase completed at
+ * 01:53:35Z. The cart's reminder clock was set ONCE, when the checkout page
+ * opened, and nothing ever moved it — so a shopper still working through the
+ * checkout was nudged about the cart they were paying for.
+ *
+ * The signal is the intent route's own: asking for a provider session is the
+ * loudest "I am buying this right now" the backend ever hears, and it stamps
+ * `lastActivityAt` on the cart. The sweep restarts the current reminder's clock
+ * from that touch instead of mailing.
+ *
+ * Plain-node: the real cron against the webhook suites' in-memory Firestore
+ * stand-in, with the email library RECORDED (it is an external sink).
+ *
+ * Run: npx omega test backend:events/payments/abandoned-cart-activity
+ */
+const sweep = require('../../../dist/manager/events/cron/frequent/abandoned-carts.js');
+const { REMINDER_DELAYS, COLLECTION } = require('../../../dist/manager/libraries/abandoned-cart-config.js');
+const { buildAdmin, CONFIG } = require('./_webhook-harness.js');
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+
+const UID = '_test-abandoned-cart-activity-uid';
+
+/** A pending cart whose first reminder is due right now */
+function dueCart(extra) {
+  const nowUNIX = Math.floor(Date.now() / 1000);
+
+  return {
+    id: UID,
+    owner: UID,
+    status: 'pending',
+    productId: 'premium',
+    type: 'subscription',
+    frequency: 'monthly',
+    reminderIndex: 0,
+    nextReminderAt: nowUNIX - 5,
+    ...(extra || {}),
+  };
+}
+
+/**
+ * Run the real sweep over one seeded cart
+ *
+ * @param {object} cart - The payments-carts document
+ * @returns {Promise<{ store: Map, logs: string[], sent: object[] }>}
+ */
+async function runSweep(cart) {
+  const { admin, store } = buildAdmin({
+    seed: {
+      [`${COLLECTION}/${UID}`]: cart,
+      [`users/${UID}`]: { auth: { uid: UID, email: 'shopper@test.dev' }, subscription: { product: { id: 'basic' }, status: 'active' } },
+    },
+    authUids: [UID],
+  });
+
+  const logs = [];
+  const sent = [];
+  const Manager = {
+    config: { ...CONFIG, brand: { name: 'Test Brand' } },
+    project: { websiteUrl: 'https://test.dev' },
+    libraries: { admin },
+    Email: () => ({ send: async (payload) => { sent.push(payload); return { status: 'sent' }; } }),
+  };
+  const ctx = {
+    Manager,
+    isTesting: () => true,
+    log: (...args) => logs.push(args.join(' ')),
+    warn: (...args) => logs.push(args.join(' ')),
+    error: (...args) => logs.push(args.join(' ')),
+  };
+
+  await sweep({ Manager, ctx, context: {}, libraries: { admin } });
+
+  return { store, logs, sent };
+}
+
+module.exports = defineCases({
+  description: 'Abandoned-cart sweep: checkout activity inside the window defers the reminder',
+  type: 'group',
+  timeout: 15000,
+
+  tests: [
+    {
+      name: 'a-cart-whose-checkout-just-started-is-never-mailed',
+      async run({ assert }) {
+        const nowUNIX = Math.floor(Date.now() / 1000);
+
+        // The shopper asked for a session a minute ago and is at the provider's
+        // page right now — which is exactly the state that got mailed.
+        const { store, sent, logs } = await runSweep(dueCart({ lastActivityAt: nowUNIX - 60 }));
+
+        assert.equal(sent.length, 0, `A shopper mid-checkout owes no nudge, got ${sent.length}: ${logs.join(' | ')}`);
+
+        const cart = store.get(`${COLLECTION}/${UID}`);
+
+        assert.equal(cart.status, 'pending', 'The cart is still open — deferring is not completing it');
+        assert.equal(cart.reminderIndex, 0, 'And it did not spend a reminder it never sent');
+        assert.equal(
+          cart.nextReminderAt,
+          (nowUNIX - 60) + REMINDER_DELAYS[0],
+          'The reminder clock restarts from the activity, so the same window is measured from the last touch',
+        );
+      },
+    },
+
+    {
+      name: 'a-cart-whose-activity-has-gone-quiet-is-still-mailed',
+      async run({ assert }) {
+        const nowUNIX = Math.floor(Date.now() / 1000);
+
+        // A checkout started and went nowhere: past the window, this IS the
+        // abandonment the sweep exists for.
+        const { sent } = await runSweep(dueCart({ lastActivityAt: nowUNIX - REMINDER_DELAYS[0] - 60 }));
+
+        assert.equal(sent.length, 1, `A cart quiet longer than the window is abandoned, got ${sent.length}`);
+        assert.equal(sent[0].data.content.event, 'abandoned-cart', 'And it is the abandoned-cart mail that goes out');
+      },
+    },
+
+    {
+      name: 'a-cart-that-never-reached-a-checkout-is-mailed-as-before',
+      async run({ assert }) {
+        // Every cart written before this stamp existed carries no activity at
+        // all — the sweep must read that as "nothing happened", not as "just now"
+        const { sent } = await runSweep(dueCart());
+
+        assert.equal(sent.length, 1, `An untouched cart is the ordinary abandoned one, got ${sent.length}`);
+      },
+    },
+  ],
+});