backend-manager 5.1.2 → 5.2.0

package/src/test/test-accounts.js

@@ -162,6 +162,33 @@ const STATIC_ACCOUNTS = {
       subscription: { product: { id: 'basic' }, status: 'active' },
     },
   },
+  'consent-granted': {
+    id: 'consent-granted',
+    uid: '_test-consent-granted',
+    email: '_test.consent-granted@{domain}',
+    properties: {
+      roles: {},
+      subscription: { product: { id: 'basic' }, status: 'active' },
+    },
+  },
+  'consent-declined': {
+    id: 'consent-declined',
+    uid: '_test-consent-declined',
+    email: '_test.consent-declined@{domain}',
+    properties: {
+      roles: {},
+      subscription: { product: { id: 'basic' }, status: 'active' },
+    },
+  },
+  'consent-missing': {
+    id: 'consent-missing',
+    uid: '_test-consent-missing',
+    email: '_test.consent-missing@{domain}',
+    properties: {
+      roles: {},
+      subscription: { product: { id: 'basic' }, status: 'active' },
+    },
+  },
 };
 
 /**
@@ -652,15 +679,53 @@ async function deleteTestUsers(admin) {
     })
   );
 
-  // Clean up payment-related collections for test accounts
+  // Clean up payment-related collections for test accounts.
+  // Two passes per collection:
+  //   1. owner-keyed: query by owner ∈ test uids (Firestore `in` caps at 30; batch).
+  //   2. id-keyed:    delete any doc whose id starts with the `_test-` prefix.
+  // Pass 2 catches docs that have no owner field (e.g. dispute alerts, raw test webhooks).
+  // All test-fixture IDs MUST start with `_test-` — that's the cleanup contract.
   const testUids = Object.values(TEST_ACCOUNTS).map(a => a.uid);
-  const paymentCollections = ['payments-orders', 'payments-webhooks', 'payments-intents'];
+  // Collections that may carry test data tied to a test user (owner-keyed) or
+  // identified solely by an `_test-` doc id prefix (id-keyed). All must be wiped
+  // at the start of every run so a test that died mid-execution leaves no
+  // ghosts. New collections that participate in tests MUST be added here too.
+  const testDataCollections = ['payments-orders', 'payments-webhooks', 'payments-intents', 'payments-disputes', 'marketing-webhooks'];
+  // Collections that exist solely for tests — wipe in full. All docs in these
+  // collections come from tests, so a single recursive delete handles cleanup.
+  const testOnlyCollections = ['_test', '_test_query'];
+  const UID_BATCH_SIZE = 30;
+  const TEST_ID_PREFIX = '_test-';
+
+  const uidBatches = [];
+  for (let i = 0; i < testUids.length; i += UID_BATCH_SIZE) {
+    uidBatches.push(testUids.slice(i, i + UID_BATCH_SIZE));
+  }
 
-  await Promise.all(
-    paymentCollections.map(async (collection) => {
+  await Promise.all([
+    // Mixed collections: scoped delete of test data only.
+    ...testDataCollections.map(async (collection) => {
+      // Pass 1 — owner-keyed
+      for (const batch of uidBatches) {
+        try {
+          const snapshot = await admin.firestore().collection(collection)
+            .where('owner', 'in', batch)
+            .get();
+
+          await Promise.all(
+            snapshot.docs.map(doc => doc.ref.delete())
+          );
+        } catch (e) {
+          // Collection may not exist yet, or doesn't carry an owner field — ignore
+        }
+      }
+
+      // Pass 2 — id-keyed (catches ownerless test docs)
+      // documentId() range scan: `_test-` ≤ id < `_test.` (the next ASCII char after `-` is `.`)
       try {
         const snapshot = await admin.firestore().collection(collection)
-          .where('owner', 'in', testUids)
+          .where(admin.firestore.FieldPath.documentId(), '>=', TEST_ID_PREFIX)
+          .where(admin.firestore.FieldPath.documentId(), '<', '_test.')
           .get();
 
         await Promise.all(
@@ -669,8 +734,25 @@ async function deleteTestUsers(admin) {
       } catch (e) {
         // Collection may not exist yet — ignore
       }
-    })
-  );
+    }),
+    // Test-only Firestore collections: wipe in full.
+    ...testOnlyCollections.map(async (collection) => {
+      try {
+        const snapshot = await admin.firestore().collection(collection).get();
+        await Promise.all(snapshot.docs.map(doc => doc.ref.delete()));
+      } catch (e) {
+        // Collection may not exist yet — ignore
+      }
+    }),
+    // Realtime Database: wipe the `_test` namespace in full.
+    (async () => {
+      try {
+        await admin.database().ref('_test').remove();
+      } catch (e) {
+        // RTDB may not be configured for this project — ignore
+      }
+    })(),
+  ]);
 
   return {
     success: results.failed.length === 0,
@@ -728,16 +810,16 @@ const TEST_DATA = {
  * Called after account setup when TEST_EXTENDED_MODE is set to remove
  * contacts added by auth:on-create
  * @param {string} domain - Domain for email addresses
- * @param {object} options - Options with hostingUrl and backendManagerKey
+ * @param {object} options - Options with apiUrl and backendManagerKey
  * @returns {Promise<object>} Result with cleaned count
  */
 async function cleanupMarketingProviders(domain, options = {}) {
   const fetch = require('wonderful-fetch');
   const results = { cleaned: 0, errors: [] };
 
-  const { hostingUrl, backendManagerKey } = options;
-  if (!hostingUrl || !backendManagerKey) {
-    console.error('cleanupMarketingProviders: Missing hostingUrl or backendManagerKey');
+  const { apiUrl, backendManagerKey } = options;
+  if (!apiUrl || !backendManagerKey) {
+    console.error('cleanupMarketingProviders: Missing apiUrl or backendManagerKey');
     return results;
   }
 
@@ -749,7 +831,7 @@ async function cleanupMarketingProviders(domain, options = {}) {
   await Promise.all(
     emails.map(async (email) => {
       try {
-        const response = await fetch(`${hostingUrl}/backend-manager/marketing/contact`, {
+        const response = await fetch(`${apiUrl}/backend-manager/marketing/contact`, {
           method: 'DELETE',
           response: 'json',
           timeout: 30000,

package/src/test/utils/http-client.js

@@ -11,9 +11,10 @@ class HttpClient {
   constructor(options) {
     options = options || {};
 
-    // Use hosting URL (port 5002) for all requests, not functions URL (port 5001)
-    // All requests go through /backend-manager which rewrites to bm_api function
-    this.baseUrl = options.hostingUrl || '';
+    // Use API URL (port 5002, the hosting emulator) for all requests, not the
+    // functions URL (port 5001). All requests go through /backend-manager which
+    // rewrites to the bm_api function.
+    this.baseUrl = options.apiUrl || '';
     this.defaultHeaders = {};
     this.defaultAuthParams = {};
     this.timeout = options.timeout || 30000;

package/src/test/utils/test-mode-file.js

@@ -0,0 +1,192 @@
+/**
+ * Shared state file that lets the test command and the running emulator
+ * agree on a small set of env vars without coordinated shell flags.
+ *
+ * The test command writes this file pre-flight (before invoking the runner).
+ * The emulator process watches it and mutates the corresponding entries in
+ * `process.env` in place when it changes. All existing branch sites read
+ * `process.env.X` per call so the mutation is invisible to them — no
+ * code-branch refactor needed.
+ *
+ * File lives at `<consumerProject>/.temp/test-mode.json` — `.temp/` is the
+ * standard transient cache directory across UJM/BXM/EM/BEM consumer projects
+ * (sits at the repo root, gitignored by default).
+ *
+ * ## Allowlist
+ *
+ * `SYNCED_ENV_KEYS` is the explicit list of env vars allowed to flow from the
+ * test command into the emulator. Adding a new live-sync var = one-line addition.
+ *
+ * Why an allowlist (not "sync everything"):
+ *   - Some env vars are process-specific (e.g. FIRESTORE_EMULATOR_HOST is only
+ *     correct on the test runner, never on the emulator) and would break things
+ *     if synced. The allowlist prevents that.
+ *   - Sensitive values (API keys) shouldn't be silently overwritten on the
+ *     emulator just because the test runner happens to have them set.
+ *   - Keeps mutation explicit and reviewable.
+ *
+ * File format:
+ *   {
+ *     "env": {
+ *       "TEST_EXTENDED_MODE": "true"
+ *     },
+ *     "updatedAt": "2026-05-14T..."
+ *   }
+ *
+ * Values are strings to match `process.env` semantics. Empty string means
+ * "unset" — applyEnvFromFile() will `delete process.env[key]` when the value
+ * is empty, matching the way Node treats unset vs falsy env vars.
+ */
+const path = require('path');
+const jetpack = require('fs-jetpack');
+
+const TEST_MODE_FILENAME = 'test-mode.json';
+const TEMP_DIR_NAME = '.temp';
+
+// Explicit allowlist of env vars that flow from the test command into the
+// running emulator. Add a key here to make it live-syncable; nothing else
+// flows through.
+const SYNCED_ENV_KEYS = [
+  'TEST_EXTENDED_MODE',
+];
+
+/**
+ * Resolve the absolute path to the test-mode file for a given consumer project.
+ *
+ * @param {string} projectDir - Consumer project root (the directory that
+ *                               contains `firebase.json` / `functions/`).
+ * @returns {string} Absolute path to `<projectDir>/.temp/test-mode.json`.
+ */
+function getTestModeFilePath(projectDir) {
+  return path.join(projectDir, TEMP_DIR_NAME, TEST_MODE_FILENAME);
+}
+
+/**
+ * Read the current test-mode payload from disk. Tolerant — returns `null`
+ * if the file is missing or unreadable, never throws.
+ *
+ * @param {string} projectDir
+ * @returns {{ env: Object<string, string>, updatedAt: string } | null}
+ */
+function readTestMode(projectDir) {
+  const filePath = getTestModeFilePath(projectDir);
+
+  if (!jetpack.exists(filePath)) {
+    return null;
+  }
+
+  try {
+    const data = jetpack.read(filePath, 'json');
+    if (!data || typeof data !== 'object') {
+      return null;
+    }
+    return {
+      env: (data.env && typeof data.env === 'object') ? data.env : {},
+      updatedAt: data.updatedAt || null,
+    };
+  } catch (e) {
+    return null;
+  }
+}
+
+/**
+ * Write the desired env subset to disk. Atomic via fs-jetpack. Creates the
+ * `.temp/` directory if missing. Filters input through SYNCED_ENV_KEYS so
+ * only allowlisted keys are persisted, even if the caller passes extras.
+ *
+ * @param {string} projectDir
+ * @param {Object<string, string|undefined>} envInput - Map of env vars to sync.
+ *                                                       Keys outside SYNCED_ENV_KEYS are dropped.
+ *                                                       Empty/undefined values are persisted as ''
+ *                                                       (meaning "unset on receiving side").
+ * @returns {string} Absolute path of the written file (for logging).
+ */
+function writeTestMode(projectDir, envInput) {
+  const filePath = getTestModeFilePath(projectDir);
+  const env = {};
+
+  for (const key of SYNCED_ENV_KEYS) {
+    const v = envInput?.[key];
+    env[key] = v == null ? '' : String(v);
+  }
+
+  const payload = {
+    env,
+    updatedAt: new Date().toISOString(),
+  };
+
+  jetpack.write(filePath, payload, { atomic: true });
+
+  return filePath;
+}
+
+/**
+ * Capture the allowlisted subset of `process.env` into a plain object.
+ * Convenience for callers that want to write "whatever I currently have".
+ *
+ * @param {NodeJS.ProcessEnv} [source=process.env]
+ * @returns {Object<string, string>}
+ */
+function captureSyncedEnv(source) {
+  const src = source || process.env;
+  const out = {};
+
+  for (const key of SYNCED_ENV_KEYS) {
+    out[key] = src[key] == null ? '' : String(src[key]);
+  }
+
+  return out;
+}
+
+/**
+ * Apply a `data.env` payload to the current process's `process.env`. Used by
+ * the watcher inside the emulator process. Returns a list of `{key, was, now}`
+ * for any key that actually changed (caller can log these).
+ *
+ * Empty-string values in the payload are treated as "unset" — the
+ * corresponding `process.env[key]` is deleted. This matches Node semantics
+ * where `delete process.env.X` makes `process.env.X === undefined` and
+ * `!!process.env.X === false`.
+ *
+ * @param {{ env: Object<string, string> } | null} data
+ * @returns {Array<{ key: string, was: string|undefined, now: string|undefined }>}
+ */
+function applyEnvFromFile(data) {
+  if (!data || !data.env) {
+    return [];
+  }
+
+  const changed = [];
+
+  for (const key of SYNCED_ENV_KEYS) {
+    if (!Object.prototype.hasOwnProperty.call(data.env, key)) {
+      continue;
+    }
+
+    const was = process.env[key];
+    const next = data.env[key];
+
+    if (next === '' || next == null) {
+      if (was != null) {
+        delete process.env[key];
+        changed.push({ key, was, now: undefined });
+      }
+    } else if (was !== next) {
+      process.env[key] = next;
+      changed.push({ key, was, now: next });
+    }
+  }
+
+  return changed;
+}
+
+module.exports = {
+  TEST_MODE_FILENAME,
+  TEMP_DIR_NAME,
+  SYNCED_ENV_KEYS,
+  getTestModeFilePath,
+  readTestMode,
+  writeTestMode,
+  captureSyncedEnv,
+  applyEnvFromFile,
+};

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

@@ -44,26 +44,17 @@ module.exports = {
       },
     },
 
-    {
-      name: 'backdate-start-date',
-      async run({ firestore, state }) {
-        // Backdate startDate so the 24-hour guard doesn't block cancellation
-        const twoDaysAgo = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000);
-        await firestore.set(`users/${state.uid}`, {
-          subscription: { payment: { startDate: { timestamp: twoDaysAgo.toISOString(), timestampUNIX: twoDaysAgo.getTime() } } },
-        }, { merge: true });
-      },
-    },
-
     {
       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
+        // 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('payments/cancel', {
           confirmed: true,
           reason: 'Too expensive',
           feedback: 'Would return at a lower price',
+          skipGuards: true,
         });
 
         assert.isSuccess(response, 'Cancel endpoint should succeed');

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

@@ -23,7 +23,6 @@ module.exports = {
         state.uid = uid;
         state.paidProductId = paidProduct.id;
         state.paidProductName = paidProduct.name;
-        state.paidStripeProductId = paidProduct.stripe?.productId;
 
         // Create subscription via test intent
         const response = await http.as('journey-payments-cancel').post('payments/intent', {
@@ -51,7 +50,7 @@ module.exports = {
 
     {
       name: 'send-pending-cancel-webhook',
-      async run({ http, assert, state, config }) {
+      async run({ http, assert, state, config, payments }) {
         const futureDate = new Date();
         futureDate.setFullYear(futureDate.getFullYear() + 1);
 
@@ -74,7 +73,7 @@ module.exports = {
               start_date: Math.floor(Date.now() / 1000) - 86400 * 30,
               trial_start: null,
               trial_end: null,
-              plan: { product: state.paidStripeProductId, interval: 'month' },
+              plan: { product: payments.stripeProductIds[state.paidProductId], interval: 'month' },
             },
           },
         });
@@ -103,7 +102,7 @@ module.exports = {
 
     {
       name: 'send-cancelled-webhook',
-      async run({ http, assert, state, config }) {
+      async run({ http, assert, state, config, payments }) {
         state.eventId2 = `_test-evt-journey-cancel-final-${Date.now()}`;
 
         const response = await http.as('none').post(`payments/webhook?processor=test&key=${config.backendManagerKey}`, {
@@ -122,7 +121,7 @@ module.exports = {
               start_date: Math.floor(Date.now() / 1000) - 86400 * 60,
               trial_start: null,
               trial_end: null,
-              plan: { product: state.paidStripeProductId, interval: 'month' },
+              plan: { product: payments.stripeProductIds[state.paidProductId], interval: 'month' },
             },
           },
         });

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

@@ -26,7 +26,6 @@ module.exports = {
         state.uid = uid;
         state.paidProductId = paidProduct.id;
         state.paidProductName = paidProduct.name;
-        state.paidStripeProductId = paidProduct.stripe?.productId;
 
         // Create subscription via test intent
         const response = await http.as('journey-payments-failure').post('payments/intent', {

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

@@ -15,12 +15,15 @@ module.exports = {
   tests: [
     {
       name: 'resolve-one-time-product',
-      async run({ accounts, assert, state, config }) {
+      async run({ accounts, assert, state, config, skip }) {
         const uid = accounts['journey-payments-one-time'].uid;
 
-        // Resolve first one-time product from config
+        // 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);
-        assert.ok(oneTimeProduct, 'Config should have at least one one-time product');
+        if (!oneTimeProduct) {
+          skip('No one-time product configured in this brand');
+        }
 
         state.uid = uid;
         state.productId = oneTimeProduct.id;

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

@@ -16,15 +16,18 @@ module.exports = {
   tests: [
     {
       name: 'resolve-one-time-product',
-      async run({ accounts, firestore, assert, state, config }) {
+      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
+        // 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);
-        assert.ok(oneTimeProduct, 'Config should have at least one one-time product');
+        if (!oneTimeProduct) {
+          skip('No one-time product configured in this brand');
+        }
 
         state.uid = uid;
         state.productId = oneTimeProduct.id;

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

@@ -24,8 +24,8 @@ module.exports = {
         const productB = paidProducts[1];
 
         state.uid = uid;
-        state.productA = { id: productA.id, name: productA.name, stripeProductId: productA.stripe?.productId };
-        state.productB = { id: productB.id, name: productB.name, stripeProductId: productB.stripe?.productId };
+        state.productA = { id: productA.id, name: productA.name };
+        state.productB = { id: productB.id, name: productB.name };
 
         // Create subscription via test intent (product A)
         const response = await http.as('journey-payments-plan-change').post('payments/intent', {
@@ -52,13 +52,13 @@ module.exports = {
 
     {
       name: 'send-plan-change-webhook',
-      async run({ http, assert, state, config }) {
+      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 a different product's Stripe product ID
+        // Send subscription.updated with product B's Stripe product ID (or test sentinel)
         const response = await http.as('none').post(`payments/webhook?processor=test&key=${config.backendManagerKey}`, {
           id: state.eventId,
           type: 'customer.subscription.updated',
@@ -75,7 +75,7 @@ module.exports = {
               start_date: Math.floor(Date.now() / 1000) - 86400 * 30,
               trial_start: null,
               trial_end: null,
-              plan: { product: state.productB.stripeProductId, interval: 'month' },
+              plan: { product: payments.stripeProductIds[state.productB.id], interval: 'month' },
             },
           },
         });

package/test/events/payments/journey-payments-refund-webhook.js

@@ -26,7 +26,6 @@ module.exports = {
 
         state.uid = uid;
         state.paidProductId = paidProduct.id;
-        state.paidStripeProductId = paidProduct.stripe?.productId;
 
         // Create subscription via test intent
         const response = await http.as('journey-payments-refund-webhook').post('payments/intent', {
@@ -54,7 +53,7 @@ module.exports = {
 
     {
       name: 'send-pending-cancel-webhook',
-      async run({ http, assert, state, config }) {
+      async run({ http, assert, state, config, payments }) {
         const futureDate = new Date();
         futureDate.setMonth(futureDate.getMonth() + 1);
 
@@ -77,7 +76,7 @@ module.exports = {
               start_date: Math.floor(Date.now() / 1000) - 86400 * 30,
               trial_start: null,
               trial_end: null,
-              plan: { product: state.paidStripeProductId, interval: 'month' },
+              plan: { product: payments.stripeProductIds[state.paidProductId], interval: 'month' },
             },
           },
         });

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

@@ -23,7 +23,6 @@ module.exports = {
         state.uid = uid;
         state.paidProductId = paidProduct.id;
         state.paidProductName = paidProduct.name;
-        state.paidStripeProductId = paidProduct.stripe?.productId;
 
         // Create subscription via test intent
         const response = await http.as('journey-payments-suspend').post('payments/intent', {
@@ -51,7 +50,7 @@ module.exports = {
 
     {
       name: 'send-past-due-webhook',
-      async run({ http, assert, state, config }) {
+      async run({ http, assert, state, config, payments }) {
         state.eventId1 = `_test-evt-journey-suspend-fail-${Date.now()}`;
 
         const response = await http.as('none').post(`payments/webhook?processor=test&key=${config.backendManagerKey}`, {
@@ -70,7 +69,7 @@ module.exports = {
               start_date: Math.floor(Date.now() / 1000) - 86400 * 60,
               trial_start: null,
               trial_end: null,
-              plan: { product: state.paidStripeProductId, interval: 'month' },
+              plan: { product: payments.stripeProductIds[state.paidProductId], interval: 'month' },
             },
           },
         });
@@ -99,7 +98,7 @@ module.exports = {
 
     {
       name: 'send-recovery-webhook',
-      async run({ http, assert, state, config }) {
+      async run({ http, assert, state, config, payments }) {
         const futureDate = new Date();
         futureDate.setMonth(futureDate.getMonth() + 1);
 
@@ -121,7 +120,7 @@ module.exports = {
               start_date: Math.floor(Date.now() / 1000) - 86400 * 60,
               trial_start: null,
               trial_end: null,
-              plan: { product: state.paidStripeProductId, interval: 'month' },
+              plan: { product: payments.stripeProductIds[state.paidProductId], interval: 'month' },
             },
           },
         });

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

@@ -73,25 +73,16 @@ module.exports = {
       },
     },
 
-    {
-      name: 'backdate-start-date',
-      async run({ firestore, state }) {
-        // Backdate startDate so the 24-hour guard doesn't block cancellation
-        const twoDaysAgo = new Date(Date.now() - 2 * 24 * 60 * 60 * 1000);
-        await firestore.set(`users/${state.uid}`, {
-          subscription: { payment: { startDate: { timestamp: twoDaysAgo.toISOString(), timestampUNIX: twoDaysAgo.getTime() } } },
-        }, { merge: true });
-      },
-    },
-
     {
       name: 'cancel-during-trial',
       async run({ http, assert }) {
-        // Cancel via endpoint — test processor should detect trial and simulate immediate cancel
+        // Cancel via endpoint — test processor should detect trial and simulate immediate cancel.
+        // skipGuards bypasses the 24-hour subscription-age guard.
         const response = await http.as('journey-payments-trial-cancel').post('payments/cancel', {
           confirmed: true,
           reason: 'Changed my mind during trial',
           feedback: 'Testing trial cancellation',
+          skipGuards: true,
         });
 
         assert.isSuccess(response, 'Cancel endpoint should succeed');

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

@@ -27,7 +27,6 @@ module.exports = {
 
         state.uid = uid;
         state.paidProductId = paidProduct.id;
-        state.paidStripeProductId = paidProduct.stripe?.productId;
       },
     },
 
@@ -110,7 +109,7 @@ module.exports = {
 
     {
       name: 'send-trial-to-active-webhook',
-      async run({ http, assert, state, config }) {
+      async run({ http, assert, state, config, payments }) {
         const futureDate = new Date();
         futureDate.setMonth(futureDate.getMonth() + 1);
 
@@ -132,7 +131,7 @@ module.exports = {
               start_date: Math.floor(Date.now() / 1000) - 86400 * 14,
               trial_start: Math.floor(Date.now() / 1000) - 86400 * 14,
               trial_end: Math.floor(Date.now() / 1000),
-              plan: { product: state.paidStripeProductId, interval: 'month' },
+              plan: { product: payments.stripeProductIds[state.paidProductId], interval: 'month' },
             },
           },
         });

package/test/events/payments/journey-payments-uid-resolution.js

@@ -29,7 +29,6 @@ module.exports = {
 
         state.uid = uid;
         state.paidProductId = paidProduct.id;
-        state.paidStripeProductId = paidProduct.stripe?.productId;
 
         // Create subscription via test intent
         const response = await http.as('journey-payments-uid-resolution').post('payments/intent', {
@@ -56,7 +55,7 @@ module.exports = {
 
     {
       name: 'send-webhook-without-uid',
-      async run({ http, assert, state, config }) {
+      async run({ http, assert, state, config, payments }) {
         // Send a subscription update webhook WITHOUT uid in metadata
         // The test processor's fetchResource() will look up payments-orders by resourceId
         // and reconstruct a Stripe-shaped subscription that includes metadata.uid
@@ -84,7 +83,7 @@ module.exports = {
               start_date: Math.floor(Date.now() / 1000) - 86400 * 30,
               trial_start: null,
               trial_end: null,
-              plan: { product: state.paidStripeProductId, interval: 'month' },
+              plan: { product: payments.stripeProductIds[state.paidProductId], interval: 'month' },
             },
           },
         });