tapimo 0.0.2 → 0.2.0

package/src/internal/Webhooks.test.ts

@@ -1,4 +1,5 @@
-import { Store, Webhooks } from 'cadent'
+import { Webhooks } from 'tapimo'
+import * as TestApp from '../../test/App.js'
 
 const apiKeyOwner = { orgId: 'org_1', type: 'api_key' } as const
 const mppOwner = { payer: 'did:pkh:eip155:1:0xabc', type: 'mpp' } as const
@@ -26,8 +27,8 @@ function createInput(overrides: Partial<Webhooks.CreateInput> = {}): Webhooks.Cr
 
 describe('createSubscription', () => {
   test('persists a subscription with generated id and secret', async () => {
-    const store = Store.memory()
-    const subscription = await Webhooks.createSubscription(store, createInput(), { now: fixedNow })
+    const db = TestApp.database()
+    const subscription = await Webhooks.createSubscription(db, createInput(), { now: fixedNow })
 
     expect(redact(subscription)).toMatchInlineSnapshot(`
       {
@@ -51,14 +52,14 @@ describe('createSubscription', () => {
       }
     `)
 
-    const read = await Webhooks.getSubscription(store, apiKeyOwner, subscription.id)
+    const read = await Webhooks.getSubscription(db, apiKeyOwner, subscription.id)
     expect(read).toEqual(subscription)
   })
 
   test('sets expiresAt from ttl for MPP-owned subscriptions', async () => {
-    const store = Store.memory()
+    const db = TestApp.database()
     const subscription = await Webhooks.createSubscription(
-      store,
+      db,
       createInput({ owner: mppOwner, ttl: 60_000 }),
       { now: fixedNow },
     )
@@ -67,77 +68,75 @@ describe('createSubscription', () => {
   })
 
   test('enforces a per-owner cap', async () => {
-    const store = Store.memory()
-    await Webhooks.createSubscription(store, createInput(), { maxPerOwner: 1 })
+    const db = TestApp.database()
+    await Webhooks.createSubscription(db, createInput(), { maxPerOwner: 1 })
 
     await expect(
-      Webhooks.createSubscription(store, createInput(), { maxPerOwner: 1 }),
+      Webhooks.createSubscription(db, createInput(), { maxPerOwner: 1 }),
     ).rejects.toThrowErrorMatchingInlineSnapshot(
       `[Webhooks.LimitExceededError: Webhook subscription limit reached (1).]`,
     )
   })
 
   test('rejects an undeliverable URL before persisting', async () => {
-    const store = Store.memory()
+    const db = TestApp.database()
     await expect(
       Webhooks.createSubscription(
-        store,
+        db,
         createInput({ destination: { type: 'url', url: 'http://localhost/x' } }),
       ),
     ).rejects.toThrowErrorMatchingInlineSnapshot(
       `[Webhooks.InvalidUrlError: Webhook URL rejected (protocol): http://localhost/x]`,
     )
 
-    expect(await Webhooks.listSubscriptions(store, apiKeyOwner)).toMatchInlineSnapshot(`[]`)
+    expect(await Webhooks.listSubscriptions(db, apiKeyOwner)).toMatchInlineSnapshot(`[]`)
   })
 })
 
 describe('owner isolation', () => {
   test('an owner cannot read or list another owner subscriptions', async () => {
-    const store = Store.memory()
-    const mine = await Webhooks.createSubscription(store, createInput({ owner: apiKeyOwner }))
-    await Webhooks.createSubscription(store, createInput({ owner: mppOwner }))
+    const db = TestApp.database()
+    const mine = await Webhooks.createSubscription(db, createInput({ owner: apiKeyOwner }))
+    await Webhooks.createSubscription(db, createInput({ owner: mppOwner }))
 
-    expect(await Webhooks.getSubscription(store, mppOwner, mine.id)).toMatchInlineSnapshot(`null`)
+    expect(await Webhooks.getSubscription(db, mppOwner, mine.id)).toMatchInlineSnapshot(`null`)
 
-    const apiKeyList = await Webhooks.listSubscriptions(store, apiKeyOwner)
+    const apiKeyList = await Webhooks.listSubscriptions(db, apiKeyOwner)
     expect(apiKeyList.map((s) => s.id)).toEqual([mine.id])
 
-    const mppList = await Webhooks.listSubscriptions(store, mppOwner)
+    const mppList = await Webhooks.listSubscriptions(db, mppOwner)
     expect(mppList).toHaveLength(1)
     expect(mppList[0]?.id).not.toBe(mine.id)
   })
 
   test('an owner cannot delete another owner subscription', async () => {
-    const store = Store.memory()
-    const mine = await Webhooks.createSubscription(store, createInput({ owner: apiKeyOwner }))
+    const db = TestApp.database()
+    const mine = await Webhooks.createSubscription(db, createInput({ owner: apiKeyOwner }))
 
-    expect(await Webhooks.deleteSubscription(store, mppOwner, mine.id)).toMatchInlineSnapshot(
-      `false`,
-    )
-    expect(await Webhooks.getSubscription(store, apiKeyOwner, mine.id)).not.toBeNull()
+    expect(await Webhooks.deleteSubscription(db, mppOwner, mine.id)).toMatchInlineSnapshot(`false`)
+    expect(await Webhooks.getSubscription(db, apiKeyOwner, mine.id)).not.toBeNull()
   })
 })
 
 describe('listSubscriptions', () => {
   test('lists subscriptions newest-first with keyset paging', async () => {
-    const store = Store.memory()
+    const db = TestApp.database()
     const created = []
     for (const minute of [0, 1, 2]) {
       const now = () => new Date(`2026-01-01T00:0${minute}:00.000Z`)
-      created.push(await Webhooks.createSubscription(store, createInput(), { now }))
+      created.push(await Webhooks.createSubscription(db, createInput(), { now }))
     }
     const [first, second, third] = created
 
     // Newest first: most recently created subscription leads.
-    const all = await Webhooks.listSubscriptions(store, apiKeyOwner)
+    const all = await Webhooks.listSubscriptions(db, apiKeyOwner)
     expect(all.map((s) => s.id)).toEqual([third!.id, second!.id, first!.id])
 
     // First page of two, then resume after the last id for the older remainder.
-    const page = await Webhooks.listSubscriptions(store, apiKeyOwner, { limit: 2 })
+    const page = await Webhooks.listSubscriptions(db, apiKeyOwner, { limit: 2 })
     expect(page.map((s) => s.id)).toEqual([third!.id, second!.id])
 
-    const next = await Webhooks.listSubscriptions(store, apiKeyOwner, {
+    const next = await Webhooks.listSubscriptions(db, apiKeyOwner, {
       cursor: page.at(-1)?.id,
       limit: 2,
     })
@@ -147,16 +146,16 @@ describe('listSubscriptions', () => {
 
 describe('updateSubscription', () => {
   test('patches fields and bumps updatedAt', async () => {
-    const store = Store.memory()
-    const created = await Webhooks.createSubscription(store, createInput(), { now: fixedNow })
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput(), { now: fixedNow })
 
     const updated = await Webhooks.updateSubscription(
-      store,
+      db,
       apiKeyOwner,
       created.id,
       {
         destination: { type: 'url', url: 'https://hooks.example.com/v2' },
-        filters: { token: '0xtoken' },
+        filters: { token: `0x${'aa'.repeat(20)}` },
       },
       { now: () => new Date('2026-01-02T00:00:00.000Z') },
     )
@@ -172,7 +171,7 @@ describe('updateSubscription', () => {
         "eventType": "token:transfer",
         "failureCount": 0,
         "filters": {
-          "token": "0xtoken",
+          "token": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
         },
         "id": "<id>",
         "owner": {
@@ -187,18 +186,18 @@ describe('updateSubscription', () => {
   })
 
   test('returns null for a missing subscription', async () => {
-    const store = Store.memory()
+    const db = TestApp.database()
     expect(
-      await Webhooks.updateSubscription(store, apiKeyOwner, 'wh_missing', { status: 'paused' }),
+      await Webhooks.updateSubscription(db, apiKeyOwner, 'wh_missing', { status: 'paused' }),
     ).toMatchInlineSnapshot(`null`)
   })
 
   test('rejects a patched URL that fails validation', async () => {
-    const store = Store.memory()
-    const created = await Webhooks.createSubscription(store, createInput())
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput())
 
     await expect(
-      Webhooks.updateSubscription(store, apiKeyOwner, created.id, {
+      Webhooks.updateSubscription(db, apiKeyOwner, created.id, {
         destination: { type: 'url', url: 'http://10.0.0.1' },
       }),
     ).rejects.toThrowErrorMatchingInlineSnapshot(
@@ -209,46 +208,49 @@ describe('updateSubscription', () => {
 
 describe('listActive', () => {
   test('returns only active subscriptions for a stream', async () => {
-    const store = Store.memory()
-    const a = await Webhooks.createSubscription(store, createInput())
-    const b = await Webhooks.createSubscription(store, createInput({ owner: mppOwner }))
-    await Webhooks.createSubscription(store, createInput({ eventType: 'transaction:included' }))
+    const db = TestApp.database()
+    const a = await Webhooks.createSubscription(db, createInput())
+    const b = await Webhooks.createSubscription(db, createInput({ owner: mppOwner }))
+    await Webhooks.createSubscription(db, createInput({ eventType: 'transaction:included' }))
 
-    let active = await Webhooks.listActive(store, 4217, 'token:transfer')
+    let active = await Webhooks.listActive(db, 4217, 'token:transfer')
     expect(active.map((s) => s.id).sort()).toEqual([a.id, b.id].sort())
 
-    await Webhooks.updateSubscription(store, apiKeyOwner, a.id, { status: 'paused' })
-    active = await Webhooks.listActive(store, 4217, 'token:transfer')
+    await Webhooks.updateSubscription(db, apiKeyOwner, a.id, { status: 'paused' })
+    active = await Webhooks.listActive(db, 4217, 'token:transfer')
     expect(active.map((s) => s.id)).toEqual([b.id])
   })
 
   test('drops a deleted subscription from the index', async () => {
-    const store = Store.memory()
-    const a = await Webhooks.createSubscription(store, createInput())
+    const db = TestApp.database()
+    const a = await Webhooks.createSubscription(db, createInput())
 
-    await Webhooks.deleteSubscription(store, apiKeyOwner, a.id)
-    expect(await Webhooks.listActive(store, 4217, 'token:transfer')).toMatchInlineSnapshot(`[]`)
+    await Webhooks.deleteSubscription(db, apiKeyOwner, a.id)
+    expect(await Webhooks.listActive(db, 4217, 'token:transfer')).toMatchInlineSnapshot(`[]`)
   })
 })
 
 describe('cursors', () => {
   test('round-trips a per-subscription cursor', async () => {
-    const store = Store.memory()
-    expect(await Webhooks.getCursor(store, 'wh_1')).toMatchInlineSnapshot(`null`)
+    const db = TestApp.database()
+    // The cursor is a column on the subscription row, so it needs a real
+    // subscription (the old key space allowed orphan cursors).
+    const created = await Webhooks.createSubscription(db, createInput())
+    expect(await Webhooks.getCursor(db, created.id)).toMatchInlineSnapshot(`null`)
 
-    await Webhooks.setCursor(store, 'wh_1', '12345:7')
-    expect(await Webhooks.getCursor(store, 'wh_1')).toMatchInlineSnapshot(`"12345:7"`)
+    await Webhooks.setCursor(db, created.id, '12345:7')
+    expect(await Webhooks.getCursor(db, created.id)).toMatchInlineSnapshot(`"12345:7"`)
   })
 })
 
 describe('recordSuccess / recordFailure', () => {
   test('recordSuccess resets failures and stamps lastDeliveryAt', async () => {
-    const store = Store.memory()
-    const created = await Webhooks.createSubscription(store, createInput())
-    const failed = await Webhooks.recordFailure(store, created, { now: fixedNow })
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput())
+    const failed = await Webhooks.recordFailure(db, created, { now: fixedNow })
     expect(failed.failureCount).toMatchInlineSnapshot(`1`)
 
-    const ok = await Webhooks.recordSuccess(store, failed, { now: fixedNow })
+    const ok = await Webhooks.recordSuccess(db, failed, { now: fixedNow })
     expect({ failureCount: ok.failureCount, lastDeliveryAt: ok.lastDeliveryAt })
       .toMatchInlineSnapshot(`
       {
@@ -258,24 +260,24 @@ describe('recordSuccess / recordFailure', () => {
     `)
 
     // Persisted, not just returned.
-    const read = await Webhooks.getSubscription(store, apiKeyOwner, created.id)
+    const read = await Webhooks.getSubscription(db, apiKeyOwner, created.id)
     expect(read?.lastDeliveryAt).toBe('2026-01-01T00:00:00.000Z')
   })
 
   test('recordFailure auto-disables at the threshold and drops from the active index', async () => {
-    const store = Store.memory()
-    let subscription = await Webhooks.createSubscription(store, createInput())
+    const db = TestApp.database()
+    let subscription = await Webhooks.createSubscription(db, createInput())
 
     // Below the threshold: stays active.
-    subscription = await Webhooks.recordFailure(store, subscription, { maxFailures: 3 })
-    subscription = await Webhooks.recordFailure(store, subscription, { maxFailures: 3 })
+    subscription = await Webhooks.recordFailure(db, subscription, { maxFailures: 3 })
+    subscription = await Webhooks.recordFailure(db, subscription, { maxFailures: 3 })
     expect(subscription.status).toMatchInlineSnapshot(`"active"`)
-    expect((await Webhooks.listActive(store, 4217, 'token:transfer')).map((s) => s.id)).toEqual([
+    expect((await Webhooks.listActive(db, 4217, 'token:transfer')).map((s) => s.id)).toEqual([
       subscription.id,
     ])
 
     // Hitting the threshold disables it and removes it from the poller's index.
-    subscription = await Webhooks.recordFailure(store, subscription, { maxFailures: 3 })
+    subscription = await Webhooks.recordFailure(db, subscription, { maxFailures: 3 })
     expect({ failureCount: subscription.failureCount, status: subscription.status })
       .toMatchInlineSnapshot(`
       {
@@ -283,7 +285,7 @@ describe('recordSuccess / recordFailure', () => {
         "status": "disabled",
       }
     `)
-    expect(await Webhooks.listActive(store, 4217, 'token:transfer')).toMatchInlineSnapshot(`[]`)
+    expect(await Webhooks.listActive(db, 4217, 'token:transfer')).toMatchInlineSnapshot(`[]`)
   })
 })
 
@@ -372,13 +374,13 @@ describe('eventId / buildEnvelope', () => {
   })
 
   test('buildEnvelope embeds the data row and a stable id', async () => {
-    const store = Store.memory()
-    const subscription = await Webhooks.createSubscription(store, createInput())
+    const db = TestApp.database()
+    const subscription = await Webhooks.createSubscription(db, createInput())
 
     const envelope = Webhooks.buildEnvelope({
       blockNumber: 100,
       createdAt: new Date('2026-01-01T00:00:00.000Z'),
-      data: { amount: '1', to: '0x1' },
+      data: { amount: '1', to: `0x${'aa'.repeat(20)}` },
       logIndex: 3,
       subscription,
     })
@@ -390,7 +392,7 @@ describe('eventId / buildEnvelope', () => {
         "createdAt": "2026-01-01T00:00:00.000Z",
         "data": {
           "amount": "1",
-          "to": "0x1",
+          "to": "0xaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa",
         },
         "id": "evt_d7c75afd0abccdc90a391d9313762a957c7e4383cac1fae76e5de56e49c9d3f8",
         "subscriptionId": "<subscriptionId>",
@@ -436,12 +438,12 @@ describe('delivery log', () => {
   }
 
   test('lists rows newest-first with keyset paging', async () => {
-    const store = Store.memory()
-    const created = await Webhooks.createSubscription(store, createInput())
-    for (const n of [1, 2, 3]) await Webhooks.recordDelivery(store, row(created.id, n))
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput())
+    for (const n of [1, 2, 3]) await Webhooks.recordDelivery(db, row(created.id, n))
 
     // Newest first.
-    const all = await Webhooks.listDeliveries(store, created.id)
+    const all = await Webhooks.listDeliveries(db, created.id)
     expect(all.map((d) => d.eventId)).toMatchInlineSnapshot(`
       [
         "evt_3",
@@ -451,10 +453,10 @@ describe('delivery log', () => {
     `)
 
     // First page of two, then resume after the last id for the older remainder.
-    const page = await Webhooks.listDeliveries(store, created.id, { limit: 2 })
+    const page = await Webhooks.listDeliveries(db, created.id, { limit: 2 })
     expect(page.map((d) => d.eventId)).toEqual(['evt_3', 'evt_2'])
 
-    const next = await Webhooks.listDeliveries(store, created.id, {
+    const next = await Webhooks.listDeliveries(db, created.id, {
       cursor: page.at(-1)?.id,
       limit: 2,
     })
@@ -462,8 +464,8 @@ describe('delivery log', () => {
   })
 
   test('deliverAndRecord appends a succeeded row', async () => {
-    const store = Store.memory()
-    const created = await Webhooks.createSubscription(store, createInput())
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput())
     const envelope = {
       chainId: 4217,
       createdAt: '2026-01-01T00:00:00.000Z',
@@ -475,9 +477,9 @@ describe('delivery log', () => {
 
     const fetch = (async () =>
       new Response(null, { status: 200 })) satisfies typeof globalThis.fetch
-    await Webhooks.deliverAndRecord(store, created, envelope, { fetch, now: fixedNow })
+    await Webhooks.deliverAndRecord(db, created, envelope, { fetch, now: fixedNow })
 
-    const [delivery] = await Webhooks.listDeliveries(store, created.id)
+    const [delivery] = await Webhooks.listDeliveries(db, created.id)
     expect(redactDelivery(delivery!)).toMatchInlineSnapshot(`
       {
         "attempt": 1,
@@ -504,8 +506,8 @@ describe('delivery log', () => {
   })
 
   test('deliverAndRecord appends a failed row with the error and status', async () => {
-    const store = Store.memory()
-    const created = await Webhooks.createSubscription(store, createInput())
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput())
     const envelope = {
       chainId: 4217,
       createdAt: '2026-01-01T00:00:00.000Z',
@@ -517,9 +519,9 @@ describe('delivery log', () => {
 
     const fetch = (async () =>
       new Response(null, { status: 500 })) satisfies typeof globalThis.fetch
-    await Webhooks.deliverAndRecord(store, created, envelope, { fetch, now: fixedNow })
+    await Webhooks.deliverAndRecord(db, created, envelope, { fetch, now: fixedNow })
 
-    const [delivery] = await Webhooks.listDeliveries(store, created.id)
+    const [delivery] = await Webhooks.listDeliveries(db, created.id)
     expect(redactDelivery(delivery!)).toMatchInlineSnapshot(`
       {
         "attempt": 1,
@@ -547,36 +549,34 @@ describe('delivery log', () => {
   })
 
   test('deleteSubscription removes the delivery log', async () => {
-    const store = Store.memory()
-    const created = await Webhooks.createSubscription(store, createInput())
-    for (const n of [1, 2]) await Webhooks.recordDelivery(store, row(created.id, n))
-    expect(await Webhooks.listDeliveries(store, created.id)).toHaveLength(2)
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput())
+    for (const n of [1, 2]) await Webhooks.recordDelivery(db, row(created.id, n))
+    expect(await Webhooks.listDeliveries(db, created.id)).toHaveLength(2)
 
-    await Webhooks.deleteSubscription(store, apiKeyOwner, created.id)
-    expect(await Webhooks.listDeliveries(store, created.id)).toMatchInlineSnapshot(`[]`)
+    await Webhooks.deleteSubscription(db, apiKeyOwner, created.id)
+    expect(await Webhooks.listDeliveries(db, created.id)).toMatchInlineSnapshot(`[]`)
   })
 
   test('getDelivery loads one row by id and returns null when absent', async () => {
-    const store = Store.memory()
-    const created = await Webhooks.createSubscription(store, createInput())
-    await Webhooks.recordDelivery(store, row(created.id, 1))
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput())
+    await Webhooks.recordDelivery(db, row(created.id, 1))
     const id = row(created.id, 1).id
 
-    const found = await Webhooks.getDelivery(store, created.id, id)
+    const found = await Webhooks.getDelivery(db, created.id, id)
     expect(found?.eventId).toMatchInlineSnapshot(`"evt_1"`)
     // The persisted row carries the full envelope for replay.
     expect(found?.envelope.id).toMatchInlineSnapshot(`"evt_1"`)
 
-    expect(await Webhooks.getDelivery(store, created.id, 'whd_missing')).toMatchInlineSnapshot(
-      `null`,
-    )
+    expect(await Webhooks.getDelivery(db, created.id, 'whd_missing')).toMatchInlineSnapshot(`null`)
   })
 })
 
 describe('buildPingEnvelope', () => {
   test('builds a synthetic ping envelope with a deterministic id from the nonce', async () => {
-    const store = Store.memory()
-    const created = await Webhooks.createSubscription(store, createInput())
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput())
     const envelope = Webhooks.buildPingEnvelope(created, {
       createdAt: fixedNow(),
       nonce: 'test-nonce',
@@ -598,8 +598,8 @@ describe('buildPingEnvelope', () => {
   })
 
   test('randomizes the id per call so repeated pings are not deduped', async () => {
-    const store = Store.memory()
-    const created = await Webhooks.createSubscription(store, createInput())
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput())
     const a = Webhooks.buildPingEnvelope(created)
     const b = Webhooks.buildPingEnvelope(created)
     expect(a.id).not.toBe(b.id)
@@ -608,8 +608,8 @@ describe('buildPingEnvelope', () => {
 
 describe('ping', () => {
   test('delivers, records a log row, and leaves the subscription state untouched', async () => {
-    const store = Store.memory()
-    const created = await Webhooks.createSubscription(store, createInput())
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput())
 
     const captured: { body: string; signature: string | null } = { body: '', signature: null }
     const fetch = (async (_url, init) => {
@@ -618,7 +618,7 @@ describe('ping', () => {
       return new Response(null, { status: 200 })
     }) satisfies typeof globalThis.fetch
 
-    const { envelope, result } = await Webhooks.ping(store, created, {
+    const { envelope, result } = await Webhooks.ping(db, created, {
       fetch,
       nonce: 'test-nonce',
       now: fixedNow,
@@ -637,31 +637,31 @@ describe('ping', () => {
     ).toBe(true)
 
     // A ping is observable in the delivery log.
-    const [delivery] = await Webhooks.listDeliveries(store, created.id)
+    const [delivery] = await Webhooks.listDeliveries(db, created.id)
     expect(delivery?.eventId).toBe(envelope.id)
     expect(delivery?.status).toMatchInlineSnapshot(`"succeeded"`)
 
     // A ping never mutates the subscription's failure/lifecycle state.
-    const after = await Webhooks.getSubscription(store, apiKeyOwner, created.id)
+    const after = await Webhooks.getSubscription(db, apiKeyOwner, created.id)
     expect(after?.failureCount).toMatchInlineSnapshot(`0`)
     expect(after?.status).toMatchInlineSnapshot(`"active"`)
     expect(after?.lastDeliveryAt).toMatchInlineSnapshot(`undefined`)
   })
 
   test('a failed ping records a failed row without disabling the subscription', async () => {
-    const store = Store.memory()
-    const created = await Webhooks.createSubscription(store, createInput())
+    const db = TestApp.database()
+    const created = await Webhooks.createSubscription(db, createInput())
 
     const fetch = (async () =>
       new Response(null, { status: 500 })) satisfies typeof globalThis.fetch
-    const { result } = await Webhooks.ping(store, created, { fetch, now: fixedNow })
+    const { result } = await Webhooks.ping(db, created, { fetch, now: fixedNow })
 
     expect(result.ok).toBe(false)
-    const [delivery] = await Webhooks.listDeliveries(store, created.id)
+    const [delivery] = await Webhooks.listDeliveries(db, created.id)
     expect(delivery?.status).toMatchInlineSnapshot(`"failed"`)
 
     // Crucially, a failed test ping must NOT count toward auto-disable.
-    const after = await Webhooks.getSubscription(store, apiKeyOwner, created.id)
+    const after = await Webhooks.getSubscription(db, apiKeyOwner, created.id)
     expect(after?.failureCount).toMatchInlineSnapshot(`0`)
     expect(after?.status).toMatchInlineSnapshot(`"active"`)
   })