@urugus/slack-cli 0.2.5 → 0.2.7

package/tests/utils/profile-config.test.ts

@@ -0,0 +1,282 @@
+import { describe, it, expect, beforeEach, 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';
+
+vi.mock('fs/promises');
+vi.mock('os');
+
+describe('ProfileConfigManager', () => {
+  let configManager: ProfileConfigManager;
+  const mockConfigPath = '/home/user/.slack-cli/config.json';
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    vi.mocked(os.homedir).mockReturnValue('/home/user');
+    configManager = new ProfileConfigManager();
+  });
+
+  describe('setToken', () => {
+    it('should set token for default profile when no profile specified', async () => {
+      vi.mocked(fs.readFile).mockRejectedValueOnce({ code: 'ENOENT' });
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue();
+      vi.mocked(fs.chmod).mockResolvedValue();
+
+      await configManager.setToken('test-token');
+
+      expect(fs.writeFile).toHaveBeenCalledWith(
+        mockConfigPath,
+        expect.stringContaining('"default"'),
+      );
+    });
+
+    it('should set token for specified profile', async () => {
+      vi.mocked(fs.readFile).mockRejectedValueOnce({ code: 'ENOENT' });
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue();
+      vi.mocked(fs.chmod).mockResolvedValue();
+
+      await configManager.setToken('test-token', 'production');
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const savedData = JSON.parse(writeCall[1] as string);
+      expect(savedData.profiles.production.token).toBe('test-token');
+    });
+  });
+
+  describe('getConfig', () => {
+    it('should return null when no config exists', async () => {
+      vi.mocked(fs.readFile).mockRejectedValueOnce({ code: 'ENOENT' });
+
+      const config = await configManager.getConfig();
+
+      expect(config).toBeNull();
+    });
+
+    it('should return config for default profile', async () => {
+      const mockStore = {
+        profiles: {
+          default: {
+            token: 'test-token',
+            updatedAt: '2024-01-01T00:00:00.000Z',
+          },
+        },
+        defaultProfile: 'default',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+
+      const config = await configManager.getConfig();
+
+      expect(config).toEqual(mockStore.profiles.default);
+    });
+
+    it('should return config for specified profile', async () => {
+      const mockStore = {
+        profiles: {
+          production: {
+            token: 'prod-token',
+            updatedAt: '2024-01-01T00:00:00.000Z',
+          },
+        },
+        defaultProfile: 'default',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+
+      const config = await configManager.getConfig('production');
+
+      expect(config).toEqual(mockStore.profiles.production);
+    });
+  });
+
+  describe('listProfiles', () => {
+    it('should return empty array when no profiles exist', async () => {
+      vi.mocked(fs.readFile).mockRejectedValueOnce({ code: 'ENOENT' });
+
+      const profiles = await configManager.listProfiles();
+
+      expect(profiles).toEqual([]);
+    });
+
+    it('should return all profiles with default flag', async () => {
+      const mockStore = {
+        profiles: {
+          default: {
+            token: 'default-token',
+            updatedAt: '2024-01-01T00:00:00.000Z',
+          },
+          production: {
+            token: 'prod-token',
+            updatedAt: '2024-01-02T00:00:00.000Z',
+          },
+        },
+        defaultProfile: 'default',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+
+      const profiles = await configManager.listProfiles();
+
+      expect(profiles).toHaveLength(2);
+      expect(profiles.find((p) => p.name === 'default')?.isDefault).toBe(true);
+      expect(profiles.find((p) => p.name === 'production')?.isDefault).toBe(false);
+    });
+  });
+
+  describe('useProfile', () => {
+    it('should switch to existing profile', async () => {
+      const mockStore = {
+        profiles: {
+          default: { token: 'default-token', updatedAt: '2024-01-01T00:00:00.000Z' },
+          production: { token: 'prod-token', updatedAt: '2024-01-02T00:00:00.000Z' },
+        },
+        defaultProfile: 'default',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue();
+      vi.mocked(fs.chmod).mockResolvedValue();
+
+      await configManager.useProfile('production');
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const savedData = JSON.parse(writeCall[1] as string);
+      expect(savedData.defaultProfile).toBe('production');
+    });
+
+    it('should throw error when profile does not exist', async () => {
+      const mockStore = {
+        profiles: {
+          default: { token: 'default-token', updatedAt: '2024-01-01T00:00:00.000Z' },
+        },
+        defaultProfile: 'default',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+
+      await expect(configManager.useProfile('nonexistent')).rejects.toThrow(
+        'Profile "nonexistent" does not exist',
+      );
+    });
+  });
+
+  describe('getCurrentProfile', () => {
+    it('should return default profile when none set', async () => {
+      vi.mocked(fs.readFile).mockRejectedValueOnce({ code: 'ENOENT' });
+
+      const profile = await configManager.getCurrentProfile();
+
+      expect(profile).toBe('default');
+    });
+
+    it('should return current profile', async () => {
+      const mockStore = {
+        profiles: {},
+        defaultProfile: 'production',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+
+      const profile = await configManager.getCurrentProfile();
+
+      expect(profile).toBe('production');
+    });
+  });
+
+  describe('clearConfig', () => {
+    it('should remove specified profile', async () => {
+      const mockStore = {
+        profiles: {
+          default: { token: 'default-token', updatedAt: '2024-01-01T00:00:00.000Z' },
+          production: { token: 'prod-token', updatedAt: '2024-01-02T00:00:00.000Z' },
+        },
+        defaultProfile: 'default',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue();
+      vi.mocked(fs.chmod).mockResolvedValue();
+
+      await configManager.clearConfig('production');
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const savedData = JSON.parse(writeCall[1] as string);
+      expect(savedData.profiles.production).toBeUndefined();
+      expect(savedData.profiles.default).toBeDefined();
+    });
+
+    it('should delete config file when last profile removed', async () => {
+      const mockStore = {
+        profiles: {
+          default: { token: 'default-token', updatedAt: '2024-01-01T00:00:00.000Z' },
+        },
+        defaultProfile: 'default',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+      vi.mocked(fs.unlink).mockResolvedValue();
+
+      await configManager.clearConfig('default');
+
+      expect(fs.unlink).toHaveBeenCalledWith(mockConfigPath);
+    });
+
+    it('should set new default when current default is removed', async () => {
+      const mockStore = {
+        profiles: {
+          default: { token: 'default-token', updatedAt: '2024-01-01T00:00:00.000Z' },
+          production: { token: 'prod-token', updatedAt: '2024-01-02T00:00:00.000Z' },
+        },
+        defaultProfile: 'default',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockStore));
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue();
+      vi.mocked(fs.chmod).mockResolvedValue();
+
+      await configManager.clearConfig('default');
+
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const savedData = JSON.parse(writeCall[1] as string);
+      expect(savedData.defaultProfile).toBe('production');
+    });
+  });
+
+  describe('maskToken', () => {
+    it('should mask short tokens completely', () => {
+      const masked = configManager.maskToken('short');
+      expect(masked).toBe('****');
+    });
+
+    it('should mask long tokens showing prefix and suffix', () => {
+      const token = 'test-1234567890-abcdefghijklmnop';
+      const masked = configManager.maskToken(token);
+      expect(masked).toBe('test-****-****-mnop');
+    });
+  });
+
+  describe('migration', () => {
+    it('should migrate old format to new format', async () => {
+      const oldConfig = {
+        token: 'old-token',
+        updatedAt: '2024-01-01T00:00:00.000Z',
+      };
+      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(oldConfig));
+      vi.mocked(fs.mkdir).mockResolvedValue(undefined);
+      vi.mocked(fs.writeFile).mockResolvedValue();
+      vi.mocked(fs.chmod).mockResolvedValue();
+
+      const config = await configManager.getConfig();
+
+      expect(config).toEqual(oldConfig);
+      const writeCall = vi.mocked(fs.writeFile).mock.calls[0];
+      const savedData = JSON.parse(writeCall[1] as string);
+      expect(savedData.profiles.default).toEqual(oldConfig);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should throw error for invalid JSON', async () => {
+      vi.mocked(fs.readFile).mockResolvedValueOnce('invalid json');
+
+      await expect(configManager.getConfig()).rejects.toThrow('Invalid config file format');
+    });
+  });
+});

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

@@ -0,0 +1,179 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import { ChannelOperations } from '../../../src/utils/slack-operations/channel-operations';
+import { WebClient } from '@slack/web-api';
+
+vi.mock('@slack/web-api');
+
+describe('ChannelOperations - refactored listUnreadChannels', () => {
+  let channelOps: ChannelOperations;
+  let mockClient: any;
+
+  beforeEach(() => {
+    vi.resetAllMocks();
+    mockClient = {
+      conversations: {
+        list: vi.fn(),
+        info: vi.fn(),
+        history: vi.fn(),
+      },
+    };
+    channelOps = new ChannelOperations(mockClient as WebClient);
+  });
+
+  describe('listUnreadChannels', () => {
+    it('should fetch unread channels with proper separation of concerns', async () => {
+      const mockChannels = [
+        { id: 'C1', name: 'general' },
+        { id: 'C2', name: 'random' },
+      ];
+
+      mockClient.conversations.list.mockResolvedValueOnce({
+        channels: mockChannels,
+      });
+
+      // Channel 1 - has unread messages
+      mockClient.conversations.info.mockResolvedValueOnce({
+        channel: { id: 'C1', last_read: '1234567890.000000' },
+      });
+      mockClient.conversations.history
+        .mockResolvedValueOnce({ messages: [{ ts: '1234567900.000000' }] }) // latest message
+        .mockResolvedValueOnce({ messages: [{ ts: '1234567900.000000' }, { ts: '1234567895.000000' }] }); // messages after last_read
+
+      // Channel 2 - no unread messages
+      mockClient.conversations.info.mockResolvedValueOnce({
+        channel: { id: 'C2', last_read: '1234567900.000000' },
+      });
+      mockClient.conversations.history
+        .mockResolvedValueOnce({ messages: [{ ts: '1234567890.000000' }] }) // latest message
+        .mockResolvedValueOnce({ messages: [] }); // no messages after last_read
+
+      const result = await channelOps.listUnreadChannels();
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        id: 'C1',
+        name: 'general',
+        unread_count: 2,
+        unread_count_display: 2,
+      });
+
+      // Verify the separation of concerns - each method is called appropriately
+      expect(mockClient.conversations.list).toHaveBeenCalledOnce();
+      expect(mockClient.conversations.info).toHaveBeenCalledTimes(2);
+      expect(mockClient.conversations.history).toHaveBeenCalledTimes(4);
+    });
+
+    it('should handle channels with no last_read timestamp', async () => {
+      const mockChannels = [
+        { id: 'C1', name: 'general' },
+      ];
+
+      mockClient.conversations.list.mockResolvedValueOnce({
+        channels: mockChannels,
+      });
+
+      mockClient.conversations.info.mockResolvedValueOnce({
+        channel: { id: 'C1' }, // no last_read
+      });
+
+      mockClient.conversations.history
+        .mockResolvedValueOnce({ messages: [{ ts: '1234567900.000000' }] }) // check if has messages
+        .mockResolvedValueOnce({ 
+          messages: [
+            { ts: '1234567900.000000' },
+            { ts: '1234567895.000000' },
+            { ts: '1234567890.000000' },
+          ]
+        }); // all messages are unread
+
+      const result = await channelOps.listUnreadChannels();
+
+      expect(result).toHaveLength(1);
+      expect(result[0]).toMatchObject({
+        id: 'C1',
+        name: 'general',
+        unread_count: 3,
+        unread_count_display: 3,
+      });
+    });
+
+    it('should skip channels with no messages', async () => {
+      const mockChannels = [
+        { id: 'C1', name: 'general' },
+      ];
+
+      mockClient.conversations.list.mockResolvedValueOnce({
+        channels: mockChannels,
+      });
+
+      mockClient.conversations.info.mockResolvedValueOnce({
+        channel: { id: 'C1', last_read: '1234567890.000000' },
+      });
+
+      mockClient.conversations.history
+        .mockResolvedValueOnce({ messages: [] }); // no messages at all
+
+      const result = await channelOps.listUnreadChannels();
+
+      expect(result).toHaveLength(0);
+    });
+
+    it('should handle rate limit errors gracefully', async () => {
+      const mockChannels = [
+        { id: 'C1', name: 'general' },
+        { id: 'C2', name: 'random' },
+      ];
+
+      mockClient.conversations.list.mockResolvedValueOnce({
+        channels: mockChannels,
+      });
+
+      // Channel 1 - rate limited
+      mockClient.conversations.info.mockRejectedValueOnce(new Error('rate_limited'));
+
+      // Channel 2 - successful
+      mockClient.conversations.info.mockResolvedValueOnce({
+        channel: { id: 'C2', last_read: '1234567890.000000' },
+      });
+      mockClient.conversations.history
+        .mockResolvedValueOnce({ messages: [{ ts: '1234567900.000000' }] })
+        .mockResolvedValueOnce({ messages: [{ ts: '1234567900.000000' }] });
+
+      const result = await channelOps.listUnreadChannels();
+
+      expect(result).toHaveLength(1);
+      expect(result[0].id).toBe('C2');
+    });
+  });
+
+  describe('private methods (indirectly tested)', () => {
+    it('fetchAllChannels should handle large channel lists', async () => {
+      const mockChannels = [
+        { id: 'C1', name: 'channel-1' },
+        { id: 'C2', name: 'channel-2' },
+        { id: 'C3', name: 'channel-3' },
+      ];
+
+      mockClient.conversations.list.mockResolvedValueOnce({
+        channels: mockChannels,
+      });
+
+      // Mock all channels having no unread messages for simplicity
+      mockChannels.forEach(() => {
+        mockClient.conversations.info.mockResolvedValueOnce({
+          channel: { last_read: '9999999999.000000' },
+        });
+        mockClient.conversations.history.mockResolvedValueOnce({ messages: [] });
+      });
+
+      const result = await channelOps.listUnreadChannels();
+
+      expect(result).toHaveLength(0);
+      expect(mockClient.conversations.list).toHaveBeenCalledWith({
+        types: 'public_channel,private_channel,im,mpim',
+        exclude_archived: true,
+        limit: 1000,
+      });
+    });
+  });
+});

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

@@ -0,0 +1,33 @@
+import { describe, it, expect } from 'vitest';
+import { maskToken } from '../../src/utils/token-utils';
+
+describe('token-utils', () => {
+  describe('maskToken', () => {
+    it('should mask short tokens completely', () => {
+      expect(maskToken('short')).toBe('****');
+      expect(maskToken('123456789')).toBe('****');
+      expect(maskToken('')).toBe('****');
+    });
+
+    it('should mask long tokens showing prefix and suffix', () => {
+      const token = 'test-1234567890-abcdefghijklmnop';
+      expect(maskToken(token)).toBe('test-****-****-mnop');
+    });
+
+    it('should handle tokens of exactly minimum length + 1', () => {
+      const token = '1234567890'; // 10 characters
+      expect(maskToken(token)).toBe('1234-****-****-7890');
+    });
+
+    it('should handle various token formats', () => {
+      expect(maskToken('test-123456789012345')).toBe('test-****-****-2345');
+      expect(maskToken('demo-2-123456789012345')).toBe('demo-****-****-2345');
+      expect(maskToken('1234567890123456789012345')).toBe('1234-****-****-2345');
+    });
+
+    it('should handle tokens with special characters', () => {
+      expect(maskToken('test-token-with-dashes')).toBe('test-****-****-shes');
+      expect(maskToken('token_with_underscores')).toBe('toke-****-****-ores');
+    });
+  });
+});