@urugus/slack-cli 0.2.11 → 0.2.13

package/tests/utils/option-parsers.test.ts

@@ -1,173 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  parseFormat,
-  parseLimit,
-  parseBoolean,
-  parseCount,
-  parseProfile,
-  parseListOptions,
-  OPTION_DEFAULTS,
-} from '../../src/utils/option-parsers';
-
-describe('option-parsers', () => {
-  describe('parseFormat', () => {
-    it('should return default format when undefined', () => {
-      expect(parseFormat(undefined)).toBe('table');
-    });
-
-    it('should return custom default format when specified', () => {
-      expect(parseFormat(undefined, 'json')).toBe('json');
-    });
-
-    it('should return provided format', () => {
-      expect(parseFormat('compact')).toBe('compact');
-    });
-
-    it('should handle empty string', () => {
-      expect(parseFormat('')).toBe('table');
-    });
-  });
-
-  describe('parseLimit', () => {
-    it('should return default limit when undefined', () => {
-      expect(parseLimit(undefined, 100)).toBe(100);
-    });
-
-    it('should parse string limit', () => {
-      expect(parseLimit('50', 100)).toBe(50);
-    });
-
-    it('should handle invalid number string', () => {
-      expect(parseLimit('abc', 100)).toBe(NaN);
-    });
-
-    it('should handle empty string', () => {
-      expect(parseLimit('', 100)).toBe(100);
-    });
-  });
-
-  describe('parseBoolean', () => {
-    it('should return default value when undefined', () => {
-      expect(parseBoolean(undefined)).toBe(false);
-      expect(parseBoolean(undefined, true)).toBe(true);
-    });
-
-    it('should return provided boolean value', () => {
-      expect(parseBoolean(true)).toBe(true);
-      expect(parseBoolean(false)).toBe(false);
-    });
-
-    it('should handle explicit false over default true', () => {
-      expect(parseBoolean(false, true)).toBe(false);
-    });
-  });
-
-  describe('parseCount', () => {
-    it('should return default count when undefined', () => {
-      expect(parseCount(undefined, 10)).toBe(10);
-    });
-
-    it('should parse string count', () => {
-      expect(parseCount('25', 10)).toBe(25);
-    });
-
-    it('should handle invalid number string', () => {
-      expect(parseCount('invalid', 10)).toBe(10);
-    });
-
-    it('should enforce minimum value', () => {
-      expect(parseCount('5', 10, 10, 100)).toBe(10);
-    });
-
-    it('should enforce maximum value', () => {
-      expect(parseCount('150', 10, 10, 100)).toBe(100);
-    });
-
-    it('should allow values within range', () => {
-      expect(parseCount('50', 10, 10, 100)).toBe(50);
-    });
-
-    it('should handle empty string', () => {
-      expect(parseCount('', 20)).toBe(20);
-    });
-  });
-
-  describe('parseProfile', () => {
-    it('should return undefined when not provided', () => {
-      expect(parseProfile(undefined)).toBeUndefined();
-    });
-
-    it('should return provided profile', () => {
-      expect(parseProfile('production')).toBe('production');
-    });
-
-    it('should handle empty string', () => {
-      expect(parseProfile('')).toBe('');
-    });
-  });
-
-  describe('parseListOptions', () => {
-    it('should use all defaults when no options provided', () => {
-      const result = parseListOptions({});
-      expect(result).toEqual({
-        format: 'table',
-        limit: 100,
-        countOnly: false,
-      });
-    });
-
-    it('should override specific options', () => {
-      const result = parseListOptions({
-        format: 'json',
-        limit: '50',
-        countOnly: true,
-      });
-      expect(result).toEqual({
-        format: 'json',
-        limit: 50,
-        countOnly: true,
-      });
-    });
-
-    it('should use custom defaults', () => {
-      const result = parseListOptions({}, {
-        format: 'compact',
-        limit: 200,
-        countOnly: true,
-      });
-      expect(result).toEqual({
-        format: 'compact',
-        limit: 200,
-        countOnly: true,
-      });
-    });
-
-    it('should override custom defaults with provided options', () => {
-      const result = parseListOptions(
-        {
-          format: 'json',
-        },
-        {
-          format: 'compact',
-          limit: 200,
-        }
-      );
-      expect(result).toEqual({
-        format: 'json',
-        limit: 200,
-        countOnly: false,
-      });
-    });
-  });
-
-  describe('OPTION_DEFAULTS', () => {
-    it('should have expected default values', () => {
-      expect(OPTION_DEFAULTS).toEqual({
-        format: 'table',
-        limit: 100,
-        countOnly: false,
-        includeArchived: false,
-      });
-    });
-  });
-});

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

@@ -1,282 +0,0 @@
-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/schedule-utils.test.ts

@@ -1,63 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { parseScheduledTimestamp, resolvePostAt } from '../../src/utils/schedule-utils';
-import { optionValidators } from '../../src/utils/validators';
-
-describe('schedule utils', () => {
-  describe('parseScheduledTimestamp', () => {
-    it('parses unix timestamp seconds', () => {
-      expect(parseScheduledTimestamp('1770855000')).toBe(1770855000);
-    });
-
-    it('parses ISO date string', () => {
-      expect(parseScheduledTimestamp('2026-02-12T00:10:00Z')).toBe(1770855000);
-    });
-
-    it('returns null for invalid input', () => {
-      expect(parseScheduledTimestamp('invalid')).toBeNull();
-    });
-  });
-
-  describe('resolvePostAt', () => {
-    it('returns parsed timestamp for --at', () => {
-      expect(resolvePostAt('1770855000', undefined)).toBe(1770855000);
-    });
-
-    it('returns now + minutes for --after', () => {
-      expect(resolvePostAt(undefined, '10', Date.parse('2026-02-12T00:00:00Z'))).toBe(1770855000);
-    });
-
-    it('returns null when invalid --after is provided', () => {
-      expect(resolvePostAt(undefined, '0')).toBeNull();
-      expect(resolvePostAt(undefined, '1.5')).toBeNull();
-      expect(resolvePostAt(undefined, '10minutes')).toBeNull();
-    });
-  });
-
-  describe('optionValidators.scheduleTiming', () => {
-    it('rejects both --at and --after', () => {
-      expect(optionValidators.scheduleTiming({ at: '1770855000', after: '10' })).toBe(
-        'Cannot use both --at and --after'
-      );
-    });
-
-    it('rejects past --at timestamp', () => {
-      vi.useFakeTimers();
-      vi.setSystemTime(new Date('2026-02-12T00:00:00Z'));
-
-      expect(optionValidators.scheduleTiming({ at: '1770854300' })).toBe(
-        'Schedule time must be in the future'
-      );
-
-      vi.useRealTimers();
-    });
-
-    it('rejects non-integer --after values', () => {
-      expect(optionValidators.scheduleTiming({ after: '1.5' })).toBe(
-        '--after must be a positive integer (minutes)'
-      );
-      expect(optionValidators.scheduleTiming({ after: '10minutes' })).toBe(
-        '--after must be a positive integer (minutes)'
-      );
-    });
-  });
-});