@urugus/slack-cli 0.2.11 → 0.2.13

package/tests/utils/channel-resolver.test.ts

@@ -1,161 +0,0 @@
-import { describe, it, expect, beforeEach, vi } from 'vitest';
-import { ChannelResolver } from '../../src/utils/channel-resolver';
-import { Channel } from '../../src/utils/slack-api-client';
-
-describe('ChannelResolver', () => {
-  let resolver: ChannelResolver;
-  let mockChannels: Channel[];
-
-  beforeEach(() => {
-    resolver = new ChannelResolver();
-    mockChannels = [
-      {
-        id: 'C1234567890',
-        name: 'general',
-        is_private: false,
-        created: 1234567890,
-        is_member: true,
-      },
-      {
-        id: 'C0987654321',
-        name: 'random',
-        is_private: false,
-        created: 1234567890,
-        is_member: true,
-      },
-      {
-        id: 'C1111111111',
-        name: 'dev-team',
-        is_private: false,
-        created: 1234567890,
-        is_member: true,
-        name_normalized: 'dev-team',
-      },
-      {
-        id: 'G1234567890',
-        name: 'private-channel',
-        is_private: true,
-        created: 1234567890,
-        is_member: true,
-      },
-    ];
-  });
-
-  describe('isChannelId', () => {
-    it('should identify channel IDs with valid format', () => {
-      expect(resolver.isChannelId('C1234567890')).toBe(true);
-      expect(resolver.isChannelId('D1234567890')).toBe(true);
-      expect(resolver.isChannelId('G1234567890')).toBe(true);
-    });
-
-    it('should return false for channel names or malformed IDs', () => {
-      expect(resolver.isChannelId('general')).toBe(false);
-      expect(resolver.isChannelId('#general')).toBe(false);
-      expect(resolver.isChannelId('General')).toBe(false);
-      expect(resolver.isChannelId('Dev')).toBe(false);
-      expect(resolver.isChannelId('C123')).toBe(false);
-    });
-  });
-
-  describe('findChannel', () => {
-    it('should find channel by exact name match', () => {
-      const result = resolver.findChannel('general', mockChannels);
-      expect(result).toEqual(mockChannels[0]);
-    });
-
-    it('should find channel by name without # prefix', () => {
-      const result = resolver.findChannel('#general', mockChannels);
-      expect(result).toEqual(mockChannels[0]);
-    });
-
-    it('should find channel by case-insensitive match', () => {
-      const result = resolver.findChannel('GENERAL', mockChannels);
-      expect(result).toEqual(mockChannels[0]);
-    });
-
-    it('should find channel by normalized name', () => {
-      const result = resolver.findChannel('dev-team', mockChannels);
-      expect(result).toEqual(mockChannels[2]);
-    });
-
-    it('should return undefined when channel not found', () => {
-      const result = resolver.findChannel('nonexistent', mockChannels);
-      expect(result).toBeUndefined();
-    });
-  });
-
-  describe('getSimilarChannels', () => {
-    it('should find similar channels by partial match', () => {
-      const result = resolver.getSimilarChannels('gen', mockChannels);
-      expect(result).toEqual(['general']);
-    });
-
-    it('should limit results to specified count', () => {
-      const manyChannels = [
-        ...mockChannels,
-        { id: 'C9999999999', name: 'general-2', is_private: false, created: 0 },
-        { id: 'C8888888888', name: 'general-3', is_private: false, created: 0 },
-      ];
-      const result = resolver.getSimilarChannels('general', manyChannels, 2);
-      expect(result).toHaveLength(2);
-    });
-
-    it('should return empty array when no similar channels found', () => {
-      const result = resolver.getSimilarChannels('xyz', mockChannels);
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe('resolveChannelError', () => {
-    it('should create error with suggestions when similar channels exist', () => {
-      const error = resolver.resolveChannelError('genera', mockChannels);
-      expect(error.message).toContain("Channel 'genera' not found");
-      expect(error.message).toContain('Did you mean one of these?');
-      expect(error.message).toContain('general');
-    });
-
-    it('should create error without suggestions when no similar channels', () => {
-      const error = resolver.resolveChannelError('xyz', mockChannels);
-      expect(error.message).toContain("Channel 'xyz' not found");
-      expect(error.message).toContain('Make sure you are a member of this channel');
-      expect(error.message).not.toContain('Did you mean');
-    });
-  });
-
-  describe('resolveChannelId', () => {
-    it('should return ID directly if already an ID', async () => {
-      const getChannelsFn = vi.fn();
-      const result = await resolver.resolveChannelId('C1234567890', getChannelsFn);
-      expect(result).toBe('C1234567890');
-      expect(getChannelsFn).not.toHaveBeenCalled();
-    });
-
-    it('should resolve channel name to ID', async () => {
-      const getChannelsFn = vi.fn().mockResolvedValue(mockChannels);
-      const result = await resolver.resolveChannelId('general', getChannelsFn);
-      expect(result).toBe('C1234567890');
-      expect(getChannelsFn).toHaveBeenCalled();
-    });
-
-    it('should resolve mixed-case channel names to ID', async () => {
-      const getChannelsFn = vi.fn().mockResolvedValue(mockChannels);
-      const result = await resolver.resolveChannelId('General', getChannelsFn);
-      expect(result).toBe('C1234567890');
-      expect(getChannelsFn).toHaveBeenCalled();
-    });
-
-    it('should throw error when channel not found', async () => {
-      const getChannelsFn = vi.fn().mockResolvedValue(mockChannels);
-      await expect(resolver.resolveChannelId('nonexistent', getChannelsFn)).rejects.toThrow(
-        "Channel 'nonexistent' not found"
-      );
-    });
-
-    it('should include suggestions in error when similar channels exist', async () => {
-      const getChannelsFn = vi.fn().mockResolvedValue(mockChannels);
-      await expect(resolver.resolveChannelId('genera', getChannelsFn)).rejects.toThrow(
-        'Did you mean one of these? general'
-      );
-    });
-  });
-});

package/tests/utils/config/config-file-manager.test.ts

@@ -1,118 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs/promises';
-import * as os from 'os';
-import * as path from 'path';
-import { ConfigFileManager } from '../../../src/utils/config/config-file-manager';
-
-vi.mock('fs/promises');
-vi.mock('os');
-
-describe('ConfigFileManager', () => {
-  let manager: ConfigFileManager;
-  const mockHomeDir = '/home/user';
-  const mockConfigPath = path.join(mockHomeDir, '.slack-cli', 'config.json');
-
-  beforeEach(() => {
-    vi.mocked(os.homedir).mockReturnValue(mockHomeDir);
-    manager = new ConfigFileManager();
-  });
-
-  afterEach(() => {
-    vi.clearAllMocks();
-  });
-
-  describe('read', () => {
-    it('should read and parse config file when it exists', async () => {
-      const mockConfig = {
-        profiles: { default: { token: 'encrypted-token' } },
-        currentProfile: 'default'
-      };
-      vi.mocked(fs.access).mockResolvedValueOnce(undefined);
-      vi.mocked(fs.readFile).mockResolvedValueOnce(JSON.stringify(mockConfig));
-
-      const result = await manager.read();
-
-      expect(result).toEqual(mockConfig);
-      expect(fs.readFile).toHaveBeenCalledWith(mockConfigPath, 'utf-8');
-    });
-
-    it('should return default config when file does not exist', async () => {
-      vi.mocked(fs.access).mockRejectedValueOnce(new Error('ENOENT'));
-
-      const result = await manager.read();
-
-      expect(result).toEqual({
-        profiles: {},
-        currentProfile: 'default'
-      });
-    });
-
-    it('should throw error for invalid JSON', async () => {
-      vi.mocked(fs.access).mockResolvedValueOnce(undefined);
-      vi.mocked(fs.readFile).mockResolvedValueOnce('invalid json');
-
-      await expect(manager.read()).rejects.toThrow('Invalid configuration file');
-    });
-  });
-
-  describe('write', () => {
-    it('should create directory and write config file', async () => {
-      const mockConfig = {
-        profiles: { default: { token: 'encrypted-token' } },
-        currentProfile: 'default'
-      };
-      vi.mocked(fs.mkdir).mockResolvedValueOnce(undefined as any);
-      vi.mocked(fs.writeFile).mockResolvedValueOnce(undefined);
-
-      await manager.write(mockConfig);
-
-      expect(fs.mkdir).toHaveBeenCalledWith(
-        path.dirname(mockConfigPath),
-        { recursive: true }
-      );
-      expect(fs.writeFile).toHaveBeenCalledWith(
-        mockConfigPath,
-        JSON.stringify(mockConfig, null, 2),
-        'utf-8'
-      );
-    });
-
-    it('should handle write errors', async () => {
-      const mockConfig = {
-        profiles: {},
-        currentProfile: 'default'
-      };
-      vi.mocked(fs.mkdir).mockResolvedValueOnce(undefined as any);
-      vi.mocked(fs.writeFile).mockRejectedValueOnce(new Error('Write failed'));
-
-      await expect(manager.write(mockConfig)).rejects.toThrow('Write failed');
-    });
-  });
-
-  describe('exists', () => {
-    it('should return true when config file exists', async () => {
-      vi.mocked(fs.access).mockResolvedValueOnce(undefined);
-
-      const result = await manager.exists();
-
-      expect(result).toBe(true);
-      expect(fs.access).toHaveBeenCalledWith(mockConfigPath);
-    });
-
-    it('should return false when config file does not exist', async () => {
-      vi.mocked(fs.access).mockRejectedValueOnce(new Error('ENOENT'));
-
-      const result = await manager.exists();
-
-      expect(result).toBe(false);
-    });
-  });
-
-  describe('getConfigPath', () => {
-    it('should return the correct config path', () => {
-      const result = manager.getConfigPath();
-
-      expect(result).toBe(mockConfigPath);
-    });
-  });
-});

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

@@ -1,266 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { ProfileManager } from '../../../src/utils/config/profile-manager';
-import { ConfigFileManager } from '../../../src/utils/config/config-file-manager';
-import { TokenCryptoService } from '../../../src/utils/config/token-crypto-service';
-import { Config } from '../../../src/types/config';
-
-vi.mock('../../../src/utils/config/config-file-manager');
-vi.mock('../../../src/utils/config/token-crypto-service');
-
-describe('ProfileManager', () => {
-  let manager: ProfileManager;
-  let mockFileManager: ConfigFileManager;
-  let mockCryptoService: TokenCryptoService;
-
-  beforeEach(() => {
-    mockFileManager = new ConfigFileManager();
-    mockCryptoService = new TokenCryptoService();
-    manager = new ProfileManager(mockFileManager, mockCryptoService);
-    
-    vi.clearAllMocks();
-  });
-
-  describe('getProfile', () => {
-    it('should get and decrypt a profile token', async () => {
-      const mockConfig = {
-        profiles: {
-          test: { token: 'encrypted-token', updatedAt: '2024-01-01' }
-        },
-        currentProfile: 'test'
-      };
-      
-      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
-      vi.mocked(mockCryptoService.isEncrypted).mockReturnValueOnce(true);
-      vi.mocked(mockCryptoService.decrypt).mockReturnValueOnce('decrypted-token');
-
-      const result = await manager.getProfile('test');
-
-      expect(result).toEqual({
-        token: 'decrypted-token',
-        updatedAt: '2024-01-01'
-      });
-      expect(mockCryptoService.decrypt).toHaveBeenCalledWith('encrypted-token');
-    });
-
-    it('should throw error if profile does not exist', async () => {
-      const mockConfig = {
-        profiles: {},
-        currentProfile: 'default'
-      };
-      
-      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
-
-      await expect(manager.getProfile('nonexistent')).rejects.toThrow(
-        'Profile "nonexistent" not found'
-      );
-    });
-
-    it('should handle already decrypted tokens', async () => {
-      const mockConfig = {
-        profiles: {
-          test: { token: 'plain-token', updatedAt: '2024-01-01' }
-        },
-        currentProfile: 'test'
-      };
-      
-      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
-      vi.mocked(mockCryptoService.isEncrypted).mockReturnValueOnce(false);
-
-      const result = await manager.getProfile('test');
-
-      expect(result).toEqual({
-        token: 'plain-token',
-        updatedAt: '2024-01-01'
-      });
-      expect(mockCryptoService.decrypt).not.toHaveBeenCalled();
-    });
-  });
-
-  describe('setProfile', () => {
-    it('should set and encrypt a profile token', async () => {
-      const mockConfig = {
-        profiles: {},
-        currentProfile: 'default'
-      };
-      const newProfile: Config = {
-        token: 'new-token',
-        updatedAt: '2024-01-01'
-      };
-      
-      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
-      vi.mocked(mockCryptoService.encrypt).mockReturnValueOnce('encrypted-new-token');
-      vi.mocked(mockFileManager.write).mockResolvedValueOnce(undefined);
-
-      await manager.setProfile('test', newProfile);
-
-      expect(mockCryptoService.encrypt).toHaveBeenCalledWith('new-token');
-      expect(mockFileManager.write).toHaveBeenCalledWith({
-        profiles: {
-          test: { token: 'encrypted-new-token', updatedAt: '2024-01-01' }
-        },
-        currentProfile: 'default'
-      });
-    });
-
-    it('should update existing profile', async () => {
-      const mockConfig = {
-        profiles: {
-          test: { token: 'old-encrypted', updatedAt: '2024-01-01' }
-        },
-        currentProfile: 'test'
-      };
-      const updatedProfile: Config = {
-        token: 'updated-token',
-        updatedAt: '2024-01-02'
-      };
-      
-      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
-      vi.mocked(mockCryptoService.encrypt).mockReturnValueOnce('encrypted-updated-token');
-      vi.mocked(mockFileManager.write).mockResolvedValueOnce(undefined);
-
-      await manager.setProfile('test', updatedProfile);
-
-      expect(mockFileManager.write).toHaveBeenCalledWith({
-        profiles: {
-          test: { token: 'encrypted-updated-token', updatedAt: '2024-01-02' }
-        },
-        currentProfile: 'test'
-      });
-    });
-  });
-
-  describe('deleteProfile', () => {
-    it('should delete a profile', async () => {
-      const mockConfig = {
-        profiles: {
-          test: { token: 'encrypted-token', updatedAt: '2024-01-01' },
-          another: { token: 'another-token', updatedAt: '2024-01-01' }
-        },
-        currentProfile: 'test'
-      };
-      
-      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
-      vi.mocked(mockFileManager.write).mockResolvedValueOnce(undefined);
-
-      await manager.deleteProfile('test');
-
-      expect(mockFileManager.write).toHaveBeenCalledWith({
-        profiles: {
-          another: { token: 'another-token', updatedAt: '2024-01-01' }
-        },
-        currentProfile: 'test'
-      });
-    });
-
-    it('should throw error if trying to delete non-existent profile', async () => {
-      const mockConfig = {
-        profiles: {},
-        currentProfile: 'default'
-      };
-      
-      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
-
-      await expect(manager.deleteProfile('nonexistent')).rejects.toThrow(
-        'Profile "nonexistent" not found'
-      );
-    });
-  });
-
-  describe('listProfiles', () => {
-    it('should list all profile names', async () => {
-      const mockConfig = {
-        profiles: {
-          default: { token: 'token1', updatedAt: '2024-01-01' },
-          work: { token: 'token2', updatedAt: '2024-01-01' },
-          personal: { token: 'token3', updatedAt: '2024-01-01' }
-        },
-        currentProfile: 'default'
-      };
-      
-      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
-
-      const result = await manager.listProfiles();
-
-      expect(result).toEqual(['default', 'work', 'personal']);
-    });
-
-    it('should return empty array if no profiles', async () => {
-      const mockConfig = {
-        profiles: {},
-        currentProfile: 'default'
-      };
-      
-      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
-
-      const result = await manager.listProfiles();
-
-      expect(result).toEqual([]);
-    });
-  });
-
-  describe('getCurrentProfile', () => {
-    it('should return the current profile name', async () => {
-      const mockConfig = {
-        profiles: {
-          test: { token: 'token', updatedAt: '2024-01-01' }
-        },
-        currentProfile: 'test'
-      };
-      
-      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
-
-      const result = await manager.getCurrentProfile();
-
-      expect(result).toBe('test');
-    });
-
-    it('should return default if no current profile set', async () => {
-      const mockConfig = {
-        profiles: {},
-        currentProfile: 'default'
-      };
-      
-      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
-
-      const result = await manager.getCurrentProfile();
-
-      expect(result).toBe('default');
-    });
-  });
-
-  describe('setCurrentProfile', () => {
-    it('should set the current profile', async () => {
-      const mockConfig = {
-        profiles: {
-          test: { token: 'token', updatedAt: '2024-01-01' }
-        },
-        currentProfile: 'default'
-      };
-      
-      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
-      vi.mocked(mockFileManager.write).mockResolvedValueOnce(undefined);
-
-      await manager.setCurrentProfile('test');
-
-      expect(mockFileManager.write).toHaveBeenCalledWith({
-        profiles: {
-          test: { token: 'token', updatedAt: '2024-01-01' }
-        },
-        currentProfile: 'test'
-      });
-    });
-
-    it('should throw error if profile does not exist', async () => {
-      const mockConfig = {
-        profiles: {},
-        currentProfile: 'default'
-      };
-      
-      vi.mocked(mockFileManager.read).mockResolvedValueOnce(mockConfig);
-
-      await expect(manager.setCurrentProfile('nonexistent')).rejects.toThrow(
-        'Profile "nonexistent" not found'
-      );
-    });
-  });
-});

package/tests/utils/config/token-crypto-service.test.ts

@@ -1,98 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { TokenCryptoService } from '../../../src/utils/config/token-crypto-service';
-
-describe('TokenCryptoService', () => {
-  let service: TokenCryptoService;
-
-  beforeEach(() => {
-    service = new TokenCryptoService();
-  });
-
-  describe('encrypt and decrypt', () => {
-    it('should encrypt and decrypt a token correctly', () => {
-      const originalToken = 'test-token-1234567890-abcdefghijklmnop';
-      
-      const encrypted = service.encrypt(originalToken);
-      expect(encrypted).not.toBe(originalToken);
-      expect(encrypted.length).toBeGreaterThan(0);
-      
-      const decrypted = service.decrypt(encrypted);
-      expect(decrypted).toBe(originalToken);
-    });
-
-    it('should produce different encrypted values for the same token', () => {
-      const token = 'test-token-1234567890-abcdefghijklmnop';
-      
-      const encrypted1 = service.encrypt(token);
-      const encrypted2 = service.encrypt(token);
-      
-      // Different encrypted values due to random IV
-      expect(encrypted1).not.toBe(encrypted2);
-      
-      // But both decrypt to the same value
-      expect(service.decrypt(encrypted1)).toBe(token);
-      expect(service.decrypt(encrypted2)).toBe(token);
-    });
-
-    it('should handle empty token', () => {
-      const emptyToken = '';
-      
-      const encrypted = service.encrypt(emptyToken);
-      expect(encrypted.length).toBeGreaterThan(0);
-      
-      const decrypted = service.decrypt(encrypted);
-      expect(decrypted).toBe(emptyToken);
-    });
-
-    it('should handle special characters in token', () => {
-      const specialToken = 'test-!@#$%^&*()_+-=[]{}|;:,.<>?';
-      
-      const encrypted = service.encrypt(specialToken);
-      const decrypted = service.decrypt(encrypted);
-      
-      expect(decrypted).toBe(specialToken);
-    });
-
-    it('should handle very long tokens', () => {
-      const longToken = 'x'.repeat(1000);
-      
-      const encrypted = service.encrypt(longToken);
-      const decrypted = service.decrypt(encrypted);
-      
-      expect(decrypted).toBe(longToken);
-    });
-  });
-
-  describe('decrypt error handling', () => {
-    it('should throw error for invalid encrypted data', () => {
-      expect(() => service.decrypt('invalid-data')).toThrow('Failed to decrypt token');
-    });
-
-    it('should throw error for empty encrypted data', () => {
-      expect(() => service.decrypt('')).toThrow('Failed to decrypt token');
-    });
-
-    it('should throw error for malformed encrypted data', () => {
-      // Missing IV separator
-      expect(() => service.decrypt('aabbccdd')).toThrow('Failed to decrypt token');
-    });
-  });
-
-  describe('isEncrypted', () => {
-    it('should return true for encrypted tokens', () => {
-      const token = 'test-token-1234567890';
-      const encrypted = service.encrypt(token);
-      
-      expect(service.isEncrypted(encrypted)).toBe(true);
-    });
-
-    it('should return false for plain tokens', () => {
-      expect(service.isEncrypted('test-token-1234567890')).toBe(false);
-      expect(service.isEncrypted('plain-text')).toBe(false);
-    });
-
-    it('should return false for empty string', () => {
-      expect(service.isEncrypted('')).toBe(false);
-    });
-  });
-});