@urugus/slack-cli 0.1.0

package/tests/commands/history.test.ts

@@ -0,0 +1,250 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { setupHistoryCommand } from '../../src/commands/history';
+import { SlackApiClient } from '../../src/utils/slack-api-client';
+import { ProfileConfigManager } from '../../src/utils/profile-config';
+import { setupMockConsole, createTestProgram, restoreMocks } from '../test-utils';
+import { ERROR_MESSAGES } from '../../src/utils/constants';
+
+vi.mock('../../src/utils/slack-api-client');
+vi.mock('../../src/utils/profile-config');
+
+describe('history command', () => {
+  let program: any;
+  let mockSlackClient: SlackApiClient;
+  let mockConfigManager: ProfileConfigManager;
+  let mockConsole: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    mockConfigManager = new ProfileConfigManager();
+    vi.mocked(ProfileConfigManager).mockReturnValue(mockConfigManager);
+    
+    mockSlackClient = new SlackApiClient('test-token');
+    vi.mocked(SlackApiClient).mockReturnValue(mockSlackClient);
+    
+    mockConsole = setupMockConsole();
+    program = createTestProgram();
+    program.addCommand(setupHistoryCommand());
+  });
+
+  afterEach(() => {
+    restoreMocks();
+  });
+
+  describe('basic functionality', () => {
+    it('should fetch channel history with default options', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+
+      const mockMessages = [
+        {
+          type: 'message',
+          text: 'Hello world',
+          user: 'U123456',
+          ts: '1609459200.000100',
+        },
+        {
+          type: 'message',
+          text: 'Another message',
+          user: 'U789012',
+          ts: '1609459300.000200',
+        },
+      ];
+      vi.mocked(mockSlackClient.getHistory).mockResolvedValue({
+        messages: mockMessages,
+        users: new Map([
+          ['U123456', 'john.doe'],
+          ['U789012', 'jane.smith']
+        ])
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'general']);
+
+      expect(mockSlackClient.getHistory).toHaveBeenCalledWith('general', {
+        limit: 10,
+      });
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Message History for #general'));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('john.doe'));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Hello world'));
+    });
+
+    it('should fetch history with custom message count', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.getHistory).mockResolvedValue({
+        messages: [],
+        users: new Map()
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'general', '-n', '20']);
+
+      expect(mockSlackClient.getHistory).toHaveBeenCalledWith('general', {
+        limit: 20,
+      });
+    });
+
+    it('should fetch history since specific date', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.getHistory).mockResolvedValue({
+        messages: [],
+        users: new Map()
+      });
+
+      const testDate = '2024-01-01 00:00:00';
+      await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'general', '--since', testDate]);
+
+      // Calculate expected timestamp based on the actual date parsing behavior
+      const expectedTimestamp = Math.floor(Date.parse(testDate) / 1000).toString();
+      
+      expect(mockSlackClient.getHistory).toHaveBeenCalledWith('general', {
+        limit: 10,
+        oldest: expectedTimestamp,
+      });
+    });
+
+    it('should use specific profile when provided', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'work-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.getHistory).mockResolvedValue({
+        messages: [],
+        users: new Map()
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'general', '--profile', 'work']);
+
+      expect(mockConfigManager.getConfig).toHaveBeenCalledWith('work');
+      expect(SlackApiClient).toHaveBeenCalledWith('work-token');
+    });
+  });
+
+  describe('error handling', () => {
+    it('should show error when no configuration exists', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue(null);
+
+      await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'general']);
+
+      expect(mockConsole.errorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'), expect.any(String));
+      expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('should show error when profile not found', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue(null);
+
+      await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'general', '--profile', 'unknown']);
+
+      expect(mockConsole.errorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'), expect.any(String));
+      expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('should show error for invalid date format', async () => {
+      const historyCommand = setupHistoryCommand();
+      historyCommand.exitOverride();
+      
+      await expect(
+        historyCommand.parseAsync(['-c', 'general', '--since', 'invalid-date'], { from: 'user' })
+      ).rejects.toThrow();
+    });
+
+    it('should show error for invalid message count', async () => {
+      const historyCommand = setupHistoryCommand();
+      historyCommand.exitOverride();
+      
+      await expect(
+        historyCommand.parseAsync(['-c', 'general', '-n', '-5'], { from: 'user' })
+      ).rejects.toThrow();
+    });
+
+    it('should handle Slack API errors', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.getHistory).mockRejectedValue(new Error('channel_not_found'));
+
+      await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'nonexistent']);
+
+      expect(mockConsole.errorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'), expect.any(String));
+      expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('output formatting', () => {
+    it('should format messages with user names and timestamps', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+
+      const mockMessages = [
+        {
+          type: 'message',
+          text: 'Hello world',
+          user: 'U123456',
+          ts: '1609459200.000100',
+        },
+      ];
+      
+      vi.mocked(mockSlackClient.getHistory).mockResolvedValue({
+        messages: mockMessages,
+        users: new Map([['U123456', 'john.doe']])
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'general']);
+
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('john.doe'));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Hello world'));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('✓ Displayed 1 message(s)'));
+    });
+
+    it('should handle messages without user info gracefully', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+
+      const mockMessages = [
+        {
+          type: 'message',
+          text: 'Bot message',
+          bot_id: 'B123456',
+          ts: '1609459200.000100',
+        },
+      ];
+
+      vi.mocked(mockSlackClient.getHistory).mockResolvedValue({
+        messages: mockMessages,
+        users: new Map()
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'general']);
+
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Bot'));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Bot message'));
+    });
+
+    it('should show message when no messages found', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.getHistory).mockResolvedValue({
+        messages: [],
+        users: new Map()
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'general']);
+
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('No messages found'));
+    });
+  });
+});

package/tests/commands/send.test.ts

@@ -0,0 +1,156 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { setupSendCommand } from '../../src/commands/send';
+import { SlackApiClient } from '../../src/utils/slack-api-client';
+import { ProfileConfigManager } from '../../src/utils/profile-config';
+import { setupMockConsole, createTestProgram, restoreMocks } from '../test-utils';
+import { ERROR_MESSAGES, SUCCESS_MESSAGES } from '../../src/utils/constants';
+import * as fs from 'fs/promises';
+
+vi.mock('../../src/utils/slack-api-client');
+vi.mock('../../src/utils/profile-config');
+vi.mock('fs/promises');
+
+describe('send command', () => {
+  let program: any;
+  let mockSlackClient: SlackApiClient;
+  let mockConfigManager: ProfileConfigManager;
+  let mockConsole: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    mockConfigManager = new ProfileConfigManager();
+    vi.mocked(ProfileConfigManager).mockReturnValue(mockConfigManager);
+    
+    mockSlackClient = new SlackApiClient('test-token');
+    vi.mocked(SlackApiClient).mockReturnValue(mockSlackClient);
+    
+    mockConsole = setupMockConsole();
+    program = createTestProgram();
+    program.addCommand(setupSendCommand());
+  });
+
+  afterEach(() => {
+    restoreMocks();
+  });
+
+  describe('send message with -m option', () => {
+    it('should send a message to specified channel', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.sendMessage).mockResolvedValue({
+        ok: true,
+        ts: '1234567890.123456'
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-m', 'Hello, World!']);
+
+      expect(mockSlackClient.sendMessage).toHaveBeenCalledWith('general', 'Hello, World!');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining(SUCCESS_MESSAGES.MESSAGE_SENT('general')));
+    });
+
+    it('should use specified profile', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'work-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.sendMessage).mockResolvedValue({
+        ok: true,
+        ts: '1234567890.123456'
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-m', 'Hello', '--profile', 'work']);
+
+      expect(mockConfigManager.getConfig).toHaveBeenCalledWith('work');
+      expect(SlackApiClient).toHaveBeenCalledWith('work-token');
+    });
+  });
+
+  describe('send message with -f option', () => {
+    it('should send message from file', async () => {
+      const fileContent = 'Message from file\nLine 2';
+      vi.mocked(fs.readFile).mockResolvedValue(fileContent);
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.sendMessage).mockResolvedValue({
+        ok: true,
+        ts: '1234567890.123456'
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-f', 'message.txt']);
+
+      expect(fs.readFile).toHaveBeenCalledWith('message.txt', 'utf-8');
+      expect(mockSlackClient.sendMessage).toHaveBeenCalledWith('general', fileContent);
+    });
+  });
+
+  describe('validation', () => {
+    it('should fail when no message or file is provided', async () => {
+      const sendCommand = setupSendCommand();
+      sendCommand.exitOverride();
+
+      await expect(
+        sendCommand.parseAsync(['-c', 'general'], { from: 'user' })
+      ).rejects.toThrow(`Error: ${ERROR_MESSAGES.NO_MESSAGE_OR_FILE}`);
+    });
+
+    it('should fail when both message and file are provided', async () => {
+      const sendCommand = setupSendCommand();
+      sendCommand.exitOverride();
+
+      await expect(
+        sendCommand.parseAsync(['-c', 'general', '-m', 'Hello', '-f', 'file.txt'], { from: 'user' })
+      ).rejects.toThrow(`Error: ${ERROR_MESSAGES.BOTH_MESSAGE_AND_FILE}`);
+    });
+
+    it('should fail when no channel is provided', async () => {
+      const sendCommand = setupSendCommand();
+      sendCommand.exitOverride();
+      
+      await expect(
+        sendCommand.parseAsync(['-m', 'Hello'], { from: 'user' })
+      ).rejects.toThrow();
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle missing configuration', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue(null);
+
+      await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-m', 'Hello']);
+
+      expect(mockConsole.errorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'), expect.any(String));
+      expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle Slack API errors', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.sendMessage).mockRejectedValue(new Error('channel_not_found'));
+
+      await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'nonexistent', '-m', 'Hello']);
+
+      expect(mockConsole.errorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'), expect.any(String));
+      expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle file read errors', async () => {
+      vi.mocked(fs.readFile).mockRejectedValue(new Error('ENOENT: no such file'));
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'send', '-c', 'general', '-f', 'nonexistent.txt']);
+
+      expect(mockConsole.errorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'), expect.any(String));
+      expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
+    });
+  });
+});

package/tests/commands/unread.test.ts

@@ -0,0 +1,248 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import { setupUnreadCommand } from '../../src/commands/unread';
+import { SlackApiClient } from '../../src/utils/slack-api-client';
+import { ProfileConfigManager } from '../../src/utils/profile-config';
+import { setupMockConsole, createTestProgram, restoreMocks } from '../test-utils';
+import { ERROR_MESSAGES } from '../../src/utils/constants';
+import chalk from 'chalk';
+
+vi.mock('../../src/utils/slack-api-client');
+vi.mock('../../src/utils/profile-config');
+
+describe('unread command', () => {
+  let program: any;
+  let mockSlackClient: SlackApiClient;
+  let mockConfigManager: ProfileConfigManager;
+  let mockConsole: any;
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    
+    mockConfigManager = new ProfileConfigManager();
+    vi.mocked(ProfileConfigManager).mockReturnValue(mockConfigManager);
+    
+    mockSlackClient = new SlackApiClient('test-token');
+    vi.mocked(SlackApiClient).mockReturnValue(mockSlackClient);
+    
+    mockConsole = setupMockConsole();
+    program = createTestProgram();
+    program.addCommand(setupUnreadCommand());
+  });
+
+  afterEach(() => {
+    restoreMocks();
+  });
+
+  const mockChannelsWithUnread = [
+    {
+      id: 'C123',
+      name: 'general',
+      is_channel: true,
+      is_member: true,
+      is_archived: false,
+      unread_count: 5,
+      unread_count_display: 5,
+      last_read: '1705286300.000000',
+    },
+    {
+      id: 'C456',
+      name: 'random',
+      is_channel: true,
+      is_member: true,
+      is_archived: false,
+      unread_count: 2,
+      unread_count_display: 2,
+      last_read: '1705286400.000000',
+    },
+    {
+      id: 'C789',
+      name: 'dev',
+      is_channel: true,
+      is_member: true,
+      is_archived: false,
+      unread_count: 0,
+      unread_count_display: 0,
+      last_read: '1705286500.000000',
+    },
+  ];
+
+  const mockUnreadMessages = [
+    {
+      ts: '1705286400.000001',
+      user: 'U123',
+      text: 'Hello world',
+      type: 'message',
+    },
+    {
+      ts: '1705286500.000002',
+      user: 'U456',
+      text: 'Test message',
+      type: 'message',
+    },
+  ];
+
+  describe('basic functionality', () => {
+    it('should display unread counts in table format by default', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listUnreadChannels).mockResolvedValue(
+        mockChannelsWithUnread.filter(ch => (ch.unread_count_display || 0) > 0)
+      );
+
+      await program.parseAsync(['node', 'slack-cli', 'unread']);
+
+      expect(mockSlackClient.listUnreadChannels).toHaveBeenCalled();
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Channel'));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Unread'));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('#general'));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('5'));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('#random'));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('2'));
+    });
+
+    it('should display only count when --count-only is specified', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listUnreadChannels).mockResolvedValue(
+        mockChannelsWithUnread.filter(ch => (ch.unread_count_display || 0) > 0)
+      );
+
+      await program.parseAsync(['node', 'slack-cli', 'unread', '--count-only']);
+
+      expect(mockConsole.logSpy).toHaveBeenCalledWith('#general: 5');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith('#random: 2');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(chalk.bold('Total: 7 unread messages'));
+    });
+
+    it('should display in JSON format when specified', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listUnreadChannels).mockResolvedValue(
+        mockChannelsWithUnread.filter(ch => (ch.unread_count_display || 0) > 0)
+      );
+
+      await program.parseAsync(['node', 'slack-cli', 'unread', '--format', 'json']);
+
+      const expectedOutput = [
+        { channel: '#general', channelId: 'C123', unreadCount: 5 },
+        { channel: '#random', channelId: 'C456', unreadCount: 2 },
+      ];
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(JSON.stringify(expectedOutput, null, 2));
+    });
+
+    it('should display in simple format when specified', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listUnreadChannels).mockResolvedValue(
+        mockChannelsWithUnread.filter(ch => (ch.unread_count_display || 0) > 0)
+      );
+
+      await program.parseAsync(['node', 'slack-cli', 'unread', '--format', 'simple']);
+
+      expect(mockConsole.logSpy).toHaveBeenCalledWith('#general (5)');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith('#random (2)');
+    });
+  });
+
+  describe('channel filtering', () => {
+    it('should filter by specific channel when --channel is specified', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.getChannelUnread).mockResolvedValue({
+        channel: mockChannelsWithUnread[0],
+        messages: mockUnreadMessages,
+        users: new Map([
+          ['U123', 'john.doe'],
+          ['U456', 'jane.smith']
+        ])
+      });
+
+      await program.parseAsync(['node', 'slack-cli', 'unread', '--channel', 'general']);
+
+      expect(mockSlackClient.getChannelUnread).toHaveBeenCalledWith('general');
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(chalk.bold(`#general: 5 unread messages`));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Hello world'));
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Test message'));
+    });
+  });
+
+  describe('limit option', () => {
+    it('should limit the number of channels displayed', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listUnreadChannels).mockResolvedValue(
+        mockChannelsWithUnread.filter(ch => (ch.unread_count_display || 0) > 0)
+      );
+
+      await program.parseAsync(['node', 'slack-cli', 'unread', '--limit', '1']);
+
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('#general'));
+      expect(mockConsole.logSpy).not.toHaveBeenCalledWith(expect.stringContaining('#random'));
+    });
+  });
+
+  describe('error handling', () => {
+    it('should display message when no unread messages found', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listUnreadChannels).mockResolvedValue([]);
+
+      await program.parseAsync(['node', 'slack-cli', 'unread']);
+
+      expect(mockConsole.logSpy).toHaveBeenCalledWith(chalk.green('✓ No unread messages'));
+    });
+
+    it('should handle channel not found error', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'test-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.getChannelUnread).mockRejectedValue(
+        new Error('channel_not_found')
+      );
+
+      await program.parseAsync(['node', 'slack-cli', 'unread', '--channel', 'nonexistent']);
+
+      expect(mockConsole.errorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'), expect.any(String));
+      expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle missing configuration', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue(null);
+
+      await program.parseAsync(['node', 'slack-cli', 'unread']);
+
+      expect(mockConsole.errorSpy).toHaveBeenCalledWith(expect.stringContaining('Error:'), expect.any(String));
+      expect(mockConsole.exitSpy).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('profile option', () => {
+    it('should use specified profile', async () => {
+      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
+        token: 'work-token',
+        updatedAt: new Date().toISOString()
+      });
+      vi.mocked(mockSlackClient.listUnreadChannels).mockResolvedValue([]);
+
+      await program.parseAsync(['node', 'slack-cli', 'unread', '--profile', 'work']);
+
+      expect(mockConfigManager.getConfig).toHaveBeenCalledWith('work');
+      expect(SlackApiClient).toHaveBeenCalledWith('work-token');
+    });
+  });
+});

package/tests/test-utils.ts

@@ -0,0 +1,28 @@
+import { vi } from 'vitest';
+import { Command } from 'commander';
+
+export interface MockConsole {
+  logSpy: any;
+  errorSpy: any;
+  exitSpy: any;
+}
+
+export function setupMockConsole(): MockConsole {
+  const logSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+  const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+  const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => undefined as never);
+
+  return { logSpy, errorSpy, exitSpy };
+}
+
+export function createTestProgram(): Command {
+  const program = new Command();
+  program.exitOverride((err) => {
+    throw new Error('process.exit');
+  });
+  return program;
+}
+
+export function restoreMocks(): void {
+  vi.restoreAllMocks();
+}