add unit tests

Author: akinwale

tests/actions/IOUTest/RejectMoneyRequestTest.ts

@@ -1,4 +1,4 @@
-import {markRejectViolationAsResolved, rejectExpenseReport, rejectMoneyRequest} from '@libs/actions/IOU/RejectMoneyRequest';
+import {dismissRejectExpenseError, markRejectViolationAsResolved, rejectExpenseReport, rejectMoneyRequest} from '@libs/actions/IOU/RejectMoneyRequest';
 import initOnyxDerivedValues from '@libs/actions/OnyxDerived';
 import {WRITE_COMMANDS} from '@libs/API/types';
 import {getParsedComment} from '@libs/ReportUtils';
@@ -22,7 +22,7 @@ import createRandomPolicy from '../../utils/collections/policies';
 import {createRandomReport} from '../../utils/collections/reports';
 import createRandomTransaction from '../../utils/collections/transaction';
 import getOnyxValue from '../../utils/getOnyxValue';
-import {getCurrencyDecimalsLocal, getGlobalFetchMock, getOnyxData} from '../../utils/TestHelper';
+import {getCurrencyDecimalsLocal, getGlobalFetchMock, getOnyxData, translateLocal} from '../../utils/TestHelper';
 import waitForBatchedUpdates from '../../utils/waitForBatchedUpdates';
 
 jest.mock('@src/libs/Navigation/Navigation', () => ({
@@ -334,6 +334,137 @@ describe('actions/IOU/RejectMoneyRequest', () => {
             expect(firstRejectedTransaction?.reportID).toBe(sharedRejectedToReportID);
             expect(secondRejectedTransaction?.reportID).toBe(sharedRejectedToReportID);
         });
+
+        describe('when the expense has already moved off the report', () => {
+            const MOVED_TO_REPORT_ID = '999';
+            const ERROR_TIMESTAMP = '1770000000000000';
+
+            // The copy Web-Expensify returns for this case, reported under its own `reject` error field
+            const SERVER_REJECT_ERROR = {[ERROR_TIMESTAMP]: 'The expense has already been moved or rejected.'};
+
+            /** Puts a second expense on the report so rejecting moves the expense off it instead of deleting the report. */
+            async function addSecondExpenseToReport() {
+                const secondTransaction = {
+                    ...createRandomTransaction(2),
+                    reportID: iouReport?.reportID,
+                    amount,
+                    currency: CONST.CURRENCY.USD,
+                    merchant: 'Second Test Merchant',
+                    transactionID: '2',
+                };
+                await Onyx.set(`${ONYXKEYS.COLLECTION.TRANSACTION}${secondTransaction.transactionID}`, secondTransaction);
+                await waitForBatchedUpdates();
+            }
+
+            it('should not send a reject for an expense the server has already moved elsewhere', async () => {
+                if (!transaction?.transactionID || !iouReport?.reportID) {
+                    throw new Error('Required transaction or report data is missing');
+                }
+
+                // Given: The expense now sits on a different report, so the copy on this report is stale
+                await Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${transaction.transactionID}`, {reportID: MOVED_TO_REPORT_ID});
+                await waitForBatchedUpdates();
+
+                // When: Rejecting it from the report it is no longer on
+                const result = rejectMoneyRequest(
+                    transaction.transactionID,
+                    iouReport.reportID,
+                    comment,
+                    policy,
+                    TEST_USER_ACCOUNT_ID,
+                    TEST_USER_EMAIL,
+                    [CONST.BETAS.ALL],
+                    undefined,
+                    getCurrencyDecimalsLocal,
+                );
+
+                await waitForBatchedUpdates();
+
+                // Then: There is nowhere to navigate back to, and nothing was applied optimistically —
+                // the expense stays put on the report the server moved it to
+                expect(result).toBeUndefined();
+                const untouchedTransaction = await getOnyxValue(`${ONYXKEYS.COLLECTION.TRANSACTION}${transaction.transactionID}`);
+                expect(untouchedTransaction?.reportID).toBe(MOVED_TO_REPORT_ID);
+            });
+
+            it('should put the expense back on the report with an error when the reject fails', async () => {
+                if (!transaction?.transactionID || !iouReport?.reportID) {
+                    throw new Error('Required transaction or report data is missing');
+                }
+                await addSecondExpenseToReport();
+
+                // When: The server rejects the request
+                mockFetch?.fail?.();
+                rejectMoneyRequest(
+                    transaction.transactionID,
+                    iouReport.reportID,
+                    comment,
+                    policy,
+                    TEST_USER_ACCOUNT_ID,
+                    TEST_USER_EMAIL,
+                    [CONST.BETAS.ALL],
+                    undefined,
+                    getCurrencyDecimalsLocal,
+                );
+                await waitForBatchedUpdates();
+
+                // Then: The expense returns to the report carrying a translated rejection error
+                const rejectedTransaction = await getOnyxValue(`${ONYXKEYS.COLLECTION.TRANSACTION}${transaction.transactionID}`);
+                expect(rejectedTransaction?.reportID).toBe(iouReport.reportID);
+                expect(Object.values(rejectedTransaction?.errors ?? {})).toEqual([translateLocal('iou.rejectReport.couldNotRejectExpense')]);
+            });
+
+            it('should clear an earlier rejection error when the expense is rejected again', async () => {
+                if (!transaction?.transactionID || !iouReport?.reportID) {
+                    throw new Error('Required transaction or report data is missing');
+                }
+                await addSecondExpenseToReport();
+
+                // Given: The expense still shows the error left by an earlier failed reject
+                await Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${transaction.transactionID}`, {
+                    errors: {[ERROR_TIMESTAMP]: translateLocal('iou.rejectReport.couldNotRejectExpense')},
+                    errorFields: {reject: SERVER_REJECT_ERROR},
+                });
+                await waitForBatchedUpdates();
+
+                // When: Rejecting it again
+                rejectMoneyRequest(
+                    transaction.transactionID,
+                    iouReport.reportID,
+                    comment,
+                    policy,
+                    TEST_USER_ACCOUNT_ID,
+                    TEST_USER_EMAIL,
+                    [CONST.BETAS.ALL],
+                    undefined,
+                    getCurrencyDecimalsLocal,
+                );
+                await waitForBatchedUpdates();
+
+                // Then: The stale error is gone, so the retry does not show the previous failure
+                const rejectedTransaction = await getOnyxValue(`${ONYXKEYS.COLLECTION.TRANSACTION}${transaction.transactionID}`);
+                expect(rejectedTransaction?.errors).toBeFalsy();
+                expect(rejectedTransaction?.errorFields?.reject).toBeFalsy();
+            });
+
+            it('should drop the stale local copy of the expense when its reject error is dismissed', async () => {
+                if (!transaction?.transactionID) {
+                    throw new Error('Required transaction data is missing');
+                }
+
+                // Given: An expense the server reported as already moved
+                await Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${transaction.transactionID}`, {errorFields: {reject: SERVER_REJECT_ERROR}});
+                await waitForBatchedUpdates();
+
+                // When: The user dismisses the error
+                dismissRejectExpenseError(transaction.transactionID);
+                await waitForBatchedUpdates();
+
+                // Then: The expense is gone locally, so it stops showing on a report it is no longer on
+                const dismissedTransaction = await getOnyxValue(`${ONYXKEYS.COLLECTION.TRANSACTION}${transaction.transactionID}`);
+                expect(dismissedTransaction).toBeFalsy();
+            });
+        });
     });
 
     describe('rejectExpenseReport', () => {

tests/actions/TransactionTest.ts

@@ -30,7 +30,7 @@ import {format} from 'date-fns';
 import Onyx from 'react-native-onyx';
 import createRandomReportAction from 'tests/utils/collections/reportActions';
 
-import {changeTransactionsReport as changeTransactionsReportAction} from '../../src/libs/actions/Transaction';
+import {changeTransactionsReport as changeTransactionsReportAction, clearError} from '../../src/libs/actions/Transaction';
 import currencyList from '../unit/currencyList.json';
 import createPersonalDetails from '../utils/collections/personalDetails';
 import createRandomPolicy from '../utils/collections/policies';
@@ -192,6 +192,34 @@ describe('actions/Transaction', () => {
         jest.clearAllMocks();
     });
 
+    describe('clearError', () => {
+        it('should clear the reject error reported against an expense that had already moved', async () => {
+            const transactionID = 'transaction-with-reject-error';
+            const errorTimestamp = '1770000000000000';
+
+            // Given: An expense carrying a reject error from the server alongside an unrelated route error
+            await Onyx.set(`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`, {
+                transactionID,
+                errors: {[errorTimestamp]: 'Something went wrong'},
+                errorFields: {
+                    reject: {[errorTimestamp]: 'The expense has already been moved or rejected.'},
+                    route: {[errorTimestamp]: 'Route error'},
+                },
+            });
+            await waitForBatchedUpdates();
+
+            // When: The error is dismissed
+            clearError(transactionID);
+            await waitForBatchedUpdates();
+
+            // Then: The reject field is cleared along with the errors already covered
+            const transaction = await getOnyxValue(`${ONYXKEYS.COLLECTION.TRANSACTION}${transactionID}`);
+            expect(transaction?.errors).toBeFalsy();
+            expect(transaction?.errorFields?.reject).toBeFalsy();
+            expect(transaction?.errorFields?.route).toBeFalsy();
+        });
+    });
+
     describe('changeTransactionsReport', () => {
         it('should set the correct optimistic onyx data for reporting a tracked expense', async () => {
             let personalDetailsList: OnyxEntry<PersonalDetailsList>;

tests/ui/MoneyRequestReportTransactionItemRejectErrorTest.tsx

@@ -0,0 +1,153 @@
+import {act, fireEvent, render, screen} from '@testing-library/react-native';
+
+import ComposeProviders from '@components/ComposeProviders';
+import {LocaleContextProvider} from '@components/LocaleContextProvider';
+import MoneyRequestReportTransactionItem from '@components/MoneyRequestReportView/MoneyRequestReportTransactionItem';
+import OnyxListItemProvider from '@components/OnyxListItemProvider';
+import ScreenWrapper from '@components/ScreenWrapper';
+
+import CONST from '@src/CONST';
+import IntlStore from '@src/languages/IntlStore';
+import ONYXKEYS from '@src/ONYXKEYS';
+import type {Report} from '@src/types/onyx';
+import type Transaction from '@src/types/onyx/Transaction';
+
+import {PortalProvider} from '@gorhom/portal';
+import React from 'react';
+import Onyx from 'react-native-onyx';
+
+import createRandomTransaction from '../utils/collections/transaction';
+import getOnyxValue from '../utils/getOnyxValue';
+import {translateLocal} from '../utils/TestHelper';
+import waitForBatchedUpdatesWithAct from '../utils/waitForBatchedUpdatesWithAct';
+
+jest.mock('@react-navigation/native');
+
+const REPORT_ID = '12345';
+const TRANSACTION_ID = '67890';
+const ERROR_TIMESTAMP = '1770000000000000';
+
+// The exact copy Web-Expensify returns for this case (Web-Expensify/lib/ReportAPI.php). It is English-only,
+// so it must never reach the screen.
+const SERVER_REJECT_MESSAGE = 'The expense has already been moved or rejected.';
+
+const report: Report = {
+    reportID: REPORT_ID,
+    type: CONST.REPORT.TYPE.EXPENSE,
+    currency: CONST.CURRENCY.USD,
+    reportName: 'Test report',
+};
+
+function buildTransaction(overrides: Partial<Transaction> = {}): Transaction {
+    return {
+        ...createRandomTransaction(0),
+        transactionID: TRANSACTION_ID,
+        reportID: REPORT_ID,
+        amount: 1000,
+        currency: CONST.CURRENCY.USD,
+        merchant: 'Test Merchant',
+        ...overrides,
+    };
+}
+
+/** A transaction the server reported as already moved, which lands under its own `reject` error field. */
+function buildTransactionWithRejectError(): Transaction {
+    return buildTransaction({errorFields: {reject: {[ERROR_TIMESTAMP]: SERVER_REJECT_MESSAGE}}});
+}
+
+describe('MoneyRequestReportTransactionItem - reject errors', () => {
+    beforeAll(() => {
+        Onyx.init({keys: ONYXKEYS});
+        IntlStore.load(CONST.LOCALES.EN);
+        return waitForBatchedUpdatesWithAct();
+    });
+
+    afterEach(async () => {
+        await act(async () => {
+            await Onyx.clear();
+        });
+        jest.clearAllMocks();
+        await waitForBatchedUpdatesWithAct();
+    });
+
+    async function renderTransactionItem(transaction: Transaction, handleOnPress = jest.fn()) {
+        await act(async () => {
+            await Onyx.merge(`${ONYXKEYS.COLLECTION.REPORT}${REPORT_ID}`, report);
+            await Onyx.merge(`${ONYXKEYS.COLLECTION.TRANSACTION}${transaction.transactionID}`, transaction);
+        });
+        await waitForBatchedUpdatesWithAct();
+
+        render(
+            <ComposeProviders components={[OnyxListItemProvider, LocaleContextProvider]}>
+                <ScreenWrapper testID="test">
+                    <PortalProvider>
+                        <MoneyRequestReportTransactionItem
+                            transaction={transaction}
+                            violations={[]}
+                            report={report}
+                            policy={undefined}
+                            isSelectionModeEnabled={false}
+                            toggleTransaction={jest.fn()}
+                            handleOnPress={handleOnPress}
+                            handleLongPress={jest.fn()}
+                            isSelected={false}
+                            dateColumnSize={CONST.SEARCH.TABLE_COLUMN_SIZES.NORMAL}
+                            postedColumnSize={CONST.SEARCH.TABLE_COLUMN_SIZES.NORMAL}
+                            amountColumnSize={CONST.SEARCH.TABLE_COLUMN_SIZES.NORMAL}
+                            taxAmountColumnSize={CONST.SEARCH.TABLE_COLUMN_SIZES.NORMAL}
+                            columns={[CONST.SEARCH.TABLE_COLUMNS.MERCHANT, CONST.SEARCH.TABLE_COLUMNS.TOTAL_AMOUNT]}
+                            shouldBeHighlighted={false}
+                            nonPersonalAndWorkspaceCards={{}}
+                        />
+                    </PortalProvider>
+                </ScreenWrapper>
+            </ComposeProviders>,
+        );
+        await waitForBatchedUpdatesWithAct();
+
+        return {handleOnPress};
+    }
+
+    it('should show the translated copy instead of the English message the server sent', async () => {
+        // Given: An expense the server refused to reject because it had already moved
+        await renderTransactionItem(buildTransactionWithRejectError());
+
+        // Then: The user sees the app's own copy, not the untranslatable server string
+        expect(screen.getByText(translateLocal('iou.rejectReport.couldNotRejectExpense'))).toBeOnTheScreen();
+        expect(screen.queryByText(SERVER_REJECT_MESSAGE)).not.toBeOnTheScreen();
+    });
+
+    it('should not let the expense be opened while it carries a reject error', async () => {
+        // Given: An expense showing a reject error, so the server no longer has it on this report
+        await renderTransactionItem(buildTransactionWithRejectError());
+
+        // Then: The row cannot be opened, because the RHP would immediately dismiss itself
+        expect(screen.getByLabelText('View details')).toBeDisabled();
+    });
+
+    it('should still open an expense that has no reject error', async () => {
+        // Given: An ordinary expense
+        const {handleOnPress} = await renderTransactionItem(buildTransaction());
+
+        // When: The user presses the row
+        expect(screen.getByLabelText('View details')).toBeEnabled();
+        fireEvent.press(screen.getByLabelText('View details'));
+        await waitForBatchedUpdatesWithAct();
+
+        // Then: The expense opens as usual
+        expect(handleOnPress).toHaveBeenCalledWith(TRANSACTION_ID);
+    });
+
+    it('should drop the stale expense when the reject error is dismissed', async () => {
+        // Given: An expense left behind by a reject the server refused
+        await renderTransactionItem(buildTransactionWithRejectError());
+
+        // When: The user dismisses the error
+        fireEvent.press(screen.getByLabelText('Dismiss'));
+        await waitForBatchedUpdatesWithAct();
+
+        // Then: The stale local copy is gone, so it stops showing on a report it is no longer on
+        const transaction = await getOnyxValue(`${ONYXKEYS.COLLECTION.TRANSACTION}${TRANSACTION_ID}`);
+        expect(transaction).toBeFalsy();
+    });
+});