test(codedapp-tool): add unit tests (#315)

- Add Vitest config with coverage support (@vitest/coverage-v8)
- Add unit tests for tool, error-handler, resolve-credentials
- Add unit tests for Commander command registration

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: deepeshrai-tech

package-lock.json

@@ -18,7 +18,10 @@
     "prepublishOnly": "npm run clean && npm run build:full",
     "dev": "bash scripts/dev.sh",
     "dev:link": "bash scripts/link-to-uipcli.sh",
-    "clean": "rimraf dist"
+    "clean": "rimraf dist",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
     "commander": "^14.0.3",
@@ -28,7 +31,9 @@
     "@uipath/uipath-ts-cli": "*",
     "@types/node": "^20.11.19",
     "rimraf": "^6.0.1",
-    "typescript": "^5.3.3"
+    "typescript": "^5.3.3",
+    "@vitest/coverage-v8": "^3.2.4",
+    "vitest": "^3.2.4"
   },
   "repository": {
     "type": "git",

packages/codedapp-tool/package.json

@@ -0,0 +1,152 @@
+import { describe, it, expect, vi } from 'vitest';
+import { Command } from 'commander';
+
+vi.mock('@uipath/uipath-ts-cli/actions', () => ({
+  executePush: vi.fn().mockResolvedValue(undefined),
+  executePull: vi.fn().mockResolvedValue(undefined),
+  executePack: vi.fn().mockResolvedValue(undefined),
+  executePublish: vi.fn().mockResolvedValue(undefined),
+  executeDeploy: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('@uipath/auth', () => ({
+  getLoginStatusAsync: vi.fn().mockResolvedValue({ loginStatus: 'Not logged in' }),
+  resolveEnvFilePathAsync: vi.fn(),
+  saveEnvFileAsync: vi.fn(),
+}));
+
+vi.mock('../../src/utils/folder-selection.js', () => ({
+  ensureFolderKey: vi.fn().mockResolvedValue(undefined),
+}));
+
+import { registerPushCommand } from '../../src/commands/push.js';
+import { registerPullCommand } from '../../src/commands/pull.js';
+import { registerPackCommand } from '../../src/commands/pack.js';
+import { registerPublishCommand } from '../../src/commands/publish.js';
+import { registerDeployCommand } from '../../src/commands/deploy.js';
+
+describe('Command Registration', () => {
+  describe('push command', () => {
+    it('should register push command on program', () => {
+      const program = new Command();
+      registerPushCommand(program);
+
+      const pushCmd = program.commands.find((c) => c.name() === 'push');
+      expect(pushCmd).toBeDefined();
+      expect(pushCmd!.description()).toContain('Push');
+    });
+
+    it('should have correct options', () => {
+      const program = new Command();
+      registerPushCommand(program);
+
+      const pushCmd = program.commands.find((c) => c.name() === 'push')!;
+      const optionNames = pushCmd.options.map((o) => o.long);
+      expect(optionNames).toContain('--buildDir');
+      expect(optionNames).toContain('--ignoreResources');
+      expect(optionNames).toContain('--baseUrl');
+      expect(optionNames).toContain('--orgId');
+      expect(optionNames).toContain('--tenantId');
+      expect(optionNames).toContain('--accessToken');
+    });
+  });
+
+  describe('pull command', () => {
+    it('should register pull command on program', () => {
+      const program = new Command();
+      registerPullCommand(program);
+
+      const pullCmd = program.commands.find((c) => c.name() === 'pull');
+      expect(pullCmd).toBeDefined();
+      expect(pullCmd!.description()).toContain('Pull');
+    });
+
+    it('should have overwrite option', () => {
+      const program = new Command();
+      registerPullCommand(program);
+
+      const pullCmd = program.commands.find((c) => c.name() === 'pull')!;
+      const optionNames = pullCmd.options.map((o) => o.long);
+      expect(optionNames).toContain('--overwrite');
+      expect(optionNames).toContain('--targetDir');
+    });
+  });
+
+  describe('pack command', () => {
+    it('should register pack command on program', () => {
+      const program = new Command();
+      registerPackCommand(program);
+
+      const packCmd = program.commands.find((c) => c.name() === 'pack');
+      expect(packCmd).toBeDefined();
+      expect(packCmd!.description()).toContain('Package');
+    });
+
+    it('should require dist argument', () => {
+      const program = new Command();
+      registerPackCommand(program);
+
+      const packCmd = program.commands.find((c) => c.name() === 'pack')!;
+      const args = packCmd.registeredArguments;
+      expect(args.length).toBeGreaterThan(0);
+      expect(args[0].required).toBe(true);
+    });
+
+    it('should have packaging options', () => {
+      const program = new Command();
+      registerPackCommand(program);
+
+      const packCmd = program.commands.find((c) => c.name() === 'pack')!;
+      const optionNames = packCmd.options.map((o) => o.long);
+      expect(optionNames).toContain('--name');
+      expect(optionNames).toContain('--version');
+      expect(optionNames).toContain('--output');
+      expect(optionNames).toContain('--dry-run');
+    });
+  });
+
+  describe('publish command', () => {
+    it('should register publish command on program', () => {
+      const program = new Command();
+      registerPublishCommand(program);
+
+      const publishCmd = program.commands.find((c) => c.name() === 'publish');
+      expect(publishCmd).toBeDefined();
+      expect(publishCmd!.description()).toContain('Publish');
+    });
+
+    it('should have publish options', () => {
+      const program = new Command();
+      registerPublishCommand(program);
+
+      const publishCmd = program.commands.find((c) => c.name() === 'publish')!;
+      const optionNames = publishCmd.options.map((o) => o.long);
+      expect(optionNames).toContain('--name');
+      expect(optionNames).toContain('--version');
+      expect(optionNames).toContain('--type');
+      expect(optionNames).toContain('--uipathDir');
+    });
+  });
+
+  describe('deploy command', () => {
+    it('should register deploy command on program', () => {
+      const program = new Command();
+      registerDeployCommand(program);
+
+      const deployCmd = program.commands.find((c) => c.name() === 'deploy');
+      expect(deployCmd).toBeDefined();
+      expect(deployCmd!.description()).toContain('Deploy');
+    });
+
+    it('should have deploy options', () => {
+      const program = new Command();
+      registerDeployCommand(program);
+
+      const deployCmd = program.commands.find((c) => c.name() === 'deploy')!;
+      const optionNames = deployCmd.options.map((o) => o.long);
+      expect(optionNames).toContain('--name');
+      expect(optionNames).toContain('--folderKey');
+      expect(optionNames).toContain('--orgName');
+    });
+  });
+});

packages/codedapp-tool/tests/unit/commands.test.ts

@@ -0,0 +1,76 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Command } from 'commander';
+
+vi.mock('../../src/utils/resolve-credentials.js', () => ({
+  loadAuthCredentials: vi.fn().mockResolvedValue(undefined),
+}));
+
+vi.mock('../../src/commands/push.js', () => ({
+  registerPushCommand: vi.fn(),
+}));
+vi.mock('../../src/commands/pull.js', () => ({
+  registerPullCommand: vi.fn(),
+}));
+vi.mock('../../src/commands/pack.js', () => ({
+  registerPackCommand: vi.fn(),
+}));
+vi.mock('../../src/commands/publish.js', () => ({
+  registerPublishCommand: vi.fn(),
+}));
+vi.mock('../../src/commands/deploy.js', () => ({
+  registerDeployCommand: vi.fn(),
+}));
+
+import { metadata, registerCommands } from '../../src/tool.js';
+import { registerPushCommand } from '../../src/commands/push.js';
+import { registerPullCommand } from '../../src/commands/pull.js';
+import { registerPackCommand } from '../../src/commands/pack.js';
+import { registerPublishCommand } from '../../src/commands/publish.js';
+import { registerDeployCommand } from '../../src/commands/deploy.js';
+
+describe('codedapp-tool', () => {
+  describe('metadata', () => {
+    it('should export correct tool name', () => {
+      expect(metadata.name).toBe('codedapp-tool');
+    });
+
+    it('should have codedapp command prefix', () => {
+      expect(metadata.commandPrefix).toBe('codedapp');
+    });
+
+    it('should have a version', () => {
+      expect(metadata.version).toBeDefined();
+      expect(typeof metadata.version).toBe('string');
+    });
+
+    it('should have a description', () => {
+      expect(metadata.description).toBeDefined();
+    });
+  });
+
+  describe('registerCommands', () => {
+    let program: Command;
+
+    beforeEach(() => {
+      vi.clearAllMocks();
+      program = new Command();
+    });
+
+    it('should register all 5 commands', () => {
+      registerCommands(program);
+
+      expect(registerPushCommand).toHaveBeenCalledWith(program);
+      expect(registerPullCommand).toHaveBeenCalledWith(program);
+      expect(registerPackCommand).toHaveBeenCalledWith(program);
+      expect(registerPublishCommand).toHaveBeenCalledWith(program);
+      expect(registerDeployCommand).toHaveBeenCalledWith(program);
+    });
+
+    it('should add a preAction hook', () => {
+      const hookSpy = vi.spyOn(program, 'hook');
+      registerCommands(program);
+
+      expect(hookSpy).toHaveBeenCalledWith('preAction', expect.any(Function));
+    });
+  });
+});