@hearthkit/payments 0.1.0

package/src/handle-stripe-webhook-ignored.test.ts

@@ -0,0 +1,293 @@
+import { afterAll, describe, expect, it } from 'vitest'
+import { expectResultKind } from '../test-fixtures/payments-gate-expectations.ts'
+import { defineGateFileContext } from '../test-fixtures/payments-gate-file-context.ts'
+import {
+  countGatePaymentsRows,
+  createVerifiedGatePaymentsDatabase,
+  type GatePaymentsDatabase,
+} from '../test-fixtures/payments-gate-postgres-database.ts'
+import {
+  buildGateCheckoutSessionObject,
+  buildGateStripeWebhookDelivery,
+  buildGateSubscriptionObject,
+  gateBillingReferenceMetadata,
+  gateCheckoutPriceMetadata,
+  gateNowSecondsSinceEpoch,
+  uniqueGateStripeId,
+} from '../test-fixtures/payments-gate-stripe-events.ts'
+import {
+  gatePaymentsCatalog,
+  uniqueGateBillingContactEmail,
+  uniqueGateBillingReferenceId,
+  uniqueGatePaymentsCatalogNames,
+} from '../test-fixtures/payments-gate-values.ts'
+import {
+  createGatePaymentsClient,
+  loadHearthkitPaymentsEntry,
+  type HearthkitPaymentsEntry,
+} from '../test-fixtures/hearthkit-payments-entry.ts'
+import {
+  handleStripeWebhookResultSchema,
+  type PaymentsClient,
+  type PaymentsWebhookIgnoredReason,
+} from './payments-contract.ts'
+
+/**
+ * Every value of ignoredReason, all six, with no Stripe key and no network. An ignored delivery is a
+ * RESULT and not a failure: Stripe delivers every event type an endpoint is subscribed to and most of
+ * them are none of this package's business, so modelling that as an error would make a webhook route
+ * log a stack trace on an ordinary Tuesday.
+ *
+ * Every gate here also asserts that nothing was written. "Ignored" has to mean ignored: a delivery
+ * that half-wrote a customer row and then declined to record the rest would pass a kind check while
+ * leaving the database in a state nobody asked for.
+ */
+
+const gateFile = defineGateFileContext<{
+  paymentsEntry: HearthkitPaymentsEntry
+  paymentsClient: PaymentsClient
+  gateDatabase: GatePaymentsDatabase
+  subscriptionPriceName: string
+}>(async () => {
+  const paymentsEntry = await loadHearthkitPaymentsEntry()
+  const gateDatabase = await createVerifiedGatePaymentsDatabase('ignored', paymentsEntry)
+  const catalogNames = uniqueGatePaymentsCatalogNames('ignored')
+  const paymentsClient = createGatePaymentsClient({
+    paymentsEntry,
+    drizzleClient: gateDatabase.drizzleClient,
+    paymentsCatalog: gatePaymentsCatalog(catalogNames),
+  })
+  return {
+    paymentsEntry,
+    paymentsClient,
+    gateDatabase,
+    subscriptionPriceName: catalogNames.subscriptionPriceName,
+  }
+})
+
+afterAll(async () => {
+  await gateFile.releaseIfCreated(({ gateDatabase }) => gateDatabase.removeGatePaymentsDatabase())
+})
+
+/** Delivers one synthesised, locally signed event and asserts it was ignored for the stated reason, writing nothing. */
+async function expectDeliveryIgnored(
+  stripeEventType: string,
+  eventDataObject: Record<string, unknown>,
+  ignoredReason: PaymentsWebhookIgnoredReason,
+): Promise<void> {
+  const { paymentsEntry, paymentsClient, gateDatabase } = await gateFile.read()
+  const delivery = buildGateStripeWebhookDelivery(paymentsClient, {
+    stripeEventType,
+    eventDataObject,
+  })
+
+  const result = await paymentsEntry.handleStripeWebhook({
+    paymentsClient,
+    rawRequestBody: delivery.rawRequestBody,
+    requestHeaders: delivery.requestHeaders,
+  })
+  handleStripeWebhookResultSchema.parse(result)
+  const ignored = expectResultKind(result, 'payments-webhook-ignored')
+
+  expect(ignored.ignoredReason).toBe(ignoredReason)
+  // Both webhook results carry the event id, so a log line traces back to a delivery in the Stripe
+  // dashboard even when nothing was written.
+  expect(String(ignored.stripeEventId)).toBe(delivery.stripeEventId)
+  expect(ignored.stripeEventType).toBe(stripeEventType)
+
+  expect(
+    await countGatePaymentsRows(
+      gateDatabase.drizzleClient,
+      paymentsEntry.hearthkitPaymentsDrizzleSchema,
+    ),
+  ).toEqual({ payments_customer: 0, payments_subscription: 0, payments_purchase: 0 })
+}
+
+describe('payments-webhook-ignored', () => {
+  it('ignores an event type it does not handle, reporting event-type-not-handled rather than failing', async () => {
+    // The handled set is exactly the four @better-auth/stripe handles. invoice.paid is a real event
+    // an endpoint can easily be subscribed to and is none of this package's business.
+    await expectDeliveryIgnored(
+      'invoice.paid',
+      { id: uniqueGateStripeId('in'), object: 'invoice', livemode: false },
+      'event-type-not-handled',
+    )
+  })
+
+  it('ignores a completed session whose mode is setup, and one whose payment status is unpaid', async () => {
+    const billingReferenceId = uniqueGateBillingReferenceId('ignored-mode')
+
+    // Stripe's mode union is payment | setup | subscription. This package never creates a setup
+    // session, so one arriving here came from somewhere else.
+    await expectDeliveryIgnored(
+      'checkout.session.completed',
+      buildGateCheckoutSessionObject({
+        stripeCheckoutSessionId: uniqueGateStripeId('cs'),
+        stripeCustomerId: uniqueGateStripeId('cus'),
+        checkoutMode: 'setup',
+        paymentStatus: 'no_payment_required',
+        billingContactEmail: uniqueGateBillingContactEmail('ignored-mode'),
+        metadata: gateBillingReferenceMetadata(billingReferenceId),
+      }),
+      'checkout-mode-not-handled',
+    )
+
+    // A purchase is recorded for paid and for no_payment_required, which is what a fully discounted
+    // order reports; unpaid is the third member of that union and the one that records nothing.
+    await expectDeliveryIgnored(
+      'checkout.session.completed',
+      buildGateCheckoutSessionObject({
+        stripeCheckoutSessionId: uniqueGateStripeId('cs'),
+        stripeCustomerId: uniqueGateStripeId('cus'),
+        checkoutMode: 'payment',
+        paymentStatus: 'unpaid',
+        billingContactEmail: uniqueGateBillingContactEmail('ignored-unpaid'),
+        stripePaymentIntentId: uniqueGateStripeId('pi'),
+        metadata: {
+          ...gateBillingReferenceMetadata(billingReferenceId),
+          ...gateCheckoutPriceMetadata(
+            'gate-price-name-that-is-present',
+            uniqueGateStripeId('price'),
+            1,
+          ),
+        },
+      }),
+      'checkout-session-unpaid',
+    )
+  })
+
+  it('ignores a session and a subscription that carry no billing reference metadata, because inventing one would attach someone else money to a hearthkit account', async () => {
+    const { subscriptionPriceName } = await gateFile.read()
+
+    await expectDeliveryIgnored(
+      'checkout.session.completed',
+      buildGateCheckoutSessionObject({
+        stripeCheckoutSessionId: uniqueGateStripeId('cs'),
+        stripeCustomerId: uniqueGateStripeId('cus'),
+        checkoutMode: 'subscription',
+        paymentStatus: 'paid',
+        billingContactEmail: uniqueGateBillingContactEmail('ignored-noref'),
+        stripeSubscriptionId: uniqueGateStripeId('sub'),
+        metadata: {},
+      }),
+      'billing-reference-missing',
+    )
+
+    // One reason serves both paths because it means the same thing and has the same fix on each. A
+    // subscription created by hand in the Stripe dashboard is exactly this: a real subscription on a
+    // catalog price, with no hearthkit metadata on it anywhere.
+    const nowSeconds = gateNowSecondsSinceEpoch()
+    await expectDeliveryIgnored(
+      'customer.subscription.created',
+      buildGateSubscriptionObject({
+        stripeSubscriptionId: uniqueGateStripeId('sub'),
+        stripeCustomerId: uniqueGateStripeId('cus'),
+        subscriptionStatus: 'active',
+        metadata: {},
+        items: [
+          {
+            stripePriceId: uniqueGateStripeId('price'),
+            priceLookupKey: subscriptionPriceName,
+            quantity: 1,
+            currentPeriodStartSeconds: nowSeconds,
+            currentPeriodEndSeconds: nowSeconds + 2_592_000,
+          },
+        ],
+      }),
+      'billing-reference-missing',
+    )
+  })
+
+  it('ignores a paid one-time session whose price metadata is absent, and one whose quantity is not a positive integer', async () => {
+    const billingReferenceId = uniqueGateBillingReferenceId('ignored-price')
+
+    // A delivery carries no line_items, so session metadata is the purchase path's only source for
+    // what was sold. Without it there is no row to write, and this reason says to look at whatever
+    // created the session rather than at the catalog.
+    await expectDeliveryIgnored(
+      'checkout.session.completed',
+      buildGateCheckoutSessionObject({
+        stripeCheckoutSessionId: uniqueGateStripeId('cs'),
+        stripeCustomerId: uniqueGateStripeId('cus'),
+        checkoutMode: 'payment',
+        paymentStatus: 'paid',
+        billingContactEmail: uniqueGateBillingContactEmail('ignored-price'),
+        stripePaymentIntentId: uniqueGateStripeId('pi'),
+        metadata: gateBillingReferenceMetadata(billingReferenceId),
+      }),
+      'checkout-price-metadata-missing',
+    )
+
+    // A quantity that is not a positive integer counts as missing rather than defaulting to one,
+    // because silently billing one unit for an order of five is worse than declining to record it.
+    await expectDeliveryIgnored(
+      'checkout.session.completed',
+      buildGateCheckoutSessionObject({
+        stripeCheckoutSessionId: uniqueGateStripeId('cs'),
+        stripeCustomerId: uniqueGateStripeId('cus'),
+        checkoutMode: 'payment',
+        paymentStatus: 'paid',
+        billingContactEmail: uniqueGateBillingContactEmail('ignored-quantity'),
+        stripePaymentIntentId: uniqueGateStripeId('pi'),
+        metadata: {
+          ...gateBillingReferenceMetadata(billingReferenceId),
+          ...gateCheckoutPriceMetadata(
+            'gate-price-name-that-is-present',
+            uniqueGateStripeId('price'),
+            'not-a-number',
+          ),
+        },
+      }),
+      'checkout-price-metadata-missing',
+    )
+  })
+
+  it('ignores a subscription whose items carry no lookup key naming a catalog price, whether the key is foreign or absent', async () => {
+    const billingReferenceId = uniqueGateBillingReferenceId('ignored-catalog')
+    const nowSeconds = gateNowSecondsSinceEpoch()
+
+    // The subscription path must consult the catalog, because priceName is resolved from lookup_key
+    // and there is no metadata to fall back on. This reason says to look at the catalog, which is
+    // exactly what the checkout path's reason does not say.
+    await expectDeliveryIgnored(
+      'customer.subscription.created',
+      buildGateSubscriptionObject({
+        stripeSubscriptionId: uniqueGateStripeId('sub'),
+        stripeCustomerId: uniqueGateStripeId('cus'),
+        subscriptionStatus: 'active',
+        metadata: gateBillingReferenceMetadata(billingReferenceId),
+        items: [
+          {
+            stripePriceId: uniqueGateStripeId('price'),
+            priceLookupKey: 'gate-price-belonging-to-some-other-catalog',
+            quantity: 1,
+            currentPeriodStartSeconds: nowSeconds,
+            currentPeriodEndSeconds: nowSeconds + 2_592_000,
+          },
+        ],
+      }),
+      'subscription-price-not-in-catalog',
+    )
+
+    // Price.lookup_key is `string | null`, and a price created by hand in the dashboard has none.
+    await expectDeliveryIgnored(
+      'customer.subscription.updated',
+      buildGateSubscriptionObject({
+        stripeSubscriptionId: uniqueGateStripeId('sub'),
+        stripeCustomerId: uniqueGateStripeId('cus'),
+        subscriptionStatus: 'active',
+        metadata: gateBillingReferenceMetadata(billingReferenceId),
+        items: [
+          {
+            stripePriceId: uniqueGateStripeId('price'),
+            priceLookupKey: null,
+            quantity: 1,
+            currentPeriodStartSeconds: nowSeconds,
+            currentPeriodEndSeconds: nowSeconds + 2_592_000,
+          },
+        ],
+      }),
+      'subscription-price-not-in-catalog',
+    )
+  })
+})

package/src/handle-stripe-webhook-purchase.test.ts

@@ -0,0 +1,279 @@
+import { afterAll, describe, expect, it } from 'vitest'
+import {
+  expectOnlyGateElement,
+  expectPaymentsFailure,
+  expectResultKind,
+  gateDateFromStripeSeconds,
+} from '../test-fixtures/payments-gate-expectations.ts'
+import { defineGateFileContext } from '../test-fixtures/payments-gate-file-context.ts'
+import {
+  countGatePaymentsRows,
+  createVerifiedGatePaymentsDatabase,
+  type GatePaymentsDatabase,
+} from '../test-fixtures/payments-gate-postgres-database.ts'
+import {
+  buildGateCheckoutSessionObject,
+  buildGateStripeWebhookDelivery,
+  gateBillingReferenceMetadata,
+  gateCheckoutPriceMetadata,
+  uniqueGateStripeId,
+} from '../test-fixtures/payments-gate-stripe-events.ts'
+import {
+  gatePaymentsCatalog,
+  uniqueGateBillingContactEmail,
+  uniqueGateBillingReferenceId,
+  uniqueGatePaymentsCatalogNames,
+} from '../test-fixtures/payments-gate-values.ts'
+import {
+  createGatePaymentsClient,
+  loadHearthkitPaymentsEntry,
+  type HearthkitPaymentsEntry,
+} from '../test-fixtures/hearthkit-payments-entry.ts'
+import {
+  handleStripeWebhookResultSchema,
+  listPaymentsPurchasesResultSchema,
+  type PaymentsClient,
+} from './payments-contract.ts'
+
+/**
+ * The purchase path, with no Stripe key and no network. Every column comes from the session's own
+ * plain fields or from session metadata this package wrote, and none from line_items, which a webhook
+ * delivery does not carry — the field is declared optional and the SDK calls it "includable" on a
+ * retrieve, and nothing expands it on a delivery.
+ *
+ * The price name every gate here sells is deliberately NOT in the client's catalog. A purchase is a
+ * historical fact: deleting a price from payments-catalog.ts must not make a completed order
+ * unrecordable, so the checkout path does not consult the catalog at all.
+ */
+
+const priceNameNotInTheCatalog = 'gate-price-deleted-from-the-catalog'
+
+const gateFile = defineGateFileContext<{
+  paymentsEntry: HearthkitPaymentsEntry
+  paymentsClient: PaymentsClient
+  gateDatabase: GatePaymentsDatabase
+}>(async () => {
+  const paymentsEntry = await loadHearthkitPaymentsEntry()
+  const gateDatabase = await createVerifiedGatePaymentsDatabase('purchase', paymentsEntry)
+  const paymentsClient = createGatePaymentsClient({
+    paymentsEntry,
+    drizzleClient: gateDatabase.drizzleClient,
+    paymentsCatalog: gatePaymentsCatalog(uniqueGatePaymentsCatalogNames('purchase')),
+  })
+  return { paymentsEntry, paymentsClient, gateDatabase }
+})
+
+afterAll(async () => {
+  await gateFile.releaseIfCreated(({ gateDatabase }) => gateDatabase.removeGatePaymentsDatabase())
+})
+
+describe('handleStripeWebhook purchase path', () => {
+  it('records a purchase for a paid one-time session and for a fully discounted one, from session metadata rather than line items', async () => {
+    const { paymentsEntry, paymentsClient } = await gateFile.read()
+
+    const paidReferenceId = uniqueGateBillingReferenceId('purchase-paid')
+    const paidSessionId = uniqueGateStripeId('cs')
+    const paidCustomerId = uniqueGateStripeId('cus')
+    const paidPaymentIntentId = uniqueGateStripeId('pi')
+    const paidPriceId = uniqueGateStripeId('price')
+    const paidDelivery = buildGateStripeWebhookDelivery(paymentsClient, {
+      stripeEventType: 'checkout.session.completed',
+      eventDataObject: buildGateCheckoutSessionObject({
+        stripeCheckoutSessionId: paidSessionId,
+        stripeCustomerId: paidCustomerId,
+        checkoutMode: 'payment',
+        paymentStatus: 'paid',
+        billingContactEmail: uniqueGateBillingContactEmail('purchase-paid'),
+        stripePaymentIntentId: paidPaymentIntentId,
+        currency: 'usd',
+        amountTotalMinorUnits: 59_800,
+        metadata: {
+          ...gateBillingReferenceMetadata(paidReferenceId),
+          // Quantity is a decimal STRING, because every Stripe metadata value is a string, and it is
+          // parsed back here rather than defaulted.
+          ...gateCheckoutPriceMetadata(priceNameNotInTheCatalog, paidPriceId, 2),
+        },
+      }),
+    })
+
+    const paidResult = await paymentsEntry.handleStripeWebhook({
+      paymentsClient,
+      rawRequestBody: paidDelivery.rawRequestBody,
+      requestHeaders: paidDelivery.requestHeaders,
+    })
+    handleStripeWebhookResultSchema.parse(paidResult)
+    const paidProcessed = expectResultKind(paidResult, 'payments-webhook-processed')
+    expect(paidProcessed.webhookOutcome).toBe('purchase-recorded')
+    expect(String(paidProcessed.stripeEventId)).toBe(paidDelivery.stripeEventId)
+
+    const paidList = await paymentsEntry.listPaymentsPurchases({
+      paymentsClient,
+      billingReferenceId: paidReferenceId,
+    })
+    listPaymentsPurchasesResultSchema.parse(paidList)
+    const paidPurchases = expectResultKind(paidList, 'payments-purchases-listed').paymentsPurchases
+    expect(paidPurchases).toHaveLength(1)
+    const paidPurchase = expectOnlyGateElement(paidPurchases, 'purchase for the paid reference')
+    expect(String(paidPurchase.stripeCheckoutSessionId)).toBe(paidSessionId)
+    expect(String(paidPurchase.stripeCustomerId)).toBe(paidCustomerId)
+    expect(String(paidPurchase.stripePaymentIntentId)).toBe(paidPaymentIntentId)
+    expect(String(paidPurchase.billingReferenceId)).toBe(paidReferenceId)
+    expect(String(paidPurchase.priceName)).toBe(priceNameNotInTheCatalog)
+    expect(String(paidPurchase.stripePriceId)).toBe(paidPriceId)
+    expect(String(paidPurchase.currency)).toBe('usd')
+    expect(paidPurchase.amountTotalMinorUnits).toBe(59_800)
+    expect(paidPurchase.quantity).toBe(2)
+    // purchasedAt is the EVENT's created, seconds since the epoch, not the moment the row was written.
+    expect(paidPurchase.purchasedAt.getTime()).toBe(
+      gateDateFromStripeSeconds(paidDelivery.createdSecondsSinceEpoch).getTime(),
+    )
+
+    // A fully discounted order: no payment intent at all, which is why that column is nullable, and
+    // a zero total, which is why amountTotalMinorUnits allows zero. payment_status is
+    // no_payment_required, the third member of that union and the second one that records a purchase.
+    const discountedReferenceId = uniqueGateBillingReferenceId('purchase-free')
+    const discountedSessionId = uniqueGateStripeId('cs')
+    const discountedDelivery = buildGateStripeWebhookDelivery(paymentsClient, {
+      stripeEventType: 'checkout.session.completed',
+      eventDataObject: buildGateCheckoutSessionObject({
+        stripeCheckoutSessionId: discountedSessionId,
+        stripeCustomerId: uniqueGateStripeId('cus'),
+        checkoutMode: 'payment',
+        paymentStatus: 'no_payment_required',
+        billingContactEmail: uniqueGateBillingContactEmail('purchase-free'),
+        stripePaymentIntentId: null,
+        currency: 'usd',
+        amountTotalMinorUnits: 0,
+        metadata: {
+          ...gateBillingReferenceMetadata(discountedReferenceId),
+          ...gateCheckoutPriceMetadata(priceNameNotInTheCatalog, uniqueGateStripeId('price'), 1),
+        },
+      }),
+    })
+
+    const discountedResult = await paymentsEntry.handleStripeWebhook({
+      paymentsClient,
+      rawRequestBody: discountedDelivery.rawRequestBody,
+      requestHeaders: discountedDelivery.requestHeaders,
+    })
+    handleStripeWebhookResultSchema.parse(discountedResult)
+    expect(expectResultKind(discountedResult, 'payments-webhook-processed').webhookOutcome).toBe(
+      'purchase-recorded',
+    )
+
+    const discountedList = expectResultKind(
+      await paymentsEntry.listPaymentsPurchases({
+        paymentsClient,
+        billingReferenceId: discountedReferenceId,
+      }),
+      'payments-purchases-listed',
+    )
+    expect(discountedList.paymentsPurchases).toHaveLength(1)
+    const discountedPurchase = expectOnlyGateElement(
+      discountedList.paymentsPurchases,
+      'purchase for the fully discounted reference',
+    )
+    expect(discountedPurchase.stripePaymentIntentId).toBeNull()
+    expect(discountedPurchase.amountTotalMinorUnits).toBe(0)
+  })
+
+  it('writes no second row when the same purchase delivery arrives twice, because the write is an upsert on the checkout session id', async () => {
+    const { paymentsEntry, paymentsClient, gateDatabase } = await gateFile.read()
+    const billingReferenceId = uniqueGateBillingReferenceId('purchase-replay')
+    const before = await countGatePaymentsRows(
+      gateDatabase.drizzleClient,
+      paymentsEntry.hearthkitPaymentsDrizzleSchema,
+    )
+
+    const delivery = buildGateStripeWebhookDelivery(paymentsClient, {
+      stripeEventType: 'checkout.session.completed',
+      eventDataObject: buildGateCheckoutSessionObject({
+        stripeCheckoutSessionId: uniqueGateStripeId('cs'),
+        stripeCustomerId: uniqueGateStripeId('cus'),
+        checkoutMode: 'payment',
+        paymentStatus: 'paid',
+        billingContactEmail: uniqueGateBillingContactEmail('purchase-replay'),
+        stripePaymentIntentId: uniqueGateStripeId('pi'),
+        currency: 'usd',
+        amountTotalMinorUnits: 29_900,
+        metadata: {
+          ...gateBillingReferenceMetadata(billingReferenceId),
+          ...gateCheckoutPriceMetadata(priceNameNotInTheCatalog, uniqueGateStripeId('price'), 1),
+        },
+      }),
+    })
+
+    // Stripe delivers events more than once. Idempotency here is structural rather than a
+    // bookkeeping table: the same bytes write the same values to the same row.
+    for (const attempt of [1, 2]) {
+      const result = await paymentsEntry.handleStripeWebhook({
+        paymentsClient,
+        rawRequestBody: delivery.rawRequestBody,
+        requestHeaders: delivery.requestHeaders,
+      })
+      handleStripeWebhookResultSchema.parse(result)
+      expect(
+        expectResultKind(result, 'payments-webhook-processed').webhookOutcome,
+        `delivery attempt ${attempt}`,
+      ).toBe('purchase-recorded')
+    }
+
+    const after = await countGatePaymentsRows(
+      gateDatabase.drizzleClient,
+      paymentsEntry.hearthkitPaymentsDrizzleSchema,
+    )
+    // Asserting exactly one new row is stronger than asserting the second delivery was refused,
+    // because it holds even if the two deliveries interleave.
+    expect(after.payments_purchase - before.payments_purchase).toBe(1)
+
+    const listed = expectResultKind(
+      await paymentsEntry.listPaymentsPurchases({ paymentsClient, billingReferenceId }),
+      'payments-purchases-listed',
+    )
+    expect(listed.paymentsPurchases).toHaveLength(1)
+  })
+
+  it('reports payments-request-failed when a paid session carries no currency, which is not a contract state', async () => {
+    const { paymentsEntry, paymentsClient, gateDatabase } = await gateFile.read()
+    const before = await countGatePaymentsRows(
+      gateDatabase.drizzleClient,
+      paymentsEntry.hearthkitPaymentsDrizzleSchema,
+    )
+
+    // Session.currency and Session.amount_total are plain nullable fields, not expandable ones, so a
+    // paid payment-mode session has both. A null here means something the contract does not model,
+    // and it lands in the catch-all rather than being written as an empty string or a zero.
+    const delivery = buildGateStripeWebhookDelivery(paymentsClient, {
+      stripeEventType: 'checkout.session.completed',
+      eventDataObject: buildGateCheckoutSessionObject({
+        stripeCheckoutSessionId: uniqueGateStripeId('cs'),
+        stripeCustomerId: uniqueGateStripeId('cus'),
+        checkoutMode: 'payment',
+        paymentStatus: 'paid',
+        billingContactEmail: uniqueGateBillingContactEmail('purchase-nocurrency'),
+        stripePaymentIntentId: uniqueGateStripeId('pi'),
+        currency: null,
+        amountTotalMinorUnits: null,
+        metadata: {
+          ...gateBillingReferenceMetadata(uniqueGateBillingReferenceId('purchase-nocurrency')),
+          ...gateCheckoutPriceMetadata(priceNameNotInTheCatalog, uniqueGateStripeId('price'), 1),
+        },
+      }),
+    })
+
+    const result = await paymentsEntry.handleStripeWebhook({
+      paymentsClient,
+      rawRequestBody: delivery.rawRequestBody,
+      requestHeaders: delivery.requestHeaders,
+    })
+    handleStripeWebhookResultSchema.parse(result)
+    const failure = expectPaymentsFailure(result, 'payments-request-failed')
+    expect(failure.paymentsFailureDetail.length).toBeGreaterThan(0)
+
+    const after = await countGatePaymentsRows(
+      gateDatabase.drizzleClient,
+      paymentsEntry.hearthkitPaymentsDrizzleSchema,
+    )
+    expect(after.payments_purchase).toBe(before.payments_purchase)
+  })
+})