@omega.js/backend 0.1.0

package/test/events/payments/journey-payments-winback-decline.test.js

@@ -0,0 +1,171 @@
+/**
+ * Test: Payment Journey - Declined win-back
+ * Simulates: fully cancelled paid subscriber → checkout with simulate: 'decline'
+ *            → suspended
+ *
+ * One branch past #218's win-back gap: a full cancellation leaves the PAID product
+ * id on the user doc, so a returning subscriber whose payment DECLINES arrives as
+ * cancelled paid → suspended — which matched none of the nine transition rules.
+ * The webhook completed silently: no transition, no log, no analytics
+ * ([#223](https://github.com/Omega-JS-Stack/omega/issues/223)).
+ *
+ * The caller is this suite's own seeded persona, driven through the shared route
+ * harness: the ACCOUNT is declared in the seed roster (#406) and the starting
+ * state (a cancelled subscription) is a SHAPE this suite writes onto it, because
+ * the seed only makes healthy steady-state accounts. Everything downstream of
+ * the handler — the test provider's declined checkout, both webhook docs, the
+ * on-write trigger, the transition detection, the user-doc write — is the real
+ * pipeline.
+ *
+ * Product-agnostic: resolves the first paid product from config.payment.products
+ *
+ * Run: npx omega test framework:events/payments/journey-payments-winback-decline
+ */
+const { buildUser, callHandler } = require('../../routes/payments/_route-harness.js');
+
+const handler = require('../../../dist/manager/routes/payments/intent/post.js');
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+
+// The suite's own seeded persona ([#406](https://github.com/Omega-JS-Stack/omega/issues/406)):
+// exclusive to this suite and declared in the seed roster, so the account it
+// drives exists — auth user and doc in sync — before the run starts.
+const PERSONA = 'journey-payments-winback-decline';
+const RESOURCE_ID = 'sub_test_journey_winback_decline_cancelled';
+
+module.exports = defineCases({
+  description: 'Payment journey: cancelled subscriber resubscribes and is declined → checkout-declined',
+  type: 'suite',
+  timeout: 60000,
+
+  tests: [
+    {
+      name: 'setup-cancelled-subscriber',
+      async run({ accounts, firestore, assert, state, config, skip }) {
+        const paidProduct = (config.payment?.products || []).find((p) => p.id !== 'basic' && p.type === 'subscription' && p.prices);
+
+        if (!paidProduct) {
+          skip('No paid subscription product configured in this brand');
+        }
+
+        const frequency = Object.keys(paidProduct.prices)[0];
+        const nowUNIX = Math.floor(Date.now() / 1000);
+        const cancelledUNIX = nowUNIX - (7 * 86400);
+        const startUNIX = nowUNIX - (365 * 86400);
+
+        state.uid = accounts[PERSONA].uid;
+        state.email = accounts[PERSONA].email;
+        state.productId = paidProduct.id;
+        state.frequency = frequency;
+
+        // The starting state: cancelled outright a week ago, still carrying the paid
+        // product id — what subscription-cancelled leaves behind.
+        state.subscription = {
+          product: { id: paidProduct.id, name: paidProduct.name || paidProduct.id },
+          status: 'cancelled',
+          expires: { timestamp: new Date(cancelledUNIX * 1000).toISOString(), timestampUNIX: cancelledUNIX },
+          trial: { claimed: false },
+          cancellation: {
+            pending: false,
+            date: { timestamp: new Date(cancelledUNIX * 1000).toISOString(), timestampUNIX: cancelledUNIX },
+          },
+          payment: {
+            provider: 'test',
+            orderId: null,
+            resourceId: RESOURCE_ID,
+            frequency: frequency,
+            price: paidProduct.prices[frequency],
+            startDate: { timestamp: new Date(startUNIX * 1000).toISOString(), timestampUNIX: startUNIX },
+          },
+        };
+
+        // The pipeline reads users/{uid} for its BEFORE state, so the doc has to be
+        // the real record the transition is detected against.
+        await firestore.set(`users/${state.uid}`, {
+          auth: { uid: state.uid, email: state.email },
+          roles: {},
+          subscription: state.subscription,
+        }, { merge: true });
+
+        const userDoc = await firestore.get(`users/${state.uid}`);
+        assert.equal(userDoc.subscription.status, 'cancelled', 'Should start cancelled');
+        assert.equal(userDoc.subscription.product.id, state.productId, 'Should still carry the paid product id');
+      },
+    },
+
+    {
+      name: 'resubscribe-through-a-declining-checkout',
+      async run({ assert, Manager, state }) {
+        const user = buildUser(Manager, {
+          auth: { uid: state.uid, email: state.email },
+          roles: {},
+          subscription: state.subscription,
+        });
+
+        const sent = await callHandler({
+          Manager,
+          handler,
+          functionName: 'payments-intent',
+          user,
+          settings: {
+            provider: 'test',
+            productId: state.productId,
+            frequency: state.frequency,
+            trial: false,
+            verification: {},
+            attribution: {},
+            trackingConsent: null,
+            discount: null,
+            supplemental: {},
+            simulate: 'decline',
+          },
+        });
+
+        assert.equal(sent.code, 200, `The checkout starts — the payment is what fails, got ${sent.code}: ${JSON.stringify(sent.body)}`);
+        assert.ok(sent.body?.orderId, `Checkout should return an orderId, got ${JSON.stringify(sent.body)}`);
+
+        state.orderId = sent.body.orderId;
+      },
+    },
+
+    {
+      name: 'the-declined-win-back-suspends-the-subscriber',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const userDoc = await firestore.get(`users/${state.uid}`);
+          return userDoc?.subscription?.status === 'suspended';
+        }, 20000, 500);
+
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        assert.equal(userDoc.subscription.status, 'suspended', 'Status should be suspended after the declined win-back');
+        assert.equal(userDoc.subscription.product.id, state.productId, 'Product should be the ATTEMPTED product');
+        assert.equal(userDoc.subscription.payment.orderId, state.orderId, 'Order ID should match the intent');
+      },
+    },
+
+    {
+      name: 'checkout-declined-transition-detected',
+      async run({ firestore, assert, state, waitFor }) {
+        const snapshot = await waitFor(async () => {
+          const query = await firestore.collection('payments-webhooks')
+            .where('owner', '==', state.uid)
+            .where('event.type', '==', 'customer.subscription.created')
+            .limit(1)
+            .get();
+
+          if (query.empty) {
+            return null;
+          }
+
+          const status = query.docs[0].data().status;
+          return (status === 'completed' || status === 'failed') ? query : null;
+        }, 30000, 500);
+
+        const webhookDoc = snapshot.docs[0].data();
+
+        assert.equal(webhookDoc.status, 'completed', 'The declined win-back webhook should process cleanly');
+        assert.equal(webhookDoc.transition, 'checkout-declined', 'Transition should be checkout-declined — the user is at the checkout watching it fail, not a subscriber being dunned');
+      },
+    },
+  ],
+});

package/test/events/payments/journey-payments-winback.test.js

@@ -0,0 +1,195 @@
+/**
+ * Test: Payment Journey - Win-back
+ * Simulates: fully cancelled paid subscriber → checkout → active again
+ *
+ * A full cancellation leaves the PAID product id on the user doc (status goes to
+ * cancelled, the product does not go back to basic), so the returning subscriber's
+ * checkout matched none of the transition rules: no confirmation email, and the
+ * analytics resolver read the payment event as a renewal
+ * ([#218](https://github.com/Omega-JS-Stack/omega/issues/218)).
+ *
+ * The caller is this suite's own seeded persona, driven through the shared route
+ * harness: the ACCOUNT is declared in the seed roster (#406) and the starting
+ * state (a cancelled subscription) is a SHAPE this suite writes onto it, because
+ * the seed only makes healthy steady-state accounts. Everything downstream of
+ * the handler — the test provider's checkout, the webhook doc, the on-write
+ * trigger, the transition detection, the user-doc write — is the real pipeline.
+ *
+ * Product-agnostic: resolves the first paid product from config.payment.products
+ *
+ * Run: npx omega test framework:events/payments/journey-payments-winback
+ */
+const { buildUser, callHandler } = require('../../routes/payments/_route-harness.js');
+const analytics = require('../../../dist/manager/events/firestore/payments-webhooks/analytics.js');
+
+const handler = require('../../../dist/manager/routes/payments/intent/post.js');
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+
+// The suite's own seeded persona ([#406](https://github.com/Omega-JS-Stack/omega/issues/406)):
+// exclusive to this suite and declared in the seed roster, so the account it
+// drives exists — auth user and doc in sync — before the run starts.
+const PERSONA = 'journey-payments-winback';
+const RESOURCE_ID = 'sub_test_journey_winback_cancelled';
+
+module.exports = defineCases({
+  description: 'Payment journey: cancelled subscriber resubscribes → win-back',
+  type: 'suite',
+  timeout: 60000,
+
+  tests: [
+    {
+      name: 'setup-cancelled-subscriber',
+      async run({ accounts, firestore, assert, state, config, skip }) {
+        const paidProduct = (config.payment?.products || []).find((p) => p.id !== 'basic' && p.type === 'subscription' && p.prices);
+
+        if (!paidProduct) {
+          skip('No paid subscription product configured in this brand');
+        }
+
+        const frequency = Object.keys(paidProduct.prices)[0];
+        const nowUNIX = Math.floor(Date.now() / 1000);
+        const cancelledUNIX = nowUNIX - (7 * 86400);
+        const startUNIX = nowUNIX - (365 * 86400);
+
+        state.uid = accounts[PERSONA].uid;
+        state.email = accounts[PERSONA].email;
+        state.productId = paidProduct.id;
+        state.frequency = frequency;
+
+        // The starting state: cancelled outright a week ago, still carrying the paid
+        // product id — what subscription-cancelled leaves behind.
+        state.subscription = {
+          product: { id: paidProduct.id, name: paidProduct.name || paidProduct.id },
+          status: 'cancelled',
+          expires: { timestamp: new Date(cancelledUNIX * 1000).toISOString(), timestampUNIX: cancelledUNIX },
+          trial: { claimed: false },
+          cancellation: {
+            pending: false,
+            date: { timestamp: new Date(cancelledUNIX * 1000).toISOString(), timestampUNIX: cancelledUNIX },
+          },
+          payment: {
+            provider: 'test',
+            orderId: null,
+            resourceId: RESOURCE_ID,
+            frequency: frequency,
+            price: paidProduct.prices[frequency],
+            startDate: { timestamp: new Date(startUNIX * 1000).toISOString(), timestampUNIX: startUNIX },
+          },
+        };
+
+        // The pipeline reads users/{uid} for its BEFORE state, so the doc has to be
+        // the real record the transition is detected against.
+        await firestore.set(`users/${state.uid}`, {
+          auth: { uid: state.uid, email: state.email },
+          roles: {},
+          subscription: state.subscription,
+        }, { merge: true });
+
+        const userDoc = await firestore.get(`users/${state.uid}`);
+        assert.equal(userDoc.subscription.status, 'cancelled', 'Should start cancelled');
+        assert.equal(userDoc.subscription.product.id, state.productId, 'Should still carry the paid product id');
+      },
+    },
+
+    {
+      name: 'resubscribe-through-checkout',
+      async run({ assert, Manager, state }) {
+        const user = buildUser(Manager, {
+          auth: { uid: state.uid, email: state.email },
+          roles: {},
+          subscription: state.subscription,
+        });
+
+        const sent = await callHandler({
+          Manager,
+          handler,
+          functionName: 'payments-intent',
+          user,
+          // What schemas/payments/intent/post.js resolves a bare checkout request
+          // to — the handler receives settings already defaulted, and writes them
+          // onto the intent doc as-is.
+          settings: {
+            provider: 'test',
+            productId: state.productId,
+            frequency: state.frequency,
+            trial: false,
+            verification: {},
+            attribution: {},
+            trackingConsent: null,
+            discount: null,
+            supplemental: {},
+            simulate: null,
+          },
+        });
+
+        assert.equal(sent.code, 200, `A cancelled subscriber should be allowed to check out again, got ${sent.code}: ${JSON.stringify(sent.body)}`);
+        assert.ok(sent.body?.orderId, `Checkout should return an orderId, got ${JSON.stringify(sent.body)}`);
+
+        state.orderId = sent.body.orderId;
+      },
+    },
+
+    {
+      name: 'subscription-is-active-again',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const userDoc = await firestore.get(`users/${state.uid}`);
+          return userDoc?.subscription?.status === 'active';
+        }, 20000, 500);
+
+        const userDoc = await firestore.get(`users/${state.uid}`);
+        assert.equal(userDoc.subscription.status, 'active', 'Status should be active again');
+        assert.equal(userDoc.subscription.product.id, state.productId, `Product should be ${state.productId}`);
+        assert.equal(userDoc.subscription.cancellation.pending, false, 'The new subscription should carry no pending cancellation');
+      },
+    },
+
+    {
+      name: 'win-back-transition-detected',
+      async run({ firestore, assert, state, waitFor }) {
+        const snapshot = await waitFor(async () => {
+          const query = await firestore.collection('payments-webhooks')
+            .where('owner', '==', state.uid)
+            .where('event.type', '==', 'customer.subscription.created')
+            .limit(1)
+            .get();
+
+          if (query.empty) {
+            return null;
+          }
+
+          const status = query.docs[0].data().status;
+          return (status === 'completed' || status === 'failed') ? query : null;
+        }, 30000, 500);
+
+        const webhookDoc = snapshot.docs[0].data();
+
+        assert.equal(webhookDoc.status, 'completed', 'The win-back webhook should process cleanly');
+        assert.equal(webhookDoc.transition, 'subscription-winback', 'Transition should be subscription-winback');
+
+        state.eventType = webhookDoc.event.type;
+        state.transition = webhookDoc.transition;
+      },
+    },
+
+    {
+      name: 'win-back-tracks-as-a-purchase',
+      async run({ firestore, assert, state }) {
+        // The order doc the pipeline just wrote IS what trackPayment resolved its
+        // event from — run the resolver over it to prove the win-back reports a
+        // purchase and not the renewal it used to report.
+        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
+
+        assert.ok(orderDoc, 'Order doc should exist');
+        assert.equal(orderDoc.owner, state.uid, 'Owner should match');
+
+        const resolved = analytics.resolvePaymentEvent('subscription', state.transition, state.eventType, orderDoc.unified, orderDoc);
+
+        assert.ok(resolved, 'A win-back should resolve to a trackable analytics event');
+        assert.equal(resolved.reason, 'winback-purchase', 'Reason should be winback-purchase');
+        assert.equal(resolved.isRecurring, false, 'A win-back is a purchase, not recurring revenue');
+        assert.equal(resolved.productId, state.productId, 'The tracked product should be the resubscribed product');
+      },
+    },
+  ],
+});

package/test/events/payments/paypal-expiry-cron.test.js

@@ -0,0 +1,166 @@
+/**
+ * Test: the daily PayPal pending-cancellation expiry cron
+ *
+ * PayPal cancels immediately on its side and fires no webhook at period end, so this
+ * cron is the ONLY thing that ends a PayPal subscriber's paid term. It used to write
+ * the user doc alone — the `payments-orders` record stayed active forever, and that
+ * record's `unified` mirror is what the transition handlers and the UI read ([#221]).
+ *
+ * It also merged a whole subscription map read from a batch snapshot, so a webhook that
+ * landed between the read and the write was overwritten with the pre-read state. The
+ * cron now takes the same staleness discipline the webhook trigger takes: anything
+ * stamped after this run's read wins, and the cron stands down.
+ */
+
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+const HOUR = 60 * 60;
+const DAY = 24 * HOUR;
+
+const EXPIRE_UID = '_test-paypal-expire';
+const RACE_UID = '_test-paypal-expire-race';
+
+const EXPIRE_ORDER = '_test-order-paypal-expire';
+const RACE_ORDER = '_test-order-paypal-expire-race';
+
+module.exports = defineCases({
+  description: 'PayPal expiry cron: the order flips with the subscription, and a newer webhook wins',
+  type: 'suite',
+  timeout: 180000,
+
+  tests: [
+    {
+      name: 'seed-pending-cancellations',
+      async run({ firestore, assert, state, config, skip }) {
+        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.type === 'subscription' && p.prices);
+
+        if (!paidProduct) {
+          skip('No paid subscription product configured in this brand');
+        }
+
+        state.paidProductId = paidProduct.id;
+
+        const nowUNIX = Math.floor(Date.now() / 1000);
+        state.expiredUNIX = nowUNIX - DAY;
+
+        // The candidate the cron must expire
+        await seed(firestore, {
+          uid: EXPIRE_UID,
+          orderId: EXPIRE_ORDER,
+          productId: paidProduct.id,
+          expiresUNIX: state.expiredUNIX,
+          orderUpdatedUNIX: nowUNIX - HOUR,
+        });
+
+        // The race: the order carries a stamp from AFTER this run's read — which is what
+        // a webhook landing between the cron's read and its write looks like
+        state.raceUpdatedUNIX = nowUNIX + HOUR;
+        await seed(firestore, {
+          uid: RACE_UID,
+          orderId: RACE_ORDER,
+          productId: paidProduct.id,
+          expiresUNIX: state.expiredUNIX,
+          orderUpdatedUNIX: state.raceUpdatedUNIX,
+        });
+
+        const seeded = await firestore.get(`payments-orders/${EXPIRE_ORDER}`);
+        assert.equal(seeded.unified.status, 'active', 'The order starts alive alongside the subscription');
+      },
+    },
+
+    {
+      name: 'the-order-flips-with-the-subscription',
+      timeout: 150000,
+      async run({ firestore, assert, waitFor, pubsub, state }) {
+        await pubsub.trigger('omega_cronDaily');
+
+        await waitFor(async () => {
+          const doc = await firestore.get(`users/${EXPIRE_UID}`);
+          return doc?.subscription?.status === 'cancelled';
+        }, 120000, 1000);
+
+        const user = await firestore.get(`users/${EXPIRE_UID}`);
+        const order = await firestore.get(`payments-orders/${EXPIRE_ORDER}`);
+
+        assert.equal(user.subscription.status, 'cancelled', 'The paid term ended');
+        assert.equal(user.subscription.cancellation.pending, false, 'Nothing is left pending');
+
+        assert.equal(order.unified.status, 'cancelled', 'The order doc flips WITH the subscription — it is what handlers and the UI read');
+        assert.equal(order.unified.cancellation.pending, false, 'The order mirror clears the pending flag too');
+        assert.ok(
+          order.metadata.updated.timestampUNIX > state.expiredUNIX,
+          'The order carries a fresh update stamp, so the NEXT webhook can tell it is newer',
+        );
+
+        // The write is the cron's delta, not a whole map: everything else on the order
+        // survives untouched
+        assert.equal(order.unified.product.id, state.paidProductId, 'The order still names its product');
+        assert.equal(order.unified.cancellation.date.timestampUNIX, state.expiredUNIX, 'The cancellation date the user requested survives');
+        assert.equal(order.owner, EXPIRE_UID, 'The order still belongs to its owner');
+      },
+    },
+
+    {
+      name: 'a-newer-webhook-stamp-wins-and-the-cron-stands-down',
+      async run({ firestore, assert, state }) {
+        const user = await firestore.get(`users/${RACE_UID}`);
+        const order = await firestore.get(`payments-orders/${RACE_ORDER}`);
+
+        assert.equal(user.subscription.status, 'active', 'A subscription whose order was written after the read is left alone');
+        assert.equal(user.subscription.cancellation.pending, true, 'Its pending flag is untouched');
+        assert.equal(order.unified.status, 'active', 'The order the newer write owns is untouched');
+        assert.equal(
+          order.metadata.updated.timestampUNIX,
+          state.raceUpdatedUNIX,
+          'The newer stamp survives — the cron did not overwrite it with its own',
+        );
+      },
+    },
+  ],
+});
+
+/**
+ * Seed a PayPal subscriber whose pending cancellation has run out its paid term,
+ * plus the purchase record that mirrors it
+ */
+async function seed(firestore, { uid, orderId, productId, expiresUNIX, orderUpdatedUNIX }) {
+  await firestore.delete(`users/${uid}`);
+  await firestore.delete(`payments-orders/${orderId}`);
+
+  await firestore.set(`users/${uid}`, {
+    subscription: {
+      product: { id: productId, name: productId },
+      status: 'active',
+      expires: stamp(expiresUNIX),
+      trial: { claimed: false, expires: stamp(0) },
+      cancellation: { pending: true, date: stamp(expiresUNIX) },
+      payment: { provider: 'paypal', orderId: orderId, resourceId: `I-${uid}`, frequency: 'monthly' },
+    },
+  });
+
+  await firestore.set(`payments-orders/${orderId}`, {
+    id: orderId,
+    type: 'subscription',
+    owner: uid,
+    productId: productId,
+    provider: 'paypal',
+    resourceId: `I-${uid}`,
+    unified: {
+      product: { id: productId, name: productId },
+      status: 'active',
+      expires: stamp(expiresUNIX),
+      cancellation: { pending: true, date: stamp(expiresUNIX) },
+      payment: { provider: 'paypal', orderId: orderId, resourceId: `I-${uid}`, frequency: 'monthly' },
+    },
+    metadata: {
+      created: stamp(orderUpdatedUNIX - 30 * DAY),
+      updated: stamp(orderUpdatedUNIX),
+    },
+  });
+}
+
+/**
+ * A `$timestamp` pair from a UNIX second
+ */
+function stamp(unix) {
+  return { timestamp: new Date(unix * 1000).toISOString(), timestampUNIX: unix };
+}

package/test/events/payments/purchase-failed-handler.test.js

@@ -0,0 +1,80 @@
+/**
+ * Test: the one-time purchase-failed handler tells the customer their payment
+ * failed ([#673](https://github.com/Omega-JS-Stack/omega/issues/673)).
+ *
+ * The transition IS reachable, which is what decided this: a Stripe
+ * `invoice.payment_failed` whose `billing_reason` is not a subscription one
+ * parses as category `one-time` (routes/payments/webhook/providers/stripe.js),
+ * and `detectOneTimeTransition()` maps that event to `purchase-failed`. The
+ * population behind it is a MANUAL invoice that failed — nobody is standing at a
+ * checkout watching it, which is the reason its subscription cousin
+ * `checkout-declined` deliberately sends nothing — so the failure only reaches
+ * the customer if this handler tells them.
+ *
+ * Called directly, and the email library is RECORDED rather than run, for the
+ * same reasons its purchase-refunded twin is.
+ *
+ * Run: npx omega test backend:events/payments/purchase-failed-handler
+ */
+const handler = require('../../../dist/manager/events/firestore/payments-webhooks/transitions/one-time/purchase-failed.js');
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+
+const ORDER_ID = '5544-3322-1100';
+
+function context(logs, sent) {
+  return {
+    before: null,
+    after: { product: { id: 'credits-100', name: '100 Credits' }, status: 'failed' },
+    order: { id: ORDER_ID, type: 'one-time', unified: { product: { id: 'credits-100' }, payment: { price: 9.99 } } },
+    uid: '_test-purchase-failed-uid',
+    userDoc: { auth: { uid: '_test-purchase-failed-uid', email: 'buyer@test.dev' } },
+    ctx: {
+      log: (line) => logs.push(line),
+      error: (line) => logs.push(line),
+      Manager: {
+        config: { brand: { name: 'Test Brand' } },
+        Email: () => ({ send: async (payload) => { sent.push(payload); return { status: 'sent' }; } }),
+      },
+    },
+  };
+}
+
+module.exports = defineCases({
+  description: 'One-time purchase-failed handler',
+  type: 'group',
+
+  tests: [
+    {
+      name: 'records-the-order-that-failed',
+      async run({ assert }) {
+        const logs = [];
+
+        await handler(context(logs, []));
+
+        const line = logs.find((entry) => entry.includes('one-time/purchase-failed'));
+
+        assert.ok(line, `The handler should log the transition, got: ${logs.join(' | ')}`);
+        assert.match(line, new RegExp(`orderId=${ORDER_ID}`), 'The line should name the order that failed');
+      },
+    },
+
+    {
+      name: 'sends-the-failed-payment-email-the-subscription-twin-sends',
+      async run({ assert }) {
+        const sent = [];
+
+        await handler(context([], sent));
+
+        assert.equal(sent.length, 1, `A failed purchase owes the customer exactly one email, got ${sent.length}`);
+
+        const email = sent[0];
+
+        assert.equal(email.template, 'order', 'It rides the one order template, like every other transition');
+        assert.deepEqual(email.categories, ['order/payment-failed'], 'Filed under the same category the subscription failure is');
+        assert.equal(email.data.content.event, 'payment-failed', 'The order template renders the payment-failed variant off this event');
+        assert.match(email.subject, new RegExp(ORDER_ID), 'The subject should name the order that failed');
+        assert.equal(email.data.content.id, ORDER_ID, 'The order rides the payload, so the mail can quote what was being bought');
+      },
+    },
+  ],
+});