@onmars/lunar-discord 0.1.0

package/src/__tests__/adapter.test.ts

@@ -0,0 +1,919 @@
+/**
+ * # Discord Channel Adapter — Functional Specification
+ *
+ * Tests the Discord adapter's logic without real Discord connections.
+ *
+ * ## DiscordChannel constructor
+ * Creates a discord.js Client with Guilds, GuildMessages, MessageContent, DirectMessages intents.
+ * Stores options: token, guildId, allowedUsers, allowedChannels.
+ *
+ * ## isConnected()
+ * Returns the internal connected flag (set by connect/disconnect/shard events).
+ *
+ * ## onMessage(handler)
+ * Stores the handler for incoming messages.
+ *
+ * ## send(target, content)
+ * Returns undefined if disconnected. Otherwise:
+ * - Fetches channel by ID, formats text via formatForDiscord, splits via splitMessage.
+ * - Converts attachments (Buffer or base64 string → Buffer).
+ * - Sends chunks, with reply on first chunk and files on last chunk.
+ * - Returns last message ID.
+ *
+ * ## sendTyping(target)
+ * No-op if disconnected. Otherwise sends typing indicator.
+ * Swallows errors (best effort).
+ *
+ * ## inferAttachmentType(contentType)
+ * Maps MIME prefixes to attachment type: image/, audio/, video/ → respective types.
+ * null/undefined/unknown → 'file'.
+ *
+ * ## Message filtering (setupMessageListener)
+ * Ignores: bots, wrong guild, non-allowed channels, non-allowed users, empty messages.
+ * Builds IncomingMessage from Discord.js Message.
+ *
+ * ## Testing approach:
+ * We test inferAttachmentType and send/sendTyping logic by accessing internals.
+ * For the message listener, we test filtering logic via the adapter's methods.
+ */
+import { afterEach, beforeEach, describe, expect, it, mock, spyOn } from 'bun:test'
+import { DiscordChannel, type DiscordChannelOptions } from '../adapter'
+
+// ─── Helpers ────────────────────────────────────────────────────────
+
+const defaultOptions: DiscordChannelOptions = {
+  token: 'fake-bot-token',
+  guildId: 'guild_123',
+}
+
+function createAdapter(overrides: Partial<DiscordChannelOptions> = {}): DiscordChannel {
+  return new DiscordChannel({ ...defaultOptions, ...overrides })
+}
+
+// ═══════════════════════════════════════════════════════════════════
+// Constructor and metadata
+// ═══════════════════════════════════════════════════════════════════
+
+describe('DiscordChannel — metadata', () => {
+  it('defaults id and name to "discord" when not specified', () => {
+    const adapter = createAdapter()
+    expect(adapter.id).toBe('discord')
+    expect(adapter.name).toBe('discord')
+  })
+
+  it('uses custom id when provided in options', () => {
+    const adapter = createAdapter({ id: 'discord:hermes' })
+    expect(adapter.id).toBe('discord:hermes')
+    expect(adapter.name).toBe('discord:hermes')
+  })
+
+  it('uses custom id for different account names', () => {
+    const athena = createAdapter({ id: 'discord:athena' })
+    expect(athena.id).toBe('discord:athena')
+
+    const themis = createAdapter({ id: 'discord:themis' })
+    expect(themis.id).toBe('discord:themis')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// isConnected — Connection state
+// ═══════════════════════════════════════════════════════════════════
+
+describe('DiscordChannel — isConnected', () => {
+  it('starts disconnected', () => {
+    const adapter = createAdapter()
+    expect(adapter.isConnected()).toBe(false)
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// onMessage — Handler registration
+// ═══════════════════════════════════════════════════════════════════
+
+describe('DiscordChannel — onMessage', () => {
+  it('stores the message handler', () => {
+    const adapter = createAdapter()
+    const handler = mock(async () => {})
+
+    adapter.onMessage(handler)
+
+    // Verify handler is stored by accessing internal state
+    expect((adapter as any).messageHandler).toBe(handler)
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// send — Message sending (when disconnected)
+// ═══════════════════════════════════════════════════════════════════
+
+describe('DiscordChannel — send (disconnected)', () => {
+  it('returns undefined when not connected', async () => {
+    const adapter = createAdapter()
+    const result = await adapter.send('channel_123', { text: 'Hello' })
+
+    expect(result).toBeUndefined()
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// send — Message sending (when connected, with mocked client)
+// ═══════════════════════════════════════════════════════════════════
+
+describe('DiscordChannel — send (connected)', () => {
+  it('sends formatted text to the target channel', async () => {
+    const adapter = createAdapter()
+    // Force connected state
+    ;(adapter as any).connected = true
+
+    const sentMessages: any[] = []
+    const mockChannel = {
+      isTextBased: () => true,
+      send: mock(async (opts: any) => {
+        sentMessages.push(opts)
+        return { id: 'msg_' + sentMessages.length }
+      }),
+    }
+
+    // Mock client.channels.fetch
+    ;(adapter as any).client = {
+      channels: {
+        fetch: mock(async () => mockChannel),
+      },
+    }
+
+    const result = await adapter.send('channel_123', { text: 'Hello world' })
+
+    expect(result).toBe('msg_1')
+    expect(sentMessages).toHaveLength(1)
+    expect(sentMessages[0].content).toBe('Hello world')
+  })
+
+  it('splits long messages and sends multiple chunks', async () => {
+    const adapter = createAdapter()
+    ;(adapter as any).connected = true
+
+    const sentMessages: any[] = []
+    const mockChannel = {
+      isTextBased: () => true,
+      send: mock(async (opts: any) => {
+        sentMessages.push(opts)
+        return { id: 'msg_' + sentMessages.length }
+      }),
+    }
+
+    ;(adapter as any).client = {
+      channels: {
+        fetch: mock(async () => mockChannel),
+      },
+    }
+
+    // Create text longer than 2000 chars
+    const longText = 'a'.repeat(3000)
+    const result = await adapter.send('channel_123', { text: longText })
+
+    expect(sentMessages.length).toBeGreaterThanOrEqual(2)
+    // Returns last message ID
+    expect(result).toBe('msg_' + sentMessages.length)
+  })
+
+  it('includes reply on first chunk only', async () => {
+    const adapter = createAdapter()
+    ;(adapter as any).connected = true
+
+    const sentMessages: any[] = []
+    const mockChannel = {
+      isTextBased: () => true,
+      send: mock(async (opts: any) => {
+        sentMessages.push(opts)
+        return { id: 'msg_' + sentMessages.length }
+      }),
+    }
+
+    ;(adapter as any).client = {
+      channels: {
+        fetch: mock(async () => mockChannel),
+      },
+    }
+
+    const longText = 'a'.repeat(3000)
+    await adapter.send('channel_123', { text: longText, replyTo: 'original_msg_id' })
+
+    // First chunk has reply
+    expect(sentMessages[0].reply).toEqual({
+      messageReference: 'original_msg_id',
+      failIfNotExists: false,
+    })
+    // Subsequent chunks should not have reply
+    for (let i = 1; i < sentMessages.length; i++) {
+      expect(sentMessages[i].reply).toBeUndefined()
+    }
+  })
+
+  it('attaches files to the last chunk', async () => {
+    const adapter = createAdapter()
+    ;(adapter as any).connected = true
+
+    const sentMessages: any[] = []
+    const mockChannel = {
+      isTextBased: () => true,
+      send: mock(async (opts: any) => {
+        sentMessages.push(opts)
+        return { id: 'msg_' + sentMessages.length }
+      }),
+    }
+
+    ;(adapter as any).client = {
+      channels: {
+        fetch: mock(async () => mockChannel),
+      },
+    }
+
+    const longText = 'a'.repeat(3000)
+    await adapter.send('channel_123', {
+      text: longText,
+      attachments: [
+        {
+          type: 'audio',
+          data: Buffer.from('audio-data'),
+          filename: 'voice.mp3',
+          mimeType: 'audio/mpeg',
+        },
+      ],
+    })
+
+    // Only last chunk has files
+    const lastChunk = sentMessages[sentMessages.length - 1]
+    expect(lastChunk.files).toHaveLength(1)
+    expect(lastChunk.files[0].name).toBe('voice.mp3')
+
+    // First chunk should NOT have files
+    if (sentMessages.length > 1) {
+      expect(sentMessages[0].files).toBeUndefined()
+    }
+  })
+
+  it('converts base64 attachment data to Buffer', async () => {
+    const adapter = createAdapter()
+    ;(adapter as any).connected = true
+
+    const sentMessages: any[] = []
+    const mockChannel = {
+      isTextBased: () => true,
+      send: mock(async (opts: any) => {
+        sentMessages.push(opts)
+        return { id: 'msg_1' }
+      }),
+    }
+
+    ;(adapter as any).client = {
+      channels: {
+        fetch: mock(async () => mockChannel),
+      },
+    }
+
+    const base64Data = Buffer.from('hello').toString('base64')
+    await adapter.send('channel_123', {
+      text: 'File attached',
+      attachments: [{ type: 'file', data: base64Data, filename: 'data.txt' }],
+    })
+
+    const file = sentMessages[0].files[0]
+    expect(file.attachment).toBeInstanceOf(Buffer)
+    expect(file.name).toBe('data.txt')
+  })
+
+  it('returns undefined for non-text-based channel', async () => {
+    const adapter = createAdapter()
+    ;(adapter as any).connected = true
+
+    const mockChannel = {
+      isTextBased: () => false,
+    }
+
+    ;(adapter as any).client = {
+      channels: {
+        fetch: mock(async () => mockChannel),
+      },
+    }
+
+    const result = await adapter.send('channel_123', { text: 'Hello' })
+    expect(result).toBeUndefined()
+  })
+
+  it('returns undefined when channel is null', async () => {
+    const adapter = createAdapter()
+    ;(adapter as any).connected = true
+
+    ;(adapter as any).client = {
+      channels: {
+        fetch: mock(async () => null),
+      },
+    }
+
+    const result = await adapter.send('nonexistent', { text: 'Hello' })
+    expect(result).toBeUndefined()
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// sendTyping — Typing indicator
+// ═══════════════════════════════════════════════════════════════════
+
+describe('DiscordChannel — sendTyping', () => {
+  it('does nothing when disconnected', async () => {
+    const adapter = createAdapter()
+    // Should not throw
+    await adapter.sendTyping('channel_123')
+  })
+
+  it('calls channel.sendTyping when connected', async () => {
+    const adapter = createAdapter()
+    ;(adapter as any).connected = true
+
+    const sendTypingMock = mock(async () => {})
+    const mockChannel = {
+      isTextBased: () => true,
+      sendTyping: sendTypingMock,
+    }
+
+    ;(adapter as any).client = {
+      channels: {
+        fetch: mock(async () => mockChannel),
+      },
+    }
+
+    await adapter.sendTyping('channel_123')
+    expect(sendTypingMock).toHaveBeenCalledTimes(1)
+  })
+
+  it('swallows errors gracefully', async () => {
+    const adapter = createAdapter()
+    ;(adapter as any).connected = true
+
+    ;(adapter as any).client = {
+      channels: {
+        fetch: mock(async () => {
+          throw new Error('Channel not accessible')
+        }),
+      },
+    }
+
+    // Should not throw
+    await adapter.sendTyping('channel_123')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// inferAttachmentType — MIME type to attachment type mapping
+// ═══════════════════════════════════════════════════════════════════
+
+describe('DiscordChannel — inferAttachmentType', () => {
+  it('maps image/* to "image"', () => {
+    const adapter = createAdapter()
+    const infer = (adapter as any).inferAttachmentType.bind(adapter)
+
+    expect(infer('image/png')).toBe('image')
+    expect(infer('image/jpeg')).toBe('image')
+    expect(infer('image/gif')).toBe('image')
+    expect(infer('image/webp')).toBe('image')
+  })
+
+  it('maps audio/* to "audio"', () => {
+    const adapter = createAdapter()
+    const infer = (adapter as any).inferAttachmentType.bind(adapter)
+
+    expect(infer('audio/ogg')).toBe('audio')
+    expect(infer('audio/mpeg')).toBe('audio')
+    expect(infer('audio/wav')).toBe('audio')
+  })
+
+  it('maps video/* to "video"', () => {
+    const adapter = createAdapter()
+    const infer = (adapter as any).inferAttachmentType.bind(adapter)
+
+    expect(infer('video/mp4')).toBe('video')
+    expect(infer('video/webm')).toBe('video')
+  })
+
+  it('maps null/undefined to "file"', () => {
+    const adapter = createAdapter()
+    const infer = (adapter as any).inferAttachmentType.bind(adapter)
+
+    expect(infer(null)).toBe('file')
+    expect(infer(undefined)).toBe('file')
+  })
+
+  it('maps unknown MIME types to "file"', () => {
+    const adapter = createAdapter()
+    const infer = (adapter as any).inferAttachmentType.bind(adapter)
+
+    expect(infer('application/pdf')).toBe('file')
+    expect(infer('text/plain')).toBe('file')
+    expect(infer('application/json')).toBe('file')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// parseAttachments — Discord.js attachment conversion
+// ═══════════════════════════════════════════════════════════════════
+
+describe('DiscordChannel — parseAttachments', () => {
+  it('converts discord.js attachment collection to Attachment array', () => {
+    const adapter = createAdapter()
+    const parse = (adapter as any).parseAttachments.bind(adapter)
+
+    // Mock a discord.js Message with attachments
+    const mockMsg = {
+      attachments: {
+        map: (fn: any) =>
+          [
+            {
+              contentType: 'image/png',
+              url: 'https://cdn.discord.com/test.png',
+              name: 'screenshot.png',
+              size: 12345,
+            },
+            {
+              contentType: 'audio/ogg',
+              url: 'https://cdn.discord.com/voice.ogg',
+              name: 'voice.ogg',
+              size: 67890,
+            },
+          ].map(fn),
+      },
+    }
+
+    const result = parse(mockMsg)
+
+    expect(result).toHaveLength(2)
+    expect(result[0]).toEqual({
+      type: 'image',
+      url: 'https://cdn.discord.com/test.png',
+      filename: 'screenshot.png',
+      mimeType: 'image/png',
+      size: 12345,
+    })
+    expect(result[1]).toEqual({
+      type: 'audio',
+      url: 'https://cdn.discord.com/voice.ogg',
+      filename: 'voice.ogg',
+      mimeType: 'audio/ogg',
+      size: 67890,
+    })
+  })
+
+  it('handles attachments with null name and contentType', () => {
+    const adapter = createAdapter()
+    const parse = (adapter as any).parseAttachments.bind(adapter)
+
+    const mockMsg = {
+      attachments: {
+        map: (fn: any) =>
+          [
+            {
+              contentType: null,
+              url: 'https://cdn.discord.com/unknown',
+              name: null,
+              size: 100,
+            },
+          ].map(fn),
+      },
+    }
+
+    const result = parse(mockMsg)
+
+    expect(result).toHaveLength(1)
+    expect(result[0].type).toBe('file')
+    expect(result[0].filename).toBeUndefined()
+    expect(result[0].mimeType).toBeUndefined()
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// edit — Message editing
+// ═══════════════════════════════════════════════════════════════════
+
+describe('DiscordChannel — edit', () => {
+  it('does nothing when disconnected', async () => {
+    const adapter = createAdapter()
+    // Should not throw
+    await adapter.edit!('msg_123', 'channel_123', { text: 'Updated' })
+  })
+
+  it('edits message content when connected', async () => {
+    const adapter = createAdapter()
+    ;(adapter as any).connected = true
+
+    const editMock = mock(async () => {})
+    const mockChannel = {
+      isTextBased: () => true,
+      messages: {
+        fetch: mock(async () => ({ edit: editMock })),
+      },
+    }
+
+    ;(adapter as any).client = {
+      channels: {
+        fetch: mock(async () => mockChannel),
+      },
+    }
+
+    await adapter.edit!('msg_123', 'channel_123', { text: 'Updated text' })
+    expect(editMock).toHaveBeenCalledTimes(1)
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// delete — Message deletion
+// ═══════════════════════════════════════════════════════════════════
+
+describe('DiscordChannel — delete', () => {
+  it('does nothing when disconnected', async () => {
+    const adapter = createAdapter()
+    await adapter.delete!('msg_123', 'channel_123')
+  })
+
+  it('deletes message when connected', async () => {
+    const adapter = createAdapter()
+    ;(adapter as any).connected = true
+
+    const deleteMock = mock(async () => {})
+    const mockChannel = {
+      isTextBased: () => true,
+      messages: {
+        fetch: mock(async () => ({ delete: deleteMock })),
+      },
+    }
+
+    ;(adapter as any).client = {
+      channels: {
+        fetch: mock(async () => mockChannel),
+      },
+    }
+
+    await adapter.delete!('msg_123', 'channel_123')
+    expect(deleteMock).toHaveBeenCalledTimes(1)
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// react — Message reaction
+// ═══════════════════════════════════════════════════════════════════
+
+describe('DiscordChannel — react', () => {
+  it('does nothing when disconnected', async () => {
+    const adapter = createAdapter()
+    await adapter.react!('msg_123', 'channel_123', '👍')
+  })
+
+  it('reacts to message when connected', async () => {
+    const adapter = createAdapter()
+    ;(adapter as any).connected = true
+
+    const reactMock = mock(async () => {})
+    const mockChannel = {
+      isTextBased: () => true,
+      messages: {
+        fetch: mock(async () => ({ react: reactMock })),
+      },
+    }
+
+    ;(adapter as any).client = {
+      channels: {
+        fetch: mock(async () => mockChannel),
+      },
+    }
+
+    await adapter.react!('msg_123', 'channel_123', '🚀')
+    expect(reactMock).toHaveBeenCalledWith('🚀')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// disconnect — Cleanup
+// ═══════════════════════════════════════════════════════════════════
+
+describe('DiscordChannel — disconnect', () => {
+  it('sets connected to false and destroys client', async () => {
+    const adapter = createAdapter()
+    ;(adapter as any).connected = true
+
+    const destroyMock = mock(() => {})
+    ;(adapter as any).client = { destroy: destroyMock }
+
+    await adapter.disconnect()
+
+    expect(adapter.isConnected()).toBe(false)
+    expect(destroyMock).toHaveBeenCalledTimes(1)
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// connect — Event listener setup and client.login
+// ═══════════════════════════════════════════════════════════════════
+
+describe('DiscordChannel — connect', () => {
+  /**
+   * Build a mock discord.js Client that supports once/on/login.
+   * login() triggers the 'ready' event on the next microtask by default.
+   */
+  /**
+   * Build a mock discord.js Client that supports once/on/login.
+   *
+   * Events.ClientReady = 'clientReady', Events.Error = 'error',
+   * Events.MessageCreate = 'messageCreate', etc.
+   * login() triggers the 'clientReady' event on the next microtask by default.
+   */
+  function buildMockClient(
+    opts: { loginBehavior?: 'ready' | 'error' | 'throw'; errorMessage?: string } = {},
+  ) {
+    const { loginBehavior = 'ready', errorMessage = 'Connection failed' } = opts
+    const onceListeners: Record<string, Function> = {}
+    const onListeners: string[] = []
+
+    const client = {
+      once: mock((event: string, handler: Function) => {
+        onceListeners[event] = handler
+      }),
+      on: mock((event: string, _fn: Function) => {
+        onListeners.push(event)
+      }),
+      login: mock(async (token: string) => {
+        if (loginBehavior === 'throw') {
+          throw new Error(errorMessage)
+        }
+        // Use queueMicrotask to fire event after login() returns
+        // but before the Promise chain resolves
+        queueMicrotask(() => {
+          if (loginBehavior === 'ready') {
+            // Events.ClientReady = 'clientReady' in discord.js
+            onceListeners['clientReady']?.({
+              user: { tag: 'Bot#0001' },
+              guilds: { cache: { size: 1 } },
+            })
+          } else if (loginBehavior === 'error') {
+            // Events.Error = 'error' in discord.js
+            onceListeners['error']?.(new Error(errorMessage))
+          }
+        })
+      }),
+    }
+
+    return { client, onceListeners, onListeners }
+  }
+
+  it('calls client.login with the configured token', async () => {
+    const adapter = createAdapter({ token: 'my-test-token' })
+    const { client } = buildMockClient()
+    ;(adapter as any).client = client
+
+    await adapter.connect()
+
+    expect(client.login).toHaveBeenCalledWith('my-test-token')
+  })
+
+  it('sets connected=true after ClientReady fires', async () => {
+    const adapter = createAdapter()
+    const { client } = buildMockClient()
+    ;(adapter as any).client = client
+
+    await adapter.connect()
+
+    expect(adapter.isConnected()).toBe(true)
+  })
+
+  it('rejects when client.login throws', async () => {
+    const adapter = createAdapter()
+    const { client } = buildMockClient({ loginBehavior: 'throw', errorMessage: 'Invalid token' })
+    ;(adapter as any).client = client
+
+    await expect(adapter.connect()).rejects.toThrow('Invalid token')
+  })
+
+  it('rejects when Error event fires before ClientReady', async () => {
+    const adapter = createAdapter()
+    const { client } = buildMockClient({
+      loginBehavior: 'error',
+      errorMessage: 'Gateway unavailable',
+    })
+    ;(adapter as any).client = client
+
+    await expect(adapter.connect()).rejects.toThrow('Gateway unavailable')
+  })
+
+  it('calls setupMessageListener and setupLifecycleListeners on ready', async () => {
+    const adapter = createAdapter()
+    const { client, onListeners } = buildMockClient()
+    ;(adapter as any).client = client
+
+    await adapter.connect()
+
+    // setupMessageListener registers on messageCreate
+    // setupLifecycleListeners registers on error, warn, shardDisconnect, shardReconnecting, shardResume, shardReady
+    expect(onListeners).toContain('messageCreate')
+    expect(onListeners).toContain('error')
+    expect(onListeners).toContain('warn')
+    expect(onListeners).toContain('shardDisconnect')
+    expect(onListeners).toContain('shardReconnecting')
+    expect(onListeners).toContain('shardResume')
+    expect(onListeners).toContain('shardReady')
+  })
+})
+
+// ═══════════════════════════════════════════════════════════════════
+// setupMessageListener — Message filtering logic
+// ═══════════════════════════════════════════════════════════════════
+
+describe('DiscordChannel — message filtering (setupMessageListener)', () => {
+  function setupAdapterWithListener(overrides: Partial<DiscordChannelOptions> = {}) {
+    const adapter = createAdapter(overrides)
+    const handler = mock(async (_msg: any) => {})
+    adapter.onMessage(handler)
+
+    // Manually call setupMessageListener
+    const messageListeners: Record<string, Function> = {}
+    ;(adapter as any).client = {
+      on: mock((event: string, fn: Function) => {
+        messageListeners[event] = fn
+      }),
+    }
+    ;(adapter as any).setupMessageListener()
+
+    return { adapter, handler, fireMessage: messageListeners['messageCreate'] }
+  }
+
+  function fakeMessage(
+    overrides: Partial<{
+      bot: boolean
+      guildId: string
+      channelId: string
+      authorId: string
+      content: string
+      attachmentSize: number
+    }> = {},
+  ) {
+    return {
+      id: 'msg_test_123',
+      author: {
+        bot: overrides.bot ?? false,
+        id: overrides.authorId ?? 'user_1',
+        displayName: 'TestUser',
+        username: 'testuser',
+      },
+      guildId: overrides.guildId ?? 'guild_123',
+      channelId: overrides.channelId ?? 'channel_1',
+      content: overrides.content ?? 'Hello!',
+      attachments: {
+        size: overrides.attachmentSize ?? 0,
+        map: (fn: any) => [],
+      },
+      member: { displayName: 'TestMember' },
+      reference: undefined,
+      createdAt: new Date(),
+    }
+  }
+
+  it('ignores bot messages', async () => {
+    const { handler, fireMessage } = setupAdapterWithListener()
+
+    await fireMessage(fakeMessage({ bot: true }))
+
+    expect(handler).not.toHaveBeenCalled()
+  })
+
+  it('ignores messages from wrong guild', async () => {
+    const { handler, fireMessage } = setupAdapterWithListener({ guildId: 'guild_123' })
+
+    await fireMessage(fakeMessage({ guildId: 'guild_999' }))
+
+    expect(handler).not.toHaveBeenCalled()
+  })
+
+  it('passes messages from the correct guild', async () => {
+    const { handler, fireMessage } = setupAdapterWithListener({ guildId: 'guild_123' })
+
+    await fireMessage(fakeMessage({ guildId: 'guild_123' }))
+
+    expect(handler).toHaveBeenCalledTimes(1)
+  })
+
+  it('filters by allowedChannels when set', async () => {
+    const { handler, fireMessage } = setupAdapterWithListener({
+      allowedChannels: ['channel_A', 'channel_B'],
+    })
+
+    // Blocked channel
+    await fireMessage(fakeMessage({ channelId: 'channel_X' }))
+    expect(handler).not.toHaveBeenCalled()
+
+    // Allowed channel
+    await fireMessage(fakeMessage({ channelId: 'channel_A' }))
+    expect(handler).toHaveBeenCalledTimes(1)
+  })
+
+  it('allows all channels when allowedChannels is empty', async () => {
+    const { handler, fireMessage } = setupAdapterWithListener({
+      allowedChannels: [],
+    })
+
+    await fireMessage(fakeMessage({ channelId: 'any_channel' }))
+    expect(handler).toHaveBeenCalledTimes(1)
+  })
+
+  it('filters by allowedUsers when set', async () => {
+    const { handler, fireMessage } = setupAdapterWithListener({
+      allowedUsers: ['user_mars'],
+    })
+
+    // Blocked user
+    await fireMessage(fakeMessage({ authorId: 'user_random' }))
+    expect(handler).not.toHaveBeenCalled()
+
+    // Allowed user
+    await fireMessage(fakeMessage({ authorId: 'user_mars' }))
+    expect(handler).toHaveBeenCalledTimes(1)
+  })
+
+  it('allows all users when allowedUsers is empty', async () => {
+    const { handler, fireMessage } = setupAdapterWithListener({
+      allowedUsers: [],
+    })
+
+    await fireMessage(fakeMessage({ authorId: 'any_user' }))
+    expect(handler).toHaveBeenCalledTimes(1)
+  })
+
+  it('ignores empty messages with no attachments', async () => {
+    const { handler, fireMessage } = setupAdapterWithListener()
+
+    await fireMessage(fakeMessage({ content: '', attachmentSize: 0 }))
+    expect(handler).not.toHaveBeenCalled()
+
+    await fireMessage(fakeMessage({ content: '   ', attachmentSize: 0 }))
+    expect(handler).not.toHaveBeenCalled()
+  })
+
+  it('accepts empty content when attachments are present', async () => {
+    const { handler, fireMessage } = setupAdapterWithListener()
+
+    await fireMessage(fakeMessage({ content: '', attachmentSize: 1 }))
+    expect(handler).toHaveBeenCalledTimes(1)
+  })
+
+  it('builds correct IncomingMessage from Discord message', async () => {
+    const { handler, fireMessage } = setupAdapterWithListener()
+
+    const msg = fakeMessage({ content: 'Test message', authorId: 'user_42' })
+    msg.reference = { messageId: 'reply_ref_123' } as any
+
+    await fireMessage(msg)
+
+    expect(handler).toHaveBeenCalledTimes(1)
+    const incoming = handler.mock.calls[0]![0] as any
+    expect(incoming.id).toBe('msg_test_123')
+    expect(incoming.sender.id).toBe('user_42')
+    expect(incoming.sender.name).toBe('TestMember')
+    expect(incoming.sender.username).toBe('testuser')
+    expect(incoming.text).toBe('Test message')
+    expect(incoming.replyTo).toBe('reply_ref_123')
+    expect(incoming.raw).toBe(msg)
+  })
+
+  it('catches errors from message handler without crashing', async () => {
+    const adapter = createAdapter()
+    const errorHandler = mock(async () => {
+      throw new Error('Handler exploded')
+    })
+    adapter.onMessage(errorHandler)
+
+    const messageListeners: Record<string, Function> = {}
+    ;(adapter as any).client = {
+      on: mock((event: string, fn: Function) => {
+        messageListeners[event] = fn
+      }),
+    }
+    ;(adapter as any).setupMessageListener()
+
+    // Should not throw even though handler errors
+    await messageListeners['messageCreate'](fakeMessage())
+
+    expect(errorHandler).toHaveBeenCalledTimes(1)
+  })
+
+  it('does nothing when no handler is registered', async () => {
+    const adapter = createAdapter()
+    // Do NOT register any handler via onMessage()
+
+    const messageListeners: Record<string, Function> = {}
+    ;(adapter as any).client = {
+      on: mock((event: string, fn: Function) => {
+        messageListeners[event] = fn
+      }),
+    }
+    ;(adapter as any).setupMessageListener()
+
+    // Should not throw when no handler is set
+    await messageListeners['messageCreate'](fakeMessage())
+  })
+})