@tuturuuu/utils 0.0.2 → 0.6.0

package/src/__tests__/interest-calculator.test.ts

@@ -0,0 +1,336 @@
+import type { WalletInterestRate } from '@tuturuuu/types';
+import { describe, expect, it } from 'vitest';
+
+import {
+  calculateDailyInterest,
+  calculateInterest,
+  formatDateString,
+  getDaysUntilInterestStarts,
+  getInterestStartDate,
+  getMonthToDateRange,
+  getNextBusinessDay,
+  getRateForDate,
+  getYearToDateRange,
+  isBusinessDay,
+  isHoliday,
+  isWeekend,
+  parseDateString,
+  projectInterest,
+} from '../finance/interest-calculator';
+
+describe('interest-calculator', () => {
+  describe('isWeekend', () => {
+    it('should return true for Saturday', () => {
+      // 2025-01-25 is a Saturday
+      const saturday = new Date(2025, 0, 25);
+      expect(isWeekend(saturday)).toBe(true);
+    });
+
+    it('should return true for Sunday', () => {
+      // 2025-01-26 is a Sunday
+      const sunday = new Date(2025, 0, 26);
+      expect(isWeekend(sunday)).toBe(true);
+    });
+
+    it('should return false for weekdays', () => {
+      // 2025-01-27 is a Monday
+      const monday = new Date(2025, 0, 27);
+      expect(isWeekend(monday)).toBe(false);
+
+      // 2025-01-29 is a Wednesday
+      const wednesday = new Date(2025, 0, 29);
+      expect(isWeekend(wednesday)).toBe(false);
+    });
+  });
+
+  describe('isHoliday', () => {
+    const holidays = new Set(['2025-01-01', '2025-01-28']);
+
+    it('should return true for holidays', () => {
+      const newYear = new Date(2025, 0, 1);
+      expect(isHoliday(newYear, holidays)).toBe(true);
+    });
+
+    it('should return false for non-holidays', () => {
+      const normalDay = new Date(2025, 0, 15);
+      expect(isHoliday(normalDay, holidays)).toBe(false);
+    });
+  });
+
+  describe('isBusinessDay', () => {
+    const holidays = new Set(['2025-01-01']);
+
+    it('should return false for weekends', () => {
+      const saturday = new Date(2025, 0, 25);
+      expect(isBusinessDay(saturday, holidays)).toBe(false);
+    });
+
+    it('should return false for holidays', () => {
+      const holiday = new Date(2025, 0, 1);
+      expect(isBusinessDay(holiday, holidays)).toBe(false);
+    });
+
+    it('should return true for normal weekdays', () => {
+      const monday = new Date(2025, 0, 6);
+      expect(isBusinessDay(monday, holidays)).toBe(true);
+    });
+  });
+
+  describe('getNextBusinessDay', () => {
+    const holidays = new Set(['2025-01-01']);
+
+    it('should return next day if it is a business day', () => {
+      // Wednesday -> Thursday
+      const wednesday = new Date(2025, 0, 8);
+      const result = getNextBusinessDay(wednesday, holidays);
+      expect(formatDateString(result)).toBe('2025-01-09');
+    });
+
+    it('should skip weekends', () => {
+      // Friday -> Monday
+      const friday = new Date(2025, 0, 24);
+      const result = getNextBusinessDay(friday, holidays);
+      expect(formatDateString(result)).toBe('2025-01-27');
+    });
+
+    it('should skip holidays', () => {
+      // Dec 31, 2024 -> Jan 2, 2025 (skipping Jan 1 holiday)
+      const dec31 = new Date(2024, 11, 31);
+      const result = getNextBusinessDay(dec31, holidays);
+      expect(formatDateString(result)).toBe('2025-01-02');
+    });
+  });
+
+  describe('getInterestStartDate', () => {
+    const holidays = new Set<string>();
+
+    it('should start interest next business day for Monday deposit', () => {
+      const monday = new Date(2025, 0, 27);
+      const result = getInterestStartDate(monday, holidays);
+      expect(formatDateString(result)).toBe('2025-01-28');
+    });
+
+    it('should start interest on Monday for Friday deposit', () => {
+      const friday = new Date(2025, 0, 24);
+      const result = getInterestStartDate(friday, holidays);
+      expect(formatDateString(result)).toBe('2025-01-27');
+    });
+
+    it('should start interest on Tuesday for Saturday deposit', () => {
+      const saturday = new Date(2025, 0, 25);
+      const result = getInterestStartDate(saturday, holidays);
+      expect(formatDateString(result)).toBe('2025-01-27');
+    });
+  });
+
+  describe('getDaysUntilInterestStarts', () => {
+    const holidays = new Set<string>();
+
+    it('should return 0 if interest already started', () => {
+      const pastDeposit = new Date(2025, 0, 20);
+      const today = new Date(2025, 0, 27);
+      const result = getDaysUntilInterestStarts(pastDeposit, holidays, today);
+      expect(result).toBe(0);
+    });
+
+    it('should return positive days for future start', () => {
+      // Deposited today (Monday), interest starts tomorrow (Tuesday)
+      const today = new Date(2025, 0, 27);
+      const result = getDaysUntilInterestStarts(today, holidays, today);
+      expect(result).toBe(1);
+    });
+  });
+
+  describe('getRateForDate', () => {
+    const rates: WalletInterestRate[] = [
+      {
+        id: '1',
+        config_id: 'cfg1',
+        annual_rate: 4.0,
+        effective_from: '2025-01-01',
+        effective_to: '2025-06-30',
+        created_at: '2025-01-01T00:00:00Z',
+      },
+      {
+        id: '2',
+        config_id: 'cfg1',
+        annual_rate: 4.5,
+        effective_from: '2025-07-01',
+        effective_to: null,
+        created_at: '2025-07-01T00:00:00Z',
+      },
+    ];
+
+    it('should return correct rate for date within range', () => {
+      const date = new Date(2025, 2, 15); // March 15
+      expect(getRateForDate(date, rates)).toBe(4.0);
+    });
+
+    it('should return correct rate for date in open-ended range', () => {
+      const date = new Date(2025, 8, 15); // September 15
+      expect(getRateForDate(date, rates)).toBe(4.5);
+    });
+
+    it('should return null for date before any rate', () => {
+      const date = new Date(2024, 11, 15); // December 2024
+      expect(getRateForDate(date, rates)).toBe(null);
+    });
+  });
+
+  describe('calculateDailyInterest', () => {
+    it('should calculate correct daily interest using Momo formula', () => {
+      // Balance: 10,000,000 VND, Rate: 4%
+      // Daily = floor(10,000,000 × (0.04 / 365)) = floor(1095.89) = 1095
+      const balance = 10_000_000;
+      const rate = 4.0;
+      expect(calculateDailyInterest(balance, rate)).toBe(1095);
+    });
+
+    it('should return 0 for zero balance', () => {
+      expect(calculateDailyInterest(0, 4.0)).toBe(0);
+    });
+
+    it('should return 0 for negative balance', () => {
+      expect(calculateDailyInterest(-1000, 4.0)).toBe(0);
+    });
+
+    it('should floor the result', () => {
+      // Check that we're flooring, not rounding
+      const balance = 1_000_000;
+      const rate = 4.0;
+      // Daily = floor(1,000,000 × (0.04 / 365)) = floor(109.589) = 109
+      expect(calculateDailyInterest(balance, rate)).toBe(109);
+    });
+  });
+
+  describe('calculateInterest', () => {
+    const rates: WalletInterestRate[] = [
+      {
+        id: '1',
+        config_id: 'cfg1',
+        annual_rate: 4.0,
+        effective_from: '2025-01-01',
+        effective_to: null,
+        created_at: '2025-01-01T00:00:00Z',
+      },
+    ];
+
+    it('should calculate interest over a date range', () => {
+      const result = calculateInterest({
+        transactions: [],
+        rates,
+        holidays: [],
+        fromDate: '2025-01-06', // Monday
+        toDate: '2025-01-10', // Friday
+        initialBalance: 10_000_000,
+      });
+
+      // 5 business days
+      expect(result.businessDaysCount).toBe(5);
+      expect(result.totalInterest).toBeGreaterThan(0);
+    });
+
+    it('should handle weekend correctly', () => {
+      const result = calculateInterest({
+        transactions: [],
+        rates,
+        holidays: [],
+        fromDate: '2025-01-25', // Saturday
+        toDate: '2025-01-26', // Sunday
+        initialBalance: 10_000_000,
+      });
+
+      expect(result.businessDaysCount).toBe(0);
+      expect(result.totalInterest).toBe(0);
+    });
+
+    it('should compound interest', () => {
+      const result = calculateInterest({
+        transactions: [],
+        rates,
+        holidays: [],
+        fromDate: '2025-01-06',
+        toDate: '2025-01-10',
+        initialBalance: 10_000_000,
+      });
+
+      // Interest should compound - final balance > initial + (daily × days)
+      const nonCompoundedInterest = calculateDailyInterest(10_000_000, 4.0) * 5;
+      expect(result.totalInterest).toBeGreaterThanOrEqual(
+        nonCompoundedInterest
+      );
+    });
+  });
+
+  describe('projectInterest', () => {
+    it('should project future interest', () => {
+      const projections = projectInterest({
+        currentBalance: 10_000_000,
+        currentRate: 4.0,
+        holidays: [],
+        days: 7,
+        startDate: '2025-01-06', // Monday
+      });
+
+      expect(projections).toHaveLength(7);
+      expect(projections[0]?.projectedBalance).toBeGreaterThanOrEqual(
+        10_000_000
+      );
+    });
+
+    it('should skip weekends in projections', () => {
+      const projections = projectInterest({
+        currentBalance: 10_000_000,
+        currentRate: 4.0,
+        holidays: [],
+        days: 7,
+        startDate: '2025-01-25', // Saturday
+      });
+
+      // First two days (Sat, Sun) should have 0 interest
+      expect(projections[0]?.projectedDailyInterest).toBe(0);
+      expect(projections[1]?.projectedDailyInterest).toBe(0);
+      // Monday should have interest
+      expect(projections[2]?.projectedDailyInterest).toBeGreaterThan(0);
+    });
+  });
+
+  describe('date range helpers', () => {
+    it('should get month-to-date range correctly', () => {
+      const today = new Date(2025, 0, 15); // January 15, 2025
+      const range = getMonthToDateRange(today);
+
+      expect(range.fromDate).toBe('2025-01-01');
+      expect(range.toDate).toBe('2025-01-15');
+    });
+
+    it('should get year-to-date range correctly', () => {
+      const today = new Date(2025, 5, 15); // June 15, 2025
+      const range = getYearToDateRange(today);
+
+      expect(range.fromDate).toBe('2025-01-01');
+      expect(range.toDate).toBe('2025-06-15');
+    });
+  });
+
+  describe('formatDateString and parseDateString', () => {
+    it('should format date correctly', () => {
+      const date = new Date(2025, 0, 15);
+      expect(formatDateString(date)).toBe('2025-01-15');
+    });
+
+    it('should parse date string correctly', () => {
+      const result = parseDateString('2025-01-15');
+      expect(result.getFullYear()).toBe(2025);
+      expect(result.getMonth()).toBe(0);
+      expect(result.getDate()).toBe(15);
+    });
+
+    it('should roundtrip correctly', () => {
+      const original = new Date(2025, 11, 31);
+      const str = formatDateString(original);
+      const parsed = parseDateString(str);
+      expect(formatDateString(parsed)).toBe(str);
+    });
+  });
+});

package/src/__tests__/interest-detector.test.ts

@@ -0,0 +1,222 @@
+import { describe, expect, it } from 'vitest';
+
+import {
+  detectInterestTransaction,
+  detectInterestTransactions,
+  summarizeDetectionResults,
+  type TransactionForDetection,
+} from '../finance/interest-detector';
+
+describe('interest-detector', () => {
+  describe('detectInterestTransaction', () => {
+    it('should detect transaction with Vietnamese interest keyword in description', () => {
+      const tx: TransactionForDetection = {
+        id: '1',
+        amount: 1000,
+        description: 'Tiền lãi hàng ngày',
+        date: '2025-01-15',
+      };
+
+      const result = detectInterestTransaction(tx);
+      expect(result).not.toBeNull();
+      expect(result?.confidence).toBe('high');
+      expect(result?.matchReason).toContain(
+        'Description matches interest pattern'
+      );
+    });
+
+    it('should detect transaction with English interest keyword', () => {
+      const tx: TransactionForDetection = {
+        id: '1',
+        amount: 1000,
+        description: 'Daily interest payment',
+        date: '2025-01-15',
+      };
+
+      const result = detectInterestTransaction(tx);
+      expect(result).not.toBeNull();
+      expect(result?.confidence).toBe('high');
+    });
+
+    it('should detect Momo-specific patterns', () => {
+      const tx: TransactionForDetection = {
+        id: '1',
+        amount: 1000,
+        description: 'Momo interest reward',
+        date: '2025-01-15',
+      };
+
+      const result = detectInterestTransaction(tx);
+      expect(result).not.toBeNull();
+      expect(result?.confidence).toBe('high');
+    });
+
+    it('should return null for negative amounts (expenses)', () => {
+      const tx: TransactionForDetection = {
+        id: '1',
+        amount: -1000,
+        description: 'Tiền lãi',
+        date: '2025-01-15',
+      };
+
+      const result = detectInterestTransaction(tx);
+      expect(result).toBeNull();
+    });
+
+    it('should return null for zero amounts', () => {
+      const tx: TransactionForDetection = {
+        id: '1',
+        amount: 0,
+        description: 'Tiền lãi',
+        date: '2025-01-15',
+      };
+
+      const result = detectInterestTransaction(tx);
+      expect(result).toBeNull();
+    });
+
+    it('should return null for unrelated descriptions', () => {
+      const tx: TransactionForDetection = {
+        id: '1',
+        amount: 50000,
+        description: 'Coffee purchase',
+        date: '2025-01-15',
+      };
+
+      const result = detectInterestTransaction(tx);
+      expect(result).toBeNull();
+    });
+
+    it('should have medium confidence when amount matches expected daily interest', () => {
+      const tx: TransactionForDetection = {
+        id: '1',
+        amount: 1000,
+        description: null,
+        date: '2025-01-15',
+      };
+
+      // If expected daily interest is 1000, and amount is 1000, should be medium confidence
+      const result = detectInterestTransaction(tx, 1000);
+      expect(result).not.toBeNull();
+      expect(result?.confidence).toBe('medium');
+      expect(result?.matchReason).toContain(
+        'Amount matches expected daily interest'
+      );
+    });
+
+    it('should have high confidence when description matches AND amount matches', () => {
+      const tx: TransactionForDetection = {
+        id: '1',
+        amount: 1000,
+        description: 'Tiền lãi',
+        date: '2025-01-15',
+      };
+
+      const result = detectInterestTransaction(tx, 1000);
+      expect(result).not.toBeNull();
+      expect(result?.confidence).toBe('high');
+    });
+
+    it('should handle null description', () => {
+      const tx: TransactionForDetection = {
+        id: '1',
+        amount: 50000,
+        description: null,
+        date: '2025-01-15',
+      };
+
+      // Without description match or amount match, should return null
+      const result = detectInterestTransaction(tx);
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('detectInterestTransactions', () => {
+    it('should detect multiple interest transactions', () => {
+      const transactions: TransactionForDetection[] = [
+        { id: '1', amount: 1000, description: 'Tiền lãi', date: '2025-01-15' },
+        { id: '2', amount: -500, description: 'Coffee', date: '2025-01-15' },
+        {
+          id: '3',
+          amount: 1100,
+          description: 'Daily interest',
+          date: '2025-01-16',
+        },
+        { id: '4', amount: 500000, description: 'Salary', date: '2025-01-17' }, // Large amount not matching pattern
+      ];
+
+      const results = detectInterestTransactions(transactions);
+      expect(results).toHaveLength(2);
+      expect(results[0]?.transactionId).toBe('3'); // Sorted by date desc
+      expect(results[1]?.transactionId).toBe('1');
+    });
+
+    it('should sort results by date descending', () => {
+      const transactions: TransactionForDetection[] = [
+        { id: '1', amount: 1000, description: 'Lãi suất', date: '2025-01-10' },
+        { id: '2', amount: 1000, description: 'Lãi suất', date: '2025-01-20' },
+        { id: '3', amount: 1000, description: 'Lãi suất', date: '2025-01-15' },
+      ];
+
+      const results = detectInterestTransactions(transactions);
+      expect(results[0]?.date).toBe('2025-01-20');
+      expect(results[1]?.date).toBe('2025-01-15');
+      expect(results[2]?.date).toBe('2025-01-10');
+    });
+
+    it('should return empty array for no matches', () => {
+      const transactions: TransactionForDetection[] = [
+        { id: '1', amount: -500, description: 'Coffee', date: '2025-01-15' },
+        { id: '2', amount: 500000, description: 'Salary', date: '2025-01-17' }, // Large amount, no pattern match
+      ];
+
+      const results = detectInterestTransactions(transactions);
+      expect(results).toHaveLength(0);
+    });
+  });
+
+  describe('summarizeDetectionResults', () => {
+    it('should summarize detection results correctly', () => {
+      const detected = [
+        {
+          transactionId: '1',
+          date: '2025-01-15',
+          amount: 1000,
+          description: 'Tiền lãi',
+          confidence: 'high' as const,
+          matchReason: 'Description matches',
+        },
+        {
+          transactionId: '2',
+          date: '2025-01-16',
+          amount: 1100,
+          description: '',
+          confidence: 'medium' as const,
+          matchReason: 'Amount matches',
+        },
+        {
+          transactionId: '3',
+          date: '2025-01-17',
+          amount: 500,
+          description: '',
+          confidence: 'low' as const,
+          matchReason: 'Small amount',
+        },
+      ];
+
+      const summary = summarizeDetectionResults(detected);
+      expect(summary.totalAmount).toBe(2600);
+      expect(summary.highConfidence).toBe(1);
+      expect(summary.mediumConfidence).toBe(1);
+      expect(summary.lowConfidence).toBe(1);
+    });
+
+    it('should handle empty array', () => {
+      const summary = summarizeDetectionResults([]);
+      expect(summary.totalAmount).toBe(0);
+      expect(summary.highConfidence).toBe(0);
+      expect(summary.mediumConfidence).toBe(0);
+      expect(summary.lowConfidence).toBe(0);
+    });
+  });
+});