@open-mercato/channel-discord 0.6.8-develop.7090.1.4dbca7b350

package/src/modules/channel_discord/lib/__tests__/discord-gateway-client.test.ts

@@ -0,0 +1,243 @@
+import {
+  DISCORD_GATEWAY_INTENTS,
+  GatewayOpcode,
+  buildIdentifyPayload,
+  buildResumePayload,
+  buildHeartbeatPayload,
+  computeReconnectDelayMs,
+  createHeartbeatMonitor,
+  isFatalGatewayCloseCode,
+  shouldResumeAfterClose,
+  getDiscordGatewayClient,
+  type DiscordGatewayConnectOptions,
+  type DiscordGatewayHandle,
+  type GatewayResumeState,
+  type GatewayWebSocketLike,
+} from '../discord-gateway-client'
+
+describe('discord gateway state-machine helpers', () => {
+  it('declares message-content + guild-message intents', () => {
+    // GUILDS (1) | GUILD_MESSAGES (512) | GUILD_MESSAGE_REACTIONS (1024) | MESSAGE_CONTENT (32768)
+    expect(DISCORD_GATEWAY_INTENTS).toBe(1 | 512 | 1024 | 32768)
+  })
+
+  it('builds an identify payload with the bot token + intents', () => {
+    const payload = buildIdentifyPayload('tok', DISCORD_GATEWAY_INTENTS)
+    expect(payload.op).toBe(GatewayOpcode.IDENTIFY)
+    expect(payload.d.token).toBe('tok')
+    expect(payload.d.intents).toBe(DISCORD_GATEWAY_INTENTS)
+  })
+
+  it('builds a resume payload with session + sequence', () => {
+    const payload = buildResumePayload('tok', 'sess-1', 42)
+    expect(payload.op).toBe(GatewayOpcode.RESUME)
+    expect(payload.d).toEqual({ token: 'tok', session_id: 'sess-1', seq: 42 })
+  })
+
+  it('builds a heartbeat payload with the last sequence', () => {
+    expect(buildHeartbeatPayload(7)).toEqual({ op: GatewayOpcode.HEARTBEAT, d: 7 })
+    expect(buildHeartbeatPayload(null)).toEqual({ op: GatewayOpcode.HEARTBEAT, d: null })
+  })
+
+  it('treats 4004/4014 as fatal (requires reauth)', () => {
+    expect(isFatalGatewayCloseCode(4004)).toBe(true)
+    expect(isFatalGatewayCloseCode(4014)).toBe(true)
+    expect(isFatalGatewayCloseCode(1006)).toBe(false)
+    expect(isFatalGatewayCloseCode(undefined)).toBe(false)
+  })
+
+  it('does not resume after fatal / session-invalidating close codes', () => {
+    expect(shouldResumeAfterClose(4004)).toBe(false)
+    expect(shouldResumeAfterClose(4007)).toBe(false)
+    expect(shouldResumeAfterClose(4009)).toBe(false)
+    expect(shouldResumeAfterClose(1000)).toBe(false)
+    expect(shouldResumeAfterClose(1006)).toBe(true)
+  })
+
+  it('bounds reconnect backoff between base and cap', () => {
+    expect(computeReconnectDelayMs(0)).toBeGreaterThanOrEqual(1000)
+    expect(computeReconnectDelayMs(0)).toBeLessThanOrEqual(1500)
+    expect(computeReconnectDelayMs(100)).toBeLessThanOrEqual(30_000)
+  })
+})
+
+describe('createHeartbeatMonitor (zombie detection)', () => {
+  it('sends the first beat and reconnects when the previous beat was never ACKed', () => {
+    const monitor = createHeartbeatMonitor()
+    expect(monitor.onBeat()).toBe('send') // first beat armed, awaiting ACK
+    expect(monitor.onBeat()).toBe('reconnect') // no ACK arrived → zombie
+  })
+
+  it('keeps sending while ACKs arrive between beats', () => {
+    const monitor = createHeartbeatMonitor()
+    expect(monitor.onBeat()).toBe('send')
+    monitor.onAck()
+    expect(monitor.onBeat()).toBe('send')
+    monitor.onAck()
+    expect(monitor.onBeat()).toBe('send')
+  })
+
+  it('re-arms after reset (fresh reconnect)', () => {
+    const monitor = createHeartbeatMonitor()
+    expect(monitor.onBeat()).toBe('send')
+    expect(monitor.onBeat()).toBe('reconnect')
+    monitor.reset()
+    expect(monitor.isAcked()).toBe(true)
+    expect(monitor.onBeat()).toBe('send')
+  })
+})
+
+type FakeSocket = {
+  sent: string[]
+  closes: Array<{ code?: number; reason?: string }>
+  socket: GatewayWebSocketLike
+  emit: (type: 'open' | 'message' | 'close' | 'error', event: unknown) => void
+}
+
+function createFakeSocket(): FakeSocket {
+  const listeners: Partial<Record<'open' | 'message' | 'close' | 'error', Array<(event: unknown) => void>>> = {}
+  const sent: string[] = []
+  const closes: Array<{ code?: number; reason?: string }> = []
+  return {
+    sent,
+    closes,
+    socket: {
+      send: (data: string) => {
+        sent.push(data)
+      },
+      close: (code?: number, reason?: string) => {
+        closes.push({ code, reason })
+      },
+      addEventListener: (type, listener) => {
+        const bucket = listeners[type] ?? []
+        bucket.push(listener)
+        listeners[type] = bucket
+      },
+    },
+    emit: (type, event) => {
+      for (const listener of listeners[type] ?? []) listener(event)
+    },
+  }
+}
+
+function connectWithFakeSockets(
+  sockets: FakeSocket[],
+  overrides: Partial<DiscordGatewayConnectOptions> = {},
+): { handle: DiscordGatewayHandle; resumeStates: GatewayResumeState[] } {
+  const resumeStates: GatewayResumeState[] = []
+  let index = 0
+  const handle = getDiscordGatewayClient().connect({
+    botToken: 'tok',
+    resumeState: { sessionId: 'sess-1', sequence: 5, resumeGatewayUrl: 'wss://resume.example' },
+    onMessage: jest.fn(),
+    onReaction: jest.fn(),
+    onReady: jest.fn(),
+    onRequiresReauth: jest.fn(),
+    onResumeStateChange: (state) => {
+      resumeStates.push(state)
+    },
+    webSocketFactory: () => {
+      const next = sockets[Math.min(index, sockets.length - 1)]
+      index += 1
+      return next.socket
+    },
+    ...overrides,
+  })
+  return { handle, resumeStates }
+}
+
+function firstOpcode(sent: string[]): number | undefined {
+  const payload = sent.map((raw) => JSON.parse(raw) as { op: number }).find((entry) => entry.op !== GatewayOpcode.HEARTBEAT)
+  return payload?.op
+}
+
+describe('gateway session — INVALID_SESSION (opcode 9)', () => {
+  beforeEach(() => {
+    jest.useFakeTimers()
+  })
+
+  afterEach(() => {
+    jest.clearAllTimers()
+    jest.useRealTimers()
+  })
+
+  it('closes the socket so the connection reconnects instead of going deaf', () => {
+    const socket = createFakeSocket()
+    const { handle } = connectWithFakeSockets([socket])
+
+    socket.emit('message', { data: JSON.stringify({ op: GatewayOpcode.INVALID_SESSION, d: false }) })
+
+    expect(socket.closes).toEqual([{ code: 4000, reason: 'invalid session' }])
+    handle.close()
+  })
+
+  it('re-IDENTIFYs on the next connect when Discord reports the session is not resumable', () => {
+    const first = createFakeSocket()
+    const second = createFakeSocket()
+    const { handle, resumeStates } = connectWithFakeSockets([first, second])
+
+    first.emit('message', { data: JSON.stringify({ op: GatewayOpcode.INVALID_SESSION, d: false }) })
+    expect(resumeStates.at(-1)).toEqual({ sessionId: undefined, sequence: null, resumeGatewayUrl: undefined })
+
+    first.emit('close', { code: 4000 })
+    jest.advanceTimersByTime(30_000)
+    second.emit('message', { data: JSON.stringify({ op: GatewayOpcode.HELLO, d: { heartbeat_interval: 45_000 } }) })
+
+    expect(firstOpcode(second.sent)).toBe(GatewayOpcode.IDENTIFY)
+    handle.close()
+  })
+
+  it('honours the resumable flag and RESUMEs the stored session when Discord allows it', () => {
+    const first = createFakeSocket()
+    const second = createFakeSocket()
+    const { handle, resumeStates } = connectWithFakeSockets([first, second])
+
+    first.emit('message', { data: JSON.stringify({ op: GatewayOpcode.INVALID_SESSION, d: true }) })
+    expect(resumeStates).toEqual([])
+
+    first.emit('close', { code: 4000 })
+    jest.advanceTimersByTime(30_000)
+    second.emit('message', { data: JSON.stringify({ op: GatewayOpcode.HELLO, d: { heartbeat_interval: 45_000 } }) })
+
+    const resume = second.sent.map((raw) => JSON.parse(raw) as { op: number; d?: { session_id?: string } })
+    expect(firstOpcode(second.sent)).toBe(GatewayOpcode.RESUME)
+    expect(resume.find((entry) => entry.op === GatewayOpcode.RESUME)?.d?.session_id).toBe('sess-1')
+    handle.close()
+  })
+})
+
+describe('gateway handle — isActive()', () => {
+  beforeEach(() => {
+    jest.useFakeTimers()
+  })
+
+  afterEach(() => {
+    jest.clearAllTimers()
+    jest.useRealTimers()
+  })
+
+  it('stays active while the session reconnects, so a refresh never restarts it', () => {
+    const first = createFakeSocket()
+    const second = createFakeSocket()
+    const { handle } = connectWithFakeSockets([first, second])
+
+    expect(handle.isActive()).toBe(true)
+    first.emit('close', { code: 1006 })
+    expect(handle.isActive()).toBe(true)
+
+    jest.advanceTimersByTime(30_000)
+    handle.close()
+  })
+
+  it('reports inactive after close() and after a fatal close code', () => {
+    const stopped = createFakeSocket()
+    const { handle: stoppedHandle } = connectWithFakeSockets([stopped])
+    stoppedHandle.close()
+    expect(stoppedHandle.isActive()).toBe(false)
+
+    const fatal = createFakeSocket()
+    const { handle: fatalHandle } = connectWithFakeSockets([fatal])
+    fatal.emit('close', { code: 4004 })
+    expect(fatalHandle.isActive()).toBe(false)
+  })
+})

package/src/modules/channel_discord/lib/__tests__/failure-reason.test.ts

@@ -0,0 +1,68 @@
+import { describeAgentFailure, redactSecrets } from '../failure-reason'
+
+/**
+ * Token-shaped fixtures are assembled at run time rather than written as
+ * literals. They are fabricated, but a literal in this shape trips GitHub's
+ * secret-scanning push protection, and a test file that cannot be pushed is
+ * worse than one that spends a `join` on its fixtures.
+ */
+const fakeBotToken = ['MTIzNDU2Nzg5MDEyMzQ1Njc4', 'GhIjKl', 'mNoPqRsTuVwXyZ0123456789abcd'].join('.')
+const fakeJwt = ['eyJhbGciOiJIUzI1NiJ9', 'eyJzdWIiOiIxIn0', 'dBjftJeZ4CVPmB92K27uhbUJU1p1r5wW1gFWFOEjXk'].join('.')
+
+/**
+ * The auto-reply failure marker is persisted on `channelState` and rendered on
+ * the settings page, so an upstream error message stops being a log line and
+ * becomes product data. These cases pin the two properties that matter: the
+ * reason stays useful, and nothing that looks like a credential survives into the
+ * column.
+ */
+describe('redactSecrets', () => {
+  it('leaves an ordinary diagnostic alone', () => {
+    expect(redactSecrets('agent policy denied: missing customers.view')).toBe(
+      'agent policy denied: missing customers.view',
+    )
+  })
+
+  it('strips a bot token quoted in an Authorization header', () => {
+    const redacted = redactSecrets(`Discord API 401: Authorization: Bot ${fakeBotToken}`)
+    expect(redacted).not.toContain(fakeBotToken)
+    expect(redacted).toContain('[redacted]')
+  })
+
+  it('strips a bare token-shaped value with no header around it', () => {
+    expect(redactSecrets(`rejected ${fakeJwt}`)).toBe('rejected [redacted]')
+  })
+
+  it('strips a provider api key prefix', () => {
+    expect(redactSecrets('bad key sk-abcdefghijklmnopqrstuvwxyz')).toBe('bad key [redacted]')
+  })
+
+  it('keeps the query parameter name but not its value', () => {
+    expect(redactSecrets('GET https://example.test/x?access_token=abc123&page=2')).toBe(
+      'GET https://example.test/x?access_token=[redacted]&page=2',
+    )
+  })
+})
+
+describe('describeAgentFailure', () => {
+  it('names the agent, because that is what the operator has to change', () => {
+    expect(describeAgentFailure('customers.support', new Error('agent_features_denied'))).toBe(
+      'agent customers.support: agent_features_denied',
+    )
+  })
+
+  it('keeps only the first line, so a stack trace never lands in the column', () => {
+    const err = new Error('boom\n    at somewhere (file.ts:1:1)\n    at elsewhere (file.ts:2:2)')
+    expect(describeAgentFailure('a.b', err)).toBe('agent a.b: boom')
+  })
+
+  it('survives a thrown non-Error', () => {
+    expect(describeAgentFailure('a.b', 'plain string')).toBe('agent a.b: plain string')
+    expect(describeAgentFailure('a.b', new Error(''))).toBe('agent a.b: unknown error')
+  })
+
+  it('redacts a credential the upstream error echoed back', () => {
+    const err = new Error('POST /channels/1/messages failed: Bearer sk-0123456789abcdefghij')
+    expect(describeAgentFailure('a.b', err)).not.toContain('0123456789abcdefghij')
+  })
+})

package/src/modules/channel_discord/lib/__tests__/gateway-bridge.test.ts

@@ -0,0 +1,62 @@
+import { buildInboundMessageJob, buildReactionJob, type GatewayChannelScope } from '../gateway-bridge'
+import type { DiscordMessageObject } from '../discord-rest'
+
+const channel: GatewayChannelScope = {
+  channelId: 'channel-uuid',
+  channelType: 'discord',
+  tenantId: 'tenant-uuid',
+  organizationId: 'org-uuid',
+}
+
+function makeMessage(authorId: string): DiscordMessageObject {
+  return {
+    id: 'm1',
+    channel_id: 'disc-chan',
+    content: 'hi',
+    author: { id: authorId, username: 'u' },
+    timestamp: '2026-06-19T10:00:00.000Z',
+  }
+}
+
+describe('buildInboundMessageJob', () => {
+  it('produces a hub inbound job for a non-bot message', () => {
+    const job = buildInboundMessageJob({ message: makeMessage('user-1'), channel, botUserId: 'bot-1' })
+    expect(job).not.toBeNull()
+    expect(job?.providerKey).toBe('discord')
+    expect(job?.channelId).toBe('channel-uuid')
+    expect(job?.raw.eventType).toBe('message')
+    expect(job?.scope).toEqual({ tenantId: 'tenant-uuid', organizationId: 'org-uuid' })
+    expect((job?.raw.raw as { discordMessage?: unknown }).discordMessage).toBeTruthy()
+  })
+
+  it('returns null for the bot own message (feedback-loop guard)', () => {
+    const job = buildInboundMessageJob({ message: makeMessage('bot-1'), channel, botUserId: 'bot-1' })
+    expect(job).toBeNull()
+  })
+})
+
+describe('buildReactionJob', () => {
+  it('builds a normalized reaction job with mapped emoji', async () => {
+    const job = await buildReactionJob({
+      reaction: { message_id: 'm1', channel_id: 'disc-chan', user_id: 'user-2', emoji: { name: '👍', id: null } },
+      action: 'added',
+      channel,
+      botUserId: 'bot-1',
+    })
+    expect(job).not.toBeNull()
+    expect(job?.kind).toBe('inbound')
+    expect(job?.event.emoji).toBe('👍')
+    expect(job?.event.action).toBe('added')
+    expect(job?.event.externalMessageId).toBe('m1')
+  })
+
+  it('returns null for a reaction the bot itself added', async () => {
+    const job = await buildReactionJob({
+      reaction: { message_id: 'm1', channel_id: 'disc-chan', user_id: 'bot-1', emoji: { name: '👍' } },
+      action: 'added',
+      channel,
+      botUserId: 'bot-1',
+    })
+    expect(job).toBeNull()
+  })
+})

package/src/modules/channel_discord/lib/__tests__/interactions-dispatch.test.ts

@@ -0,0 +1,223 @@
+import { createTranslator } from '@open-mercato/shared/lib/i18n/translate'
+import type { DiscordRestClient } from '../discord-rest'
+import {
+  buildInteractionFollowUpContent,
+  buildInteractionInboundJob,
+  buildInteractionMessage,
+  readDispatchableInteraction,
+  renderInteractionContent,
+  sendInteractionFollowUp,
+  type DispatchableInteraction,
+} from '../interactions-dispatch'
+import { DiscordInteractionType, type ParsedInteraction } from '../interactions-verify'
+import { normalizeInboundDiscordMessage } from '../normalize-inbound'
+
+const now = new Date('2026-06-19T10:00:00.000Z')
+
+function slashCommand(overrides: Partial<ParsedInteraction> = {}): ParsedInteraction {
+  return {
+    type: DiscordInteractionType.APPLICATION_COMMAND,
+    id: 'interaction-1',
+    token: 'interaction-token',
+    application_id: 'app-1',
+    channel_id: 'discord-channel-1',
+    guild_id: 'guild-1',
+    member: { user: { id: 'user-1', username: 'ada', global_name: 'Ada L.' } },
+    data: { name: 'mercato', options: [{ name: 'message', value: 'the printer is jammed' }] },
+    ...overrides,
+  }
+}
+
+describe('renderInteractionContent', () => {
+  it('renders a slash command with its options', () => {
+    expect(renderInteractionContent(slashCommand())).toBe('/mercato message:the printer is jammed')
+  })
+
+  it('descends into subcommands instead of losing what the user typed', () => {
+    // Discord nests the real arguments under the subcommand's own `options`, so
+    // a one-level read renders `/support ticket:` and drops the payload.
+    const content = renderInteractionContent(
+      slashCommand({
+        data: {
+          name: 'support',
+          options: [
+            { name: 'ticket', options: [{ name: 'subject', value: 'jam' }, { name: 'priority', value: 2 }] },
+          ],
+        },
+      }),
+    )
+    expect(content).toBe('/support ticket subject:jam priority:2')
+  })
+
+  it('renders a component press with its selected values', () => {
+    const content = renderInteractionContent({
+      type: DiscordInteractionType.MESSAGE_COMPONENT,
+      data: { custom_id: 'escalate', values: ['tier-2', 'urgent'] },
+    })
+    expect(content).toBe('[component] escalate tier-2 urgent')
+  })
+
+  it('renders a modal submission field by field', () => {
+    const content = renderInteractionContent({
+      type: DiscordInteractionType.MODAL_SUBMIT,
+      data: {
+        custom_id: 'ticket-form',
+        components: [{ components: [{ custom_id: 'subject', value: 'jam' }] }],
+      },
+    })
+    expect(content).toBe('[modal] ticket-form subject:jam')
+  })
+})
+
+describe('readDispatchableInteraction', () => {
+  it('extracts everything the worker needs from a guild slash command', () => {
+    const dispatch = readDispatchableInteraction(slashCommand(), { now })
+    expect(dispatch).toEqual({
+      id: 'interaction-1',
+      token: 'interaction-token',
+      type: DiscordInteractionType.APPLICATION_COMMAND,
+      applicationId: 'app-1',
+      discordChannelId: 'discord-channel-1',
+      guildId: 'guild-1',
+      user: { id: 'user-1', username: 'ada', global_name: 'Ada L.' },
+      commandName: 'mercato',
+      customId: undefined,
+      content: '/mercato message:the printer is jammed',
+      timestamp: now.toISOString(),
+    })
+  })
+
+  it('reads the invoker from `user` in a DM, where there is no `member`', () => {
+    const dispatch = readDispatchableInteraction(
+      slashCommand({ member: undefined, guild_id: undefined, user: { id: 'user-2', username: 'grace' } }),
+      { now },
+    )
+    expect(dispatch?.user.id).toBe('user-2')
+    expect(dispatch?.guildId).toBeUndefined()
+  })
+
+  it.each([
+    ['no follow-up token', { token: undefined }],
+    ['no interaction id', { id: undefined }],
+    ['no channel', { channel_id: undefined }],
+    ['no application', { application_id: undefined }],
+    ['no invoking user', { member: undefined, user: undefined }],
+  ])('refuses to dispatch a payload with %s', (_label, overrides) => {
+    expect(readDispatchableInteraction(slashCommand(overrides as Partial<ParsedInteraction>), { now })).toBeNull()
+  })
+
+  it('refuses interaction types this provider does not turn into hub messages', () => {
+    expect(readDispatchableInteraction(slashCommand({ type: DiscordInteractionType.PING }), { now })).toBeNull()
+    expect(
+      readDispatchableInteraction(
+        slashCommand({ type: DiscordInteractionType.APPLICATION_COMMAND_AUTOCOMPLETE }),
+        { now },
+      ),
+    ).toBeNull()
+  })
+})
+
+describe('buildInteractionInboundJob', () => {
+  const channel = { channelId: 'ch-1', channelType: 'discord', tenantId: 't-1', organizationId: 'o-1' }
+
+  it('produces the same job shape the gateway worker enqueues, under the matched tenant scope', () => {
+    const dispatch = readDispatchableInteraction(slashCommand(), { now }) as DispatchableInteraction
+    const job = buildInteractionInboundJob({ dispatch, channel })
+
+    expect(job).toMatchObject({
+      providerKey: 'discord',
+      channelId: 'ch-1',
+      channelType: 'discord',
+      scope: { tenantId: 't-1', organizationId: 'o-1' },
+    })
+    expect(job?.raw.eventType).toBe('message')
+  })
+
+  it('normalizes through the adapter path into a hub message keyed on the interaction id', () => {
+    // The point of synthesizing a message object is that the hub's existing
+    // inbound path handles it unchanged — so drive the real normalizer.
+    const dispatch = readDispatchableInteraction(slashCommand(), { now }) as DispatchableInteraction
+    const normalized = normalizeInboundDiscordMessage(buildInteractionMessage(dispatch))
+
+    expect(normalized.externalMessageId).toBe('interaction-1')
+    expect(normalized.externalConversationId).toBe('discord-channel:discord-channel-1')
+    expect(normalized.senderIdentifier).toBe('user-1')
+    expect(normalized.body).toBe('/mercato message:the printer is jammed')
+    expect(normalized.channelMetadata).toMatchObject({
+      discordInteractionId: 'interaction-1',
+      discordInteractionType: DiscordInteractionType.APPLICATION_COMMAND,
+      discordCommandName: 'mercato',
+    })
+  })
+
+  it('drops an interaction invoked by a bot — the same feedback-loop guard as inbound messages', () => {
+    const dispatch = readDispatchableInteraction(
+      slashCommand({ member: { user: { id: 'bot-1', username: 'other-bot' } } }),
+      { now },
+    ) as DispatchableInteraction
+    const botAuthored = { ...dispatch, user: { ...dispatch.user, bot: true } }
+    expect(buildInteractionInboundJob({ dispatch: botAuthored, channel })).toBeNull()
+  })
+})
+
+describe('sendInteractionFollowUp', () => {
+  function restClient(overrides: Partial<DiscordRestClient>): DiscordRestClient {
+    return {
+      editOriginalInteractionResponse: jest.fn(async () => {}),
+      createInteractionFollowUp: jest.fn(async () => {}),
+      ...overrides,
+    } as unknown as DiscordRestClient
+  }
+
+  const input = { applicationId: 'app-1', interactionToken: 'tok', content: 'done', ephemeral: true }
+
+  it('edits the original response, because that is what ends the "thinking" state', async () => {
+    const client = restClient({})
+    await expect(sendInteractionFollowUp(client, input)).resolves.toBe('edited-original')
+    expect(client.editOriginalInteractionResponse).toHaveBeenCalledWith('app-1', 'tok', {
+      content: 'done',
+      ephemeral: true,
+    })
+    expect(client.createInteractionFollowUp).not.toHaveBeenCalled()
+  })
+
+  it('falls back to a follow-up message when the original response is gone', async () => {
+    const client = restClient({
+      editOriginalInteractionResponse: jest.fn(async () => {
+        throw new Error('404 Unknown Webhook')
+      }),
+    })
+    await expect(sendInteractionFollowUp(client, input)).resolves.toBe('follow-up')
+    expect(client.createInteractionFollowUp).toHaveBeenCalledTimes(1)
+  })
+
+  it('rethrows when neither call delivers, so the queue retries inside the token lifetime', async () => {
+    const client = restClient({
+      editOriginalInteractionResponse: jest.fn(async () => {
+        throw new Error('edit failed')
+      }),
+      createInteractionFollowUp: jest.fn(async () => {
+        throw new Error('follow-up failed')
+      }),
+    })
+    await expect(sendInteractionFollowUp(client, input)).rejects.toThrow('edit failed')
+  })
+})
+
+describe('buildInteractionFollowUpContent', () => {
+  it('names the command it recorded', () => {
+    const dispatch = readDispatchableInteraction(slashCommand(), { now }) as DispatchableInteraction
+    const content = buildInteractionFollowUpContent(
+      dispatch,
+      createTranslator({ 'channel_discord.interactions.commandReceived': 'Zapisano /{command}.' }),
+    )
+    expect(content).toBe('Zapisano /mercato.')
+  })
+
+  it('answers in English rather than echoing a key when no dictionary is loaded', () => {
+    const dispatch = readDispatchableInteraction(slashCommand(), { now }) as DispatchableInteraction
+    const content = buildInteractionFollowUpContent(dispatch, createTranslator({}))
+    expect(content).toContain('/mercato')
+    expect(content).not.toContain('channel_discord.interactions')
+  })
+})