backend-manager 5.0.83 → 5.0.85

package/test/routes/payments/intent.js

@@ -0,0 +1,189 @@
+/**
+ * Test: POST /payments/intent
+ * Tests intent creation endpoint validation + end-to-end flow via test processor
+ *
+ * Validation tests use processor=stripe (fail at SDK step, proving validation logic)
+ * Success tests use processor=test (full intent→webhook→trigger pipeline)
+ *
+ * Product-agnostic: resolves the first paid product from config.payment.products
+ */
+module.exports = {
+  description: 'Payment intent creation',
+  type: 'group',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'rejects-unauthenticated',
+      auth: 'none',
+      async run({ http, assert, config }) {
+        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+
+        const response = await http.as('none').post('payments/intent', {
+          processor: 'stripe',
+          productId: paidProduct.id,
+          frequency: 'monthly',
+        });
+
+        assert.isError(response, 401, 'Should reject unauthenticated request');
+      },
+    },
+
+    {
+      name: 'rejects-missing-processor',
+      async run({ http, assert, config }) {
+        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+
+        const response = await http.as('basic').post('payments/intent', {
+          productId: paidProduct.id,
+          frequency: 'monthly',
+        });
+
+        assert.isError(response, 400, 'Should reject missing processor');
+      },
+    },
+
+    {
+      name: 'rejects-missing-product-id',
+      async run({ http, assert }) {
+        const response = await http.as('basic').post('payments/intent', {
+          processor: 'stripe',
+          frequency: 'monthly',
+        });
+
+        assert.isError(response, 400, 'Should reject missing productId');
+      },
+    },
+
+    {
+      name: 'rejects-missing-frequency',
+      async run({ http, assert, config }) {
+        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+
+        const response = await http.as('basic').post('payments/intent', {
+          processor: 'stripe',
+          productId: paidProduct.id,
+        });
+
+        assert.isError(response, 400, 'Should reject missing frequency');
+      },
+    },
+
+    {
+      name: 'rejects-active-paid-user',
+      auth: 'premium-active',
+      async run({ http, assert, config }) {
+        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+
+        const response = await http.as('premium-active').post('payments/intent', {
+          processor: 'stripe',
+          productId: paidProduct.id,
+          frequency: 'monthly',
+        });
+
+        assert.isError(response, 400, 'Should reject user with active subscription');
+      },
+    },
+
+    {
+      name: 'rejects-invalid-product',
+      async run({ http, assert }) {
+        const response = await http.as('basic').post('payments/intent', {
+          processor: 'stripe',
+          productId: 'nonexistent-product',
+          frequency: 'monthly',
+        });
+
+        assert.isError(response, 400, 'Should reject invalid product');
+      },
+    },
+
+    {
+      name: 'rejects-unknown-processor',
+      async run({ http, assert, config }) {
+        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+
+        const response = await http.as('basic').post('payments/intent', {
+          processor: 'unknown-processor',
+          productId: paidProduct.id,
+          frequency: 'monthly',
+        });
+
+        assert.isError(response, 400, 'Should reject unknown processor');
+      },
+    },
+
+    {
+      name: 'succeeds-with-test-processor',
+      async run({ http, assert, config, firestore, accounts, waitFor }) {
+        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
+
+        const response = await http.as('basic').post('payments/intent', {
+          processor: 'test',
+          productId: paidProduct.id,
+          frequency: 'monthly',
+        });
+
+        assert.isSuccess(response, 'Should succeed with test processor');
+        assert.ok(response.data.id, 'Should return intent ID');
+        assert.ok(response.data.url, 'Should return URL');
+
+        // Verify intent doc was saved
+        const intentDoc = await firestore.get(`payments-intents/${response.data.id}`);
+        assert.ok(intentDoc, 'Intent doc should exist');
+        assert.equal(intentDoc.processor, 'test', 'Processor should be test');
+        assert.equal(intentDoc.productId, paidProduct.id, 'Product should match');
+
+        // Clean up: wait for auto-webhook to process, then restore basic user
+        await waitFor(async () => {
+          const userDoc = await firestore.get(`users/${accounts.basic.uid}`);
+          return userDoc?.subscription?.product?.id === paidProduct.id;
+        }, 15000, 500).catch(() => {});
+
+        await firestore.set(`users/${accounts.basic.uid}`, {
+          subscription: { product: { id: 'basic' }, status: 'active' },
+        }, { merge: true });
+      },
+    },
+
+    {
+      name: 'downgrades-trial-for-user-with-history',
+      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}`;
+
+        // Create fake subscription history so user is ineligible for trial
+        await firestore.set(subDocPath, { uid, processor: 'test', status: 'cancelled' });
+
+        try {
+          const response = await http.as('basic').post('payments/intent', {
+            processor: 'test',
+            productId: paidProduct.id,
+            frequency: 'monthly',
+            trial: true,
+          });
+
+          // 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}`);
+          assert.equal(intentDoc.trial, false, 'Trial should be false (downgraded)');
+
+          // Clean up: wait for auto-webhook, restore basic user
+          await waitFor(async () => {
+            const userDoc = await firestore.get(`users/${uid}`);
+            return userDoc?.subscription?.product?.id === paidProduct.id;
+          }, 15000, 500).catch(() => {});
+
+          await firestore.set(`users/${uid}`, {
+            subscription: { product: { id: 'basic' }, status: 'active' },
+          }, { merge: true });
+        } finally {
+          await firestore.delete(subDocPath);
+        }
+      },
+    },
+  ],
+};

package/test/{payments → routes/payments}/webhook.js

@@ -2,7 +2,7 @@
  * Test: POST /payments/webhook
  * Tests the webhook endpoint validates requests and saves to Firestore
  */
-const { TEST_ACCOUNTS } = require('../../src/test/test-accounts.js');
+const { TEST_ACCOUNTS } = require('../../../src/test/test-accounts.js');
 
 module.exports = {
   description: 'Payment webhook endpoint',

package/test/routes/test/usage.js

@@ -171,17 +171,18 @@ module.exports = {
     {
       name: 'unauthenticated-usage-by-ip',
       async run({ http, assert, state }) {
-        // Unauthenticated requests use IP as key (127.0.0.1 in emulator)
-        state.unauthKey = '127.0.0.1';
+        // Unauthenticated requests use IP as key (no proxy headers in emulator, so falls back to 'unknown')
+        state.unauthKey = 'unknown';
 
         const response = await http.as('none').post('test/usage', {});
 
         assert.isSuccess(response, 'Unauthenticated usage increment should succeed');
         assert.equal(response.data.authenticated, false, 'Should report as unauthenticated');
-        assert.equal(response.data.key, state.unauthKey, 'Key should be 127.0.0.1');
+        assert.equal(response.data.key, state.unauthKey, 'Key should be unknown');
 
-        // Verify increment happened
-        assert.equal(response.data.after.period, 1, 'Period should be 1 after first increment');
+        // Verify increment happened (relative check — prior tests may have incremented too)
+        state.unauthPeriod = response.data.after.period;
+        assert.equal(response.data.after.period, response.data.before.period + 1, 'Period should increment by 1');
       },
     },
 
@@ -193,7 +194,7 @@ module.exports = {
 
         assert.ok(usageDoc, 'Usage doc should exist in usage collection');
         assert.ok(usageDoc?.requests, 'Usage doc should have the requests metric');
-        assert.equal(usageDoc.requests.period, 1, 'Persisted period should be 1');
+        assert.equal(usageDoc.requests.period, state.unauthPeriod, 'Persisted period should match');
       },
     },
 

package/test/routes/user/subscription.js

@@ -44,8 +44,8 @@ module.exports = {
 
         // Check trial structure
         assert.ok(
-          typeof subscription.trial.activated === 'boolean',
-          'trial.activated should be boolean'
+          typeof subscription.trial.claimed === 'boolean',
+          'trial.claimed should be boolean'
         );
 
         // Check payment structure

package/test/payments/intent.js

@@ -1,104 +0,0 @@
-/**
- * Test: POST /payments/intent
- * Tests intent creation endpoint validation
- *
- * Note: These tests validate the route logic (auth, validation, subscription checks)
- * They do NOT create real Stripe sessions since there's no Stripe key in test env
- */
-module.exports = {
-  description: 'Payment intent creation',
-  type: 'group',
-  timeout: 30000,
-
-  tests: [
-    {
-      name: 'rejects-unauthenticated',
-      auth: 'none',
-      async run({ http, assert }) {
-        const response = await http.as('none').post('payments/intent', {
-          processor: 'stripe',
-          productId: 'premium',
-          frequency: 'monthly',
-        });
-
-        assert.isError(response, 401, 'Should reject unauthenticated request');
-      },
-    },
-
-    {
-      name: 'rejects-missing-processor',
-      async run({ http, assert }) {
-        const response = await http.as('basic').post('payments/intent', {
-          productId: 'premium',
-          frequency: 'monthly',
-        });
-
-        assert.isError(response, 400, 'Should reject missing processor');
-      },
-    },
-
-    {
-      name: 'rejects-missing-product-id',
-      async run({ http, assert }) {
-        const response = await http.as('basic').post('payments/intent', {
-          processor: 'stripe',
-          frequency: 'monthly',
-        });
-
-        assert.isError(response, 400, 'Should reject missing productId');
-      },
-    },
-
-    {
-      name: 'rejects-missing-frequency',
-      async run({ http, assert }) {
-        const response = await http.as('basic').post('payments/intent', {
-          processor: 'stripe',
-          productId: 'premium',
-        });
-
-        assert.isError(response, 400, 'Should reject missing frequency');
-      },
-    },
-
-    {
-      name: 'rejects-active-premium-user',
-      auth: 'premium-active',
-      async run({ http, assert }) {
-        const response = await http.as('premium-active').post('payments/intent', {
-          processor: 'stripe',
-          productId: 'premium',
-          frequency: 'monthly',
-        });
-
-        assert.isError(response, 400, 'Should reject user with active subscription');
-      },
-    },
-
-    {
-      name: 'rejects-invalid-product',
-      async run({ http, assert }) {
-        const response = await http.as('basic').post('payments/intent', {
-          processor: 'stripe',
-          productId: 'nonexistent-product',
-          frequency: 'monthly',
-        });
-
-        assert.isError(response, 400, 'Should reject invalid product');
-      },
-    },
-
-    {
-      name: 'rejects-unknown-processor',
-      async run({ http, assert }) {
-        const response = await http.as('basic').post('payments/intent', {
-          processor: 'unknown-processor',
-          productId: 'premium',
-          frequency: 'monthly',
-        });
-
-        assert.isError(response, 400, 'Should reject unknown processor');
-      },
-    },
-  ],
-};

package/test/payments/journey-payment-cancel.js

@@ -1,166 +0,0 @@
-/**
- * Test: Payment Journey - Cancel
- * Simulates: premium active → pending cancel → cancelled
- *
- * Step 1: Webhook with cancel_at_period_end=true → cancellation.pending=true
- * Step 2: Webhook with status=canceled → status=cancelled, id=basic
- */
-const powertools = require('node-powertools');
-
-module.exports = {
-  description: 'Payment journey: premium → pending cancel → cancelled',
-  type: 'suite',
-  timeout: 30000,
-
-  tests: [
-    {
-      name: 'verify-starts-as-premium',
-      async run({ accounts, firestore, assert, state }) {
-        const uid = accounts['journey-payment-cancel'].uid;
-        const userDoc = await firestore.get(`users/${uid}`);
-
-        assert.ok(userDoc, 'User doc should exist');
-        assert.equal(userDoc.subscription?.product?.id, 'premium', 'Should start as premium');
-        assert.equal(userDoc.subscription?.status, 'active', 'Should be active');
-
-        state.uid = uid;
-        state.subscriptionId = '_test-sub-journey-cancel';
-      },
-    },
-
-    {
-      name: 'write-pending-cancel-webhook',
-      async run({ firestore, state }) {
-        const now = powertools.timestamp(new Date(), { output: 'string' });
-        const nowUNIX = powertools.timestamp(now, { output: 'unix' });
-        const futureDate = new Date();
-        futureDate.setFullYear(futureDate.getFullYear() + 1);
-
-        state.eventId1 = '_test-evt-journey-cancel-pending';
-
-        await firestore.delete(`payments-webhooks/${state.eventId1}`);
-        await firestore.delete(`payments-subscriptions/${state.subscriptionId}`);
-
-        // Webhook: active subscription with cancel_at_period_end = true
-        await firestore.set(`payments-webhooks/${state.eventId1}`, {
-          id: state.eventId1,
-          processor: 'stripe',
-          status: 'pending',
-          uid: state.uid,
-          event: { type: 'customer.subscription.updated' },
-          raw: {
-            id: state.eventId1,
-            type: 'customer.subscription.updated',
-            data: {
-              object: {
-                id: state.subscriptionId,
-                object: 'subscription',
-                status: 'active',
-                metadata: { uid: state.uid },
-                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: { id: 'price_xxx', interval: 'month' },
-              },
-            },
-          },
-          error: null,
-          metadata: {
-            received: { timestamp: now, timestampUNIX: nowUNIX },
-            processed: { timestamp: null, timestampUNIX: null },
-          },
-        });
-      },
-    },
-
-    {
-      name: 'pending-cancel-processed',
-      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 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: 'write-cancelled-webhook',
-      async run({ firestore, state }) {
-        const now = powertools.timestamp(new Date(), { output: 'string' });
-        const nowUNIX = powertools.timestamp(now, { output: 'unix' });
-
-        state.eventId2 = '_test-evt-journey-cancel-final';
-
-        await firestore.delete(`payments-webhooks/${state.eventId2}`);
-
-        // Webhook: subscription now cancelled
-        await firestore.set(`payments-webhooks/${state.eventId2}`, {
-          id: state.eventId2,
-          processor: 'stripe',
-          status: 'pending',
-          uid: state.uid,
-          event: { type: 'customer.subscription.deleted' },
-          raw: {
-            id: state.eventId2,
-            type: 'customer.subscription.deleted',
-            data: {
-              object: {
-                id: state.subscriptionId,
-                object: 'subscription',
-                status: 'canceled',
-                metadata: { uid: state.uid },
-                cancel_at_period_end: false,
-                canceled_at: Math.floor(Date.now() / 1000),
-                current_period_end: Math.floor(Date.now() / 1000),
-                current_period_start: Math.floor(Date.now() / 1000) - 86400 * 30,
-                start_date: Math.floor(Date.now() / 1000) - 86400 * 60,
-                trial_start: null,
-                trial_end: null,
-                plan: { id: 'price_xxx', interval: 'month' },
-              },
-            },
-          },
-          error: null,
-          metadata: {
-            received: { timestamp: now, timestampUNIX: nowUNIX },
-            processed: { timestamp: null, timestampUNIX: null },
-          },
-        });
-      },
-    },
-
-    {
-      name: 'subscription-cancelled',
-      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 userDoc = await firestore.get(`users/${state.uid}`);
-
-        assert.equal(userDoc.subscription.status, 'cancelled', 'Status should be cancelled');
-        assert.equal(userDoc.subscription.cancellation.pending, false, 'Cancellation should not be pending');
-      },
-    },
-
-    {
-      name: 'cleanup',
-      async run({ firestore, state }) {
-        await firestore.delete(`payments-webhooks/${state.eventId1}`);
-        await firestore.delete(`payments-webhooks/${state.eventId2}`);
-        await firestore.delete(`payments-subscriptions/${state.subscriptionId}`);
-      },
-    },
-  ],
-};

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

@@ -1,162 +0,0 @@
-/**
- * Test: Payment Journey - Suspend & Recover
- * Simulates: premium active → payment fails → suspended → payment succeeds → active again
- */
-const powertools = require('node-powertools');
-
-module.exports = {
-  description: 'Payment journey: premium → suspended → recovered',
-  type: 'suite',
-  timeout: 30000,
-
-  tests: [
-    {
-      name: 'verify-starts-as-premium',
-      async run({ accounts, firestore, assert, state }) {
-        const uid = accounts['journey-payment-suspend'].uid;
-        const userDoc = await firestore.get(`users/${uid}`);
-
-        assert.ok(userDoc, 'User doc should exist');
-        assert.equal(userDoc.subscription?.product?.id, 'premium', 'Should start as premium');
-        assert.equal(userDoc.subscription?.status, 'active', 'Should be active');
-
-        state.uid = uid;
-        state.subscriptionId = '_test-sub-journey-suspend';
-      },
-    },
-
-    {
-      name: 'write-past-due-webhook',
-      async run({ firestore, state }) {
-        const now = powertools.timestamp(new Date(), { output: 'string' });
-        const nowUNIX = powertools.timestamp(now, { output: 'unix' });
-
-        state.eventId1 = '_test-evt-journey-suspend-fail';
-
-        await firestore.delete(`payments-webhooks/${state.eventId1}`);
-        await firestore.delete(`payments-subscriptions/${state.subscriptionId}`);
-
-        // Webhook: subscription status changed to past_due
-        await firestore.set(`payments-webhooks/${state.eventId1}`, {
-          id: state.eventId1,
-          processor: 'stripe',
-          status: 'pending',
-          uid: state.uid,
-          event: { type: 'customer.subscription.updated' },
-          raw: {
-            id: state.eventId1,
-            type: 'customer.subscription.updated',
-            data: {
-              object: {
-                id: state.subscriptionId,
-                object: 'subscription',
-                status: 'past_due',
-                metadata: { uid: state.uid },
-                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: { id: 'price_xxx', interval: 'month' },
-              },
-            },
-          },
-          error: null,
-          metadata: {
-            received: { timestamp: now, timestampUNIX: nowUNIX },
-            processed: { timestamp: null, timestampUNIX: null },
-          },
-        });
-      },
-    },
-
-    {
-      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 userDoc = await firestore.get(`users/${state.uid}`);
-
-        assert.equal(userDoc.subscription.status, 'suspended', 'Status should be suspended');
-        assert.equal(userDoc.subscription.product.id, 'premium', 'Product should still be premium');
-      },
-    },
-
-    {
-      name: 'write-recovery-webhook',
-      async run({ firestore, state }) {
-        const now = powertools.timestamp(new Date(), { output: 'string' });
-        const nowUNIX = powertools.timestamp(now, { output: 'unix' });
-        const futureDate = new Date();
-        futureDate.setMonth(futureDate.getMonth() + 1);
-
-        state.eventId2 = '_test-evt-journey-suspend-recover';
-
-        await firestore.delete(`payments-webhooks/${state.eventId2}`);
-
-        // Webhook: subscription back to active after payment succeeds
-        await firestore.set(`payments-webhooks/${state.eventId2}`, {
-          id: state.eventId2,
-          processor: 'stripe',
-          status: 'pending',
-          uid: state.uid,
-          event: { type: 'customer.subscription.updated' },
-          raw: {
-            id: state.eventId2,
-            type: 'customer.subscription.updated',
-            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) - 86400 * 60,
-                trial_start: null,
-                trial_end: null,
-                plan: { id: 'price_xxx', interval: 'month' },
-              },
-            },
-          },
-          error: null,
-          metadata: {
-            received: { timestamp: now, timestampUNIX: nowUNIX },
-            processed: { timestamp: null, timestampUNIX: null },
-          },
-        });
-      },
-    },
-
-    {
-      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 userDoc = await firestore.get(`users/${state.uid}`);
-
-        assert.equal(userDoc.subscription.status, 'active', 'Status should be active again');
-        assert.equal(userDoc.subscription.product.id, 'premium', 'Product should still be premium');
-      },
-    },
-
-    {
-      name: 'cleanup',
-      async run({ firestore, state }) {
-        await firestore.delete(`payments-webhooks/${state.eventId1}`);
-        await firestore.delete(`payments-webhooks/${state.eventId2}`);
-        await firestore.delete(`payments-subscriptions/${state.subscriptionId}`);
-      },
-    },
-  ],
-};