shawnxixi-cli 1.1.3 → 1.2.0

package/tests/commands/calendar.test.ts

@@ -0,0 +1,124 @@
+/**
+ * Calendar Command Tests
+ * Comprehensive CLI integration tests for biz calendar commands
+ */
+
+import { calendarCommands } from '../../src/commands/biz/calendar';
+import { setGlobalFlags } from '../../src/utils/output';
+
+// Mock apiService
+jest.mock('../../src/services/api', () => ({
+  apiService: {
+    createCalendarEvent: jest.fn().mockResolvedValue({ id: 1, title: '测试日程' }),
+    listCalendarEvents: jest.fn().mockResolvedValue({ data: [{ id: 1, title: '测试日程' }] }),
+  },
+}));
+
+import { apiService } from '../../src/services/api';
+
+// Mock process.exit to prevent test from exiting
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+// Suppress console output during tests
+beforeAll(() => {
+  setGlobalFlags({ quiet: true });
+});
+
+afterAll(() => {
+  setGlobalFlags({ quiet: false });
+  mockExit.mockRestore();
+});
+
+describe('biz calendar commands', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('create', () => {
+    it('should call apiService.createCalendarEvent with title and required options', async () => {
+      await calendarCommands.create('测试日程', { from: '2026-04-12', to: '2026-04-13' });
+      expect(apiService.createCalendarEvent).toHaveBeenCalledWith(
+        '测试日程',
+        '2026-04-12',
+        '2026-04-13',
+        undefined,
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createCalendarEvent with all options', async () => {
+      await calendarCommands.create('测试日程', {
+        from: '2026-04-12 10:00',
+        to: '2026-04-12 11:00',
+        desc: '会议讨论',
+        location: '会议室A',
+        color: '#ff0000',
+      });
+      expect(apiService.createCalendarEvent).toHaveBeenCalledWith(
+        '测试日程',
+        '2026-04-12 10:00',
+        '2026-04-12 11:00',
+        '会议讨论',
+        '会议室A',
+        '#ff0000'
+      );
+    });
+
+    it('should exit with error when from is missing', async () => {
+      await calendarCommands.create('测试日程', { to: '2026-04-13' });
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should exit with error when to is missing', async () => {
+      await calendarCommands.create('测试日程', { from: '2026-04-12' });
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.createCalendarEvent as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await calendarCommands.create('测试日程', { from: '2026-04-12', to: '2026-04-13' });
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('list', () => {
+    it('should call apiService.listCalendarEvents without filters', async () => {
+      await calendarCommands.list();
+      expect(apiService.listCalendarEvents).toHaveBeenCalledWith(undefined, undefined);
+    });
+
+    it('should call apiService.listCalendarEvents with from filter', async () => {
+      await calendarCommands.list({ from: '2026-04-01' });
+      expect(apiService.listCalendarEvents).toHaveBeenCalledWith('2026-04-01', undefined);
+    });
+
+    it('should call apiService.listCalendarEvents with to filter', async () => {
+      await calendarCommands.list({ to: '2026-04-30' });
+      expect(apiService.listCalendarEvents).toHaveBeenCalledWith(undefined, '2026-04-30');
+    });
+
+    it('should call apiService.listCalendarEvents with both filters', async () => {
+      await calendarCommands.list({ from: '2026-04-01', to: '2026-04-30' });
+      expect(apiService.listCalendarEvents).toHaveBeenCalledWith('2026-04-01', '2026-04-30');
+    });
+
+    it('should handle empty results', async () => {
+      (apiService.listCalendarEvents as jest.Mock).mockResolvedValueOnce({ data: [] });
+
+      await calendarCommands.list();
+
+      expect(apiService.listCalendarEvents).toHaveBeenCalled();
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.listCalendarEvents as jest.Mock).mockRejectedValueOnce(new Error('Network Error'));
+
+      await calendarCommands.list();
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+});

package/tests/commands/health.test.ts

@@ -0,0 +1,160 @@
+/**
+ * Health Command Tests
+ * Comprehensive CLI integration tests for biz health commands
+ */
+
+import { healthCommands } from '../../src/commands/biz/health';
+import { setGlobalFlags } from '../../src/utils/output';
+
+// Mock apiService
+jest.mock('../../src/services/api', () => ({
+  apiService: {
+    logHealthData: jest.fn().mockResolvedValue({ id: 1, dataType: 'heart_rate', value: '72' }),
+    listHealthData: jest.fn().mockResolvedValue({ data: [{ id: 1, dataType: 'heart_rate', value: '72' }] }),
+    syncHealthData: jest.fn().mockResolvedValue({ synced: true }),
+  },
+}));
+
+import { apiService } from '../../src/services/api';
+
+// Mock process.exit to prevent test from exiting
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+// Suppress console output during tests
+beforeAll(() => {
+  setGlobalFlags({ quiet: true });
+});
+
+afterAll(() => {
+  setGlobalFlags({ quiet: false });
+  mockExit.mockRestore();
+});
+
+describe('biz health commands', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('log', () => {
+    it('should call apiService.logHealthData with required options', async () => {
+      await healthCommands.log({ dataType: 'heart_rate', value: '72' });
+      expect(apiService.logHealthData).toHaveBeenCalledWith(
+        'heart_rate',
+        '72',
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.logHealthData with unit', async () => {
+      await healthCommands.log({ dataType: 'heart_rate', value: '72', unit: 'bpm' });
+      expect(apiService.logHealthData).toHaveBeenCalledWith(
+        'heart_rate',
+        '72',
+        'bpm',
+        undefined
+      );
+    });
+
+    it('should call apiService.logHealthData with date', async () => {
+      await healthCommands.log({ dataType: 'heart_rate', value: '72', date: '2026-04-12' });
+      expect(apiService.logHealthData).toHaveBeenCalledWith(
+        'heart_rate',
+        '72',
+        undefined,
+        '2026-04-12'
+      );
+    });
+
+    it('should call apiService.logHealthData with all options', async () => {
+      await healthCommands.log({
+        dataType: 'weight',
+        value: '70.5',
+        unit: 'kg',
+        date: '2026-04-12',
+      });
+      expect(apiService.logHealthData).toHaveBeenCalledWith(
+        'weight',
+        '70.5',
+        'kg',
+        '2026-04-12'
+      );
+    });
+
+    it('should exit with error when dataType is missing', async () => {
+      await healthCommands.log({ value: '72' });
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should exit with error when value is missing', async () => {
+      await healthCommands.log({ dataType: 'heart_rate' });
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.logHealthData as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await healthCommands.log({ dataType: 'heart_rate', value: '72' });
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('list', () => {
+    it('should call apiService.listHealthData without filters', async () => {
+      await healthCommands.list();
+      expect(apiService.listHealthData).toHaveBeenCalledWith(undefined, undefined, undefined);
+    });
+
+    it('should call apiService.listHealthData with dataType filter', async () => {
+      await healthCommands.list({ dataType: 'heart_rate' });
+      expect(apiService.listHealthData).toHaveBeenCalledWith('heart_rate', undefined, undefined);
+    });
+
+    it('should call apiService.listHealthData with from date', async () => {
+      await healthCommands.list({ from: '2026-04-01' });
+      expect(apiService.listHealthData).toHaveBeenCalledWith(undefined, '2026-04-01', undefined);
+    });
+
+    it('should call apiService.listHealthData with to date', async () => {
+      await healthCommands.list({ to: '2026-04-12' });
+      expect(apiService.listHealthData).toHaveBeenCalledWith(undefined, undefined, '2026-04-12');
+    });
+
+    it('should call apiService.listHealthData with all filters', async () => {
+      await healthCommands.list({ dataType: 'heart_rate', from: '2026-04-01', to: '2026-04-12' });
+      expect(apiService.listHealthData).toHaveBeenCalledWith('heart_rate', '2026-04-01', '2026-04-12');
+    });
+
+    it('should handle empty results', async () => {
+      (apiService.listHealthData as jest.Mock).mockResolvedValueOnce({ data: [] });
+
+      await healthCommands.list();
+
+      expect(apiService.listHealthData).toHaveBeenCalled();
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.listHealthData as jest.Mock).mockRejectedValueOnce(new Error('Network Error'));
+
+      await healthCommands.list();
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('sync', () => {
+    it('should call apiService.syncHealthData', async () => {
+      await healthCommands.sync();
+      expect(apiService.syncHealthData).toHaveBeenCalled();
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.syncHealthData as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await healthCommands.sync();
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+});

package/tests/commands/item.test.ts

@@ -145,12 +145,22 @@ describe('biz item commands', () => {
   describe('list', () => {
     it('should call apiService.listItems without filters', async () => {
       await itemCommands.list();
-      expect(apiService.listItems).toHaveBeenCalledWith(undefined);
+      expect(apiService.listItems).toHaveBeenCalledWith(undefined, undefined);
     });
 
     it('should call apiService.listItems with category filter', async () => {
       await itemCommands.list({ category: 'electronics' });
-      expect(apiService.listItems).toHaveBeenCalledWith('electronics');
+      expect(apiService.listItems).toHaveBeenCalledWith('electronics', undefined);
+    });
+
+    it('should call apiService.listItems with status filter', async () => {
+      await itemCommands.list({ status: 'out_of_stock' });
+      expect(apiService.listItems).toHaveBeenCalledWith(undefined, 'out_of_stock');
+    });
+
+    it('should call apiService.listItems with both filters', async () => {
+      await itemCommands.list({ category: 'electronics', status: 'out_of_stock' });
+      expect(apiService.listItems).toHaveBeenCalledWith('electronics', 'out_of_stock');
     });
 
     it('should handle empty results', async () => {

package/tests/commands/record.test.ts

@@ -0,0 +1,134 @@
+/**
+ * Record Command Tests
+ * Comprehensive CLI integration tests for biz record commands
+ */
+
+import { recordCommands } from '../../src/commands/biz/record';
+import { setGlobalFlags } from '../../src/utils/output';
+
+// Mock apiService
+jest.mock('../../src/services/api', () => ({
+  apiService: {
+    createRecord: jest.fn().mockResolvedValue({ id: 1, title: '测试记录' }),
+    listRecords: jest.fn().mockResolvedValue({ data: [{ id: 1, title: '测试记录' }] }),
+  },
+}));
+
+import { apiService } from '../../src/services/api';
+
+// Mock process.exit to prevent test from exiting
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+// Suppress console output during tests
+beforeAll(() => {
+  setGlobalFlags({ quiet: true });
+});
+
+afterAll(() => {
+  setGlobalFlags({ quiet: false });
+  mockExit.mockRestore();
+});
+
+describe('biz record commands', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('create', () => {
+    it('should call apiService.createRecord with title and empty content', async () => {
+      await recordCommands.create('测试记录', '');
+      expect(apiService.createRecord).toHaveBeenCalledWith(
+        '测试记录',
+        '',
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createRecord with content', async () => {
+      await recordCommands.create('测试记录', '这是记录内容');
+      expect(apiService.createRecord).toHaveBeenCalledWith(
+        '测试记录',
+        '这是记录内容',
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createRecord with type', async () => {
+      await recordCommands.create('测试记录', '', { type: 'diary' });
+      expect(apiService.createRecord).toHaveBeenCalledWith(
+        '测试记录',
+        '',
+        'diary',
+        undefined
+      );
+    });
+
+    it('should call apiService.createRecord with tags', async () => {
+      await recordCommands.create('测试记录', '', { tags: 'work,important' });
+      expect(apiService.createRecord).toHaveBeenCalledWith(
+        '测试记录',
+        '',
+        undefined,
+        'work,important'
+      );
+    });
+
+    it('should call apiService.createRecord with all options', async () => {
+      await recordCommands.create('测试记录', '内容部分', { type: 'note', tags: 'test' });
+      expect(apiService.createRecord).toHaveBeenCalledWith(
+        '测试记录',
+        '内容部分',
+        'note',
+        'test'
+      );
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.createRecord as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await recordCommands.create('测试记录', '');
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('list', () => {
+    it('should call apiService.listRecords without filters', async () => {
+      await recordCommands.list();
+      expect(apiService.listRecords).toHaveBeenCalledWith(undefined, undefined);
+    });
+
+    it('should call apiService.listRecords with type filter', async () => {
+      await recordCommands.list({ type: 'diary' });
+      expect(apiService.listRecords).toHaveBeenCalledWith('diary', undefined);
+    });
+
+    it('should call apiService.listRecords with tags filter', async () => {
+      await recordCommands.list({ tags: 'work' });
+      expect(apiService.listRecords).toHaveBeenCalledWith(undefined, 'work');
+    });
+
+    it('should call apiService.listRecords with both filters', async () => {
+      await recordCommands.list({ type: 'pet', tags: 'cat' });
+      expect(apiService.listRecords).toHaveBeenCalledWith('pet', 'cat');
+    });
+
+    it('should handle empty results', async () => {
+      (apiService.listRecords as jest.Mock).mockResolvedValueOnce({ data: [] });
+
+      await recordCommands.list();
+
+      expect(apiService.listRecords).toHaveBeenCalled();
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.listRecords as jest.Mock).mockRejectedValueOnce(new Error('Network Error'));
+
+      await recordCommands.list();
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+});

package/tests/commands/task.test.ts

@@ -0,0 +1,180 @@
+/**
+ * Task Command Tests
+ * Comprehensive CLI integration tests for biz task commands
+ */
+
+import { taskCommands } from '../../src/commands/biz/task';
+import { setGlobalFlags } from '../../src/utils/output';
+
+// Mock apiService
+jest.mock('../../src/services/api', () => ({
+  apiService: {
+    createTask: jest.fn().mockResolvedValue({ id: 1, title: '测试任务' }),
+    listTasks: jest.fn().mockResolvedValue({ data: [{ id: 1, title: '测试任务' }] }),
+    updateTask: jest.fn().mockResolvedValue({ id: 1, status: 'done' }),
+    deleteTask: jest.fn().mockResolvedValue({ success: true }),
+  },
+}));
+
+import { apiService } from '../../src/services/api';
+
+// Mock process.exit to prevent test from exiting
+const mockExit = jest.spyOn(process, 'exit').mockImplementation((() => {}) as any);
+
+// Suppress console output during tests
+beforeAll(() => {
+  setGlobalFlags({ quiet: true });
+});
+
+afterAll(() => {
+  setGlobalFlags({ quiet: false });
+  mockExit.mockRestore();
+});
+
+describe('biz task commands', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  describe('list', () => {
+    it('should call apiService.listTasks without filters', async () => {
+      await taskCommands.list();
+      expect(apiService.listTasks).toHaveBeenCalledWith(undefined, undefined);
+    });
+
+    it('should call apiService.listTasks with status filter', async () => {
+      await taskCommands.list({ status: 'running' });
+      expect(apiService.listTasks).toHaveBeenCalledWith('running', undefined);
+    });
+
+    it('should call apiService.listTasks with source filter', async () => {
+      await taskCommands.list({ source: 'openclaw' });
+      expect(apiService.listTasks).toHaveBeenCalledWith(undefined, 'openclaw');
+    });
+
+    it('should call apiService.listTasks with both filters', async () => {
+      await taskCommands.list({ status: 'pending', source: 'cli' });
+      expect(apiService.listTasks).toHaveBeenCalledWith('pending', 'cli');
+    });
+
+    it('should handle empty results', async () => {
+      (apiService.listTasks as jest.Mock).mockResolvedValueOnce({ data: [] });
+
+      await taskCommands.list();
+
+      expect(apiService.listTasks).toHaveBeenCalled();
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.listTasks as jest.Mock).mockRejectedValueOnce(new Error('Network Error'));
+
+      await taskCommands.list();
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('create', () => {
+    it('should call apiService.createTask with title only', async () => {
+      await taskCommands.create('测试任务');
+      expect(apiService.createTask).toHaveBeenCalledWith(
+        '测试任务',
+        undefined,
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createTask with source', async () => {
+      await taskCommands.create('测试任务', { source: 'openclaw' });
+      expect(apiService.createTask).toHaveBeenCalledWith(
+        '测试任务',
+        'openclaw',
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createTask with openclawId', async () => {
+      await taskCommands.create('测试任务', { openclawId: '123' });
+      expect(apiService.createTask).toHaveBeenCalledWith(
+        '测试任务',
+        undefined,
+        '123',
+        undefined
+      );
+    });
+
+    it('should call apiService.createTask with priority', async () => {
+      await taskCommands.create('测试任务', { priority: 'high' });
+      expect(apiService.createTask).toHaveBeenCalledWith(
+        '测试任务',
+        undefined,
+        undefined,
+        'high'
+      );
+    });
+
+    it('should call apiService.createTask with all options', async () => {
+      await taskCommands.create('测试任务', {
+        source: 'openclaw',
+        openclawId: '456',
+        priority: 'medium',
+      });
+      expect(apiService.createTask).toHaveBeenCalledWith(
+        '测试任务',
+        'openclaw',
+        '456',
+        'medium'
+      );
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.createTask as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await taskCommands.create('测试任务');
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('update', () => {
+    it('should call apiService.updateTask with status', async () => {
+      await taskCommands.update(1, { status: 'running' });
+      expect(apiService.updateTask).toHaveBeenCalledWith(1, { status: 'running' });
+    });
+
+    it('should call apiService.updateTask with priority', async () => {
+      await taskCommands.update(1, { priority: 'high' });
+      expect(apiService.updateTask).toHaveBeenCalledWith(1, { priority: 'high' });
+    });
+
+    it('should call apiService.updateTask with both updates', async () => {
+      await taskCommands.update(1, { status: 'done', priority: 'low' });
+      expect(apiService.updateTask).toHaveBeenCalledWith(1, { status: 'done', priority: 'low' });
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.updateTask as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await taskCommands.update(1, { status: 'done' });
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('delete', () => {
+    it('should call apiService.deleteTask with id', async () => {
+      await taskCommands.delete(1);
+      expect(apiService.deleteTask).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.deleteTask as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await taskCommands.delete(1);
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+});