bbk-cli 1.1.2 → 1.2.0

package/tests/unit/utils/config-loader.test.ts

@@ -1,158 +1,493 @@
 import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-
-import { loadConfig } from '../../../src/utils/config-loader.js';
+import os from 'node:os';
+import path from 'node:path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { loadConfig, setupConfig } from '../../../src/utils/config-loader.js';
+
+// Create shared mock interface for readline
+const mockQuestion = vi.fn();
+const mockClose = vi.fn();
+const mockOn = vi.fn();
+
+const mockRlInterface = {
+  question: mockQuestion,
+  close: mockClose,
+  on: mockOn,
+  write: vi.fn(),
+};
+
+// Mock readline at module level
+vi.mock('readline', () => ({
+  default: {
+    createInterface: vi.fn(() => mockRlInterface),
+  },
+}));
 
 describe('config-loader', () => {
-  let testDir: string;
+  describe('loadConfig', () => {
+    let testConfigDir: string;
+    let homedirSpy: vi.SpyInstance;
 
-  beforeEach(() => {
-    // Create a temporary directory for test configs
-    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bbk-cli-test-'));
-    fs.mkdirSync(path.join(testDir, '.claude'));
-  });
+    beforeEach(() => {
+      // Create a temporary directory for test configs
+      testConfigDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bbk-cli-test-'));
 
-  afterEach(() => {
-    // Clean up test directory
-    fs.rmSync(testDir, { recursive: true, force: true });
-  });
+      // Spy on os.homedir() to return test directory (works on all platforms)
+      homedirSpy = vi.spyOn(os, 'homedir').mockReturnValue(testConfigDir);
+    });
 
-  describe('loadConfig', () => {
-    it('should load valid Bitbucket configuration file', () => {
-      const configContent = `---
-profiles:
-  cloud:
-    email: user@example.com
-    apiToken: app_token_here
-  staging:
-    email: staging@example.com
-    apiToken: staging_token_here
-
-defaultProfile: cloud
-defaultFormat: json
----
-
-# Bitbucket Connection Profiles
-`;
+    afterEach(() => {
+      // Clean up test directory
+      if (testConfigDir) {
+        fs.rmSync(testConfigDir, { recursive: true, force: true });
+      }
 
-      const configPath = path.join(testDir, '.claude', 'bitbucket-config.local.md');
-      fs.writeFileSync(configPath, configContent);
+      // Restore original os.homedir()
+      homedirSpy.mockRestore();
 
-      const config = loadConfig(testDir);
+      // Clear mock calls
+      vi.clearAllMocks();
+    });
 
-      expect(config.profiles).toBeDefined();
-      expect(config.profiles.cloud).toBeDefined();
-      expect(config.profiles.cloud.email).toBe('user@example.com');
-      expect(config.profiles.cloud.apiToken).toBe('app_token_here');
+    it('should load valid INI configuration file', async () => {
+      const configContent = `[auth]
+email=user@example.com
+api_token=app_token_here
 
-      expect(config.profiles.staging).toBeDefined();
-      expect(config.profiles.staging.apiToken).toBe('staging_token_here');
+[defaults]
+workspace=myworkspace
+format=json
+`;
 
-      expect(config.defaultProfile).toBe('cloud');
-      expect(config.defaultFormat).toBe('json');
-    });
+      const configPath = path.join(testConfigDir, '.bbkcli');
+      fs.writeFileSync(configPath, configContent);
 
-    it('should throw error if config file does not exist', () => {
-      expect(() => loadConfig(testDir)).toThrow('Configuration file not found');
+      const config = await loadConfig();
+
+      expect(config.email).toBe('user@example.com');
+      expect(config.apiToken).toBe('app_token_here');
+      expect(config.defaultWorkspace).toBe('myworkspace');
+      expect(config.defaultFormat).toBe('json');
     });
 
-    it('should throw error if frontmatter is missing', () => {
-      const configContent = `# Bitbucket Connection Profiles
+    it('should load config without optional default workspace', async () => {
+      const configContent = `[auth]
+email=user@example.com
+api_token=app_token_here
 
-This is just markdown content without frontmatter.
+[defaults]
+format=json
 `;
 
-      const configPath = path.join(testDir, '.claude', 'bitbucket-config.local.md');
+      const configPath = path.join(testConfigDir, '.bbkcli');
       fs.writeFileSync(configPath, configContent);
 
-      expect(() => loadConfig(testDir)).toThrow('Invalid configuration file format');
+      const config = await loadConfig();
+
+      expect(config.email).toBe('user@example.com');
+      expect(config.apiToken).toBe('app_token_here');
+      expect(config.defaultWorkspace).toBeUndefined();
+      expect(config.defaultFormat).toBe('json');
     });
 
-    it('should throw error if profiles are missing', () => {
-      const configContent = `---
-defaultProfile: cloud
----
+    it('should use json as default format if not specified', async () => {
+      const configContent = `[auth]
+email=user@example.com
+api_token=app_token_here
 `;
 
-      const configPath = path.join(testDir, '.claude', 'bitbucket-config.local.md');
+      const configPath = path.join(testConfigDir, '.bbkcli');
       fs.writeFileSync(configPath, configContent);
 
-      expect(() => loadConfig(testDir)).toThrow('Configuration must include "profiles" object');
+      const config = await loadConfig();
+
+      expect(config.defaultFormat).toBe('json');
     });
 
-    it('should throw error if profile is missing required auth fields', () => {
-      const configContent = `---
-profiles:
-  incomplete:
-    email: test@example.com
-    # Missing apiToken
----
+    it('should support all output formats: json, toon', async () => {
+      const formats: Array<'json' | 'toon'> = ['json', 'toon'];
+
+      for (const format of formats) {
+        const configContent = `[auth]
+email=user@example.com
+api_token=app_token_here
+
+[defaults]
+format=${format}
 `;
 
-      const configPath = path.join(testDir, '.claude', 'bitbucket-config.local.md');
-      fs.writeFileSync(configPath, configContent);
+        const configPath = path.join(testConfigDir, '.bbkcli');
+        fs.writeFileSync(configPath, configContent);
+
+        const config = await loadConfig();
+        expect(config.defaultFormat).toBe(format);
 
-      expect(() => loadConfig(testDir)).toThrow('must have both "email" and "apiToken"');
+        // Clean up for next iteration
+        fs.rmSync(configPath);
+      }
     });
 
-    it('should use first profile as default if defaultProfile not specified', () => {
-      const configContent = `---
-profiles:
-  first:
-    email: first@example.com
-    apiToken: first_token
-  second:
-    email: second@example.com
-    apiToken: second_token
----
+    it('should handle comments and empty lines in config file', async () => {
+      const configContent = `# This is a comment
+[auth]
+email=user@example.com
+api_token=app_token_here
+
+# Another comment
+
+[defaults]
+workspace=myworkspace
+
+# format comment
+format=json
 `;
 
-      const configPath = path.join(testDir, '.claude', 'bitbucket-config.local.md');
+      const configPath = path.join(testConfigDir, '.bbkcli');
       fs.writeFileSync(configPath, configContent);
 
-      const config = loadConfig(testDir);
+      const config = await loadConfig();
+
+      expect(config.email).toBe('user@example.com');
+      expect(config.apiToken).toBe('app_token_here');
+      expect(config.defaultWorkspace).toBe('myworkspace');
+      expect(config.defaultFormat).toBe('json');
+    });
+  });
+
+  describe('setupConfig', () => {
+    let testConfigDir: string;
+    let homedirSpy: vi.SpyInstance;
+
+    beforeEach(() => {
+      testConfigDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bbk-cli-test-'));
+
+      // Spy on os.homedir() to return test directory (works on all platforms)
+      homedirSpy = vi.spyOn(os, 'homedir').mockReturnValue(testConfigDir);
+    });
+
+    afterEach(() => {
+      if (testConfigDir) {
+        fs.rmSync(testConfigDir, { recursive: true, force: true });
+      }
+
+      // Restore original os.homedir()
+      homedirSpy.mockRestore();
+
+      vi.clearAllMocks();
+    });
+
+    it('should create config file with all fields', async () => {
+      // Mock readline to provide all inputs
+      mockQuestion
+        .mockImplementationOnce((_, callback) => callback('user@example.com'))
+        .mockImplementationOnce((_, callback) => callback('test_token'))
+        .mockImplementationOnce((_, callback) => callback('myworkspace'))
+        .mockImplementationOnce((_, callback) => callback('toon')); // Use non-default format
+
+      await setupConfig();
+
+      const configPath = path.join(testConfigDir, '.bbkcli');
+      expect(fs.existsSync(configPath)).toBe(true);
+
+      const content = fs.readFileSync(configPath, 'utf-8');
+      expect(content).toContain('[auth]');
+      expect(content).toContain('email=user@example.com');
+      expect(content).toContain('api_token=test_token');
+      expect(content).toContain('[defaults]');
+      expect(content).toContain('workspace=myworkspace');
+      expect(content).toContain('format=toon');
+
+      // Check file permissions (0o600 = read/write for owner only)
+      // Note: Windows doesn't support Unix-style permissions, so we skip the check
+      if (process.platform !== 'win32') {
+        const stats = fs.statSync(configPath);
+        const mode = stats.mode & 0o777;
+        expect(mode).toBe(0o600);
+      }
+    });
+
+    it('should create minimal config file with only required fields', async () => {
+      mockQuestion
+        .mockImplementationOnce((_, callback) => callback('minimal@example.com'))
+        .mockImplementationOnce((_, callback) => callback('minimal_token'))
+        .mockImplementationOnce((_, callback) => callback('')) // empty workspace
+        .mockImplementationOnce((_, callback) => callback('')); // empty format (defaults to json)
+
+      await setupConfig();
+
+      const configPath = path.join(testConfigDir, '.bbkcli');
+      const content = fs.readFileSync(configPath, 'utf-8');
+
+      expect(content).toContain('[auth]');
+      expect(content).toContain('email=minimal@example.com');
+      expect(content).toContain('api_token=minimal_token');
+      // Should not include defaults section when both are empty
+      expect(content).not.toContain('[defaults]');
+    });
+
+    it('should reject invalid email format and re-prompt', async () => {
+      const emailInputs = ['invalid-email', 'still-invalid', 'valid@example.com'];
+      let emailInputIndex = 0;
+
+      mockQuestion.mockImplementation((prompt, callback) => {
+        if (prompt.includes('email:')) {
+          callback(emailInputs[emailInputIndex++]);
+        } else if (prompt.includes('api_token:')) {
+          callback('token');
+        } else if (prompt.includes('workspace:')) {
+          callback('');
+        } else if (prompt.includes('format:')) {
+          callback('');
+        }
+      });
+
+      await setupConfig();
 
-      expect(config.defaultProfile).toBe('first');
+      const configPath = path.join(testConfigDir, '.bbkcli');
+      const content = fs.readFileSync(configPath, 'utf-8');
+      expect(content).toContain('email=valid@example.com');
     });
 
-    it('should use json as default format if not specified', () => {
-      const configContent = `---
-profiles:
-  cloud:
-    email: user@example.com
-    apiToken: token_here
----
+    it('should reject empty email and re-prompt', async () => {
+      const emailInputs = ['', 'test@example.com'];
+      let emailInputIndex = 0;
+
+      mockQuestion.mockImplementation((prompt, callback) => {
+        if (prompt.includes('email:')) {
+          callback(emailInputs[emailInputIndex++]);
+        } else if (prompt.includes('api_token:')) {
+          callback('token');
+        } else if (prompt.includes('workspace:')) {
+          callback('');
+        } else if (prompt.includes('format:')) {
+          callback('');
+        }
+      });
+
+      await setupConfig();
+
+      const configPath = path.join(testConfigDir, '.bbkcli');
+      const content = fs.readFileSync(configPath, 'utf-8');
+      expect(content).toContain('email=test@example.com');
+    });
+
+    it('should reject empty api_token and re-prompt', async () => {
+      const tokenInputs = ['', 'real_token'];
+      let tokenInputIndex = 0;
+
+      mockQuestion.mockImplementation((prompt, callback) => {
+        if (prompt.includes('email:')) {
+          callback('test@example.com');
+        } else if (prompt.includes('api_token:')) {
+          callback(tokenInputs[tokenInputIndex++]);
+        } else if (prompt.includes('workspace:')) {
+          callback('');
+        } else if (prompt.includes('format:')) {
+          callback('');
+        }
+      });
+
+      await setupConfig();
+
+      const configPath = path.join(testConfigDir, '.bbkcli');
+      const content = fs.readFileSync(configPath, 'utf-8');
+      expect(content).toContain('api_token=real_token');
+    });
+
+    it('should reject invalid format and re-prompt', async () => {
+      const formatInputs = ['xml', 'toon']; // Use non-default format
+      let formatInputIndex = 0;
+
+      mockQuestion.mockImplementation((prompt, callback) => {
+        if (prompt.includes('email:')) {
+          callback('test@example.com');
+        } else if (prompt.includes('api_token:')) {
+          callback('token');
+        } else if (prompt.includes('workspace:')) {
+          callback('ws');
+        } else if (prompt.includes('format:')) {
+          callback(formatInputs[formatInputIndex++]);
+        }
+      });
+
+      await setupConfig();
+
+      const configPath = path.join(testConfigDir, '.bbkcli');
+      const content = fs.readFileSync(configPath, 'utf-8');
+      expect(content).toContain('format=toon');
+    });
+
+    it('should handle write permission errors gracefully', async () => {
+      // Create a directory instead of a file to cause write error
+      const existingPath = path.join(testConfigDir, '.bbkcli');
+      fs.mkdirSync(existingPath);
+
+      mockQuestion
+        .mockImplementationOnce((_, callback) => callback('test@example.com'))
+        .mockImplementationOnce((_, callback) => callback('token'))
+        .mockImplementationOnce((_, callback) => callback('ws'))
+        .mockImplementationOnce((_, callback) => callback('json'));
+
+      await expect(setupConfig()).rejects.toThrow('Cannot write config');
+    });
+
+    it('should include defaults section when only format is specified', async () => {
+      mockQuestion
+        .mockImplementationOnce((_, callback) => callback('test@example.com'))
+        .mockImplementationOnce((_, callback) => callback('token'))
+        .mockImplementationOnce((_, callback) => callback('')) // empty workspace
+        .mockImplementationOnce((_, callback) => callback('toon')); // non-default format
+
+      await setupConfig();
+
+      const configPath = path.join(testConfigDir, '.bbkcli');
+      const content = fs.readFileSync(configPath, 'utf-8');
+
+      expect(content).toContain('[defaults]');
+      expect(content).toContain('format=toon');
+      expect(content).not.toContain('workspace=');
+    });
+
+    it('should include defaults section when only workspace is specified', async () => {
+      mockQuestion
+        .mockImplementationOnce((_, callback) => callback('test@example.com'))
+        .mockImplementationOnce((_, callback) => callback('token'))
+        .mockImplementationOnce((_, callback) => callback('myworkspace'))
+        .mockImplementationOnce((_, callback) => callback('')); // empty format (defaults to json)
+
+      await setupConfig();
+
+      const configPath = path.join(testConfigDir, '.bbkcli');
+      const content = fs.readFileSync(configPath, 'utf-8');
+
+      expect(content).toContain('[defaults]');
+      expect(content).toContain('workspace=myworkspace');
+      expect(content).not.toContain('format=');
+    });
+
+    it.skipIf(process.platform === 'win32')('should set secure file permissions (0o600)', async () => {
+      mockQuestion
+        .mockImplementationOnce((_, callback) => callback('secure@example.com'))
+        .mockImplementationOnce((_, callback) => callback('secure_token'))
+        .mockImplementationOnce((_, callback) => callback('workspace'))
+        .mockImplementationOnce((_, callback) => callback('toon'));
+
+      await setupConfig();
+
+      const configPath = path.join(testConfigDir, '.bbkcli');
+      const stats = fs.statSync(configPath);
+      const mode = stats.mode & 0o777;
+
+      // 0o600 = read/write for owner only (rw-------)
+      expect(mode).toBe(0o600);
+    });
+
+    it('should pre-populate existing config values when user presses Enter for all fields', async () => {
+      // Create existing config
+      const existingConfig = `[auth]
+email=old@example.com
+api_token=old_token_123
+
+[defaults]
+workspace=old_workspace
+format=toon
 `;
+      const configPath = path.join(testConfigDir, '.bbkcli');
+      fs.writeFileSync(configPath, existingConfig);
+
+      // User presses Enter for all prompts (accepts existing values)
+      mockQuestion
+        .mockImplementationOnce((_, callback) => callback('')) // keep email
+        .mockImplementationOnce((_, callback) => callback('')) // keep token
+        .mockImplementationOnce((_, callback) => callback('')) // keep workspace
+        .mockImplementationOnce((_, callback) => callback('')); // keep format
+
+      await setupConfig();
+
+      const content = fs.readFileSync(configPath, 'utf-8');
+      expect(content).toContain('email=old@example.com');
+      expect(content).toContain('api_token=old_token_123');
+      expect(content).toContain('workspace=old_workspace');
+      expect(content).toContain('format=toon');
+    });
 
-      const configPath = path.join(testDir, '.claude', 'bitbucket-config.local.md');
-      fs.writeFileSync(configPath, configContent);
+    it('should pre-populate and update individual fields while keeping others', async () => {
+      // Create existing config with toon format (non-default)
+      const existingConfig = `[auth]
+email=old@example.com
+api_token=old_token_123
 
-      const config = loadConfig(testDir);
+[defaults]
+workspace=old_workspace
+format=toon
+`;
+      const configPath = path.join(testConfigDir, '.bbkcli');
+      fs.writeFileSync(configPath, existingConfig);
+
+      // User updates email and workspace but keeps token and format
+      mockQuestion
+        .mockImplementationOnce((_, callback) => callback('new@example.com')) // new email
+        .mockImplementationOnce((_, callback) => callback('')) // keep token
+        .mockImplementationOnce((_, callback) => callback('new_workspace')) // new workspace
+        .mockImplementationOnce((_, callback) => callback('')); // keep format
+
+      await setupConfig();
+
+      const content = fs.readFileSync(configPath, 'utf-8');
+      expect(content).toContain('email=new@example.com');
+      expect(content).toContain('api_token=old_token_123');
+      expect(content).toContain('workspace=new_workspace');
+      expect(content).toContain('format=toon');
+    });
 
-      expect(config.defaultFormat).toBe('json');
+    it('should handle corrupted existing config file gracefully', async () => {
+      // Create a corrupted existing config
+      const configPath = path.join(testConfigDir, '.bbkcli');
+      fs.writeFileSync(configPath, 'this is not valid INI at all {{{');
+
+      const consoleWarnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
+
+      // User provides new values
+      mockQuestion
+        .mockImplementationOnce((_, callback) => callback('fresh@example.com'))
+        .mockImplementationOnce((_, callback) => callback('fresh_token'))
+        .mockImplementationOnce((_, callback) => callback('fresh_workspace'))
+        .mockImplementationOnce((_, callback) => callback('json'));
+
+      await setupConfig();
+
+      const content = fs.readFileSync(configPath, 'utf-8');
+      expect(content).toContain('email=fresh@example.com');
+      expect(content).toContain('api_token=fresh_token');
+
+      consoleWarnSpy.mockRestore();
     });
 
-    it('should support all output formats: json, toon', () => {
-      const formats: Array<'json' | 'toon'> = ['json', 'toon'];
+    it('should preserve api_token when user deletes asterisks and presses Enter', async () => {
+      // Create existing config
+      const existingConfig = `[auth]
+email=test@example.com
+api_token=existing_token
 
-      formats.forEach(format => {
-        const configContent = `---
-profiles:
-  cloud:
-    email: user@example.com
-    apiToken: token_here
-defaultFormat: ${format}
----
+[defaults]
+format=json
 `;
+      const configPath = path.join(testConfigDir, '.bbkcli');
+      fs.writeFileSync(configPath, existingConfig);
 
-        const configPath = path.join(testDir, '.claude', 'bitbucket-config.local.md');
-        fs.writeFileSync(configPath, configContent);
+      // User keeps email, deletes all asterisks (backspaces) and presses Enter to keep token
+      mockQuestion
+        .mockImplementationOnce((_, callback) => callback('')) // keep email
+        .mockImplementationOnce((_, callback) => callback('')) // deleted asterisks, keep token
+        .mockImplementationOnce((_, callback) => callback('')) // no workspace
+        .mockImplementationOnce((_, callback) => callback('')); // keep format
 
-        const config = loadConfig(testDir);
-        expect(config.defaultFormat).toBe(format);
-      });
+      await setupConfig();
+
+      const content = fs.readFileSync(configPath, 'utf-8');
+      expect(content).toContain('email=test@example.com');
+      expect(content).toContain('api_token=existing_token');
     });
   });
 });