backend-manager 5.0.85 → 5.0.87

package/src/manager/routes/payments/intent/processors/test.js

@@ -12,95 +12,158 @@ module.exports = {
    *
    * @param {object} options
    * @param {string} options.uid - User's UID
+   * @param {object} options.product - Full product object from config
    * @param {string} options.productId - Product ID from config
-   * @param {string} options.frequency - 'monthly' or 'annually'
-   * @param {boolean} options.trial - Whether to include a trial period
+   * @param {string} options.frequency - 'monthly' or 'annually' (subscriptions only)
+   * @param {boolean} options.trial - Whether to include a trial period (subscriptions only)
    * @param {object} options.config - BEM config
    * @param {object} options.Manager - Manager instance
    * @param {object} options.assistant - Assistant instance
    * @returns {object} { id, url, raw }
    */
-  async createIntent({ uid, productId, frequency, trial, config, Manager, assistant }) {
+  async createIntent({ uid, product, productId, frequency, trial, config, Manager, assistant }) {
     // Guard: test processor is not available in production
     if (assistant.isProduction()) {
       throw new Error('Test processor is not available in production');
     }
 
-    // Find the product in config
-    const product = (config.payment?.products || []).find(p => p.id === productId);
-    if (!product) {
-      throw new Error(`Product '${productId}' not found in config`);
-    }
-
-    // Get the price ID for the requested frequency (needed for product resolution in toUnified)
-    const priceId = product.prices?.[frequency]?.stripe;
-    if (!priceId) {
-      throw new Error(`No Stripe price found for ${productId}/${frequency}`);
-    }
+    const productType = product.type || 'subscription';
 
-    // Generate IDs
-    const timestamp = Date.now();
-    const sessionId = `_test-cs-${timestamp}`;
-    const subscriptionId = `_test-sub-${timestamp}`;
-    const eventId = `_test-evt-${timestamp}`;
-
-    // Map frequency to Stripe interval
-    const interval = frequency === 'annually' ? 'year' : 'month';
-
-    // Build timestamps
-    const now = Math.floor(timestamp / 1000);
-    const periodEnd = frequency === 'annually'
-      ? now + (365 * 86400)
-      : now + (30 * 86400);
-
-    // Build Stripe-shaped subscription object
-    const subscription = {
-      id: subscriptionId,
-      object: 'subscription',
-      status: trial && product.trial?.days ? 'trialing' : 'active',
-      metadata: { uid },
-      plan: { id: priceId, interval },
-      current_period_end: periodEnd,
-      current_period_start: now,
-      start_date: now,
-      cancel_at_period_end: false,
-      cancel_at: null,
-      canceled_at: null,
-      trial_start: null,
-      trial_end: null,
-    };
-
-    // Add trial dates if applicable
-    if (trial && product.trial?.days) {
-      subscription.trial_start = now;
-      subscription.trial_end = now + (product.trial.days * 86400);
-      subscription.current_period_end = subscription.trial_end;
+    if (productType === 'subscription') {
+      return createSubscriptionIntent({ uid, product, productId, frequency, trial, config, Manager, assistant });
     }
 
-    // Build Stripe-shaped event
-    const event = {
-      id: eventId,
-      type: 'customer.subscription.created',
-      data: { object: subscription },
-    };
-
-    assistant?.log(`Test intent: sessionId=${sessionId}, subscriptionId=${subscriptionId}, eventId=${eventId}, trial=${!!subscription.trial_start}`);
-
-    // Auto-fire webhook (fire-and-forget — don't block intent response)
-    const webhookUrl = `${Manager.project.apiUrl}/backend-manager/payments/webhook?processor=test&key=${process.env.BACKEND_MANAGER_KEY}`;
-    fetch(webhookUrl, {
-      method: 'POST',
-      response: 'json',
-      body: event,
-      timeout: 15000,
-    }).catch((e) => {
-      assistant?.log(`Test processor auto-webhook failed: ${e.message}`);
-    });
-
-    return {
-      id: sessionId,
-      url: `${config.brand?.url || 'https://example.com'}/payment/confirmation?session=${sessionId}`,
-      raw: { id: sessionId, object: 'checkout.session', subscription: subscriptionId },
-    };
+    return createOneTimeIntent({ uid, product, productId, config, Manager, assistant });
   },
 };
+
+/**
+ * Create a test subscription intent
+ * Generates Stripe-shaped subscription + customer.subscription.created event
+ */
+async function createSubscriptionIntent({ uid, product, productId, frequency, trial, config, Manager, assistant }) {
+  // Get the price ID for the requested frequency
+  const priceId = product.prices?.[frequency]?.stripe;
+  if (!priceId) {
+    throw new Error(`No Stripe price found for ${productId}/${frequency}`);
+  }
+
+  // Generate IDs
+  const timestamp = Date.now();
+  const sessionId = `_test-cs-${timestamp}`;
+  const subscriptionId = `_test-sub-${timestamp}`;
+  const eventId = `_test-evt-${timestamp}`;
+
+  // Map frequency to Stripe interval
+  const interval = frequency === 'annually' ? 'year' : 'month';
+
+  // Build timestamps
+  const now = Math.floor(timestamp / 1000);
+  const periodEnd = frequency === 'annually'
+    ? now + (365 * 86400)
+    : now + (30 * 86400);
+
+  // Build Stripe-shaped subscription object
+  const subscription = {
+    id: subscriptionId,
+    object: 'subscription',
+    status: trial && product.trial?.days ? 'trialing' : 'active',
+    metadata: { uid },
+    plan: { id: priceId, interval },
+    current_period_end: periodEnd,
+    current_period_start: now,
+    start_date: now,
+    cancel_at_period_end: false,
+    cancel_at: null,
+    canceled_at: null,
+    trial_start: null,
+    trial_end: null,
+  };
+
+  // Add trial dates if applicable
+  if (trial && product.trial?.days) {
+    subscription.trial_start = now;
+    subscription.trial_end = now + (product.trial.days * 86400);
+    subscription.current_period_end = subscription.trial_end;
+  }
+
+  // Build Stripe-shaped event
+  const event = {
+    id: eventId,
+    type: 'customer.subscription.created',
+    data: { object: subscription },
+  };
+
+  assistant?.log(`Test subscription intent: sessionId=${sessionId}, subscriptionId=${subscriptionId}, eventId=${eventId}, trial=${!!subscription.trial_start}`);
+
+  // Auto-fire webhook
+  fireWebhook({ event, Manager, assistant });
+
+  return {
+    id: sessionId,
+    url: `${config.brand?.url || 'https://example.com'}/payment/confirmation?session=${sessionId}`,
+    raw: { id: sessionId, object: 'checkout.session', subscription: subscriptionId },
+  };
+}
+
+/**
+ * Create a test one-time payment intent
+ * Generates Stripe-shaped checkout session + checkout.session.completed event
+ */
+async function createOneTimeIntent({ uid, product, productId, config, Manager, assistant }) {
+  // Get the price ID for one-time purchase
+  const priceId = product.prices?.once?.stripe;
+  if (!priceId) {
+    throw new Error(`No Stripe price found for ${productId}/once`);
+  }
+
+  // Generate IDs
+  const timestamp = Date.now();
+  const sessionId = `_test-cs-${timestamp}`;
+  const eventId = `_test-evt-${timestamp}`;
+
+  // Build Stripe-shaped checkout session object
+  const session = {
+    id: sessionId,
+    object: 'checkout.session',
+    mode: 'payment',
+    status: 'complete',
+    payment_status: 'paid',
+    metadata: { uid, productId },
+    amount_total: Math.round((product.prices?.once?.amount || 0) * 100),
+    currency: 'usd',
+  };
+
+  // Build Stripe-shaped event
+  const event = {
+    id: eventId,
+    type: 'checkout.session.completed',
+    data: { object: session },
+  };
+
+  assistant?.log(`Test one-time intent: sessionId=${sessionId}, eventId=${eventId}, productId=${productId}`);
+
+  // Auto-fire webhook
+  fireWebhook({ event, Manager, assistant });
+
+  return {
+    id: sessionId,
+    url: `${config.brand?.url || 'https://example.com'}/payment/confirmation?session=${sessionId}`,
+    raw: { id: sessionId, object: 'checkout.session', mode: 'payment' },
+  };
+}
+
+/**
+ * Fire-and-forget webhook to trigger the full pipeline
+ */
+function fireWebhook({ event, Manager, assistant }) {
+  const webhookUrl = `${Manager.project.apiUrl}/backend-manager/payments/webhook?processor=test&key=${process.env.BACKEND_MANAGER_KEY}`;
+  fetch(webhookUrl, {
+    method: 'POST',
+    response: 'json',
+    body: event,
+    timeout: 15000,
+  }).catch((e) => {
+    assistant?.log(`Test processor auto-webhook failed: ${e.message}`);
+  });
+}

package/src/manager/routes/payments/webhook/post.js

@@ -7,7 +7,7 @@ const powertools = require('node-powertools');
  * The Firestore onWrite trigger handles async processing
  *
  * This handler is processor-agnostic. Each processor module defines:
- *   - parseWebhook(req) — extracts { eventId, eventType, raw, uid }
+ *   - parseWebhook(req) — extracts { eventId, eventType, category, resourceType, resourceId, raw, uid }
  *   - isSupported(eventType) — returns true for events we should process
  */
 module.exports = async ({ assistant, Manager, libraries }) => {
@@ -45,13 +45,19 @@ module.exports = async ({ assistant, Manager, libraries }) => {
     return assistant.respond(`Failed to parse webhook: ${e.message}`, { code: 400 });
   }
 
-  const { eventId, eventType, raw, uid } = parsed;
+  const { eventId, eventType, category, resourceType, resourceId, raw, uid } = parsed;
 
-  assistant.log(`Parsed webhook: eventId=${eventId}, eventType=${eventType}, uid=${uid || 'null'}`);
+  assistant.log(`Parsed webhook: eventId=${eventId}, eventType=${eventType}, category=${category || 'null'}, resourceType=${resourceType || 'null'}, uid=${uid || 'null'}`);
 
   // Let the processor decide if this event type is relevant
   if (processorModule.isSupported && !processorModule.isSupported(eventType)) {
-    assistant.log(`Ignoring event type: ${eventType}`);
+    assistant.log(`Ignoring unsupported event type: ${eventType}`);
+    return assistant.respond({ received: true, ignored: true });
+  }
+
+  // Skip events with no category (e.g., checkout.session.completed for subscription mode)
+  if (!category) {
+    assistant.log(`Ignoring event with no category: ${eventType}`);
     return assistant.respond({ received: true, ignored: true });
   }
 
@@ -79,6 +85,9 @@ module.exports = async ({ assistant, Manager, libraries }) => {
     uid: uid,
     event: {
       type: eventType,
+      category: category,
+      resourceType: resourceType,
+      resourceId: resourceId,
     },
     error: null,
     metadata: {
@@ -93,7 +102,7 @@ module.exports = async ({ assistant, Manager, libraries }) => {
     },
   });
 
-  assistant.log(`Saved payments-webhooks/${eventId}: eventType=${eventType}, processor=${processor}, uid=${uid}`);
+  assistant.log(`Saved payments-webhooks/${eventId}: eventType=${eventType}, category=${category}, processor=${processor}, uid=${uid}`);
 
   // Return 200 immediately
   return assistant.respond({ received: true });

package/src/manager/routes/payments/webhook/processors/stripe.js

@@ -1,13 +1,25 @@
 /**
  * Stripe webhook processor
- * Extracts and validates webhook event data from Stripe
+ * Extracts, validates, and categorizes webhook event data from Stripe
+ *
+ * Each event is mapped to a category (subscription or one-time) and includes
+ * the resource type + ID needed to fetch the latest state from Stripe's API.
  */
 
-// Stripe event types we process — add new ones here as needed
+// Events we process, mapped to their default category
+// Some events (invoice.payment_failed, checkout.session.completed) require
+// inspecting the payload to determine the actual category
 const SUPPORTED_EVENTS = new Set([
+  // Subscription lifecycle
   'customer.subscription.created',
   'customer.subscription.updated',
   'customer.subscription.deleted',
+
+  // Payment failures (could be subscription or one-time)
+  'invoice.payment_failed',
+
+  // Checkout completion (could be subscription or one-time)
+  'checkout.session.completed',
 ]);
 
 module.exports = {
@@ -20,10 +32,13 @@ module.exports = {
 
   /**
    * Parse a Stripe webhook request
-   * Extracts the event data, event type, and resolves the UID from metadata
+   * Extracts event data and determines category, resource type, resource ID, and UID
    *
    * @param {object} req - The raw HTTP request
-   * @returns {object} { eventId, eventType, raw, uid }
+   * @returns {object} { eventId, eventType, category, resourceType, resourceId, raw, uid }
+   *   - category: 'subscription' | 'one-time' | null (null = skip)
+   *   - resourceType: 'subscription' | 'invoice' | 'session'
+   *   - resourceId: ID to fetch from processor API
    */
   parseWebhook(req) {
     const event = req.body;
@@ -33,16 +48,67 @@ module.exports = {
       throw new Error('Invalid Stripe webhook payload');
     }
 
-    // The subscription object is typically in event.data.object
     const dataObject = event.data?.object || {};
+    const eventType = event.type;
+
+    // Resolve category, resource info, and UID based on event type
+    let category = null;
+    let resourceType = null;
+    let resourceId = null;
+    let uid = null;
+
+    if (eventType.startsWith('customer.subscription.')) {
+      // Subscription lifecycle events — always subscription category
+      category = 'subscription';
+      resourceType = 'subscription';
+      resourceId = dataObject.id;
+      uid = dataObject.metadata?.uid || null;
 
-    // Resolve UID from subscription metadata
-    // When creating checkout sessions, we set metadata.uid on the subscription
-    const uid = dataObject.metadata?.uid || null;
+    } else if (eventType === 'invoice.payment_failed') {
+      // Payment failure — inspect billing_reason to determine category
+      const billingReason = dataObject.billing_reason || '';
+      const subscriptionId = dataObject.parent?.subscription_details?.subscription
+        || dataObject.subscription
+        || null;
+
+      if (billingReason.startsWith('subscription') && subscriptionId) {
+        // Subscription-related invoice failure
+        category = 'subscription';
+        resourceType = 'subscription';
+        resourceId = subscriptionId;
+        uid = dataObject.parent?.subscription_details?.metadata?.uid
+          || dataObject.subscription_details?.metadata?.uid
+          || dataObject.metadata?.uid
+          || null;
+      } else {
+        // One-time invoice failure
+        category = 'one-time';
+        resourceType = 'invoice';
+        resourceId = dataObject.id;
+        uid = dataObject.metadata?.uid || null;
+      }
+
+    } else if (eventType === 'checkout.session.completed') {
+      const mode = dataObject.mode;
+
+      if (mode === 'subscription') {
+        // Subscription checkout — skip, subscription events handle this
+        category = null;
+      } else if (mode === 'payment') {
+        // One-time payment checkout
+        category = 'one-time';
+        resourceType = 'session';
+        resourceId = dataObject.id;
+        uid = dataObject.metadata?.uid || null;
+      }
+    }
 
     return {
       eventId: event.id,
-      eventType: event.type,
+      eventType: eventType,
+      category: category,
+      resourceType: resourceType,
+      resourceId: resourceId,
       raw: event,
       uid: uid,
     };

package/src/manager/schemas/payments/intent/post.js

@@ -13,7 +13,7 @@ module.exports = () => ({
   },
   frequency: {
     types: ['string'],
-    required: true,
+    default: null,
   },
   trial: {
     types: ['boolean'],

package/src/test/test-accounts.js

@@ -166,6 +166,15 @@ const JOURNEY_ACCOUNTS = {
       subscription: { product: { id: 'basic' }, status: 'active' }, // Starts as basic, upgraded via trial webhook
     },
   },
+  'journey-payments-failure': {
+    id: 'journey-payments-failure',
+    uid: '_test-journey-payments-failure',
+    email: '_test.journey-payments-failure@{domain}',
+    properties: {
+      roles: {},
+      subscription: { product: { id: 'basic' }, status: 'active' }, // Test's first step overwrites with correct paid product from config
+    },
+  },
 };
 
 /**
@@ -354,7 +363,7 @@ async function deleteTestUsers(admin) {
 
   // Clean up payment-related collections for test accounts
   const testUids = Object.values(TEST_ACCOUNTS).map(a => a.uid);
-  const paymentCollections = ['payments-subscriptions', 'payments-webhooks', 'payments-intents'];
+  const paymentCollections = ['payments-subscriptions', 'payments-webhooks', 'payments-intents', 'payments-one-time'];
 
   await Promise.all(
     paymentCollections.map(async (collection) => {

package/templates/backend-manager-config.json

@@ -62,16 +62,28 @@
         prices: {
           monthly: {
             amount: 4.99,
-            stripe: 'price_xxx',
-            paypal: 'P-xxx',
+            stripe: null,
+            paypal: null,
           },
           annually: {
             amount: 49.99,
-            stripe: 'price_yyy',
-            paypal: 'P-yyy',
+            stripe: null,
+            paypal: null,
           },
         },
       },
+      // Example one-time product:
+      // {
+      //   id: 'credits-100',
+      //   name: '100 Credits',
+      //   type: 'one-time',
+      //   prices: {
+      //     once: {
+      //       amount: 9.99,
+      //       stripe: null,
+      //     },
+      //   },
+      // },
       // Add more products/tiers here
     ],
   },

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

@@ -89,6 +89,9 @@ module.exports = {
           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');
@@ -134,6 +137,9 @@ module.exports = {
           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');

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

@@ -0,0 +1,114 @@
+/**
+ * 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 }) {
+        const uid = accounts['journey-payments-failure'].uid;
+
+        // Resolve first paid subscription product
+        const paidProduct = config.payment.products.find(p => p.id !== 'basic' && p.type === 'subscription' && p.prices);
+        assert.ok(paidProduct, 'Config should have at least one paid subscription product');
+
+        state.uid = uid;
+        state.paidProductId = paidProduct.id;
+        state.paidProductName = paidProduct.name;
+        state.paidPriceId = paidProduct.prices.monthly.stripe;
+
+        // Create subscription via test intent
+        const response = await http.as('journey-payments-failure').post('payments/intent', {
+          processor: 'test',
+          productId: paidProduct.id,
+          frequency: 'monthly',
+        });
+        assert.isSuccess(response, 'Intent should succeed');
+
+        // 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');
+
+        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(`payments/webhook?processor=test&key=${config.backendManagerKey}`, {
+          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 },
+                },
+                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}`);
+      },
+    },
+  ],
+};

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

@@ -85,6 +85,9 @@ module.exports = {
           return doc?.status === 'completed';
         }, 15000, 500);
 
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId1}`);
+        assert.equal(webhookDoc.transition, 'payment-failed', 'Transition should be payment-failed');
+
         const userDoc = await firestore.get(`users/${state.uid}`);
 
         assert.equal(userDoc.subscription.status, 'suspended', 'Status should be suspended');
@@ -133,6 +136,9 @@ module.exports = {
           return doc?.status === 'completed';
         }, 15000, 500);
 
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId2}`);
+        assert.equal(webhookDoc.transition, 'payment-recovered', 'Transition should be payment-recovered');
+
         const userDoc = await firestore.get(`users/${state.uid}`);
 
         assert.equal(userDoc.subscription.status, 'active', 'Status should be active again');

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

@@ -45,6 +45,9 @@ module.exports = {
         assert.ok(response.data.id, 'Should return intent ID');
 
         state.intentId = response.data.id;
+
+        // Derive webhook event ID from intent ID (same timestamp)
+        state.eventId = response.data.id.replace('_test-cs-', '_test-evt-');
       },
     },
 
@@ -64,6 +67,11 @@ module.exports = {
         assert.equal(userDoc.subscription.trial.claimed, true, 'Trial should be claimed');
 
         state.subscriptionId = userDoc.subscription.payment.resourceId;
+
+        // Verify the auto-fired webhook triggered new-subscription (trial is a property, not a separate transition)
+        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)');
       },
     },
 
@@ -108,6 +116,10 @@ module.exports = {
           return doc?.status === 'completed';
         }, 15000, 500);
 
+        // Trial → active paid is the same status/product, so no transition fires
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId2}`);
+        assert.equal(webhookDoc.transition, null, 'No transition (same status/product, trial already claimed)');
+
         const userDoc = await firestore.get(`users/${state.uid}`);
 
         assert.equal(userDoc.subscription.product.id, state.paidProductId, `Product should be ${state.paidProductId}`);