backend-manager 5.9.7 → 5.9.9

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

@@ -0,0 +1,180 @@
+/**
+ * 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

@@ -0,0 +1,181 @@
+/**
+ * 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

@@ -0,0 +1,130 @@
+/**
+ * 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');
+      },
+    },
+  ],
+};

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

@@ -0,0 +1,171 @@
+/**
+ * Test: Payment Journey - Trial
+ * Simulates: basic user → trial activation via test intent → trial ends → active paid
+ *
+ * Uses the test processor for initial trial, then manual webhook for trial-to-active
+ * Product-agnostic: resolves the first paid product from config.payment.products
+ */
+module.exports = {
+  description: 'Payment journey: basic → trial → active paid via test processor',
+  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'].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 a trial from config. The test processor
+        // only creates a trialing subscription when product.trial.days > 0, so a
+        // brand whose paid products all have trial.days: 0 (e.g. trials disabled)
+        // has nothing to exercise here — skip the journey. This is a config-gap,
+        // not a code failure, and mirrors journey-payments-trial-cancel.js.
+        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices && p.trial?.days);
+        if (!paidProduct) {
+          skip('No paid product with trial configured in this brand');
+        }
+
+        state.uid = uid;
+        state.paidProductId = paidProduct.id;
+        state.product = payments.products[paidProduct.id];
+      },
+    },
+
+    {
+      name: 'create-trial-intent',
+      async run({ http, assert, state }) {
+        const response = await http.as('journey-payments-trial').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;
+
+        // Derive webhook event ID from intent ID (same timestamp)
+        state.eventId = response.data.id.replace('_test-cs-', '_test-evt-');
+      },
+    },
+
+    {
+      name: 'trial-activated',
+      async run({ firestore, assert, state, waitFor }) {
+        // Poll until trial subscription appears
+        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.payment.orderId, state.orderId, 'Order ID should match intent');
+
+        state.subscriptionId = userDoc.subscription.payment.resourceId;
+
+        // Verify the auto-fired webhook triggered new-subscription (trial is a property, not a separate transition)
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId}`);
+        assert.ok(webhookDoc, 'Webhook doc should exist');
+        assert.equal(webhookDoc.transition, 'new-subscription', 'Transition should be new-subscription (trial detected inside handler)');
+        assert.equal(webhookDoc.orderId, state.orderId, 'Webhook doc orderId should match intent');
+      },
+    },
+
+    {
+      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');
+      },
+    },
+
+    {
+      name: 'order-doc-created',
+      async run({ firestore, assert, state }) {
+        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
+
+        assert.ok(orderDoc, 'Order doc should exist');
+        assert.equal(orderDoc.id, state.orderId, 'ID should match orderId');
+        assert.equal(orderDoc.type, 'subscription', 'Type should be subscription');
+        assert.equal(orderDoc.owner, state.uid, 'Owner should match');
+        assert.equal(orderDoc.unified.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);
+        assert.equal(orderDoc.unified.trial.claimed, true, 'Trial should be claimed');
+        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: 'send-trial-to-active-webhook',
+      async run({ http, assert, state, config, payments }) {
+        const futureDate = new Date();
+        futureDate.setMonth(futureDate.getMonth() + 1);
+
+        state.eventId2 = `_test-evt-journey-trial-active-${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 * 14,
+              trial_start: Math.floor(Date.now() / 1000) - 86400 * 14,
+              trial_end: Math.floor(Date.now() / 1000),
+              plan: { product: payments.stripeProductIds[state.paidProductId], interval: state.product.interval },
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Webhook should be accepted');
+      },
+    },
+
+    {
+      name: 'trial-transitioned-to-active',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.eventId2}`);
+          return doc?.status === 'completed';
+        }, 15000, 500);
+
+        // Trial → active paid is the same status/product, so no transition fires
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId2}`);
+        assert.equal(webhookDoc.transition, null, 'No transition (same status/product, trial already claimed)');
+
+        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 remain claimed (historical)');
+        assert.equal(userDoc.subscription.payment.frequency, state.product.frequency, `Frequency should be ${state.product.frequency}`);
+      },
+    },
+  ],
+};