@teleporthq/teleport-plugin-next-workflows 0.43.67 → 0.43.68

package/__tests__/payment-charge-user-earlier-attempt.test.ts

@@ -0,0 +1,267 @@
+import { loadHandler } from './_helpers/load-handler'
+import { PaymentDriverRegistry, loadPaymentDrivers } from './_helpers/load-payment-drivers'
+
+/**
+ * `payment-charge-user` with the checkout an order opened earlier
+ * (`previousAttempt`): the node asks the provider about it before opening
+ * another, because two open checkouts are how one order gets paid twice.
+ * With `deferRedirect` it answers with the page instead of sending the buyer
+ * there, so the workflow can record the checkout first.
+ */
+
+interface FakeDriverCalls {
+  inspected: unknown[]
+  created: any[]
+}
+
+const fakeDriver = (inspection: unknown, calls: FakeDriverCalls) => ({
+  inspectCheckout: async (input: unknown) => {
+    calls.inspected.push(input)
+    if (inspection instanceof Error) {
+      throw inspection
+    }
+    return inspection
+  },
+  createCheckout: async (input: any) => {
+    calls.created.push(input)
+    return { checkoutUrl: 'https://pay.test/new', sessionId: 'new-1' }
+  },
+})
+
+const registryOf = (driver: unknown): PaymentDriverRegistry => ({
+  ids: ['stripe'],
+  core: {},
+  get: (id: string) => (id === 'stripe' ? driver : null),
+})
+
+const CHARGE = {
+  providerId: 'stripe',
+  amount: 20,
+  currency: 'eur',
+  successUrl: '/order-details/ORD-1?payment=success',
+  cancelUrl: '/order-details/ORD-1',
+  metadata: '{"orderId":"order-1","orderNumber":"ORD-1"}',
+}
+const CONTEXT = { __baseUrl: 'https://shop.test' }
+
+const run = async (inspection: unknown, config: Record<string, unknown>) => {
+  const calls: FakeDriverCalls = { inspected: [], created: [] }
+  const handler = loadHandler('payment-charge-user', {
+    paymentDrivers: registryOf(fakeDriver(inspection, calls)),
+  })
+  const result = (await handler({ ...CHARGE, ...config }, CONTEXT)) as Record<string, unknown>
+  return { result, calls }
+}
+
+describe('payment-charge-user — the checkout opened earlier', () => {
+  beforeAll(() => {
+    ;(globalThis as { __workflowUtils?: unknown }).__workflowUtils = {
+      localizeHref: (href: string) => href,
+    }
+  })
+  afterAll(() => {
+    delete (globalThis as { __workflowUtils?: unknown }).__workflowUtils
+  })
+
+  it('sends the buyer back to a checkout they can still pay, opening no other', async () => {
+    const { result, calls } = await run(
+      { state: 'open', checkoutUrl: 'https://pay.test/earlier' },
+      { previousAttempt: 'cs_earlier', deferRedirect: true }
+    )
+    expect(calls.inspected).toEqual([{ reference: 'cs_earlier' }])
+    expect(calls.created).toEqual([])
+    expect(result).toEqual({
+      checkoutUrl: 'https://pay.test/earlier',
+      sessionId: 'cs_earlier',
+      attemptRef: 'cs_earlier',
+      attemptOutcome: 'reused',
+      redirectUrl: 'https://pay.test/earlier',
+    })
+  })
+
+  it.each(['paid', 'confirming'])(
+    'opens nothing while the earlier checkout is %s, and points the buyer at the confirmation',
+    async (state) => {
+      const { result, calls } = await run(
+        { state, checkoutUrl: '' },
+        { previousAttempt: 'cs_earlier', deferRedirect: true }
+      )
+      expect(calls.created).toEqual([])
+      expect(result).toEqual({
+        checkoutUrl: '',
+        sessionId: 'cs_earlier',
+        attemptRef: 'cs_earlier',
+        attemptOutcome: 'in-progress',
+        redirectUrl: 'https://shop.test/order-details/ORD-1?payment=success',
+      })
+    }
+  )
+
+  it('opens a new checkout once the earlier one can take no more money', async () => {
+    const { result, calls } = await run(
+      { state: 'closed', checkoutUrl: '' },
+      { previousAttempt: 'cs_earlier', deferRedirect: true }
+    )
+    expect(calls.created).toHaveLength(1)
+    // The driver learns which checkout this one follows (Square keys its link on it).
+    expect(calls.created[0].previousAttempt).toBe('cs_earlier')
+    expect(result).toEqual({
+      checkoutUrl: 'https://pay.test/new',
+      sessionId: 'new-1',
+      attemptRef: 'new-1',
+      attemptOutcome: 'created',
+      redirectUrl: 'https://pay.test/new',
+    })
+  })
+
+  it('refuses with a 400 when the provider cannot say what became of the earlier checkout', async () => {
+    for (const inspection of [
+      { state: '', checkoutUrl: '', error: 'Stripe is unavailable' },
+      new Error('socket hang up'),
+    ]) {
+      const { result, calls } = await run(inspection, {
+        previousAttempt: 'cs_earlier',
+        deferRedirect: true,
+      })
+      expect(calls.created).toEqual([])
+      expect(result).toMatchObject({ __earlyResponse: { status: 400 } })
+    }
+  })
+
+  it('opens a checkout without asking anyone when no earlier one is known', async () => {
+    const { result, calls } = await run(new Error('never asked'), { deferRedirect: 'true' })
+    expect(calls.inspected).toEqual([])
+    expect(calls.created).toHaveLength(1)
+    expect(result.attemptOutcome).toBe('created')
+    expect(result).not.toHaveProperty('__terminal')
+  })
+
+  it('without deferRedirect stays terminal, and sends a payment in progress to the confirmation', async () => {
+    const { result } = await run({ state: 'confirming' }, { previousAttempt: 'cs_earlier' })
+    expect(result).toMatchObject({
+      __terminal: true,
+      __redirectUrl: 'https://shop.test/order-details/ORD-1?payment=success',
+      attemptOutcome: 'in-progress',
+    })
+  })
+
+  it('opens a checkout as before with a driver that cannot inspect one', async () => {
+    const calls: FakeDriverCalls = { inspected: [], created: [] }
+    const { inspectCheckout, ...withoutInspect } = fakeDriver({ state: 'open' }, calls)
+    expect(typeof inspectCheckout).toBe('function')
+    const handler = loadHandler('payment-charge-user', {
+      paymentDrivers: registryOf(withoutInspect),
+    })
+    const result = await handler({ ...CHARGE, previousAttempt: 'cs_earlier' }, CONTEXT)
+    expect(calls.created).toHaveLength(1)
+    expect(result).toMatchObject({ attemptOutcome: 'created', __terminal: true })
+  })
+})
+
+describe('payment-charge-user — an order that recorded no checkout', () => {
+  const PLACED_AT = '2026-09-28T10:00:00.000Z'
+  const { core } = loadPaymentDrivers({ ids: [] })
+
+  beforeAll(() => {
+    ;(globalThis as { __workflowUtils?: unknown }).__workflowUtils = {
+      localizeHref: (href: string) => href,
+    }
+  })
+  afterAll(() => {
+    delete (globalThis as { __workflowUtils?: unknown }).__workflowUtils
+  })
+
+  const lookup = async (found: unknown, states: Record<string, unknown> = {}) => {
+    const calls = { found: [] as unknown[], closed: [] as string[], created: [] as unknown[] }
+    const driver = {
+      findCheckouts: async (input: unknown) => {
+        calls.found.push(input)
+        return found
+      },
+      closeCheckout: async ({ reference }: { reference: string }) => {
+        calls.closed.push(reference)
+        return states[reference]
+      },
+      createCheckout: async (input: unknown) => {
+        calls.created.push(input)
+        return { checkoutUrl: 'https://pay.test/new', sessionId: 'new-1' }
+      },
+    }
+    const handler = loadHandler('payment-charge-user', {
+      paymentDrivers: {
+        ids: ['stripe'],
+        core,
+        get: (id: string) => (id === 'stripe' ? driver : null),
+      },
+    })
+    const result = (await handler(
+      { ...CHARGE, deferRedirect: true, lookupOrderId: 'order-1', lookupPlacedAt: PLACED_AT },
+      CONTEXT
+    )) as Record<string, unknown>
+    return { result, calls }
+  }
+
+  it('closes the pages its placing opened, then opens a new one', async () => {
+    const { result, calls } = await lookup({ references: ['cs_a'] }, { cs_a: { state: 'closed' } })
+    expect(calls.found).toEqual([{ orderId: 'order-1', placedAt: PLACED_AT }])
+    expect(calls.closed).toEqual(['cs_a'])
+    expect(calls.created).toHaveLength(1)
+    expect(result).toMatchObject({ attemptOutcome: 'created', attemptRef: 'new-1' })
+  })
+
+  it('opens nothing when a page it finds took the money, or is taking it', async () => {
+    for (const state of ['paid', 'confirming']) {
+      const { result, calls } = await lookup({ references: ['cs_a'] }, { cs_a: { state } })
+      expect(calls.created).toEqual([])
+      expect(result).toMatchObject({
+        attemptOutcome: 'in-progress',
+        attemptRef: '',
+        redirectUrl: 'https://shop.test/order-details/ORD-1?payment=success',
+      })
+    }
+  })
+
+  it('reopens a page the provider cannot close, answered to be recorded', async () => {
+    const { result, calls } = await lookup(
+      { references: ['42'] },
+      {
+        42: {
+          state: 'open',
+          checkoutUrl: 'https://coingate.test/42',
+          openUntil: '2026-09-28T10:20:00Z',
+        },
+      }
+    )
+    expect(calls.created).toEqual([])
+    expect(result).toEqual({
+      checkoutUrl: 'https://coingate.test/42',
+      sessionId: '42',
+      attemptRef: '42',
+      attemptOutcome: 'adopted',
+      redirectUrl: 'https://coingate.test/42',
+    })
+  })
+
+  it('waits out a page it cannot find (PayPal), saying until when', async () => {
+    const until = new Date(Date.now() + 3 * 60 * 60 * 1000)
+    const { result, calls } = await lookup({ searchable: false, openUntil: until.toISOString() })
+    expect(calls.created).toEqual([])
+    const early = result.__earlyResponse as { status: number; body: { error: string } }
+    expect(early.status).toBe(400)
+    expect(early.body.error).toContain(until.toISOString().slice(0, 16).replace('T', ' ') + ' UTC')
+  })
+
+  it('opens a new page once a page it cannot find has certainly run out', async () => {
+    const { result, calls } = await lookup({ searchable: false, openUntil: PLACED_AT })
+    expect(calls.created).toHaveLength(1)
+    expect(result.attemptOutcome).toBe('created')
+  })
+
+  it('refuses when the provider cannot be searched', async () => {
+    const { result, calls } = await lookup({ error: 'Stripe is down' })
+    expect(calls.created).toEqual([])
+    expect(result).toMatchObject({
+      __earlyResponse: { status: 400, body: { error: 'Stripe is down' } },
+    })
+  })
+})

package/__tests__/payment-charge-user-handler-serialization.test.ts

@@ -1,96 +1,61 @@
 import { paymentChargeUser } from '../src/nodes/payment/payment-charge-user'
-
-// Regression coverage for a production bug: clicking "Pay Now" on a
-// Stripe checkout failed with
-//   { "success": false, "error": "Oo is not defined", "provider": "stripe" }
-//
-// Root cause: `generateHandler()` builds the final server-route handler by
-// calling `.toString()` on several TypeScript functions independently and
-// concatenating the source text (see `../src/nodes/types.ts`'s
-// `handlerToString` docs). Two currency-code arrays
-// (STRIPE_ZERO_DECIMAL_CURRENCIES / STRIPE_THREE_DECIMAL_CURRENCIES) used
-// to be declared as top-level consts and referenced from inside
-// `toStripeMinorUnits`. That's fine in an unminified build, but this
-// package is itself bundled + minified by consumers (teleport-gui's
-// browser packer, via webpack/Terser) before `generateHandler()` ever
-// runs — the minifier is free to rename an unused-by-name top-level
-// const (nothing calls it by string, only a runtime `.toString()` read
-// does, which the minifier can't see), and it renamed the declaration
-// away from what the reconstructed `var STRIPE_ZERO_DECIMAL_CURRENCIES =
-// [...]` text in `generateHandler()` assumed. The result: the generated
-// workflow segment file declared the array under the ORIGINAL name but
-// `toStripeMinorUnits`'s serialized body referenced the MINIFIER-RENAMED
-// name (e.g. a mangled `Oo`), which was never declared anywhere in the
-// generated file — a `ReferenceError` the first time a Stripe charge ran
-// with a zero- or three-decimal currency.
-//
-// The fix moves both arrays to be declared LOCAL to `toStripeMinorUnits`
-// so the declaration and every reference to it live in the SAME
-// `.toString()` snapshot — a consistent rename can never separate them.
-describe('payment-charge-user handler serialization survives minification-style renaming', () => {
+import { generatePaymentCoreCode } from '../src/payments/payment-core-code'
+import { evaluateEmittedModule } from './_helpers/load-invoice-route'
+
+// A production bug once made every Stripe charge in a minified build fail
+// with "Oo is not defined": the handler was assembled from several
+// `.toString()`'d functions, and a minifier renamed a top-level currency list
+// away from the name the serialized function referenced. The provider code
+// now ships as STRING modules (`utils/payments/*.js`, see src/payments), which
+// no minifier rewrites; these tests pin what is left of that hazard — the
+// handler itself — and the money conversion the drivers share.
+describe('payment-charge-user handler serialization', () => {
   const handlerSource = paymentChargeUser.generateHandler()
 
-  it('does not reference the old top-level currency-array identifiers anywhere', () => {
-    // These names no longer exist ANYWHERE in the source — not as a
-    // declaration, not as a reference. If a future edit reintroduces a
-    // top-level const referenced only from inside a separately
-    // `.toString()`'d function, this is the shape of bug that comes back.
-    expect(handlerSource).not.toContain('STRIPE_ZERO_DECIMAL_CURRENCIES')
-    expect(handlerSource).not.toContain('STRIPE_THREE_DECIMAL_CURRENCIES')
+  it('produces syntactically valid, runnable JavaScript end-to-end', () => {
+    // Evaluating the FULL concatenated source is what catches an orphaned
+    // free-variable reference, exactly like requiring the generated segment.
+    expect(() => new Function(handlerSource + '\nreturn payment_charge_user;')()).not.toThrow()
   })
 
-  it('declares the currency arrays INSIDE toStripeMinorUnits, not reconstructed separately', () => {
-    const fnStart = handlerSource.indexOf('function toStripeMinorUnits')
-    expect(fnStart).toBeGreaterThan(-1)
-    // The next function declaration marks the end of toStripeMinorUnits's
-    // body (functions are concatenated back-to-back by generateHandler()).
-    // chargeWithStripe is `async function …` — the slice must stop BEFORE the
-    // `async` keyword or the extracted body ends with a dangling `async`.
-    const nextFn = /(?:async\s+)?function chargeWithStripe/.exec(handlerSource.slice(fnStart))
-    expect(nextFn).not.toBeNull()
-    const body = handlerSource.slice(fnStart, fnStart + nextFn!.index)
-    expect(body).toContain('JPY')
-    expect(body).toContain('BHD')
+  it('reads no environment and requires no module: providers are reached through the drivers', () => {
+    expect(handlerSource).toContain('__paymentDrivers')
+    expect(handlerSource).not.toContain('process')
+    expect(handlerSource).not.toMatch(/\brequire\(/)
   })
+})
 
-  it('produces syntactically valid, runnable JavaScript end-to-end', () => {
-    // Evaluating the FULL concatenated handler source (not just one
-    // function in isolation) is what actually catches an orphaned
-    // free-variable reference — exactly like requiring the generated
-    // workflow segment .js file would in production.
-    expect(() => new Function(handlerSource + '\nreturn payment_charge_user;')()).not.toThrow()
-  })
+describe('the drivers’ minor-unit conversion (utils/payments/core.js)', () => {
+  const core = evaluateEmittedModule<{
+    toMinor: (major: unknown, currency: string) => number
+    fromMinor: (minor: unknown, currency: string) => number
+    decimalString: (major: unknown, currency: string) => string
+  }>(generatePaymentCoreCode(), require)
 
-  describe('toStripeMinorUnits — extracted from the serialized handler source', () => {
-    const toStripeMinorUnits = (() => {
-      const fnStart = handlerSource.indexOf('function toStripeMinorUnits')
-      const nextFn = /(?:async\s+)?function chargeWithStripe/.exec(handlerSource.slice(fnStart))
-      const body = handlerSource.slice(fnStart, fnStart + (nextFn as RegExpExecArray).index)
-      return new Function(body + '\nreturn toStripeMinorUnits;')() as (
-        major: unknown,
-        currency: string
-      ) => number
-    })()
+  it('converts a two-decimal currency to cents', () => {
+    expect(core.toMinor(19.99, 'usd')).toBe(1999)
+  })
 
-    it('converts a standard (2-decimal) currency to minor units', () => {
-      expect(toStripeMinorUnits(19.99, 'usd')).toBe(1999)
-    })
+  it('passes zero-decimal currencies through rounded, unmultiplied', () => {
+    expect(core.toMinor(500, 'JPY')).toBe(500)
+    expect(core.toMinor(500.6, 'jpy')).toBe(501)
+  })
 
-    it('passes zero-decimal currencies through rounded, unmultiplied', () => {
-      // This is the exact code path that threw "Oo is not defined" in
-      // production — a JPY (zero-decimal) charge.
-      expect(toStripeMinorUnits(500, 'JPY')).toBe(500)
-      expect(toStripeMinorUnits(500.6, 'jpy')).toBe(501)
-    })
+  it('multiplies three-decimal currencies by 1000', () => {
+    expect(core.toMinor(1.5, 'BHD')).toBe(1500)
+  })
 
-    it('multiplies three-decimal currencies by 1000', () => {
-      expect(toStripeMinorUnits(1.5, 'BHD')).toBe(1500)
-    })
+  it('returns 0 for non-finite or non-positive amounts', () => {
+    expect(core.toMinor(0, 'usd')).toBe(0)
+    expect(core.toMinor(-5, 'usd')).toBe(0)
+    expect(core.toMinor(NaN, 'usd')).toBe(0)
+  })
 
-    it('returns 0 for non-finite or non-positive amounts', () => {
-      expect(toStripeMinorUnits(0, 'usd')).toBe(0)
-      expect(toStripeMinorUnits(-5, 'usd')).toBe(0)
-      expect(toStripeMinorUnits(NaN, 'usd')).toBe(0)
-    })
+  it('reads a provider amount back and prints one with the currency’s decimals', () => {
+    expect(core.fromMinor(1999, 'usd')).toBe(19.99)
+    expect(core.fromMinor(1500, 'BHD')).toBe(1.5)
+    expect(core.decimalString(12.5, 'EUR')).toBe('12.50')
+    expect(core.decimalString(12.5, 'JPY')).toBe('13')
+    expect(core.decimalString(1.2345, 'KWD')).toBe('1.235')
   })
 })

package/__tests__/payment-charge-user-line-descriptions.test.ts

@@ -0,0 +1,124 @@
+import { loadHandler, HandlerFn } from './_helpers/load-handler'
+
+/**
+ * A line bought with product options carries its short configuration label as
+ * `description` in the checkout's line items, and Stripe shows it under the
+ * product on the hosted page and the receipt. Stripe rejects an empty-string
+ * description, so a line without options must reach Stripe exactly as before.
+ */
+
+type SessionParams = Record<string, any>
+
+const withFakeStripe = async (run: (sessions: SessionParams[]) => Promise<void>) => {
+  const sessions: SessionParams[] = []
+  function FakeStripe() {
+    return {
+      checkout: {
+        sessions: {
+          create: async (params: SessionParams) => {
+            sessions.push(params)
+            return { id: 'cs_test_1', url: 'https://checkout.stripe.test/cs_test_1' }
+          },
+        },
+      },
+    }
+  }
+  const scope = globalThis as { __non_webpack_require__?: unknown; __workflowUtils?: unknown }
+  const savedKey = process.env.STRIPE_SECRET_KEY
+  scope.__non_webpack_require__ = (name: string) => {
+    if (name !== 'stripe') {
+      throw new Error('unexpected require ' + name)
+    }
+    return FakeStripe
+  }
+  scope.__workflowUtils = { localizeHref: (href: string) => href }
+  process.env.STRIPE_SECRET_KEY = 'sk_test_1'
+  try {
+    await run(sessions)
+  } finally {
+    delete scope.__non_webpack_require__
+    delete scope.__workflowUtils
+    if (savedKey === undefined) {
+      delete process.env.STRIPE_SECRET_KEY
+    } else {
+      process.env.STRIPE_SECRET_KEY = savedKey
+    }
+  }
+}
+
+describe('payment-charge-user — Stripe line descriptions', () => {
+  const handler: HandlerFn = loadHandler('payment-charge-user')
+  const charge = (lineItems: unknown[]) =>
+    handler(
+      {
+        providerId: 'stripe',
+        amount: 41,
+        currency: 'usd',
+        successUrl: 'https://store.test/order-details/ORD-1',
+        cancelUrl: 'https://store.test/checkout',
+        lineItems,
+      },
+      {}
+    )
+
+  it('sends the configuration label as the product description', async () => {
+    await withFakeStripe(async (sessions) => {
+      await charge([
+        {
+          name: 'Photo print',
+          unitAmount: 27,
+          quantity: 1,
+          description: '  Size: A3 · Paper: Glossy  ',
+        },
+      ])
+      expect(sessions[0].line_items[0].price_data.product_data).toEqual({
+        name: 'Photo print',
+        description: 'Size: A3 · Paper: Glossy',
+      })
+    })
+  })
+
+  it('omits the description when a line has none, an empty one or a non-string', async () => {
+    await withFakeStripe(async (sessions) => {
+      await charge([
+        { name: 'Mug', unitAmount: 12, quantity: 2 },
+        { name: 'Tote', unitAmount: 8, quantity: 1, description: '   ' },
+        { name: 'Cap', unitAmount: 6, quantity: 1, description: { label: 'x' } },
+      ])
+      expect(
+        sessions[0].line_items.map((line: SessionParams) => line.price_data.product_data)
+      ).toEqual([{ name: 'Mug' }, { name: 'Tote' }, { name: 'Cap' }])
+    })
+  })
+
+  it('caps the description at the 500 characters Stripe accepts', async () => {
+    await withFakeStripe(async (sessions) => {
+      await charge([
+        { name: 'Engraved pen', unitAmount: 20, quantity: 1, description: 'E'.repeat(700) },
+      ])
+      expect(sessions[0].line_items[0].price_data.product_data.description).toBe('E'.repeat(500))
+    })
+  })
+
+  it('keeps the single-line session for a charge without line items', async () => {
+    await withFakeStripe(async (sessions) => {
+      await handler(
+        {
+          providerId: 'stripe',
+          amount: 41,
+          currency: 'usd',
+          description: 'Order ORD-1',
+          successUrl: 'https://store.test/done',
+          cancelUrl: 'https://store.test/checkout',
+        },
+        {}
+      )
+      expect(sessions[0].line_items).toEqual([
+        {
+          price_data: { currency: 'usd', product_data: { name: 'Order ORD-1' }, unit_amount: 4100 },
+          quantity: 1,
+        },
+      ])
+    })
+  })
+})

package/__tests__/payment-charge-user-report-refusal.test.ts

@@ -0,0 +1,105 @@
+import { loadHandler } from './_helpers/load-handler'
+import { PaymentDriverRegistry } from './_helpers/load-payment-drivers'
+
+/**
+ * `payment-charge-user` with `reportRefusal`: a provider that will not open
+ * the checkout (keys refused, a currency its account cannot charge, a
+ * business it has not verified) is answered as the node's result, so the
+ * workflow can give back what the order held and tell the buyer why —
+ * never under `error`, which would end the run.
+ */
+
+const registryOf = (driver: unknown): PaymentDriverRegistry => ({
+  ids: ['coingate'],
+  core: {},
+  get: (id: string) => (id === 'coingate' ? driver : null),
+})
+
+const refusing = {
+  createCheckout: async () => ({
+    checkoutUrl: '',
+    sessionId: '',
+    error: 'Order is not valid: Business is not verified',
+  }),
+}
+const opening = {
+  createCheckout: async () => ({ checkoutUrl: 'https://pay.test/1', sessionId: '1234' }),
+}
+
+const CHARGE = {
+  providerId: 'CoinGate',
+  amount: 20,
+  currency: 'eur',
+  successUrl: '/order-details/ORD-1?payment=success',
+  cancelUrl: '/order-details/ORD-1',
+  metadata: '{"orderId":"order-1","orderNumber":"ORD-1"}',
+  deferRedirect: true,
+}
+const CONTEXT = { __baseUrl: 'https://shop.test' }
+
+const run = async (driver: unknown, config: Record<string, unknown>) =>
+  (await loadHandler('payment-charge-user', { paymentDrivers: registryOf(driver) })(
+    { ...CHARGE, ...config },
+    CONTEXT
+  )) as Record<string, unknown>
+
+describe('payment-charge-user — reportRefusal', () => {
+  beforeAll(() => {
+    ;(globalThis as { __workflowUtils?: unknown }).__workflowUtils = {
+      localizeHref: (href: string) => href,
+    }
+  })
+  afterAll(() => {
+    delete (globalThis as { __workflowUtils?: unknown }).__workflowUtils
+  })
+
+  it("answers the provider's refusal in its own words, for the workflow to act on", async () => {
+    const result = await run(refusing, { reportRefusal: true })
+    expect(result).toEqual({
+      refused: 'true',
+      refusal: 'Order is not valid: Business is not verified',
+      provider: 'coingate',
+      checkoutUrl: '',
+      sessionId: '',
+      attemptRef: '',
+      attemptOutcome: '',
+      redirectUrl: '',
+    })
+    expect(result).not.toHaveProperty('error')
+  })
+
+  it('says a provider the store has no driver for refused too', async () => {
+    const result = await run(null, { reportRefusal: 'true' })
+    expect(result).toMatchObject({
+      refused: 'true',
+      refusal: 'Payment provider "coingate" is not supported by this store.',
+    })
+  })
+
+  it('names the provider and no refusal when the checkout opened', async () => {
+    expect(await run(opening, { reportRefusal: true })).toEqual({
+      checkoutUrl: 'https://pay.test/1',
+      sessionId: '1234',
+      attemptRef: '1234',
+      attemptOutcome: 'created',
+      redirectUrl: 'https://pay.test/1',
+      refused: 'false',
+      refusal: '',
+      provider: 'coingate',
+    })
+  })
+
+  it('still ends the run with a 400 without it', async () => {
+    expect(await run(refusing, {})).toEqual({
+      __earlyResponse: {
+        status: 400,
+        headers: { 'Content-Type': 'application/json' },
+        body: {
+          success: false,
+          error: 'Order is not valid: Business is not verified',
+          provider: 'coingate',
+        },
+      },
+    })
+  })
+})