bbk-cli 1.0.0

package/tests/unit/utils/arg-parser.test.ts

@@ -0,0 +1,350 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+
+import { parseArguments } from '../../../src/utils/arg-parser.js';
+
+// Mock the imported modules
+vi.mock('../../../src/commands/index.js', () => ({
+  getCurrentVersion: vi.fn().mockReturnValue('0.0.0'),
+  printAvailableCommands: vi.fn(),
+  printCommandDetail: vi.fn(),
+  runCommand: vi.fn(),
+}));
+
+vi.mock('../../../src/config/index.js', () => ({
+  COMMANDS: [
+    'list-repos',
+    'get-repo',
+    'list-prs',
+    'get-pr',
+    'create-pr',
+    'update-pr',
+    'add-comment',
+    'delete-pr',
+    'get-user',
+    'test-connection',
+  ],
+}));
+
+describe('arg-parser', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  afterEach(() => {
+    vi.restoreAllMocks();
+  });
+
+  describe('parseArguments', () => {
+    it('should handle --version flag', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation((): never => {
+        throw new Error('process.exit called');
+      });
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      try {
+        await parseArguments(['--version']);
+      } catch {
+        // Expected
+      }
+
+      expect(consoleLogSpy).toHaveBeenCalledWith('0.0.0');
+      expect(exitSpy).toHaveBeenCalledWith(0);
+
+      exitSpy.mockRestore();
+      consoleLogSpy.mockRestore();
+    });
+
+    it('should handle -v flag (short version)', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation((): never => {
+        throw new Error('process.exit called');
+      });
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      try {
+        await parseArguments(['-v']);
+      } catch {
+        // Expected
+      }
+
+      expect(consoleLogSpy).toHaveBeenCalledWith('0.0.0');
+      expect(exitSpy).toHaveBeenCalledWith(0);
+
+      exitSpy.mockRestore();
+      consoleLogSpy.mockRestore();
+    });
+
+    it('should handle --commands flag', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation((): never => {
+        throw new Error('process.exit called');
+      });
+      const { printAvailableCommands } = await import('../../../src/commands/index.js');
+
+      try {
+        await parseArguments(['--commands']);
+      } catch {
+        // Expected
+      }
+
+      expect(printAvailableCommands).toHaveBeenCalled();
+      expect(exitSpy).toHaveBeenCalledWith(0);
+
+      exitSpy.mockRestore();
+    });
+
+    it('should handle command -h for command-specific help', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation((): never => {
+        throw new Error('process.exit called');
+      });
+      const { printCommandDetail } = await import('../../../src/commands/index.js');
+
+      try {
+        await parseArguments(['list-repos', '-h']);
+      } catch {
+        // Expected
+      }
+
+      expect(printCommandDetail).toHaveBeenCalledWith('list-repos');
+      expect(exitSpy).toHaveBeenCalledWith(0);
+
+      exitSpy.mockRestore();
+    });
+
+    it('should handle --help flag', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation((): never => {
+        throw new Error('process.exit called');
+      });
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      try {
+        await parseArguments(['--help']);
+      } catch {
+        // Expected
+      }
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Bitbucket CLI'));
+      expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Usage:'));
+      expect(exitSpy).toHaveBeenCalledWith(0);
+
+      exitSpy.mockRestore();
+      consoleLogSpy.mockRestore();
+    });
+
+    it('should handle -h flag (short help)', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation((): never => {
+        throw new Error('process.exit called');
+      });
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      try {
+        await parseArguments(['-h']);
+      } catch {
+        // Expected
+      }
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Bitbucket CLI'));
+      expect(exitSpy).toHaveBeenCalledWith(0);
+
+      exitSpy.mockRestore();
+      consoleLogSpy.mockRestore();
+    });
+
+    it('should execute valid command in headless mode', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation((): never => {
+        throw new Error('process.exit called');
+      });
+      const { runCommand } = await import('../../../src/commands/index.js');
+
+      try {
+        await parseArguments(['list-repos', '{"workspace":"myworkspace"}']);
+      } catch {
+        // Expected
+      }
+
+      expect(runCommand).toHaveBeenCalledWith('list-repos', '{"workspace":"myworkspace"}', null);
+      expect(exitSpy).toHaveBeenCalledWith(0);
+
+      exitSpy.mockRestore();
+    });
+
+    it('should execute command without arguments', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation((): never => {
+        throw new Error('process.exit called');
+      });
+      const { runCommand } = await import('../../../src/commands/index.js');
+
+      try {
+        await parseArguments(['test-connection']);
+      } catch {
+        // Expected
+      }
+
+      expect(runCommand).toHaveBeenCalledWith('test-connection', null, null);
+      expect(exitSpy).toHaveBeenCalledWith(0);
+
+      exitSpy.mockRestore();
+    });
+
+    it('should parse command with flag parameter', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation((): never => {
+        throw new Error('process.exit called');
+      });
+      const { runCommand } = await import('../../../src/commands/index.js');
+
+      try {
+        await parseArguments(['get-repo', '{"workspace":"myworkspace","repo":"myrepo"}', '--format', 'json']);
+      } catch {
+        // Expected
+      }
+
+      expect(runCommand).toHaveBeenCalledWith('get-repo', '{"workspace":"myworkspace","repo":"myrepo"}', '--format');
+      expect(exitSpy).toHaveBeenCalledWith(0);
+
+      exitSpy.mockRestore();
+    });
+
+    it('should return false for interactive mode (no arguments)', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {});
+      const result = await parseArguments([]);
+
+      expect(result).toBe(false);
+      expect(exitSpy).not.toHaveBeenCalled();
+
+      exitSpy.mockRestore();
+    });
+
+    it('should return false for empty arguments', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {});
+      const result = await parseArguments([]);
+
+      expect(result).toBe(false);
+      expect(exitSpy).not.toHaveBeenCalled();
+
+      exitSpy.mockRestore();
+    });
+
+    it('should return false for unrecognized flags when not first argument', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation(() => {});
+      const result = await parseArguments(['--unknown']);
+
+      expect(result).toBe(false);
+      expect(exitSpy).not.toHaveBeenCalled();
+
+      exitSpy.mockRestore();
+    });
+
+    it('should prioritize --version flag even if other arguments exist', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation((): never => {
+        throw new Error('process.exit called');
+      });
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+      const { runCommand } = await import('../../../src/commands/index.js');
+
+      try {
+        await parseArguments(['--version', 'list-repos', '{"workspace":"myworkspace"}']);
+      } catch {
+        // Expected
+      }
+
+      expect(consoleLogSpy).toHaveBeenCalledWith('0.0.0');
+      expect(exitSpy).toHaveBeenCalledWith(0);
+      expect(runCommand).not.toHaveBeenCalled();
+
+      exitSpy.mockRestore();
+      consoleLogSpy.mockRestore();
+    });
+
+    it('should prioritize --commands flag', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation((): never => {
+        throw new Error('process.exit called');
+      });
+      const { printAvailableCommands } = await import('../../../src/commands/index.js');
+      const { runCommand } = await import('../../../src/commands/index.js');
+
+      try {
+        await parseArguments(['--commands', 'list-repos']);
+      } catch {
+        // Expected
+      }
+
+      expect(printAvailableCommands).toHaveBeenCalled();
+      expect(runCommand).not.toHaveBeenCalled();
+
+      exitSpy.mockRestore();
+    });
+
+    it('should handle all 10 commands as valid', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation((): never => {
+        throw new Error('process.exit called');
+      });
+      const { runCommand } = await import('../../../src/commands/index.js');
+
+      const commands = [
+        'list-repos',
+        'get-repo',
+        'list-prs',
+        'get-pr',
+        'create-pr',
+        'update-pr',
+        'add-comment',
+        'delete-pr',
+        'get-user',
+        'test-connection',
+      ];
+
+      for (const cmd of commands) {
+        try {
+          await parseArguments([cmd]);
+        } catch {
+          // Expected for each command
+        }
+      }
+
+      expect(runCommand).toHaveBeenCalledTimes(commands.length);
+
+      exitSpy.mockRestore();
+    });
+  });
+
+  describe('printGeneralHelp', () => {
+    it('should display help message with all commands', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation((): never => {
+        throw new Error('process.exit called');
+      });
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      try {
+        await parseArguments(['--help']);
+      } catch {
+        // Expected
+      }
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Bitbucket CLI'));
+      expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('npx bbk-cli'));
+      expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('npx bbk-cli --commands'));
+      expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('list-repos'));
+
+      exitSpy.mockRestore();
+      consoleLogSpy.mockRestore();
+    });
+
+    it('should display examples section', async () => {
+      const exitSpy = vi.spyOn(process, 'exit').mockImplementation((): never => {
+        throw new Error('process.exit called');
+      });
+      const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+      try {
+        await parseArguments(['--help']);
+      } catch {
+        // Expected
+      }
+
+      expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Examples:'));
+      expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('npx bbk-cli list-repos'));
+      expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('npx bbk-cli get-repo'));
+
+      exitSpy.mockRestore();
+      consoleLogSpy.mockRestore();
+    });
+  });
+});

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

@@ -0,0 +1,158 @@
+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';
+
+describe('config-loader', () => {
+  let testDir: string;
+
+  beforeEach(() => {
+    // Create a temporary directory for test configs
+    testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'bbk-cli-test-'));
+    fs.mkdirSync(path.join(testDir, '.claude'));
+  });
+
+  afterEach(() => {
+    // Clean up test directory
+    fs.rmSync(testDir, { recursive: true, force: true });
+  });
+
+  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
+`;
+
+      const configPath = path.join(testDir, '.claude', 'bitbucket-config.local.md');
+      fs.writeFileSync(configPath, configContent);
+
+      const config = loadConfig(testDir);
+
+      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');
+
+      expect(config.profiles.staging).toBeDefined();
+      expect(config.profiles.staging.apiToken).toBe('staging_token_here');
+
+      expect(config.defaultProfile).toBe('cloud');
+      expect(config.defaultFormat).toBe('json');
+    });
+
+    it('should throw error if config file does not exist', () => {
+      expect(() => loadConfig(testDir)).toThrow('Configuration file not found');
+    });
+
+    it('should throw error if frontmatter is missing', () => {
+      const configContent = `# Bitbucket Connection Profiles
+
+This is just markdown content without frontmatter.
+`;
+
+      const configPath = path.join(testDir, '.claude', 'bitbucket-config.local.md');
+      fs.writeFileSync(configPath, configContent);
+
+      expect(() => loadConfig(testDir)).toThrow('Invalid configuration file format');
+    });
+
+    it('should throw error if profiles are missing', () => {
+      const configContent = `---
+defaultProfile: cloud
+---
+`;
+
+      const configPath = path.join(testDir, '.claude', 'bitbucket-config.local.md');
+      fs.writeFileSync(configPath, configContent);
+
+      expect(() => loadConfig(testDir)).toThrow('Configuration must include "profiles" object');
+    });
+
+    it('should throw error if profile is missing required auth fields', () => {
+      const configContent = `---
+profiles:
+  incomplete:
+    email: test@example.com
+    # Missing apiToken
+---
+`;
+
+      const configPath = path.join(testDir, '.claude', 'bitbucket-config.local.md');
+      fs.writeFileSync(configPath, configContent);
+
+      expect(() => loadConfig(testDir)).toThrow('must have both "email" and "apiToken"');
+    });
+
+    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
+---
+`;
+
+      const configPath = path.join(testDir, '.claude', 'bitbucket-config.local.md');
+      fs.writeFileSync(configPath, configContent);
+
+      const config = loadConfig(testDir);
+
+      expect(config.defaultProfile).toBe('first');
+    });
+
+    it('should use json as default format if not specified', () => {
+      const configContent = `---
+profiles:
+  cloud:
+    email: user@example.com
+    apiToken: token_here
+---
+`;
+
+      const configPath = path.join(testDir, '.claude', 'bitbucket-config.local.md');
+      fs.writeFileSync(configPath, configContent);
+
+      const config = loadConfig(testDir);
+
+      expect(config.defaultFormat).toBe('json');
+    });
+
+    it('should support all output formats: json, toon', () => {
+      const formats: Array<'json' | 'toon'> = ['json', 'toon'];
+
+      formats.forEach(format => {
+        const configContent = `---
+profiles:
+  cloud:
+    email: user@example.com
+    apiToken: token_here
+defaultFormat: ${format}
+---
+`;
+
+        const configPath = path.join(testDir, '.claude', 'bitbucket-config.local.md');
+        fs.writeFileSync(configPath, configContent);
+
+        const config = loadConfig(testDir);
+        expect(config.defaultFormat).toBe(format);
+      });
+    });
+  });
+});

package/vitest.config.ts

@@ -0,0 +1,22 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+  test: {
+    globals: true,
+    environment: 'node',
+    coverage: {
+      provider: 'v8',
+      reporter: ['text', 'json', 'html'],
+      exclude: [
+        'node_modules/',
+        'dist/',
+        '**/*.d.ts',
+        '**/*.config.*',
+        '**/index.ts', // Barrel exports
+        'tests/',
+      ],
+    },
+    include: ['tests/**/*.test.ts'],
+    exclude: ['node_modules', 'dist'],
+  },
+});