@newpeak/barista-cli 0.1.0

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

@@ -0,0 +1,111 @@
+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',
+    })),
+  },
+}));
+
+vi.mock('../../../../../src/core/auth/token-manager.js', () => ({
+  tokenManager: {
+    getToken: vi.fn(() => Promise.resolve('test-token')),
+  },
+}));
+
+vi.mock('../../../../../src/core/api/client.js', () => ({
+  apiClient: {
+    getEmployee: vi.fn(),
+  },
+}));
+
+import { createEmployeeGetCommand } from '../../../../../src/commands/liberica/employees/get.js';
+
+describe('createEmployeeGetCommand', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should create command with name "get"', () => {
+    const command = createEmployeeGetCommand();
+    expect(command.name()).toBe('get');
+  });
+
+  it('should have correct description', () => {
+    const command = createEmployeeGetCommand();
+    expect(command.description()).toBe('Get employee details by ID');
+  });
+
+  it('should have --json option', () => {
+    const command = createEmployeeGetCommand();
+    const jsonOption = command.options.find((opt) => opt.long === '--json');
+    expect(jsonOption).toBeDefined();
+  });
+});
+
+describe('get employee command logic', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should call apiClient.getEmployee with correct parameters', async () => {
+    const { apiClient } = await import('../../../../../src/core/api/client.js');
+    const mockEmployee = {
+      employeeId: 12345,
+      employeeCode: 'EMP001',
+      employeeName: 'John Doe',
+      employeeNo: '001',
+      statusFlag: 1,
+    };
+    (apiClient.getEmployee as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: true,
+      data: mockEmployee,
+    });
+
+    expect(apiClient.getEmployee).toBeDefined();
+  });
+
+  it('should handle employee not found (404)', async () => {
+    const { apiClient } = await import('../../../../../src/core/api/client.js');
+    (apiClient.getEmployee as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: false,
+      error: {
+        code: '01001150001',
+        message: '查询结果不存在',
+      },
+    });
+
+    expect(apiClient.getEmployee).toBeDefined();
+  });
+
+  it('should format JSON output correctly', async () => {
+    const { apiClient } = await import('../../../../../src/core/api/client.js');
+    const mockEmployee = {
+      employeeId: 12345,
+      employeeCode: 'EMP001',
+      employeeName: 'John Doe',
+      employeeNo: '001',
+      statusFlag: 1,
+    };
+    (apiClient.getEmployee as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: true,
+      data: mockEmployee,
+    });
+
+    const response = await apiClient.getEmployee('dev', 'test-tenant', 12345);
+    expect(response.success).toBe(true);
+    expect(response.data).toEqual(mockEmployee);
+  });
+});

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

@@ -0,0 +1,294 @@
+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('cli-table3', () => ({
+  default: vi.fn(() => ({
+    head: vi.fn(),
+    push: vi.fn(),
+    toString: vi.fn(() => 'mocked-table'),
+  })),
+}));
+
+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/auth/token-manager.js', () => ({
+  tokenManager: {
+    getToken: vi.fn(),
+    setToken: vi.fn(),
+    deleteToken: vi.fn(),
+  },
+}));
+
+vi.mock('../../../../../src/core/api/client.js', () => ({
+  apiClient: {
+    listEmployees: vi.fn(),
+  },
+}));
+
+import { createEmployeeListCommand } from '../../../../../src/commands/liberica/employees/list.js';
+
+const mockEmployees = [
+  {
+    employeeId: 1,
+    employeeCode: 'E001',
+    employeeName: '张三',
+    employeePhone: '13800000001',
+    orgName: '研发部',
+    orgCode: 'RD',
+    statusFlag: 1 as const,
+    employeeNo: '001',
+    employeeEmail: 'zhangsan@example.com',
+  },
+  {
+    employeeId: 2,
+    employeeCode: 'E002',
+    employeeName: '李四',
+    employeePhone: '13800000002',
+    orgName: '市场部',
+    orgCode: 'MKT',
+    statusFlag: 2 as const,
+    employeeNo: '002',
+    employeeEmail: 'lisi@example.com',
+  },
+];
+
+describe('createEmployeeListCommand', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should create command with name "list"', () => {
+    const command = createEmployeeListCommand();
+    expect(command.name()).toBe('list');
+  });
+
+  it('should have description "List employees with pagination"', () => {
+    const command = createEmployeeListCommand();
+    expect(command.description()).toBe('List employees with pagination');
+  });
+
+  it('should have --page option', () => {
+    const command = createEmployeeListCommand();
+    const pageOption = command.options.find((opt) => opt.short === '-p' || opt.long === '--page');
+    expect(pageOption).toBeDefined();
+  });
+
+  it('should have --size option', () => {
+    const command = createEmployeeListCommand();
+    const sizeOption = command.options.find((opt) => opt.short === '-s' || opt.long === '--size');
+    expect(sizeOption).toBeDefined();
+  });
+
+  it('should have --status option', () => {
+    const command = createEmployeeListCommand();
+    const statusOption = command.options.find((opt) => opt.long === '--status');
+    expect(statusOption).toBeDefined();
+  });
+
+  it('should have --org-id option', () => {
+    const command = createEmployeeListCommand();
+    const orgIdOption = command.options.find((opt) => opt.long === '--org-id');
+    expect(orgIdOption).toBeDefined();
+  });
+
+  it('should have --json option', () => {
+    const command = createEmployeeListCommand();
+    const jsonOption = command.options.find((opt) => opt.long === '--json');
+    expect(jsonOption).toBeDefined();
+  });
+
+  describe('apiClient.listEmployees', () => {
+    it('should be defined', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      expect(apiClient.listEmployees).toBeDefined();
+    });
+
+    it('should be called with correct default params', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      const { configManager } = await import('../../../../../src/core/config/manager.js');
+
+      (apiClient.listEmployees as ReturnType<typeof vi.fn>).mockResolvedValue({
+        success: true,
+        data: {
+          total: 0,
+          size: 20,
+          current: 1,
+          records: [],
+        },
+      });
+
+      expect(apiClient.listEmployees).toBeDefined();
+      expect(configManager.getCurrentContext).toBeDefined();
+    });
+  });
+
+  describe('command options defaults', () => {
+    it('should have page defaulting to "1"', () => {
+      const command = createEmployeeListCommand();
+      const pageOption = command.options.find((opt) => opt.short === '-p');
+      expect(pageOption?.defaultValue).toBe('1');
+    });
+
+    it('should have size defaulting to "20"', () => {
+      const command = createEmployeeListCommand();
+      const sizeOption = command.options.find((opt) => opt.short === '-s');
+      expect(sizeOption?.defaultValue).toBe('20');
+    });
+  });
+});
+
+describe('employee list response handling', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+  });
+
+  it('should handle successful response with employees', async () => {
+    const { apiClient } = await import('../../../../../src/core/api/client.js');
+
+    (apiClient.listEmployees as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: true,
+      data: {
+        total: 2,
+        size: 20,
+        current: 1,
+        records: mockEmployees,
+      },
+    });
+
+    expect(apiClient.listEmployees).toBeDefined();
+  });
+
+  it('should handle empty results gracefully', async () => {
+    const { apiClient } = await import('../../../../../src/core/api/client.js');
+
+    (apiClient.listEmployees as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: true,
+      data: {
+        total: 0,
+        size: 20,
+        current: 1,
+        records: [],
+      },
+    });
+
+    expect(apiClient.listEmployees).toBeDefined();
+  });
+
+  it('should handle API error response', async () => {
+    const { apiClient } = await import('../../../../../src/core/api/client.js');
+
+    (apiClient.listEmployees as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: false,
+      error: {
+        code: 'NO_TOKEN',
+        message: 'Not logged in. Run: barista auth login --service liberica --env dev',
+      },
+    });
+
+    expect(apiClient.listEmployees).toBeDefined();
+  });
+
+  it('should pass pagination params to apiClient.listEmployees', async () => {
+    const { apiClient } = await import('../../../../../src/core/api/client.js');
+    const { configManager } = await import('../../../../../src/core/config/manager.js');
+
+    (apiClient.listEmployees as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: true,
+      data: { total: 1, size: 10, current: 2, records: [mockEmployees[0]] },
+    });
+
+    expect(apiClient.listEmployees).toBeDefined();
+    expect(configManager.getCurrentContext).toBeDefined();
+  });
+
+  it('should pass status filter to apiClient.listEmployees', async () => {
+    const { apiClient } = await import('../../../../../src/core/api/client.js');
+
+    (apiClient.listEmployees as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: true,
+      data: { total: 1, size: 20, current: 1, records: [mockEmployees[0]] },
+    });
+
+    expect(apiClient.listEmployees).toBeDefined();
+  });
+
+  it('should pass org-id filter to apiClient.listEmployees', async () => {
+    const { apiClient } = await import('../../../../../src/core/api/client.js');
+
+    (apiClient.listEmployees as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: true,
+      data: { total: 1, size: 20, current: 1, records: [mockEmployees[0]] },
+    });
+
+    expect(apiClient.listEmployees).toBeDefined();
+  });
+
+  it('should output JSON when --json option is used', async () => {
+    const { apiClient } = await import('../../../../../src/core/api/client.js');
+
+    (apiClient.listEmployees as ReturnType<typeof vi.fn>).mockResolvedValue({
+      success: true,
+      data: {
+        total: 2,
+        size: 20,
+        current: 1,
+        records: mockEmployees,
+      },
+    });
+
+    expect(apiClient.listEmployees).toBeDefined();
+  });
+
+  it('should handle network error', async () => {
+    const { apiClient } = await import('../../../../../src/core/api/client.js');
+
+    (apiClient.listEmployees as ReturnType<typeof vi.fn>).mockRejectedValue(new Error('Network error'));
+
+    await expect(apiClient.listEmployees).rejects.toThrow('Network error');
+  });
+});
+
+describe('PageResult structure', () => {
+  it('should have correct pagination fields', () => {
+    const pageResult = {
+      total: 100,
+      size: 20,
+      current: 1,
+      records: mockEmployees,
+    };
+
+    expect(pageResult).toHaveProperty('total');
+    expect(pageResult).toHaveProperty('size');
+    expect(pageResult).toHaveProperty('current');
+    expect(pageResult).toHaveProperty('records');
+    expect(Array.isArray(pageResult.records)).toBe(true);
+  });
+
+  it('should calculate total pages correctly', () => {
+    const pageResult = {
+      total: 100,
+      size: 20,
+      current: 1,
+      records: mockEmployees,
+    };
+
+    const totalPages = Math.ceil(pageResult.total / pageResult.size);
+    expect(totalPages).toBe(5);
+  });
+});

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

@@ -0,0 +1,210 @@
+import { describe, it, expect, vi, beforeEach } 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/auth/token-manager.js', () => ({
+  tokenManager: {
+    getToken: vi.fn(() => Promise.resolve('mock-token')),
+  },
+}));
+
+vi.mock('../../../../../src/core/api/client.js', () => ({
+  apiClient: {
+    getEmployee: vi.fn(),
+    updateEmployee: vi.fn(),
+  },
+}));
+
+import { createEmployeeUpdateCommand } from '../../../../../src/commands/liberica/employees/update.js';
+
+describe('createEmployeeUpdateCommand', () => {
+  describe('command structure', () => {
+    it('should create command with name "update"', () => {
+      const command = createEmployeeUpdateCommand();
+      expect(command.name()).toBe('update');
+    });
+
+    it('should have correct description', () => {
+      const command = createEmployeeUpdateCommand();
+      expect(command.description()).toBe('Update employee information');
+    });
+
+    it('should have positional <id> argument', () => {
+      const command = createEmployeeUpdateCommand();
+      expect(command.description()).toContain('employee');
+    });
+
+    it('should have --name / -n option', () => {
+      const command = createEmployeeUpdateCommand();
+      const opt = command.options.find((o) => o.short === '-n' || o.long === '--name');
+      expect(opt).toBeDefined();
+    });
+
+    it('should have --phone / -p option', () => {
+      const command = createEmployeeUpdateCommand();
+      const opt = command.options.find((o) => o.short === '-p' || o.long === '--phone');
+      expect(opt).toBeDefined();
+    });
+
+    it('should have --email / -e option', () => {
+      const command = createEmployeeUpdateCommand();
+      const opt = command.options.find((o) => o.short === '-e' || o.long === '--email');
+      expect(opt).toBeDefined();
+    });
+
+    it('should have --position-id option', () => {
+      const command = createEmployeeUpdateCommand();
+      const opt = command.options.find((o) => o.long === '--position-id');
+      expect(opt).toBeDefined();
+    });
+
+    it('should have --joined-date / -d option', () => {
+      const command = createEmployeeUpdateCommand();
+      const opt = command.options.find((o) => o.short === '-d' || o.long === '--joined-date');
+      expect(opt).toBeDefined();
+    });
+
+    it('should have --org-id option', () => {
+      const command = createEmployeeUpdateCommand();
+      const opt = command.options.find((o) => o.long === '--org-id');
+      expect(opt).toBeDefined();
+    });
+
+    it('should have --dry-run option', () => {
+      const command = createEmployeeUpdateCommand();
+      const opt = command.options.find((o) => o.long === '--dry-run');
+      expect(opt).toBeDefined();
+    });
+
+    it('should have --json option', () => {
+      const command = createEmployeeUpdateCommand();
+      const opt = command.options.find((o) => o.long === '--json');
+      expect(opt).toBeDefined();
+    });
+  });
+
+  describe('API integration', () => {
+    beforeEach(() => {
+      vi.clearAllMocks();
+    });
+
+    it('should have getEmployee method on apiClient', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      expect(apiClient.getEmployee).toBeDefined();
+    });
+
+    it('should have updateEmployee method on apiClient', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      expect(apiClient.updateEmployee).toBeDefined();
+    });
+
+    it('should call getEmployee with correct params on employee not found', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      (apiClient.getEmployee as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+        success: false,
+        error: { code: '01001150001', message: '查询结果不存在' },
+      });
+      await apiClient.getEmployee('dev', 'test-tenant', 99999);
+      expect(apiClient.getEmployee).toHaveBeenCalledWith('dev', 'test-tenant', 99999);
+    });
+
+    it('should handle update failure error response', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      (apiClient.updateEmployee as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+        success: false,
+        error: { code: '01001150007', message: '指定岗位不存在' },
+      });
+      const response = await apiClient.updateEmployee('dev', 'test-tenant', {
+        employeeId: 123,
+        employeeName: 'Bad Update',
+      });
+      expect(response.success).toBe(false);
+      expect(response.error?.code).toBe('01001150007');
+    });
+
+    it('should handle update success response with correct data', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      const mockEmployee = {
+        employeeId: 123,
+        employeeName: 'Updated Name',
+        employeeNo: 'E001',
+        statusFlag: 1 as const,
+      };
+      (apiClient.updateEmployee as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+        success: true,
+        data: mockEmployee,
+      });
+      const response = await apiClient.updateEmployee('dev', 'test-tenant', {
+        employeeId: 123,
+        employeeName: 'Updated Name',
+      });
+      expect(response.success).toBe(true);
+      expect(response.data).toEqual(mockEmployee);
+    });
+
+    it('should pass partial update fields to updateEmployee', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      (apiClient.updateEmployee as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+        success: true,
+        data: { employeeId: 123, employeeName: 'New', employeeNo: 'E001', statusFlag: 1 as const },
+      });
+      const updateData = {
+        employeeId: 123,
+        employeeName: 'New',
+        employeePhone: '13900139000',
+        employeeEmail: 'test@example.com',
+      };
+      await apiClient.updateEmployee('dev', 'test-tenant', updateData);
+      expect(apiClient.updateEmployee).toHaveBeenCalledWith('dev', 'test-tenant', updateData);
+    });
+
+    it('should call getEmployee to fetch employee before update', async () => {
+      const { apiClient } = await import('../../../../../src/core/api/client.js');
+      (apiClient.getEmployee as ReturnType<typeof vi.fn>).mockResolvedValueOnce({
+        success: true,
+        data: { employeeId: 123, employeeName: 'Before', employeeNo: 'E001', statusFlag: 1 as const },
+      });
+      await apiClient.getEmployee('dev', 'test-tenant', 123);
+      expect(apiClient.getEmployee).toHaveBeenCalledWith('dev', 'test-tenant', 123);
+    });
+  });
+
+  describe('configManager integration', () => {
+    it('should have getCurrentContext on configManager', async () => {
+      const { configManager } = await import('../../../../../src/core/config/manager.js');
+      expect(configManager.getCurrentContext).toBeDefined();
+    });
+
+    it('should return correct context values', async () => {
+      const { configManager } = await import('../../../../../src/core/config/manager.js');
+      const context = configManager.getCurrentContext();
+      expect(context.environment).toBe('dev');
+      expect(context.tenant).toBe('test-tenant');
+      expect(context.service).toBe('liberica');
+    });
+  });
+});