backend-manager 5.0.88 → 5.0.91

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

@@ -0,0 +1,126 @@
+/**
+ * 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 }) {
+        const uid = accounts['journey-payments-plan-change'].uid;
+
+        // Resolve two distinct paid subscription products from config
+        const paidProducts = config.payment.products.filter(p => p.id !== 'basic' && p.type === 'subscription' && p.prices);
+        assert.ok(paidProducts.length >= 2, 'Config should have at least two paid subscription products');
+
+        const productA = paidProducts[0];
+        const productB = paidProducts[1];
+
+        state.uid = uid;
+        state.productA = { id: productA.id, name: productA.name, priceId: productA.prices.monthly.stripe };
+        state.productB = { id: productB.id, name: productB.name, priceId: productB.prices.monthly.stripe };
+
+        // Create subscription via test intent (product A)
+        const response = await http.as('journey-payments-plan-change').post('payments/intent', {
+          processor: 'test',
+          productId: productA.id,
+          frequency: 'monthly',
+        });
+        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 }) {
+        const futureDate = new Date();
+        futureDate.setMonth(futureDate.getMonth() + 1);
+
+        state.eventId = `_test-evt-journey-plan-change-${Date.now()}`;
+
+        // Send subscription.updated with a different product's price ID
+        const response = await http.as('none').post(`payments/webhook?processor=test&key=${config.backendManagerKey}`, {
+          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: { id: state.productB.priceId, interval: 'month' },
+            },
+          },
+        });
+
+        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, 'monthly', 'Frequency should be monthly');
+        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');
+      },
+    },
+  ],
+};

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

@@ -32,6 +32,7 @@ module.exports = {
           frequency: 'monthly',
         });
         assert.isSuccess(response, 'Intent should succeed');
+        state.orderId = response.data.orderId;
 
         // Wait for subscription to activate
         await waitFor(async () => {
@@ -42,6 +43,7 @@ module.exports = {
         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;
       },

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

@@ -43,8 +43,10 @@ module.exports = {
 
         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-');
@@ -65,6 +67,7 @@ module.exports = {
         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;
 
@@ -72,6 +75,7 @@ module.exports = {
         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');
       },
     },
 

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

@@ -42,9 +42,12 @@ module.exports = {
 
         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-');
@@ -65,6 +68,7 @@ module.exports = {
         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.payment.processor, 'test', 'Processor should be test');
+        assert.equal(userDoc.subscription.payment.orderId, state.orderId, 'Order ID should match intent');
         assert.ok(userDoc.subscription.payment.resourceId, 'Resource ID should be set');
         assert.equal(userDoc.subscription.payment.frequency, 'monthly', 'Frequency should be monthly');
         assert.equal(userDoc.subscription.cancellation.pending, false, 'Should not be pending cancellation');
@@ -74,15 +78,18 @@ module.exports = {
     },
 
     {
-      name: 'subscription-doc-created',
+      name: 'order-doc-created',
       async run({ firestore, assert, state }) {
-        const subDoc = await firestore.get(`payments-subscriptions/${state.subscriptionId}`);
-
-        assert.ok(subDoc, 'Subscription doc should exist');
-        assert.equal(subDoc.uid, state.uid, 'UID should match');
-        assert.equal(subDoc.processor, 'test', 'Processor should be test');
-        assert.equal(subDoc.subscription.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);
-        assert.equal(subDoc.subscription.status, 'active', 'Status should be active');
+        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.processor, 'test', 'Processor should be test');
+        assert.equal(orderDoc.resourceId, state.subscriptionId, 'Resource ID should match');
+        assert.equal(orderDoc.unified.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);
+        assert.equal(orderDoc.unified.status, 'active', 'Status should be active');
       },
     },
 
@@ -97,16 +104,19 @@ module.exports = {
         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');
+        assert.equal(webhookDoc.orderId, state.orderId, 'Webhook doc orderId should match intent');
       },
     },
 
     {
       name: 'intent-doc-created',
       async run({ firestore, assert, state }) {
-        const intentDoc = await firestore.get(`payments-intents/${state.intentId}`);
+        const intentDoc = await firestore.get(`payments-intents/${state.orderId}`);
 
         assert.ok(intentDoc, 'Intent doc should exist');
-        assert.equal(intentDoc.uid, state.uid, 'UID should match');
+        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, 'pending', 'Intent status should be pending');
         assert.equal(intentDoc.productId, state.paidProductId, `Product should be ${state.paidProductId}`);

package/test/helpers/stripe-to-unified.js

@@ -365,6 +365,22 @@ module.exports = {
       },
     },
 
+    {
+      name: 'payment-order-id-from-metadata',
+      async run({ assert }) {
+        const result = toUnifiedSubscription({ metadata: { orderId: '1234-5678-9012' } });
+        assert.equal(result.payment.orderId, '1234-5678-9012', 'orderId should come from metadata');
+      },
+    },
+
+    {
+      name: 'payment-order-id-null-when-missing',
+      async run({ assert }) {
+        const result = toUnifiedSubscription({});
+        assert.equal(result.payment.orderId, null, 'Missing metadata → null orderId');
+      },
+    },
+
     {
       name: 'payment-event-metadata-passed-through',
       async run({ assert }) {
@@ -432,6 +448,7 @@ module.exports = {
         assert.equal(result.trial.claimed, false, 'Empty → trial not claimed');
         assert.equal(result.cancellation.pending, false, 'Empty → not pending');
         assert.equal(result.payment.processor, 'stripe', 'Empty → still stripe');
+        assert.equal(result.payment.orderId, null, 'Empty → null orderId');
         assert.equal(result.payment.resourceId, null, 'Empty → null resourceId');
         assert.equal(result.payment.frequency, null, 'Empty → null frequency');
       },

package/test/helpers/user.js

@@ -393,6 +393,7 @@ module.exports = {
         });
 
         assert.equal(user.subscription.payment.processor, 'stripe', 'processor preserved');
+        assert.equal(user.subscription.payment.orderId, null, 'missing orderId defaults to null');
         assert.equal(user.subscription.payment.resourceId, 'sub_123', 'resourceId preserved');
         assert.equal(user.subscription.payment.frequency, null, 'missing frequency defaults to null');
         assert.ok(user.subscription.payment.startDate.timestamp, 'missing startDate gets default');

package/test/routes/payments/intent.js

@@ -126,11 +126,14 @@ module.exports = {
 
         assert.isSuccess(response, 'Should succeed with test processor');
         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');
 
-        // Verify intent doc was saved
-        const intentDoc = await firestore.get(`payments-intents/${response.data.id}`);
+        // Verify intent doc was saved (keyed by orderId)
+        const intentDoc = await firestore.get(`payments-intents/${response.data.orderId}`);
         assert.ok(intentDoc, 'Intent doc should exist');
+        assert.equal(intentDoc.intentId, response.data.id, 'Intent ID should match response');
         assert.equal(intentDoc.processor, 'test', 'Processor should be test');
         assert.equal(intentDoc.productId, paidProduct.id, 'Product should match');
 
@@ -151,10 +154,10 @@ module.exports = {
       async run({ http, assert, config, accounts, firestore, waitFor }) {
         const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
         const uid = accounts.basic.uid;
-        const subDocPath = `payments-subscriptions/_test-sub-history-${uid}`;
+        const orderDocPath = `payments-orders/_test-order-history-${uid}`;
 
         // Create fake subscription history so user is ineligible for trial
-        await firestore.set(subDocPath, { uid, processor: 'test', status: 'cancelled' });
+        await firestore.set(orderDocPath, { owner: uid, type: 'subscription', processor: 'test', status: 'cancelled' });
 
         try {
           const response = await http.as('basic').post('payments/intent', {
@@ -167,8 +170,8 @@ module.exports = {
           // Should succeed (not reject with 400) — trial silently downgraded
           assert.isSuccess(response, 'Should not reject — trial silently downgraded');
 
-          // Verify intent saved with trial=false
-          const intentDoc = await firestore.get(`payments-intents/${response.data.id}`);
+          // Verify intent saved with trial=false (keyed by orderId)
+          const intentDoc = await firestore.get(`payments-intents/${response.data.orderId}`);
           assert.equal(intentDoc.trial, false, 'Trial should be false (downgraded)');
 
           // Clean up: wait for auto-webhook, restore basic user
@@ -181,7 +184,7 @@ module.exports = {
             subscription: { product: { id: 'basic' }, status: 'active' },
           }, { merge: true });
         } finally {
-          await firestore.delete(subDocPath);
+          await firestore.delete(orderDocPath);
         }
       },
     },