backend-manager 5.9.4 → 5.9.6

package/test/events/payments/journey-payments-plan-change.js

@@ -1,144 +0,0 @@
-/**
- * Test: Payment Journey - Plan Change
- * Simulates: basic → paid product A → plan-changed webhook → paid product B
- *
- * Uses test intent for initial subscription, then manual webhook to change plans.
- * Requires at least two paid subscription products in config.
- */
-module.exports = {
-  description: 'Payment journey: paid product A → plan-changed → paid product B',
-  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-plan-change'].uid;
-
-        // Resolve two distinct paid subscription products from config. If the brand
-        // has fewer than two, skip the journey — this is a config-gap, not a code failure.
-        const paidProducts = config.payment.products.filter(p => p.id !== 'basic' && p.type === 'subscription' && p.prices);
-        if (paidProducts.length < 2) {
-          skip('Fewer than two paid subscription products configured in this brand');
-        }
-
-        const productA = paidProducts[0];
-        const productB = paidProducts[1];
-
-        state.uid = uid;
-        state.productA = payments.products[productA.id];
-        state.productB = payments.products[productB.id];
-
-        // Create subscription via test intent (product A)
-        const response = await http.as('journey-payments-plan-change').post('backend-manager/payments/intent', {
-          processor: 'test',
-          productId: productA.id,
-          frequency: state.productA.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 === productA.id;
-        }, 15000, 500);
-
-        const userDoc = await firestore.get(`users/${uid}`);
-        assert.equal(userDoc.subscription?.product?.id, productA.id, `Should start as ${productA.id}`);
-        assert.equal(userDoc.subscription?.status, 'active', 'Should be active');
-
-        state.subscriptionId = userDoc.subscription.payment.resourceId;
-      },
-    },
-
-    {
-      name: 'send-plan-change-webhook',
-      async run({ http, assert, state, config, payments }) {
-        const futureDate = new Date();
-        futureDate.setMonth(futureDate.getMonth() + 1);
-
-        state.eventId = `_test-evt-journey-plan-change-${Date.now()}`;
-
-        // Send subscription.updated with product B's Stripe product ID (or test sentinel)
-        const response = await http.as('none').post(`backend-manager/payments/webhook?processor=test&key=${config.backendManagerWebhookKey}`, {
-          id: state.eventId,
-          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 * 30,
-              trial_start: null,
-              trial_end: null,
-              plan: { product: payments.stripeProductIds[state.productB.id], interval: state.productB.interval },
-            },
-          },
-        });
-
-        assert.isSuccess(response, 'Webhook should be accepted');
-      },
-    },
-
-    {
-      name: 'plan-changed-transition-detected',
-      async run({ firestore, assert, state, waitFor }) {
-        await waitFor(async () => {
-          const doc = await firestore.get(`payments-webhooks/${state.eventId}`);
-          return doc?.status === 'completed';
-        }, 15000, 500);
-
-        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId}`);
-        assert.ok(webhookDoc, 'Webhook doc should exist');
-        assert.equal(webhookDoc.transition, 'plan-changed', 'Transition should be plan-changed');
-      },
-    },
-
-    {
-      name: 'subscription-updated-to-product-b',
-      async run({ firestore, assert, state }) {
-        const userDoc = await firestore.get(`users/${state.uid}`);
-
-        assert.equal(userDoc.subscription.product.id, state.productB.id, `Product should be ${state.productB.id}`);
-        assert.equal(userDoc.subscription.product.name, state.productB.name, `Product name should be ${state.productB.name}`);
-        assert.equal(userDoc.subscription.status, 'active', 'Status should still be active');
-        assert.equal(userDoc.subscription.payment.processor, 'test', 'Processor should be test');
-        assert.equal(userDoc.subscription.payment.frequency, state.productB.frequency, `Frequency should be ${state.productB.frequency}`);
-        assert.equal(userDoc.subscription.payment.resourceId, state.subscriptionId, 'Resource ID should be the same subscription');
-      },
-    },
-
-    {
-      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.unified.product.id, state.productB.id, `Order product should be ${state.productB.id}`);
-        assert.equal(orderDoc.unified.status, 'active', 'Order status should be active');
-        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-refund-webhook.js

@@ -1,180 +0,0 @@
-/**
- * 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 processor library's getRefundDetails()
- * 4. Record the transition name on the webhook doc for auditing
- *
- * Product-agnostic: resolves the first paid product from config.payment.products
- */
-module.exports = {
-  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', {
-          processor: '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?processor=test&key=${config.backendManagerWebhookKey}`, {
-          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 processor)
-        // 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?processor=test&key=${config.backendManagerWebhookKey}`, {
-          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');
-      },
-    },
-  ],
-};

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

@@ -1,181 +0,0 @@
-/**
- * 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
- */
-module.exports = {
-  description: 'Payment journey: paid → suspended → recovered via test processor',
-  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', {
-          processor: '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?processor=test&key=${config.backendManagerWebhookKey}`, {
-          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?processor=test&key=${config.backendManagerWebhookKey}`, {
-          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.js

@@ -1,130 +0,0 @@
-/**
- * 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 processor for initial trial, then cancel endpoint for cancellation.
- * Product-agnostic: resolves the first paid product from config.payment.products
- */
-module.exports = {
-  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', {
-          processor: '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 processor 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');
-      },
-    },
-  ],
-};