shawnxixi-cli 0.3.0 → 1.1.0

package/tests/commands/todo.test.ts

@@ -1,39 +1,322 @@
 /**
  * Todo Command Tests
+ * Comprehensive CLI integration tests for biz todo commands
  */
 
 import { todoCommands } from '../../src/commands/biz/todo';
+import { setGlobalFlags } from '../../src/utils/output';
 
 // Mock apiService
 jest.mock('../../src/services/api', () => ({
   apiService: {
     createTodo: jest.fn().mockResolvedValue({ id: 1, title: '测试待办' }),
-    listTodos: jest.fn().mockResolvedValue([{ id: 1, title: '测试待办' }]),
+    listTodos: jest.fn().mockResolvedValue({ data: [{ id: 1, title: '测试待办' }] }),
+    updateTodo: jest.fn().mockResolvedValue({ id: 1, title: '更新后的待办' }),
+    deleteTodo: jest.fn().mockResolvedValue({ success: true }),
+    repeatTodo: jest.fn().mockResolvedValue({ id: 2, title: '下次 occurrence' }),
+    listSubtasks: jest.fn().mockResolvedValue({ data: [] }),
   },
 }));
 
 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 todo commands', () => {
   beforeEach(() => {
     jest.clearAllMocks();
   });
 
   describe('create', () => {
-    it('should call apiService.createTodo', async () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    it('should call apiService.createTodo with title only', async () => {
       await todoCommands.create('测试待办');
-      expect(apiService.createTodo).toHaveBeenCalledWith('测试待办', undefined, undefined);
-      consoleSpy.mockRestore();
+      expect(apiService.createTodo).toHaveBeenCalledWith(
+        '测试待办',
+        undefined, // due
+        undefined, // priority
+        undefined, // tags
+        undefined, // repeat
+        undefined, // endDate
+        undefined  // parentId
+      );
+    });
+
+    it('should call apiService.createTodo with due date', async () => {
+      await todoCommands.create('测试待办', { due: '2026-04-15' });
+      expect(apiService.createTodo).toHaveBeenCalledWith(
+        '测试待办',
+        '2026-04-15',
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createTodo with priority', async () => {
+      await todoCommands.create('测试待办', { priority: 'high' });
+      expect(apiService.createTodo).toHaveBeenCalledWith(
+        '测试待办',
+        undefined,
+        'high',
+        undefined,
+        undefined,
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createTodo with tags', async () => {
+      await todoCommands.create('测试待办', { tags: 'work,important' });
+      expect(apiService.createTodo).toHaveBeenCalledWith(
+        '测试待办',
+        undefined,
+        undefined,
+        'work,important',
+        undefined,
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createTodo with repeat rule', async () => {
+      await todoCommands.create('测试待办', { repeat: 'daily' });
+      expect(apiService.createTodo).toHaveBeenCalledWith(
+        '测试待办',
+        undefined,
+        undefined,
+        undefined,
+        'daily',
+        undefined,
+        undefined
+      );
+    });
+
+    it('should call apiService.createTodo with end date', async () => {
+      await todoCommands.create('测试待办', { endDate: '2026-12-31' });
+      expect(apiService.createTodo).toHaveBeenCalledWith(
+        '测试待办',
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        '2026-12-31',
+        undefined
+      );
+    });
+
+    it('should call apiService.createTodo with all options', async () => {
+      await todoCommands.create('测试待办', {
+        due: '2026-04-15',
+        priority: 'high',
+        tags: 'work,urgent',
+        repeat: 'weekly',
+        endDate: '2026-12-31',
+      });
+      expect(apiService.createTodo).toHaveBeenCalledWith(
+        '测试待办',
+        '2026-04-15',
+        'high',
+        'work,urgent',
+        'weekly',
+        '2026-12-31',
+        undefined
+      );
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.createTodo as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await todoCommands.create('测试待办');
+
+      expect(mockExit).toHaveBeenCalledWith(1);
     });
   });
 
   describe('list', () => {
-    it('should call apiService.listTodos', async () => {
-      const consoleSpy = jest.spyOn(console, 'log').mockImplementation();
+    it('should call apiService.listTodos without filters', async () => {
       await todoCommands.list();
-      expect(apiService.listTodos).toHaveBeenCalledWith(undefined);
-      consoleSpy.mockRestore();
+      expect(apiService.listTodos).toHaveBeenCalledWith(undefined, undefined, undefined);
+    });
+
+    it('should call apiService.listTodos with status filter', async () => {
+      await todoCommands.list({ status: 'pending' });
+      expect(apiService.listTodos).toHaveBeenCalledWith('pending', undefined, undefined);
+    });
+
+    it('should call apiService.listTodos with priority filter', async () => {
+      await todoCommands.list({ priority: 'high' });
+      expect(apiService.listTodos).toHaveBeenCalledWith(undefined, 'high', undefined);
+    });
+
+    it('should call apiService.listTodos with tags filter', async () => {
+      await todoCommands.list({ tags: 'work' });
+      expect(apiService.listTodos).toHaveBeenCalledWith(undefined, undefined, 'work');
+    });
+
+    it('should call apiService.listTodos with all filters', async () => {
+      await todoCommands.list({ status: 'done', priority: 'low', tags: 'home' });
+      expect(apiService.listTodos).toHaveBeenCalledWith('done', 'low', 'home');
+    });
+
+    it('should handle empty results', async () => {
+      (apiService.listTodos as jest.Mock).mockResolvedValueOnce({ data: [] });
+
+      await todoCommands.list();
+
+      expect(apiService.listTodos).toHaveBeenCalled();
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.listTodos as jest.Mock).mockRejectedValueOnce(new Error('Network Error'));
+
+      await todoCommands.list();
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('update', () => {
+    it('should call apiService.updateTodo with id and title', async () => {
+      await todoCommands.update(1, { title: '新标题' });
+      expect(apiService.updateTodo).toHaveBeenCalledWith(1, { title: '新标题' });
+    });
+
+    it('should call apiService.updateTodo with status', async () => {
+      await todoCommands.update(1, { status: 'done' });
+      expect(apiService.updateTodo).toHaveBeenCalledWith(1, { status: 'done' });
+    });
+
+    it('should call apiService.updateTodo with priority', async () => {
+      await todoCommands.update(1, { priority: 'high' });
+      expect(apiService.updateTodo).toHaveBeenCalledWith(1, { priority: 'high' });
+    });
+
+    it('should call apiService.updateTodo with due date', async () => {
+      await todoCommands.update(1, { due: '2026-04-20' });
+      expect(apiService.updateTodo).toHaveBeenCalledWith(1, { dueDate: '2026-04-20' });
+    });
+
+    it('should call apiService.updateTodo with tags', async () => {
+      await todoCommands.update(1, { tags: 'work,urgent' });
+      expect(apiService.updateTodo).toHaveBeenCalledWith(1, { tags: 'work,urgent' });
+    });
+
+    it('should call apiService.updateTodo with multiple updates', async () => {
+      await todoCommands.update(1, {
+        title: '新标题',
+        status: 'done',
+        priority: 'high',
+        due: '2026-04-20',
+        tags: 'work',
+      });
+      expect(apiService.updateTodo).toHaveBeenCalledWith(1, {
+        title: '新标题',
+        status: 'done',
+        priority: 'high',
+        dueDate: '2026-04-20',
+        tags: 'work',
+      });
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.updateTodo as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await todoCommands.update(1, { title: '新标题' });
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('done', () => {
+    it('should call apiService.updateTodo with id and done status', async () => {
+      await todoCommands.done(1);
+      expect(apiService.updateTodo).toHaveBeenCalledWith(1, { status: 'done' });
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.updateTodo as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await todoCommands.done(1);
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('delete', () => {
+    it('should call apiService.deleteTodo with id', async () => {
+      await todoCommands.delete(1);
+      expect(apiService.deleteTodo).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.deleteTodo as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await todoCommands.delete(1);
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('repeat', () => {
+    it('should call apiService.repeatTodo with id', async () => {
+      await todoCommands.repeat(1);
+      expect(apiService.repeatTodo).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.repeatTodo as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await todoCommands.repeat(1);
+
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('subtask', () => {
+    it('should call apiService.createTodo with parentId', async () => {
+      await todoCommands.subtask(1, { title: '子待办标题' });
+      expect(apiService.createTodo).toHaveBeenCalledWith(
+        '子待办标题',
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        undefined,
+        '1'
+      );
+    });
+
+    it('should exit with error when title is missing', async () => {
+      await todoCommands.subtask(1, {});
+      expect(mockExit).toHaveBeenCalledWith(1);
+    });
+  });
+
+  describe('subtasks', () => {
+    it('should call apiService.listSubtasks with parentId', async () => {
+      await todoCommands.subtasks(1);
+      expect(apiService.listSubtasks).toHaveBeenCalledWith(1);
+    });
+
+    it('should handle api errors gracefully', async () => {
+      (apiService.listSubtasks as jest.Mock).mockRejectedValueOnce(new Error('API Error'));
+
+      await todoCommands.subtasks(1);
+
+      expect(mockExit).toHaveBeenCalledWith(1);
     });
   });
 });

package/tests/services/api.test.ts

@@ -1,39 +1,311 @@
 /**
  * API Service Tests with Mock
+ * Comprehensive tests for HTTP mocking, error handling, and request serialization
  */
 
-import { apiService } from '../../src/services/api';
+import axios from 'axios';
 
-// Mock axios
-jest.mock('axios', () => ({
-  create: () => ({
+// Mock axios before importing apiService
+jest.mock('axios', () => {
+  const mockAxiosInstance = {
     interceptors: {
-      request: { use: jest.fn((cb) => cb) },
-      response: { use: jest.fn((successCb, _errorCb) => successCb) },
+      request: {
+        use: jest.fn((cb) => cb),
+      },
+      response: {
+        use: jest.fn((successCb, _errorCb) => successCb),
+      },
     },
-    get: jest.fn().mockResolvedValue({ data: {} }),
-    post: jest.fn().mockResolvedValue({ data: { id: 1 } }),
-    put: jest.fn().mockResolvedValue({ data: {} }),
-    delete: jest.fn().mockResolvedValue({ data: {} }),
-  }),
-}));
+    get: jest.fn(),
+    post: jest.fn(),
+    put: jest.fn(),
+    patch: jest.fn(),
+    delete: jest.fn(),
+  };
+
+  return {
+    create: jest.fn(() => mockAxiosInstance),
+  };
+});
+
+// Import after mocking
+import { apiService } from '../../src/services/api';
 
 describe('ApiService', () => {
+  const mockAxios = axios.create();
+
   beforeEach(() => {
     jest.clearAllMocks();
   });
 
-  describe('createTodo', () => {
-    it('should call POST /api/v1/todos', async () => {
-      const result = await apiService.createTodo('测试待办');
-      expect(result).toBeDefined();
+  describe('Todo API', () => {
+    describe('createTodo', () => {
+      it('should call POST /api/v1/todos with correct payload', async () => {
+        const mockResponse = { data: { id: 1, title: '测试待办' } };
+        (mockAxios.post as jest.Mock).mockResolvedValue(mockResponse);
+
+        const result = await apiService.createTodo('测试待办', '2026-04-15', 'high', 'work,important');
+
+        expect(mockAxios.post).toHaveBeenCalledWith(
+          '/api/v1/todos',
+          expect.objectContaining({
+            title: '测试待办',
+            dueDate: '2026-04-15T00:00:00',
+            priority: 'high',
+            status: 'pending',
+            tags: 'work,important',
+          })
+        );
+        expect(result).toEqual(mockResponse.data);
+      });
+
+      it('should use default priority when not specified', async () => {
+        const mockResponse = { data: { id: 2, title: '测试' } };
+        (mockAxios.post as jest.Mock).mockResolvedValue(mockResponse);
+
+        await apiService.createTodo('测试');
+
+        expect(mockAxios.post).toHaveBeenCalledWith(
+          '/api/v1/todos',
+          expect.objectContaining({
+            priority: 'medium',
+          })
+        );
+      });
+
+      it('should handle datetime format in due date', async () => {
+        const mockResponse = { data: { id: 3 } };
+        (mockAxios.post as jest.Mock).mockResolvedValue(mockResponse);
+
+        await apiService.createTodo('测试', '2026-04-15 14:30');
+
+        expect(mockAxios.post).toHaveBeenCalledWith(
+          '/api/v1/todos',
+          expect.objectContaining({
+            dueDate: '2026-04-15T14:30:00',
+          })
+        );
+      });
+    });
+
+    describe('listTodos', () => {
+      it('should call GET /api/v1/todos without params', async () => {
+        const mockResponse = { data: [] };
+        (mockAxios.get as jest.Mock).mockResolvedValue(mockResponse);
+
+        await apiService.listTodos();
+
+        expect(mockAxios.get).toHaveBeenCalledWith('/api/v1/todos', { params: {} });
+      });
+
+      it('should call GET with query params', async () => {
+        const mockResponse = { data: [] };
+        (mockAxios.get as jest.Mock).mockResolvedValue(mockResponse);
+
+        await apiService.listTodos('pending', 'high', 'work');
+
+        expect(mockAxios.get).toHaveBeenCalledWith('/api/v1/todos', {
+          params: { status: 'pending', priority: 'high', tags: 'work' },
+        });
+      });
+
+      it('should filter out undefined params', async () => {
+        const mockResponse = { data: [] };
+        (mockAxios.get as jest.Mock).mockResolvedValue(mockResponse);
+
+        await apiService.listTodos(undefined, 'high', undefined);
+
+        expect(mockAxios.get).toHaveBeenCalledWith('/api/v1/todos', {
+          params: { priority: 'high' },
+        });
+      });
+    });
+
+    describe('updateTodo', () => {
+      it('should call PATCH /api/v1/todos/:id with updates', async () => {
+        const mockResponse = { data: { id: 1, title: '更新后的标题' } };
+        (mockAxios.patch as jest.Mock).mockResolvedValue(mockResponse);
+
+        const result = await apiService.updateTodo(1, { title: '更新后的标题', status: 'done' });
+
+        expect(mockAxios.patch).toHaveBeenCalledWith('/api/v1/todos/1', {
+          title: '更新后的标题',
+          status: 'done',
+        });
+        expect(result).toEqual(mockResponse.data);
+      });
+    });
+
+    describe('deleteTodo', () => {
+      it('should call DELETE /api/v1/todos/:id', async () => {
+        const mockResponse = { data: { success: true } };
+        (mockAxios.delete as jest.Mock).mockResolvedValue(mockResponse);
+
+        await apiService.deleteTodo(1);
+
+        expect(mockAxios.delete).toHaveBeenCalledWith('/api/v1/todos/1');
+      });
     });
   });
 
-  describe('listTodos', () => {
-    it('should call GET /api/v1/todos', async () => {
-      const result = await apiService.listTodos();
-      expect(result).toBeDefined();
+  describe('Finance API', () => {
+    describe('createFinance', () => {
+      it('should call POST /api/v1/finances with correct payload', async () => {
+        const mockResponse = { data: { id: 1, amount: 100, type: 'expense' } };
+        (mockAxios.post as jest.Mock).mockResolvedValue(mockResponse);
+
+        const result = await apiService.createFinance(100, 'expense', 'food', '午饭');
+
+        expect(mockAxios.post).toHaveBeenCalledWith('/api/v1/finances', {
+          amount: 100,
+          type: 'expense',
+          category: 'food',
+          description: '午饭',
+        });
+        expect(result).toEqual(mockResponse.data);
+      });
+    });
+
+    describe('listFinances', () => {
+      it('should call GET /api/v1/finances with filters', async () => {
+        const mockResponse = { data: [] };
+        (mockAxios.get as jest.Mock).mockResolvedValue(mockResponse);
+
+        await apiService.listFinances('expense', 'food', '2026-04');
+
+        expect(mockAxios.get).toHaveBeenCalledWith('/api/v1/finances', {
+          params: { type: 'expense', category: 'food', month: '2026-04' },
+        });
+      });
+    });
+
+    describe('getFinanceStats', () => {
+      it('should call GET /api/v1/finances/stats with month', async () => {
+        const mockResponse = { data: { totalIncome: 10000, totalExpense: 5000 } };
+        (mockAxios.get as jest.Mock).mockResolvedValue(mockResponse);
+
+        const result = await apiService.getFinanceStats('2026-04');
+
+        expect(mockAxios.get).toHaveBeenCalledWith('/api/v1/finances/stats', {
+          params: { month: '2026-04' },
+        });
+        expect(result).toEqual(mockResponse.data);
+      });
+    });
+  });
+
+  describe('Item API', () => {
+    describe('createItem', () => {
+      it('should call POST /api/v1/items with correct payload', async () => {
+        const mockResponse = { data: { id: 1, name: '测试物品' } };
+        (mockAxios.post as jest.Mock).mockResolvedValue(mockResponse);
+
+        await apiService.createItem('测试物品', 'electronics', '客厅', '2026-12-31');
+
+        expect(mockAxios.post).toHaveBeenCalledWith('/api/v1/items', {
+          name: '测试物品',
+          category: 'electronics',
+          location: '客厅',
+          expireDate: '2026-12-31T00:00:00',
+        });
+      });
+    });
+
+    describe('listItems', () => {
+      it('should call GET /api/v1/items with category filter', async () => {
+        const mockResponse = { data: [] };
+        (mockAxios.get as jest.Mock).mockResolvedValue(mockResponse);
+
+        await apiService.listItems('electronics');
+
+        expect(mockAxios.get).toHaveBeenCalledWith('/api/v1/items', {
+          params: { category: 'electronics' },
+        });
+      });
+    });
+  });
+
+  describe('Error Handling', () => {
+    it('should handle network errors', async () => {
+      const error = new Error('Network Error');
+      (mockAxios.get as jest.Mock).mockRejectedValue(error);
+
+      await expect(apiService.listTodos()).rejects.toThrow('Network Error');
+    });
+
+    it('should handle HTTP 500 errors', async () => {
+      const error = {
+        response: {
+          status: 500,
+          data: { message: 'Internal Server Error' },
+        },
+      };
+      (mockAxios.get as jest.Mock).mockRejectedValue(error);
+
+      await expect(apiService.listTodos()).rejects.toEqual(error);
+    });
+
+    it('should handle HTTP 404 errors', async () => {
+      const error = {
+        response: {
+          status: 404,
+          data: { message: 'Not Found' },
+        },
+      };
+      (mockAxios.get as jest.Mock).mockRejectedValue(error);
+
+      await expect(apiService.listTodos()).rejects.toEqual(error);
+    });
+
+    it('should handle timeout errors', async () => {
+      const error = new Error('timeout');
+      (mockAxios.get as jest.Mock).mockRejectedValue(error);
+
+      await expect(apiService.listTodos()).rejects.toThrow('timeout');
+    });
+  });
+
+  describe('Date Formatting', () => {
+    it('should convert YYYY-MM-DD to LocalDateTime format', async () => {
+      const mockResponse = { data: { id: 1 } };
+      (mockAxios.post as jest.Mock).mockResolvedValue(mockResponse);
+
+      await apiService.createTodo('test', '2026-04-15');
+
+      expect(mockAxios.post).toHaveBeenCalledWith(
+        '/api/v1/todos',
+        expect.objectContaining({
+          dueDate: '2026-04-15T00:00:00',
+        })
+      );
+    });
+
+    it('should convert YYYY-MM-DD HH:MM to LocalDateTime format', async () => {
+      const mockResponse = { data: { id: 1 } };
+      (mockAxios.post as jest.Mock).mockResolvedValue(mockResponse);
+
+      await apiService.createTodo('test', '2026-04-15 14:30');
+
+      expect(mockAxios.post).toHaveBeenCalledWith(
+        '/api/v1/todos',
+        expect.objectContaining({
+          dueDate: '2026-04-15T14:30:00',
+        })
+      );
+    });
+
+    it('should pass through ISO format dates', async () => {
+      const mockResponse = { data: { id: 1 } };
+      (mockAxios.post as jest.Mock).mockResolvedValue(mockResponse);
+
+      await apiService.createTodo('test', '2026-04-15T14:30:00');
+
+      expect(mockAxios.post).toHaveBeenCalledWith(
+        '/api/v1/todos',
+        expect.objectContaining({
+          dueDate: '2026-04-15T14:30:00',
+        })
+      );
     });
   });
 });