@teleporthq/teleport-plugin-next-workflows 0.43.74 → 0.44.0

package/__tests__/invoice-billing-details.test.ts

@@ -0,0 +1,278 @@
+/* tslint:disable:function-constructor */
+import { generateInvoiceGenerateRouteCode } from '../src/invoice/api-routes-code'
+import { generatePdfGeneratorCode } from '../src/invoice/pdf-generator-code'
+import type { UIDLInvoiceSettings } from '@teleporthq/teleport-types'
+import {
+  INVOICE_TEST_APP_SECRET,
+  createInvoiceRouteRequire,
+  evaluateEmittedModule,
+  serverCallHeaders,
+} from './_helpers/load-invoice-route'
+
+/**
+ * The buyer's own invoice details on the invoice. An order whose buyer gave
+ * them (a booking's "Add invoice details") carries the address in its parts
+ * and the tax or VAT number in its metadata: the invoice is made out to them
+ * — never mixed with a shipping address — and names the VAT number. A booking
+ * order also records the tax its final price includes, so its invoice extracts
+ * it instead of adding the store's rate on top. And the template's sample
+ * customer never fills a part the buyer left out. Every piece below is the
+ * EMITTED code, run.
+ */
+
+const settingsWith = (overrides: Record<string, unknown>) =>
+  ({
+    invoicePrefix: 'INV-',
+    defaultTaxRate: 19,
+    showDiscount: false,
+    taxIncludedInPrice: false,
+    companyDetails: {},
+    template: { document: null as unknown },
+    tables: { invoicesTable: 'teleport_invoices', invoiceItemsTable: 'teleport_invoice_items' },
+    emailDelivery: { enabled: false },
+    ...overrides,
+  } as unknown as UIDLInvoiceSettings)
+
+type Row = Record<string, unknown>
+
+const BOOKING_ORDER: Row = {
+  id: 'order-bk',
+  order_number: 'ORD-1',
+  currency: 'EUR',
+  total_amount: 238,
+  shipping_amount: 0,
+  billing_name: 'Acme SRL',
+  billing_email: 'ana@example.com',
+  billing_address: 'Str. Lunga 1, 400000 Cluj, Cluj, Romania',
+  shipping_city: 'Shipped-to city',
+  tax_breakdown: JSON.stringify({
+    taxRate: 19,
+    taxIncluded: true,
+    taxDecimals: 2,
+    shippingTax: 0,
+    lines: [{ productId: 'room', variantId: '', taxRate: 19, taxIncluded: true }],
+  }),
+  metadata: JSON.stringify({
+    bookingId: 'b1',
+    bookingReference: 'BK-1',
+    billingTaxId: 'RO12345678',
+    billingStreet: 'Str. Lunga 1',
+    billingCity: 'Cluj',
+    billingPostalCode: '400000',
+    billingRegion: 'Cluj',
+    billingCountry: 'Romania',
+  }),
+}
+const BOOKING_ITEMS: Row[] = [
+  {
+    product_id: 'room',
+    product_name: 'Double room',
+    quantity: 1,
+    unit_price: 238,
+    total_price: 238,
+  },
+]
+
+async function runHandler(
+  settings: UIDLInvoiceSettings,
+  order: Row,
+  items: Row[],
+  body: Row
+): Promise<{ status: number; invoice: Row }> {
+  const code = generateInvoiceGenerateRouteCode(settings)
+  let invoice: Row = {}
+  const handler = evaluateEmittedModule<(req: unknown, res: unknown) => Promise<void>>(
+    code,
+    createInvoiceRouteRequire(settings, {
+      dataAccess: {
+        getOrderWithItems: async (orderId: string) =>
+          orderId === order.id ? { order, items } : null,
+        reserveInvoice: async (invoiceData: Row) => {
+          invoice = invoiceData
+          return { invoice: invoiceData, created: true }
+        },
+        storeInvoicePdf: async () => ({}),
+        updateInvoice: async () => ({}),
+      },
+      pdfGenerator: {
+        generateInvoicePdf: async () => Buffer.from('%PDF-1.4 fake'),
+        COMPANY_DETAILS: {},
+      },
+    })
+  )
+  let status = 0
+  const res = {
+    status(statusCode: number) {
+      status = statusCode
+      return this
+    },
+    json() {
+      return this
+    },
+    setHeader() {
+      /* unused */
+    },
+    end() {
+      /* unused */
+    },
+  }
+  await handler({ method: 'POST', headers: serverCallHeaders(), body }, res)
+  return { status, invoice }
+}
+
+interface PdfGeneratorModule {
+  buildInvoiceDataScope: (invoiceData: Row) => { invoiceData: Record<string, Row> }
+}
+
+function loadPdfGenerator(
+  settings: UIDLInvoiceSettings,
+  templateUidl: unknown
+): PdfGeneratorModule {
+  const code = generatePdfGeneratorCode(settings, templateUidl, {})
+  const moduleObject = { exports: {} as Record<string, unknown> }
+  new Function('require', 'module', 'exports', `${code}; return module.exports;`)(
+    require,
+    moduleObject,
+    moduleObject.exports
+  )
+  return moduleObject.exports as unknown as PdfGeneratorModule
+}
+
+describe('/api/invoices/generate — the buyer’s own invoice details', () => {
+  const originalFetch = globalThis.fetch
+  const originalConnString = process.env.TELEPORT_DB_CONNECTION_STRING
+  const originalDatabaseUrl = process.env.DATABASE_URL
+  const originalAppSecret = process.env.NEXTAUTH_SECRET
+
+  beforeAll(() => {
+    globalThis.fetch = (async () => {
+      throw new Error('runtime storage not configured in tests')
+    }) as unknown as typeof fetch
+    delete process.env.TELEPORT_DB_CONNECTION_STRING
+    delete process.env.DATABASE_URL
+    process.env.NEXTAUTH_SECRET = INVOICE_TEST_APP_SECRET
+  })
+
+  afterAll(() => {
+    globalThis.fetch = originalFetch
+    if (originalAppSecret === undefined) {
+      delete process.env.NEXTAUTH_SECRET
+    } else {
+      process.env.NEXTAUTH_SECRET = originalAppSecret
+    }
+    if (originalConnString !== undefined) {
+      process.env.TELEPORT_DB_CONNECTION_STRING = originalConnString
+    }
+    if (originalDatabaseUrl !== undefined) {
+      process.env.DATABASE_URL = originalDatabaseUrl
+    }
+  })
+
+  it('makes the invoice out to the address parts and VAT number the order carries', async () => {
+    const run = await runHandler(settingsWith({}), BOOKING_ORDER, BOOKING_ITEMS, {
+      orderId: 'order-bk',
+    })
+    expect(run.status).toBe(200)
+    expect(run.invoice).toMatchObject({
+      customerName: 'Acme SRL',
+      customerAddress: 'Str. Lunga 1',
+      customerCity: 'Cluj',
+      customerZip: '400000',
+      customerState: 'Cluj',
+      customerCountry: 'Romania',
+      customerVat: 'RO12345678',
+    })
+  })
+
+  it('extracts the tax a booking price includes, so the invoice totals what was charged', async () => {
+    // The store adds 19% on top of its products; the booking's price already holds it.
+    const run = await runHandler(settingsWith({}), BOOKING_ORDER, BOOKING_ITEMS, {
+      orderId: 'order-bk',
+    })
+    expect(run.invoice.total).toBe(238)
+    expect(run.invoice.taxAmount).toBeCloseTo(38, 2)
+    expect(run.invoice.subtotal).toBeCloseTo(200, 2)
+  })
+
+  it('keeps the order’s own billing and shipping address when it carries no parts', async () => {
+    const order = {
+      ...BOOKING_ORDER,
+      tax_breakdown: null,
+      billing_address: 'Main St 5',
+      shipping_city: 'Springfield',
+      shipping_country: 'United States',
+      metadata: JSON.stringify({ billingTaxId: 'US-99' }),
+    }
+    const run = await runHandler(settingsWith({ defaultTaxRate: 0 }), order, BOOKING_ITEMS, {
+      orderId: 'order-bk',
+    })
+    expect(run.invoice).toMatchObject({
+      customerAddress: 'Main St 5',
+      customerCity: 'Springfield',
+      customerCountry: 'United States',
+      customerVat: 'US-99',
+    })
+  })
+
+  it('reads no metadata that is not a JSON object, and lets the caller’s VAT win', async () => {
+    for (const metadata of ['not json', '[1,2]', null]) {
+      const run = await runHandler(
+        settingsWith({ defaultTaxRate: 0 }),
+        { ...BOOKING_ORDER, metadata, tax_breakdown: null },
+        BOOKING_ITEMS,
+        { orderId: 'order-bk' }
+      )
+      expect([metadata, run.status]).toEqual([metadata, 200])
+      expect([metadata, run.invoice.customerVat, run.invoice.customerCity]).toEqual([
+        metadata,
+        '',
+        'Shipped-to city',
+      ])
+    }
+    const stated = await runHandler(settingsWith({}), BOOKING_ORDER, BOOKING_ITEMS, {
+      orderId: 'order-bk',
+      customerVat: 'EDITED-1',
+    })
+    expect(stated.invoice.customerVat).toBe('EDITED-1')
+  })
+})
+
+describe('invoice PDF renderer — the buyer, never the template’s sample', () => {
+  const settings = settingsWith({})
+  const templated = loadPdfGenerator(settings, {
+    name: 'invoice-template',
+    node: {
+      type: 'element',
+      content: {
+        elementType: 'context',
+        attrs: {
+          Customer: {
+            type: 'static',
+            content: { name: 'Jane Smith', city: 'San Francisco', state: 'CA', vat: 'US1' },
+          },
+          Payment: { type: 'static', content: { method: 'Card', intentId: 'pi_sample' } },
+        },
+        children: [],
+      },
+    },
+  })
+
+  it('leaves out what the buyer did not give, and flags the lines that show', () => {
+    const { invoiceData } = templated.buildInvoiceDataScope({
+      customerName: 'Acme SRL',
+      customerVat: 'RO12345678',
+      currency: 'EUR',
+      items: [],
+    })
+    expect(invoiceData.Customer).toMatchObject({
+      name: 'Acme SRL',
+      city: '',
+      state: '',
+      vat: 'RO12345678',
+      hasVat: 'true',
+      hasZip: 'false',
+      hasCountry: 'false',
+    })
+    expect(invoiceData.Payment.intentId).toBe('')
+  })
+})

package/__tests__/middleware-admin-panel-roles.test.ts

@@ -0,0 +1,127 @@
+import { UIDLAuthentication } from '@teleporthq/teleport-types'
+import { generateMiddlewareFile } from '../src/auth-generator'
+import {
+  compileGeneratedMiddleware,
+  extractProtectedRoutes,
+} from './_helpers/run-generated-middleware'
+
+/**
+ * An admin panel whose folder admits admins only, some of whose pages (the
+ * dashboard first among them) also admit staff, whose built-in entities stay
+ * admin only, and whose project redirects the home page into the dashboard
+ * (`homeRedirect`). Two things must follow from the ADMIN FOLDER's protection,
+ * never from whichever page happens to come first:
+ *  - the `/admin` catch-all, which guards `/admin` itself and every admin page
+ *    the middleware has no entry for (one an owner added without protection);
+ *  - where a role denial lands: never `/` when `/` leads straight back into a
+ *    page the visitor may not open — that is a redirect loop.
+ */
+
+const page = (route: string, allowedRoles: string[]) => ({
+  requiresAuth: true,
+  allowedRoles,
+  pageName: route,
+  route,
+})
+
+const panelAuth = (homeRedirect?: string): UIDLAuthentication => ({
+  enabled: true,
+  dataSourceId: 'ds-1',
+  dataSourceType: 'teleport',
+  passwordAuthEnabled: true,
+  providers: [],
+  roles: ['admin', 'staff', 'user'],
+  tables: {},
+  // The dashboard is the first admin route, as the GUI emits it.
+  pageProtection: {
+    'p-dashboard': page('/admin/dashboard', ['admin', 'staff']),
+    'p-tasks': page('/admin/tasks', ['admin', 'staff']),
+    'p-users': page('/admin/users', ['admin']),
+  },
+  folderProtection: {
+    'f-admin': {
+      requiresAuth: true,
+      allowedRoles: ['admin'],
+      folderName: 'admin-panel',
+      parentId: 'pages',
+      children: { 'p-dashboard': 'page', 'f-tasks': 'folder', 'f-users': 'folder' },
+    },
+    'f-tasks': {
+      requiresAuth: true,
+      allowedRoles: ['admin', 'staff'],
+      folderName: 'tasks',
+      parentId: 'f-admin',
+      children: { 'p-tasks': 'page' },
+    },
+    'f-users': {
+      requiresAuth: true,
+      allowedRoles: ['admin'],
+      folderName: 'users',
+      parentId: 'f-admin',
+      children: { 'p-users': 'page' },
+    },
+  },
+  authPages: {
+    signIn: { pageId: 'p-sign-in', pageName: 'sign-in', route: '/auth/sign-in' },
+  },
+  callbackBaseUrl: '/api/auth/callback',
+  envKeys: {},
+  customUserProperties: [],
+  ...(homeRedirect ? { homeRedirect } : {}),
+})
+
+const ORIGIN = 'https://panel.test'
+
+describe('the /admin catch-all', () => {
+  it("admits the admin folder's roles, not the first admin page's", () => {
+    const routes = extractProtectedRoutes(generateMiddlewareFile(panelAuth('/admin/dashboard')))
+    expect(routes['/admin']).toEqual({ requiresAuth: true, allowedRoles: ['admin'] })
+  })
+
+  it('keeps staff out of an admin page the middleware has no entry for', async () => {
+    const run = compileGeneratedMiddleware(panelAuth('/admin/dashboard'))
+    const staff = { id: 's1', role: 'staff' }
+    expect(await run('/admin/reports', { sessionUser: staff, origin: ORIGIN })).toMatchObject({
+      kind: 'redirect',
+    })
+    expect(await run('/admin/tasks', { sessionUser: staff, origin: ORIGIN })).toEqual({
+      kind: 'next',
+    })
+    expect(
+      await run('/admin/reports', { sessionUser: { id: 'a1', role: 'admin' }, origin: ORIGIN })
+    ).toEqual({ kind: 'next' })
+  })
+})
+
+describe('a role denial when the home page redirects into the admin panel', () => {
+  const run = compileGeneratedMiddleware(panelAuth('/admin/dashboard'))
+  const signInLocation = (callbackUrl: string) =>
+    `${ORIGIN}/auth/sign-in?callbackUrl=${encodeURIComponent(callbackUrl)}&error=forbidden`
+
+  it('sends a signed-in account the panel does not admit to sign-in, explained — never to "/"', async () => {
+    const user = { id: 'u1', role: 'user' }
+    // "/" would redirect to the dashboard, which denies the role again: a loop.
+    expect(await run('/admin/dashboard', { sessionUser: user, origin: ORIGIN })).toEqual({
+      kind: 'redirect',
+      location: signInLocation('/admin/dashboard'),
+    })
+    expect(await run('/admin/users', { sessionUser: user, origin: ORIGIN })).toEqual({
+      kind: 'redirect',
+      location: signInLocation('/admin/users'),
+    })
+  })
+
+  it('still sends staff denied an admin-only page home, where the dashboard admits them', async () => {
+    expect(
+      await run('/admin/users', { sessionUser: { id: 's1', role: 'staff' }, origin: ORIGIN })
+    ).toEqual({ kind: 'redirect', location: `${ORIGIN}/` })
+  })
+
+  it('leaves a project whose home is not redirected as it was', () => {
+    const code = generateMiddlewareFile(panelAuth())
+    expect(code).toContain('function roleDeniedRedirect(request, pathname) {')
+    expect(code).toContain('return roleDeniedRedirect(request, pathname);')
+    expect(code).not.toContain('homeRedirect')
+    expect(code).not.toContain("'forbidden'")
+  })
+})

package/__tests__/page-arrival-remount.test.ts

@@ -0,0 +1,247 @@
+// A page keeps its instance when a navigation lands on the page already on
+// screen (a link to the current URL, another record of the same dynamic route,
+// another query string), so a trigger that fires when the page appears —
+// page-loaded, element-visible, component-loaded — ran only on the first
+// arrival. Such pages are wrapped in `remountOnPageArrival`, which starts them
+// fresh on every arrival; pages whose workflows only answer interactions keep
+// their plain export.
+
+import generator from '@babel/generator'
+import * as types from '@babel/types'
+import { createNextWorkflowPlugin } from '../src/workflow-component-plugin'
+
+const PAGE_ID = 'page-dashboard'
+const ROOT_ID = 'thq_container_root'
+
+const workflow = (type: string, scope: string, config: Record<string, unknown>) => ({
+  id: `wf-${type}`,
+  name: type,
+  trigger: { type, nodeId: 'trigger-1', scope, config },
+  nodes: [
+    {
+      id: 'update-1',
+      type: 'state-update-local-state',
+      config: { property: 'isLoading', value: false },
+      stepNumber: 1,
+      label: 'Update',
+    },
+  ],
+  edges: [{ id: 'e1', source: 'trigger-1', target: 'update-1' }],
+})
+
+const jsxComponentChunk = (rootId: string) => ({
+  type: 'AST',
+  name: 'jsx-component',
+  content: types.variableDeclaration('const', [
+    types.variableDeclarator(
+      types.identifier('Dashboard'),
+      types.arrowFunctionExpression(
+        [types.identifier('props')],
+        types.blockStatement([
+          types.returnStatement(
+            types.jsxElement(
+              types.jsxOpeningElement(types.jsxIdentifier('div'), [
+                types.jsxAttribute(types.jsxIdentifier('id'), types.stringLiteral(rootId)),
+              ]),
+              types.jsxClosingElement(types.jsxIdentifier('div')),
+              []
+            )
+          ),
+        ])
+      )
+    ),
+  ]),
+})
+
+interface RunOptions {
+  isPage?: boolean
+  rootId?: string
+  pageNode?: unknown
+  projectComponents?: Record<string, unknown>
+}
+
+const run = async (
+  workflows: Array<ReturnType<typeof workflow>>,
+  {
+    isPage = true,
+    rootId = ROOT_ID,
+    pageNode = { type: 'element', content: { elementType: 'container' } },
+    projectComponents,
+  }: RunOptions = {}
+) => {
+  const structure: any = {
+    uidl: {
+      name: 'Dashboard',
+      node: pageNode,
+      stateDefinitions: { isLoading: { type: 'boolean', defaultValue: true } },
+      outputOptions: { pageId: PAGE_ID, folderPath: [] },
+    },
+    chunks: [
+      jsxComponentChunk(rootId),
+      {
+        type: 'AST',
+        name: 'export',
+        content: types.exportDefaultDeclaration(types.identifier('Dashboard')),
+      },
+    ],
+    options: {
+      workflows: {
+        workflows: workflows.reduce(
+          (byId: Record<string, unknown>, wf) => ({ ...byId, [wf.id]: wf }),
+          {}
+        ),
+        customNodes: {},
+      },
+      pagesPath: ['pages'],
+      extractedResources: {},
+      projectComponents,
+    },
+    dependencies: {},
+  }
+  await createNextWorkflowPlugin({ isPage })(structure)
+  const exportChunk = structure.chunks.find((chunk: any) => chunk.name === 'export')
+  const moduleChunk = structure.chunks.find((chunk: any) => chunk.name === 'workflow-module')
+  return {
+    exportCode: generator(exportChunk.content).code,
+    moduleCode: moduleChunk ? String(moduleChunk.content) : '',
+    dependencies: structure.dependencies,
+    extractedResources: structure.options.extractedResources,
+  }
+}
+
+const BANNER_ID = 'thq_container_banner'
+
+/** An instance of a project component, as local dependencies are resolved for pages. */
+const componentInstance = (name: string) => ({
+  type: 'element',
+  content: { elementType: 'component', semanticType: name, dependency: { type: 'local' } },
+})
+
+const pageRendering = (componentName: string) => ({
+  type: 'element',
+  content: { elementType: 'container', children: [componentInstance(componentName)] },
+})
+
+const bannerComponent = () => ({
+  name: 'Banner',
+  node: {
+    type: 'element',
+    content: { elementType: 'container', attrs: { id: { type: 'static', content: BANNER_ID } } },
+  },
+})
+
+const WRAPPED_EXPORT = 'export default remountOnPageArrival(Dashboard);'
+const PLAIN_EXPORT = 'export default Dashboard;'
+
+describe('workflow plugin — remount on page arrival', () => {
+  it('wraps a page whose workflow runs when the page loads', async () => {
+    const result = await run([workflow('event-page-loaded', 'page', { pageId: PAGE_ID })])
+
+    expect(result.exportCode).toBe(WRAPPED_EXPORT)
+    expect(result.dependencies.remountOnPageArrival).toEqual({
+      type: 'local',
+      path: '../utils/page-arrival',
+    })
+    expect(result.extractedResources['utils/page-arrival']).toBeDefined()
+  })
+
+  it('wraps a page whose workflow runs when its root element becomes visible', async () => {
+    const result = await run([
+      workflow('event-element-visible', 'element', { elementHtmlId: ROOT_ID, once: true }),
+    ])
+
+    expect(result.exportCode).toBe(WRAPPED_EXPORT)
+  })
+
+  it('leaves the page alone when the visible element is rendered elsewhere', async () => {
+    const result = await run(
+      [workflow('event-element-visible', 'element', { elementHtmlId: ROOT_ID, once: true })],
+      { rootId: 'thq_container_other' }
+    )
+
+    expect(result.exportCode).toBe(PLAIN_EXPORT)
+    expect(result.dependencies.remountOnPageArrival).toBeUndefined()
+    expect(result.extractedResources).toEqual({})
+  })
+
+  it('leaves the page alone when its workflows only answer interactions', async () => {
+    const result = await run([
+      workflow('event-element-clicked', 'element', { elementHtmlId: ROOT_ID }),
+      workflow('event-interval', 'page', { pageId: PAGE_ID, intervalMs: 1000 }),
+    ])
+
+    expect(result.moduleCode).not.toBe('')
+    expect(result.exportCode).toBe(PLAIN_EXPORT)
+  })
+
+  it('never wraps a component', async () => {
+    const result = await run(
+      [workflow('event-component-loaded', 'component', { componentName: 'Dashboard' })],
+      { isPage: false }
+    )
+
+    expect(result.moduleCode).toContain('Component loaded')
+    expect(result.exportCode).toBe(PLAIN_EXPORT)
+  })
+
+  it('wraps a page that renders a component running a workflow when its element is visible', async () => {
+    const result = await run(
+      [workflow('event-element-visible', 'element', { elementHtmlId: BANNER_ID, once: true })],
+      { pageNode: pageRendering('Banner'), projectComponents: { Banner: bannerComponent() } }
+    )
+
+    expect(result.moduleCode).toBe('')
+    expect(result.exportCode).toBe(WRAPPED_EXPORT)
+  })
+
+  it('finds the component through the components it is nested in', async () => {
+    const result = await run(
+      [workflow('event-element-visible', 'element', { elementHtmlId: BANNER_ID, once: true })],
+      {
+        pageNode: pageRendering('Layout'),
+        projectComponents: {
+          Layout: { name: 'Layout', node: componentInstance('Banner') },
+          Banner: bannerComponent(),
+        },
+      }
+    )
+
+    expect(result.exportCode).toBe(WRAPPED_EXPORT)
+  })
+
+  it('wraps a page that renders a component running a workflow when it loads', async () => {
+    const result = await run(
+      [workflow('event-component-loaded', 'component', { componentName: 'Banner' })],
+      { pageNode: pageRendering('Banner'), projectComponents: { Banner: bannerComponent() } }
+    )
+
+    expect(result.exportCode).toBe(WRAPPED_EXPORT)
+  })
+
+  it('leaves the page alone when no rendered component observes the element', async () => {
+    const result = await run(
+      [
+        workflow('event-element-visible', 'element', {
+          elementHtmlId: 'thq_elsewhere',
+          once: true,
+        }),
+      ],
+      { pageNode: pageRendering('Banner'), projectComponents: { Banner: bannerComponent() } }
+    )
+
+    expect(result.exportCode).toBe(PLAIN_EXPORT)
+  })
+
+  it('cancels a delayed page-loaded run together with the other triggers', async () => {
+    const result = await run([
+      workflow('event-page-loaded', 'page', { pageId: PAGE_ID, delay: 500 }),
+    ])
+
+    expect(result.moduleCode).toContain(
+      'const __delay_wf_event_page_loaded = setTimeout(function() { __execWf(__wfConfig_wf_event_page_loaded'
+    )
+    expect(result.moduleCode).toContain(
+      'cleanups.push(function() { clearTimeout(__delay_wf_event_page_loaded); });'
+    )
+  })
+})

package/__tests__/payment-driver-stripe.test.ts

@@ -265,3 +265,26 @@ describe('Stripe driver — settling a checkout from Stripe', () => {
     expect(calls).toEqual([])
   })
 })
+
+describe('Stripe driver — checkout lifetime', () => {
+  it("opens every Checkout page for an hour, not Stripe's default day", async () => {
+    const { stripe, calls } = load()
+    const before = Math.floor(Date.now() / 1000)
+    await withEnv(KEY, async () => {
+      await stripe.createCheckout({ amount: 10, currency: 'usd', description: 'Order' })
+      await stripe.createSubscriptionCheckout({
+        amount: 10,
+        currency: 'usd',
+        recurringInterval: 'month',
+        description: 'Club',
+      })
+    })
+    const after = Math.floor(Date.now() / 1000)
+    const sessions = calls.filter((call: any) => call.method === 'checkout.sessions.create')
+    expect(sessions).toHaveLength(2)
+    for (const session of sessions as any[]) {
+      expect(session.params.expires_at).toBeGreaterThanOrEqual(before + 3600)
+      expect(session.params.expires_at).toBeLessThanOrEqual(after + 3600)
+    }
+  })
+})