agent-messenger 1.0.0

package/tests/commands/channel.test.ts

@@ -0,0 +1,185 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+import { SlackClient } from '../../src/platforms/slack/client'
+import type { SlackChannel } from '../../src/platforms/slack/types'
+
+describe('Channel Commands', () => {
+  let mockClient: SlackClient
+
+  beforeEach(() => {
+    // Mock SlackClient
+    mockClient = {
+      listChannels: mock(async () => [
+        {
+          id: 'C001',
+          name: 'general',
+          is_private: false,
+          is_archived: false,
+          created: 1234567890,
+          creator: 'U001',
+          topic: {
+            value: 'General discussion',
+            creator: 'U001',
+            last_set: 1234567890,
+          },
+          purpose: {
+            value: 'General channel',
+            creator: 'U001',
+            last_set: 1234567890,
+          },
+        },
+        {
+          id: 'C002',
+          name: 'private-team',
+          is_private: true,
+          is_archived: false,
+          created: 1234567891,
+          creator: 'U002',
+        },
+        {
+          id: 'C003',
+          name: 'archived-channel',
+          is_private: false,
+          is_archived: true,
+          created: 1234567892,
+          creator: 'U003',
+        },
+      ]),
+      getChannel: mock(async (id: string) => {
+        const channels: Record<string, SlackChannel> = {
+          C001: {
+            id: 'C001',
+            name: 'general',
+            is_private: false,
+            is_archived: false,
+            created: 1234567890,
+            creator: 'U001',
+            topic: {
+              value: 'General discussion',
+              creator: 'U001',
+              last_set: 1234567890,
+            },
+            purpose: {
+              value: 'General channel',
+              creator: 'U001',
+              last_set: 1234567890,
+            },
+          },
+          C002: {
+            id: 'C002',
+            name: 'private-team',
+            is_private: true,
+            is_archived: false,
+            created: 1234567891,
+            creator: 'U002',
+          },
+        }
+        if (!channels[id]) {
+          throw new Error(`Channel not found: ${id}`)
+        }
+        return channels[id]
+      }),
+    } as any
+  })
+
+  describe('channel list', () => {
+    test('lists all channels', async () => {
+      // Given: SlackClient returns channels
+      // When: Listing channels
+      const channels = await mockClient.listChannels()
+
+      // Then: Should return channels
+      expect(channels).toHaveLength(3)
+      expect(channels[0].name).toBe('general')
+      expect(channels[1].name).toBe('private-team')
+      expect(channels[2].name).toBe('archived-channel')
+    })
+
+    test('excludes archived channels by default', async () => {
+      // Given: SlackClient returns channels including archived
+      const channels = await mockClient.listChannels()
+
+      // When: Filtering out archived (default behavior)
+      const activeChannels = channels.filter((c) => !c.is_archived)
+
+      // Then: Should exclude archived channels
+      expect(activeChannels).toHaveLength(2)
+      expect(activeChannels.every((c) => !c.is_archived)).toBe(true)
+    })
+
+    test('includes archived channels when requested', async () => {
+      // Given: SlackClient returns channels including archived
+      const channels = await mockClient.listChannels()
+
+      // When: Including archived (--include-archived)
+      // Then: Should include all channels
+      expect(channels).toHaveLength(3)
+      expect(channels.some((c) => c.is_archived)).toBe(true)
+    })
+
+    test('filters channels by type=public', async () => {
+      // Given: SlackClient returns mixed channels
+      // When: Filtering by public type
+      const channels = await mockClient.listChannels()
+      const publicChannels = channels.filter((c) => !c.is_private)
+
+      // Then: Should return only public channels
+      expect(publicChannels).toHaveLength(2)
+      expect(publicChannels.every((c) => !c.is_private)).toBe(true)
+    })
+
+    test('filters channels by type=private', async () => {
+      // Given: SlackClient returns mixed channels
+      // When: Filtering by private type
+      const channels = await mockClient.listChannels()
+      const privateChannels = channels.filter((c) => c.is_private)
+
+      // Then: Should return only private channels
+      expect(privateChannels).toHaveLength(1)
+      expect(privateChannels[0].name).toBe('private-team')
+    })
+  })
+
+  describe('channel info', () => {
+    test('gets channel by ID', async () => {
+      // Given: Channel ID C001
+      // When: Getting channel info
+      const channel = await mockClient.getChannel('C001')
+
+      // Then: Should return channel details
+      expect(channel.id).toBe('C001')
+      expect(channel.name).toBe('general')
+      expect(channel.is_private).toBe(false)
+    })
+
+    test('throws error for non-existent channel', async () => {
+      // Given: Non-existent channel ID
+      // When: Getting channel info
+      // Then: Should throw error
+      try {
+        await mockClient.getChannel('C999')
+        expect.unreachable()
+      } catch (error: any) {
+        expect(error.message).toContain('Channel not found')
+      }
+    })
+
+    test('returns channel with topic and purpose', async () => {
+      // Given: Channel with topic and purpose
+      // When: Getting channel info
+      const channel = await mockClient.getChannel('C001')
+
+      // Then: Should include topic and purpose
+      expect(channel.topic?.value).toBe('General discussion')
+      expect(channel.purpose?.value).toBe('General channel')
+    })
+  })
+
+  describe('channel history (alias for message list)', () => {
+    test('history command should be alias for message list', () => {
+      // Given: channel history command
+      // When: Checking command structure
+      // Then: Should be alias for message list
+      expect(true).toBe(true)
+    })
+  })
+})

package/tests/commands/file.test.ts

@@ -0,0 +1,204 @@
+import { beforeEach, describe, expect, mock, test } from 'bun:test'
+import { SlackClient } from '../../src/platforms/slack/client'
+import type { SlackFile } from '../../src/platforms/slack/types'
+
+describe('File Commands', () => {
+  let mockClient: SlackClient
+
+  beforeEach(() => {
+    mockClient = {
+      uploadFile: mock(async (channels: string[], file: Buffer, filename: string) => ({
+        id: 'F123',
+        name: filename,
+        title: filename,
+        mimetype: 'text/plain',
+        size: file.length,
+        url_private: 'https://files.slack.com/files-pri/T123-F123/test.txt',
+        created: Math.floor(Date.now() / 1000),
+        user: 'U123',
+        channels,
+      })),
+      listFiles: mock(async (channel?: string) => [
+        {
+          id: 'F123',
+          name: 'test.txt',
+          title: 'test.txt',
+          mimetype: 'text/plain',
+          size: 1024,
+          url_private: 'https://files.slack.com/files-pri/T123-F123/test.txt',
+          created: 1234567890,
+          user: 'U123',
+          channels: channel ? [channel] : ['C123'],
+        },
+        {
+          id: 'F456',
+          name: 'document.pdf',
+          title: 'document.pdf',
+          mimetype: 'application/pdf',
+          size: 2048,
+          url_private: 'https://files.slack.com/files-pri/T123-F456/document.pdf',
+          created: 1234567891,
+          user: 'U456',
+          channels: channel ? [channel] : ['C456'],
+        },
+      ]),
+    } as any
+  })
+
+  describe('file upload', () => {
+    test('uploads file to channel', async () => {
+      const channel = 'C123'
+      const fileBuffer = Buffer.from('test content')
+      const filename = 'test.txt'
+
+      const result = await mockClient.uploadFile([channel], fileBuffer, filename)
+
+      expect(result.id).toBeDefined()
+      expect(result.name).toBe(filename)
+      expect(result.size).toBe(fileBuffer.length)
+      expect(result.channels).toContain(channel)
+    })
+
+    test('supports --filename override', async () => {
+      const channel = 'C123'
+      const fileBuffer = Buffer.from('content')
+      const customFilename = 'custom-name.txt'
+
+      const result = await mockClient.uploadFile([channel], fileBuffer, customFilename)
+
+      expect(result.name).toBe(customFilename)
+    })
+
+    test('returns file with metadata', () => {
+      const file: SlackFile = {
+        id: 'F123',
+        name: 'test.txt',
+        title: 'test.txt',
+        mimetype: 'text/plain',
+        size: 1024,
+        url_private: 'https://files.slack.com/files-pri/T123-F123/test.txt',
+        created: 1234567890,
+        user: 'U123',
+      }
+
+      const output = { ...file }
+
+      expect(output.id).toBe('F123')
+      expect(output.name).toBe('test.txt')
+    })
+  })
+
+  describe('file list', () => {
+    test('lists all files in workspace', async () => {
+      const files = await mockClient.listFiles()
+
+      expect(files).toHaveLength(2)
+      expect(files[0].name).toBe('test.txt')
+      expect(files[1].name).toBe('document.pdf')
+    })
+
+    test('filters files by channel', async () => {
+      const channel = 'C123'
+
+      const files = await mockClient.listFiles(channel)
+
+      expect(files).toBeDefined()
+      expect(files.length).toBeGreaterThan(0)
+    })
+
+    test('returns files with metadata', () => {
+      const files: SlackFile[] = [
+        {
+          id: 'F123',
+          name: 'test.txt',
+          title: 'test.txt',
+          mimetype: 'text/plain',
+          size: 1024,
+          url_private: 'https://files.slack.com/files-pri/T123-F123/test.txt',
+          created: 1234567890,
+          user: 'U123',
+        },
+        {
+          id: 'F456',
+          name: 'document.pdf',
+          title: 'document.pdf',
+          mimetype: 'application/pdf',
+          size: 2048,
+          url_private: 'https://files.slack.com/files-pri/T123-F456/document.pdf',
+          created: 1234567891,
+          user: 'U456',
+        },
+      ]
+
+      const output = files.map((file) => ({ ...file }))
+
+      expect(output).toHaveLength(2)
+      expect(output[0].name).toBe('test.txt')
+      expect(output[1].name).toBe('document.pdf')
+    })
+  })
+
+  describe('file info', () => {
+    test('shows file details', async () => {
+      const fileId = 'F123'
+
+      const files = await mockClient.listFiles()
+      const file = files.find((f) => f.id === fileId)
+
+      expect(file).toBeDefined()
+      expect(file?.id).toBe(fileId)
+      expect(file?.name).toBe('test.txt')
+    })
+  })
+
+  describe('output formatting', () => {
+    test('includes file fields in output', () => {
+      const file: SlackFile = {
+        id: 'F123',
+        name: 'test.txt',
+        title: 'test.txt',
+        mimetype: 'text/plain',
+        size: 1024,
+        url_private: 'https://files.slack.com/files-pri/T123-F123/test.txt',
+        created: 1234567890,
+        user: 'U123',
+      }
+
+      const output = { ...file }
+
+      expect(output.id).toBeDefined()
+      expect(output.name).toBe('test.txt')
+    })
+
+    test('formats multiple files', () => {
+      const files: SlackFile[] = [
+        {
+          id: 'F123',
+          name: 'test.txt',
+          title: 'test.txt',
+          mimetype: 'text/plain',
+          size: 1024,
+          url_private: 'https://files.slack.com/files-pri/T123-F123/test.txt',
+          created: 1234567890,
+          user: 'U123',
+        },
+        {
+          id: 'F456',
+          name: 'document.pdf',
+          title: 'document.pdf',
+          mimetype: 'application/pdf',
+          size: 2048,
+          url_private: 'https://files.slack.com/files-pri/T123-F456/document.pdf',
+          created: 1234567891,
+          user: 'U456',
+        },
+      ]
+
+      const output = files.map((file) => ({ ...file }))
+
+      expect(output).toHaveLength(2)
+      expect(output[0].name).toBe('test.txt')
+      expect(output[1].name).toBe('document.pdf')
+    })
+  })
+})