tapimo 0.0.0 → 0.0.2

package/src/internal/Webhooks.test.ts

@@ -0,0 +1,668 @@
+import { Store, Webhooks } from 'cadent'
+
+const apiKeyOwner = { orgId: 'org_1', type: 'api_key' } as const
+const mppOwner = { payer: 'did:pkh:eip155:1:0xabc', type: 'mpp' } as const
+
+/** Fixed clock so created/updated timestamps snapshot deterministically. */
+const fixedNow = () => new Date('2026-01-01T00:00:00.000Z')
+
+/** Asserts the random id/secret shape, then redacts them for a stable snapshot. */
+function redact(subscription: Webhooks.Subscription | null) {
+  expect(subscription).not.toBeNull()
+  expect(subscription?.id).toMatch(/^wh_\d{15}_[A-Za-z0-9_-]{21}$/)
+  expect(subscription?.secret).toMatch(/^whsec_[0-9a-f]{64}$/)
+  return { ...subscription, id: '<id>', secret: '<secret>' }
+}
+
+function createInput(overrides: Partial<Webhooks.CreateInput> = {}): Webhooks.CreateInput {
+  return {
+    chainId: 4217,
+    destination: { type: 'url', url: 'https://hooks.example.com/endpoint' },
+    eventType: 'token:transfer',
+    owner: apiKeyOwner,
+    ...overrides,
+  }
+}
+
+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 })
+
+    expect(redact(subscription)).toMatchInlineSnapshot(`
+      {
+        "chainId": 4217,
+        "createdAt": "2026-01-01T00:00:00.000Z",
+        "destination": {
+          "type": "url",
+          "url": "https://hooks.example.com/endpoint",
+        },
+        "eventType": "token:transfer",
+        "failureCount": 0,
+        "filters": {},
+        "id": "<id>",
+        "owner": {
+          "orgId": "org_1",
+          "type": "api_key",
+        },
+        "secret": "<secret>",
+        "status": "active",
+        "updatedAt": "2026-01-01T00:00:00.000Z",
+      }
+    `)
+
+    const read = await Webhooks.getSubscription(store, apiKeyOwner, subscription.id)
+    expect(read).toEqual(subscription)
+  })
+
+  test('sets expiresAt from ttl for MPP-owned subscriptions', async () => {
+    const store = Store.memory()
+    const subscription = await Webhooks.createSubscription(
+      store,
+      createInput({ owner: mppOwner, ttl: 60_000 }),
+      { now: fixedNow },
+    )
+
+    expect(subscription.expiresAt).toMatchInlineSnapshot(`"2026-01-01T00:01:00.000Z"`)
+  })
+
+  test('enforces a per-owner cap', async () => {
+    const store = Store.memory()
+    await Webhooks.createSubscription(store, createInput(), { maxPerOwner: 1 })
+
+    await expect(
+      Webhooks.createSubscription(store, createInput(), { maxPerOwner: 1 }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Webhooks.LimitExceededError: Webhook subscription limit reached (1).]`,
+    )
+  })
+
+  test('rejects an undeliverable URL before persisting', async () => {
+    const store = Store.memory()
+    await expect(
+      Webhooks.createSubscription(
+        store,
+        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(`[]`)
+  })
+})
+
+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 }))
+
+    expect(await Webhooks.getSubscription(store, mppOwner, mine.id)).toMatchInlineSnapshot(`null`)
+
+    const apiKeyList = await Webhooks.listSubscriptions(store, apiKeyOwner)
+    expect(apiKeyList.map((s) => s.id)).toEqual([mine.id])
+
+    const mppList = await Webhooks.listSubscriptions(store, 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 }))
+
+    expect(await Webhooks.deleteSubscription(store, mppOwner, mine.id)).toMatchInlineSnapshot(
+      `false`,
+    )
+    expect(await Webhooks.getSubscription(store, apiKeyOwner, mine.id)).not.toBeNull()
+  })
+})
+
+describe('listSubscriptions', () => {
+  test('lists subscriptions newest-first with keyset paging', async () => {
+    const store = Store.memory()
+    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 }))
+    }
+    const [first, second, third] = created
+
+    // Newest first: most recently created subscription leads.
+    const all = await Webhooks.listSubscriptions(store, 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 })
+    expect(page.map((s) => s.id)).toEqual([third!.id, second!.id])
+
+    const next = await Webhooks.listSubscriptions(store, apiKeyOwner, {
+      cursor: page.at(-1)?.id,
+      limit: 2,
+    })
+    expect(next.map((s) => s.id)).toEqual([first!.id])
+  })
+})
+
+describe('updateSubscription', () => {
+  test('patches fields and bumps updatedAt', async () => {
+    const store = Store.memory()
+    const created = await Webhooks.createSubscription(store, createInput(), { now: fixedNow })
+
+    const updated = await Webhooks.updateSubscription(
+      store,
+      apiKeyOwner,
+      created.id,
+      {
+        destination: { type: 'url', url: 'https://hooks.example.com/v2' },
+        filters: { token: '0xtoken' },
+      },
+      { now: () => new Date('2026-01-02T00:00:00.000Z') },
+    )
+
+    expect(redact(updated)).toMatchInlineSnapshot(`
+      {
+        "chainId": 4217,
+        "createdAt": "2026-01-01T00:00:00.000Z",
+        "destination": {
+          "type": "url",
+          "url": "https://hooks.example.com/v2",
+        },
+        "eventType": "token:transfer",
+        "failureCount": 0,
+        "filters": {
+          "token": "0xtoken",
+        },
+        "id": "<id>",
+        "owner": {
+          "orgId": "org_1",
+          "type": "api_key",
+        },
+        "secret": "<secret>",
+        "status": "active",
+        "updatedAt": "2026-01-02T00:00:00.000Z",
+      }
+    `)
+  })
+
+  test('returns null for a missing subscription', async () => {
+    const store = Store.memory()
+    expect(
+      await Webhooks.updateSubscription(store, 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())
+
+    await expect(
+      Webhooks.updateSubscription(store, apiKeyOwner, created.id, {
+        destination: { type: 'url', url: 'http://10.0.0.1' },
+      }),
+    ).rejects.toThrowErrorMatchingInlineSnapshot(
+      `[Webhooks.InvalidUrlError: Webhook URL rejected (protocol): http://10.0.0.1]`,
+    )
+  })
+})
+
+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' }))
+
+    let active = await Webhooks.listActive(store, 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')
+    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())
+
+    await Webhooks.deleteSubscription(store, apiKeyOwner, a.id)
+    expect(await Webhooks.listActive(store, 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`)
+
+    await Webhooks.setCursor(store, 'wh_1', '12345:7')
+    expect(await Webhooks.getCursor(store, 'wh_1')).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 })
+    expect(failed.failureCount).toMatchInlineSnapshot(`1`)
+
+    const ok = await Webhooks.recordSuccess(store, failed, { now: fixedNow })
+    expect({ failureCount: ok.failureCount, lastDeliveryAt: ok.lastDeliveryAt })
+      .toMatchInlineSnapshot(`
+      {
+        "failureCount": 0,
+        "lastDeliveryAt": "2026-01-01T00:00:00.000Z",
+      }
+    `)
+
+    // Persisted, not just returned.
+    const read = await Webhooks.getSubscription(store, 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())
+
+    // Below the threshold: stays active.
+    subscription = await Webhooks.recordFailure(store, subscription, { maxFailures: 3 })
+    subscription = await Webhooks.recordFailure(store, subscription, { maxFailures: 3 })
+    expect(subscription.status).toMatchInlineSnapshot(`"active"`)
+    expect((await Webhooks.listActive(store, 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 })
+    expect({ failureCount: subscription.failureCount, status: subscription.status })
+      .toMatchInlineSnapshot(`
+      {
+        "failureCount": 3,
+        "status": "disabled",
+      }
+    `)
+    expect(await Webhooks.listActive(store, 4217, 'token:transfer')).toMatchInlineSnapshot(`[]`)
+  })
+})
+
+describe('sign / verify', () => {
+  test('signs a body deterministically', () => {
+    const signature = Webhooks.sign({
+      body: JSON.stringify({ hello: 'world' }),
+      secret: 'whsec_test',
+      timestamp: 1_000,
+    })
+
+    expect(signature).toMatchInlineSnapshot(
+      `"t=1000,v1=b345b1f6668bbb1b5f1a02cc5a2de10334d1281ba860bbdeadf4681c4719563d"`,
+    )
+  })
+
+  test('verifies a freshly signed body', () => {
+    const secret = 'whsec_test'
+    const body = JSON.stringify({ hello: 'world' })
+    const signature = Webhooks.sign({ body, secret, timestamp: 1_000 })
+
+    expect(Webhooks.verify({ body, now: 1_000, secret, signature })).toMatchInlineSnapshot(`true`)
+  })
+
+  test('rejects a tampered body', () => {
+    const secret = 'whsec_test'
+    const signature = Webhooks.sign({ body: 'original', secret, timestamp: 1_000 })
+
+    expect(
+      Webhooks.verify({ body: 'tampered', now: 1_000, secret, signature }),
+    ).toMatchInlineSnapshot(`false`)
+  })
+
+  test('rejects the wrong secret', () => {
+    const signature = Webhooks.sign({ body: 'x', secret: 'a', timestamp: 1_000 })
+    expect(
+      Webhooks.verify({ body: 'x', now: 1_000, secret: 'b', signature }),
+    ).toMatchInlineSnapshot(`false`)
+  })
+
+  test('rejects a stale signature beyond tolerance', () => {
+    const secret = 'whsec_test'
+    const signature = Webhooks.sign({ body: 'x', secret, timestamp: 1_000 })
+
+    expect(
+      Webhooks.verify({ body: 'x', now: 2_000, secret, signature, tolerance: 300 }),
+    ).toMatchInlineSnapshot(`false`)
+    expect(
+      Webhooks.verify({ body: 'x', now: 1_200, secret, signature, tolerance: 300 }),
+    ).toMatchInlineSnapshot(`true`)
+  })
+
+  test('rejects a malformed signature', () => {
+    expect(
+      Webhooks.verify({ body: 'x', secret: 'a', signature: 'nonsense' }),
+    ).toMatchInlineSnapshot(`false`)
+  })
+})
+
+describe('eventId / buildEnvelope', () => {
+  test('eventId is stable for the same coordinates', () => {
+    const a = Webhooks.eventId({
+      blockNumber: 100,
+      chainId: 4217,
+      eventType: 'token:transfer',
+      logIndex: 3,
+    })
+    const b = Webhooks.eventId({
+      blockNumber: 100,
+      chainId: 4217,
+      eventType: 'token:transfer',
+      logIndex: 3,
+    })
+    const different = Webhooks.eventId({
+      blockNumber: 100,
+      chainId: 4217,
+      eventType: 'token:transfer',
+      logIndex: 4,
+    })
+
+    expect(a).toMatchInlineSnapshot(
+      `"evt_d7c75afd0abccdc90a391d9313762a957c7e4383cac1fae76e5de56e49c9d3f8"`,
+    )
+    expect(a).toBe(b)
+    expect(a).not.toBe(different)
+  })
+
+  test('buildEnvelope embeds the data row and a stable id', async () => {
+    const store = Store.memory()
+    const subscription = await Webhooks.createSubscription(store, createInput())
+
+    const envelope = Webhooks.buildEnvelope({
+      blockNumber: 100,
+      createdAt: new Date('2026-01-01T00:00:00.000Z'),
+      data: { amount: '1', to: '0x1' },
+      logIndex: 3,
+      subscription,
+    })
+
+    expect(envelope.subscriptionId).toBe(subscription.id)
+    expect({ ...envelope, subscriptionId: '<subscriptionId>' }).toMatchInlineSnapshot(`
+      {
+        "chainId": 4217,
+        "createdAt": "2026-01-01T00:00:00.000Z",
+        "data": {
+          "amount": "1",
+          "to": "0x1",
+        },
+        "id": "evt_d7c75afd0abccdc90a391d9313762a957c7e4383cac1fae76e5de56e49c9d3f8",
+        "subscriptionId": "<subscriptionId>",
+        "type": "token:transfer",
+      }
+    `)
+  })
+})
+
+describe('delivery log', () => {
+  /** Asserts the time-sortable delivery id shape and redacts non-deterministic fields. */
+  function redactDelivery(delivery: Webhooks.Delivery) {
+    expect(delivery.id).toMatch(/^whd_\d{15}_[A-Za-z0-9_-]{21}$/)
+    expect(delivery.subscriptionId).toMatch(/^wh_\d{15}_[A-Za-z0-9_-]{21}$/)
+    return {
+      ...delivery,
+      envelope: { ...delivery.envelope, subscriptionId: '<subscriptionId>' },
+      id: '<id>',
+      subscriptionId: '<subscriptionId>',
+      ...(delivery.responseMs === undefined ? {} : { responseMs: '<ms>' }),
+    }
+  }
+
+  /** A delivery row with an explicit, lexically-sortable id for ordering tests. */
+  function row(subscriptionId: string, n: number): Webhooks.Delivery {
+    return {
+      attempt: n,
+      createdAt: new Date(1_700_000_000_000 + n * 1_000).toISOString(),
+      envelope: {
+        chainId: 4217,
+        createdAt: new Date(1_700_000_000_000 + n * 1_000).toISOString(),
+        data: { amount: String(n) },
+        id: `evt_${n}`,
+        subscriptionId,
+        type: 'token:transfer',
+      },
+      eventId: `evt_${n}`,
+      id: `whd_${String(1_700_000_000_000 + n * 1_000).padStart(15, '0')}_${'0'.repeat(16)}`,
+      requestUrl: 'https://hooks.example.com/endpoint',
+      status: 'succeeded',
+      subscriptionId,
+    }
+  }
+
+  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))
+
+    // Newest first.
+    const all = await Webhooks.listDeliveries(store, created.id)
+    expect(all.map((d) => d.eventId)).toMatchInlineSnapshot(`
+      [
+        "evt_3",
+        "evt_2",
+        "evt_1",
+      ]
+    `)
+
+    // First page of two, then resume after the last id for the older remainder.
+    const page = await Webhooks.listDeliveries(store, created.id, { limit: 2 })
+    expect(page.map((d) => d.eventId)).toEqual(['evt_3', 'evt_2'])
+
+    const next = await Webhooks.listDeliveries(store, created.id, {
+      cursor: page.at(-1)?.id,
+      limit: 2,
+    })
+    expect(next.map((d) => d.eventId)).toEqual(['evt_1'])
+  })
+
+  test('deliverAndRecord appends a succeeded row', async () => {
+    const store = Store.memory()
+    const created = await Webhooks.createSubscription(store, createInput())
+    const envelope = {
+      chainId: 4217,
+      createdAt: '2026-01-01T00:00:00.000Z',
+      data: { amount: '1' },
+      id: 'evt_ok',
+      subscriptionId: created.id,
+      type: 'token:transfer',
+    } satisfies Webhooks.Envelope
+
+    const fetch = (async () =>
+      new Response(null, { status: 200 })) satisfies typeof globalThis.fetch
+    await Webhooks.deliverAndRecord(store, created, envelope, { fetch, now: fixedNow })
+
+    const [delivery] = await Webhooks.listDeliveries(store, created.id)
+    expect(redactDelivery(delivery!)).toMatchInlineSnapshot(`
+      {
+        "attempt": 1,
+        "createdAt": "2026-01-01T00:00:00.000Z",
+        "envelope": {
+          "chainId": 4217,
+          "createdAt": "2026-01-01T00:00:00.000Z",
+          "data": {
+            "amount": "1",
+          },
+          "id": "evt_ok",
+          "subscriptionId": "<subscriptionId>",
+          "type": "token:transfer",
+        },
+        "eventId": "evt_ok",
+        "id": "<id>",
+        "requestUrl": "https://hooks.example.com/endpoint",
+        "responseMs": "<ms>",
+        "responseStatus": 200,
+        "status": "succeeded",
+        "subscriptionId": "<subscriptionId>",
+      }
+    `)
+  })
+
+  test('deliverAndRecord appends a failed row with the error and status', async () => {
+    const store = Store.memory()
+    const created = await Webhooks.createSubscription(store, createInput())
+    const envelope = {
+      chainId: 4217,
+      createdAt: '2026-01-01T00:00:00.000Z',
+      data: { amount: '1' },
+      id: 'evt_fail',
+      subscriptionId: created.id,
+      type: 'token:transfer',
+    } satisfies Webhooks.Envelope
+
+    const fetch = (async () =>
+      new Response(null, { status: 500 })) satisfies typeof globalThis.fetch
+    await Webhooks.deliverAndRecord(store, created, envelope, { fetch, now: fixedNow })
+
+    const [delivery] = await Webhooks.listDeliveries(store, created.id)
+    expect(redactDelivery(delivery!)).toMatchInlineSnapshot(`
+      {
+        "attempt": 1,
+        "createdAt": "2026-01-01T00:00:00.000Z",
+        "envelope": {
+          "chainId": 4217,
+          "createdAt": "2026-01-01T00:00:00.000Z",
+          "data": {
+            "amount": "1",
+          },
+          "id": "evt_fail",
+          "subscriptionId": "<subscriptionId>",
+          "type": "token:transfer",
+        },
+        "error": "non-2xx response (500)",
+        "eventId": "evt_fail",
+        "id": "<id>",
+        "requestUrl": "https://hooks.example.com/endpoint",
+        "responseMs": "<ms>",
+        "responseStatus": 500,
+        "status": "failed",
+        "subscriptionId": "<subscriptionId>",
+      }
+    `)
+  })
+
+  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)
+
+    await Webhooks.deleteSubscription(store, apiKeyOwner, created.id)
+    expect(await Webhooks.listDeliveries(store, 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 id = row(created.id, 1).id
+
+    const found = await Webhooks.getDelivery(store, 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`,
+    )
+  })
+})
+
+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 envelope = Webhooks.buildPingEnvelope(created, {
+      createdAt: fixedNow(),
+      nonce: 'test-nonce',
+    })
+    // The id hashes the (random) subscription id, so assert its shape and redact.
+    expect(envelope.id).toMatch(/^evt_[0-9a-f]{64}$/)
+    expect({ ...envelope, id: '<id>', subscriptionId: '<subscriptionId>' }).toMatchInlineSnapshot(`
+      {
+        "chainId": 4217,
+        "createdAt": "2026-01-01T00:00:00.000Z",
+        "data": {
+          "ping": true,
+        },
+        "id": "<id>",
+        "subscriptionId": "<subscriptionId>",
+        "type": "ping",
+      }
+    `)
+  })
+
+  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 a = Webhooks.buildPingEnvelope(created)
+    const b = Webhooks.buildPingEnvelope(created)
+    expect(a.id).not.toBe(b.id)
+  })
+})
+
+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 captured: { body: string; signature: string | null } = { body: '', signature: null }
+    const fetch = (async (_url, init) => {
+      captured.body = typeof init?.body === 'string' ? init.body : ''
+      captured.signature = new Headers(init?.headers).get(Webhooks.signatureHeader)
+      return new Response(null, { status: 200 })
+    }) satisfies typeof globalThis.fetch
+
+    const { envelope, result } = await Webhooks.ping(store, created, {
+      fetch,
+      nonce: 'test-nonce',
+      now: fixedNow,
+    })
+
+    expect(result.ok).toBe(true)
+    // The delivered body is signed with the subscription secret.
+    expect(
+      Webhooks.verify({
+        body: captured.body,
+        now: 0,
+        secret: created.secret,
+        signature: captured.signature ?? '',
+        tolerance: Number.POSITIVE_INFINITY,
+      }),
+    ).toBe(true)
+
+    // A ping is observable in the delivery log.
+    const [delivery] = await Webhooks.listDeliveries(store, 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)
+    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 fetch = (async () =>
+      new Response(null, { status: 500 })) satisfies typeof globalThis.fetch
+    const { result } = await Webhooks.ping(store, created, { fetch, now: fixedNow })
+
+    expect(result.ok).toBe(false)
+    const [delivery] = await Webhooks.listDeliveries(store, 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)
+    expect(after?.failureCount).toMatchInlineSnapshot(`0`)
+    expect(after?.status).toMatchInlineSnapshot(`"active"`)
+  })
+})