backend-manager 5.9.7 → 5.9.9

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

@@ -0,0 +1,146 @@
+/**
+ * Test: Payment Journey - Invoice Payment Failure
+ * Simulates: basic → paid subscription → invoice.payment_failed → suspended
+ *
+ * Unlike journey-payments-suspend (which uses customer.subscription.updated with past_due),
+ * this test uses the invoice.payment_failed event with billing_reason: subscription_cycle.
+ * This verifies the new parseWebhook routing that determines category from invoice data.
+ *
+ * Product-agnostic: resolves the first paid product from config.payment.products
+ */
+module.exports = {
+  description: 'Payment journey: paid → invoice.payment_failed → suspended',
+  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-failure'].uid;
+
+        // Resolve first paid subscription product. 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.type === 'subscription' && p.prices);
+        if (!paidProduct) {
+          skip('No paid subscription 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-failure').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-invoice-payment-failed',
+      async run({ http, assert, state, config }) {
+        state.eventId = `_test-evt-journey-failure-${Date.now()}`;
+
+        // Send invoice.payment_failed with subscription billing reason
+        // This tests the new parseWebhook routing: billing_reason=subscription_cycle → subscription category
+        const response = await http.as('none').post(`backend-manager/payments/webhook?processor=test&key=${config.backendManagerWebhookKey}`, {
+          id: state.eventId,
+          type: 'invoice.payment_failed',
+          data: {
+            object: {
+              id: `in_test_failure_${Date.now()}`,
+              object: 'invoice',
+              billing_reason: 'subscription_cycle',
+              amount_due: 999,
+              amount_paid: 0,
+              status: 'open',
+              parent: {
+                subscription_details: {
+                  subscription: state.subscriptionId,
+                  metadata: { uid: state.uid, orderId: state.orderId },
+                },
+                type: 'subscription_details',
+              },
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Webhook should be accepted');
+      },
+    },
+
+    {
+      name: 'verify-webhook-categorized-as-subscription',
+      async run({ firestore, assert, state, waitFor }) {
+        // Wait for webhook doc to be saved
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.eventId}`);
+          return doc?.status === 'completed' || doc?.status === 'failed';
+        }, 15000, 500);
+
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId}`);
+        assert.ok(webhookDoc, 'Webhook doc should exist');
+        assert.equal(webhookDoc.event?.category, 'subscription', 'Category should be subscription');
+        assert.equal(webhookDoc.event?.resourceType, 'subscription', 'Resource type should be subscription');
+        assert.equal(webhookDoc.event?.resourceId, state.subscriptionId, 'Resource ID should be subscription ID');
+        assert.equal(webhookDoc.transition, 'payment-failed', 'Transition should be payment-failed');
+      },
+    },
+
+    {
+      name: 'subscription-suspended',
+      async run({ firestore, assert, state }) {
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        assert.equal(userDoc.subscription.status, 'suspended', 'Status should be suspended after payment failure');
+        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 initial webhook processing');
+        assert.ok(intentDoc.metadata?.completed?.timestampUNIX > 0, 'Completed timestamp should be set');
+      },
+    },
+  ],
+};

package/test/events/payments/journey-payments-legacy-product.js

@@ -0,0 +1,149 @@
+/**
+ * Test: Payment Journey - Legacy Product ID Resolution
+ * Simulates: webhook with a legacy Stripe product ID → resolves to the correct product
+ *
+ * Verifies Fix 4: when an existing subscriber's webhook carries a legacy product ID
+ * (from before product migration), resolveProduct() checks stripe.legacyProductIds[]
+ * and maps it to the correct current product.
+ *
+ * Flow:
+ * 1. Find a config product that has stripe.legacyProductIds (skip if none)
+ * 2. Send a customer.subscription.created webhook with the legacy product ID in plan.product
+ * 3. Verify: subscription.product.id resolves to the correct (current) product ID
+ *
+ * This test is config-dependent — it requires at least one product with legacyProductIds.
+ * If no such product exists, the test skips gracefully.
+ */
+module.exports = {
+  description: 'Payment journey: webhook with legacy product ID → correct product resolution',
+  type: 'suite',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'find-product-with-legacy-ids',
+      async run({ accounts, assert, state, config }) {
+        const uid = accounts['journey-payments-legacy-product'].uid;
+        state.uid = uid;
+
+        // Find a paid product that has legacy Stripe product IDs configured
+        const productWithLegacy = config.payment?.products?.find(
+          p => p.id !== 'basic'
+            && p.prices?.monthly
+            && p.stripe?.legacyProductIds?.length > 0,
+        );
+
+        if (!productWithLegacy) {
+          state.skip = true;
+          console.log('No product with stripe.legacyProductIds found in config — skipping legacy product ID test');
+          return;
+        }
+
+        state.skip = false;
+        state.productId = productWithLegacy.id;
+        state.productName = productWithLegacy.name;
+        state.currentStripeProductId = productWithLegacy.stripe.productId;
+        state.legacyStripeProductId = productWithLegacy.stripe.legacyProductIds[0];
+
+        assert.ok(state.legacyStripeProductId, 'Legacy product ID should exist');
+        assert.notEqual(state.legacyStripeProductId, state.currentStripeProductId, 'Legacy ID should differ from current ID');
+      },
+    },
+
+    {
+      name: 'send-webhook-with-legacy-product-id',
+      async run({ http, assert, state, config }) {
+        if (state.skip) {
+          return;
+        }
+
+        const futureDate = new Date();
+        futureDate.setMonth(futureDate.getMonth() + 1);
+
+        state.legacyEventId = `_test-evt-journey-legacy-prod-${Date.now()}`;
+        state.subscriptionId = `sub_test_legacy_${Date.now()}`;
+
+        // Send a subscription created webhook with the LEGACY product ID
+        // This simulates an existing subscriber whose Stripe subscription still
+        // references the old product ID from before migration
+        const response = await http.as('none').post(`backend-manager/payments/webhook?processor=test&key=${config.backendManagerWebhookKey}`, {
+          id: state.legacyEventId,
+          type: 'customer.subscription.created',
+          data: {
+            object: {
+              id: state.subscriptionId,
+              object: 'subscription',
+              status: 'active',
+              metadata: { uid: state.uid },
+              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),
+              trial_start: null,
+              trial_end: null,
+              // KEY: use the LEGACY product ID, not the current one
+              plan: { product: state.legacyStripeProductId, interval: 'month' },
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Webhook with legacy product ID should be accepted');
+      },
+    },
+
+    {
+      name: 'legacy-product-resolved-correctly',
+      async run({ firestore, assert, state, waitFor }) {
+        if (state.skip) {
+          return;
+        }
+
+        // Wait for webhook to complete
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.legacyEventId}`);
+          return doc?.status === 'completed' || doc?.status === 'failed';
+        }, 15000, 500);
+
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.legacyEventId}`);
+        assert.equal(webhookDoc.status, 'completed', 'Webhook should complete successfully');
+        assert.equal(webhookDoc.transition, 'new-subscription', 'Transition should be new-subscription');
+
+        // Core assertion: the legacy product ID resolved to the correct current product
+        const userDoc = await firestore.get(`users/${state.uid}`);
+        assert.equal(
+          userDoc.subscription.product.id,
+          state.productId,
+          `Legacy product ID "${state.legacyStripeProductId}" should resolve to "${state.productId}" (not "basic")`,
+        );
+        assert.equal(userDoc.subscription.status, 'active', 'Status should be active');
+        assert.equal(userDoc.subscription.payment.processor, 'test', 'Processor should be test');
+      },
+    },
+
+    {
+      name: 'order-doc-has-correct-product',
+      async run({ firestore, assert, state }) {
+        if (state.skip) {
+          return;
+        }
+
+        // Find the order doc — legacy webhook may not have an orderId from metadata,
+        // so look it up by resourceId
+        const orderQuery = await firestore.query('payments-orders', {
+          where: [{ field: 'resourceId', op: '==', value: state.subscriptionId }],
+          limit: 1,
+        });
+
+        if (orderQuery && orderQuery.length > 0) {
+          const orderDoc = orderQuery[0];
+          assert.equal(
+            orderDoc.unified?.product?.id,
+            state.productId,
+            `Order unified product should be "${state.productId}"`,
+          );
+        }
+      },
+    },
+  ],
+};

package/test/events/payments/journey-payments-one-time-failure.js

@@ -0,0 +1,111 @@
+/**
+ * Test: Payment Journey - One-Time Payment Failure
+ * Simulates: invoice.payment_failed for a non-subscription invoice → purchase-failed transition
+ *
+ * This verifies the webhook routing for one-time invoice failures:
+ * invoice.payment_failed with no subscription billing_reason → category: 'one-time'
+ *
+ * Uses the journey-payments-one-time account (one-time events don't modify subscription state)
+ */
+module.exports = {
+  description: 'Payment journey: one-time invoice.payment_failed → purchase-failed',
+  type: 'suite',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'resolve-one-time-product',
+      async run({ accounts, assert, state, config, skip }) {
+        const uid = accounts['journey-payments-one-time'].uid;
+
+        // Resolve first one-time product from config. If none configured, skip the
+        // entire journey — this is a config-gap, not a code failure.
+        const oneTimeProduct = config.payment.products.find(p => p.type === 'one-time' && p.prices?.once);
+        if (!oneTimeProduct) {
+          skip('No one-time product configured in this brand');
+        }
+
+        state.uid = uid;
+        state.productId = oneTimeProduct.id;
+      },
+    },
+
+    {
+      name: 'send-one-time-payment-failed',
+      async run({ http, assert, state, config }) {
+        state.eventId = `_test-evt-journey-onetime-fail-${Date.now()}`;
+        state.invoiceId = `_test-inv-onetime-fail-${Date.now()}`;
+        state.orderId = `0000-0000-0000`; // Fake orderId for test
+
+        // Send invoice.payment_failed with a non-subscription billing reason
+        // This routes to category: 'one-time' in the webhook parser
+        const response = await http.as('none').post(`backend-manager/payments/webhook?processor=test&key=${config.backendManagerWebhookKey}`, {
+          id: state.eventId,
+          type: 'invoice.payment_failed',
+          data: {
+            object: {
+              id: state.invoiceId,
+              object: 'invoice',
+              billing_reason: 'manual',
+              amount_due: 999,
+              amount_paid: 0,
+              status: 'open',
+              metadata: {
+                uid: state.uid,
+                orderId: state.orderId,
+                productId: state.productId,
+              },
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Webhook should be accepted');
+      },
+    },
+
+    {
+      name: 'webhook-categorized-as-one-time',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.eventId}`);
+          return doc?.status === 'completed' || doc?.status === 'failed';
+        }, 15000, 500);
+
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId}`);
+        assert.ok(webhookDoc, 'Webhook doc should exist');
+        assert.equal(webhookDoc.event?.category, 'one-time', 'Category should be one-time');
+        assert.equal(webhookDoc.event?.resourceType, 'invoice', 'Resource type should be invoice');
+        assert.equal(webhookDoc.transition, 'purchase-failed', 'Transition should be purchase-failed');
+      },
+    },
+
+    {
+      name: 'order-doc-created-with-failure',
+      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, 'one-time', 'Type should be one-time');
+        assert.equal(orderDoc.owner, state.uid, 'Owner should match');
+        assert.equal(orderDoc.processor, 'test', 'Processor should be test');
+        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: 'subscription-unchanged',
+      async run({ firestore, assert, state }) {
+        // One-time payment failures must NOT modify subscription state
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        assert.equal(
+          userDoc.subscription?.product?.id,
+          'basic',
+          'Subscription should remain basic after one-time failure',
+        );
+      },
+    },
+  ],
+};

package/test/events/payments/journey-payments-one-time.js

@@ -0,0 +1,136 @@
+/**
+ * Test: Payment Journey - One-Time Purchase
+ * Simulates: user → test intent (one-time product) → auto-webhook → purchase-completed
+ *
+ * Uses the test processor to exercise the full intent→webhook→trigger pipeline
+ * for one-time payments. Unlike subscriptions, one-time payments only write to
+ * payments-orders/{orderId} — they do NOT modify users/{uid}.subscription.
+ *
+ * Requires at least one product with type: 'one-time' in config.payment.products
+ */
+module.exports = {
+  description: 'Payment journey: one-time purchase via test intent → purchase-completed',
+  type: 'suite',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'resolve-one-time-product',
+      async run({ accounts, firestore, assert, state, config, skip }) {
+        const uid = accounts['journey-payments-one-time'].uid;
+        const userDoc = await firestore.get(`users/${uid}`);
+
+        assert.ok(userDoc, 'User doc should exist');
+
+        // Resolve first one-time product from config. If the brand has none configured,
+        // skip the entire journey — this is a config-gap, not a code failure.
+        const oneTimeProduct = config.payment.products.find(p => p.type === 'one-time' && p.prices?.once);
+        if (!oneTimeProduct) {
+          skip('No one-time product configured in this brand');
+        }
+
+        state.uid = uid;
+        state.productId = oneTimeProduct.id;
+        state.productName = oneTimeProduct.name;
+        state.price = oneTimeProduct.prices.once;
+
+        // Snapshot subscription before purchase — should remain unchanged after
+        state.subscriptionBefore = userDoc.subscription || null;
+      },
+    },
+
+    {
+      name: 'create-one-time-intent',
+      async run({ http, assert, state }) {
+        const response = await http.as('journey-payments-one-time').post('backend-manager/payments/intent', {
+          processor: 'test',
+          productId: state.productId,
+        });
+
+        assert.isSuccess(response, 'Intent should succeed');
+        assert.ok(response.data.id, 'Should return intent ID');
+        assert.ok(response.data.orderId, 'Should return orderId');
+        assert.match(response.data.orderId, /^\d{4}-\d{4}-\d{4}$/, 'orderId should be XXXX-XXXX-XXXX format');
+        assert.ok(response.data.url, 'Should return URL');
+
+        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: 'webhook-transition-purchase-completed',
+      async run({ firestore, assert, state, waitFor }) {
+        // Poll until the webhook is processed
+        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, 'purchase-completed', 'Transition should be purchase-completed');
+        assert.equal(webhookDoc.orderId, state.orderId, 'Webhook doc orderId should match intent');
+        assert.equal(webhookDoc.event?.category, 'one-time', 'Category should be one-time');
+      },
+    },
+
+    {
+      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, 'one-time', 'Type should be one-time');
+        assert.equal(orderDoc.owner, state.uid, 'Owner should match');
+        assert.equal(orderDoc.processor, 'test', 'Processor should be test');
+        assert.equal(orderDoc.unified.product.id, state.productId, `Product should be ${state.productId}`);
+        assert.equal(orderDoc.unified.payment.processor, 'test', 'Unified processor should be test');
+        assert.equal(orderDoc.unified.payment.orderId, state.orderId, 'Unified orderId 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: 'subscription-unchanged',
+      async run({ firestore, assert, state }) {
+        // One-time payments must NOT modify users/{uid}.subscription
+        const userDoc = await firestore.get(`users/${state.uid}`);
+        const subAfter = userDoc.subscription || null;
+
+        assert.deepEqual(
+          subAfter?.product?.id,
+          state.subscriptionBefore?.product?.id,
+          'Subscription product should be unchanged after one-time purchase',
+        );
+        assert.deepEqual(
+          subAfter?.status,
+          state.subscriptionBefore?.status,
+          'Subscription status should be unchanged after one-time purchase',
+        );
+      },
+    },
+
+    {
+      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.intentId, state.intentId, 'Intent ID should match processor session ID');
+        assert.equal(intentDoc.owner, state.uid, 'Owner should match');
+        assert.equal(intentDoc.processor, 'test', 'Processor should be test');
+        assert.equal(intentDoc.status, 'completed', 'Intent status should be completed after webhook processing');
+        assert.equal(intentDoc.productId, state.productId, `Product should be ${state.productId}`);
+        assert.ok(intentDoc.metadata?.completed?.timestampUNIX > 0, 'Completed timestamp should be set');
+      },
+    },
+  ],
+};

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

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