agent-messenger 2.10.1 → 2.11.0

package/src/platforms/slack/types.test.ts

@@ -1,4 +1,4 @@
-import { expect, test } from 'bun:test'
+import { expect, it } from 'bun:test'
 
 import {
   ConfigSchema,
@@ -10,7 +10,7 @@ import {
   WorkspaceCredentialsSchema,
 } from '@/platforms/slack/types'
 
-test('SlackChannelSchema validates correct data', () => {
+it('SlackChannelSchema validates correct data', () => {
   const validChannel = {
     id: 'C123456',
     name: 'general',
@@ -22,7 +22,7 @@ test('SlackChannelSchema validates correct data', () => {
   expect(() => SlackChannelSchema.parse(validChannel)).not.toThrow()
 })
 
-test('SlackChannelSchema validates with optional fields', () => {
+it('SlackChannelSchema validates with optional fields', () => {
   const validChannel = {
     id: 'C123456',
     name: 'general',
@@ -44,7 +44,7 @@ test('SlackChannelSchema validates with optional fields', () => {
   expect(() => SlackChannelSchema.parse(validChannel)).not.toThrow()
 })
 
-test('SlackChannelSchema rejects missing required fields', () => {
+it('SlackChannelSchema rejects missing required fields', () => {
   const invalidChannel = {
     id: 'C123456',
     name: 'general',
@@ -52,7 +52,7 @@ test('SlackChannelSchema rejects missing required fields', () => {
   expect(() => SlackChannelSchema.parse(invalidChannel)).toThrow()
 })
 
-test('SlackMessageSchema validates correct data', () => {
+it('SlackMessageSchema validates correct data', () => {
   const validMessage = {
     ts: '1234567890.123456',
     text: 'Hello world',
@@ -61,7 +61,7 @@ test('SlackMessageSchema validates correct data', () => {
   expect(() => SlackMessageSchema.parse(validMessage)).not.toThrow()
 })
 
-test('SlackMessageSchema validates with optional fields', () => {
+it('SlackMessageSchema validates with optional fields', () => {
   const validMessage = {
     ts: '1234567890.123456',
     text: 'Hello world',
@@ -79,7 +79,7 @@ test('SlackMessageSchema validates with optional fields', () => {
   expect(() => SlackMessageSchema.parse(validMessage)).not.toThrow()
 })
 
-test('SlackMessageSchema validates with files', () => {
+it('SlackMessageSchema validates with files', () => {
   const validMessage = {
     ts: '1234567890.123456',
     text: 'Hello world',
@@ -102,14 +102,14 @@ test('SlackMessageSchema validates with files', () => {
   expect(() => SlackMessageSchema.parse(validMessage)).not.toThrow()
 })
 
-test('SlackMessageSchema rejects missing required fields', () => {
+it('SlackMessageSchema rejects missing required fields', () => {
   const invalidMessage = {
     ts: '1234567890.123456',
   }
   expect(() => SlackMessageSchema.parse(invalidMessage)).toThrow()
 })
 
-test('SlackUserSchema validates correct data', () => {
+it('SlackUserSchema validates correct data', () => {
   const validUser = {
     id: 'U123456',
     name: 'john',
@@ -122,7 +122,7 @@ test('SlackUserSchema validates correct data', () => {
   expect(() => SlackUserSchema.parse(validUser)).not.toThrow()
 })
 
-test('SlackUserSchema validates with optional profile', () => {
+it('SlackUserSchema validates with optional profile', () => {
   const validUser = {
     id: 'U123456',
     name: 'john',
@@ -141,7 +141,7 @@ test('SlackUserSchema validates with optional profile', () => {
   expect(() => SlackUserSchema.parse(validUser)).not.toThrow()
 })
 
-test('SlackUserSchema rejects missing required fields', () => {
+it('SlackUserSchema rejects missing required fields', () => {
   const invalidUser = {
     id: 'U123456',
     name: 'john',
@@ -149,7 +149,7 @@ test('SlackUserSchema rejects missing required fields', () => {
   expect(() => SlackUserSchema.parse(invalidUser)).toThrow()
 })
 
-test('SlackReactionSchema validates correct data', () => {
+it('SlackReactionSchema validates correct data', () => {
   const validReaction = {
     name: 'thumbsup',
     count: 3,
@@ -158,7 +158,7 @@ test('SlackReactionSchema validates correct data', () => {
   expect(() => SlackReactionSchema.parse(validReaction)).not.toThrow()
 })
 
-test('SlackReactionSchema rejects invalid data', () => {
+it('SlackReactionSchema rejects invalid data', () => {
   const invalidReaction = {
     name: 'thumbsup',
     count: 'three',
@@ -167,7 +167,7 @@ test('SlackReactionSchema rejects invalid data', () => {
   expect(() => SlackReactionSchema.parse(invalidReaction)).toThrow()
 })
 
-test('SlackFileSchema validates correct data', () => {
+it('SlackFileSchema validates correct data', () => {
   const validFile = {
     id: 'F123456',
     name: 'document.pdf',
@@ -181,7 +181,7 @@ test('SlackFileSchema validates correct data', () => {
   expect(() => SlackFileSchema.parse(validFile)).not.toThrow()
 })
 
-test('SlackFileSchema validates with optional channels', () => {
+it('SlackFileSchema validates with optional channels', () => {
   const validFile = {
     id: 'F123456',
     name: 'document.pdf',
@@ -196,7 +196,7 @@ test('SlackFileSchema validates with optional channels', () => {
   expect(() => SlackFileSchema.parse(validFile)).not.toThrow()
 })
 
-test('SlackFileSchema rejects missing required fields', () => {
+it('SlackFileSchema rejects missing required fields', () => {
   const invalidFile = {
     id: 'F123456',
     name: 'document.pdf',
@@ -204,7 +204,7 @@ test('SlackFileSchema rejects missing required fields', () => {
   expect(() => SlackFileSchema.parse(invalidFile)).toThrow()
 })
 
-test('WorkspaceCredentialsSchema validates correct data', () => {
+it('WorkspaceCredentialsSchema validates correct data', () => {
   const validCredentials = {
     workspace_id: 'T123456',
     workspace_name: 'my-workspace',
@@ -214,7 +214,7 @@ test('WorkspaceCredentialsSchema validates correct data', () => {
   expect(() => WorkspaceCredentialsSchema.parse(validCredentials)).not.toThrow()
 })
 
-test('WorkspaceCredentialsSchema rejects missing fields', () => {
+it('WorkspaceCredentialsSchema rejects missing fields', () => {
   const invalidCredentials = {
     workspace_id: 'T123456',
     workspace_name: 'my-workspace',
@@ -222,7 +222,7 @@ test('WorkspaceCredentialsSchema rejects missing fields', () => {
   expect(() => WorkspaceCredentialsSchema.parse(invalidCredentials)).toThrow()
 })
 
-test('ConfigSchema validates correct data', () => {
+it('ConfigSchema validates correct data', () => {
   const validConfig = {
     current_workspace: 'T123456',
     workspaces: {
@@ -237,7 +237,7 @@ test('ConfigSchema validates correct data', () => {
   expect(() => ConfigSchema.parse(validConfig)).not.toThrow()
 })
 
-test('ConfigSchema validates with null current_workspace', () => {
+it('ConfigSchema validates with null current_workspace', () => {
   const validConfig = {
     current_workspace: null,
     workspaces: {
@@ -252,7 +252,7 @@ test('ConfigSchema validates with null current_workspace', () => {
   expect(() => ConfigSchema.parse(validConfig)).not.toThrow()
 })
 
-test('ConfigSchema rejects invalid workspace credentials', () => {
+it('ConfigSchema rejects invalid workspace credentials', () => {
   const invalidConfig = {
     current_workspace: 'T123456',
     workspaces: {

package/src/platforms/slackbot/cli.ts

@@ -6,6 +6,7 @@ import pkg from '../../../package.json' with { type: 'json' }
 import {
   authCommand,
   channelCommand,
+  fileCommand,
   messageCommand,
   reactionCommand,
   userCommand,
@@ -18,7 +19,17 @@ program
   .name('agent-slackbot')
   .description('CLI tool for Slack bot integration using bot tokens (xoxb-)')
   .version(pkg.version)
+  .option('--pretty', 'Pretty-print JSON output')
   .option('--bot <id>', 'Use specific bot (default: current)')
+  .hook('preAction', (thisCmd, actionCmd) => {
+    for (const [key, value] of Object.entries(thisCmd.opts())) {
+      if (value === undefined) continue
+      const source = actionCmd.getOptionValueSource(key)
+      if (source === undefined || source === 'default') {
+        actionCmd.setOptionValue(key, value)
+      }
+    }
+  })
 
 program.addCommand(authCommand)
 program.addCommand(whoamiCommand)
@@ -26,7 +37,8 @@ program.addCommand(messageCommand)
 program.addCommand(channelCommand)
 program.addCommand(userCommand)
 program.addCommand(reactionCommand)
+program.addCommand(fileCommand)
 
-program.parse(process.argv)
+program.parseAsync(process.argv)
 
 export default program

package/src/platforms/slackbot/client.test.ts

@@ -1,4 +1,4 @@
-import { beforeEach, describe, expect, mock, test } from 'bun:test'
+import { beforeEach, describe, expect, mock, it } from 'bun:test'
 
 import { SlackBotClient } from './client'
 import { SlackBotError } from './types'
@@ -65,6 +65,70 @@ const mockReactions = {
   add: mock(() => Promise.resolve({ ok: true })),
   remove: mock(() => Promise.resolve({ ok: true })),
 }
+const mockAssistant = {
+  threads: {
+    setStatus: mock(() => Promise.resolve({ ok: true })),
+  },
+}
+const mockFiles = {
+  uploadV2: mock(() =>
+    Promise.resolve({
+      ok: true,
+      files: [
+        {
+          ok: true,
+          files: [
+            {
+              id: 'F123',
+              name: 'test.txt',
+              title: 'test.txt',
+              mimetype: 'text/plain',
+              size: 12,
+              url_private: 'https://files.slack.com/files-pri/T123-F123/test.txt',
+              created: 1234567890,
+              user: 'U123',
+              channels: ['C123'],
+            },
+          ],
+        },
+      ],
+    }),
+  ),
+  list: mock(() =>
+    Promise.resolve({
+      ok: true,
+      files: [
+        {
+          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',
+        },
+      ],
+    }),
+  ),
+  info: mock(() =>
+    Promise.resolve({
+      ok: true,
+      file: {
+        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: ['C123'],
+      },
+    }),
+  ),
+  delete: mock(() => Promise.resolve({ ok: true })),
+}
 const mockUsers = {
   list: mock(() =>
     Promise.resolve({
@@ -105,6 +169,8 @@ mock.module('@slack/web-api', () => ({
     chat = mockChat
     reactions = mockReactions
     users = mockUsers
+    files = mockFiles
+    assistant = mockAssistant
   },
 }))
 
@@ -120,33 +186,38 @@ describe('SlackBotClient', () => {
     mockReactions.remove.mockClear()
     mockUsers.list.mockClear()
     mockUsers.info.mockClear()
+    mockFiles.uploadV2.mockClear()
+    mockFiles.list.mockClear()
+    mockFiles.info.mockClear()
+    mockFiles.delete.mockClear()
+    mockAssistant.threads.setStatus.mockClear()
   })
 
   describe('login', () => {
-    test('accepts bot tokens (xoxb-)', async () => {
+    it('accepts bot tokens (xoxb-)', async () => {
       // when/then: should not throw
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
       expect(client).toBeDefined()
     })
 
-    test('rejects user tokens (xoxp-)', async () => {
+    it('rejects user tokens (xoxp-)', async () => {
       // when/then
       await expect(new SlackBotClient().login({ token: 'xoxp-user-token' })).rejects.toThrow(SlackBotError)
     })
 
-    test('rejects empty token', async () => {
+    it('rejects empty token', async () => {
       // when/then
       await expect(new SlackBotClient().login({ token: '' })).rejects.toThrow(SlackBotError)
     })
 
-    test('rejects non-bot tokens', async () => {
+    it('rejects non-bot tokens', async () => {
       // when/then
       await expect(new SlackBotClient().login({ token: 'invalid-token' })).rejects.toThrow(SlackBotError)
     })
   })
 
   describe('testAuth', () => {
-    test('returns auth info for valid token', async () => {
+    it('returns auth info for valid token', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -161,7 +232,7 @@ describe('SlackBotClient', () => {
   })
 
   describe('postMessage', () => {
-    test('sends message and returns timestamp', async () => {
+    it('sends message and returns timestamp', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -175,7 +246,7 @@ describe('SlackBotClient', () => {
   })
 
   describe('getConversationHistory', () => {
-    test('returns messages', async () => {
+    it('returns messages', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -189,7 +260,7 @@ describe('SlackBotClient', () => {
   })
 
   describe('getMessage', () => {
-    test('returns single message', async () => {
+    it('returns single message', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -203,7 +274,7 @@ describe('SlackBotClient', () => {
   })
 
   describe('addReaction', () => {
-    test('adds reaction to message', async () => {
+    it('adds reaction to message', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -214,7 +285,7 @@ describe('SlackBotClient', () => {
   })
 
   describe('removeReaction', () => {
-    test('removes reaction from message', async () => {
+    it('removes reaction from message', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -224,8 +295,40 @@ describe('SlackBotClient', () => {
     })
   })
 
+  describe('setAssistantStatus', () => {
+    it('sets assistant typing status with channel_id and thread_ts', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.setAssistantStatus('C123', '1234567890.123456', 'is typing...')
+
+      // then
+      expect(mockAssistant.threads.setStatus).toHaveBeenCalledWith({
+        channel_id: 'C123',
+        thread_ts: '1234567890.123456',
+        status: 'is typing...',
+      })
+    })
+
+    it('clears status when given empty string', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.setAssistantStatus('C123', '1234567890.123456', '')
+
+      // then
+      expect(mockAssistant.threads.setStatus).toHaveBeenCalledWith({
+        channel_id: 'C123',
+        thread_ts: '1234567890.123456',
+        status: '',
+      })
+    })
+  })
+
   describe('listChannels', () => {
-    test('returns list of channels', async () => {
+    it('returns list of channels', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -240,7 +343,7 @@ describe('SlackBotClient', () => {
   })
 
   describe('getChannelInfo', () => {
-    test('returns channel details', async () => {
+    it('returns channel details', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -254,7 +357,7 @@ describe('SlackBotClient', () => {
   })
 
   describe('resolveChannel', () => {
-    test('returns channel ID unchanged when it starts with C', async () => {
+    it('returns channel ID unchanged when it starts with C', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -266,7 +369,7 @@ describe('SlackBotClient', () => {
       expect(mockConversations.list).not.toHaveBeenCalled()
     })
 
-    test('returns channel ID unchanged when it starts with D', async () => {
+    it('returns channel ID unchanged when it starts with D', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -278,7 +381,7 @@ describe('SlackBotClient', () => {
       expect(mockConversations.list).not.toHaveBeenCalled()
     })
 
-    test('returns channel ID unchanged when it starts with G', async () => {
+    it('returns channel ID unchanged when it starts with G', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -290,7 +393,7 @@ describe('SlackBotClient', () => {
       expect(mockConversations.list).not.toHaveBeenCalled()
     })
 
-    test('resolves channel name to ID', async () => {
+    it('resolves channel name to ID', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -302,7 +405,7 @@ describe('SlackBotClient', () => {
       expect(mockConversations.list).toHaveBeenCalled()
     })
 
-    test('strips leading # from channel name', async () => {
+    it('strips leading # from channel name', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -314,7 +417,7 @@ describe('SlackBotClient', () => {
       expect(mockConversations.list).toHaveBeenCalled()
     })
 
-    test('returns channel ID unchanged when input is #C prefixed ID', async () => {
+    it('returns channel ID unchanged when input is #C prefixed ID', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -325,7 +428,7 @@ describe('SlackBotClient', () => {
       expect(channel).toBe('C123ABC')
     })
 
-    test('throws channel_not_found error when name is not found', async () => {
+    it('throws channel_not_found error when name is not found', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -341,7 +444,7 @@ describe('SlackBotClient', () => {
   })
 
   describe('listUsers', () => {
-    test('returns list of users', async () => {
+    it('returns list of users', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -355,7 +458,7 @@ describe('SlackBotClient', () => {
   })
 
   describe('getUserInfo', () => {
-    test('returns user details', async () => {
+    it('returns user details', async () => {
       // given
       const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
 
@@ -367,4 +470,175 @@ describe('SlackBotClient', () => {
       expect(user.name).toBe('testuser')
     })
   })
+
+  describe('uploadFile', () => {
+    it('uploads file via files.uploadV2 and returns mapped file', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const file = await client.uploadFile('C123', Buffer.from('test content'), 'test.txt')
+
+      // then
+      expect(file.id).toBe('F123')
+      expect(file.name).toBe('test.txt')
+      expect(file.size).toBe(12)
+      expect(mockFiles.uploadV2).toHaveBeenCalledWith(
+        expect.objectContaining({ channel_id: 'C123', filename: 'test.txt' }),
+      )
+    })
+
+    it('forwards thread_ts, title, initial_comment to the SDK', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.uploadFile('C123', Buffer.from('x'), 'test.txt', {
+        thread_ts: '1234567890.123456',
+        title: 'My Title',
+        initial_comment: 'Here you go',
+      })
+
+      // then
+      expect(mockFiles.uploadV2).toHaveBeenCalledWith(
+        expect.objectContaining({
+          channel_id: 'C123',
+          filename: 'test.txt',
+          thread_ts: '1234567890.123456',
+          title: 'My Title',
+          initial_comment: 'Here you go',
+        }),
+      )
+    })
+
+    it('throws SlackBotError when API responds not ok', async () => {
+      // given
+      mockFiles.uploadV2.mockResolvedValueOnce({ ok: false, error: 'file_upload_failed' } as any)
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when/then
+      await expect(client.uploadFile('C123', Buffer.from('x'), 'test.txt')).rejects.toThrow(SlackBotError)
+    })
+
+    it('throws SlackBotError when completion has no inner files', async () => {
+      // given
+      mockFiles.uploadV2.mockResolvedValueOnce({ ok: true, files: [{ ok: true, files: [] }] } as any)
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when/then
+      await expect(client.uploadFile('C123', Buffer.from('x'), 'test.txt')).rejects.toThrow(SlackBotError)
+    })
+  })
+
+  describe('listFiles', () => {
+    it('returns mapped files', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const files = await client.listFiles()
+
+      // then
+      expect(files).toHaveLength(1)
+      expect(files[0].id).toBe('F123')
+      expect(files[0].mimetype).toBe('text/plain')
+    })
+
+    it('forwards channel/user/limit to the SDK', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.listFiles({ channel: 'C123', user: 'U123', limit: 50 })
+
+      // then
+      expect(mockFiles.list).toHaveBeenCalledWith({ channel: 'C123', user: 'U123', count: 50 })
+    })
+  })
+
+  describe('getFileInfo', () => {
+    it('returns file metadata', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      const file = await client.getFileInfo('F123')
+
+      // then
+      expect(file.id).toBe('F123')
+      expect(file.url_private).toBe('https://files.slack.com/files-pri/T123-F123/test.txt')
+    })
+
+    it('throws on API failure', async () => {
+      // given
+      mockFiles.info.mockResolvedValueOnce({ ok: false, error: 'file_not_found' } as any)
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when/then
+      await expect(client.getFileInfo('F999')).rejects.toThrow(SlackBotError)
+    })
+  })
+
+  describe('downloadFile', () => {
+    it('downloads file content using the bot token', async () => {
+      // given
+      const originalFetch = globalThis.fetch
+      let capturedAuthHeader: string | null = null
+      globalThis.fetch = async (_url: any, init: any = {}) => {
+        capturedAuthHeader = init?.headers?.Authorization ?? null
+        return new Response(Buffer.from('downloaded content'), { status: 200 })
+      }
+
+      try {
+        const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+        // when
+        const result = await client.downloadFile('F123')
+
+        // then
+        expect(capturedAuthHeader).toBe('Bearer xoxb-test-token')
+        expect(result.file.id).toBe('F123')
+        expect(result.buffer.toString()).toBe('downloaded content')
+      } finally {
+        globalThis.fetch = originalFetch
+      }
+    })
+
+    it('throws SlackBotError when download HTTP response is not ok', async () => {
+      // given
+      const originalFetch = globalThis.fetch
+      globalThis.fetch = async () => new Response('forbidden', { status: 403, statusText: 'Forbidden' })
+
+      try {
+        const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+        // when/then
+        await expect(client.downloadFile('F123')).rejects.toThrow(SlackBotError)
+      } finally {
+        globalThis.fetch = originalFetch
+      }
+    })
+  })
+
+  describe('deleteFile', () => {
+    it('calls files.delete with the given file ID', async () => {
+      // given
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when
+      await client.deleteFile('F123')
+
+      // then
+      expect(mockFiles.delete).toHaveBeenCalledWith({ file: 'F123' })
+    })
+
+    it('throws on API failure', async () => {
+      // given
+      mockFiles.delete.mockResolvedValueOnce({ ok: false, error: 'cant_delete_file' } as any)
+      const client = await new SlackBotClient().login({ token: 'xoxb-test-token' })
+
+      // when/then
+      await expect(client.deleteFile('F123')).rejects.toThrow(SlackBotError)
+    })
+  })
 })