shawnxixi-cli 1.1.4 → 1.2.0

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);
+    });
+  });
+});