@urugus/slack-cli 0.2.11 → 0.2.13

package/tests/commands/history.test.ts

@@ -1,403 +0,0 @@
-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);
-    });
-
-    it('should show helpful error when channel not found', async () => {
-      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-        token: 'test-token',
-        updatedAt: new Date().toISOString()
-      });
-      
-      // Mock getHistory to throw our new helpful error
-      vi.mocked(mockSlackClient.getHistory).mockRejectedValue(
-        new Error("Channel 'times_sakashi' not found. Make sure you are a member of this channel.")
-      );
-
-      await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'times_sakashi']);
-
-      expect(mockSlackClient.getHistory).toHaveBeenCalledWith('times_sakashi', { limit: 10 });
-      expect(mockConsole.errorSpy).toHaveBeenCalledWith(
-        expect.stringContaining('Error:'),
-        expect.stringContaining('Make sure you are a member of this channel')
-      );
-    });
-
-    it('should find private channels with underscore in name', async () => {
-      vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-        token: 'test-token',
-        updatedAt: new Date().toISOString()
-      });
-      
-      // Mock the getHistory method to simulate successful channel lookup
-      vi.mocked(mockSlackClient.getHistory).mockResolvedValue({
-        messages: [],
-        users: new Map()
-      });
-
-      await program.parseAsync(['node', 'slack-cli', 'history', '-c', 'times_sakashi']);
-
-      expect(mockSlackClient.getHistory).toHaveBeenCalledWith('times_sakashi', { limit: 10 });
-      expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('No messages found'));
-    });
-  });
-
-  describe('output formatting', () => {
-    describe('format options', () => {
-      it('should display messages in JSON format when --format json is specified', 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', '--format', 'json']);
-
-        const expectedOutput = {
-          channel: 'general',
-          messages: [
-            {
-              timestamp: '2021-01-01 00:01:40',
-              user: 'jane.smith',
-              text: 'Another message'
-            },
-            {
-              timestamp: '2021-01-01 00:00:00',
-              user: 'john.doe',
-              text: 'Hello world'
-            }
-          ],
-          total: 2
-        };
-
-        expect(mockConsole.logSpy).toHaveBeenCalledWith(JSON.stringify(expectedOutput, null, 2));
-      });
-
-      it('should display messages in simple format when --format simple is specified', 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', '--format', 'simple']);
-
-        expect(mockConsole.logSpy).toHaveBeenCalledWith('[2021-01-01 00:00:00] john.doe: Hello world');
-      });
-
-      it('should display messages in table format by default', 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']);
-
-        // Should display in table format (current format)
-        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 handle invalid format option', async () => {
-        const historyCommand = setupHistoryCommand();
-        historyCommand.exitOverride();
-        
-        await expect(
-          historyCommand.parseAsync(['-c', 'general', '--format', 'invalid'], { from: 'user' })
-        ).rejects.toThrow();
-      });
-    });
-
-    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/scheduled.test.ts

@@ -1,131 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import { setupScheduledCommand } from '../../src/commands/scheduled';
-import { SlackApiClient } from '../../src/utils/slack-api-client';
-import { ProfileConfigManager } from '../../src/utils/profile-config';
-import { setupMockConsole, createTestProgram, restoreMocks } from '../test-utils';
-
-vi.mock('../../src/utils/slack-api-client');
-vi.mock('../../src/utils/profile-config');
-
-describe('scheduled command', () => {
-  let program: any;
-  let mockSlackClient: SlackApiClient;
-  let mockConfigManager: ProfileConfigManager;
-  let mockConsole: any;
-  let tableSpy: any;
-
-  const mockScheduledMessages = [
-    {
-      id: 'Q123',
-      channel_id: 'C1234567890',
-      post_at: 1770855000,
-      date_created: 1770854400,
-      text: 'Scheduled message 1',
-    },
-    {
-      id: 'Q456',
-      channel_id: 'C0987654321',
-      post_at: 1770858600,
-      date_created: 1770854400,
-      text: 'Scheduled message 2',
-    },
-  ];
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-
-    mockConfigManager = new ProfileConfigManager();
-    vi.mocked(ProfileConfigManager).mockReturnValue(mockConfigManager);
-
-    mockSlackClient = new SlackApiClient('test-token');
-    vi.mocked(SlackApiClient).mockReturnValue(mockSlackClient);
-
-    mockConsole = setupMockConsole();
-    tableSpy = vi.spyOn(console, 'table').mockImplementation(() => {});
-
-    program = createTestProgram();
-    program.addCommand(setupScheduledCommand());
-  });
-
-  afterEach(() => {
-    restoreMocks();
-  });
-
-  it('should list scheduled messages in table format by default', async () => {
-    vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-      token: 'test-token',
-      updatedAt: new Date().toISOString(),
-    });
-    vi.mocked(mockSlackClient.listScheduledMessages).mockResolvedValue(
-      mockScheduledMessages as any
-    );
-
-    await program.parseAsync(['node', 'slack-cli', 'scheduled']);
-
-    expect(mockSlackClient.listScheduledMessages).toHaveBeenCalledWith(undefined, 50);
-    expect(tableSpy).toHaveBeenCalled();
-  });
-
-  it('should filter by channel and limit', async () => {
-    vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-      token: 'test-token',
-      updatedAt: new Date().toISOString(),
-    });
-    vi.mocked(mockSlackClient.listScheduledMessages).mockResolvedValue(
-      mockScheduledMessages as any
-    );
-
-    await program.parseAsync([
-      'node',
-      'slack-cli',
-      'scheduled',
-      '--channel',
-      'general',
-      '--limit',
-      '10',
-    ]);
-
-    expect(mockSlackClient.listScheduledMessages).toHaveBeenCalledWith('general', 10);
-  });
-
-  it('should output json format', async () => {
-    vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-      token: 'test-token',
-      updatedAt: new Date().toISOString(),
-    });
-    vi.mocked(mockSlackClient.listScheduledMessages).mockResolvedValue(
-      mockScheduledMessages as any
-    );
-
-    await program.parseAsync(['node', 'slack-cli', 'scheduled', '--format', 'json']);
-
-    expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('"id": "Q123"'));
-  });
-
-  it('should output simple format', async () => {
-    vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-      token: 'test-token',
-      updatedAt: new Date().toISOString(),
-    });
-    vi.mocked(mockSlackClient.listScheduledMessages).mockResolvedValue(
-      mockScheduledMessages as any
-    );
-
-    await program.parseAsync(['node', 'slack-cli', 'scheduled', '--format', 'simple']);
-
-    expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Q123'));
-    expect(mockConsole.logSpy).toHaveBeenCalledWith(expect.stringContaining('Q456'));
-  });
-
-  it('should show empty message when no scheduled messages', async () => {
-    vi.mocked(mockConfigManager.getConfig).mockResolvedValue({
-      token: 'test-token',
-      updatedAt: new Date().toISOString(),
-    });
-    vi.mocked(mockSlackClient.listScheduledMessages).mockResolvedValue([] as any);
-
-    await program.parseAsync(['node', 'slack-cli', 'scheduled']);
-
-    expect(mockConsole.logSpy).toHaveBeenCalledWith('No scheduled messages found');
-  });
-});