Merge pull request #97767 from c3024/chaitanya/97583-footer-reset-currency

Fix footer Reset falling back to a stale selected-expense currency

Author: mountiny

src/components/Search/SearchPageFooter.tsx

@@ -42,7 +42,7 @@ type SearchPageFooterProps = {
     isTotalLoading: boolean;
 
     /** Function to call when the footer currency changes */
-    onCurrencyChange: (currency: string | undefined) => void;
+    onCurrencyChange: (currency: string) => void;
 };
 
 function SearchPageFooter({count, total, currency, defaultCurrency, isTotalLoading, onCurrencyChange}: SearchPageFooterProps) {
@@ -69,11 +69,12 @@ function SearchPageFooter({count, total, currency, defaultCurrency, isTotalLoadi
             return;
         }
 
+        // Reset (no item) selects the default explicitly so figures loaded in another currency get converted to it.
         const nextCurrency = item?.value ?? defaultCurrency;
         if (!nextCurrency) {
             return;
         }
-        onCurrencyChange(nextCurrency === defaultCurrency ? undefined : nextCurrency);
+        onCurrencyChange(nextCurrency);
     };
 
     const renderCurrencyPopup: FilterPopupButtonProps['PopoverComponent'] = ({closeOverlay, isExpanded}) => (

src/components/Search/SearchResultsProvider.tsx

@@ -36,7 +36,7 @@ const defaultSearchInfo: SearchResultsInfo = {
     isLoading: false,
     count: 0,
     total: 0,
-    currency: '',
+    currency: undefined,
 };
 
 function SearchResultsProvider({children}: SearchResultsProviderProps) {

src/components/Search/SearchSelectionFooter.tsx

@@ -1,3 +1,4 @@
+import useActivePolicy from '@hooks/useActivePolicy';
 import useNetwork from '@hooks/useNetwork';
 import useOnyx from '@hooks/useOnyx';
 import useSearchShouldCalculateTotals from '@hooks/useSearchShouldCalculateTotals';
@@ -88,6 +89,9 @@ function SearchSelectionFooter({searchResults}: SearchSelectionFooterProps) {
     const {currentSearchHash, currentSearchKey, currentSearchQueryJSON} = useSearchQueryContext();
     const shouldAllowFooterTotals = useSearchShouldCalculateTotals(currentSearchKey, currentSearchQueryJSON?.hash, true, areAllMatchingItemsSelected);
     const {isOffline} = useNetwork();
+    const activePolicy = useActivePolicy();
+    // The server converts search figures to the active policy's currency when the query carries no explicit target.
+    const searchTargetCurrency = activePolicy?.outputCurrency ?? CONST.CURRENCY.USD;
     const [footerCurrencyState, setFooterCurrencyState] = useState<FooterCurrencyState>({
         searchHash: undefined,
         selectedCurrency: undefined,
@@ -377,7 +381,7 @@ function SearchSelectionFooter({searchResults}: SearchSelectionFooterProps) {
     ]);
 
     const handleFooterCurrencyChange = useCallback(
-        (currency: string | undefined) => {
+        (currency: string) => {
             setFooterCurrencyState({
                 searchHash: currentSearchHash,
                 selectedCurrency: currency,
@@ -464,7 +468,7 @@ function SearchSelectionFooter({searchResults}: SearchSelectionFooterProps) {
             count={footerData.count}
             total={footerData.total}
             currency={footerData.currency}
-            defaultCurrency={effectiveDefaultCurrency}
+            defaultCurrency={searchTargetCurrency}
             isTotalLoading={isFooterTotalLoading}
             onCurrencyChange={handleFooterCurrencyChange}
         />

tests/unit/Search/SearchSelectionFooterTest.tsx

@@ -0,0 +1,179 @@
+import {act, render} from '@testing-library/react-native';
+
+import SearchSelectionFooter from '@components/Search/SearchSelectionFooter';
+import type {SelectedTransactionInfo, SelectedTransactions} from '@components/Search/types';
+
+import {getFooterConvertedAmounts} from '@libs/actions/Search';
+
+import CONST from '@src/CONST';
+import ONYXKEYS from '@src/ONYXKEYS';
+import type {SearchResults} from '@src/types/onyx';
+
+import Onyx from 'react-native-onyx';
+
+import waitForBatchedUpdates from '../../utils/waitForBatchedUpdates';
+
+jest.mock('@hooks/useNetwork', () => jest.fn(() => ({isOffline: false})));
+
+jest.mock('@hooks/useSearchShouldCalculateTotals', () => jest.fn(() => true));
+
+jest.mock('@libs/actions/Search', () => ({
+    getFooterConvertedAmounts: jest.fn(),
+}));
+
+const mockSearchQueryContext: {current: {currentSearchHash: number; currentSearchKey: undefined; currentSearchQueryJSON: {hash: number; type: string} | undefined}} = {
+    current: {currentSearchHash: 1, currentSearchKey: undefined, currentSearchQueryJSON: {hash: 1, type: CONST.SEARCH.DATA_TYPES.EXPENSE}},
+};
+const mockSelectedTransactions: {current: SelectedTransactions} = {current: {}};
+jest.mock('@components/Search/SearchContext', () => ({
+    useSearchQueryContext: () => mockSearchQueryContext.current,
+    useSearchResultsContext: () => ({currentSearchResults: undefined}),
+    useSearchSelectionContext: () => ({selectedTransactions: mockSelectedTransactions.current, areAllMatchingItemsSelected: false, selectedReports: []}),
+}));
+
+type CapturedFooterProps = {defaultCurrency?: string; currency?: string; onCurrencyChange?: (currency: string) => void};
+const mockCapturedFooterProps: {current: CapturedFooterProps | undefined} = {current: undefined};
+jest.mock('@components/Search/SearchPageFooter', () => ({
+    __esModule: true,
+    default: (props: CapturedFooterProps) => {
+        mockCapturedFooterProps.current = props;
+        return null;
+    },
+}));
+
+// The currency of the selected expense — deliberately different from every other currency in this test so a leak
+// from any wrong fallback source is easy to spot.
+const SELECTED_EXPENSE_CURRENCY = 'JPY';
+
+// The Preferences > Payment currency setting, stored as the personal policy's output currency. Deliberately not USD
+// so the test can tell the real fallback apart from the USD last resort.
+const PAYMENT_CURRENCY = CONST.CURRENCY.GBP;
+
+const ACCOUNT_ID = 1;
+const PERSONAL_POLICY_ID = 'personalPolicy1';
+const WORKSPACE_POLICY_ID = 'workspacePolicy1';
+
+function buildSearchResults(currency: string | undefined, count = 1): SearchResults {
+    return {
+        search: {
+            count,
+            currency,
+            total: -100,
+            offset: 0,
+            isLoading: false,
+            hash: 1,
+            type: CONST.SEARCH.DATA_TYPES.EXPENSE,
+            sortBy: CONST.SEARCH.TABLE_COLUMNS.DATE,
+            sortOrder: CONST.SEARCH.SORT_ORDER.DESC,
+            hasMoreResults: false,
+            hasResults: true,
+        },
+        data: {},
+    };
+}
+
+function buildSelectedTransaction(currency: string, groupCurrency?: string, groupAmount?: number): SelectedTransactionInfo {
+    return {
+        isSelected: true,
+        canReject: false,
+        canHold: false,
+        canSplit: false,
+        hasBeenSplit: false,
+        canChangeReport: false,
+        isHeld: false,
+        canUnhold: false,
+        action: CONST.SEARCH.ACTION_TYPES.VIEW,
+        policyID: undefined,
+        amount: 100,
+        currency,
+        groupCurrency,
+        groupAmount,
+        isFromOneTransactionReport: false,
+    };
+}
+
+describe('SearchSelectionFooter', () => {
+    beforeAll(() => {
+        Onyx.init({keys: ONYXKEYS});
+    });
+
+    beforeEach(async () => {
+        mockSearchQueryContext.current = {currentSearchHash: 1, currentSearchKey: undefined, currentSearchQueryJSON: {hash: 1, type: CONST.SEARCH.DATA_TYPES.EXPENSE}};
+        mockSelectedTransactions.current = {transaction1: buildSelectedTransaction(SELECTED_EXPENSE_CURRENCY)};
+        mockCapturedFooterProps.current = undefined;
+        // Clear here rather than in afterEach: Onyx.clear() there re-renders the previous test's still-mounted
+        // component (testing-library only unmounts it afterwards), and those renders can record mock calls.
+        jest.clearAllMocks();
+        await Onyx.merge(ONYXKEYS.SESSION, {accountID: ACCOUNT_ID});
+        // Accounts without a workspace have their personal policy as the active policy.
+        await Onyx.merge(ONYXKEYS.NVP_ACTIVE_POLICY_ID, PERSONAL_POLICY_ID);
+        await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${PERSONAL_POLICY_ID}`, {id: PERSONAL_POLICY_ID, outputCurrency: PAYMENT_CURRENCY});
+        await waitForBatchedUpdates();
+    });
+
+    afterEach(async () => {
+        await Onyx.clear();
+    });
+
+    it("offers the user's live payment currency as the Reset target when there is no active workspace", async () => {
+        // A fresh no-workspace account: the active policy is the personal policy, and the only selected expense
+        // happens to be in a different currency (JPY) from the live payment currency (GBP).
+        render(<SearchSelectionFooter searchResults={buildSearchResults(undefined)} />);
+        await waitForBatchedUpdates();
+
+        // The footer's Reset/default currency follows the live payment currency (the personal policy's output
+        // currency), not the selected expense's own (stale) currency.
+        expect(mockCapturedFooterProps.current?.defaultCurrency).toBe(PAYMENT_CURRENCY);
+    });
+
+    it("offers the active workspace's currency as the Reset target when one is set", async () => {
+        // The server converts search figures to the active policy's currency, so with an active workspace the Reset
+        // target is the workspace currency, not the personal payment currency.
+        await Onyx.merge(ONYXKEYS.NVP_ACTIVE_POLICY_ID, WORKSPACE_POLICY_ID);
+        await Onyx.merge(`${ONYXKEYS.COLLECTION.POLICY}${WORKSPACE_POLICY_ID}`, {id: WORKSPACE_POLICY_ID, outputCurrency: CONST.CURRENCY.EUR});
+        await waitForBatchedUpdates();
+
+        render(<SearchSelectionFooter searchResults={buildSearchResults(CONST.CURRENCY.EUR)} />);
+        await waitForBatchedUpdates();
+
+        expect(mockCapturedFooterProps.current?.defaultCurrency).toBe(CONST.CURRENCY.EUR);
+    });
+
+    it('converts the figures when Reset selects a default the figures are not denominated in', async () => {
+        // The payment currency changed after the snapshot loaded: the selected group's server-converted figure is
+        // still denominated in the old payment currency (INR), while the live default is now GBP.
+        mockSelectedTransactions.current = {[`${CONST.SEARCH.GROUP_PREFIX}category1`]: buildSelectedTransaction(SELECTED_EXPENSE_CURRENCY, 'INR', -100)};
+
+        // A partial selection (1 of 2), so the footer uses the client-side selected total.
+        render(<SearchSelectionFooter searchResults={buildSearchResults(undefined, 2)} />);
+        await waitForBatchedUpdates();
+
+        // No picker choice yet, so nothing converts.
+        expect(getFooterConvertedAmounts).not.toHaveBeenCalled();
+
+        // Reset passes the default through onCurrencyChange as an explicit selection.
+        await act(async () => {
+            mockCapturedFooterProps.current?.onCurrencyChange?.(PAYMENT_CURRENCY);
+            await waitForBatchedUpdates();
+        });
+
+        // The chosen default differs from the figures' denomination, so a conversion to it is requested.
+        expect(getFooterConvertedAmounts).toHaveBeenCalledWith(expect.objectContaining({targetCurrency: PAYMENT_CURRENCY}));
+    });
+
+    it('does not convert when Reset selects the currency the figures are already denominated in', async () => {
+        mockSelectedTransactions.current = {[`${CONST.SEARCH.GROUP_PREFIX}category1`]: buildSelectedTransaction(SELECTED_EXPENSE_CURRENCY, PAYMENT_CURRENCY, -100)};
+
+        render(<SearchSelectionFooter searchResults={buildSearchResults(undefined, 2)} />);
+        await waitForBatchedUpdates();
+
+        await act(async () => {
+            mockCapturedFooterProps.current?.onCurrencyChange?.(PAYMENT_CURRENCY);
+            await waitForBatchedUpdates();
+        });
+
+        // The figures are already in the chosen currency, so no request is made and the snapshot data is used as-is.
+        expect(getFooterConvertedAmounts).not.toHaveBeenCalled();
+        expect(mockCapturedFooterProps.current?.currency).toBe(PAYMENT_CURRENCY);
+    });
+});