@omega.js/backend 0.1.0

package/test/events/payments/webhook-chargebee-unreachable.test.js

@@ -0,0 +1,106 @@
+/**
+ * Test: a Chargebee webhook the Chargebee API cannot answer writes NOTHING
+ *
+ * The trigger used to degrade to the payload the webhook carried (flagged stale)
+ * whenever the provider lookup failed, and wrote real subscription state from it —
+ * an object supplied by whoever posted the event
+ * ([#506](https://github.com/Omega-JS-Stack/omega/issues/506)). An unreachable
+ * provider is not a provider saying anything at all, so the event now DEFERS: the
+ * doc is marked failed, the retry sweep re-pends it, and no user doc, order or
+ * intent is written off the payload in the meantime.
+ *
+ * Chargebee is unconfigured in this brand (no CHARGEBEE_API_KEY), so the lookup
+ * fails for real, locally, with no network call and no credential.
+ */
+
+// The suite's own seeded persona ([#406](https://github.com/Omega-JS-Stack/omega/issues/406)):
+// exclusive to this suite, declared in the seed roster, and the half the seed
+// owns here is the AUTH USER — the doc is deleted below on purpose, and proving
+// nothing recreates it is the point.
+
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+const PERSONA = 'webhook-chargebee-unreachable';
+const ORDER_ID = '6161-6161-6161';
+
+module.exports = defineCases({
+  description: 'A Chargebee lookup that cannot be answered defers instead of processing the payload',
+  type: 'suite',
+  timeout: 60000,
+
+  tests: [
+    {
+      name: 'send-chargebee-subscription-webhook',
+      async run({ accounts, http, firestore, assert, state, config }) {
+        state.uid = accounts[PERSONA].uid;
+
+        // Deleted so the run starts from nothing: anything found afterwards was
+        // written by this event, off a payload nothing verified
+        await firestore.delete(`users/${state.uid}`);
+        await firestore.delete(`payments-orders/${ORDER_ID}`);
+
+        state.orderId = ORDER_ID;
+        state.resourceId = `_test-cb-unreachable-sub-${Date.now()}`;
+        state.eventId = `_test-evt-cb-unreachable-${Date.now()}`;
+        state.termEnd = Math.floor(Date.now() / 1000) + 86400 * 30;
+
+        const response = await http.as('none').post(`backend-manager/payments/webhook?provider=chargebee&key=${config.webhookKey}`, {
+          id: state.eventId,
+          occurred_at: Math.floor(Date.now() / 1000),
+          event_type: 'subscription_created',
+          content: {
+            subscription: {
+              id: state.resourceId,
+              customer_id: '_test-cb-unreachable-cust',
+              status: 'active',
+              current_term_start: Math.floor(Date.now() / 1000),
+              current_term_end: state.termEnd,
+              created_at: Math.floor(Date.now() / 1000),
+              started_at: Math.floor(Date.now() / 1000),
+              subscription_items: [{ item_price_id: 'premium-monthly', item_type: 'plan', quantity: 1 }],
+              meta_data: JSON.stringify({ uid: state.uid, orderId: ORDER_ID }),
+              currency_code: 'USD',
+              object: 'subscription',
+            },
+            customer: {
+              id: '_test-cb-unreachable-cust',
+              email: '_test.cb-unreachable@example.com',
+              object: 'customer',
+            },
+          },
+        });
+
+        // The ROUTE still accepts it — storing the event is what makes the retry
+        // ladder possible at all. The processing is what refuses to guess.
+        assert.isSuccess(response, 'Webhook should be accepted');
+      },
+    },
+
+    {
+      name: 'the-event-defers-and-nothing-is-written-from-its-payload',
+      async run({ firestore, assert, waitFor, state }) {
+        // 45s, not the usual 15s: this is the first suite of the run and the emulator
+        // is still draining the seeding wipe, which stretches the read back out
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.eventId}`);
+          return doc?.status === 'completed' || doc?.status === 'failed';
+        }, 45000, 500);
+
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId}`);
+
+        assert.equal(webhookDoc.status, 'failed', 'An unreachable Chargebee defers — the retry sweep is the reconciliation path');
+        assert.equal(webhookDoc.retryCount, 1, 'The attempt is counted toward the retry ladder');
+        assert.ok(!webhookDoc.refusal, 'A deferral is not a refusal — nothing was decided about this event');
+
+        // The payload carried a complete active subscription. Anything below that
+        // exists could only have come from it.
+        const userDoc = await firestore.get(`users/${state.uid}`);
+
+        assert.ok(!userDoc?.subscription, 'No subscription state is written from a payload the provider never confirmed');
+
+        const orderDoc = await firestore.get(`payments-orders/${ORDER_ID}`);
+
+        assert.ok(!orderDoc, 'And no order is minted behind it');
+      },
+    },
+  ],
+});

package/test/events/payments/webhook-discount-clear.test.js

@@ -0,0 +1,189 @@
+/**
+ * Test: a persisted discount belongs to the subscription it was applied to
+ * ([#333](https://github.com/Omega-JS-Stack/omega/issues/333)).
+ *
+ * The winback claim writes `users/{uid}.subscription.discount` and nothing ever
+ * cleared it. The unified webhook write carries no discount key at all, so the
+ * merge PRESERVES the node forever, and a customer who churns and resubscribes
+ * carried `source: 'winback'` into the new subscription, where the billing
+ * card's pitch gate reads it as "already claimed" and silently never offers the
+ * save again, though the backend would grant a fresh one.
+ *
+ * The claim stamps the subscription it discounted (`discount.resourceId`), so
+ * the pipeline can tell the two apart: a webhook for a DIFFERENT subscription is
+ * a new subscription, and a new subscription is a clean slate.
+ *
+ * Plain-node control-flow test (no emulator, no network): the real trigger runs
+ * against the shared in-memory Firestore stand-in, which is what lets one test
+ * start from an exact prior account state (a live claim stamped with a
+ * subscription that is already gone) without minting a persona and a payment
+ * history per permutation.
+ */
+const assert = require('node:assert');
+const { runTrigger } = require('./_webhook-harness.js');
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+
+const UID = '_test-discount-clear-uid';
+const ORDER_ID = '5252-5252-5252';
+const OLD_RESOURCE_ID = '_test-discount-old-sub';
+const NEW_RESOURCE_ID = '_test-discount-new-sub';
+const EVENT_ID = '_test-discount-evt';
+
+/** The claimed winback discount, as the apply route persists it */
+function claimedDiscount(resourceId) {
+  return {
+    valid: true,
+    code: 'WINBACK50',
+    percent: 50,
+    amount: 0,
+    duration: 'once',
+    source: 'winback',
+    resourceId: resourceId,
+  };
+}
+
+/** A subscriber whose account already carries `discount`, on the subscription `resourceId` */
+function subscriberSeed(discount, resourceId) {
+  return {
+    [`users/${UID}`]: {
+      auth: { uid: UID, email: `${UID}@example.com` },
+      subscription: {
+        product: { id: 'premium', name: 'Premium' },
+        status: 'active',
+        payment: { provider: 'test', orderId: ORDER_ID, resourceId: resourceId },
+        ...(discount ? { discount: discount } : {}),
+      },
+    },
+  };
+}
+
+/** A subscription event for `resourceId`, over an account seeded with `seed` */
+function runEvent({ resourceId, seed }) {
+  return runTrigger({
+    uid: UID,
+    orderId: ORDER_ID,
+    resourceId: resourceId,
+    eventId: EVENT_ID,
+    seed: seed,
+  });
+}
+
+module.exports = defineCases({
+  description: 'Webhook pipeline clears a discount the new subscription never claimed',
+  type: 'group',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'a resubscribe clears the discount claimed on the subscription that ended',
+
+      async run() {
+        const { store } = await runEvent({
+          resourceId: NEW_RESOURCE_ID,
+          seed: subscriberSeed(claimedDiscount(OLD_RESOURCE_ID), OLD_RESOURCE_ID),
+        });
+
+        const subscription = store.get(`users/${UID}`).subscription;
+
+        assert.equal(subscription.payment.resourceId, NEW_RESOURCE_ID, 'the new subscription is the one on the account');
+        assert.equal(subscription.discount.valid, false, 'the old claim is no longer a discount');
+        assert.equal(subscription.discount.code, null, 'nothing names a coupon that ended with the old subscription');
+        assert.equal(subscription.discount.percent, 0, 'and it is worth nothing');
+        assert.equal(subscription.discount.amount, 0, 'in either shape');
+        assert.equal(subscription.discount.duration, null);
+        assert.equal(
+          subscription.discount.source, null,
+          'source is the pitch gate: left at winback, this customer is never offered the save again',
+        );
+        assert.equal(subscription.discount.resourceId, null, 'and the stamp goes with it');
+      },
+    },
+
+    {
+      name: 'same-subscription traffic PRESERVES the discount riding it',
+
+      async run() {
+        const discount = claimedDiscount(OLD_RESOURCE_ID);
+        const { store } = await runEvent({
+          resourceId: OLD_RESOURCE_ID,
+          seed: subscriberSeed(discount, OLD_RESOURCE_ID),
+        });
+
+        assert.deepEqual(
+          store.get(`users/${UID}`).subscription.discount, discount,
+          'a renewal, a cancellation, any update to the SAME subscription leaves the saving exactly as claimed',
+        );
+      },
+    },
+
+    {
+      name: 'an unstamped legacy discount is kept, and adopted by the subscription it is on',
+
+      async run() {
+        // A node written before the stamp existed names no subscription, and
+        // nothing can prove it belongs to an older one. Keeping it is the safe
+        // read: an account that resubscribed before this shipped keeps a stale
+        // claim it already had, and no live discount is ever taken away from
+        // someone paying a discounted price. Stamping it now is what ends that:
+        // from this event on it is a normal node, and the NEXT resubscribe
+        // clears it like any other.
+        const legacy = claimedDiscount(OLD_RESOURCE_ID);
+        delete legacy.resourceId;
+
+        const { store } = await runEvent({
+          resourceId: OLD_RESOURCE_ID,
+          seed: subscriberSeed(legacy, OLD_RESOURCE_ID),
+        });
+
+        const discount = store.get(`users/${UID}`).subscription.discount;
+
+        assert.equal(discount.valid, true, 'the discount survives');
+        assert.equal(discount.code, 'WINBACK50', 'unchanged');
+        assert.equal(discount.source, 'winback', 'source and all');
+        assert.equal(discount.resourceId, OLD_RESOURCE_ID, 'and it now names the subscription it is riding');
+      },
+    },
+
+    {
+      name: 'a subscription-category event riding an invoice resource never clears the claim',
+
+      async run() {
+        // A subscription-CATEGORY event can carry a non-subscription resource
+        // (Stripe charge.refunded rides an invoice; PayPal's raw-payload
+        // fallback rides a sale). Its id will never match the stamp, so without
+        // the resourceType gate a partial refund on a still-live discounted
+        // subscription would silently clear a saving the customer still gets.
+        const discount = claimedDiscount(OLD_RESOURCE_ID);
+        const { store } = await runTrigger({
+          uid: UID,
+          orderId: ORDER_ID,
+          resourceId: '_test-discount-invoice-id',
+          resourceType: 'invoice',
+          eventId: EVENT_ID,
+          seed: subscriberSeed(discount, OLD_RESOURCE_ID),
+        });
+
+        assert.deepEqual(
+          store.get(`users/${UID}`).subscription.discount, discount,
+          'only a real subscription resource may judge the stamp',
+        );
+      },
+    },
+
+    {
+      name: 'an account with no discount is left with none',
+
+      async run() {
+        const { store } = await runEvent({
+          resourceId: NEW_RESOURCE_ID,
+          seed: subscriberSeed(null, OLD_RESOURCE_ID),
+        });
+
+        assert.equal(
+          store.get(`users/${UID}`).subscription.discount, undefined,
+          'the pipeline never writes a discount node onto an account that has none',
+        );
+      },
+    },
+  ],
+});

package/test/events/payments/webhook-failure-intent.test.js

@@ -0,0 +1,93 @@
+/**
+ * Test: a failed webhook closes out its checkout intent
+ *
+ * The webhook trigger resolves the orderId partway through processing, so anything
+ * that throws before that point (an unresolvable UID, a fetchResource failure) used
+ * to leave payments-intents/{orderId} at 'pending' forever — a checkout the user
+ * started that nothing ever closes.
+ *
+ * The failure path now resolves the orderId from what IS available (the webhook
+ * payload the provider library can read one out of) and fails the intent with it.
+ */
+const powertools = require('node-powertools');
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+
+const ORDER_ID = '9119-9119-9119';
+
+module.exports = defineCases({
+  description: 'Webhook failure closes out its payments-intent',
+  type: 'suite',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'seed-pending-intent',
+      async run({ firestore, assert, state }) {
+        const now = powertools.timestamp(new Date(), { output: 'string' });
+
+        state.orderId = ORDER_ID;
+        state.resourceId = `_test-sub-no-uid-${Date.now()}`;
+        state.eventId = `_test-evt-no-uid-${Date.now()}`;
+
+        await firestore.set(`payments-intents/${ORDER_ID}`, {
+          id: ORDER_ID,
+          status: 'pending',
+          provider: 'test',
+          metadata: {
+            created: {
+              timestamp: now,
+              timestampUNIX: powertools.timestamp(now, { output: 'unix' }),
+            },
+          },
+        });
+
+        const intentDoc = await firestore.get(`payments-intents/${ORDER_ID}`);
+        assert.equal(intentDoc.status, 'pending', 'Intent should start pending');
+      },
+    },
+
+    {
+      name: 'send-webhook-with-no-uid',
+      async run({ http, assert, state, config }) {
+        // Carries the orderId but no uid, and names a subscription no order was ever
+        // written for — so nothing can reconstruct the uid and processing throws
+        const response = await http.as('none').post(`backend-manager/payments/webhook?provider=test&key=${config.webhookKey}`, {
+          id: state.eventId,
+          type: 'customer.subscription.updated',
+          data: {
+            object: {
+              id: state.resourceId,
+              object: 'subscription',
+              status: 'active',
+              metadata: { orderId: state.orderId },
+              cancel_at_period_end: false,
+              current_period_end: Math.floor(Date.now() / 1000) + 86400,
+              current_period_start: Math.floor(Date.now() / 1000),
+              start_date: Math.floor(Date.now() / 1000),
+            },
+          },
+        });
+
+        assert.isSuccess(response, 'Webhook should be accepted (it fails during processing, not at the door)');
+      },
+    },
+
+    {
+      name: 'webhook-fails-and-intent-is-failed',
+      async run({ firestore, assert, state, waitFor }) {
+        await waitFor(async () => {
+          const doc = await firestore.get(`payments-webhooks/${state.eventId}`);
+          return doc?.status === 'failed';
+        }, 15000, 500);
+
+        const webhookDoc = await firestore.get(`payments-webhooks/${state.eventId}`);
+        assert.match(webhookDoc.error, /no UID/i, 'The webhook should have failed on the unresolvable UID');
+
+        // The point: the intent no longer hangs pending behind that failure
+        const intentDoc = await firestore.get(`payments-intents/${state.orderId}`);
+        assert.equal(intentDoc.status, 'failed', 'The intent should be marked failed, not left pending');
+        assert.ok(intentDoc.error, 'The intent should carry the failure reason');
+      },
+    },
+  ],
+});

package/test/events/payments/webhook-hosted-page-uid-trust.test.js

@@ -0,0 +1,212 @@
+/**
+ * Test: the hosted page is consulted BEFORE a payload uid is believed
+ *
+ * A Chargebee hosted-page checkout does not forward `meta_data` to the
+ * subscription, so the provider's record carries no uid and the payload's claim
+ * steers with a loud warn ([#509](https://github.com/Omega-JS-Stack/omega/issues/509)).
+ * But Chargebee DOES hold a second authoritative source for exactly those
+ * subscriptions — the hosted page's `pass_thru_content` — and the lookup that
+ * reads it was gated on `!uid`, so it was consulted only when the payload claimed
+ * nothing: never in the one case where a claim needed checking
+ * ([#533](https://github.com/Omega-JS-Stack/omega/issues/533)).
+ *
+ * The lookup runs first now. A hit STEERS — and a payload that disagrees with it
+ * is refused, the same refusal a mismatched record earns. A miss still falls back
+ * to the payload with the warn: the scan covers only the last 25 hosted pages, so
+ * "no page found" honestly means "not in the window", never "not this uid".
+ *
+ * Plain-node control-flow test (no emulator, no network): the real trigger module
+ * runs against the shared in-memory Firestore stand-in (_webhook-harness.js).
+ * Chargebee's credentials + HTTP call are the one thing stubbed — the transport
+ * boundary. Everything inward runs for real.
+ *
+ * Run: npx omega test backend:events/payments/webhook-hosted-page-uid-trust
+ */
+const assert = require('node:assert');
+const { runTrigger } = require('./_webhook-harness.js');
+const Chargebee = require('../../../dist/manager/libraries/payment/providers/chargebee.js');
+const defineCases = require('../../../dist/vendor/devkit/test/define-cases.js');
+
+// The subscriber the hosted page says bought this subscription
+const OWNER_UID = '_test-hosted-page-owner';
+const OWNER_ORDER_ID = '5331-5331-5331';
+
+// The uid a forged event claims for it, and the order it names
+const FORGED_UID = '_test-hosted-page-forged';
+const FORGED_ORDER_ID = '5330-5330-5330';
+
+const SUBSCRIPTION_ID = 'cb_sub_hosted_page';
+const EVENT_ID = '_test-hosted-page-evt';
+
+const HOSTED_PAGES = '/hosted_pages?limit=25&sort_by[desc]=created_at';
+
+/** Run fn with Chargebee's credentials + HTTP call replaced by stand-ins */
+async function withChargebeeAnswering(request, fn) {
+  const realInit = Chargebee.init;
+  const realRequest = Chargebee.request;
+
+  Chargebee.init = () => ({ apiKey: '_test', site: '_test', baseUrl: 'https://_test.chargebee.com/api/v2' });
+  Chargebee.request = request;
+
+  try {
+    return await fn();
+  } finally {
+    Chargebee.init = realInit;
+    Chargebee.request = realRequest;
+  }
+}
+
+/** A stand-in that records every endpoint asked for and answers from `responses` */
+function requestReturning(responses, calls) {
+  return async (endpoint) => {
+    calls.push(endpoint);
+
+    const response = responses[endpoint];
+
+    if (!response) {
+      const error = new Error(`Chargebee API 404: no stand-in response for ${endpoint}`);
+      error.statusCode = 404;
+      throw error;
+    }
+
+    return JSON.parse(JSON.stringify(response));
+  };
+}
+
+/** The hosted-page checkout's subscription: active, and carrying no meta_data at all */
+function subscriptionRecord() {
+  const nowUNIX = Math.floor(Date.now() / 1000);
+
+  return {
+    subscription: {
+      id: SUBSCRIPTION_ID,
+      status: 'active',
+      started_at: nowUNIX,
+      current_term_end: nowUNIX + 86400,
+      subscription_items: [{ item_price_id: 'premium-monthly' }],
+    },
+  };
+}
+
+/** The last 25 hosted pages, holding the one whose pass_thru_content names the owner */
+function hostedPages({ matching = true } = {}) {
+  return {
+    list: [
+      {
+        hosted_page: {
+          id: 'hp_test_hosted_page',
+          content: { subscription: { id: matching ? SUBSCRIPTION_ID : 'cb_sub_someone_else' } },
+          pass_thru_content: JSON.stringify({ uid: OWNER_UID, orderId: OWNER_ORDER_ID }),
+        },
+      },
+    ],
+  };
+}
+
+/**
+ * A hosted-page subscription event claiming `payloadUid`, with the page either in
+ * the scan window or outside it
+ */
+function runHostedPageEvent({ payloadUid, payloadOrderId, inWindow = true, calls = [] }) {
+  const responses = {
+    [`/subscriptions/${SUBSCRIPTION_ID}`]: subscriptionRecord(),
+    [HOSTED_PAGES]: hostedPages({ matching: inWindow }),
+    // The backfill the pipeline fires after a hosted-page resolution
+    [`/customers/undefined`]: {},
+  };
+
+  return withChargebeeAnswering(requestReturning(responses, calls), () => runTrigger({
+    uid: payloadUid,
+    orderId: payloadOrderId,
+    resourceId: SUBSCRIPTION_ID,
+    eventId: EVENT_ID,
+    eventType: 'subscription_changed',
+    provider: 'chargebee',
+    raw: {
+      id: EVENT_ID,
+      event_type: 'subscription_changed',
+      content: { subscription: { id: SUBSCRIPTION_ID, meta_data: JSON.stringify({ uid: payloadUid, orderId: payloadOrderId }) } },
+    },
+    // Both uids are real accounts in this project — what is forged is the CLAIM
+    authUids: [OWNER_UID, FORGED_UID],
+  }));
+}
+
+module.exports = defineCases({
+  description: 'A payload uid is checked against the hosted page before it is allowed to steer',
+  type: 'group',
+  timeout: 30000,
+
+  tests: [
+    {
+      name: 'a forged uid on a hosted-page subscription still in the window is refused',
+
+      async run() {
+        const calls = [];
+        const { store } = await runHostedPageEvent({ payloadUid: FORGED_UID, payloadOrderId: FORGED_ORDER_ID, calls });
+
+        assert.ok(calls.includes(HOSTED_PAGES), 'the second source is consulted exactly when the claim needs checking');
+        assert.ok(!store.get(`users/${FORGED_UID}`), 'the uid the caller chose never receives a subscription it did not buy');
+        assert.ok(!store.get(`users/${OWNER_UID}`), 'and the refusal acts on nobody, not even the real owner');
+        assert.ok(!store.get(`payments-orders/${FORGED_ORDER_ID}`), 'no order behind it either');
+      },
+    },
+
+    {
+      name: 'the refusal names the hosted page as the source it disagreed with',
+
+      async run() {
+        const { store, logs } = await runHostedPageEvent({ payloadUid: FORGED_UID, payloadOrderId: FORGED_ORDER_ID });
+        const event = store.get(`payments-webhooks/${EVENT_ID}`);
+
+        assert.equal(event.status, 'completed', 'no retry can make the payload agree — the event must not be redelivered forever');
+        assert.equal(event.refusal?.reason, 'uid-mismatch', 'it is the same refusal a mismatched record earns');
+        assert.equal(event.refusal?.payloadUid, FORGED_UID, 'the stamp names the uid the payload claimed');
+        assert.equal(event.refusal?.providerUid, OWNER_UID, 'and the uid Chargebee\'s hosted page carries');
+        assert.equal(event.refusal?.source, 'hosted-page', 'and which of Chargebee\'s records answered');
+        assert.match(logs.join('\n'), /UID MISMATCH/, 'the refusal is loud');
+      },
+    },
+
+    {
+      name: 'a subscription whose page has aged out of the window falls back, never refuses',
+
+      async run() {
+        // The scan covers the last 25 hosted pages: a null answer means "not in
+        // the window", not "not this uid". Refusing on it would break every
+        // hosted-page checkout older than 25 pages.
+        const { store, logs } = await runHostedPageEvent({ payloadUid: FORGED_UID, payloadOrderId: FORGED_ORDER_ID, inWindow: false });
+
+        assert.ok(!store.get(`payments-webhooks/${EVENT_ID}`)?.refusal, 'a miss is not a mismatch');
+        assert.equal(store.get(`users/${FORGED_UID}`)?.subscription?.status, 'active', 'the payload steers, as it did before');
+        assert.match(logs.join('\n'), /UID FALLBACK/, 'and the write that was never cross-checked is named out loud');
+      },
+    },
+
+    {
+      name: 'a payload uid the hosted page AGREES with steers, and brings its orderId',
+
+      async run() {
+        const { store } = await runHostedPageEvent({ payloadUid: OWNER_UID, payloadOrderId: OWNER_ORDER_ID });
+
+        assert.ok(!store.get(`payments-webhooks/${EVENT_ID}`)?.refusal, 'a claim the second source confirms is refused nothing');
+        assert.equal(store.get(`users/${OWNER_UID}`)?.subscription?.status, 'active', 'the subscription lands on the owner\'s doc');
+        assert.equal(store.get(`payments-orders/${OWNER_ORDER_ID}`)?.owner, OWNER_UID, 'and the order the hosted page names is written with it');
+      },
+    },
+
+    {
+      name: 'a payload claiming no uid at all still resolves from the hosted page',
+
+      async run() {
+        // The path this lookup was written for ([#347]) — unchanged.
+        const { store } = await runHostedPageEvent({ payloadUid: null, payloadOrderId: null });
+        const event = store.get(`payments-webhooks/${EVENT_ID}`);
+
+        assert.ok(!event.refusal, 'a payload that claims nothing contradicts nothing');
+        assert.equal(event.owner, OWNER_UID, 'the resolved uid is persisted on the event doc');
+        assert.equal(store.get(`users/${OWNER_UID}`)?.subscription?.status, 'active', 'and the subscription lands on it');
+      },
+    },
+  ],
+});