@urugus/slack-cli 0.2.12 → 0.3.0

package/tests/utils/config.test.ts

@@ -1,400 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as os from 'os';
-import { ProfileConfigManager } from '../../src/utils/profile-config';
-import type { Config, ConfigStore } from '../../src/types/config';
-
-vi.mock('fs/promises');
-vi.mock('os');
-
-describe('ProfileConfigManager', () => {
-  let configManager: ProfileConfigManager;
-  const mockHomeDir = '/mock/home';
-  const mockConfigPath = path.join(mockHomeDir, '.slack-cli', 'config.json');
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    vi.mocked(os.homedir).mockReturnValue(mockHomeDir);
-    configManager = new ProfileConfigManager();
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  describe('setToken', () => {
-    it('should save token to default profile when no profile specified and no default set', async () => {
-      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
-      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-      vi.mocked(fs.chmod).mockResolvedValue(undefined);
-      vi.mocked(fs.readFile).mockRejectedValue({ code: 'ENOENT' });
-
-      await configManager.setToken('test-token-123');
-
-      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
-      const writtenData = JSON.parse(writeCall[1] as string) as ConfigStore;
-      
-      expect(writtenData.profiles.default).toBeDefined();
-      expect(writtenData.profiles.default.token).toBe('test-token-123');
-      expect(writtenData.defaultProfile).toBe('default');
-    });
-
-    it('should save token to current default profile when no profile specified', async () => {
-      const existingStore: ConfigStore = {
-        profiles: {
-          personal: {
-            token: 'personal-token',
-            updatedAt: '2025-01-01T00:00:00.000Z'
-          }
-        },
-        defaultProfile: 'personal'
-      };
-
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(existingStore));
-      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
-      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-      vi.mocked(fs.chmod).mockResolvedValue(undefined);
-
-      await configManager.setToken('updated-token-123');
-
-      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
-      const writtenData = JSON.parse(writeCall[1] as string) as ConfigStore;
-      
-      expect(writtenData.profiles.personal.token).toBe('updated-token-123');
-      expect(writtenData.defaultProfile).toBe('personal');
-    });
-
-    it('should save token to specified profile', async () => {
-      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
-      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-      vi.mocked(fs.chmod).mockResolvedValue(undefined);
-      vi.mocked(fs.readFile).mockRejectedValue({ code: 'ENOENT' });
-
-      await configManager.setToken('work-token-123', 'work');
-
-      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
-      const writtenData = JSON.parse(writeCall[1] as string) as ConfigStore;
-      
-      expect(writtenData.profiles.work).toBeDefined();
-      expect(writtenData.profiles.work.token).toBe('work-token-123');
-    });
-
-    it('should preserve existing profiles when adding new one', async () => {
-      const existingStore: ConfigStore = {
-        profiles: {
-          personal: {
-            token: 'personal-token',
-            updatedAt: '2025-01-01T00:00:00.000Z'
-          }
-        },
-        defaultProfile: 'personal'
-      };
-
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(existingStore));
-      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-      vi.mocked(fs.chmod).mockResolvedValue(undefined);
-
-      await configManager.setToken('work-token-123', 'work');
-
-      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
-      const writtenData = JSON.parse(writeCall[1] as string) as ConfigStore;
-      
-      expect(writtenData.profiles.personal).toBeDefined();
-      expect(writtenData.profiles.work).toBeDefined();
-      expect(writtenData.profiles.work.token).toBe('work-token-123');
-      expect(writtenData.defaultProfile).toBe('personal'); // default unchanged
-    });
-  });
-
-  describe('getConfig', () => {
-    it('should return config from default profile', async () => {
-      const mockStore: ConfigStore = {
-        profiles: {
-          default: {
-            token: 'default-token',
-            updatedAt: '2025-06-21T10:00:00.000Z'
-          },
-          work: {
-            token: 'work-token',
-            updatedAt: '2025-06-21T11:00:00.000Z'
-          }
-        },
-        defaultProfile: 'default'
-      };
-
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
-
-      const config = await configManager.getConfig();
-
-      expect(config).toEqual(mockStore.profiles.default);
-    });
-
-    it('should return config from specified profile', async () => {
-      const mockStore: ConfigStore = {
-        profiles: {
-          default: {
-            token: 'default-token',
-            updatedAt: '2025-06-21T10:00:00.000Z'
-          },
-          work: {
-            token: 'work-token',
-            updatedAt: '2025-06-21T11:00:00.000Z'
-          }
-        },
-        defaultProfile: 'default'
-      };
-
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
-
-      const config = await configManager.getConfig('work');
-
-      expect(config).toEqual(mockStore.profiles.work);
-    });
-
-    it('should return null when profile does not exist', async () => {
-      const mockStore: ConfigStore = {
-        profiles: {
-          default: {
-            token: 'default-token',
-            updatedAt: '2025-06-21T10:00:00.000Z'
-          }
-        },
-        defaultProfile: 'default'
-      };
-
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
-
-      const config = await configManager.getConfig('nonexistent');
-
-      expect(config).toBeNull();
-    });
-  });
-
-  describe('listProfiles', () => {
-    it('should return all profiles with current profile marked', async () => {
-      const mockStore: ConfigStore = {
-        profiles: {
-          default: {
-            token: 'default-token',
-            updatedAt: '2025-06-21T10:00:00.000Z'
-          },
-          work: {
-            token: 'work-token',
-            updatedAt: '2025-06-21T11:00:00.000Z'
-          },
-          personal: {
-            token: 'personal-token',
-            updatedAt: '2025-06-21T12:00:00.000Z'
-          }
-        },
-        defaultProfile: 'work'
-      };
-
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
-
-      const profiles = await configManager.listProfiles();
-
-      expect(profiles).toHaveLength(3);
-      expect(profiles.find(p => p.name === 'work')?.isDefault).toBe(true);
-      expect(profiles.find(p => p.name === 'default')?.isDefault).toBe(false);
-    });
-
-    it('should return empty array when no profiles exist', async () => {
-      vi.mocked(fs.readFile).mockRejectedValue({ code: 'ENOENT' });
-
-      const profiles = await configManager.listProfiles();
-
-      expect(profiles).toEqual([]);
-    });
-  });
-
-  describe('useProfile', () => {
-    it('should set default profile', async () => {
-      const mockStore: ConfigStore = {
-        profiles: {
-          default: {
-            token: 'default-token',
-            updatedAt: '2025-06-21T10:00:00.000Z'
-          },
-          work: {
-            token: 'work-token',
-            updatedAt: '2025-06-21T11:00:00.000Z'
-          }
-        },
-        defaultProfile: 'default'
-      };
-
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
-      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-      vi.mocked(fs.chmod).mockResolvedValue(undefined);
-
-      await configManager.useProfile('work');
-
-      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
-      const writtenData = JSON.parse(writeCall[1] as string) as ConfigStore;
-      
-      expect(writtenData.defaultProfile).toBe('work');
-    });
-
-    it('should throw error when profile does not exist', async () => {
-      const mockStore: ConfigStore = {
-        profiles: {
-          default: {
-            token: 'default-token',
-            updatedAt: '2025-06-21T10:00:00.000Z'
-          }
-        },
-        defaultProfile: 'default'
-      };
-
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
-
-      await expect(configManager.useProfile('nonexistent')).rejects.toThrow('Profile "nonexistent" does not exist');
-    });
-  });
-
-  describe('getCurrentProfile', () => {
-    it('should return current default profile name', async () => {
-      const mockStore: ConfigStore = {
-        profiles: {
-          default: {
-            token: 'default-token',
-            updatedAt: '2025-06-21T10:00:00.000Z'
-          },
-          work: {
-            token: 'work-token',
-            updatedAt: '2025-06-21T11:00:00.000Z'
-          }
-        },
-        defaultProfile: 'work'
-      };
-
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
-
-      const currentProfile = await configManager.getCurrentProfile();
-
-      expect(currentProfile).toBe('work');
-    });
-
-    it('should return "default" when no default profile set', async () => {
-      const mockStore: ConfigStore = {
-        profiles: {
-          default: {
-            token: 'default-token',
-            updatedAt: '2025-06-21T10:00:00.000Z'
-          }
-        }
-      };
-
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
-
-      const currentProfile = await configManager.getCurrentProfile();
-
-      expect(currentProfile).toBe('default');
-    });
-  });
-
-  describe('clearConfig', () => {
-    it('should clear specific profile', async () => {
-      const mockStore: ConfigStore = {
-        profiles: {
-          default: {
-            token: 'default-token',
-            updatedAt: '2025-06-21T10:00:00.000Z'
-          },
-          work: {
-            token: 'work-token',
-            updatedAt: '2025-06-21T11:00:00.000Z'
-          }
-        },
-        defaultProfile: 'work'
-      };
-
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
-      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-      vi.mocked(fs.chmod).mockResolvedValue(undefined);
-
-      await configManager.clearConfig('work');
-
-      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
-      const writtenData = JSON.parse(writeCall[1] as string) as ConfigStore;
-      
-      expect(writtenData.profiles.work).toBeUndefined();
-      expect(writtenData.profiles.default).toBeDefined();
-      expect(writtenData.defaultProfile).toBe('default'); // fallback to default
-    });
-
-    it('should clear default profile and reset defaultProfile', async () => {
-      const mockStore: ConfigStore = {
-        profiles: {
-          default: {
-            token: 'default-token',
-            updatedAt: '2025-06-21T10:00:00.000Z'
-          },
-          work: {
-            token: 'work-token',
-            updatedAt: '2025-06-21T11:00:00.000Z'
-          }
-        },
-        defaultProfile: 'default'
-      };
-
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
-      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-      vi.mocked(fs.chmod).mockResolvedValue(undefined);
-
-      await configManager.clearConfig('default');
-
-      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
-      const writtenData = JSON.parse(writeCall[1] as string) as ConfigStore;
-      
-      expect(writtenData.profiles.default).toBeUndefined();
-      expect(writtenData.profiles.work).toBeDefined();
-      expect(writtenData.defaultProfile).toBe('work'); // switch to remaining profile
-    });
-
-    it('should delete config file when clearing last profile', async () => {
-      const mockStore: ConfigStore = {
-        profiles: {
-          default: {
-            token: 'default-token',
-            updatedAt: '2025-06-21T10:00:00.000Z'
-          }
-        },
-        defaultProfile: 'default'
-      };
-
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(mockStore));
-      vi.mocked(fs.unlink).mockResolvedValue(undefined);
-
-      await configManager.clearConfig('default');
-
-      expect(fs.unlink).toHaveBeenCalledWith(mockConfigPath);
-    });
-  });
-
-  describe('migration from old config', () => {
-    it('should automatically migrate old single-token config to profile format', async () => {
-      const oldConfig = {
-        token: 'old-token-123',
-        updatedAt: '2025-01-01T00:00:00.000Z'
-      };
-
-      vi.mocked(fs.readFile).mockResolvedValue(JSON.stringify(oldConfig));
-      vi.mocked(fs.writeFile).mockResolvedValue(undefined);
-      vi.mocked(fs.chmod).mockResolvedValue(undefined);
-
-      const config = await configManager.getConfig();
-
-      expect(config).toEqual(oldConfig);
-      
-      // Verify migration happened
-      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
-      const writtenData = JSON.parse(writeCall[1] as string) as ConfigStore;
-      
-      expect(writtenData.profiles.default).toEqual(oldConfig);
-      expect(writtenData.defaultProfile).toBe('default');
-    });
-  });
-});

package/tests/utils/date-utils.test.ts

@@ -1,30 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { formatUnixTimestamp, formatSlackTimestamp } from '../../src/utils/date-utils';
-
-describe('date-utils', () => {
-  describe('formatUnixTimestamp', () => {
-    it('should format unix timestamp to ISO date string', () => {
-      const timestamp = 1640995200; // 2022-01-01 00:00:00 UTC
-      expect(formatUnixTimestamp(timestamp)).toBe('2022-01-01');
-    });
-
-    it('should handle different timestamps correctly', () => {
-      const timestamp = 1672531200; // 2023-01-01 00:00:00 UTC
-      expect(formatUnixTimestamp(timestamp)).toBe('2023-01-01');
-    });
-  });
-
-  describe('formatSlackTimestamp', () => {
-    it('should format Slack timestamp to locale string', () => {
-      const slackTimestamp = '1640995200.000000';
-      const result = formatSlackTimestamp(slackTimestamp);
-      expect(result).toContain('2022');
-    });
-
-    it('should handle timestamps with milliseconds', () => {
-      const slackTimestamp = '1640995200.123456';
-      const result = formatSlackTimestamp(slackTimestamp);
-      expect(result).toContain('2022');
-    });
-  });
-});

package/tests/utils/error-utils.test.ts

@@ -1,34 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractErrorMessage } from '../../src/utils/error-utils';
-
-describe('extractErrorMessage', () => {
-  it('should extract message from Error instance', () => {
-    const error = new Error('Test error message');
-    expect(extractErrorMessage(error)).toBe('Test error message');
-  });
-
-  it('should convert string to string', () => {
-    const error = 'String error';
-    expect(extractErrorMessage(error)).toBe('String error');
-  });
-
-  it('should convert number to string', () => {
-    const error = 404;
-    expect(extractErrorMessage(error)).toBe('404');
-  });
-
-  it('should convert object to string', () => {
-    const error = { code: 'ERROR_CODE', detail: 'Some detail' };
-    expect(extractErrorMessage(error)).toBe('[object Object]');
-  });
-
-  it('should handle null', () => {
-    const error = null;
-    expect(extractErrorMessage(error)).toBe('null');
-  });
-
-  it('should handle undefined', () => {
-    const error = undefined;
-    expect(extractErrorMessage(error)).toBe('undefined');
-  });
-});

package/tests/utils/format-utils.test.ts

@@ -1,61 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { formatMessageWithMentions } from '../../src/utils/format-utils';
-
-describe('formatMessageWithMentions', () => {
-  it('should replace user ID mentions with usernames', () => {
-    const message = 'Hello <@U784E34>, please check this';
-    const users = new Map([['U784E34', 'sakashita']]);
-    
-    const result = formatMessageWithMentions(message, users);
-    
-    expect(result).toBe('Hello @sakashita, please check this');
-  });
-
-  it('should handle multiple mentions', () => {
-    const message = '<@U784E34> and <@U123456> are working on this';
-    const users = new Map([
-      ['U784E34', 'sakashita'],
-      ['U123456', 'tanaka']
-    ]);
-    
-    const result = formatMessageWithMentions(message, users);
-    
-    expect(result).toBe('@sakashita and @tanaka are working on this');
-  });
-
-  it('should keep user ID if username is not found', () => {
-    const message = 'Hello <@U784E34>, please check this';
-    const users = new Map<string, string>();
-    
-    const result = formatMessageWithMentions(message, users);
-    
-    expect(result).toBe('Hello @U784E34, please check this');
-  });
-
-  it('should handle messages without mentions', () => {
-    const message = 'This is a regular message';
-    const users = new Map<string, string>();
-    
-    const result = formatMessageWithMentions(message, users);
-    
-    expect(result).toBe('This is a regular message');
-  });
-
-  it('should handle empty message', () => {
-    const message = '';
-    const users = new Map<string, string>();
-    
-    const result = formatMessageWithMentions(message, users);
-    
-    expect(result).toBe('');
-  });
-
-  it('should handle malformed mentions', () => {
-    const message = 'Hello <@>, <@ >, <@invalid';
-    const users = new Map<string, string>();
-    
-    const result = formatMessageWithMentions(message, users);
-    
-    expect(result).toBe('Hello <@>, <@ >, <@invalid');
-  });
-});

package/tests/utils/mention-utils.test.ts

@@ -1,100 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { extractUserIdsFromMentions, extractAllUserIds } from '../../src/utils/mention-utils';
-
-describe('mention-utils', () => {
-  describe('extractUserIdsFromMentions', () => {
-    it('should extract single user ID from mention', () => {
-      const text = 'Hello <@U123456789>';
-      const userIds = extractUserIdsFromMentions(text);
-      expect(userIds).toEqual(['U123456789']);
-    });
-
-    it('should extract multiple user IDs from mentions', () => {
-      const text = 'Hey <@U123456789> and <@U987654321>, please check this';
-      const userIds = extractUserIdsFromMentions(text);
-      expect(userIds).toEqual(['U123456789', 'U987654321']);
-    });
-
-    it('should handle duplicate mentions', () => {
-      const text = '<@U123456789> mentioned <@U123456789> again';
-      const userIds = extractUserIdsFromMentions(text);
-      expect(userIds).toEqual(['U123456789', 'U123456789']);
-    });
-
-    it('should return empty array for text without mentions', () => {
-      const text = 'No mentions here';
-      const userIds = extractUserIdsFromMentions(text);
-      expect(userIds).toEqual([]);
-    });
-
-    it('should handle empty text', () => {
-      const userIds = extractUserIdsFromMentions('');
-      expect(userIds).toEqual([]);
-    });
-
-    it('should ignore malformed mentions', () => {
-      const text = 'Invalid <@> mention and <@lowercase> mention';
-      const userIds = extractUserIdsFromMentions(text);
-      expect(userIds).toEqual([]);
-    });
-  });
-
-  describe('extractAllUserIds', () => {
-    it('should extract user IDs from message authors only', () => {
-      const messages = [
-        { user: 'U111111111', text: 'Hello world' },
-        { user: 'U222222222', text: 'Hi there' },
-      ];
-      const userIds = extractAllUserIds(messages);
-      expect(userIds).toEqual(['U111111111', 'U222222222']);
-    });
-
-    it('should extract user IDs from mentions only', () => {
-      const messages = [
-        { text: 'Hello <@U333333333>' },
-        { text: 'Hi <@U444444444>' },
-      ];
-      const userIds = extractAllUserIds(messages);
-      expect(userIds).toEqual(['U333333333', 'U444444444']);
-    });
-
-    it('should extract both authors and mentioned users', () => {
-      const messages = [
-        { user: 'U111111111', text: 'Hello <@U222222222>' },
-        { user: 'U333333333', text: 'Hi <@U444444444> and <@U555555555>' },
-      ];
-      const userIds = extractAllUserIds(messages);
-      expect(userIds.sort()).toEqual([
-        'U111111111',
-        'U222222222',
-        'U333333333',
-        'U444444444',
-        'U555555555',
-      ]);
-    });
-
-    it('should remove duplicate user IDs', () => {
-      const messages = [
-        { user: 'U111111111', text: 'Hello <@U111111111>' },
-        { user: 'U111111111', text: 'Another message' },
-      ];
-      const userIds = extractAllUserIds(messages);
-      expect(userIds).toEqual(['U111111111']);
-    });
-
-    it('should handle messages without user or text', () => {
-      const messages = [
-        { user: 'U111111111' },
-        { text: 'No user here' },
-        {},
-      ];
-      const userIds = extractAllUserIds(messages);
-      expect(userIds).toEqual(['U111111111']);
-    });
-
-    it('should handle empty messages array', () => {
-      const userIds = extractAllUserIds([]);
-      expect(userIds).toEqual([]);
-    });
-  });
-});