@omega.js/backend 0.1.0

package/test/events/payments/journey-payments-refund-no-order.test.js

@@ -0,0 +1,76 @@
+/**
+ * Test: Payment Journey - Refund with no order doc ([#216](https://github.com/Omega-JS-Stack/omega/issues/216))
+ * Simulates: paid, pending cancellation, WITHOUT an order doc → POST /payments/refund → cancelled, product intact
+ *
+ * The same hole #210 fixed in the cancel provider: the refund test provider
+ * resolved the plan's product from the payments-orders doc only, so a paid user
+ * with no order got a webhook carrying plan.product = null — the pipeline
+ * resolved that to Basic and downgraded the user mid-refund instead of recording
+ * a cancelled paid subscription. The product falls back to the subscription's own.
+ *
+ * The refund-no-order persona is seeded paid + pending cancellation on the test
+ * provider with payment.orderId null. Product-agnostic: the persona's 'premium'
+ * is remapped to the brand's first paid product at seed time, and the assertions
+ * compare against whatever the user doc starts with.
+ */
+
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+module.exports = defineCases({
+  description: 'Payment journey: refund with no order doc → cancelled, product intact',
+  type: 'suite',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'starts-paid-with-no-order',
+      async run({ accounts, firestore, assert, state }) {
+        const uid = accounts['refund-no-order'].uid;
+        state.uid = uid;
+
+        const userDoc = await firestore.get(`users/${uid}`);
+
+        assert.ok(userDoc, 'User doc should exist');
+        assert.notEqual(userDoc.subscription?.product?.id, 'basic', 'Persona should start on a paid product');
+        assert.equal(userDoc.subscription?.status, 'active', 'Should be active');
+        assert.equal(userDoc.subscription?.cancellation?.pending, true, 'Refund requires a pending cancellation');
+        assert.equal(userDoc.subscription?.payment?.provider, 'test', 'Should be on the test provider');
+        assert.equal(userDoc.subscription?.payment?.orderId, null, 'The bug scenario needs no order doc');
+
+        state.paidProductId = userDoc.subscription.product.id;
+      },
+    },
+
+    {
+      name: 'call-refund-endpoint',
+      async run({ http, assert }) {
+        // The test provider writes a payments-webhooks doc directly, triggering the
+        // on-write pipeline automatically — no manual webhook needed.
+        const response = await http.as('refund-no-order').post('backend-manager/payments/refund', {
+          confirmed: true,
+          reason: 'Not satisfied with the service',
+        });
+
+        assert.isSuccess(response, 'Refund endpoint should succeed');
+        assert.equal(response.data.success, true, 'Should return { success: true }');
+      },
+    },
+
+    {
+      name: 'verify-cancelled-and-product-intact',
+      async run({ firestore, assert, state, waitFor }) {
+        // Wait for the pipeline to land either outcome: the cancellation (correct) or the
+        // downgrade to Basic (the bug) — so the regression fails on its assertion, not a timeout.
+        await waitFor(async () => {
+          const userDoc = await firestore.get(`users/${state.uid}`);
+          return userDoc?.subscription?.status === 'cancelled'
+            || userDoc?.subscription?.product?.id === 'basic';
+        }, 15000, 500);
+
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        assert.equal(userDoc.subscription.product.id, state.paidProductId, `Product should stay ${state.paidProductId}, not fall back to Basic`);
+        assert.equal(userDoc.subscription.status, 'cancelled', 'The refund cancels the subscription immediately');
+      },
+    },
+  ],
+});

package/test/events/payments/journey-payments-refund-webhook.test.js

@@ -0,0 +1,225 @@
+/**
+ * Test: Payment Journey - Refund Webhook
+ * Simulates: basic → paid active → pending cancel → charge.refunded webhook → payment-refunded transition
+ *
+ * Verifies that refund webhook events:
+ * 1. Flow through the pipeline correctly
+ * 2. Trigger the payment-refunded transition (not subscription-cancelled)
+ * 3. Extract refundDetails via the provider library's getRefundDetails()
+ * 4. Record the transition name on the webhook doc for auditing
+ *
+ * 5. Fire exactly once when the same refund event is reprocessed
+ *
+ * Product-agnostic: resolves the first paid product from config.payment.products
+ */
+const powertools = require('node-powertools');
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+
+module.exports = defineCases({
+  description: 'Payment journey: paid → refund webhook → payment-refunded transition',
+  type: 'suite',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'setup-paid-subscription',
+      async run({ accounts, firestore, assert, state, config, http, waitFor, skip, payments }) {
+        const uid = accounts['journey-payments-refund-webhook'].uid;
+
+        // Resolve a paid product with a monthly price. If the brand has none configured,
+        // skip the entire journey — this is a config-gap, not a code failure.
+        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices?.monthly);
+        if (!paidProduct) {
+          skip('No paid product with monthly price configured in this brand');
+        }
+
+        state.uid = uid;
+        state.paidProductId = paidProduct.id;
+        state.product = payments.products[paidProduct.id];
+        // Create subscription via test intent
+        const response = await http.as('journey-payments-refund-webhook').post('backend-manager/payments/intent', {
+          provider: 'test',
+          productId: paidProduct.id,
+          frequency: state.product.frequency,
+        });
+        assert.isSuccess(response, 'Intent should succeed');
+        state.orderId = response.data.orderId;
+
+        // Wait for subscription to activate
+        await waitFor(async () => {
+          const userDoc = await firestore.get(`users/${uid}`);
+          return userDoc?.subscription?.product?.id === paidProduct.id
+            && userDoc?.subscription?.status === 'active';
+        }, 15000, 500);
+
+        const userDoc = await firestore.get(`users/${uid}`);
+        assert.equal(userDoc.subscription?.product?.id, paidProduct.id, `Should be ${paidProduct.id}`);
+        assert.equal(userDoc.subscription?.status, 'active', 'Should be active');
+
+        state.subscriptionId = userDoc.subscription.payment.resourceId;
+      },
+    },
+
+    {
+      name: 'send-pending-cancel-webhook',
+      async run({ http, assert, state, config, payments }) {
+        const futureDate = new Date();
+        futureDate.setMonth(futureDate.getMonth() + 1);
+
+        state.cancelEventId = `_test-evt-journey-refund-cancel-${Date.now()}`;
+
+        const response = await http.as('none').post(`backend-manager/payments/webhook?provider=test&key=${config.webhookKey}`, {
+          id: state.cancelEventId,
+          type: 'customer.subscription.updated',
+          data: {
+            object: {
+              id: state.subscriptionId,
+              object: 'subscription',
+              status: 'active',
+              metadata: { uid: state.uid, orderId: state.orderId },
+              cancel_at_period_end: true,
+              cancel_at: Math.floor(futureDate.getTime() / 1000),
+              canceled_at: null,
+              current_period_end: Math.floor(futureDate.getTime() / 1000),
+              current_period_start: Math.floor(Date.now() / 1000),
+              start_date: Math.floor(Date.now() / 1000) - 86400 * 30,
+              trial_start: null,
+              trial_end: null,
+              plan: { product: payments.stripeProductIds[state.paidProductId], interval: state.product.interval },
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Cancel webhook should be accepted');
+      },
+    },
+
+    {
+      name: 'cancellation-pending-confirmed',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.cancelEventId}`);
+          return doc?.status === 'completed';
+        }, 15000, 500);
+
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.cancelEventId}`);
+        assert.equal(webhookDoc.transition, 'cancellation-requested', 'Should detect cancellation-requested');
+
+        const userDoc = await firestore.get(`users/${state.uid}`);
+        assert.equal(userDoc.subscription.status, 'active', 'Status should still be active');
+        assert.equal(userDoc.subscription.cancellation.pending, true, 'Cancellation should be pending');
+      },
+    },
+
+    {
+      name: 'send-charge-refunded-webhook',
+      async run({ http, assert, state, config }) {
+        // Simulate a charge.refunded event (Stripe-shaped, used by test provider)
+        // This carries refund amount data that getRefundDetails() extracts
+        state.refundEventId = `_test-evt-journey-refund-charge-${Date.now()}`;
+        state.refundAmountCents = 2800; // $28.00
+
+        const response = await http.as('none').post(`backend-manager/payments/webhook?provider=test&key=${config.webhookKey}`, {
+          id: state.refundEventId,
+          type: 'charge.refunded',
+          data: {
+            object: {
+              id: `ch_test_${Date.now()}`,
+              object: 'charge',
+              amount: state.refundAmountCents,
+              amount_refunded: state.refundAmountCents,
+              currency: 'usd',
+              subscription: state.subscriptionId,
+              metadata: { uid: state.uid, orderId: state.orderId },
+              refunds: {
+                data: [
+                  {
+                    id: `re_test_${Date.now()}`,
+                    amount: state.refundAmountCents,
+                    currency: 'usd',
+                    reason: 'requested_by_customer',
+                  },
+                ],
+              },
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Refund webhook should be accepted');
+      },
+    },
+
+    {
+      name: 'payment-refunded-transition-detected',
+      async run({ firestore, assert, state, waitFor }) {
+        // Wait for the refund webhook to be processed
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.refundEventId}`);
+          return doc?.status === 'completed';
+        }, 15000, 500);
+
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.refundEventId}`);
+
+        // Core assertion: refund events trigger payment-refunded, not subscription-cancelled
+        assert.equal(webhookDoc.status, 'completed', 'Webhook should complete successfully');
+        assert.equal(webhookDoc.transition, 'payment-refunded', 'Transition should be payment-refunded (not subscription-cancelled)');
+        assert.equal(webhookDoc.owner, state.uid, 'Owner should match');
+        assert.equal(webhookDoc.orderId, state.orderId, 'Order ID should match');
+      },
+    },
+
+    {
+      name: 'order-doc-updated',
+      async run({ firestore, assert, state }) {
+        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
+
+        assert.ok(orderDoc, 'Order doc should exist');
+        assert.equal(orderDoc.type, 'subscription', 'Type should be subscription');
+        assert.equal(orderDoc.owner, state.uid, 'Owner should match');
+
+        // The order was last updated by the refund webhook event
+        assert.equal(orderDoc.metadata?.updatedBy?.event?.name, 'charge.refunded', 'Last event should be charge.refunded');
+      },
+    },
+
+    {
+      name: 'reprocessed-refund-fires-once',
+      async run({ firestore, assert, state, waitFor }) {
+        // Reprocess the SAME refund event: put the completed doc back to pending,
+        // exactly as the route's retry path does. Refund detection reads the event
+        // type alone, so without an idempotency guard the second pass re-dispatches
+        // payment-refunded and the customer is emailed twice about one refund.
+        //
+        // The received timestamp is deliberately set AHEAD of the order's last write
+        // so the pre-existing staleness guard cannot be what skips this pass — the
+        // only thing left to suppress the transition is the idempotency guard.
+        const received = powertools.timestamp(new Date(Date.now() + 60000), { output: 'string' });
+
+        await firestore.set(`payments-webhooks/${state.refundEventId}`, {
+          status: 'pending',
+          transition: 'reprocessing',
+          metadata: {
+            created: {
+              timestamp: received,
+              timestampUNIX: powertools.timestamp(received, { output: 'unix' }),
+            },
+          },
+        }, { merge: true });
+
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.refundEventId}`);
+          return doc?.status === 'completed';
+        }, 15000, 500);
+
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.refundEventId}`);
+
+        assert.equal(webhookDoc.transition, null, 'A reprocessed refund must dispatch nothing — one refund, one email');
+        assert.equal(webhookDoc.orderId, state.orderId, 'The reprocess should still resolve the same order');
+
+        // The pass ran in full (it was not skipped as stale) — the order carries its write
+        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
+        assert.equal(orderDoc.metadata?.updatedBy?.event?.id, state.refundEventId, 'The order should record the reprocessed event');
+      },
+    },
+  ],
+});

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

@@ -0,0 +1,183 @@
+/**
+ * Test: Payment Journey - Suspend & Recover
+ * Simulates: paid active → payment fails → suspended → payment succeeds → active again
+ *
+ * Uses test intent for initial subscription, then manual webhooks for suspend/recover
+ * Product-agnostic: resolves the first paid product from config.payment.products
+ */
+
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+module.exports = defineCases({
+  description: 'Payment journey: paid → suspended → recovered via test provider',
+  type: 'suite',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'setup-paid-subscription',
+      async run({ accounts, firestore, assert, state, config, http, waitFor, skip, payments }) {
+        const uid = accounts['journey-payments-suspend'].uid;
+
+        // Resolve first paid product from config. If the brand has none configured,
+        // skip the entire journey — this is a config-gap, not a code failure.
+        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+        if (!paidProduct) {
+          skip('No paid product configured in this brand');
+        }
+
+        state.uid = uid;
+        state.paidProductId = paidProduct.id;
+        state.product = payments.products[paidProduct.id];
+
+        state.paidProductName = paidProduct.name;
+
+        // Create subscription via test intent
+        const response = await http.as('journey-payments-suspend').post('backend-manager/payments/intent', {
+          provider: 'test',
+          productId: paidProduct.id,
+          frequency: state.product.frequency,
+        });
+        assert.isSuccess(response, 'Intent should succeed');
+        state.orderId = response.data.orderId;
+
+        // Wait for subscription to activate
+        await waitFor(async () => {
+          const userDoc = await firestore.get(`users/${uid}`);
+          return userDoc?.subscription?.product?.id === paidProduct.id;
+        }, 15000, 500);
+
+        const userDoc = await firestore.get(`users/${uid}`);
+        assert.equal(userDoc.subscription?.product?.id, paidProduct.id, `Should start as ${paidProduct.id}`);
+        assert.equal(userDoc.subscription?.status, 'active', 'Should be active');
+        assert.equal(userDoc.subscription?.payment?.orderId, state.orderId, 'Order ID should match intent');
+
+        state.subscriptionId = userDoc.subscription.payment.resourceId;
+      },
+    },
+
+    {
+      name: 'send-past-due-webhook',
+      async run({ http, assert, state, config, payments }) {
+        state.eventId1 = `_test-evt-journey-suspend-fail-${Date.now()}`;
+
+        const response = await http.as('none').post(`backend-manager/payments/webhook?provider=test&key=${config.webhookKey}`, {
+          id: state.eventId1,
+          type: 'customer.subscription.updated',
+          data: {
+            object: {
+              id: state.subscriptionId,
+              object: 'subscription',
+              status: 'past_due',
+              metadata: { uid: state.uid, orderId: state.orderId },
+              cancel_at_period_end: false,
+              canceled_at: null,
+              current_period_end: Math.floor(Date.now() / 1000) + 86400,
+              current_period_start: Math.floor(Date.now() / 1000) - 86400 * 29,
+              start_date: Math.floor(Date.now() / 1000) - 86400 * 60,
+              trial_start: null,
+              trial_end: null,
+              plan: { product: payments.stripeProductIds[state.paidProductId], interval: state.product.interval },
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Webhook should be accepted');
+      },
+    },
+
+    {
+      name: 'subscription-suspended',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.eventId1}`);
+          return doc?.status === 'completed';
+        }, 15000, 500);
+
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId1}`);
+        assert.equal(webhookDoc.transition, 'payment-failed', 'Transition should be payment-failed');
+
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        assert.equal(userDoc.subscription.status, 'suspended', 'Status should be suspended');
+        assert.equal(userDoc.subscription.product.id, state.paidProductId, `Product should still be ${state.paidProductId}`);
+      },
+    },
+
+    {
+      name: 'send-recovery-webhook',
+      async run({ http, assert, state, config, payments }) {
+        const futureDate = new Date();
+        futureDate.setMonth(futureDate.getMonth() + 1);
+
+        state.eventId2 = `_test-evt-journey-suspend-recover-${Date.now()}`;
+
+        const response = await http.as('none').post(`backend-manager/payments/webhook?provider=test&key=${config.webhookKey}`, {
+          id: state.eventId2,
+          type: 'customer.subscription.updated',
+          data: {
+            object: {
+              id: state.subscriptionId,
+              object: 'subscription',
+              status: 'active',
+              metadata: { uid: state.uid, orderId: state.orderId },
+              cancel_at_period_end: false,
+              canceled_at: null,
+              current_period_end: Math.floor(futureDate.getTime() / 1000),
+              current_period_start: Math.floor(Date.now() / 1000),
+              start_date: Math.floor(Date.now() / 1000) - 86400 * 60,
+              trial_start: null,
+              trial_end: null,
+              plan: { product: payments.stripeProductIds[state.paidProductId], interval: state.product.interval },
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Webhook should be accepted');
+      },
+    },
+
+    {
+      name: 'subscription-recovered',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.eventId2}`);
+          return doc?.status === 'completed';
+        }, 15000, 500);
+
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId2}`);
+        assert.equal(webhookDoc.transition, 'payment-recovered', 'Transition should be payment-recovered');
+
+        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.paidProductId, `Product should still be ${state.paidProductId}`);
+      },
+    },
+
+    {
+      name: 'order-doc-verified',
+      async run({ firestore, assert, state }) {
+        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
+
+        assert.ok(orderDoc, 'Order doc should exist');
+        assert.equal(orderDoc.type, 'subscription', 'Type should be subscription');
+        assert.equal(orderDoc.owner, state.uid, 'Owner should match');
+        assert.ok(orderDoc.requests !== undefined, 'requests field should exist');
+        assert.equal(orderDoc.requests.cancellation, null, 'requests.cancellation should be null');
+        assert.equal(orderDoc.requests.refund, null, 'requests.refund should be null');
+      },
+    },
+
+    {
+      name: 'intent-doc-completed',
+      async run({ firestore, assert, state }) {
+        const intentDoc = await firestore.get(`payments-intents/${state.orderId}`);
+
+        assert.ok(intentDoc, 'Intent doc should exist');
+        assert.equal(intentDoc.id, state.orderId, 'ID should match orderId');
+        assert.equal(intentDoc.status, 'completed', 'Intent status should be completed after webhook processing');
+        assert.ok(intentDoc.metadata?.completed?.timestampUNIX > 0, 'Completed timestamp should be set');
+      },
+    },
+  ],
+});

package/test/events/payments/journey-payments-trial-cancel.test.js

@@ -0,0 +1,132 @@
+/**
+ * Test: Payment Journey - Trial Cancel
+ * Simulates: basic user → trial activation → cancel during trial → immediate cancellation
+ *
+ * When a user cancels during a free trial, the subscription should be cancelled immediately
+ * (not scheduled for period end) to avoid giving free premium access for the remainder of the trial.
+ *
+ * Uses the test provider for initial trial, then cancel endpoint for cancellation.
+ * Product-agnostic: resolves the first paid product from config.payment.products
+ */
+
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+module.exports = defineCases({
+  description: 'Payment journey: trial → cancel during trial → immediate cancellation',
+  type: 'suite',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'verify-starts-as-basic',
+      async run({ accounts, firestore, assert, state, config, skip, payments }) {
+        const uid = accounts['journey-payments-trial-cancel'].uid;
+        const userDoc = await firestore.get(`users/${uid}`);
+
+        assert.ok(userDoc, 'User doc should exist');
+        assert.equal(userDoc.subscription?.product?.id, 'basic', 'Should start as basic');
+        assert.equal(userDoc.subscription?.trial?.claimed, false, 'Trial should not be claimed');
+
+        // Resolve first paid product with trial from config. If the brand has none
+        // configured, skip the entire journey — this is a config-gap, not a code failure.
+        const trialProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices && p.trial?.days);
+        if (!trialProduct) {
+          skip('No paid product with trial configured in this brand');
+        }
+
+        state.uid = uid;
+        state.paidProductId = trialProduct.id;
+        state.paidProductName = trialProduct.name;
+        state.product = payments.products[trialProduct.id];
+      },
+    },
+
+    {
+      name: 'create-trial-intent',
+      async run({ http, assert, state }) {
+        const response = await http.as('journey-payments-trial-cancel').post('backend-manager/payments/intent', {
+          provider: 'test',
+          productId: state.paidProductId,
+          frequency: state.product.frequency,
+          trial: true,
+        });
+
+        assert.isSuccess(response, 'Intent should succeed');
+        assert.ok(response.data.id, 'Should return intent ID');
+        assert.ok(response.data.orderId, 'Should return orderId');
+
+        state.intentId = response.data.id;
+        state.orderId = response.data.orderId;
+        state.eventId = response.data.id.replace('_test-cs-', '_test-evt-');
+      },
+    },
+
+    {
+      name: 'trial-activated',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const userDoc = await firestore.get(`users/${state.uid}`);
+          return userDoc?.subscription?.trial?.claimed === true;
+        }, 15000, 500);
+
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        assert.equal(userDoc.subscription.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);
+        assert.equal(userDoc.subscription.status, 'active', 'Status should be active');
+        assert.equal(userDoc.subscription.trial.claimed, true, 'Trial should be claimed');
+        assert.equal(userDoc.subscription.trial.expires.timestampUNIX, userDoc.subscription.expires.timestampUNIX, 'Trial expires should match subscription expires (still in trial period)');
+
+        state.subscriptionId = userDoc.subscription.payment.resourceId;
+      },
+    },
+
+    {
+      name: 'cancel-during-trial',
+      async run({ http, assert }) {
+        // Cancel via endpoint — test provider should detect trial and simulate immediate cancel.
+        // skipGuards bypasses the 24-hour subscription-age guard.
+        const response = await http.as('journey-payments-trial-cancel').post('backend-manager/payments/cancel', {
+          confirmed: true,
+          reason: 'Changed my mind during trial',
+          feedback: 'Testing trial cancellation',
+          skipGuards: true,
+        });
+
+        assert.isSuccess(response, 'Cancel endpoint should succeed');
+        assert.equal(response.data.success, true, 'Should return { success: true }');
+      },
+    },
+
+    {
+      name: 'verify-immediate-cancellation',
+      async run({ firestore, assert, state, waitFor }) {
+        // Poll until subscription is cancelled (NOT just pending)
+        await waitFor(async () => {
+          const userDoc = await firestore.get(`users/${state.uid}`);
+          return userDoc?.subscription?.status === 'cancelled';
+        }, 15000, 500);
+
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        // During trial cancel: subscription should be immediately cancelled, not pending
+        assert.equal(userDoc.subscription.status, 'cancelled', 'Status should be cancelled (not active with pending)');
+        assert.equal(userDoc.subscription.cancellation.pending, false, 'Should NOT be pending — should be fully cancelled');
+        assert.equal(userDoc.subscription.product.id, state.paidProductId, `Product should still be ${state.paidProductId}`);
+      },
+    },
+
+    {
+      name: 'cancellation-request-stored',
+      async run({ firestore, assert, state }) {
+        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
+
+        assert.ok(orderDoc, 'Order doc should exist');
+        assert.ok(orderDoc.requests, 'requests field should exist');
+        assert.ok(orderDoc.requests.cancellation, 'requests.cancellation should be populated');
+        assert.equal(orderDoc.requests.cancellation.reason, 'Changed my mind during trial', 'Cancellation reason should match');
+        assert.equal(orderDoc.requests.cancellation.feedback, 'Testing trial cancellation', 'Cancellation feedback should match');
+        assert.ok(orderDoc.requests.cancellation.date.timestampUNIX > 0, 'Cancellation date should be set');
+        assert.equal(orderDoc.requests.refund, null, 'requests.refund should still be null');
+      },
+    },
+  ],
+});