backend-manager 5.9.5 → 5.9.6

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

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

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

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

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