Fix account breakdown percentage calculation in net totals mode and enhance unit tests

- Corrected the denominator used for account breakdown percentages in net totals mode to reflect the sum of absolute values of net spending, ensuring accurate percentage calculations.
- Added unit tests for account breakdown percentage calculations in both net totals and absolute modes, including scenarios with negative net spending and edge cases.

Author: MatissJanis

CHANGELOG.md

@@ -26,11 +26,13 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 - Fixed category totals calculation bug where income transactions (e.g., refunds) in the same category as expenses were not reducing the category total. Now correctly shows net spending (e.g., -$100 expense + $50 income = $50 net spending)
 - Fixed payee totals calculation: Income transactions (e.g., refunds) now reduce payee totals when net totals mode is enabled
 - Fixed account breakdown totals: Income transactions now reduce account totals when net totals mode is enabled
+- Fixed account breakdown percentage calculation: Account breakdown percentages now use the correct denominator when net totals mode is enabled (sum of absolute values of net spending) instead of total expenses, fixing incorrect percentages that didn't sum to 100% and could be negative
 - Fixed day of week spending totals: Income transactions now reduce day totals when net totals mode is enabled
 
 ### Tests
 
 - Added comprehensive unit tests for net totals calculation mode, covering categories, payees, and account breakdown in both new mode (with income) and old mode (expenses only), including scenarios with multiple income and expense transactions
+- Added unit tests for account breakdown percentage calculation in both net totals mode and absolute mode, including edge cases with negative net spending
 
 ## 2026-01-05
 

src/utils/dataTransform.test.ts

@@ -1931,6 +1931,119 @@ describe('transformToWrappedData', () => {
       expect(checking?.totalSpending).toBe(100); // Only $100 (absolute spending, ignores income)
       expect(checking?.transactionCount).toBe(2); // Count still includes both
     });
+
+    it('calculates account breakdown percentages correctly when includeIncomeInCategories is true (net totals mode)', () => {
+      const transactions: Transaction[] = [
+        createMockTransaction({ id: 't1', account: 'acc1', amount: -10000 }), // -$100 expense
+        createMockTransaction({ id: 't2', account: 'acc1', amount: 5000 }), // +$50 income (refund) → net = $50
+        createMockTransaction({ id: 't3', account: 'acc2', amount: -20000 }), // -$200 expense → net = $200
+      ];
+
+      const accounts: Account[] = [
+        createMockAccount({ id: 'acc1', name: 'Checking' }),
+        createMockAccount({ id: 'acc2', name: 'Savings' }),
+      ];
+
+      // New mode: includeIncomeInCategories = true (default)
+      const result = transformToWrappedData(transactions, [], [], accounts);
+
+      const checking = result.accountBreakdown.find(a => a.accountId === 'acc1');
+      const savings = result.accountBreakdown.find(a => a.accountId === 'acc2');
+
+      expect(checking).toBeDefined();
+      expect(checking?.totalSpending).toBe(50); // $100 - $50 = $50 (net spending)
+      expect(savings).toBeDefined();
+      expect(savings?.totalSpending).toBe(200); // $200 (net spending)
+
+      // Percentages should use sum of absolute values: $50 + $200 = $250
+      // Account 1: $50 / $250 = 20%
+      // Account 2: $200 / $250 = 80%
+      // Total should be approximately 100%
+      const totalPercentage = result.accountBreakdown.reduce((sum, acc) => sum + acc.percentage, 0);
+      expect(totalPercentage).toBeCloseTo(100, 1);
+      expect(checking?.percentage).toBeCloseTo(20, 1);
+      expect(savings?.percentage).toBeCloseTo(80, 1);
+    });
+
+    it('calculates account breakdown percentages correctly when includeIncomeInCategories is false (absolute mode)', () => {
+      const transactions: Transaction[] = [
+        createMockTransaction({ id: 't1', account: 'acc1', amount: -10000 }), // -$100 expense
+        createMockTransaction({ id: 't2', account: 'acc1', amount: 5000 }), // +$50 income (ignored)
+        createMockTransaction({ id: 't3', account: 'acc2', amount: -20000 }), // -$200 expense
+      ];
+
+      const accounts: Account[] = [
+        createMockAccount({ id: 'acc1', name: 'Checking' }),
+        createMockAccount({ id: 'acc2', name: 'Savings' }),
+      ];
+
+      // Old mode: includeIncomeInCategories = false
+      const result = transformToWrappedData(
+        transactions,
+        [],
+        [],
+        accounts,
+        2025,
+        false,
+        true,
+        false,
+        '$',
+        undefined,
+        new Map(),
+        new Map(),
+        false, // includeIncomeInCategories = false
+      );
+
+      const checking = result.accountBreakdown.find(a => a.accountId === 'acc1');
+      const savings = result.accountBreakdown.find(a => a.accountId === 'acc2');
+
+      expect(checking).toBeDefined();
+      expect(checking?.totalSpending).toBe(100); // Only $100 (absolute spending, ignores income)
+      expect(savings).toBeDefined();
+      expect(savings?.totalSpending).toBe(200); // $200 (absolute spending)
+
+      // Percentages should use totalExpenses: $100 + $200 = $300
+      // Account 1: $100 / $300 = 33.33%
+      // Account 2: $200 / $300 = 66.67%
+      // Total should be approximately 100%
+      const totalPercentage = result.accountBreakdown.reduce((sum, acc) => sum + acc.percentage, 0);
+      expect(totalPercentage).toBeCloseTo(100, 1);
+      expect(checking?.percentage).toBeCloseTo(33.33, 1);
+      expect(savings?.percentage).toBeCloseTo(66.67, 1);
+    });
+
+    it('handles negative net spending in account breakdown percentages correctly', () => {
+      const transactions: Transaction[] = [
+        createMockTransaction({ id: 't1', account: 'acc1', amount: -10000 }), // -$100 expense
+        createMockTransaction({ id: 't2', account: 'acc1', amount: 15000 }), // +$150 income → net = -$50 (negative)
+        createMockTransaction({ id: 't3', account: 'acc2', amount: -20000 }), // -$200 expense → net = $200
+      ];
+
+      const accounts: Account[] = [
+        createMockAccount({ id: 'acc1', name: 'Checking' }),
+        createMockAccount({ id: 'acc2', name: 'Savings' }),
+      ];
+
+      // New mode: includeIncomeInCategories = true (default)
+      const result = transformToWrappedData(transactions, [], [], accounts);
+
+      const checking = result.accountBreakdown.find(a => a.accountId === 'acc1');
+      const savings = result.accountBreakdown.find(a => a.accountId === 'acc2');
+
+      expect(checking).toBeDefined();
+      expect(checking?.totalSpending).toBe(-50); // $100 - $150 = -$50 (negative net spending)
+      expect(savings).toBeDefined();
+      expect(savings?.totalSpending).toBe(200); // $200 (net spending)
+
+      // Percentages should use sum of absolute values: |-$50| + $200 = $250
+      // Account 1: $50 / $250 = 20%
+      // Account 2: $200 / $250 = 80%
+      // Total should be approximately 100%
+      const totalPercentage = result.accountBreakdown.reduce((sum, acc) => sum + acc.percentage, 0);
+      expect(totalPercentage).toBeCloseTo(100, 1);
+      expect(checking?.percentage).toBeCloseTo(20, 1);
+      expect(savings?.percentage).toBeCloseTo(80, 1);
+    });
   });
 
   describe('Spending Streaks', () => {

src/utils/dataTransform.ts

@@ -967,18 +967,27 @@ export function transformToWrappedData(
       }
     });
 
-    const accountBreakdown: AccountBreakdown[] = Array.from(accountMap.entries())
-      .map(([accountId, data]) => ({
-        accountId,
-        accountName: accountIdToName.get(accountId) || accountId,
-        totalSpending: data.totalSpending,
-        transactionCount: data.transactionCount,
-        percentage: 0, // Will calculate after sorting
-      }))
+    const accountBreakdownUnsorted = Array.from(accountMap.entries()).map(([accountId, data]) => ({
+      accountId,
+      accountName: accountIdToName.get(accountId) || accountId,
+      totalSpending: data.totalSpending,
+      transactionCount: data.transactionCount,
+      percentage: 0, // Will calculate after sorting
+    }));
+
+    // Calculate the correct denominator for percentages
+    // When includeIncomeInCategories is true (net totals mode), use sum of absolute values of net spending
+    // When false (absolute mode), use totalExpenses
+    const totalForPercentage = includeIncomeInCategories
+      ? accountBreakdownUnsorted.reduce((sum, acc) => sum + Math.abs(acc.totalSpending), 0)
+      : totalExpenses;
+
+    const accountBreakdown: AccountBreakdown[] = accountBreakdownUnsorted
       .sort((a, b) => b.totalSpending - a.totalSpending)
       .map(acc => ({
         ...acc,
-        percentage: totalExpenses > 0 ? (acc.totalSpending / totalExpenses) * 100 : 0,
+        percentage:
+          totalForPercentage > 0 ? (Math.abs(acc.totalSpending) / totalForPercentage) * 100 : 0,
       }));
 
     // Spending Streaks