Expand unit coverage for currency sanitization edge cases

CurrencyUtilsTest additions:
- isValidCurrencyCode: non-string inputs (number, boolean, object, array).
- sanitizeCurrencyCode: whitespace/case normalization edge cases
  (tab/newline/internal-spaces, mixed case), explicit non-string inputs,
  log throttling (warn fires once per unique malformed value), and
  no-warn assertion when normalization recovers a valid code.
- convertToShortDisplayString, convertAmountToDisplayString, and
  convertToDisplayStringWithoutCurrency now have malformed-currency
  fallback coverage matching convertToDisplayString.
- convertToDisplayString: covers the shouldUseLocalCurrencySymbol branch
  with a malformed currency, and the undefined currency default path.

New NumberFormatUtilsTest covers the try/catch safety net directly:
- format/formatToParts succeed for valid currencies without warning.
- format/formatToParts fall back to USD without throwing for malformed
  currencies (including the empty-string case via the 'currency' in
  options guard).
- format/formatToParts do not swallow RangeErrors when the failing
  option is not currency (e.g. an unknown unit), preserving normal
  error propagation for unrelated bugs.
- Verifies Intl's native case-insensitive handling of lowercase ISO
  codes ('usd') does not trigger the fallback path.

Co-authored-by: Cursor <cursoragent@cursor.com>

Author: mountiny

tests/unit/CurrencyUtilsTest.ts

@@ -2,6 +2,7 @@ import Onyx from 'react-native-onyx';
 import CONST from '@src/CONST';
 import IntlStore from '@src/languages/IntlStore';
 import * as CurrencyUtils from '@src/libs/CurrencyUtils';
+import Log from '@src/libs/Log';
 import ONYXKEYS from '@src/ONYXKEYS';
 import waitForBatchedUpdates from '../utils/waitForBatchedUpdates';
 // This file can get outdated. In that case, you can follow these steps to update it:
@@ -203,6 +204,10 @@ describe('CurrencyUtils', () => {
             ['US1', false],
             [undefined, false],
             [null, false],
+            [42, false],
+            [{}, false],
+            [[], false],
+            [true, false],
         ])('isValidCurrencyCode(%p) → %p', (input, expected) => {
             expect(CurrencyUtils.isValidCurrencyCode(input)).toBe(expected);
         });
@@ -213,14 +218,50 @@ describe('CurrencyUtils', () => {
             expect(CurrencyUtils.sanitizeCurrencyCode('EUR')).toBe('EUR');
         });
 
-        test('normalizes whitespace and case before validating', () => {
-            expect(CurrencyUtils.sanitizeCurrencyCode(' usd ')).toBe('USD');
-            expect(CurrencyUtils.sanitizeCurrencyCode('eur')).toBe('EUR');
+        test.each([
+            [' usd ', 'USD'],
+            ['eur', 'EUR'],
+            ['UsD', 'USD'],
+            ['\tEUR', 'EUR'],
+            ['JPY\n', 'JPY'],
+            ['  GBP  ', 'GBP'],
+        ])('normalizes whitespace and case: %p → %p', (input, expected) => {
+            expect(CurrencyUtils.sanitizeCurrencyCode(input)).toBe(expected);
+        });
+
+        test.each(['', 'XX', 'USDD', 'US1', '???', 'us-d', 'U S D'])('falls back to USD for malformed string %p', (input) => {
+            expect(CurrencyUtils.sanitizeCurrencyCode(input)).toBe(CONST.CURRENCY.USD);
         });
 
-        test.each(['', 'XX', 'USDD', 'US1', '???'])('falls back to USD for malformed input %p', (input) => {
+        test.each([undefined, null, 42, true, {}, []])('falls back to USD for non-string input %p', (input) => {
             expect(CurrencyUtils.sanitizeCurrencyCode(input)).toBe(CONST.CURRENCY.USD);
         });
+
+        test('logs a warning at most once per unique malformed value', () => {
+            const warnSpy = jest.spyOn(Log, 'warn').mockImplementation(() => undefined);
+            try {
+                // Use unique fixtures so other tests don't already mark these as warned.
+                CurrencyUtils.sanitizeCurrencyCode('TEST_THROTTLE_A');
+                CurrencyUtils.sanitizeCurrencyCode('TEST_THROTTLE_A');
+                CurrencyUtils.sanitizeCurrencyCode('TEST_THROTTLE_A');
+                expect(warnSpy).toHaveBeenCalledTimes(1);
+
+                CurrencyUtils.sanitizeCurrencyCode('TEST_THROTTLE_B');
+                expect(warnSpy).toHaveBeenCalledTimes(2);
+            } finally {
+                warnSpy.mockRestore();
+            }
+        });
+
+        test('does not log a warning when normalization recovers a valid code', () => {
+            const warnSpy = jest.spyOn(Log, 'warn').mockImplementation(() => undefined);
+            try {
+                expect(CurrencyUtils.sanitizeCurrencyCode(' eur ')).toBe('EUR');
+                expect(warnSpy).not.toHaveBeenCalled();
+            } finally {
+                warnSpy.mockRestore();
+            }
+        });
     });
 
     describe('convertToDisplayString with malformed currency', () => {
@@ -232,6 +273,41 @@ describe('CurrencyUtils', () => {
         test('normalizes case-only variations to the intended currency instead of USD', () => {
             expect(CurrencyUtils.convertToDisplayString(2500, 'eur')).toBe(CurrencyUtils.convertToDisplayString(2500, 'EUR'));
         });
+
+        test('falls back to USD when shouldUseLocalCurrencySymbol is true and currency is malformed', () => {
+            expect(() => CurrencyUtils.convertToDisplayString(2500, 'invalid', true)).not.toThrow();
+            // USD has a known local symbol in the currencyList, so the local-symbol branch should produce a $-prefixed result.
+            expect(CurrencyUtils.convertToDisplayString(2500, 'invalid', true)).toMatch(/\$/);
+        });
+
+        test('handles undefined currency via the default parameter', () => {
+            expect(CurrencyUtils.convertToDisplayString(2500, undefined)).toBe('$25.00');
+        });
+    });
+
+    describe('convertToShortDisplayString with malformed currency', () => {
+        test.each(['', 'XX', 'USDD', '???'])('does not throw and falls back to USD formatting for %p', (input) => {
+            expect(() => CurrencyUtils.convertToShortDisplayString(2500, input)).not.toThrow();
+            expect(CurrencyUtils.convertToShortDisplayString(2500, input)).toBe('$25');
+        });
+    });
+
+    describe('convertAmountToDisplayString with malformed currency', () => {
+        test.each(['', 'XX', 'USDD', '???'])('does not throw and falls back to USD formatting for %p', (input) => {
+            expect(() => CurrencyUtils.convertAmountToDisplayString(2500, input)).not.toThrow();
+            // The result should at least include a $ symbol from the USD fallback.
+            expect(CurrencyUtils.convertAmountToDisplayString(2500, input)).toMatch(/\$/);
+        });
+    });
+
+    describe('convertToDisplayStringWithoutCurrency with malformed currency', () => {
+        test.each(['', 'XX', 'USDD', '???'])('does not throw and produces a numeric output for %p', (input) => {
+            expect(() => CurrencyUtils.convertToDisplayStringWithoutCurrency(2500, input)).not.toThrow();
+            // Output should not contain a currency symbol but should contain the numeric portion.
+            const result = CurrencyUtils.convertToDisplayStringWithoutCurrency(2500, input);
+            expect(result).not.toMatch(/\$/);
+            expect(result).toContain('25');
+        });
     });
 
     describe('getLocalizedCurrencySymbol with malformed currency', () => {

tests/unit/NumberFormatUtilsTest.ts

@@ -0,0 +1,85 @@
+import CONST from '@src/CONST';
+import Log from '@src/libs/Log';
+import * as NumberFormatUtils from '@src/libs/NumberFormatUtils';
+
+describe('NumberFormatUtils', () => {
+    let warnSpy: jest.SpyInstance;
+
+    beforeEach(() => {
+        warnSpy = jest.spyOn(Log, 'warn').mockImplementation(() => undefined);
+    });
+
+    afterEach(() => {
+        warnSpy.mockRestore();
+    });
+
+    describe('format', () => {
+        test('formats a valid currency without entering the fallback path', () => {
+            expect(NumberFormatUtils.format(CONST.LOCALES.EN, 25, {style: 'currency', currency: 'USD'})).toBe('$25.00');
+            expect(warnSpy).not.toHaveBeenCalled();
+        });
+
+        test('formats decimal style without a currency option', () => {
+            expect(NumberFormatUtils.format(CONST.LOCALES.EN, 25.5, {style: 'decimal', minimumFractionDigits: 2})).toBe('25.50');
+            expect(warnSpy).not.toHaveBeenCalled();
+        });
+
+        test.each(['', 'XX', '1USD', 'US-D', '???'])('falls back to USD without throwing for malformed currency %p', (input) => {
+            expect(() => NumberFormatUtils.format(CONST.LOCALES.EN, 25, {style: 'currency', currency: input})).not.toThrow();
+            expect(NumberFormatUtils.format(CONST.LOCALES.EN, 25, {style: 'currency', currency: input})).toBe('$25.00');
+            expect(warnSpy).toHaveBeenCalled();
+        });
+
+        test('explicitly recovers from an empty-string currency (RangeError guard via "in" check)', () => {
+            expect(() => NumberFormatUtils.format(CONST.LOCALES.EN, 25, {style: 'currency', currency: ''})).not.toThrow();
+            expect(NumberFormatUtils.format(CONST.LOCALES.EN, 25, {style: 'currency', currency: ''})).toBe('$25.00');
+        });
+
+        test('passes case-insensitive valid codes through without entering the fallback', () => {
+            // Intl.NumberFormat accepts lowercase ISO 4217 codes natively (it normalizes case),
+            // so no RangeError is thrown and the fallback should not run.
+            expect(NumberFormatUtils.format(CONST.LOCALES.EN, 25, {style: 'currency', currency: 'usd'})).toBe('$25.00');
+            expect(warnSpy).not.toHaveBeenCalled();
+        });
+
+        test('does not swallow RangeErrors when options has no currency key', () => {
+            // An invalid `unit` triggers a RangeError but the fallback only applies when `currency` is in options,
+            // so this should still throw rather than being silently rewritten to USD.
+            expect(() => NumberFormatUtils.format(CONST.LOCALES.EN, 25, {style: 'unit', unit: 'not-a-real-unit'} as Intl.NumberFormatOptions)).toThrow(RangeError);
+        });
+
+        test('does not swallow RangeErrors when options is undefined', () => {
+            expect(NumberFormatUtils.format(CONST.LOCALES.EN, 25)).toBe('25');
+            expect(warnSpy).not.toHaveBeenCalled();
+        });
+
+        test('uses the default locale when locale is undefined', () => {
+            expect(NumberFormatUtils.format(undefined, 25, {style: 'currency', currency: 'USD'})).toBe('$25.00');
+        });
+    });
+
+    describe('formatToParts', () => {
+        test('returns parts for a valid currency without entering the fallback path', () => {
+            const parts = NumberFormatUtils.formatToParts(CONST.LOCALES.EN, 0, {style: 'currency', currency: 'USD'});
+            expect(parts.find((part) => part.type === 'currency')?.value).toBe('$');
+            expect(warnSpy).not.toHaveBeenCalled();
+        });
+
+        test.each(['', 'XX', '1USD', 'US-D', '???'])('falls back to USD without throwing for malformed currency %p', (input) => {
+            expect(() => NumberFormatUtils.formatToParts(CONST.LOCALES.EN, 0, {style: 'currency', currency: input})).not.toThrow();
+            const parts = NumberFormatUtils.formatToParts(CONST.LOCALES.EN, 0, {style: 'currency', currency: input});
+            expect(parts.find((part) => part.type === 'currency')?.value).toBe('$');
+            expect(warnSpy).toHaveBeenCalled();
+        });
+
+        test('explicitly recovers from an empty-string currency (RangeError guard via "in" check)', () => {
+            expect(() => NumberFormatUtils.formatToParts(CONST.LOCALES.EN, 0, {style: 'currency', currency: ''})).not.toThrow();
+            const parts = NumberFormatUtils.formatToParts(CONST.LOCALES.EN, 0, {style: 'currency', currency: ''});
+            expect(parts.find((part) => part.type === 'currency')?.value).toBe('$');
+        });
+
+        test('does not swallow RangeErrors when options has no currency key', () => {
+            expect(() => NumberFormatUtils.formatToParts(CONST.LOCALES.EN, 0, {style: 'unit', unit: 'not-a-real-unit'} as Intl.NumberFormatOptions)).toThrow(RangeError);
+        });
+    });
+});