backend-manager 5.9.4 → 5.9.6

package/test/events/auth-delete-race.js

@@ -1,201 +0,0 @@
-const uuid = require('uuid');
-
-/**
- * Test: auth:on-delete race condition
- *
- * Proves the emulator's async on-delete trigger clobbers freshly-recreated docs
- * when you don't wait for it to settle, and that the mitigation strategies work.
- *
- * The production fix uses the emulator's bulk-clear REST API in deleteTestUsers()
- * to avoid triggering on-delete at all during test setup.
- */
-module.exports = {
-  description: 'auth:on-delete race condition (create → delete → recreate)',
-  type: 'group',
-  timeout: 120000,
-
-  tests: [
-    {
-      name: 'baseline-create-and-verify',
-      async run({ Manager, assert }) {
-        const admin = Manager.libraries.admin;
-        const testUid = '_test-race-baseline';
-        const testEmail = '_test.race-baseline@test.com';
-        const userRef = admin.firestore().doc(`users/${testUid}`);
-
-        await admin.auth().deleteUser(testUid).catch(() => {});
-        await pollUntilGone(userRef);
-
-        await admin.auth().createUser({
-          uid: testUid,
-          email: testEmail,
-          password: uuid.v4(),
-          emailVerified: true,
-        });
-
-        const ready = await pollUntilReady(userRef);
-        assert.ok(ready, 'on-create should complete and write api keys');
-
-        const doc = await userRef.get();
-        assert.ok(doc.data()?.api?.clientId, 'doc should have api.clientId');
-        assert.ok(doc.data()?.api?.privateKey, 'doc should have api.privateKey');
-
-        await admin.auth().deleteUser(testUid).catch(() => {});
-        await pollUntilGone(userRef);
-      },
-    },
-
-    {
-      name: 'no-wait-gets-clobbered',
-      async run({ Manager, assert }) {
-        const admin = Manager.libraries.admin;
-        const testUid = '_test-race-no-wait';
-        const testEmail = '_test.race-no-wait@test.com';
-        const userRef = admin.firestore().doc(`users/${testUid}`);
-
-        await admin.auth().deleteUser(testUid).catch(() => {});
-        await pollUntilGone(userRef);
-
-        // Create and wait for doc to be fully ready
-        await admin.auth().createUser({
-          uid: testUid, email: testEmail,
-          password: uuid.v4(), emailVerified: true,
-        });
-        assert.ok(await pollUntilReady(userRef), 'First create should produce api keys');
-
-        // Delete auth user — do NOT wait for doc to disappear — then recreate
-        await admin.auth().deleteUser(testUid);
-        await admin.auth().createUser({
-          uid: testUid, email: testEmail,
-          password: uuid.v4(), emailVerified: true,
-        });
-        await pollUntilReady(userRef);
-
-        // The late on-delete clobbers the doc within a few seconds
-        await sleep(3000);
-        const doc = await userRef.get();
-        const survived = doc.exists && !!(doc.data()?.api?.clientId);
-
-        assert.ok(!survived, 'Doc should be clobbered by late on-delete (proves the race exists)');
-
-        await admin.auth().deleteUser(testUid).catch(() => {});
-        await pollUntilGone(userRef);
-      },
-    },
-
-    {
-      name: 'wait-for-gone-survives',
-      async run({ Manager, assert }) {
-        const admin = Manager.libraries.admin;
-        const testUid = '_test-race-wait-gone';
-        const testEmail = '_test.race-wait-gone@test.com';
-        const userRef = admin.firestore().doc(`users/${testUid}`);
-
-        await admin.auth().deleteUser(testUid).catch(() => {});
-        await pollUntilGone(userRef);
-
-        await admin.auth().createUser({
-          uid: testUid, email: testEmail,
-          password: uuid.v4(), emailVerified: true,
-        });
-        assert.ok(await pollUntilReady(userRef), 'First create should produce api keys');
-
-        // Delete and WAIT for doc to disappear before recreating
-        await admin.auth().deleteUser(testUid);
-        await pollUntilGone(userRef);
-
-        await admin.auth().createUser({
-          uid: testUid, email: testEmail,
-          password: uuid.v4(), emailVerified: true,
-        });
-        assert.ok(await pollUntilReady(userRef), 'Second create should produce api keys');
-
-        await sleep(3000);
-        const doc = await userRef.get();
-        const survived = doc.exists && !!(doc.data()?.api?.clientId);
-
-        assert.ok(survived, 'Doc should survive when we wait for on-delete to settle first');
-
-        await admin.auth().deleteUser(testUid).catch(() => {});
-        await pollUntilGone(userRef);
-      },
-    },
-
-    {
-      name: 'force-delete-doc-survives',
-      async run({ Manager, assert }) {
-        const admin = Manager.libraries.admin;
-        const testUid = '_test-race-force-del';
-        const testEmail = '_test.race-force-del@test.com';
-        const userRef = admin.firestore().doc(`users/${testUid}`);
-
-        await admin.auth().deleteUser(testUid).catch(() => {});
-        await pollUntilGone(userRef);
-
-        await admin.auth().createUser({
-          uid: testUid, email: testEmail,
-          password: uuid.v4(), emailVerified: true,
-        });
-        assert.ok(await pollUntilReady(userRef), 'First create should produce api keys');
-
-        // Delete auth user AND force-delete the Firestore doc, then pause
-        await admin.auth().deleteUser(testUid);
-        await userRef.delete().catch(() => {});
-        await sleep(500);
-
-        await admin.auth().createUser({
-          uid: testUid, email: testEmail,
-          password: uuid.v4(), emailVerified: true,
-        });
-        assert.ok(await pollUntilReady(userRef), 'Second create should produce api keys');
-
-        await sleep(3000);
-        const doc = await userRef.get();
-        const survived = doc.exists && !!(doc.data()?.api?.clientId);
-
-        assert.ok(survived, 'Doc should survive when we force-delete the doc before recreating');
-
-        await admin.auth().deleteUser(testUid).catch(() => {});
-        await pollUntilGone(userRef);
-      },
-    },
-  ],
-};
-
-function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms));
-}
-
-async function pollUntilReady(userRef, maxWait = 15000) {
-  const interval = 300;
-  let waited = 0;
-
-  while (waited < maxWait) {
-    const doc = await userRef.get();
-    const data = doc.exists ? doc.data() : null;
-    if (data?.metadata?.tag === 'auth:on-create' && data.api?.clientId && data.api?.privateKey) {
-      return true;
-    }
-    await sleep(interval);
-    waited += interval;
-  }
-
-  return false;
-}
-
-async function pollUntilGone(userRef, maxWait = 10000) {
-  const interval = 200;
-  let waited = 0;
-
-  while (waited < maxWait) {
-    const doc = await userRef.get();
-    if (!doc.exists) {
-      return true;
-    }
-    await sleep(interval);
-    waited += interval;
-  }
-
-  await userRef.delete().catch(() => {});
-  return false;
-}

package/test/events/payments/journey-payments-cancel-endpoint.js

@@ -1,100 +0,0 @@
-/**
- * Test: Payment Journey - Cancel via endpoint
- * Simulates: paid active → POST /payments/cancel → cancellation pending
- *
- * The test processor's cancelAtPeriodEnd writes a Stripe-shaped webhook doc directly
- * to payments-webhooks/{eventId}, triggering the full on-write pipeline automatically.
- * Product-agnostic: resolves the first paid product from config.payment.products
- */
-module.exports = {
-  description: 'Payment journey: cancel endpoint → cancellation pending',
-  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-cancel-route'].uid;
-        // Resolve first paid product from config. If the brand has none configured,
-        // skip the entire journey — this is a config-gap, not a code failure.
-        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
-        if (!paidProduct) {
-          skip('No paid product configured in this brand');
-        }
-
-        state.uid = uid;
-        state.paidProductId = paidProduct.id;
-        state.product = payments.products[paidProduct.id];
-        // Create subscription via test intent — auto-fires webhook pipeline
-        const response = await http.as('journey-payments-cancel-route').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 be ${paidProduct.id}`);
-        assert.equal(userDoc.subscription?.status, 'active', 'Should be active');
-        assert.equal(userDoc.subscription?.cancellation?.pending, false, 'Should not be pending cancellation');
-      },
-    },
-
-    {
-      name: 'call-cancel-endpoint',
-      async run({ http, assert }) {
-        // Test processor writes a payments-webhooks doc directly,
-        // triggering the on-write pipeline automatically — no manual webhook needed.
-        // skipGuards bypasses the 24-hour subscription-age guard.
-        const response = await http.as('journey-payments-cancel-route').post('backend-manager/payments/cancel', {
-          confirmed: true,
-          reason: 'Too expensive',
-          feedback: 'Would return at a lower price',
-          skipGuards: true,
-        });
-
-        assert.isSuccess(response, 'Cancel endpoint should succeed');
-        assert.equal(response.data.success, true, 'Should return { success: true }');
-      },
-    },
-
-    {
-      name: 'verify-cancellation-pending',
-      async run({ firestore, assert, state, waitFor }) {
-        // Poll user doc until the on-write pipeline updates subscription state
-        await waitFor(async () => {
-          const userDoc = await firestore.get(`users/${state.uid}`);
-          return userDoc?.subscription?.cancellation?.pending === true;
-        }, 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');
-        assert.ok(userDoc.subscription.cancellation.date.timestampUNIX > 0, 'Cancellation date should be set');
-      },
-    },
-
-    {
-      name: 'cancellation-request-stored',
-      async run({ firestore, assert, state }) {
-        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
-
-        assert.ok(orderDoc, 'Order doc should exist');
-        assert.ok(orderDoc.requests, 'requests field should exist');
-        assert.ok(orderDoc.requests.cancellation, 'requests.cancellation should be populated');
-        assert.equal(orderDoc.requests.cancellation.reason, 'Too expensive', 'Cancellation reason should match');
-        assert.equal(orderDoc.requests.cancellation.feedback, 'Would return at a lower price', 'Cancellation feedback should match');
-        assert.ok(orderDoc.requests.cancellation.date.timestampUNIX > 0, 'Cancellation date should be set');
-        assert.equal(orderDoc.requests.refund, null, 'requests.refund should still be null');
-      },
-    },
-  ],
-};

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

@@ -1,182 +0,0 @@
-/**
- * Test: Payment Journey - Cancel
- * Simulates: paid active → pending cancel → cancelled
- *
- * Uses test intent for initial subscription, then manual webhooks for cancel flow
- * Product-agnostic: resolves the first paid product from config.payment.products
- */
-module.exports = {
-  description: 'Payment journey: paid → pending cancel → cancelled',
-  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-cancel'].uid;
-
-        // Resolve first paid product from config. If the brand has none configured,
-        // skip the entire journey — this is a config-gap, not a code failure.
-        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices);
-        if (!paidProduct) {
-          skip('No paid product configured in this brand');
-        }
-
-        state.uid = uid;
-        state.paidProductId = paidProduct.id;
-        state.product = payments.products[paidProduct.id];
-
-        state.paidProductName = paidProduct.name;
-
-        // Create subscription via test intent
-        const response = await http.as('journey-payments-cancel').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-pending-cancel-webhook',
-      async run({ http, assert, state, config, payments }) {
-        const futureDate = new Date();
-        futureDate.setFullYear(futureDate.getFullYear() + 1);
-
-        state.eventId1 = `_test-evt-journey-cancel-pending-${Date.now()}`;
-
-        const response = await http.as('none').post(`backend-manager/payments/webhook?processor=test&key=${config.backendManagerWebhookKey}`, {
-          id: state.eventId1,
-          type: 'customer.subscription.updated',
-          data: {
-            object: {
-              id: state.subscriptionId,
-              object: 'subscription',
-              status: 'active',
-              metadata: { uid: state.uid, orderId: state.orderId },
-              cancel_at_period_end: true,
-              cancel_at: Math.floor(futureDate.getTime() / 1000),
-              canceled_at: null,
-              current_period_end: Math.floor(futureDate.getTime() / 1000),
-              current_period_start: Math.floor(Date.now() / 1000),
-              start_date: Math.floor(Date.now() / 1000) - 86400 * 30,
-              trial_start: null,
-              trial_end: null,
-              plan: { product: payments.stripeProductIds[state.paidProductId], interval: state.product.interval },
-            },
-          },
-        });
-
-        assert.isSuccess(response, 'Webhook should be accepted');
-      },
-    },
-
-    {
-      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 webhookDoc = await firestore.get(`payments-webhooks/${state.eventId1}`);
-        assert.equal(webhookDoc.transition, 'cancellation-requested', 'Transition should be cancellation-requested');
-
-        const userDoc = await firestore.get(`users/${state.uid}`);
-
-        assert.equal(userDoc.subscription.status, 'active', 'Status should still be active');
-        assert.equal(userDoc.subscription.cancellation.pending, true, 'Cancellation should be pending');
-      },
-    },
-
-    {
-      name: 'send-cancelled-webhook',
-      async run({ http, assert, state, config, payments }) {
-        state.eventId2 = `_test-evt-journey-cancel-final-${Date.now()}`;
-
-        const response = await http.as('none').post(`backend-manager/payments/webhook?processor=test&key=${config.backendManagerWebhookKey}`, {
-          id: state.eventId2,
-          type: 'customer.subscription.deleted',
-          data: {
-            object: {
-              id: state.subscriptionId,
-              object: 'subscription',
-              status: 'canceled',
-              metadata: { uid: state.uid, orderId: state.orderId },
-              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: { product: payments.stripeProductIds[state.paidProductId], interval: state.product.interval },
-            },
-          },
-        });
-
-        assert.isSuccess(response, 'Webhook should be accepted');
-      },
-    },
-
-    {
-      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 webhookDoc = await firestore.get(`payments-webhooks/${state.eventId2}`);
-        assert.equal(webhookDoc.transition, 'subscription-cancelled', 'Transition should be subscription-cancelled');
-
-        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: '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 (cancel was via webhook, not endpoint)');
-        assert.equal(orderDoc.requests.refund, null, 'requests.refund should be null');
-      },
-    },
-
-    {
-      name: 'intent-doc-completed',
-      async run({ firestore, assert, state }) {
-        const intentDoc = await firestore.get(`payments-intents/${state.orderId}`);
-
-        assert.ok(intentDoc, 'Intent doc should exist');
-        assert.equal(intentDoc.id, state.orderId, 'ID should match orderId');
-        assert.equal(intentDoc.status, 'completed', 'Intent status should be completed after webhook processing');
-        assert.ok(intentDoc.metadata?.completed?.timestampUNIX > 0, 'Completed timestamp should be set');
-      },
-    },
-  ],
-};

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

@@ -1,89 +0,0 @@
-/**
- * Test: Payment Journey - Subscription with Discount
- * Simulates: basic → paid subscription with WELCOME15 promo code → confirmation email with discount
- *
- * Verifies the discount flows through: intent → order → transition → email template
- * Product-agnostic: resolves the first paid product from config.payment.products
- */
-module.exports = {
-  description: 'Payment journey: subscription with discount code',
-  type: 'suite',
-  timeout: 30000,
-
-  tests: [
-    {
-      name: 'setup',
-      async run({ accounts, firestore, assert, state, config, skip, payments }) {
-        const uid = accounts['journey-payments-intent-discount'].uid;
-        const userDoc = await firestore.get(`users/${uid}`);
-
-        assert.ok(userDoc, 'User doc should exist');
-        assert.equal(userDoc.subscription?.product?.id, 'basic', 'Should start as basic');
-
-        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.prices && p.type === 'subscription');
-        if (!paidProduct) {
-          skip('No paid subscription product configured');
-        }
-
-        state.uid = uid;
-        state.paidProductId = paidProduct.id;
-        state.product = payments.products[paidProduct.id];
-      },
-    },
-
-    {
-      name: 'create-intent-with-discount',
-      async run({ http, assert, state }) {
-        const response = await http.as('journey-payments-intent-discount').post('backend-manager/payments/intent', {
-          processor: 'test',
-          productId: state.paidProductId,
-          frequency: state.product.frequency,
-          discount: 'WELCOME15',
-        });
-
-        assert.isSuccess(response, 'Intent with discount should succeed');
-        assert.ok(response.data.orderId, 'Should return orderId');
-
-        state.orderId = response.data.orderId;
-        state.eventId = response.data.id.replace('_test-cs-', '_test-evt-');
-      },
-    },
-
-    {
-      name: 'subscription-activated-with-discount',
-      async run({ firestore, assert, state, waitFor }) {
-        await waitFor(async () => {
-          const userDoc = await firestore.get(`users/${state.uid}`);
-          return userDoc?.subscription?.product?.id === state.paidProductId;
-        }, 15000, 500);
-
-        const userDoc = await firestore.get(`users/${state.uid}`);
-
-        assert.equal(userDoc.subscription.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);
-        assert.equal(userDoc.subscription.status, 'active', 'Status should be active');
-      },
-    },
-
-    {
-      name: 'order-has-discount',
-      async run({ firestore, assert, state }) {
-        const orderDoc = await firestore.get(`payments-orders/${state.orderId}`);
-
-        assert.ok(orderDoc, 'Order doc should exist');
-        assert.ok(orderDoc.discount, 'Order should have discount');
-        assert.equal(orderDoc.discount.code, 'WELCOME15', 'Discount code should be WELCOME15');
-        assert.equal(orderDoc.discount.percent, 15, 'Discount should be 15%');
-      },
-    },
-
-    {
-      name: 'webhook-transition-new-subscription',
-      async run({ firestore, assert, state }) {
-        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');
-      },
-    },
-  ],
-};