feat: Add unit tests for various command classes to improve test coverage

Author: Coderrob

src/commands/audit/ref-audit.command.test.ts

@@ -0,0 +1,77 @@
+/* eslint-disable no-undefined */
+import { Command } from 'commander';
+
+import { container } from '../../core/system/container';
+import { SERVICE_KEYS } from '../../types/core';
+import { ILogger } from '../../types/observability';
+import { CommandName, IReferenceAuditUseCase } from '../../types';
+
+import { RefAuditCommand } from './ref-audit.command';
+
+jest.mock('../../core/system/container');
+jest.mock('commander');
+
+describe('RefAuditCommand', () => {
+  let mockLogger: jest.Mocked<ILogger>;
+  let mockService: jest.Mocked<IReferenceAuditUseCase>;
+  let mockParentCommand: jest.Mocked<Command>;
+
+  beforeEach(() => {
+    mockLogger = {
+      info: jest.fn(),
+    } as unknown as jest.Mocked<ILogger>;
+
+    mockService = {
+      execute: jest.fn().mockResolvedValue(undefined),
+    } as jest.Mocked<IReferenceAuditUseCase>;
+
+    mockParentCommand = {
+      command: jest.fn().mockReturnThis(),
+      description: jest.fn().mockReturnThis(),
+      action: jest.fn().mockReturnThis(),
+    } as unknown as jest.Mocked<Command>;
+
+    (container.resolve as jest.Mock).mockReturnValue(mockService);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should have correct name and description', () => {
+    const cmd = new RefAuditCommand(mockLogger);
+    expect(cmd.name).toBe(CommandName.AUDIT);
+    expect(cmd.description).toBe('Audit references across repo & tasks');
+  });
+
+  it('should execute the command successfully', async () => {
+    const cmd = new RefAuditCommand(mockLogger);
+    await cmd.execute();
+
+    expect(mockLogger.info).toHaveBeenCalledWith('Executing ref audit command');
+    expect(container.resolve).toHaveBeenCalledWith(SERVICE_KEYS.REFERENCE_AUDIT);
+    expect(mockService.execute).toHaveBeenCalled();
+    expect(mockLogger.info).toHaveBeenCalledWith('Ref audit command executed');
+  });
+
+  it('should configure the command on parent', () => {
+    RefAuditCommand.configure(mockParentCommand, mockLogger);
+
+    expect(mockParentCommand.command).toHaveBeenCalledWith(CommandName.AUDIT);
+    expect(mockParentCommand.description).toHaveBeenCalledWith(
+      'Audit references across repo & tasks',
+    );
+    expect(mockParentCommand.action).toHaveBeenCalledWith(expect.any(Function));
+  });
+
+  it('should handle service execution error', async () => {
+    const error = new Error('Service error');
+    mockService.execute.mockRejectedValue(error);
+
+    const cmd = new RefAuditCommand(mockLogger);
+
+    await expect(cmd.execute()).rejects.toThrow('Service error');
+    expect(mockLogger.info).toHaveBeenCalledWith('Executing ref audit command');
+    expect(mockLogger.info).not.toHaveBeenCalledWith('Ref audit command executed');
+  });
+});

src/commands/audit/supersede.command.test.ts

@@ -0,0 +1,103 @@
+/* eslint-disable no-undefined */
+import { Command } from 'commander';
+
+import { container } from '../../core/system/container';
+import { SERVICE_KEYS } from '../../types/core';
+import { ILogger } from '../../types/observability';
+import { CommandName, IUIdSupersedeUseCase } from '../../types';
+
+import { SupersedeCommand } from './supersede.command';
+
+jest.mock('../../core/system/container');
+jest.mock('commander');
+
+describe('SupersedeCommand', () => {
+  let mockLogger: jest.Mocked<ILogger>;
+  let mockService: jest.Mocked<IUIdSupersedeUseCase>;
+  let command: SupersedeCommand;
+
+  beforeEach(() => {
+    mockLogger = {
+      info: jest.fn(),
+      error: jest.fn(),
+      warn: jest.fn(),
+      debug: jest.fn(),
+    } as unknown as jest.Mocked<ILogger>;
+
+    mockService = {
+      execute: jest.fn().mockResolvedValue(undefined),
+    } as jest.Mocked<IUIdSupersedeUseCase>;
+
+    (container.resolve as jest.Mock).mockReturnValue(mockService);
+
+    command = new SupersedeCommand(mockLogger);
+  });
+
+  afterEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('execute', () => {
+    it('should execute supersede and log correctly', async () => {
+      const oldUid = 'OLD123';
+      const newUid = 'NEW456';
+
+      await command.execute({ oldUid, newUid });
+
+      expect(mockLogger.info).toHaveBeenCalledWith('Executing supersede command', {
+        newUid,
+        oldUid,
+      });
+      expect(container.resolve).toHaveBeenCalledWith(SERVICE_KEYS.UID_SUPERSEDE);
+      expect(mockService.execute).toHaveBeenCalledWith(oldUid, newUid);
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        `Supersede command executed: ${oldUid} -> ${newUid}`,
+        { newUid, oldUid },
+      );
+    });
+
+    it('should handle service execution error', async () => {
+      const error = new Error('Service error');
+      mockService.execute.mockRejectedValue(error);
+
+      await expect(command.execute({ oldUid: 'OLD123', newUid: 'NEW456' })).rejects.toThrow(
+        'Service error',
+      );
+
+      expect(mockLogger.info).toHaveBeenCalledWith('Executing supersede command', {
+        newUid: 'NEW456',
+        oldUid: 'OLD123',
+      });
+      expect(mockService.execute).toHaveBeenCalledWith('OLD123', 'NEW456');
+      // Note: In real scenario, error logging might be handled by BaseCommand or elsewhere
+    });
+  });
+
+  describe('configure', () => {
+    it('should configure the command correctly', () => {
+      const mockParent = new Command();
+      const mockCommand = {
+        command: jest.fn().mockReturnThis(),
+        argument: jest.fn().mockReturnThis(),
+        description: jest.fn().mockReturnThis(),
+        action: jest.fn().mockReturnThis(),
+      };
+      mockParent.command = jest.fn().mockReturnValue(mockCommand);
+
+      SupersedeCommand.configure(mockParent, mockLogger);
+
+      expect(mockParent.command).toHaveBeenCalledWith(CommandName.SUPERSEDE);
+      expect(mockCommand.argument).toHaveBeenCalledWith('<oldUid>', 'Old UID');
+      expect(mockCommand.argument).toHaveBeenCalledWith('<newUid>', 'New UID');
+      expect(mockCommand.description).toHaveBeenCalledWith('Supersede an old UID with a new one');
+      expect(mockCommand.action).toHaveBeenCalledWith(expect.any(Function));
+    });
+  });
+
+  describe('properties', () => {
+    it('should have correct name and description', () => {
+      expect(command.name).toBe(CommandName.SUPERSEDE);
+      expect(command.description).toBe('Supersede an old UID with a new one');
+    });
+  });
+});