Create unit tests to cover the `sortReportsToDisplayInLHN()` function

[tgolen]

Coming from #67399 (comment), there needs to be some unit tests created for this method.

Issue Owner

Current Issue Owner: @shubham1206agra

[melvin-bot]

Triggered auto assignment to @lschurr (Bug), see https://stackoverflow.com/c/expensify/questions/14418 for more details. Please add this bug to a GH project, as outlined in the SO.

[nabi-ebrahimi]

Proposal

Please re-state the problem that we are trying to solve in this issue.

Create unit tests to cover the sortReportsToDisplayInLHN() function

What is the root cause of that problem?

Improvement

What changes do you think we should make in order to solve the problem?

We need to implement unit tests for sortReportsToDisplayInLHN in ReportUtilsTest

jest.mock('@libs/Performance', () => ({
    markStart: jest.fn(),
    markEnd: jest.fn(),
}));

jest.mock('@libs/ReportUtils', () => {
    const actual = jest.requireActual('@libs/ReportUtils');
    return {
        ...actual,
        hasValidDraftComment: jest.fn().mockImplementation((reportID) => reportID === '3'),
        isArchivedNonExpenseReport: jest.fn().mockImplementation((report, isArchived) => isArchived),
    };
});

describe('sortReportsToDisplayInLHN', () => {
    const currentUserEmail = 'test@vikings.net';
    const currentUserAccountID = 5;

    const personalDetails = {
        '1': {
            accountID: 1,
            displayName: 'Ragnar Lothbrok',
            login: 'ragnar@vikings.net',
        },
        '2': {
            accountID: 2,
            displayName: 'Floki',
            login: 'floki@vikings.net',
        },
        '3': {
            accountID: 3,
            displayName: 'Lagertha Lothbrok',
            login: 'lagertha@vikings.net',
        },
        '4': {
            accountID: 4,
            displayName: 'Bjorn Ironside',
            login: 'bjorn@vikings.net',
        },
        '5': {
            accountID: 5,
            displayName: 'Test User',
            login: 'test@vikings.net',
        },
    };

    const reports: ReportsToDisplayInLHN = {
        report_1: {
            reportID: '1',
            isPinned: true,
            lastVisibleActionCreated: '2023-07-01 10:00:00.000',
            participants: {[currentUserAccountID]: {}, '1': {}},
        },
        report_2: {
            reportID: '2',
            hasErrorsOtherThanFailedReceipt: true,
            lastVisibleActionCreated: '2023-07-02 10:00:00.000',
            participants: {[currentUserAccountID]: {}, '2': {}},
        },
        report_3: {
            reportID: '3',
            lastVisibleActionCreated: '2023-07-03 10:00:00.000',
            participants: {[currentUserAccountID]: {}, '3': {}},
        },
        report_4: {
            reportID: '4',
            lastVisibleActionCreated: '2023-07-04 10:00:00.000',
            participants: {[currentUserAccountID]: {}, '4': {}},
        },
        report_5: {
            reportID: '5',
            lastVisibleActionCreated: '2023-07-05 10:00:00.000',
            participants: {[currentUserAccountID]: {}, '1': {}},
        },
    };

    const reportNameValuePairs: OnyxCollection<ReportNameValuePairs> = {
        [`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}5`]: {
            private_isArchived: DateUtils.getDBTime(),
        },
    };

    const reportAttributes: ReportAttributesDerivedValue['reports'] = {
        '1': {requiresAttention: true},
        '2': {requiresAttention: false},
        '3': {requiresAttention: false},
        '4': {requiresAttention: false},
        '5': {requiresAttention: false},
    };

    beforeAll(() => {
        Onyx.init({keys: ONYXKEYS});
        Onyx.multiSet({
            [ONYXKEYS.PERSONAL_DETAILS_LIST]: personalDetails,
            [ONYXKEYS.SESSION]: {email: currentUserEmail, accountID: currentUserAccountID},
            [ONYXKEYS.COLLECTION.REPORT]: reports,
            [ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS]: reportNameValuePairs,
        });
        return waitForBatchedUpdates();
    });

    beforeEach(() => {
        jest.clearAllMocks();
    });

    describe('in Default Mode', () => {
        it('should sort reports correctly with pinned, error, draft, non-archived, and archived groups', async () => {
            const result = sortReportsToDisplayInLHN(reports, CONST.PRIORITY_MODE.DEFAULT, reportNameValuePairs, reportAttributes);

            expect(result).toEqual(['1', '2', '3', '4', '5']);
        });

        it('should sort non-archived reports by lastVisibleActionCreated in descending order', async () => {
            const nonArchivedReports = Object.values(reports).filter(
                (report) =>
                    !report.isPinned &&
                    !report.hasErrorsOtherThanFailedReceipt &&
                    !hasValidDraftComment(report.reportID) &&
                    !isArchivedNonExpenseReport(report, !!reportNameValuePairs?.[`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${report.reportID}`]?.private_isArchived),
            );
            const sortedNonArchived = nonArchivedReports.sort((a, b) =>
                a.lastVisibleActionCreated && b.lastVisibleActionCreated
                    ? DateUtils.compareStringDates(b.lastVisibleActionCreated, a.lastVisibleActionCreated)
                    : localeCompare(getReportName(a), getReportName(b)),
            );
            const expectedNonArchivedIDs = sortedNonArchived.map((report) => report.reportID);

            const result = sortReportsToDisplayInLHN(reports, CONST.PRIORITY_MODE.DEFAULT, reportNameValuePairs, reportAttributes);
            const nonArchivedResult = result.filter((id) => ['4'].includes(id));

            expect(nonArchivedResult).toEqual(expectedNonArchivedIDs);
        });

        it('should sort archived reports by lastVisibleActionCreated in descending order', async () => {
            const archivedReports = Object.values(reports).filter((report) =>
                isArchivedNonExpenseReport(report, !!reportNameValuePairs?.[`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${report.reportID}`]?.private_isArchived),
            );
            const sortedArchived = archivedReports.sort((a, b) =>
                a.lastVisibleActionCreated && b.lastVisibleActionCreated ? DateUtils.compareStringDates(b.lastVisibleActionCreated, a.lastVisibleActionCreated) : 0,
            );
            const expectedArchivedIDs = sortedArchived.map((report) => report.reportID);

            const result = sortReportsToDisplayInLHN(reports, CONST.PRIORITY_MODE.DEFAULT, reportNameValuePairs, reportAttributes);
            const archivedResult = result.filter((id) => ['5'].includes(id));

            expect(archivedResult).toEqual(expectedArchivedIDs);
        });
    });

    describe('in Focus Mode', () => {
        it('should sort reports correctly with pinned, error, draft, non-archived, and archived groups', async () => {
            const result = sortReportsToDisplayInLHN(reports, CONST.PRIORITY_MODE.GSD, reportNameValuePairs, reportAttributes);

            expect(result).toEqual(['1', '2', '3', '4', '5']);
        });

        it('should sort non-archived reports by displayName', async () => {
            const nonArchivedReports = Object.values(reports).filter(
                (report) =>
                    !report.isPinned &&
                    !report.hasErrorsOtherThanFailedReceipt &&
                    !hasValidDraftComment(report.reportID) &&
                    !isArchivedNonExpenseReport(report, !!reportNameValuePairs?.[`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${report.reportID}`]?.private_isArchived),
            );
            const sortedNonArchived = nonArchivedReports.sort((a, b) => localeCompare(getReportName(a), getReportName(b)));
            const expectedNonArchivedIDs = sortedNonArchived.map((report) => report.reportID);

            const result = sortReportsToDisplayInLHN(reports, CONST.PRIORITY_MODE.GSD, reportNameValuePairs, reportAttributes);
            const nonArchivedResult = result.filter((id) => ['4'].includes(id));

            expect(nonArchivedResult).toEqual(expectedNonArchivedIDs);
        });

        it('should sort archived reports by displayName', async () => {
            const archivedReports = Object.values(reports).filter((report) =>
                isArchivedNonExpenseReport(report, !!reportNameValuePairs?.[`${ONYXKEYS.COLLECTION.REPORT_NAME_VALUE_PAIRS}${report.reportID}`]?.private_isArchived),
            );
            const sortedArchived = archivedReports.sort((a, b) => localeCompare(getReportName(a), getReportName(b)));
            const expectedArchivedIDs = sortedArchived.map((report) => report.reportID);

            const result = sortReportsToDisplayInLHN(reports, CONST.PRIORITY_MODE.GSD, reportNameValuePairs, reportAttributes);
            const archivedResult = result.filter((id) => ['5'].includes(id));

            expect(archivedResult).toEqual(expectedArchivedIDs);
        });
    });

    it('should sort pinned and GBR reports by displayName', async () => {
        const pinnedAndGBRReports = Object.values(reports).filter(
            (report) => report.isPinned || reportAttributes?.[report.reportID]?.requiresAttention,
        );
        const sortedPinnedAndGBR = pinnedAndGBRReports.sort((a, b) => localeCompare(getReportName(a), getReportName(b)));
        const expectedPinnedAndGBRIDs = sortedPinnedAndGBR.map((report) => report.reportID);

        const result = sortReportsToDisplayInLHN(reports, CONST.PRIORITY_MODE.DEFAULT, reportNameValuePairs, reportAttributes);
        const pinnedAndGBRResult = result.filter((id) => ['1'].includes(id));

        expect(pinnedAndGBRResult).toEqual(expectedPinnedAndGBRIDs);
    });

    it('should sort error reports by displayName', async () => {
        const errorReports = Object.values(reports).filter((report) => report.hasErrorsOtherThanFailedReceipt);
        const sortedErrorReports = errorReports.sort((a, b) => localeCompare(getReportName(a), getReportName(b)));
        const expectedErrorIDs = sortedErrorReports.map((report) => report.reportID);

        const result = sortReportsToDisplayInLHN(reports, CONST.PRIORITY_MODE.DEFAULT, reportNameValuePairs, reportAttributes);
        const errorResult = result.filter((id) => ['2'].includes(id));

        expect(errorResult).toEqual(expectedErrorIDs);
    });

    it('should sort draft reports by displayName', async () => {
        const draftReports = Object.values(reports).filter((report) => hasValidDraftComment(report.reportID));
        const sortedDraftReports = draftReports.sort((a, b) => localeCompare(getReportName(a), getReportName(b)));
        const expectedDraftIDs = sortedDraftReports.map((report) => report.reportID);

        const result = sortReportsToDisplayInLHN(reports, CONST.PRIORITY_MODE.DEFAULT, reportNameValuePairs, reportAttributes);
        const draftResult = result.filter((id) => ['3'].includes(id));

        expect(draftResult).toEqual(expectedDraftIDs);
    });

    it('should handle missing report properties gracefully', async () => {
        const reportsWithMissingProps: ReportsToDisplayInLHN = {
            report_6: {
                reportID: '6',
            },
        };

        await Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT, reportsWithMissingProps);

        const result = sortReportsToDisplayInLHN(reportsWithMissingProps, CONST.PRIORITY_MODE.DEFAULT, reportNameValuePairs, reportAttributes);

        expect(result).toEqual(['6']);
    });

    it('should filter out undefined reportIDs', async () => {
        const reportsWithUndefined: ReportsToDisplayInLHN = {
            report_undefined: {
                lastVisibleActionCreated: '2023-07-06 10:00:00.000',
                participants: {[currentUserAccountID]: {}, '1': {}},
            },
            report_1: reports.report_1,
        };

        await Onyx.mergeCollection(ONYXKEYS.COLLECTION.REPORT, reportsWithUndefined);

        const result = sortReportsToDisplayInLHN(reportsWithUndefined, CONST.PRIORITY_MODE.DEFAULT, reportNameValuePairs, reportAttributes);

        expect(result).toEqual(['1']);
    });
});

What specific scenarios should we cover in automated tests to prevent reintroducing this issue in the future?

None

What alternative solutions did you explore? (Optional)

[lschurr]

Hi @tgolen @shubham1206agra @DylanDylann are we looking for proposals on this one? Who is the C+ that will review them?

[shubham1206agra]

We are not looking for proposals