agent-messenger 1.0.0 → 1.2.0

package/dist/tests/slack-client.test.js

@@ -1,741 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from 'bun:test';
-import { SlackClient, SlackError } from '../src/platforms/slack/client';
-const mockWebClient = {
-    conversations: {
-        list: mock(() => Promise.resolve({ ok: true, channels: [] })),
-        info: mock(() => Promise.resolve({ ok: true, channel: {} })),
-        history: mock(() => Promise.resolve({ ok: true, messages: [] })),
-        replies: mock(() => Promise.resolve({ ok: true, messages: [], has_more: false })),
-    },
-    chat: {
-        postMessage: mock(() => Promise.resolve({ ok: true, ts: '123.456', message: {} })),
-        update: mock(() => Promise.resolve({ ok: true, ts: '123.456', message: {} })),
-        delete: mock(() => Promise.resolve({ ok: true })),
-    },
-    reactions: {
-        add: mock(() => Promise.resolve({ ok: true })),
-        remove: mock(() => Promise.resolve({ ok: true })),
-    },
-    users: {
-        list: mock(() => Promise.resolve({ ok: true, members: [] })),
-        info: mock(() => Promise.resolve({ ok: true, user: {} })),
-    },
-    files: {
-        uploadV2: mock(() => Promise.resolve({ ok: true, file: {} })),
-        list: mock(() => Promise.resolve({ ok: true, files: [] })),
-    },
-    auth: {
-        test: mock(() => Promise.resolve({ ok: true, user_id: 'U123', team_id: 'T123' })),
-    },
-};
-function resetMocks() {
-    for (const group of Object.values(mockWebClient)) {
-        for (const fn of Object.values(group)) {
-            if (typeof fn.mockReset === 'function') {
-                fn.mockReset();
-            }
-        }
-    }
-}
-describe('SlackClient', () => {
-    describe('constructor', () => {
-        test('throws SlackError when token is empty', () => {
-            expect(() => new SlackClient('', 'xoxd-cookie')).toThrow(SlackError);
-            expect(() => new SlackClient('', 'xoxd-cookie')).toThrow('Token is required');
-        });
-        test('throws SlackError when cookie is empty', () => {
-            expect(() => new SlackClient('xoxc-token', '')).toThrow(SlackError);
-            expect(() => new SlackClient('xoxc-token', '')).toThrow('Cookie is required');
-        });
-        test('throws SlackError when both token and cookie are empty', () => {
-            expect(() => new SlackClient('', '')).toThrow(SlackError);
-        });
-        test('creates client successfully with valid token and cookie', () => {
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            expect(client).toBeInstanceOf(SlackClient);
-        });
-    });
-    describe('testAuth', () => {
-        beforeEach(() => resetMocks());
-        test('returns auth info on success', async () => {
-            mockWebClient.auth.test.mockResolvedValue({
-                ok: true,
-                user_id: 'U123',
-                team_id: 'T123',
-                user: 'testuser',
-                team: 'Test Team',
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            const result = await client.testAuth();
-            expect(result.user_id).toBe('U123');
-            expect(result.team_id).toBe('T123');
-        });
-        test('throws SlackError on API failure', async () => {
-            mockWebClient.auth.test.mockResolvedValue({
-                ok: false,
-                error: 'invalid_auth',
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.testAuth()).rejects.toThrow(SlackError);
-        });
-    });
-    describe('listChannels', () => {
-        beforeEach(() => resetMocks());
-        test('returns list of channels', async () => {
-            mockWebClient.conversations.list.mockResolvedValue({
-                ok: true,
-                channels: [
-                    {
-                        id: 'C123',
-                        name: 'general',
-                        is_private: false,
-                        is_archived: false,
-                        created: 1234567890,
-                        creator: 'U123',
-                    },
-                    {
-                        id: 'C456',
-                        name: 'random',
-                        is_private: false,
-                        is_archived: false,
-                        created: 1234567891,
-                        creator: 'U123',
-                    },
-                ],
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            const channels = await client.listChannels();
-            expect(channels).toHaveLength(2);
-            expect(channels[0].id).toBe('C123');
-            expect(channels[1].name).toBe('random');
-        });
-        test('handles pagination automatically', async () => {
-            mockWebClient.conversations.list
-                .mockResolvedValueOnce({
-                ok: true,
-                channels: [
-                    {
-                        id: 'C123',
-                        name: 'general',
-                        is_private: false,
-                        is_archived: false,
-                        created: 1234567890,
-                        creator: 'U123',
-                    },
-                ],
-                response_metadata: { next_cursor: 'cursor123' },
-            })
-                .mockResolvedValueOnce({
-                ok: true,
-                channels: [
-                    {
-                        id: 'C456',
-                        name: 'random',
-                        is_private: false,
-                        is_archived: false,
-                        created: 1234567891,
-                        creator: 'U123',
-                    },
-                ],
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            const channels = await client.listChannels();
-            expect(channels).toHaveLength(2);
-            expect(mockWebClient.conversations.list).toHaveBeenCalledTimes(2);
-        });
-        test('throws SlackError on API failure', async () => {
-            mockWebClient.conversations.list.mockResolvedValue({
-                ok: false,
-                error: 'channel_not_found',
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.listChannels()).rejects.toThrow(SlackError);
-        });
-    });
-    describe('getChannel', () => {
-        beforeEach(() => resetMocks());
-        test('returns channel info', async () => {
-            mockWebClient.conversations.info.mockResolvedValue({
-                ok: true,
-                channel: {
-                    id: 'C123',
-                    name: 'general',
-                    is_private: false,
-                    is_archived: false,
-                    created: 1234567890,
-                    creator: 'U123',
-                },
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            const channel = await client.getChannel('C123');
-            expect(channel.id).toBe('C123');
-            expect(channel.name).toBe('general');
-        });
-        test('throws SlackError when channel not found', async () => {
-            mockWebClient.conversations.info.mockResolvedValue({
-                ok: false,
-                error: 'channel_not_found',
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.getChannel('C999')).rejects.toThrow(SlackError);
-        });
-    });
-    describe('getMessages', () => {
-        beforeEach(() => resetMocks());
-        test('returns messages with default limit of 20', async () => {
-            const messages = Array.from({ length: 20 }, (_, i) => ({
-                ts: `123.${i}`,
-                text: `Message ${i}`,
-                type: 'message',
-            }));
-            mockWebClient.conversations.history.mockResolvedValue({
-                ok: true,
-                messages,
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            const result = await client.getMessages('C123');
-            expect(result).toHaveLength(20);
-            expect(mockWebClient.conversations.history).toHaveBeenCalledWith(expect.objectContaining({ channel: 'C123', limit: 20 }));
-        });
-        test('respects custom limit', async () => {
-            mockWebClient.conversations.history.mockResolvedValue({
-                ok: true,
-                messages: [{ ts: '123.456', text: 'Hello', type: 'message' }],
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await client.getMessages('C123', 50);
-            expect(mockWebClient.conversations.history).toHaveBeenCalledWith(expect.objectContaining({ channel: 'C123', limit: 50 }));
-        });
-        test('throws SlackError on API failure', async () => {
-            mockWebClient.conversations.history.mockResolvedValue({
-                ok: false,
-                error: 'channel_not_found',
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.getMessages('C999')).rejects.toThrow(SlackError);
-        });
-    });
-    describe('sendMessage', () => {
-        beforeEach(() => resetMocks());
-        test('sends message to channel', async () => {
-            mockWebClient.chat.postMessage.mockResolvedValue({
-                ok: true,
-                ts: '123.456',
-                message: { ts: '123.456', text: 'Hello', type: 'message' },
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            const message = await client.sendMessage('C123', 'Hello');
-            expect(message.ts).toBe('123.456');
-            expect(mockWebClient.chat.postMessage).toHaveBeenCalledWith(expect.objectContaining({ channel: 'C123', text: 'Hello' }));
-        });
-        test('sends message to thread', async () => {
-            mockWebClient.chat.postMessage.mockResolvedValue({
-                ok: true,
-                ts: '123.789',
-                message: { ts: '123.789', text: 'Reply', type: 'message', thread_ts: '123.456' },
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            const message = await client.sendMessage('C123', 'Reply', '123.456');
-            expect(message.thread_ts).toBe('123.456');
-            expect(mockWebClient.chat.postMessage).toHaveBeenCalledWith(expect.objectContaining({ channel: 'C123', text: 'Reply', thread_ts: '123.456' }));
-        });
-        test('throws SlackError on API failure', async () => {
-            mockWebClient.chat.postMessage.mockResolvedValue({
-                ok: false,
-                error: 'channel_not_found',
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.sendMessage('C999', 'Hello')).rejects.toThrow(SlackError);
-        });
-    });
-    describe('updateMessage', () => {
-        beforeEach(() => resetMocks());
-        test('updates message text', async () => {
-            mockWebClient.chat.update.mockResolvedValue({
-                ok: true,
-                ts: '123.456',
-                message: { ts: '123.456', text: 'Updated', type: 'message' },
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            const message = await client.updateMessage('C123', '123.456', 'Updated');
-            expect(message.text).toBe('Updated');
-            expect(mockWebClient.chat.update).toHaveBeenCalledWith(expect.objectContaining({ channel: 'C123', ts: '123.456', text: 'Updated' }));
-        });
-        test('throws SlackError on API failure', async () => {
-            mockWebClient.chat.update.mockResolvedValue({
-                ok: false,
-                error: 'message_not_found',
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.updateMessage('C123', '999.999', 'Updated')).rejects.toThrow(SlackError);
-        });
-    });
-    describe('deleteMessage', () => {
-        beforeEach(() => resetMocks());
-        test('deletes message', async () => {
-            mockWebClient.chat.delete.mockResolvedValue({ ok: true });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.deleteMessage('C123', '123.456')).resolves.toBeUndefined();
-            expect(mockWebClient.chat.delete).toHaveBeenCalledWith(expect.objectContaining({ channel: 'C123', ts: '123.456' }));
-        });
-        test('throws SlackError on API failure', async () => {
-            mockWebClient.chat.delete.mockResolvedValue({
-                ok: false,
-                error: 'message_not_found',
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.deleteMessage('C123', '999.999')).rejects.toThrow(SlackError);
-        });
-    });
-    describe('addReaction', () => {
-        beforeEach(() => resetMocks());
-        test('adds reaction to message', async () => {
-            mockWebClient.reactions.add.mockResolvedValue({ ok: true });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.addReaction('C123', '123.456', 'thumbsup')).resolves.toBeUndefined();
-            expect(mockWebClient.reactions.add).toHaveBeenCalledWith(expect.objectContaining({ channel: 'C123', timestamp: '123.456', name: 'thumbsup' }));
-        });
-        test('throws SlackError on API failure', async () => {
-            mockWebClient.reactions.add.mockResolvedValue({
-                ok: false,
-                error: 'already_reacted',
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.addReaction('C123', '123.456', 'thumbsup')).rejects.toThrow(SlackError);
-        });
-    });
-    describe('removeReaction', () => {
-        beforeEach(() => resetMocks());
-        test('removes reaction from message', async () => {
-            mockWebClient.reactions.remove.mockResolvedValue({ ok: true });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.removeReaction('C123', '123.456', 'thumbsup')).resolves.toBeUndefined();
-            expect(mockWebClient.reactions.remove).toHaveBeenCalledWith(expect.objectContaining({ channel: 'C123', timestamp: '123.456', name: 'thumbsup' }));
-        });
-        test('throws SlackError on API failure', async () => {
-            mockWebClient.reactions.remove.mockResolvedValue({
-                ok: false,
-                error: 'no_reaction',
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.removeReaction('C123', '123.456', 'thumbsup')).rejects.toThrow(SlackError);
-        });
-    });
-    describe('listUsers', () => {
-        beforeEach(() => resetMocks());
-        test('returns list of users', async () => {
-            mockWebClient.users.list.mockResolvedValue({
-                ok: true,
-                members: [
-                    {
-                        id: 'U123',
-                        name: 'alice',
-                        real_name: 'Alice',
-                        is_admin: false,
-                        is_owner: false,
-                        is_bot: false,
-                        is_app_user: false,
-                    },
-                    {
-                        id: 'U456',
-                        name: 'bob',
-                        real_name: 'Bob',
-                        is_admin: true,
-                        is_owner: false,
-                        is_bot: false,
-                        is_app_user: false,
-                    },
-                ],
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            const users = await client.listUsers();
-            expect(users).toHaveLength(2);
-            expect(users[0].name).toBe('alice');
-            expect(users[1].is_admin).toBe(true);
-        });
-        test('handles pagination automatically', async () => {
-            mockWebClient.users.list
-                .mockResolvedValueOnce({
-                ok: true,
-                members: [
-                    {
-                        id: 'U123',
-                        name: 'alice',
-                        real_name: 'Alice',
-                        is_admin: false,
-                        is_owner: false,
-                        is_bot: false,
-                        is_app_user: false,
-                    },
-                ],
-                response_metadata: { next_cursor: 'cursor123' },
-            })
-                .mockResolvedValueOnce({
-                ok: true,
-                members: [
-                    {
-                        id: 'U456',
-                        name: 'bob',
-                        real_name: 'Bob',
-                        is_admin: false,
-                        is_owner: false,
-                        is_bot: false,
-                        is_app_user: false,
-                    },
-                ],
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            const users = await client.listUsers();
-            expect(users).toHaveLength(2);
-            expect(mockWebClient.users.list).toHaveBeenCalledTimes(2);
-        });
-        test('throws SlackError on API failure', async () => {
-            mockWebClient.users.list.mockResolvedValue({
-                ok: false,
-                error: 'invalid_auth',
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.listUsers()).rejects.toThrow(SlackError);
-        });
-    });
-    describe('getUser', () => {
-        beforeEach(() => resetMocks());
-        test('returns user info', async () => {
-            mockWebClient.users.info.mockResolvedValue({
-                ok: true,
-                user: {
-                    id: 'U123',
-                    name: 'alice',
-                    real_name: 'Alice',
-                    is_admin: false,
-                    is_owner: false,
-                    is_bot: false,
-                    is_app_user: false,
-                },
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            const user = await client.getUser('U123');
-            expect(user.id).toBe('U123');
-            expect(user.name).toBe('alice');
-        });
-        test('throws SlackError when user not found', async () => {
-            mockWebClient.users.info.mockResolvedValue({
-                ok: false,
-                error: 'user_not_found',
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.getUser('U999')).rejects.toThrow(SlackError);
-        });
-    });
-    describe('uploadFile', () => {
-        beforeEach(() => resetMocks());
-        test('uploads file to channels', async () => {
-            mockWebClient.files.uploadV2.mockResolvedValue({
-                ok: true,
-                file: {
-                    id: 'F123',
-                    name: 'test.txt',
-                    title: 'test.txt',
-                    mimetype: 'text/plain',
-                    size: 100,
-                    url_private: 'https://...',
-                    created: 1234567890,
-                    user: 'U123',
-                },
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            const file = await client.uploadFile(['C123'], Buffer.from('test'), 'test.txt');
-            expect(file.id).toBe('F123');
-            expect(mockWebClient.files.uploadV2).toHaveBeenCalledWith(expect.objectContaining({ channel_id: 'C123', filename: 'test.txt' }));
-        });
-        test('throws SlackError on API failure', async () => {
-            mockWebClient.files.uploadV2.mockResolvedValue({
-                ok: false,
-                error: 'file_upload_failed',
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.uploadFile(['C123'], Buffer.from('test'), 'test.txt')).rejects.toThrow(SlackError);
-        });
-    });
-    describe('listFiles', () => {
-        beforeEach(() => resetMocks());
-        test('returns list of files', async () => {
-            mockWebClient.files.list.mockResolvedValue({
-                ok: true,
-                files: [
-                    {
-                        id: 'F123',
-                        name: 'test.txt',
-                        title: 'test.txt',
-                        mimetype: 'text/plain',
-                        size: 100,
-                        url_private: 'https://...',
-                        created: 1234567890,
-                        user: 'U123',
-                    },
-                ],
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            const files = await client.listFiles();
-            expect(files).toHaveLength(1);
-            expect(files[0].name).toBe('test.txt');
-        });
-        test('filters by channel when provided', async () => {
-            mockWebClient.files.list.mockResolvedValue({
-                ok: true,
-                files: [],
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await client.listFiles('C123');
-            expect(mockWebClient.files.list).toHaveBeenCalledWith(expect.objectContaining({ channel: 'C123' }));
-        });
-        test('throws SlackError on API failure', async () => {
-            mockWebClient.files.list.mockResolvedValue({
-                ok: false,
-                error: 'invalid_auth',
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.listFiles()).rejects.toThrow(SlackError);
-        });
-    });
-    describe('getThreadReplies', () => {
-        beforeEach(() => resetMocks());
-        test('returns thread replies including parent message', async () => {
-            mockWebClient.conversations.replies.mockResolvedValue({
-                ok: true,
-                messages: [
-                    {
-                        ts: '123.456',
-                        text: 'Parent message',
-                        type: 'message',
-                        user: 'U123',
-                        thread_ts: '123.456',
-                        reply_count: 2,
-                    },
-                    {
-                        ts: '123.457',
-                        text: 'First reply',
-                        type: 'message',
-                        user: 'U456',
-                        thread_ts: '123.456',
-                    },
-                    {
-                        ts: '123.458',
-                        text: 'Second reply',
-                        type: 'message',
-                        user: 'U789',
-                        thread_ts: '123.456',
-                    },
-                ],
-                has_more: false,
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            const result = await client.getThreadReplies('C123', '123.456');
-            expect(result.messages).toHaveLength(3);
-            expect(result.messages[0].text).toBe('Parent message');
-            expect(result.messages[0].reply_count).toBe(2);
-            expect(result.messages[1].text).toBe('First reply');
-            expect(result.messages[2].text).toBe('Second reply');
-            expect(result.has_more).toBe(false);
-        });
-        test('respects limit parameter', async () => {
-            mockWebClient.conversations.replies.mockResolvedValue({
-                ok: true,
-                messages: [{ ts: '123.456', text: 'Hello', type: 'message' }],
-                has_more: false,
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await client.getThreadReplies('C123', '123.456', { limit: 50 });
-            expect(mockWebClient.conversations.replies).toHaveBeenCalledWith(expect.objectContaining({ channel: 'C123', ts: '123.456', limit: 50 }));
-        });
-        test('passes optional oldest and latest parameters', async () => {
-            mockWebClient.conversations.replies.mockResolvedValue({
-                ok: true,
-                messages: [],
-                has_more: false,
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await client.getThreadReplies('C123', '123.456', {
-                oldest: '123.400',
-                latest: '123.500',
-            });
-            expect(mockWebClient.conversations.replies).toHaveBeenCalledWith(expect.objectContaining({
-                channel: 'C123',
-                ts: '123.456',
-                oldest: '123.400',
-                latest: '123.500',
-            }));
-        });
-        test('returns pagination info when has_more is true', async () => {
-            mockWebClient.conversations.replies.mockResolvedValue({
-                ok: true,
-                messages: [{ ts: '123.456', text: 'Hello', type: 'message' }],
-                has_more: true,
-                response_metadata: { next_cursor: 'cursor123' },
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            const result = await client.getThreadReplies('C123', '123.456');
-            expect(result.has_more).toBe(true);
-            expect(result.next_cursor).toBe('cursor123');
-        });
-        test('throws SlackError when thread not found', async () => {
-            mockWebClient.conversations.replies.mockResolvedValue({
-                ok: false,
-                error: 'thread_not_found',
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.getThreadReplies('C123', '999.999')).rejects.toThrow(SlackError);
-        });
-        test('throws SlackError when channel not found', async () => {
-            mockWebClient.conversations.replies.mockResolvedValue({
-                ok: false,
-                error: 'channel_not_found',
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.getThreadReplies('C999', '123.456')).rejects.toThrow(SlackError);
-        });
-    });
-    describe('rate limiting', () => {
-        beforeEach(() => resetMocks());
-        test('retries on rate limit error with exponential backoff', async () => {
-            const rateLimitError = new Error('Rate limited');
-            rateLimitError.code = 'slack_webapi_rate_limited_error';
-            rateLimitError.retryAfter = 0.001;
-            mockWebClient.conversations.list
-                .mockRejectedValueOnce(rateLimitError)
-                .mockRejectedValueOnce(rateLimitError)
-                .mockResolvedValueOnce({
-                ok: true,
-                channels: [
-                    {
-                        id: 'C123',
-                        name: 'general',
-                        is_private: false,
-                        is_archived: false,
-                        created: 1234567890,
-                        creator: 'U123',
-                    },
-                ],
-            });
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            const channels = await client.listChannels();
-            expect(channels).toHaveLength(1);
-            expect(mockWebClient.conversations.list).toHaveBeenCalledTimes(3);
-        });
-        test('throws SlackError after max retries (3)', async () => {
-            const rateLimitError = new Error('Rate limited');
-            rateLimitError.code = 'slack_webapi_rate_limited_error';
-            rateLimitError.retryAfter = 0.001;
-            mockWebClient.conversations.list.mockRejectedValue(rateLimitError);
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.listChannels()).rejects.toThrow(SlackError);
-            // Initial call + 3 retries = 4 total calls
-            expect(mockWebClient.conversations.list).toHaveBeenCalledTimes(4);
-        });
-        test('does not retry on non-rate-limit errors', async () => {
-            const otherError = new Error('Some other error');
-            otherError.code = 'some_other_error';
-            mockWebClient.conversations.list.mockRejectedValue(otherError);
-            const client = new SlackClient('xoxc-token', 'xoxd-cookie');
-            // @ts-expect-error - accessing private property for testing
-            client.client = mockWebClient;
-            await expect(client.listChannels()).rejects.toThrow(SlackError);
-            expect(mockWebClient.conversations.list).toHaveBeenCalledTimes(1);
-        });
-    });
-    describe('SlackError', () => {
-        test('is an instance of Error', () => {
-            const error = new SlackError('test error', 'test_code');
-            expect(error).toBeInstanceOf(Error);
-            expect(error).toBeInstanceOf(SlackError);
-        });
-        test('has message and code properties', () => {
-            const error = new SlackError('test error', 'test_code');
-            expect(error.message).toBe('test error');
-            expect(error.code).toBe('test_code');
-        });
-        test('has name property set to SlackError', () => {
-            const error = new SlackError('test error', 'test_code');
-            expect(error.name).toBe('SlackError');
-        });
-    });
-});
-//# sourceMappingURL=slack-client.test.js.map