tapimo 0.0.0 → 0.0.2

package/src/internal/WebhookDestination.test.ts

@@ -0,0 +1,648 @@
+import * as WebhookDestination from './WebhookDestination.js'
+
+const envelope = {
+  chainId: 4217,
+  createdAt: '2026-01-01T00:00:00.000Z',
+  data: { amount: '1000', token: '0xabc' },
+  id: 'evt_test',
+  subscriptionId: 'wh_test',
+  type: 'token:transfer',
+} satisfies WebhookDestination.deliver.Options['envelope']
+
+describe('url', () => {
+  test('builds a url destination with a deliver method', () => {
+    const destination = WebhookDestination.url('https://example.com/hook')
+    expect(destination).toMatchObject({ type: 'url', url: 'https://example.com/hook' })
+    expect(typeof destination.deliver).toBe('function')
+    // The method drops out of JSON — a destination serializes to just its data.
+    expect(JSON.parse(JSON.stringify(destination))).toEqual({
+      type: 'url',
+      url: 'https://example.com/hook',
+    })
+  })
+
+  test('rejects a blocked host', () => {
+    expect(() =>
+      WebhookDestination.url('https://169.254.169.254/latest/meta-data'),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Webhooks.InvalidUrlError: Webhook URL rejected (blocked_host): https://169.254.169.254/latest/meta-data]`,
+    )
+  })
+})
+
+describe('slack', () => {
+  test('builds a slack destination', () => {
+    expect(WebhookDestination.slack('https://hooks.slack.com/services/T/B/x')).toMatchObject({
+      type: 'slack',
+      url: 'https://hooks.slack.com/services/T/B/x',
+    })
+  })
+
+  test('rejects a non-Slack host', () => {
+    expect(() =>
+      WebhookDestination.slack('https://evil.example.com/hook'),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Webhooks.InvalidUrlError: Webhook URL rejected (slack_host): https://evil.example.com/hook]`,
+    )
+  })
+})
+
+describe('betterStack', () => {
+  test('builds a betterstack destination', () => {
+    expect(
+      WebhookDestination.betterStack({
+        token: 'src_token',
+        url: 'https://s1.eu-nbg-2.betterstackdata.com',
+      }),
+    ).toMatchObject({
+      token: 'src_token',
+      type: 'betterstack',
+      url: 'https://s1.eu-nbg-2.betterstackdata.com',
+    })
+  })
+
+  test('rejects a non-Better Stack host', () => {
+    expect(() =>
+      WebhookDestination.betterStack({ token: 'src_token', url: 'https://evil.example.com' }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Webhooks.InvalidUrlError: Webhook URL rejected (betterstack_host): https://evil.example.com]`,
+    )
+  })
+})
+
+describe('from', () => {
+  test('normalizes a bare URL string into a url destination', () => {
+    expect(WebhookDestination.from('https://example.com/hook')).toMatchObject({
+      type: 'url',
+      url: 'https://example.com/hook',
+    })
+  })
+
+  test('validates and returns a destination object', () => {
+    expect(
+      WebhookDestination.from({ type: 'slack', url: 'https://hooks.slack.com/services/T/B/x' }),
+    ).toMatchObject({ type: 'slack', url: 'https://hooks.slack.com/services/T/B/x' })
+  })
+
+  test('rejects an invalid destination', () => {
+    expect(() =>
+      WebhookDestination.from({ type: 'slack', url: 'https://evil.example.com' }),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Webhooks.InvalidUrlError: Webhook URL rejected (slack_host): https://evil.example.com]`,
+    )
+  })
+})
+
+describe('url().deliver', () => {
+  test('signs the body and POSTs a 2xx as success', async () => {
+    let captured:
+      | { body: string; headers: Headers; method?: string | undefined; url: string }
+      | undefined
+    const fetch = (async (input, init) => {
+      captured = {
+        body: typeof init?.body === 'string' ? init.body : '',
+        headers: new Headers(init?.headers),
+        method: init?.method,
+        url: typeof input === 'string' ? input : '',
+      }
+      return new Response(null, { status: 200 })
+    }) satisfies typeof globalThis.fetch
+
+    const secret = 'whsec_test'
+    const result = await WebhookDestination.url('https://hooks.example.com/x').deliver({
+      envelope,
+      fetch,
+      now: () => 0,
+      secret,
+      timestamp: 1_000,
+    })
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "durationMs": 0,
+        "ok": true,
+        "status": 200,
+      }
+    `)
+    expect(captured?.method).toMatchInlineSnapshot(`"POST"`)
+    expect(captured?.headers.get('tempo-event-id')).toMatchInlineSnapshot(`"evt_test"`)
+    expect(captured?.headers.get('tempo-event-type')).toMatchInlineSnapshot(`"token:transfer"`)
+
+    const signature = captured?.headers.get('tempo-signature') ?? ''
+    expect(
+      WebhookDestination.verify({ body: captured?.body ?? '', now: 1_000, secret, signature }),
+    ).toMatchInlineSnapshot(`true`)
+  })
+
+  test('classifies a non-2xx as failure with the status', async () => {
+    const fetch = (async () =>
+      new Response(null, { status: 500 })) satisfies typeof globalThis.fetch
+    const result = await WebhookDestination.url('https://hooks.example.com/x').deliver({
+      envelope,
+      fetch,
+      now: () => 0,
+      secret: 'whsec_test',
+    })
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "durationMs": 0,
+        "error": "non-2xx response (500)",
+        "ok": false,
+        "status": 500,
+      }
+    `)
+  })
+
+  test('rejects a 3xx redirect without following it (SSRF guard)', async () => {
+    let redirectMode: RequestRedirect | undefined
+    const fetch = (async (_input, init) => {
+      redirectMode = init?.redirect
+      return new Response(null, {
+        headers: { location: 'https://169.254.169.254/latest' },
+        status: 302,
+      })
+    }) satisfies typeof globalThis.fetch
+
+    const result = await WebhookDestination.url('https://hooks.example.com/x').deliver({
+      envelope,
+      fetch,
+      now: () => 0,
+      secret: 'whsec_test',
+    })
+
+    expect(redirectMode).toMatchInlineSnapshot(`"manual"`)
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "durationMs": 0,
+        "error": "redirect rejected (302)",
+        "ok": false,
+        "status": 302,
+      }
+    `)
+  })
+
+  test('fails a url delivery attempted without a secret', async () => {
+    let called = false
+    const fetch = (async () => {
+      called = true
+      return new Response(null, { status: 200 })
+    }) satisfies typeof globalThis.fetch
+
+    const result = await WebhookDestination.url('https://hooks.example.com/x').deliver({
+      envelope,
+      fetch,
+    })
+
+    expect(called).toBe(false)
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "error": "url destination requires a secret",
+        "ok": false,
+      }
+    `)
+  })
+})
+
+describe('slack().deliver', () => {
+  test('POSTs an unsigned Block Kit message to the incoming-webhook URL', async () => {
+    let captured: { body: string; headers: Headers; url: string } | undefined
+    const fetch = (async (input, init) => {
+      captured = {
+        body: typeof init?.body === 'string' ? init.body : '',
+        headers: new Headers(init?.headers),
+        url: typeof input === 'string' ? input : '',
+      }
+      return new Response(null, { status: 200 })
+    }) satisfies typeof globalThis.fetch
+
+    const result = await WebhookDestination.slack(
+      'https://hooks.slack.com/services/T000/B000/xxxx',
+    ).deliver({ envelope, fetch, now: () => 0 })
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "durationMs": 0,
+        "ok": true,
+        "status": 200,
+      }
+    `)
+    expect(captured?.url).toBe('https://hooks.slack.com/services/T000/B000/xxxx')
+    expect(captured?.headers.get('tempo-signature')).toBeNull()
+    const payload = JSON.parse(captured?.body ?? '{}') as { blocks: unknown[]; text: string }
+    expect(Array.isArray(payload.blocks)).toBe(true)
+    expect(payload.text).toMatchInlineSnapshot(`"Token transfer · 1000 · chain 4217"`)
+  })
+
+  test('leads with the subscription context (title header + description section)', async () => {
+    let captured: { body: string } | undefined
+    const fetch = (async (_input, init) => {
+      captured = { body: typeof init?.body === 'string' ? init.body : '' }
+      return new Response(null, { status: 200 })
+    }) satisfies typeof globalThis.fetch
+
+    await WebhookDestination.slack('https://hooks.slack.com/services/T/B/x').deliver({
+      envelope: {
+        ...envelope,
+        context: {
+          description: 'Notify #ops on big settles.',
+          metadata: { env: 'prod', team: 'payments' },
+          title: 'Prod USDC transfers',
+        },
+      },
+      fetch,
+      now: () => 0,
+    })
+
+    const payload = JSON.parse(captured?.body ?? '{}') as {
+      blocks: { fields?: { text: string }[]; text?: { text: string }; type: string }[]
+      text: string
+    }
+    // Title drives the header + notification fallback.
+    expect(payload.text).toBe('Prod USDC transfers')
+    expect(payload.blocks[0]).toMatchObject({
+      text: { text: 'Prod USDC transfers' },
+      type: 'header',
+    })
+    // Description gets its own section, before the field grid.
+    expect(payload.blocks[1]).toMatchObject({
+      text: { text: 'Notify #ops on big settles.' },
+      type: 'section',
+    })
+    // Metadata renders as its own field grid.
+    const metadata = payload.blocks.find((block) =>
+      block.fields?.some((f) => f.text.startsWith('*env*')),
+    )
+    expect(metadata?.fields).toEqual([
+      { text: '*env*\nprod', type: 'mrkdwn' },
+      { text: '*team*\npayments', type: 'mrkdwn' },
+    ])
+    // The raw event type stays in the context line so identity survives the title.
+    const context = payload.blocks.at(-1)
+    expect(context?.type).toBe('context')
+  })
+
+  test('renders a token:transfer with a human amount and explorer links', async () => {
+    const payload = await captureSlack({
+      chainId: 4217,
+      createdAt: '2026-01-14T18:38:03.000Z',
+      data: {
+        address: '0x20c0000000000000000000008f5425160ebe5525',
+        amount: '10000000',
+        blockNumber: 1000002,
+        recipient: '0x9e39034aae71fb89f66061a2602eb6efec271754',
+        sender: '0xe7687128b0a808c2831ff94d4f7b2fb35c65af38',
+        timestamp: '2026-01-14T18:38:03.000Z',
+        token: { decimals: 6, symbol: 'USDC' },
+        transactionHash: '0x3d24a706cc2f6f4c96620bef1f61ddb23040ff77c22c8db42918c7c424bbf9d3',
+      },
+      id: 'evt_abc',
+      subscriptionId: 'wh_abc',
+      type: 'token:transfer',
+    })
+
+    expect(header(payload)).toBe(':money_with_wings: Token transfer')
+    // Human amount from token metadata, with truncated + linked sender/recipient.
+    expect(section(payload, 1)).toContain('*10 USDC* from')
+    expect(section(payload, 1)).toContain('<https://explore.tempo.xyz/address/0xe768')
+    expect(payload.text).toBe('Token transfer · 10 USDC · chain 4217')
+    // The Amount field renders the human amount only (no raw base units).
+    const json = JSON.stringify(payload.blocks)
+    expect(json).toContain('*Amount*\\n10 USDC')
+    expect(json).not.toContain('base units')
+  })
+
+  test('renders a reverted transaction with an :x: accent header', async () => {
+    const payload = await captureSlack({
+      chainId: 4217,
+      createdAt: '2026-01-14T18:38:03.000Z',
+      data: {
+        blockNumber: 23456789,
+        hash: '0x3d24a706cc2f6f4c96620bef1f61ddb23040ff77c22c8db42918c7c424bbf9d3',
+        meta: { receipt: { status: 'reverted' } },
+        recipient: '0x9e39034aae71fb89f66061a2602eb6efec271754',
+        sender: '0xe7687128b0a808c2831ff94d4f7b2fb35c65af38',
+        type: 'eip1559',
+        value: '0',
+      },
+      id: 'evt_tx',
+      subscriptionId: 'wh_tx',
+      type: 'transaction:included',
+    })
+
+    expect(header(payload)).toBe(':x: Transaction reverted')
+    expect(section(payload, 1)).toContain(':x: *reverted*')
+    expect(payload.text).toBe('Transaction included · reverted · chain 4217')
+  })
+
+  test('renders a decoded log with the event name in the header', async () => {
+    const payload = await captureSlack({
+      chainId: 4217,
+      createdAt: '2026-01-14T18:38:03.000Z',
+      data: {
+        address: '0x20c0000000000000000000008f5425160ebe5525',
+        args: { from: '0xe7687128b0a808c2831ff94d4f7b2fb35c65af38', value: '10000' },
+        blockNumber: 1000002,
+        event: { name: 'Transfer', signature: 'event Transfer(address,address,uint256)' },
+        logIndex: 0,
+        timestamp: '2026-01-14T18:38:03.000Z',
+        transactionHash: '0x3d24a706cc2f6f4c96620bef1f61ddb23040ff77c22c8db42918c7c424bbf9d3',
+      },
+      id: 'evt_log',
+      subscriptionId: 'wh_log',
+      type: 'log:emitted',
+    })
+
+    expect(header(payload)).toBe(':label: Log: Transfer')
+    expect(section(payload, 1)).toContain('*Transfer* on')
+    expect(payload.text).toContain('Log: Transfer')
+  })
+
+  test('renders a block:created header with the block number', async () => {
+    const payload = await captureSlack({
+      chainId: 4217,
+      createdAt: '2026-01-14T18:38:03.000Z',
+      data: {
+        gasLimit: 500000000,
+        gasUsed: 4340281,
+        hash: '0x3fe7d9e595f3d8215ec840c6ef55ac0bead58933e96fc2ead0f2aaf79715f45d',
+        miner: '0x0000000000000000000000000000000000000000',
+        number: 1000002,
+        transactionCount: 3,
+        timestamp: '2026-01-14T18:38:03.000Z',
+      },
+      id: 'evt_blk',
+      subscriptionId: 'wh_blk',
+      type: 'block:created',
+    })
+
+    expect(header(payload)).toBe(':link: Block created #1000002')
+    expect(section(payload, 1)).toContain('*3* transactions')
+    expect(payload.text).toBe('Block created #1000002 · 3 txns · chain 4217')
+  })
+
+  test('renders a ping with a wired-up confirmation lead', async () => {
+    const payload = await captureSlack({
+      chainId: 4217,
+      createdAt: '2026-01-14T18:38:03.000Z',
+      data: { ping: true },
+      id: 'evt_ping',
+      subscriptionId: 'wh_ping',
+      type: 'ping',
+    })
+
+    expect(header(payload)).toBe(':bell: Webhook test ping')
+    expect(section(payload, 1)).toContain('wired up correctly')
+    expect(payload.text).toBe('Webhook test ping · chain 4217')
+  })
+
+  test('classifies a non-2xx Slack response as failure', async () => {
+    const fetch = (async () =>
+      new Response('invalid_token', { status: 403 })) satisfies typeof globalThis.fetch
+    const result = await WebhookDestination.slack(
+      'https://hooks.slack.com/services/T000/B000/xxxx',
+    ).deliver({ envelope, fetch, now: () => 0 })
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "durationMs": 0,
+        "error": "slack non-2xx response (403)",
+        "ok": false,
+        "status": 403,
+      }
+    `)
+  })
+})
+
+/** A parsed Slack Block Kit payload with the loose block shapes we assert on. */
+type SlackPayload = {
+  blocks: { elements?: { text: string }[]; text?: { text: string }; type: string }[]
+  text: string
+}
+
+/** Delivers an envelope through the `slack` transport and returns the parsed body. */
+async function captureSlack(
+  envelope: WebhookDestination.deliver.Options['envelope'],
+): Promise<SlackPayload> {
+  let body = '{}'
+  const fetch = (async (_input, init) => {
+    body = typeof init?.body === 'string' ? init.body : '{}'
+    return new Response(null, { status: 200 })
+  }) satisfies typeof globalThis.fetch
+  await WebhookDestination.slack('https://hooks.slack.com/services/T/B/x').deliver({
+    envelope,
+    fetch,
+    now: () => 0,
+  })
+  return JSON.parse(body) as SlackPayload
+}
+
+/** The header block's text. */
+function header(payload: SlackPayload): string | undefined {
+  return payload.blocks.find((block) => block.type === 'header')?.text?.text
+}
+
+/** The mrkdwn text of the section block at `index` (header is block 0). */
+function section(payload: SlackPayload, index: number): string {
+  return payload.blocks[index]?.text?.text ?? ''
+}
+
+describe('betterStack().deliver', () => {
+  test('POSTs a bearer-authed log event to the ingest URL', async () => {
+    let captured: { body: string; headers: Headers; url: string } | undefined
+    const fetch = (async (input, init) => {
+      captured = {
+        body: typeof init?.body === 'string' ? init.body : '',
+        headers: new Headers(init?.headers),
+        url: typeof input === 'string' ? input : '',
+      }
+      return new Response(null, { status: 202 })
+    }) satisfies typeof globalThis.fetch
+
+    const result = await WebhookDestination.betterStack({
+      token: 'src_token',
+      url: 'https://s1234567.eu-nbg-2.betterstackdata.com',
+    }).deliver({ envelope, fetch, now: () => 0 })
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "durationMs": 0,
+        "ok": true,
+        "status": 202,
+      }
+    `)
+    expect(captured?.headers.get('authorization')).toBe('Bearer src_token')
+    expect(captured?.headers.get('tempo-signature')).toBeNull()
+    const payload = JSON.parse(captured?.body ?? '{}') as Record<string, unknown>
+    expect(payload['dt']).toBe('2026-01-01T00:00:00.000Z')
+    expect(payload['event']).toBe('token:transfer')
+  })
+
+  test('maps subscription context onto the log message + description', async () => {
+    let captured: { body: string } | undefined
+    const fetch = (async (_input, init) => {
+      captured = { body: typeof init?.body === 'string' ? init.body : '' }
+      return new Response(null, { status: 202 })
+    }) satisfies typeof globalThis.fetch
+
+    await WebhookDestination.betterStack({
+      token: 'src_token',
+      url: 'https://s1234567.eu-nbg-2.betterstackdata.com',
+    }).deliver({
+      envelope: {
+        ...envelope,
+        context: {
+          description: 'Notify #ops on big settles.',
+          metadata: { env: 'prod', team: 'payments' },
+          title: 'Prod USDC transfers',
+        },
+      },
+      fetch,
+      now: () => 0,
+    })
+
+    const payload = JSON.parse(captured?.body ?? '{}') as Record<string, unknown>
+    expect(payload['message']).toBe('Prod USDC transfers')
+    expect(payload['description']).toBe('Notify #ops on big settles.')
+    expect(payload['metadata']).toEqual({ env: 'prod', team: 'payments' })
+  })
+
+  test('classifies a non-2xx Better Stack response as failure', async () => {
+    const fetch = (async () =>
+      new Response('Unauthorized', { status: 403 })) satisfies typeof globalThis.fetch
+    const result = await WebhookDestination.betterStack({
+      token: 'src_token',
+      url: 'https://s1234567.eu-nbg-2.betterstackdata.com',
+    }).deliver({ envelope, fetch, now: () => 0 })
+
+    expect(result).toMatchInlineSnapshot(`
+      {
+        "durationMs": 0,
+        "error": "betterstack non-2xx response (403)",
+        "ok": false,
+        "status": 403,
+      }
+    `)
+  })
+})
+
+describe('from(...).deliver', () => {
+  test('rebuilds a plain (persisted) destination and delivers via its own transport', async () => {
+    let capturedUrl: string | undefined
+    const fetch = (async (input) => {
+      capturedUrl = typeof input === 'string' ? input : ''
+      return new Response(null, { status: 200 })
+    }) satisfies typeof globalThis.fetch
+
+    // A plain destination as read back from the store — no bound `deliver`.
+    const destination: WebhookDestination.Destination = {
+      type: 'slack',
+      url: 'https://hooks.slack.com/services/T000/B000/xxxx',
+    }
+    const result = await WebhookDestination.from(destination).deliver({
+      envelope,
+      fetch,
+      now: () => 0,
+    })
+
+    expect(result.ok).toBe(true)
+    expect(capturedUrl).toBe('https://hooks.slack.com/services/T000/B000/xxxx')
+  })
+})
+
+describe('assertDeliverableUrl', () => {
+  test('accepts a plain https URL', () => {
+    expect(() =>
+      WebhookDestination.assertDeliverableUrl('https://hooks.example.com/x'),
+    ).not.toThrow()
+  })
+
+  test.each([
+    ['http (non-https)', 'http://hooks.example.com', 'protocol'],
+    ['ftp scheme', 'ftp://hooks.example.com', 'protocol'],
+    ['embedded credentials', 'https://user:pass@hooks.example.com', 'credentials'],
+    ['localhost', 'https://localhost/x', 'blocked_host'],
+    ['sub.localhost', 'https://api.localhost/x', 'blocked_host'],
+    ['loopback v4', 'https://127.0.0.1/x', 'blocked_host'],
+    ['private 10/8', 'https://10.1.2.3/x', 'blocked_host'],
+    ['private 172.16/12', 'https://172.16.0.1/x', 'blocked_host'],
+    ['private 192.168/16', 'https://192.168.0.1/x', 'blocked_host'],
+    ['link-local / metadata', 'https://169.254.169.254/x', 'blocked_host'],
+    ['cgnat', 'https://100.64.0.1/x', 'blocked_host'],
+    ['gcp metadata host', 'https://metadata.google.internal/x', 'blocked_host'],
+    ['ipv6 loopback', 'https://[::1]/x', 'blocked_host'],
+    ['ipv6 link-local', 'https://[fe80::1]/x', 'blocked_host'],
+    ['ipv6 unique-local', 'https://[fd00::1]/x', 'blocked_host'],
+    ['ipv4-mapped loopback', 'https://[::ffff:127.0.0.1]/x', 'blocked_host'],
+    ['malformed', 'not a url', 'malformed'],
+  ])('rejects %s', (_label, url, reason) => {
+    let error: unknown
+    try {
+      WebhookDestination.assertDeliverableUrl(url)
+    } catch (caught) {
+      error = caught
+    }
+    expect(error).toBeInstanceOf(WebhookDestination.InvalidUrlError)
+    expect((error as WebhookDestination.InvalidUrlError).reason).toBe(reason)
+  })
+
+  test('accepts a public IPv4 literal', () => {
+    expect(() => WebhookDestination.assertDeliverableUrl('https://93.184.216.34/x')).not.toThrow()
+  })
+})
+
+describe('assertSlackUrl', () => {
+  test('accepts a hooks.slack.com https URL', () => {
+    expect(() =>
+      WebhookDestination.assertSlackUrl('https://hooks.slack.com/services/T000/B000/xxxx'),
+    ).not.toThrow()
+  })
+
+  test('rejects a non-Slack host', () => {
+    expect(() =>
+      WebhookDestination.assertSlackUrl('https://evil.example.com/hook'),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Webhooks.InvalidUrlError: Webhook URL rejected (slack_host): https://evil.example.com/hook]`,
+    )
+  })
+
+  test('rejects a non-https URL', () => {
+    expect(() =>
+      WebhookDestination.assertSlackUrl('http://hooks.slack.com/services/x'),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Webhooks.InvalidUrlError: Webhook URL rejected (protocol): http://hooks.slack.com/services/x]`,
+    )
+  })
+})
+
+describe('redactSlackUrl', () => {
+  test('masks the secret path, keeping the origin', () => {
+    expect(
+      WebhookDestination.redactSlackUrl('https://hooks.slack.com/services/T000/B000/secrettoken'),
+    ).toMatchInlineSnapshot(`"https://hooks.slack.com/…"`)
+  })
+})
+
+describe('assertBetterstackUrl', () => {
+  test('accepts a betterstackdata.com https URL', () => {
+    expect(() =>
+      WebhookDestination.assertBetterstackUrl('https://s1234567.eu-nbg-2.betterstackdata.com'),
+    ).not.toThrow()
+  })
+
+  test('rejects a non-Better Stack host', () => {
+    expect(() =>
+      WebhookDestination.assertBetterstackUrl('https://evil.example.com/ingest'),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Webhooks.InvalidUrlError: Webhook URL rejected (betterstack_host): https://evil.example.com/ingest]`,
+    )
+  })
+
+  test('rejects a non-https URL', () => {
+    expect(() =>
+      WebhookDestination.assertBetterstackUrl('http://s1.betterstackdata.com'),
+    ).toThrowErrorMatchingInlineSnapshot(
+      `[Webhooks.InvalidUrlError: Webhook URL rejected (protocol): http://s1.betterstackdata.com]`,
+    )
+  })
+})