BuildOnyxDataForMoneyRequestTest.ts

import {buildOnyxDataForMoneyRequest} from '@libs/actions/IOU/MoneyRequestBuilder';
import {getOriginalMessage} from '@libs/ReportActionsUtils';
import type {OptimisticCreatedReportAction, OptimisticIOUReportAction} from '@libs/ReportUtils';

import CONST from '@src/CONST';
import ONYXKEYS from '@src/ONYXKEYS';
import type {Report, ReportAction, Transaction} from '@src/types/onyx';

import Onyx from 'react-native-onyx';

import {createSelfDM} from '../../utils/collections/reports';
import waitForBatchedUpdates from '../../utils/waitForBatchedUpdates';

jest.mock('@src/libs/Navigation/Navigation', () => ({
    navigate: jest.fn(),
    goBack: jest.fn(),
}));

const CURRENT_USER_ACCOUNT_ID = 1;
const CURRENT_USER_EMAIL = 'user@example.com';
const PAYER_ACCOUNT_ID = 2;
const SELF_DM_REPORT_ID = '100';
const CHAT_REPORT_ID = '200';
const IOU_REPORT_ID = '300';
const TRANSACTION_ID = 'transaction-111';
const IOU_ACTION_ID = 'action-222';
const CREATED_ACTION_ID = 'created-action-333';
const REPORT_PREVIEW_ACTION_ID = 'preview-action-444';
const THREAD_REPORT_ID = 'thread-555';

/* eslint-disable @typescript-eslint/no-unsafe-type-assertion */

function buildMockIouAction(iouReportID: string): OptimisticIOUReportAction {
    return {
        reportActionID: IOU_ACTION_ID,
        reportID: iouReportID,
        actionName: CONST.REPORT.ACTIONS.TYPE.IOU,
        actorAccountID: CURRENT_USER_ACCOUNT_ID,
        automatic: false,
        avatar: '',
        isAttachmentOnly: false,
        originalMessage: {
            amount: 1000,
            comment: 'Test split',
            currency: CONST.CURRENCY.USD,
            IOUTransactionID: TRANSACTION_ID,
            type: CONST.IOU.REPORT_ACTION_TYPE.CREATE,
        },
        message: undefined,
        person: [],
        shouldShow: true,
        created: '2024-01-01 00:00:00.000',
        pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
        receipt: undefined,
        childReportID: undefined,
        childVisibleActionCount: undefined,
        childCommenterCount: undefined,
        delegateAccountID: undefined,
    } as unknown as OptimisticIOUReportAction;
}

function buildMockCreatedAction(reportActionID: string): OptimisticCreatedReportAction {
    return {
        reportActionID,
        actionName: CONST.REPORT.ACTIONS.TYPE.CREATED,
        actorAccountID: CURRENT_USER_ACCOUNT_ID,
        automatic: false,
        avatar: '',
        created: '2024-01-01 00:00:00.000',
        message: undefined,
        person: [],
        shouldShow: true,
        pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
    } as unknown as OptimisticCreatedReportAction;
}

function buildMockReportPreviewAction(): ReportAction {
    return {
        reportActionID: REPORT_PREVIEW_ACTION_ID,
        actionName: CONST.REPORT.ACTIONS.TYPE.REPORT_PREVIEW,
        actorAccountID: CURRENT_USER_ACCOUNT_ID,
        created: '2024-01-01 00:00:00.000',
        shouldShow: true,
        pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
        message: undefined,
        person: [],
    } as unknown as ReportAction;
}

function buildMockTransaction(reportID: string): Transaction {
    return {
        transactionID: TRANSACTION_ID,
        reportID,
        amount: 1000,
        currency: CONST.CURRENCY.USD,
        created: '2024-01-01',
        merchant: 'Test Merchant',
        comment: {comment: ''},
        pendingAction: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD,
        pendingFields: {amount: CONST.RED_BRICK_ROAD_PENDING_ACTION.ADD},
    } as unknown as Transaction;
}

function buildMockIouReport(reportID: string, chatReportID: string): Report {
    return {
        reportID,
        type: CONST.REPORT.TYPE.IOU,
        chatReportID,
        currency: CONST.CURRENCY.USD,
        ownerAccountID: CURRENT_USER_ACCOUNT_ID,
        managerID: PAYER_ACCOUNT_ID,
        total: 1000,
        participants: {
            [CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.HIDDEN},
            [PAYER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.HIDDEN},
        },
    } as unknown as Report;
}

function buildMockChatReport(reportID: string): Report {
    return {
        reportID,
        type: CONST.REPORT.TYPE.CHAT,
        chatType: CONST.REPORT.CHAT_TYPE.POLICY_EXPENSE_CHAT,
        participants: {
            [CURRENT_USER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
            [PAYER_ACCOUNT_ID]: {notificationPreference: CONST.REPORT.NOTIFICATION_PREFERENCE.ALWAYS},
        },
    } as unknown as Report;
}

function buildMockThreadReport(reportID: string, parentReportID: string): Report {
    return {
        reportID,
        type: CONST.REPORT.TYPE.CHAT,
        parentReportID,
    } as unknown as Report;
}

type BuildOnyxDataParams = Parameters<typeof buildOnyxDataForMoneyRequest>[0];

function buildBaseOptimisticParams(iouReportID: string): BuildOnyxDataParams['optimisticParams'] {
    return {
        chat: {
            report: buildMockChatReport(CHAT_REPORT_ID),
            createdAction: buildMockCreatedAction(CREATED_ACTION_ID),
            reportPreviewAction: buildMockReportPreviewAction(),
        },
        iou: {
            report: buildMockIouReport(iouReportID, CHAT_REPORT_ID),
            createdAction: buildMockCreatedAction(`${CREATED_ACTION_ID}-iou`),
            action: buildMockIouAction(iouReportID),
        },
        transactionParams: {
            transaction: buildMockTransaction(iouReportID),
            transactionThreadReport: buildMockThreadReport(THREAD_REPORT_ID, iouReportID),
            transactionThreadCreatedReportAction: buildMockCreatedAction(`${CREATED_ACTION_ID}-thread`),
        },
        policyRecentlyUsed: {},
    };
}

describe('buildOnyxDataForMoneyRequest', () => {
    beforeAll(() => {
        Onyx.init({keys: ONYXKEYS});
        return waitForBatchedUpdates();
    });

    beforeEach(async () => {
        await Onyx.clear();
        await waitForBatchedUpdates();
    });

    describe('isSelfDMSplit behavior', () => {
        describe('when isSelfDMSplit=true and selfDMReportID is provided', () => {
            const selfDMReport = createSelfDM(Number(SELF_DM_REPORT_ID), CURRENT_USER_ACCOUNT_ID);

            function buildSelfDMParams(): BuildOnyxDataParams {
                return {
                    isNewChatReport: false,
                    shouldCreateNewMoneyRequestReport: false,
                    shouldGenerateTransactionThreadReport: true,
                    isASAPSubmitBetaEnabled: false,
                    currentUserAccountIDParam: CURRENT_USER_ACCOUNT_ID,
                    currentUserEmailParam: CURRENT_USER_EMAIL,
                    hasViolations: false,
                    quickAction: undefined,
                    isSelfDMSplit: true,
                    selfDMReportID: selfDMReport.reportID,
                    optimisticParams: buildBaseOptimisticParams(IOU_REPORT_ID),
                    delegateAccountID: undefined,
                    isTrackIntentUser: false,
                };
            }

            it('optimisticData sets transaction via SET', () => {
                const {optimisticData} = buildOnyxDataForMoneyRequest(buildSelfDMParams());
                const transactionEntry = optimisticData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.TRANSACTION}${TRANSACTION_ID}`);

                expect(transactionEntry).toBeDefined();
                expect(transactionEntry?.onyxMethod).toBe(Onyx.METHOD.SET);
            });

            it('optimisticData adds IOU action to selfDM report actions with type patched to TRACK', () => {
                const {optimisticData} = buildOnyxDataForMoneyRequest(buildSelfDMParams());
                const actionsEntry = optimisticData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${selfDMReport.reportID}`);

                expect(actionsEntry).toBeDefined();
                expect(actionsEntry?.onyxMethod).toBe(Onyx.METHOD.MERGE);

                const entryValue = actionsEntry?.value as Record<string, ReportAction>;
                const storedAction = entryValue?.[IOU_ACTION_ID] as ReportAction<typeof CONST.REPORT.ACTIONS.TYPE.IOU>;
                const originalMessage = getOriginalMessage(storedAction);

                expect(storedAction).toBeDefined();
                expect(originalMessage?.type).toBe(CONST.IOU.REPORT_ACTION_TYPE.TRACK);
                expect(storedAction?.reportID).toBe(selfDMReport.reportID);
            });

            it('optimisticData updates selfDM report lastVisibleActionCreated', () => {
                const {optimisticData} = buildOnyxDataForMoneyRequest(buildSelfDMParams());
                const reportEntry = optimisticData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT}${selfDMReport.reportID}`);

                expect(reportEntry).toBeDefined();
                expect(reportEntry?.onyxMethod).toBe(Onyx.METHOD.MERGE);
                expect((reportEntry?.value as Partial<Report>)?.lastVisibleActionCreated).toBeDefined();
            });

            it('optimisticData adds transaction thread report with parentReportID and chatReportID pointing to selfDM', () => {
                const {optimisticData} = buildOnyxDataForMoneyRequest(buildSelfDMParams());
                const threadEntry = optimisticData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT}${THREAD_REPORT_ID}`);

                expect(threadEntry).toBeDefined();
                expect((threadEntry?.value as Partial<Report>)?.parentReportID).toBe(selfDMReport.reportID);
                expect((threadEntry?.value as Partial<Report>)?.chatReportID).toBe(selfDMReport.reportID);
            });

            it('optimisticData does NOT add a standard IOU report entry', () => {
                const {optimisticData} = buildOnyxDataForMoneyRequest(buildSelfDMParams());
                const iouReportEntry = optimisticData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT}${IOU_REPORT_ID}`);

                expect(iouReportEntry).toBeUndefined();
            });

            it('optimisticData does NOT add a standard chat report entry', () => {
                const {optimisticData} = buildOnyxDataForMoneyRequest(buildSelfDMParams());
                const chatReportEntry = optimisticData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT}${CHAT_REPORT_ID}`);

                expect(chatReportEntry).toBeUndefined();
            });

            it('optimisticData does NOT add IOU report actions', () => {
                const {optimisticData} = buildOnyxDataForMoneyRequest(buildSelfDMParams());
                const iouActionsEntry = optimisticData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${IOU_REPORT_ID}`);

                expect(iouActionsEntry).toBeUndefined();
            });

            it('successData clears transaction pendingAction and pendingFields', () => {
                const {successData} = buildOnyxDataForMoneyRequest(buildSelfDMParams());
                const transactionEntry = successData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.TRANSACTION}${TRANSACTION_ID}`);

                expect(transactionEntry).toBeDefined();
                expect((transactionEntry?.value as Partial<Transaction>)?.pendingAction).toBeNull();
                expect((transactionEntry?.value as Partial<Transaction>)?.pendingFields).toBeDefined();
            });

            it('successData clears IOU action pending state in selfDM report', () => {
                const {successData} = buildOnyxDataForMoneyRequest(buildSelfDMParams());
                const actionsEntry = successData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${selfDMReport.reportID}`);

                expect(actionsEntry).toBeDefined();
                const entryValue = actionsEntry?.value as Record<string, Partial<ReportAction>>;
                const storedAction = entryValue?.[IOU_ACTION_ID];
                expect(storedAction?.pendingAction).toBeNull();
                expect(storedAction?.errors).toBeNull();
                expect(storedAction?.isOptimisticAction).toBeNull();
            });

            it('successData does NOT include standard IOU report success entry', () => {
                const {successData} = buildOnyxDataForMoneyRequest(buildSelfDMParams());
                const iouReportEntry = successData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT}${IOU_REPORT_ID}`);

                expect(iouReportEntry).toBeUndefined();
            });

            it('successData does NOT include standard chat report success entry', () => {
                const {successData} = buildOnyxDataForMoneyRequest(buildSelfDMParams());
                const chatReportEntry = successData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT}${CHAT_REPORT_ID}`);

                expect(chatReportEntry).toBeUndefined();
            });

            it('failureData sets error on transaction', () => {
                const {failureData} = buildOnyxDataForMoneyRequest(buildSelfDMParams());
                const transactionEntry = failureData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.TRANSACTION}${TRANSACTION_ID}`);

                expect(transactionEntry).toBeDefined();
                expect((transactionEntry?.value as Partial<Transaction>)?.errors).toBeDefined();
            });

            it('failureData sets error on IOU action in selfDM report', () => {
                const {failureData} = buildOnyxDataForMoneyRequest(buildSelfDMParams());
                const actionsEntry = failureData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${selfDMReport.reportID}`);

                expect(actionsEntry).toBeDefined();
                const entryValue = actionsEntry?.value as Record<string, Partial<ReportAction>>;
                const storedAction = entryValue?.[IOU_ACTION_ID];
                expect(storedAction?.errors).toBeDefined();
            });

            it('failureData does NOT include standard chat report failure entry', () => {
                const {failureData} = buildOnyxDataForMoneyRequest(buildSelfDMParams());
                const chatReportEntry = failureData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT}${CHAT_REPORT_ID}`);

                expect(chatReportEntry).toBeUndefined();
            });
        });

        describe('when isSelfDMSplit=false (standard flow)', () => {
            function buildStandardParams(): BuildOnyxDataParams {
                return {
                    isNewChatReport: false,
                    shouldCreateNewMoneyRequestReport: false,
                    shouldGenerateTransactionThreadReport: false,
                    isASAPSubmitBetaEnabled: false,
                    currentUserAccountIDParam: CURRENT_USER_ACCOUNT_ID,
                    currentUserEmailParam: CURRENT_USER_EMAIL,
                    hasViolations: false,
                    quickAction: undefined,
                    isSelfDMSplit: false,
                    optimisticParams: buildBaseOptimisticParams(IOU_REPORT_ID),
                    delegateAccountID: undefined,
                    isTrackIntentUser: false,
                };
            }

            it('optimisticData includes IOU report entry', () => {
                const {optimisticData} = buildOnyxDataForMoneyRequest(buildStandardParams());
                const iouReportEntry = optimisticData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT}${IOU_REPORT_ID}`);

                expect(iouReportEntry).toBeDefined();
            });

            it('optimisticData includes chat report entry', () => {
                const {optimisticData} = buildOnyxDataForMoneyRequest(buildStandardParams());
                const chatReportEntry = optimisticData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT}${CHAT_REPORT_ID}`);

                expect(chatReportEntry).toBeDefined();
            });

            it('optimisticData does NOT add an IOU action to selfDM report', () => {
                const {optimisticData} = buildOnyxDataForMoneyRequest(buildStandardParams());
                const selfDMActionsEntry = optimisticData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${SELF_DM_REPORT_ID}`);

                expect(selfDMActionsEntry).toBeUndefined();
            });
        });

        describe('when isSelfDMSplit=true but selfDMReportID is undefined', () => {
            function buildNoSelfDMReportIDParams(): BuildOnyxDataParams {
                return {
                    isNewChatReport: false,
                    shouldCreateNewMoneyRequestReport: false,
                    shouldGenerateTransactionThreadReport: false,
                    isASAPSubmitBetaEnabled: false,
                    currentUserAccountIDParam: CURRENT_USER_ACCOUNT_ID,
                    currentUserEmailParam: CURRENT_USER_EMAIL,
                    hasViolations: false,
                    quickAction: undefined,
                    isSelfDMSplit: true,
                    selfDMReportID: undefined,
                    optimisticParams: buildBaseOptimisticParams(IOU_REPORT_ID),
                    delegateAccountID: undefined,
                    isTrackIntentUser: false,
                };
            }

            it('falls back to standard flow and includes IOU report entry', () => {
                const {optimisticData} = buildOnyxDataForMoneyRequest(buildNoSelfDMReportIDParams());
                const iouReportEntry = optimisticData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT}${IOU_REPORT_ID}`);

                expect(iouReportEntry).toBeDefined();
            });

            it('does NOT add IOU action to selfDM report when selfDMReportID is undefined', () => {
                const {optimisticData} = buildOnyxDataForMoneyRequest(buildNoSelfDMReportIDParams());
                const selfDMActionsEntry = optimisticData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT_ACTIONS}${SELF_DM_REPORT_ID}`);

                expect(selfDMActionsEntry).toBeUndefined();
            });
        });
    });

    describe('chatReport.iouReportID update behavior', () => {
        const OTHER_OPEN_REPORT_ID = '999';

        function buildParamsWithCreateFlag(shouldCreateNewMoneyRequestReport: boolean, iouReportIDOverride?: string | null): BuildOnyxDataParams {
            const optimisticParams = buildBaseOptimisticParams(IOU_REPORT_ID);

            return {
                isNewChatReport: false,
                shouldCreateNewMoneyRequestReport,
                shouldGenerateTransactionThreadReport: false,
                isASAPSubmitBetaEnabled: false,
                currentUserAccountIDParam: CURRENT_USER_ACCOUNT_ID,
                currentUserEmailParam: CURRENT_USER_EMAIL,
                hasViolations: false,
                quickAction: undefined,
                isSelfDMSplit: false,
                optimisticParams: {
                    ...optimisticParams,
                    chat: {
                        ...optimisticParams.chat,
                        report: {
                            ...optimisticParams.chat.report,
                            ...(iouReportIDOverride !== undefined ? {iouReportID: iouReportIDOverride} : {}),
                        } as Report,
                    },
                },
                delegateAccountID: undefined,
                isTrackIntentUser: false,
            };
        }

        function getChatReportOptimisticEntry(optimisticData: ReturnType<typeof buildOnyxDataForMoneyRequest>['optimisticData']) {
            return optimisticData?.find((entry) => entry.key === `${ONYXKEYS.COLLECTION.REPORT}${CHAT_REPORT_ID}`);
        }

        it('sets iouReportID on chat report when shouldCreateNewMoneyRequestReport is true', () => {
            const {optimisticData} = buildOnyxDataForMoneyRequest(buildParamsWithCreateFlag(true));
            const chatReportEntry = getChatReportOptimisticEntry(optimisticData);

            expect(chatReportEntry).toBeDefined();
            expect((chatReportEntry?.value as Partial<Report>)?.iouReportID).toBe(IOU_REPORT_ID);
        });

        it('does not update iouReportID when shouldCreateNewMoneyRequestReport is false', () => {
            const {optimisticData} = buildOnyxDataForMoneyRequest(buildParamsWithCreateFlag(false, null));
            const chatReportEntry = getChatReportOptimisticEntry(optimisticData);

            expect(chatReportEntry).toBeDefined();
            expect((chatReportEntry?.value as Partial<Report>)?.iouReportID).toBeNull();
        });

        it('preserves existing iouReportID when adding expense to a different existing report', () => {
            const {optimisticData} = buildOnyxDataForMoneyRequest(buildParamsWithCreateFlag(false, OTHER_OPEN_REPORT_ID));
            const chatReportEntry = getChatReportOptimisticEntry(optimisticData);

            expect(chatReportEntry).toBeDefined();
            expect((chatReportEntry?.value as Partial<Report>)?.iouReportID).toBe(OTHER_OPEN_REPORT_ID);
        });

        it('does not update iouReportID when isASAPSubmitBetaEnabled and transaction is a scan request', () => {
            const optimisticParams = buildBaseOptimisticParams(IOU_REPORT_ID);
            const params: BuildOnyxDataParams = {
                ...buildParamsWithCreateFlag(true),
                isASAPSubmitBetaEnabled: true,
                optimisticParams: {
                    ...optimisticParams,
                    transactionParams: {
                        ...optimisticParams.transactionParams,
                        transaction: {
                            ...optimisticParams.transactionParams.transaction,
                            iouRequestType: CONST.IOU.REQUEST_TYPE.SCAN,
                        },
                    },
                },
            };

            const {optimisticData} = buildOnyxDataForMoneyRequest(params);
            const chatReportEntry = getChatReportOptimisticEntry(optimisticData);

            expect(chatReportEntry).toBeDefined();
            expect((chatReportEntry?.value as Partial<Report>)?.iouReportID).toBeUndefined();
        });
    });

    describe('failure handling for a brand-new chat', () => {
        function buildNewChatParams(overrides?: Partial<BuildOnyxDataParams>): BuildOnyxDataParams {
            return {
                isNewChatReport: true,
                shouldCreateNewMoneyRequestReport: true,
                shouldGenerateTransactionThreadReport: true,
                isASAPSubmitBetaEnabled: false,
                currentUserAccountIDParam: CURRENT_USER_ACCOUNT_ID,
                currentUserEmailParam: CURRENT_USER_EMAIL,
                hasViolations: false,
                quickAction: undefined,
                isSelfDMSplit: false,
                optimisticParams: buildBaseOptimisticParams(IOU_REPORT_ID),
                delegateAccountID: undefined,
                isTrackIntentUser: false,
                ...overrides,
            };
        }

        function findFailureEntry(failureData: ReturnType<typeof buildOnyxDataForMoneyRequest>['failureData'], key: string) {
            return failureData?.find((entry) => entry.key === key);
        }

        it('keeps the failed expense visible by MERGE-ing createChat errors onto the new chat and IOU reports instead of deleting them', () => {
            const {failureData} = buildOnyxDataForMoneyRequest(buildNewChatParams());

            const chatReportEntry = findFailureEntry(failureData, `${ONYXKEYS.COLLECTION.REPORT}${CHAT_REPORT_ID}`);
            const iouReportEntry = findFailureEntry(failureData, `${ONYXKEYS.COLLECTION.REPORT}${IOU_REPORT_ID}`);

            expect(chatReportEntry?.onyxMethod).toBe(Onyx.METHOD.MERGE);
            expect((chatReportEntry?.value as Partial<Report>)?.errorFields?.createChat).toBeDefined();
            expect(iouReportEntry?.onyxMethod).toBe(Onyx.METHOD.MERGE);
            expect((iouReportEntry?.value as Partial<Report>)?.errorFields?.createChat).toBeDefined();
        });

        it('resets the new chat and IOU report metadata to non-optimistic so the chat is not stuck on an infinite loading skeleton', () => {
            const {failureData} = buildOnyxDataForMoneyRequest(buildNewChatParams());

            const chatMetadataEntry = findFailureEntry(failureData, `${ONYXKEYS.COLLECTION.REPORT_METADATA}${CHAT_REPORT_ID}`);
            const iouMetadataEntry = findFailureEntry(failureData, `${ONYXKEYS.COLLECTION.REPORT_METADATA}${IOU_REPORT_ID}`);

            expect(chatMetadataEntry?.onyxMethod).toBe(Onyx.METHOD.MERGE);
            expect((chatMetadataEntry?.value as {isOptimisticReport?: boolean})?.isOptimisticReport).toBe(false);
            expect(iouMetadataEntry?.onyxMethod).toBe(Onyx.METHOD.MERGE);
            expect((iouMetadataEntry?.value as {isOptimisticReport?: boolean})?.isOptimisticReport).toBe(false);
        });

        it('does not SET any of the new-chat entities to null on failure (rollback happens on dismiss, not on failure)', () => {
            const {failureData} = buildOnyxDataForMoneyRequest(buildNewChatParams());

            const keys = [
                `${ONYXKEYS.COLLECTION.REPORT}${CHAT_REPORT_ID}`,
                `${ONYXKEYS.COLLECTION.REPORT}${IOU_REPORT_ID}`,
                `${ONYXKEYS.COLLECTION.TRANSACTION}${TRANSACTION_ID}`,
                `${ONYXKEYS.COLLECTION.REPORT}${THREAD_REPORT_ID}`,
            ];

            for (const key of keys) {
                const entry = findFailureEntry(failureData, key);
                expect(entry).toBeDefined();
                expect(entry?.value).not.toBeNull();
            }
        });

        it('does not reset report metadata when the expense is added to an existing chat and IOU report', () => {
            const {failureData} = buildOnyxDataForMoneyRequest(
                buildNewChatParams({
                    isNewChatReport: false,
                    shouldCreateNewMoneyRequestReport: false,
                }),
            );

            const chatMetadataEntry = findFailureEntry(failureData, `${ONYXKEYS.COLLECTION.REPORT_METADATA}${CHAT_REPORT_ID}`);
            const iouMetadataEntry = findFailureEntry(failureData, `${ONYXKEYS.COLLECTION.REPORT_METADATA}${IOU_REPORT_ID}`);

            expect(chatMetadataEntry).toBeUndefined();
            expect(iouMetadataEntry).toBeUndefined();
        });

        it('keeps the standard error-merge behavior when the expense is added to an existing chat and IOU report (retryable)', () => {
            const {failureData} = buildOnyxDataForMoneyRequest(
                buildNewChatParams({
                    isNewChatReport: false,
                    shouldCreateNewMoneyRequestReport: false,
                }),
            );

            const chatReportEntry = findFailureEntry(failureData, `${ONYXKEYS.COLLECTION.REPORT}${CHAT_REPORT_ID}`);
            const iouReportEntry = findFailureEntry(failureData, `${ONYXKEYS.COLLECTION.REPORT}${IOU_REPORT_ID}`);

            expect(chatReportEntry?.onyxMethod).toBe(Onyx.METHOD.MERGE);
            expect(chatReportEntry?.value).not.toBeNull();
            expect(iouReportEntry?.onyxMethod).toBe(Onyx.METHOD.MERGE);
            expect(iouReportEntry?.value).not.toBeNull();
        });
    });
});