@urugus/slack-cli 0.2.12 → 0.2.13

package/tests/utils/slack-api-client.test.ts

@@ -1,313 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { SlackApiClient } from '../../src/utils/slack-api-client';
-import { WebClient, LogLevel } from '@slack/web-api';
-
-vi.mock('@slack/web-api');
-
-describe('SlackApiClient', () => {
-  let client: SlackApiClient;
-  let mockWebClient: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockWebClient = {
-      chat: {
-        postMessage: vi.fn(),
-        scheduleMessage: vi.fn(),
-        scheduledMessages: {
-          list: vi.fn(),
-        },
-      },
-      conversations: {
-        list: vi.fn(),
-        info: vi.fn(),
-      },
-      users: {
-        conversations: vi.fn(),
-      },
-    };
-    vi.mocked(WebClient).mockReturnValue(mockWebClient);
-    client = new SlackApiClient('test-token');
-  });
-
-  describe('constructor', () => {
-    it('should create WebClient with provided token', () => {
-      expect(WebClient).toHaveBeenCalledWith('test-token', {
-        retryConfig: {
-          retries: 0, // Disabled to handle rate limits manually
-        },
-        logLevel: LogLevel.ERROR,
-      });
-    });
-  });
-
-  describe('sendMessage', () => {
-    it('should send message to channel', async () => {
-      const mockResponse = { ok: true, ts: '1234567890.123456' };
-      vi.mocked(mockWebClient.chat.postMessage).mockResolvedValue(mockResponse as any);
-
-      const result = await client.sendMessage('general', 'Hello, World!');
-
-      expect(mockWebClient.chat.postMessage).toHaveBeenCalledWith({
-        channel: 'general',
-        text: 'Hello, World!',
-      });
-      expect(result).toEqual(mockResponse);
-    });
-
-    it('should handle channel ID format', async () => {
-      const mockResponse = { ok: true, ts: '1234567890.123456' };
-      vi.mocked(mockWebClient.chat.postMessage).mockResolvedValue(mockResponse as any);
-
-      await client.sendMessage('C1234567890', 'Hello!');
-
-      expect(mockWebClient.chat.postMessage).toHaveBeenCalledWith({
-        channel: 'C1234567890',
-        text: 'Hello!',
-      });
-    });
-
-    it('should handle multi-line messages', async () => {
-      const mockResponse = { ok: true, ts: '1234567890.123456' };
-      vi.mocked(mockWebClient.chat.postMessage).mockResolvedValue(mockResponse as any);
-
-      const multiLineMessage = 'Line 1\nLine 2\nLine 3';
-      await client.sendMessage('general', multiLineMessage);
-
-      expect(mockWebClient.chat.postMessage).toHaveBeenCalledWith({
-        channel: 'general',
-        text: multiLineMessage,
-      });
-    });
-
-    it('should throw error on API failure', async () => {
-      const mockError = new Error('channel_not_found');
-      vi.mocked(mockWebClient.chat.postMessage).mockRejectedValue(mockError);
-
-      await expect(client.sendMessage('nonexistent', 'Hello')).rejects.toThrow('channel_not_found');
-    });
-  });
-
-  describe('scheduleMessage', () => {
-    it('should schedule message to channel', async () => {
-      const mockResponse = { ok: true, scheduled_message_id: 'Q123', post_at: 1770855000 };
-      vi.mocked(mockWebClient.chat.scheduleMessage).mockResolvedValue(mockResponse as any);
-
-      const result = await client.scheduleMessage('general', 'Hello, future!', 1770855000);
-
-      expect(mockWebClient.chat.scheduleMessage).toHaveBeenCalledWith({
-        channel: 'general',
-        text: 'Hello, future!',
-        post_at: 1770855000,
-      });
-      expect(result).toEqual(mockResponse);
-    });
-  });
-
-  describe('listScheduledMessages', () => {
-    it('should list scheduled messages', async () => {
-      const mockResponse = {
-        ok: true,
-        scheduled_messages: [
-          { id: 'Q123', channel_id: 'C123', post_at: 1770855000, date_created: 1770854400 },
-        ],
-      };
-      vi.mocked(mockWebClient.chat.scheduledMessages.list).mockResolvedValue(mockResponse as any);
-
-      const result = await client.listScheduledMessages();
-
-      expect(mockWebClient.chat.scheduledMessages.list).toHaveBeenCalledWith({ limit: 50 });
-      expect(result).toEqual(mockResponse.scheduled_messages);
-    });
-  });
-
-  describe('listChannels', () => {
-    it('should list channels with default options', async () => {
-      const mockChannels = [
-        {
-          id: 'C1234567890',
-          name: 'general',
-          is_channel: true,
-          is_private: false,
-          num_members: 150,
-          created: 1579075200,
-          purpose: { value: 'Company announcements' },
-        },
-      ];
-      vi.mocked(mockWebClient.conversations.list).mockResolvedValue({
-        ok: true,
-        channels: mockChannels,
-      } as any);
-
-      const result = await client.listChannels({
-        types: 'public_channel',
-        exclude_archived: true,
-        limit: 100,
-      });
-
-      expect(mockWebClient.conversations.list).toHaveBeenCalledWith({
-        types: 'public_channel',
-        exclude_archived: true,
-        limit: 100,
-      });
-      expect(result).toEqual(mockChannels);
-    });
-
-    it('should handle private channels', async () => {
-      const mockChannels = [
-        {
-          id: 'G1234567890',
-          name: 'private-channel',
-          is_group: true,
-          is_private: true,
-          num_members: 10,
-          created: 1579075200,
-          purpose: { value: 'Private discussions' },
-        },
-      ];
-      vi.mocked(mockWebClient.conversations.list).mockResolvedValue({
-        ok: true,
-        channels: mockChannels,
-      } as any);
-
-      const result = await client.listChannels({
-        types: 'private_channel',
-        exclude_archived: true,
-        limit: 50,
-      });
-
-      expect(mockWebClient.conversations.list).toHaveBeenCalledWith({
-        types: 'private_channel',
-        exclude_archived: true,
-        limit: 50,
-      });
-      expect(result).toEqual(mockChannels);
-    });
-
-    it('should handle multiple channel types', async () => {
-      vi.mocked(mockWebClient.conversations.list).mockResolvedValue({
-        ok: true,
-        channels: [],
-      } as any);
-
-      await client.listChannels({
-        types: 'public_channel,private_channel,im',
-        exclude_archived: false,
-        limit: 200,
-      });
-
-      expect(mockWebClient.conversations.list).toHaveBeenCalledWith({
-        types: 'public_channel,private_channel,im',
-        exclude_archived: false,
-        limit: 200,
-      });
-    });
-
-    it('should handle API errors', async () => {
-      vi.mocked(mockWebClient.conversations.list).mockRejectedValue(new Error('invalid_auth'));
-
-      await expect(
-        client.listChannels({
-          types: 'public_channel',
-          exclude_archived: true,
-          limit: 100,
-        })
-      ).rejects.toThrow('invalid_auth');
-    });
-
-    it('should handle pagination when listing channels', async () => {
-      // First page
-      vi.mocked(mockWebClient.conversations.list).mockResolvedValueOnce({
-        ok: true,
-        channels: [
-          { id: 'C001', name: 'channel1', is_private: false },
-          { id: 'C002', name: 'channel2', is_private: false },
-        ],
-        response_metadata: {
-          next_cursor: 'cursor123',
-        },
-      } as any);
-
-      // Second page
-      vi.mocked(mockWebClient.conversations.list).mockResolvedValueOnce({
-        ok: true,
-        channels: [
-          { id: 'C003', name: 'channel3', is_private: false },
-          { id: 'C004', name: 'channel4', is_private: false },
-        ],
-        response_metadata: {
-          next_cursor: 'cursor456',
-        },
-      } as any);
-
-      // Third page (last page)
-      vi.mocked(mockWebClient.conversations.list).mockResolvedValueOnce({
-        ok: true,
-        channels: [{ id: 'C005', name: 'channel5', is_private: false }],
-        response_metadata: {
-          next_cursor: '',
-        },
-      } as any);
-
-      const result = await client.listChannels({
-        types: 'public_channel',
-        exclude_archived: true,
-        limit: 2,
-      });
-
-      // Should have called the API 3 times
-      expect(mockWebClient.conversations.list).toHaveBeenCalledTimes(3);
-
-      // First call
-      expect(mockWebClient.conversations.list).toHaveBeenNthCalledWith(1, {
-        types: 'public_channel',
-        exclude_archived: true,
-        limit: 2,
-        cursor: undefined,
-      });
-
-      // Second call
-      expect(mockWebClient.conversations.list).toHaveBeenNthCalledWith(2, {
-        types: 'public_channel',
-        exclude_archived: true,
-        limit: 2,
-        cursor: 'cursor123',
-      });
-
-      // Third call
-      expect(mockWebClient.conversations.list).toHaveBeenNthCalledWith(3, {
-        types: 'public_channel',
-        exclude_archived: true,
-        limit: 2,
-        cursor: 'cursor456',
-      });
-
-      // Should return all channels
-      expect(result).toHaveLength(5);
-      expect(result[0].name).toBe('channel1');
-      expect(result[1].name).toBe('channel2');
-      expect(result[2].name).toBe('channel3');
-      expect(result[3].name).toBe('channel4');
-      expect(result[4].name).toBe('channel5');
-    });
-
-    it('should handle empty cursor in pagination', async () => {
-      vi.mocked(mockWebClient.conversations.list).mockResolvedValueOnce({
-        ok: true,
-        channels: [{ id: 'C001', name: 'channel1', is_private: false }],
-        response_metadata: {
-          // No next_cursor field
-        },
-      } as any);
-
-      const result = await client.listChannels({
-        types: 'public_channel',
-        exclude_archived: true,
-        limit: 100,
-      });
-
-      expect(mockWebClient.conversations.list).toHaveBeenCalledTimes(1);
-      expect(result).toHaveLength(1);
-    });
-  });
-});

package/tests/utils/slack-operations/channel-operations.test.ts

@@ -1,248 +0,0 @@
-import { vi, describe, it, expect, beforeEach } from 'vitest';
-import { ChannelOperations } from '../../../src/utils/slack-operations/channel-operations';
-
-vi.mock('@slack/web-api', () => ({
-  WebClient: vi.fn().mockImplementation(() => ({
-    conversations: {
-      list: vi.fn(),
-      info: vi.fn(),
-      history: vi.fn(),
-    },
-  })),
-  LogLevel: {
-    ERROR: 'error',
-  },
-}));
-
-vi.mock('p-limit', () => ({
-  default: () => (fn: any) => fn(),
-}));
-
-describe('ChannelOperations', () => {
-  let channelOps: ChannelOperations;
-  let mockClient: any;
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockClient = {
-      conversations: {
-        list: vi.fn(),
-        info: vi.fn(),
-        history: vi.fn(),
-      },
-    };
-    // Create instance with mocked token
-    channelOps = new ChannelOperations('test-token');
-    // Replace the client with our mock
-    (channelOps as any).client = mockClient;
-  });
-
-  describe('listUnreadChannels', () => {
-    it('should detect unread messages when last_read is present', async () => {
-      // Mock conversations.list response
-      mockClient.conversations.list.mockResolvedValue({
-        channels: [
-          { id: 'C123', name: 'general' },
-          { id: 'C456', name: 'random' },
-        ],
-      });
-
-      // Mock conversations.info responses
-      mockClient.conversations.info
-        .mockResolvedValueOnce({
-          channel: {
-            id: 'C123',
-            name: 'general',
-            last_read: '1234567890.000100',
-          },
-        })
-        .mockResolvedValueOnce({
-          channel: {
-            id: 'C456',
-            name: 'random',
-            last_read: '1234567890.000200',
-          },
-        });
-
-      // Mock conversations.history responses
-      mockClient.conversations.history
-        // First call for C123 - check latest message
-        .mockResolvedValueOnce({
-          messages: [{ ts: '1234567890.000200' }], // Newer than last_read
-        })
-        // Second call for C123 - get unread messages
-        .mockResolvedValueOnce({
-          messages: [
-            { ts: '1234567890.000200' },
-            { ts: '1234567890.000150' },
-          ],
-        })
-        // Third call for C456 - check latest message
-        .mockResolvedValueOnce({
-          messages: [{ ts: '1234567890.000100' }], // Older than last_read
-        });
-
-      const result = await channelOps.listUnreadChannels();
-
-      expect(result).toHaveLength(1);
-      expect(result[0]).toMatchObject({
-        id: 'C123',
-        name: 'general',
-        unread_count: 2,
-        unread_count_display: 2,
-        last_read: '1234567890.000100',
-      });
-    });
-
-    it('should count all messages as unread when last_read is not present', async () => {
-      // Mock conversations.list response
-      mockClient.conversations.list.mockResolvedValue({
-        channels: [{ id: 'C789', name: 'no-read-channel' }],
-      });
-
-      // Mock conversations.info response - no last_read
-      mockClient.conversations.info.mockResolvedValue({
-        channel: {
-          id: 'C789',
-          name: 'no-read-channel',
-          // last_read is missing
-        },
-      });
-
-      // Mock conversations.history responses
-      mockClient.conversations.history
-        // First call - check if channel has messages
-        .mockResolvedValueOnce({
-          messages: [{ ts: '1234567890.000300' }],
-        })
-        // Second call - get all messages (up to 100)
-        .mockResolvedValueOnce({
-          messages: [
-            { ts: '1234567890.000300' },
-            { ts: '1234567890.000200' },
-            { ts: '1234567890.000100' },
-          ],
-        });
-
-      const result = await channelOps.listUnreadChannels();
-
-      expect(result).toHaveLength(1);
-      expect(result[0]).toMatchObject({
-        id: 'C789',
-        name: 'no-read-channel',
-        unread_count: 3,
-        unread_count_display: 3,
-        last_read: undefined,
-      });
-    });
-
-    it('should skip channels with no messages', async () => {
-      mockClient.conversations.list.mockResolvedValue({
-        channels: [{ id: 'C999', name: 'empty-channel' }],
-      });
-
-      mockClient.conversations.info.mockResolvedValue({
-        channel: {
-          id: 'C999',
-          name: 'empty-channel',
-          last_read: '1234567890.000100',
-        },
-      });
-
-      // No messages in channel
-      mockClient.conversations.history.mockResolvedValue({
-        messages: [],
-      });
-
-      const result = await channelOps.listUnreadChannels();
-
-      expect(result).toHaveLength(0);
-    });
-
-    it('should skip channels with all messages read', async () => {
-      mockClient.conversations.list.mockResolvedValue({
-        channels: [{ id: 'C111', name: 'all-read' }],
-      });
-
-      mockClient.conversations.info.mockResolvedValue({
-        channel: {
-          id: 'C111',
-          name: 'all-read',
-          last_read: '1234567890.000200',
-        },
-      });
-
-      // First call to get latest message (limit: 1)
-      mockClient.conversations.history.mockResolvedValueOnce({
-        messages: [{ ts: '1234567890.000100' }],
-      });
-      
-      // Second call to get messages after last_read (should be empty)
-      mockClient.conversations.history.mockResolvedValueOnce({
-        messages: [],
-      });
-
-      const result = await channelOps.listUnreadChannels();
-
-      expect(result).toHaveLength(0);
-    });
-
-    it('should handle API errors gracefully', async () => {
-      mockClient.conversations.list.mockResolvedValue({
-        channels: [
-          { id: 'C222', name: 'error-channel' },
-          { id: 'C333', name: 'good-channel' },
-        ],
-      });
-
-      // First channel throws error
-      mockClient.conversations.info
-        .mockRejectedValueOnce(new Error('API Error'))
-        .mockResolvedValueOnce({
-          channel: {
-            id: 'C333',
-            name: 'good-channel',
-            last_read: '1234567890.000100',
-          },
-        });
-
-      mockClient.conversations.history
-        .mockResolvedValueOnce({
-          messages: [{ ts: '1234567890.000200' }],
-        })
-        .mockResolvedValueOnce({
-          messages: [{ ts: '1234567890.000200' }],
-        });
-
-      const result = await channelOps.listUnreadChannels();
-
-      // Should skip the error channel and process the good one
-      expect(result).toHaveLength(1);
-      expect(result[0].id).toBe('C333');
-    });
-
-    it('should handle rate limiting with delay', async () => {
-      const delaySpy = vi.spyOn(channelOps as any, 'delay');
-      
-      mockClient.conversations.list.mockResolvedValue({
-        channels: [
-          { id: 'C444', name: 'channel1' },
-          { id: 'C555', name: 'channel2' },
-        ],
-      });
-
-      mockClient.conversations.info.mockResolvedValue({
-        channel: { id: 'C444', name: 'channel1' },
-      });
-
-      mockClient.conversations.history.mockResolvedValue({
-        messages: [],
-      });
-
-      await channelOps.listUnreadChannels();
-
-      // Verify delay was called between API calls
-      expect(delaySpy).toHaveBeenCalledWith(100);
-    });
-  });
-});