shawnxixi-cli 0.3.0 → 1.1.0

package/tests/utils/finance.model.test.ts

@@ -0,0 +1,319 @@
+/**
+ * Finance Model Tests
+ * 测试收支分类、账户余额计算、金额格式化
+ */
+
+import {
+  categorizeFinance,
+  getDefaultCategory,
+  isValidCategory,
+  calculateBalance,
+  calculateFinanceStats,
+  formatAmount,
+  parseAmount,
+  isValidAmount,
+  calculateDailyAverage,
+  calculateBudgetRemaining,
+  FinanceItem,
+  FinanceStats,
+} from '../../src/utils/finance.model';
+
+describe('Finance Model - Categorization', () => {
+  describe('categorizeFinance', () => {
+    it('should return type if explicitly specified as income', () => {
+      expect(categorizeFinance(100, 'income')).toBe('income');
+    });
+
+    it('should return type if explicitly specified as expense', () => {
+      expect(categorizeFinance(100, 'expense')).toBe('expense');
+    });
+
+    it('should return income for positive amount with no type', () => {
+      expect(categorizeFinance(100)).toBe('income');
+    });
+
+    it('should return expense for negative amount with no type', () => {
+      expect(categorizeFinance(-50)).toBe('expense');
+    });
+
+    it('should treat zero as income by default', () => {
+      expect(categorizeFinance(0)).toBe('income');
+    });
+  });
+
+  describe('getDefaultCategory', () => {
+    it('should return other_income for income type', () => {
+      expect(getDefaultCategory('income')).toBe('other_income');
+    });
+
+    it('should return other for expense type', () => {
+      expect(getDefaultCategory('expense')).toBe('other');
+    });
+  });
+
+  describe('isValidCategory', () => {
+    it('should validate income categories', () => {
+      expect(isValidCategory('income', 'salary')).toBe(true);
+      expect(isValidCategory('income', 'bonus')).toBe(true);
+      expect(isValidCategory('income', 'investment')).toBe(true);
+    });
+
+    it('should validate expense categories', () => {
+      expect(isValidCategory('expense', 'food')).toBe(true);
+      expect(isValidCategory('expense', 'transport')).toBe(true);
+      expect(isValidCategory('expense', 'shopping')).toBe(true);
+    });
+
+    it('should reject invalid categories', () => {
+      expect(isValidCategory('income', 'food')).toBe(false);
+      expect(isValidCategory('expense', 'salary')).toBe(false);
+      expect(isValidCategory('expense', 'invalid')).toBe(false);
+    });
+  });
+});
+
+describe('Finance Model - Balance Calculation', () => {
+  const createItem = (
+    amount: number,
+    type: 'income' | 'expense',
+    category: string = 'other'
+  ): FinanceItem => ({
+    id: Math.random().toString(),
+    amount: Math.abs(amount),
+    type,
+    category,
+    createdAt: new Date().toISOString(),
+  });
+
+  it('should calculate zero balance for empty array', () => {
+    expect(calculateBalance([])).toBe(0);
+  });
+
+  it('should calculate positive balance for income only', () => {
+    const items = [
+      createItem(100, 'income'),
+      createItem(200, 'income'),
+    ];
+    expect(calculateBalance(items)).toBe(300);
+  });
+
+  it('should calculate negative balance for expense only', () => {
+    const items = [
+      createItem(50, 'expense'),
+      createItem(30, 'expense'),
+    ];
+    expect(calculateBalance(items)).toBe(-80);
+  });
+
+  it('should calculate net balance correctly', () => {
+    const items = [
+      createItem(1000, 'income', 'salary'),
+      createItem(500, 'expense', 'food'),
+      createItem(200, 'expense', 'transport'),
+    ];
+    expect(calculateBalance(items)).toBe(300);
+  });
+
+  it('should handle mixed income and expense', () => {
+    const items = [
+      createItem(10000, 'income', 'salary'),
+      createItem(3000, 'expense', 'housing'),
+      createItem(1500, 'expense', 'food'),
+      createItem(2000, 'expense', 'shopping'),
+      createItem(500, 'income', 'bonus'),
+    ];
+    expect(calculateBalance(items)).toBe(4000);
+  });
+});
+
+describe('Finance Model - Finance Stats', () => {
+  const createItem = (
+    amount: number,
+    type: 'income' | 'expense',
+    category: string
+  ): FinanceItem => ({
+    id: Math.random().toString(),
+    amount: Math.abs(amount),
+    type,
+    category,
+    createdAt: new Date().toISOString(),
+  });
+
+  it('should calculate correct totals', () => {
+    const items = [
+      createItem(1000, 'income', 'salary'),
+      createItem(200, 'income', 'bonus'),
+      createItem(300, 'expense', 'food'),
+      createItem(100, 'expense', 'transport'),
+    ];
+
+    const stats = calculateFinanceStats(items);
+    expect(stats.totalIncome).toBe(1200);
+    expect(stats.totalExpense).toBe(400);
+    expect(stats.netBalance).toBe(800);
+  });
+
+  it('should aggregate by category', () => {
+    const items = [
+      createItem(1000, 'income', 'salary'),
+      createItem(300, 'expense', 'food'),
+      createItem(200, 'expense', 'food'),
+      createItem(150, 'expense', 'transport'),
+    ];
+
+    const stats = calculateFinanceStats(items);
+    expect(stats.byCategory['salary'].income).toBe(1000);
+    expect(stats.byCategory['salary'].expense).toBe(0);
+    expect(stats.byCategory['food'].expense).toBe(500);
+    expect(stats.byCategory['transport'].expense).toBe(150);
+  });
+
+  it('should handle empty items array', () => {
+    const stats = calculateFinanceStats([]);
+    expect(stats.totalIncome).toBe(0);
+    expect(stats.totalExpense).toBe(0);
+    expect(stats.netBalance).toBe(0);
+    expect(Object.keys(stats.byCategory).length).toBe(0);
+  });
+
+  it('should handle income-only items', () => {
+    const items = [
+      createItem(1000, 'income', 'salary'),
+      createItem(500, 'income', 'investment'),
+    ];
+
+    const stats = calculateFinanceStats(items);
+    expect(stats.totalIncome).toBe(1500);
+    expect(stats.totalExpense).toBe(0);
+    expect(stats.netBalance).toBe(1500);
+  });
+
+  it('should handle expense-only items', () => {
+    const items = [
+      createItem(300, 'expense', 'food'),
+      createItem(200, 'expense', 'transport'),
+    ];
+
+    const stats = calculateFinanceStats(items);
+    expect(stats.totalIncome).toBe(0);
+    expect(stats.totalExpense).toBe(500);
+    expect(stats.netBalance).toBe(-500);
+  });
+});
+
+describe('Finance Model - Amount Formatting', () => {
+  describe('formatAmount', () => {
+    it('should format positive amount with currency', () => {
+      expect(formatAmount(100)).toBe('¥100.00');
+    });
+
+    it('should format negative amount with currency', () => {
+      expect(formatAmount(-50)).toBe('¥50.00');
+    });
+
+    it('should format with thousand separators', () => {
+      expect(formatAmount(1234567.89)).toBe('¥1,234,567.89');
+    });
+
+    it('should format with sign when showSign is true', () => {
+      expect(formatAmount(100, '¥', true)).toBe('+¥100.00');
+      expect(formatAmount(-100, '¥', true)).toBe('-¥100.00');
+    });
+
+    it('should handle different currencies', () => {
+      expect(formatAmount(100, '$')).toBe('$100.00');
+      expect(formatAmount(100, '€')).toBe('€100.00');
+    });
+
+    it('should handle decimal places', () => {
+      expect(formatAmount(100.1)).toBe('¥100.10');
+      expect(formatAmount(100.159)).toBe('¥100.16');
+    });
+  });
+
+  describe('parseAmount', () => {
+    it('should parse simple amount', () => {
+      expect(parseAmount('100')).toBe(100);
+    });
+
+    it('should parse amount with currency symbol', () => {
+      expect(parseAmount('¥100')).toBe(100);
+      expect(parseAmount('$50')).toBe(50);
+    });
+
+    it('should parse amount with thousand separators', () => {
+      expect(parseAmount('1,234,567')).toBe(1234567);
+    });
+
+    it('should parse amount with currency and separators', () => {
+      expect(parseAmount('¥1,234.56')).toBe(1234.56);
+    });
+
+    it('should return 0 for invalid input', () => {
+      expect(parseAmount('invalid')).toBe(0);
+      expect(parseAmount('')).toBe(0);
+    });
+
+    it('should handle negative amounts', () => {
+      expect(parseAmount('-¥100')).toBe(-100);
+    });
+  });
+
+  describe('isValidAmount', () => {
+    it('should return true for valid positive amounts', () => {
+      expect(isValidAmount(100)).toBe(true);
+      expect(isValidAmount(0.01)).toBe(true);
+    });
+
+    it('should return true for valid negative amounts', () => {
+      expect(isValidAmount(-100)).toBe(true);
+    });
+
+    it('should return false for zero', () => {
+      expect(isValidAmount(0)).toBe(false);
+    });
+
+    it('should return false for NaN', () => {
+      expect(isValidAmount(NaN)).toBe(false);
+    });
+
+    it('should return false for Infinity', () => {
+      expect(isValidAmount(Infinity)).toBe(false);
+      expect(isValidAmount(-Infinity)).toBe(false);
+    });
+  });
+});
+
+describe('Finance Model - Calculations', () => {
+  describe('calculateDailyAverage', () => {
+    it('should calculate daily average correctly', () => {
+      expect(calculateDailyAverage(3000, 30)).toBe(100);
+    });
+
+    it('should return 0 for 0 days', () => {
+      expect(calculateDailyAverage(3000, 0)).toBe(0);
+    });
+
+    it('should return 0 for negative days', () => {
+      expect(calculateDailyAverage(3000, -5)).toBe(0);
+    });
+
+    it('should handle decimal result', () => {
+      expect(calculateDailyAverage(1000, 3)).toBeCloseTo(333.33, 1);
+    });
+  });
+
+  describe('calculateBudgetRemaining', () => {
+    it('should calculate remaining budget correctly', () => {
+      expect(calculateBudgetRemaining(5000, 3000)).toBe(2000);
+    });
+
+    it('should handle overspent budget', () => {
+      expect(calculateBudgetRemaining(3000, 5000)).toBe(-2000);
+    });
+
+    it('should handle exact budget match', () => {
+      expect(calculateBudgetRemaining(3000, 3000)).toBe(0);
+    });
+  });
+});

package/tests/utils/todo.model.test.ts

@@ -0,0 +1,315 @@
+/**
+ * Todo Model Tests
+ * 测试重复规则计算、序列化、标签解析、时长格式化
+ */
+
+import {
+  parseRepeatRule,
+  calculateNextOccurrence,
+  parseTags,
+  formatDuration,
+  parseDuration,
+  serializeTodo,
+  deserializeTodo,
+  RepeatRule,
+} from '../../src/utils/todo.model';
+
+describe('Todo Model - Repeat Rule', () => {
+  describe('parseRepeatRule', () => {
+    it('should parse "none" as no repeat', () => {
+      const rule = parseRepeatRule('none');
+      expect(rule.type).toBe('none');
+      expect(rule.interval).toBe(1);
+    });
+
+    it('should parse undefined as no repeat', () => {
+      const rule = parseRepeatRule(undefined as any);
+      expect(rule.type).toBe('none');
+      expect(rule.interval).toBe(1);
+    });
+
+    it('should parse empty string as no repeat', () => {
+      const rule = parseRepeatRule('');
+      expect(rule.type).toBe('none');
+      expect(rule.interval).toBe(1);
+    });
+
+    it('should parse "daily" as daily repeat', () => {
+      const rule = parseRepeatRule('daily');
+      expect(rule.type).toBe('daily');
+      expect(rule.interval).toBe(1);
+    });
+
+    it('should parse "weekly" as weekly repeat', () => {
+      const rule = parseRepeatRule('weekly');
+      expect(rule.type).toBe('weekly');
+      expect(rule.interval).toBe(1);
+    });
+
+    it('should parse "monthly" as monthly repeat', () => {
+      const rule = parseRepeatRule('monthly');
+      expect(rule.type).toBe('monthly');
+      expect(rule.interval).toBe(1);
+    });
+
+    it('should parse "2d" as daily repeat every 2 days', () => {
+      const rule = parseRepeatRule('2d');
+      expect(rule.type).toBe('daily');
+      expect(rule.interval).toBe(2);
+    });
+
+    it('should parse "3w" as weekly repeat every 3 weeks', () => {
+      const rule = parseRepeatRule('3w');
+      expect(rule.type).toBe('weekly');
+      expect(rule.interval).toBe(3);
+    });
+
+    it('should parse "1m" as monthly repeat every 1 month', () => {
+      const rule = parseRepeatRule('1m');
+      expect(rule.type).toBe('monthly');
+      expect(rule.interval).toBe(1);
+    });
+
+    it('should parse case-insensitive repeat rules', () => {
+      const rule1 = parseRepeatRule('DAILY');
+      expect(rule1.type).toBe('daily');
+
+      const rule2 = parseRepeatRule('2D');
+      expect(rule2.type).toBe('daily');
+      expect(rule2.interval).toBe(2);
+    });
+
+    it('should return none for unknown patterns', () => {
+      const rule = parseRepeatRule('yearly');
+      expect(rule.type).toBe('none');
+    });
+  });
+
+  describe('calculateNextOccurrence', () => {
+    it('should return null for no repeat rule', () => {
+      const rule: RepeatRule = { type: 'none', interval: 1 };
+      const next = calculateNextOccurrence(new Date('2026-04-12'), rule);
+      expect(next).toBeNull();
+    });
+
+    it('should calculate daily next occurrence', () => {
+      const rule: RepeatRule = { type: 'daily', interval: 1 };
+      const current = new Date('2026-04-12');
+      const next = calculateNextOccurrence(current, rule);
+      expect(next).not.toBeNull();
+      expect(next!.getDate()).toBe(13);
+    });
+
+    it('should calculate daily next occurrence with interval', () => {
+      const rule: RepeatRule = { type: 'daily', interval: 3 };
+      const current = new Date('2026-04-12');
+      const next = calculateNextOccurrence(current, rule);
+      expect(next).not.toBeNull();
+      expect(next!.getDate()).toBe(15);
+    });
+
+    it('should calculate weekly next occurrence', () => {
+      const rule: RepeatRule = { type: 'weekly', interval: 1 };
+      const current = new Date('2026-04-12');
+      const next = calculateNextOccurrence(current, rule);
+      expect(next).not.toBeNull();
+      expect(next!.getDate()).toBe(19); // 12 + 7 = 19
+    });
+
+    it('should calculate bi-weekly occurrence', () => {
+      const rule: RepeatRule = { type: 'weekly', interval: 2 };
+      const current = new Date('2026-04-12');
+      const next = calculateNextOccurrence(current, rule);
+      expect(next).not.toBeNull();
+      expect(next!.getDate()).toBe(26); // 12 + 14 = 26
+    });
+
+    it('should calculate monthly next occurrence', () => {
+      const rule: RepeatRule = { type: 'monthly', interval: 1 };
+      const current = new Date('2026-04-12');
+      const next = calculateNextOccurrence(current, rule);
+      expect(next).not.toBeNull();
+      expect(next!.getMonth()).toBe(4); // May (0-indexed)
+      expect(next!.getDate()).toBe(12);
+    });
+
+    it('should calculate bimonthly occurrence', () => {
+      const rule: RepeatRule = { type: 'monthly', interval: 2 };
+      const current = new Date('2026-04-12');
+      const next = calculateNextOccurrence(current, rule);
+      expect(next).not.toBeNull();
+      expect(next!.getMonth()).toBe(5); // June
+    });
+
+    it('should return null if next occurrence exceeds end date', () => {
+      const rule: RepeatRule = {
+        type: 'daily',
+        interval: 1,
+        endDate: '2026-04-13',
+      };
+      const current = new Date('2026-04-14');
+      const next = calculateNextOccurrence(current, rule);
+      expect(next).toBeNull();
+    });
+
+    it('should return next occurrence if within end date', () => {
+      const rule: RepeatRule = {
+        type: 'daily',
+        interval: 1,
+        endDate: '2026-04-15',
+      };
+      const current = new Date('2026-04-12');
+      const next = calculateNextOccurrence(current, rule);
+      expect(next).not.toBeNull();
+      expect(next!.getDate()).toBe(13);
+    });
+  });
+});
+
+describe('Todo Model - Tags Parsing', () => {
+  it('should parse comma-separated tags', () => {
+    const tags = parseTags('work,important,urgent');
+    expect(tags).toEqual(['work', 'important', 'urgent']);
+  });
+
+  it('should trim whitespace from tags', () => {
+    const tags = parseTags(' work , important , urgent ');
+    expect(tags).toEqual(['work', 'important', 'urgent']);
+  });
+
+  it('should filter out empty tags', () => {
+    const tags = parseTags('work,,important,,');
+    expect(tags).toEqual(['work', 'important']);
+  });
+
+  it('should return empty array for undefined', () => {
+    const tags = parseTags(undefined);
+    expect(tags).toEqual([]);
+  });
+
+  it('should return empty array for empty string', () => {
+    const tags = parseTags('');
+    expect(tags).toEqual([]);
+  });
+
+  it('should return empty array for whitespace-only string', () => {
+    const tags = parseTags('   ');
+    expect(tags).toEqual([]);
+  });
+
+  it('should handle single tag', () => {
+    const tags = parseTags('work');
+    expect(tags).toEqual(['work']);
+  });
+
+  it('should handle tags with spaces', () => {
+    const tags = parseTags('home office, weekend project');
+    expect(tags).toEqual(['home office', 'weekend project']);
+  });
+});
+
+describe('Todo Model - Duration Formatting', () => {
+  describe('formatDuration', () => {
+    it('should format 0 seconds as 0m', () => {
+      expect(formatDuration(0)).toBe('0m');
+    });
+
+    it('should format negative seconds as 0m', () => {
+      expect(formatDuration(-100)).toBe('0m');
+    });
+
+    it('should format minutes only', () => {
+      expect(formatDuration(45 * 60)).toBe('45m');
+    });
+
+    it('should format hours only', () => {
+      expect(formatDuration(2 * 3600)).toBe('2h');
+    });
+
+    it('should format hours and minutes', () => {
+      expect(formatDuration(1.5 * 3600)).toBe('1h30m');
+    });
+
+    it('should format 90 minutes correctly', () => {
+      expect(formatDuration(90 * 60)).toBe('1h30m');
+    });
+
+    it('should handle large durations', () => {
+      expect(formatDuration(8 * 3600 + 15 * 60)).toBe('8h15m');
+    });
+  });
+
+  describe('parseDuration', () => {
+    it('should parse hours and minutes', () => {
+      expect(parseDuration('1h30m')).toBe(1 * 3600 + 30 * 60);
+    });
+
+    it('should parse hours only', () => {
+      expect(parseDuration('2h')).toBe(2 * 3600);
+    });
+
+    it('should parse minutes only', () => {
+      expect(parseDuration('45m')).toBe(45 * 60);
+    });
+
+    it('should return 0 for invalid format', () => {
+      expect(parseDuration('invalid')).toBe(0);
+    });
+
+    it('should handle 0', () => {
+      expect(parseDuration('0h')).toBe(0);
+    });
+  });
+});
+
+describe('Todo Model - Serialization', () => {
+  const sampleTodo = {
+    id: '1',
+    title: '测试待办',
+    completed: false,
+    priority: 'high' as const,
+    dueDate: '2026-04-15',
+    tags: ['work', 'important'],
+    repeatRule: { type: 'daily' as const, interval: 1 },
+    estimatedDuration: 3600,
+    createdAt: '2026-04-12T10:00:00',
+  };
+
+  it('should serialize todo to JSON', () => {
+    const json = serializeTodo(sampleTodo);
+    expect(typeof json).toBe('string');
+    expect(json).toContain('"id":"1"');
+    expect(json).toContain('"title":"测试待办"');
+  });
+
+  it('should deserialize JSON to todo', () => {
+    const json = JSON.stringify(sampleTodo);
+    const todo = deserializeTodo(json);
+    expect(todo).not.toBeNull();
+    expect(todo!.id).toBe('1');
+    expect(todo!.title).toBe('测试待办');
+    expect(todo!.priority).toBe('high');
+    expect(todo!.tags).toEqual(['work', 'important']);
+  });
+
+  it('should return null for invalid JSON', () => {
+    const todo = deserializeTodo('invalid json');
+    expect(todo).toBeNull();
+  });
+
+  it('should handle todo with optional fields', () => {
+    const minimalTodo = {
+      id: '2',
+      title: '简单待办',
+      completed: false,
+      priority: 'low' as const,
+      createdAt: '2026-04-12',
+    };
+
+    const json = serializeTodo(minimalTodo);
+    const parsed = deserializeTodo(json);
+    expect(parsed).not.toBeNull();
+    expect(parsed!.dueDate).toBeUndefined();
+    expect(parsed!.tags).toBeUndefined();
+  });
+});