@newpeak/barista-cli 0.1.0

package/tests/unit/commands/liberica/employees/create.test.ts

@@ -0,0 +1,463 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+vi.mock('chalk', () => ({
+  default: {
+    bold: vi.fn((text) => text),
+    green: vi.fn((text) => text),
+    red: vi.fn((text) => text),
+    gray: vi.fn((text) => text),
+  },
+}));
+
+
+
+vi.mock('../../../../../src/core/config/manager.js', () => ({
+  configManager: {
+    getCurrentContext: vi.fn(() => ({
+      environment: 'dev' as const,
+      service: 'liberica' as const,
+      tenant: 'test-tenant',
+    })),
+    setTenant: vi.fn(),
+  },
+}));
+
+vi.mock('../../../../../src/core/auth/token-manager.js', () => ({
+  tokenManager: {
+    getToken: vi.fn(() => Promise.resolve('test-token')),
+    setToken: vi.fn(),
+    deleteToken: vi.fn(),
+    findAllTokens: vi.fn(() => []),
+  },
+}));
+
+vi.mock('../../../../../src/core/api/client.js', () => ({
+  apiClient: {
+    createEmployee: vi.fn(),
+    getCodeByType: vi.fn(),
+    getOrgListName: vi.fn(),
+    listPositions: vi.fn(),
+  },
+}));
+
+import { createEmployeeCreateCommand } from '../../../../../src/commands/liberica/employees/create.js';
+import { apiClient } from '../../../../../src/core/api/client.js';
+import { configManager } from '../../../../../src/core/config/manager.js';
+
+const defaultContext = {
+  environment: 'dev' as const,
+  service: 'liberica' as const,
+  tenant: 'test-tenant',
+};
+
+describe('createEmployeeCreateCommand', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    (configManager.getCurrentContext as ReturnType<typeof vi.fn>).mockReturnValue(defaultContext);
+  });
+
+  it('should create command with name "create"', () => {
+    const command = createEmployeeCreateCommand();
+    expect(command.name()).toBe('create');
+  });
+
+  it('should have description "Create a new employee"', () => {
+    const command = createEmployeeCreateCommand();
+    expect(command.description()).toBe('Create a new employee');
+  });
+
+  it('should have --name option', () => {
+    const command = createEmployeeCreateCommand();
+    const nameOption = command.options.find((opt) => opt.long === '--name');
+    expect(nameOption).toBeDefined();
+  });
+
+  it('should have --code option', () => {
+    const command = createEmployeeCreateCommand();
+    const codeOption = command.options.find((opt) => opt.long === '--code');
+    expect(codeOption).toBeDefined();
+  });
+
+  it('should have --phone option', () => {
+    const command = createEmployeeCreateCommand();
+    const phoneOption = command.options.find((opt) => opt.long === '--phone');
+    expect(phoneOption).toBeDefined();
+  });
+
+  it('should have --email option', () => {
+    const command = createEmployeeCreateCommand();
+    const emailOption = command.options.find((opt) => opt.long === '--email');
+    expect(emailOption).toBeDefined();
+  });
+
+  it('should have --sex option', () => {
+    const command = createEmployeeCreateCommand();
+    const sexOption = command.options.find((opt) => opt.long === '--sex');
+    expect(sexOption).toBeDefined();
+  });
+
+  it('should have --org option', () => {
+    const command = createEmployeeCreateCommand();
+    const orgOption = command.options.find((opt) => opt.long === '--org');
+    expect(orgOption).toBeDefined();
+  });
+
+  it('should have --position option', () => {
+    const command = createEmployeeCreateCommand();
+    const posOption = command.options.find((opt) => opt.long === '--position');
+    expect(posOption).toBeDefined();
+  });
+
+  it('should have --joined-date option', () => {
+    const command = createEmployeeCreateCommand();
+    const dateOption = command.options.find((opt) => opt.long === '--joined-date');
+    expect(dateOption).toBeDefined();
+  });
+
+  it('should have --no option', () => {
+    const command = createEmployeeCreateCommand();
+    const noOption = command.options.find((opt) => opt.long === '--no');
+    expect(noOption).toBeDefined();
+  });
+
+  it('should have --dry-run option', () => {
+    const command = createEmployeeCreateCommand();
+    const dryRunOption = command.options.find((opt) => opt.long === '--dry-run');
+    expect(dryRunOption).toBeDefined();
+  });
+
+  it('should have --json option', () => {
+    const command = createEmployeeCreateCommand();
+    const jsonOption = command.options.find((opt) => opt.long === '--json');
+    expect(jsonOption).toBeDefined();
+  });
+
+  it('should have -n short option for --name', () => {
+    const command = createEmployeeCreateCommand();
+    const nameOption = command.options.find((opt) => opt.short === '-n');
+    expect(nameOption).toBeDefined();
+  });
+
+  it('should have -c short option for --code', () => {
+    const command = createEmployeeCreateCommand();
+    const codeOption = command.options.find((opt) => opt.short === '-c');
+    expect(codeOption).toBeDefined();
+  });
+
+  it('should have -p short option for --phone', () => {
+    const command = createEmployeeCreateCommand();
+    const phoneOption = command.options.find((opt) => opt.short === '-p');
+    expect(phoneOption).toBeDefined();
+  });
+
+  it('should have -e short option for --email', () => {
+    const command = createEmployeeCreateCommand();
+    const emailOption = command.options.find((opt) => opt.short === '-e');
+    expect(emailOption).toBeDefined();
+  });
+
+  it('should have -s short option for --sex', () => {
+    const command = createEmployeeCreateCommand();
+    const sexOption = command.options.find((opt) => opt.short === '-s');
+    expect(sexOption).toBeDefined();
+  });
+
+  it('should have -d short option for --joined-date', () => {
+    const command = createEmployeeCreateCommand();
+    const dateOption = command.options.find((opt) => opt.short === '-d');
+    expect(dateOption).toBeDefined();
+  });
+});
+
+describe('createEmployeeCreateCommand validation', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    (configManager.getCurrentContext as ReturnType<typeof vi.fn>).mockReturnValue(defaultContext);
+    (apiClient.getCodeByType as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: true,
+      data: 'TESTCODE001',
+    });
+    vi.spyOn(process, 'exit').mockImplementation((() => {
+      throw new Error('process.exit');
+    }) as typeof process.exit);
+  });
+
+  it('should validate email format', async () => {
+    const command = createEmployeeCreateCommand();
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await expect(
+      command.parseAsync(['node', 'test', '--name', 'Test', '--no', 'E001', '--email', 'invalid-email'])
+    ).rejects.toThrow('process.exit');
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid email format'));
+    consoleErrorSpy.mockRestore();
+  });
+
+  it('should validate phone format', async () => {
+    const command = createEmployeeCreateCommand();
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await expect(
+      command.parseAsync(['node', 'test', '--name', 'Test', '--no', 'E001', '--phone', 'abc@123'])
+    ).rejects.toThrow('process.exit');
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid phone format'));
+    consoleErrorSpy.mockRestore();
+  });
+
+  it('should validate date format', async () => {
+    const command = createEmployeeCreateCommand();
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await expect(
+      command.parseAsync(['node', 'test', '--name', 'Test', '--no', 'E001', '--joined-date', '2024/01/15'])
+    ).rejects.toThrow('process.exit');
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid date format'));
+    consoleErrorSpy.mockRestore();
+  });
+
+  it('should validate sex value', async () => {
+    const command = createEmployeeCreateCommand();
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await expect(
+      command.parseAsync(['node', 'test', '--name', 'Test', '--no', 'E001', '--sex', 'X'])
+    ).rejects.toThrow('process.exit');
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Invalid sex value'));
+    consoleErrorSpy.mockRestore();
+  });
+});
+
+describe('createEmployeeCreateCommand dry-run', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    (configManager.getCurrentContext as ReturnType<typeof vi.fn>).mockReturnValue(defaultContext);
+    (apiClient.getCodeByType as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: true,
+      data: 'TESTCODE001',
+    });
+  });
+
+  it('should not call apiClient.createEmployee in dry-run mode', async () => {
+    const command = createEmployeeCreateCommand();
+    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await command.parseAsync(['node', 'test', '--name', 'Test User', '--no', 'E001', '--dry-run']);
+
+    expect(apiClient.createEmployee).not.toHaveBeenCalled();
+    expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('Dry-Run'));
+    consoleLogSpy.mockRestore();
+  });
+
+  it('should output JSON in dry-run mode with --json', async () => {
+    const command = createEmployeeCreateCommand();
+    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await command.parseAsync(['node', 'test', '--name', 'Test User', '--no', 'E001', '--dry-run', '--json']);
+
+    expect(apiClient.createEmployee).not.toHaveBeenCalled();
+    expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('"dryRun":true'));
+    consoleLogSpy.mockRestore();
+  });
+});
+
+describe('createEmployeeCreateCommand API interaction', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    (configManager.getCurrentContext as ReturnType<typeof vi.fn>).mockReturnValue(defaultContext);
+    (apiClient.getCodeByType as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: true,
+      data: 'TESTCODE001',
+    });
+    (apiClient.getOrgListName as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: true,
+      data: [
+        { id: 100, name: '人力资源部' },
+        { id: 101, name: '销售部' },
+      ],
+    });
+    (apiClient.listPositions as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: true,
+      data: [
+        { id: 'MANAGER', name: '经理' },
+        { id: 'STAFF', name: '员工' },
+      ],
+    });
+    vi.spyOn(process, 'exit').mockImplementation((() => {
+      throw new Error('process.exit');
+    }) as typeof process.exit);
+  });
+
+  it('should call apiClient.createEmployee with correct data on happy path', async () => {
+    (apiClient.createEmployee as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: true,
+      data: {
+        employeeId: 1,
+        employeeName: 'Test User',
+        employeeNo: 'E001',
+        statusFlag: 1 as const,
+      },
+    });
+
+    const command = createEmployeeCreateCommand();
+
+    await command.parseAsync([
+      'node', 'test',
+      '--name', 'Test User',
+      '--no', 'E001',
+      '--code', 'CODE001',
+      '--phone', '13800138000',
+      '--email', 'test@example.com',
+      '--sex', 'M',
+      '--org', '人力资源部',
+      '--position', '经理',
+      '--joined-date', '2024-01-15',
+    ]);
+
+    expect(apiClient.createEmployee).toHaveBeenCalledWith(
+      'dev',
+      'test-tenant',
+      expect.objectContaining({
+        employeeName: 'Test User',
+        employeeNo: 'E001',
+        employeeCode: 'CODE001',
+        employeePhone: '13800138000',
+        employeeEmail: 'test@example.com',
+        employeeSex: 'M',
+        organizationId: 100,
+        positionId: 'MANAGER',
+        employeeJoinedDate: '2024-01-15',
+      })
+    );
+  });
+
+  it('should call apiClient.createEmployee with minimal fields', async () => {
+    (apiClient.createEmployee as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: true,
+      data: {
+        employeeId: 2,
+        employeeName: 'Minimal User',
+        employeeNo: 'E002',
+        statusFlag: 1 as const,
+      },
+    });
+
+    const command = createEmployeeCreateCommand();
+
+    await command.parseAsync(['node', 'test', '--name', 'Minimal User', '--no', 'E002']);
+
+    expect(apiClient.createEmployee).toHaveBeenCalledWith(
+      'dev',
+      'test-tenant',
+      expect.objectContaining({
+        employeeName: 'Minimal User',
+        employeeNo: 'E002',
+      })
+    );
+  });
+
+  it('should handle API error and exit with code 1', async () => {
+    (apiClient.createEmployee as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: false,
+      error: {
+        code: '01001150003',
+        message: '职员编码规则不能为空',
+      },
+    });
+
+    const command = createEmployeeCreateCommand();
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await expect(
+      command.parseAsync(['node', 'test', '--name', 'Test', '--no', 'E001'])
+    ).rejects.toThrow('process.exit');
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('职员编码规则不能为空'));
+    consoleErrorSpy.mockRestore();
+  });
+
+  it('should handle API network error', async () => {
+    (apiClient.createEmployee as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: false,
+      error: {
+        code: 'NETWORK_ERROR',
+        message: 'Network error occurred',
+      },
+    });
+
+    const command = createEmployeeCreateCommand();
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await expect(
+      command.parseAsync(['node', 'test', '--name', 'Test', '--no', 'E001'])
+    ).rejects.toThrow('process.exit');
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining('Network error occurred'));
+    consoleErrorSpy.mockRestore();
+  });
+
+  it('should output JSON on API success', async () => {
+    (apiClient.createEmployee as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: true,
+      data: {
+        employeeId: 1,
+        employeeName: 'Test User',
+        employeeNo: 'E001',
+        statusFlag: 1 as const,
+      },
+    });
+
+    const command = createEmployeeCreateCommand();
+    const consoleLogSpy = vi.spyOn(console, 'log').mockImplementation(() => {});
+
+    await command.parseAsync(['node', 'test', '--name', 'Test User', '--no', 'E001', '--json']);
+
+    expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('"success":true'));
+    expect(consoleLogSpy).toHaveBeenCalledWith(expect.stringContaining('"employeeId":1'));
+    consoleLogSpy.mockRestore();
+  });
+
+  it('should error when organization name not found', async () => {
+    const command = createEmployeeCreateCommand();
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await expect(
+      command.parseAsync(['node', 'test', '--name', 'Test', '--no', 'E001', '--org', '不存在的部门'])
+    ).rejects.toThrow('process.exit');
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("Organization '不存在的部门' not found"));
+    consoleErrorSpy.mockRestore();
+  });
+
+  it('should error when position name not found', async () => {
+    const command = createEmployeeCreateCommand();
+    const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+
+    await expect(
+      command.parseAsync(['node', 'test', '--name', 'Test', '--no', 'E001', '--position', '不存在的岗位'])
+    ).rejects.toThrow('process.exit');
+
+    expect(consoleErrorSpy).toHaveBeenCalledWith(expect.stringContaining("Position '不存在的岗位' not found"));
+    consoleErrorSpy.mockRestore();
+  });
+});
+
+describe('createEmployeeCreateCommand interactive prompts', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    (configManager.getCurrentContext as ReturnType<typeof vi.fn>).mockReturnValue(defaultContext);
+  });
+
+  it('should have prompt behavior for missing name', () => {
+    const command = createEmployeeCreateCommand();
+    expect(command).toBeDefined();
+  });
+
+  it('should have prompt behavior for missing no', () => {
+    const command = createEmployeeCreateCommand();
+    expect(command).toBeDefined();
+  });
+});

package/tests/unit/commands/liberica/employees/disable.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+vi.mock('chalk', () => ({
+  default: {
+    bold: vi.fn((text) => text),
+    green: vi.fn((text) => text),
+    red: vi.fn((text) => text),
+    gray: vi.fn((text) => text),
+    cyan: vi.fn((text) => text),
+  },
+}));
+
+vi.mock('inquirer', () => ({
+  default: {
+    prompt: vi.fn(),
+  },
+}));
+
+vi.mock('../../../../../src/core/config/manager.js', () => ({
+  configManager: {
+    getCurrentContext: vi.fn(() => ({
+      environment: 'dev' as const,
+      service: 'liberica' as const,
+      tenant: 'test-tenant',
+    })),
+  },
+}));
+
+vi.mock('../../../../../src/core/api/client.js', () => ({
+  apiClient: {
+    getEmployee: vi.fn(),
+    disableEmployee: vi.fn(),
+  },
+}));
+
+import { createEmployeeDisableCommand } from '../../../../../src/commands/liberica/employees/disable.js';
+
+describe('createEmployeeDisableCommand', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should create command with name "disable"', () => {
+    const command = createEmployeeDisableCommand();
+    expect(command.name()).toBe('disable');
+  });
+
+  it('should have correct description', () => {
+    const command = createEmployeeDisableCommand();
+    expect(command.description()).toBe('Disable (deactivate) an employee account');
+  });
+
+  describe('API integration', () => {
+    it('should call apiClient.getEmployee to fetch employee details', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      expect(apiClient.getEmployee).toBeDefined();
+    });
+
+    it('should call apiClient.disableEmployee to disable employee', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      expect(apiClient.disableEmployee).toBeDefined();
+    });
+
+    it('should handle employee not found error', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      (apiClient.getEmployee as ReturnType<typeof vi.fn>).mockResolvedValue({
+        success: false,
+        error: { code: '01001150001', message: 'Employee not found' },
+      });
+      expect(apiClient.getEmployee).toBeDefined();
+    });
+
+    it('should handle already disabled employee (idempotent)', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      (apiClient.disableEmployee as ReturnType<typeof vi.fn>).mockResolvedValue({
+        success: false,
+        error: { code: '01001150001', message: 'Employee not found' },
+      });
+      expect(apiClient.disableEmployee).toBeDefined();
+    });
+  });
+});

package/tests/unit/commands/liberica/employees/enable.test.ts

@@ -0,0 +1,82 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+vi.mock('chalk', () => ({
+  default: {
+    bold: vi.fn((text) => text),
+    green: vi.fn((text) => text),
+    red: vi.fn((text) => text),
+    gray: vi.fn((text) => text),
+    cyan: vi.fn((text) => text),
+  },
+}));
+
+vi.mock('inquirer', () => ({
+  default: {
+    prompt: vi.fn(),
+  },
+}));
+
+vi.mock('../../../../../src/core/config/manager.js', () => ({
+  configManager: {
+    getCurrentContext: vi.fn(() => ({
+      environment: 'dev' as const,
+      service: 'liberica' as const,
+      tenant: 'test-tenant',
+    })),
+  },
+}));
+
+vi.mock('../../../../../src/core/api/client.js', () => ({
+  apiClient: {
+    getEmployee: vi.fn(),
+    enableEmployee: vi.fn(),
+  },
+}));
+
+import { createEmployeeEnableCommand } from '../../../../../src/commands/liberica/employees/enable.js';
+
+describe('createEmployeeEnableCommand', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should create command with name "enable"', () => {
+    const command = createEmployeeEnableCommand();
+    expect(command.name()).toBe('enable');
+  });
+
+  it('should have correct description', () => {
+    const command = createEmployeeEnableCommand();
+    expect(command.description()).toBe('Enable (activate) an employee account');
+  });
+
+  describe('API integration', () => {
+    it('should call apiClient.getEmployee to fetch employee details', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      expect(apiClient.getEmployee).toBeDefined();
+    });
+
+    it('should call apiClient.enableEmployee to enable employee', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      expect(apiClient.enableEmployee).toBeDefined();
+    });
+
+    it('should handle employee not found error', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      (apiClient.getEmployee as ReturnType<typeof vi.fn>).mockResolvedValue({
+        success: false,
+        error: { code: '01001150001', message: 'Employee not found' },
+      });
+      expect(apiClient.getEmployee).toBeDefined();
+    });
+
+    it('should handle already enabled employee (idempotent)', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      (apiClient.enableEmployee as ReturnType<typeof vi.fn>).mockResolvedValue({
+        success: false,
+        error: { code: '01001150001', message: 'Employee not found' },
+      });
+      expect(apiClient.enableEmployee).toBeDefined();
+    });
+  });
+});