emberflow 1.3.74 → 1.3.77

package/lib/tests/index.test.js

@@ -33,6 +33,8 @@ const paths = __importStar(require("../utils/paths"));
 const adminClient = __importStar(require("emberflow-admin-client/lib"));
 var Timestamp = firebase_admin_1.firestore.Timestamp;
 const index_utils_1 = require("../index-utils");
+const distribution = __importStar(require("../utils/distribution"));
+var FieldValue = firebase_admin_1.firestore.FieldValue;
 const projectConfig = {
     projectId: "your-project-id",
     budgetAlertTopicName: "budget-alerts",
@@ -54,8 +56,9 @@ const getMock = {
     data: dataMock,
 };
 const updateMock = jest.fn();
+const setMock = jest.fn();
 const docMock = {
-    set: jest.fn(),
+    set: setMock,
     get: jest.fn().mockResolvedValue(getMock),
     update: updateMock,
     collection: jest.fn(() => collectionMock),
@@ -63,11 +66,21 @@ const docMock = {
 const collectionMock = {
     doc: jest.fn(() => docMock),
 };
+const transactionGetMock = jest.fn();
+const transactionSetMock = jest.fn();
+const transactionUpdateMock = jest.fn();
+const transactionMock = {
+    get: transactionGetMock,
+    set: transactionSetMock,
+    update: transactionUpdateMock,
+    delete: jest.fn(),
+};
 jest.spyOn(admin, "firestore")
     .mockImplementation(() => {
     return {
         collection: jest.fn(() => collectionMock),
         doc: jest.fn(() => docMock),
+        runTransaction: jest.fn((fn) => fn(transactionMock)),
     };
 });
 jest.spyOn(admin, "database")
@@ -78,8 +91,9 @@ jest.spyOn(admin, "database")
 });
 admin.initializeApp();
 (0, index_1.initializeEmberFlow)(projectConfig, admin, db_structure_1.dbStructure, db_structure_1.Entity, {}, {}, []);
+const refUpdateMock = jest.fn();
 const refMock = {
-    update: jest.fn(),
+    update: refUpdateMock,
 };
 function createDocumentSnapshot(form) {
     return {
@@ -121,6 +135,41 @@ describe("onFormSubmit", () => {
             nestedField2: "oldValue",
         },
     };
+    const equation = "totalTodos = notStartedCount + inProgressCount + toVerifyCount + requestChangesCount + doneCount";
+    const now = Timestamp.fromDate(new Date());
+    const journalEntry = {
+        date: now,
+        ledgerEntries: [
+            {
+                account: "totalTodos",
+                debit: 1,
+                credit: 0,
+            },
+            {
+                account: "notStartedCount",
+                debit: 0,
+                credit: 1,
+            },
+        ],
+        equation: equation,
+    };
+    const recordedJournalEntry = {
+        date: now,
+        ledgerEntries: [
+            {
+                account: "inProgressCount",
+                debit: 1,
+                credit: 0,
+            },
+            {
+                account: "doneCount",
+                debit: 0,
+                credit: 1,
+            },
+        ],
+        equation: equation,
+        recordEntry: true,
+    };
     beforeEach(() => {
         jest.spyOn(index_1._mockable, "createNowTimestamp").mockReturnValue(Timestamp.now());
         jest.spyOn(console, "log").mockImplementation();
@@ -131,6 +180,14 @@ describe("onFormSubmit", () => {
         });
         refMock.update.mockReset();
         updateMock.mockReset();
+        transactionGetMock.mockResolvedValue({
+            data: () => ({
+                totalTodos: 3,
+                notStartedCount: 1,
+                inProgressCount: 1,
+                doneCount: 1,
+            }),
+        });
     });
     afterEach(() => {
         jest.restoreAllMocks();
@@ -495,7 +552,326 @@ describe("onFormSubmit", () => {
         docMock.set.mockReset();
         docMock.update.mockReset();
     });
+    it("should write journal entries first", async () => {
+        const consoleErrorSpy = jest.spyOn(console, "error").mockImplementation();
+        const consoleInfoSpy = jest.spyOn(console, "info").mockImplementation();
+        jest.spyOn(indexutils, "runBusinessLogics").mockImplementation(async (actionRef, action, distributeFn) => {
+            await distributeFn(actionRef, logicResults, 0);
+            return "done";
+        });
+        let logicResults = [
+            {
+                name: "logic 1",
+                timeFinished: index_1._mockable.createNowTimestamp(),
+                status: "finished",
+                documents: [
+                    { action: "merge", priority: "normal", dstPath: "path1/doc1" },
+                ],
+            },
+        ];
+        const docPath = "users/user-1";
+        const form = {
+            "formData": JSON.stringify({
+                "@actionType": "create",
+                "name": "test",
+                "@docPath": docPath,
+            }),
+            "@status": "submit",
+        };
+        const event = createEvent(form);
+        await (0, index_1.onFormSubmit)(event);
+        expect(consoleInfoSpy).toHaveBeenCalledWith("No journal entries to write");
+        expect(transactionUpdateMock).not.toHaveBeenCalled();
+        expect(transactionSetMock).not.toHaveBeenCalled();
+        expect(transactionGetMock).not.toHaveBeenCalled();
+        logicResults = [
+            {
+                name: "logic 1",
+                timeFinished: index_1._mockable.createNowTimestamp(),
+                status: "finished",
+                documents: [
+                    { action: "merge", priority: "normal", dstPath: "", journalEntries: [journalEntry] },
+                ],
+            },
+        ];
+        await (0, index_1.onFormSubmit)(event);
+        expect(consoleErrorSpy).toHaveBeenCalledWith("Dst path has no docId");
+        expect(transactionUpdateMock).not.toHaveBeenCalled();
+        expect(transactionSetMock).not.toHaveBeenCalled();
+        expect(transactionGetMock).not.toHaveBeenCalled();
+        logicResults = [
+            {
+                name: "logic 1",
+                timeFinished: index_1._mockable.createNowTimestamp(),
+                status: "finished",
+                documents: [
+                    { action: "merge", priority: "high", dstPath: "path1/doc5", doc: { totalTodos: 1 }, journalEntries: [journalEntry] },
+                ],
+            },
+        ];
+        await (0, index_1.onFormSubmit)(event);
+        expect(consoleErrorSpy).toHaveBeenCalledWith("Doc cannot have keys that are the same as account names");
+        expect(transactionUpdateMock).not.toHaveBeenCalled();
+        expect(transactionSetMock).not.toHaveBeenCalled();
+        expect(transactionGetMock).not.toHaveBeenCalled();
+        logicResults = [
+            {
+                name: "logic 1",
+                timeFinished: index_1._mockable.createNowTimestamp(),
+                status: "finished",
+                documents: [
+                    { action: "merge", priority: "high", dstPath: "path1/doc5", instructions: { totalTodos: "+1" }, journalEntries: [journalEntry] },
+                ],
+            },
+        ];
+        await (0, index_1.onFormSubmit)(event);
+        expect(consoleErrorSpy).toHaveBeenCalledWith("Instructions cannot have keys that are the same as account names");
+        expect(transactionUpdateMock).not.toHaveBeenCalled();
+        expect(transactionSetMock).not.toHaveBeenCalled();
+        expect(transactionGetMock).not.toHaveBeenCalled();
+        const unbalancedJournalEntry = {
+            date: index_1._mockable.createNowTimestamp(),
+            ledgerEntries: [
+                {
+                    account: "totalTodos",
+                    debit: 1,
+                    credit: 0,
+                },
+                {
+                    account: "notStartedCount",
+                    debit: 0,
+                    credit: 1,
+                },
+                {
+                    account: "inProgressCount",
+                    debit: 0,
+                    credit: 1,
+                },
+            ],
+            equation: equation,
+        };
+        logicResults = [
+            {
+                name: "logic 1",
+                timeFinished: index_1._mockable.createNowTimestamp(),
+                status: "finished",
+                documents: [
+                    { action: "merge", priority: "high", dstPath: "path1/doc5", journalEntries: [unbalancedJournalEntry] },
+                ],
+            },
+        ];
+        await (0, index_1.onFormSubmit)(event);
+        expect(consoleErrorSpy).toHaveBeenCalledWith("Debit and credit should be equal");
+        expect(transactionUpdateMock).not.toHaveBeenCalled();
+        expect(transactionSetMock).not.toHaveBeenCalled();
+        expect(transactionGetMock).not.toHaveBeenCalled();
+        transactionGetMock.mockRestore();
+        transactionSetMock.mockRestore();
+        transactionUpdateMock.mockRestore();
+        transactionGetMock.mockResolvedValueOnce({
+            data: () => undefined,
+        });
+        const docRef = index_1.db.doc("path1/doc1");
+        logicResults = [
+            {
+                name: "logic 1",
+                timeFinished: index_1._mockable.createNowTimestamp(),
+                status: "finished",
+                documents: [
+                    { action: "merge", priority: "normal", dstPath: "path1/doc1", doc: { field: "value" }, journalEntries: [journalEntry] },
+                ],
+            },
+        ];
+        await (0, index_1.onFormSubmit)(event);
+        expect(transactionGetMock).toHaveBeenCalledTimes(1);
+        expect(transactionGetMock).toHaveBeenCalledWith(docRef);
+        expect(transactionSetMock).toHaveBeenCalledTimes(1);
+        expect(transactionSetMock).toHaveBeenCalledWith(docRef, { "field": "value", "@forDeletionLater": true });
+        expect(transactionUpdateMock).toHaveBeenCalledTimes(2);
+        expect(transactionUpdateMock).toHaveBeenNthCalledWith(1, docRef, {
+            "totalTodos": 1,
+            "@forDeletionLater": FieldValue.delete(),
+        });
+        expect(transactionUpdateMock).toHaveBeenNthCalledWith(2, docRef, {
+            "notStartedCount": 1,
+            "@forDeletionLater": FieldValue.delete(),
+        });
+        transactionGetMock.mockRestore();
+        transactionSetMock.mockRestore();
+        transactionUpdateMock.mockRestore();
+        transactionGetMock.mockResolvedValueOnce({
+            data: () => ({
+                "totalTodos": 1,
+                "notStartedCount": 1,
+            }),
+        });
+        logicResults = [
+            {
+                name: "logic 1",
+                timeFinished: index_1._mockable.createNowTimestamp(),
+                status: "finished",
+                documents: [
+                    { action: "merge", priority: "normal", dstPath: "path1/doc1", doc: { field: "value" }, journalEntries: [journalEntry] },
+                ],
+            },
+        ];
+        await (0, index_1.onFormSubmit)(event);
+        expect(transactionGetMock).toHaveBeenCalledTimes(1);
+        expect(transactionGetMock).toHaveBeenCalledWith(docRef);
+        expect(transactionSetMock).not.toHaveBeenCalled();
+        expect(transactionUpdateMock).toHaveBeenCalledTimes(3);
+        expect(transactionUpdateMock).toHaveBeenNthCalledWith(1, docRef, { "field": "value", "@forDeletionLater": true });
+        expect(transactionUpdateMock).toHaveBeenNthCalledWith(2, docRef, {
+            "totalTodos": 2,
+            "@forDeletionLater": FieldValue.delete(),
+        });
+        expect(transactionUpdateMock).toHaveBeenNthCalledWith(3, docRef, {
+            "notStartedCount": 2,
+            "@forDeletionLater": FieldValue.delete(),
+        });
+        transactionGetMock.mockRestore();
+        transactionSetMock.mockRestore();
+        transactionUpdateMock.mockRestore();
+        transactionGetMock.mockResolvedValueOnce({
+            data: () => ({
+                "totalTodos": 2,
+                "notStartedCount": 0,
+                "inProgressCount": 2,
+            }),
+        });
+        const zeroJournalEntry = {
+            date: index_1._mockable.createNowTimestamp(),
+            ledgerEntries: [
+                {
+                    account: "notStartedCount",
+                    debit: 1,
+                    credit: 1,
+                },
+                {
+                    account: "inProgressCount",
+                    debit: 1,
+                    credit: 1,
+                },
+            ],
+            equation: equation,
+        };
+        logicResults = [
+            {
+                name: "logic 1",
+                timeFinished: index_1._mockable.createNowTimestamp(),
+                status: "finished",
+                documents: [
+                    { action: "merge", priority: "normal", dstPath: "path1/doc1", journalEntries: [zeroJournalEntry] },
+                ],
+            },
+        ];
+        await (0, index_1.onFormSubmit)(event);
+        expect(transactionGetMock).toHaveBeenCalledTimes(1);
+        expect(transactionGetMock).toHaveBeenCalledWith(docRef);
+        expect(transactionSetMock).not.toHaveBeenCalled();
+        expect(transactionUpdateMock).toHaveBeenCalledTimes(3);
+        expect(transactionUpdateMock).toHaveBeenNthCalledWith(1, docRef, { "@forDeletionLater": true });
+        expect(transactionUpdateMock).toHaveBeenNthCalledWith(2, docRef, { "@forDeletionLater": FieldValue.delete() });
+        expect(transactionUpdateMock).toHaveBeenNthCalledWith(3, docRef, { "@forDeletionLater": FieldValue.delete() });
+        const errorMock = jest.spyOn(global, "Error")
+            .mockImplementation();
+        transactionGetMock.mockRestore();
+        transactionSetMock.mockRestore();
+        transactionUpdateMock.mockRestore();
+        transactionGetMock.mockResolvedValueOnce({
+            data: () => ({
+                "totalTodos": 2,
+                "notStartedCount": 0,
+                "inProgressCount": 2,
+            }),
+        });
+        const changeStatusJournalEntry = {
+            date: index_1._mockable.createNowTimestamp(),
+            ledgerEntries: [
+                {
+                    account: "notStartedCount",
+                    debit: 1,
+                    credit: 0,
+                },
+                {
+                    account: "inProgressCount",
+                    debit: 0,
+                    credit: 1,
+                },
+            ],
+            equation: equation,
+        };
+        logicResults = [
+            {
+                name: "logic 1",
+                timeFinished: index_1._mockable.createNowTimestamp(),
+                status: "finished",
+                documents: [
+                    { action: "merge", priority: "normal", dstPath: "path1/doc1", journalEntries: [changeStatusJournalEntry] },
+                ],
+            },
+        ];
+        await (0, index_1.onFormSubmit)(event);
+        expect(transactionGetMock).toHaveBeenCalledTimes(1);
+        expect(transactionGetMock).toHaveBeenCalledWith(docRef);
+        expect(transactionSetMock).not.toHaveBeenCalled();
+        expect(transactionUpdateMock).toHaveBeenCalledTimes(1);
+        expect(transactionUpdateMock).toHaveBeenCalledWith(docRef, { "@forDeletionLater": true });
+        expect(errorMock).toHaveBeenCalledTimes(1);
+        expect(errorMock).toHaveBeenCalledWith("Account value cannot be negative");
+        transactionGetMock.mockRestore();
+        transactionSetMock.mockRestore();
+        transactionUpdateMock.mockRestore();
+        transactionGetMock.mockResolvedValueOnce({
+            data: () => ({
+                "totalTodos": 2,
+                "notStartedCount": 1,
+                "inProgressCount": 1,
+                "doneCount": 0,
+            }),
+        });
+        logicResults = [
+            {
+                name: "logic 1",
+                timeFinished: index_1._mockable.createNowTimestamp(),
+                status: "finished",
+                documents: [
+                    { action: "merge", priority: "normal", dstPath: "path1/doc1", journalEntries: [recordedJournalEntry] },
+                ],
+            },
+        ];
+        await (0, index_1.onFormSubmit)(event);
+        expect(transactionGetMock).toHaveBeenCalledTimes(1);
+        expect(transactionGetMock).toHaveBeenCalledWith(docRef);
+        expect(transactionUpdateMock).toHaveBeenCalledTimes(3);
+        expect(transactionUpdateMock).toHaveBeenNthCalledWith(1, docRef, { "@forDeletionLater": true });
+        expect(transactionUpdateMock).toHaveBeenNthCalledWith(2, docRef, {
+            "inProgressCount": 0,
+            "@forDeletionLater": FieldValue.delete(),
+        });
+        expect(transactionUpdateMock).toHaveBeenNthCalledWith(3, docRef, {
+            "doneCount": 1,
+            "@forDeletionLater": FieldValue.delete(),
+        });
+        expect(transactionSetMock).toHaveBeenCalledTimes(2);
+        expect(transactionSetMock).toHaveBeenNthCalledWith(1, index_1.db.doc("path/doc1/@ledgers/doc100"), {
+            "journalEntryId": "doc10",
+            "account": "inProgressCount",
+            "debit": 1,
+            "credit": 0,
+        });
+        expect(transactionSetMock).toHaveBeenNthCalledWith(2, index_1.db.doc("path/doc1/@ledgers/doc101"), {
+            "journalEntryId": "doc10",
+            "account": "doneCount",
+            "debit": 0,
+            "credit": 1,
+        });
+    });
     it("should execute the sequence of operations correctly", async () => {
+        refUpdateMock.mockRestore();
+        setMock.mockRestore();
+        transactionSetMock.mockRestore();
+        transactionUpdateMock.mockRestore();
         jest.spyOn(indexutils, "validateForm").mockResolvedValue([false, {}]);
         jest.spyOn(indexutils, "getFormModifiedFields").mockReturnValue({ "field1": "value1", "field2": "value2" });
         jest.spyOn(indexutils, "getSecurityFn").mockReturnValue(() => Promise.resolve({ status: "allowed" }));
@@ -503,6 +879,12 @@ describe("onFormSubmit", () => {
         jest.spyOn(indexutils, "distribute").mockResolvedValue();
         jest.spyOn(indexutils, "distributeLater").mockResolvedValue();
         jest.spyOn(viewLogics, "queueRunViewLogics").mockResolvedValue();
+        jest.spyOn(distribution, "convertInstructionsToDbValues").mockReturnValue({
+            updateData: {
+                transactions: FieldValue.increment(-1),
+            },
+            removeData: {},
+        });
         const highPriorityDocs = [
             {
                 action: "merge",
@@ -561,7 +943,7 @@ describe("onFormSubmit", () => {
                 priority: "low",
             },
         ];
-        const anotherNormalPriorityDocs = [
+        const additionalNormalPriorityDocs = [
             {
                 action: "merge",
                 dstPath: "users/user-1/activities/activity-1",
@@ -571,6 +953,66 @@ describe("onFormSubmit", () => {
                 priority: "normal",
             },
         ];
+        const transactionalDocs = [
+            {
+                action: "create",
+                dstPath: "transactions/transaction-1",
+                doc: {
+                    title: "Transaction doc for user 1",
+                },
+                priority: "high",
+            },
+            {
+                action: "merge",
+                dstPath: "users/user-1",
+                doc: {
+                    lastActivity: index_1._mockable.createNowTimestamp(),
+                },
+                instructions: {
+                    transactions: "--",
+                },
+                priority: "normal",
+            },
+            {
+                action: "delete",
+                dstPath: "messages/message-1",
+                doc: {
+                    title: "Message doc for transaction 1",
+                },
+                priority: "low",
+            },
+        ];
+        const recordedJournalEntry = {
+            date: index_1._mockable.createNowTimestamp(),
+            ledgerEntries: [
+                {
+                    account: "inProgressCount",
+                    debit: 1,
+                    credit: 0,
+                },
+                {
+                    account: "doneCount",
+                    debit: 0,
+                    credit: 1,
+                },
+            ],
+            equation: equation,
+            recordEntry: true,
+        };
+        const journalDocs = [
+            {
+                action: "merge",
+                priority: "normal",
+                dstPath: "journal/doc1",
+                journalEntries: [recordedJournalEntry, journalEntry],
+            },
+            {
+                action: "merge",
+                priority: "normal",
+                dstPath: "journal/doc2",
+                journalEntries: [journalEntry],
+            },
+        ];
         const logicResults = [
             {
                 name: "testLogic",
@@ -578,10 +1020,22 @@ describe("onFormSubmit", () => {
                 timeFinished: index_1._mockable.createNowTimestamp(),
                 documents: [...highPriorityDocs, ...normalPriorityDocs, ...lowPriorityDocs],
             }, {
-                name: "anotherLogic",
+                name: "additionalLogic",
+                status: "finished",
+                timeFinished: index_1._mockable.createNowTimestamp(),
+                documents: [...additionalNormalPriorityDocs],
+            }, {
+                name: "transactionalLogic",
+                status: "finished",
+                timeFinished: index_1._mockable.createNowTimestamp(),
+                documents: [...transactionalDocs],
+                transactional: true,
+            }, {
+                name: "journalLogic",
                 status: "finished",
                 timeFinished: index_1._mockable.createNowTimestamp(),
-                documents: [...anotherNormalPriorityDocs],
+                documents: [...journalDocs],
+                transactional: true,
             },
         ];
         const runBusinessLogicsSpy = jest.spyOn(indexutils, "runBusinessLogics").mockImplementation(async (actionRef, action, distributeFn) => {
@@ -600,10 +1054,12 @@ describe("onFormSubmit", () => {
         const event = createEvent(form);
         const highPriorityDstPathLogicDocsMap = await (0, index_utils_1.expandConsolidateAndGroupByDstPath)(highPriorityDocs);
         const { docsByDocPath: highPriorityDocsByDocPath, otherDocsByDocPath: highPriorityOtherDocsByDocPath, } = (0, index_utils_1.groupDocsByTargetDocPath)(highPriorityDstPathLogicDocsMap, docPath);
-        const normalPriorityDstPathLogicDocsMap = await (0, index_utils_1.expandConsolidateAndGroupByDstPath)([...normalPriorityDocs, ...anotherNormalPriorityDocs]);
+        const normalPriorityDstPathLogicDocsMap = await (0, index_utils_1.expandConsolidateAndGroupByDstPath)([...normalPriorityDocs, ...additionalNormalPriorityDocs]);
         const { docsByDocPath: normalPriorityDocsByDocPath, otherDocsByDocPath: normalPriorityOtherDocsByDocPath, } = (0, index_utils_1.groupDocsByTargetDocPath)(normalPriorityDstPathLogicDocsMap, docPath);
         const lowPriorityDstPathLogicDocsMap = await (0, index_utils_1.expandConsolidateAndGroupByDstPath)(lowPriorityDocs);
         const { docsByDocPath: lowPriorityDocsByDocPath, otherDocsByDocPath: lowPriorityOtherDocsByDocPath, } = (0, index_utils_1.groupDocsByTargetDocPath)(lowPriorityDstPathLogicDocsMap, docPath);
+        const transactionalDstPathLogicDocsMap = await (0, index_utils_1.expandConsolidateAndGroupByDstPath)(transactionalDocs);
+        const journalDstPathLogicDocsMap = await (0, index_utils_1.expandConsolidateAndGroupByDstPath)(journalDocs);
         const viewLogicResults = [{
                 name: "User ViewLogic",
                 status: "finished",
@@ -611,6 +1067,8 @@ describe("onFormSubmit", () => {
                 documents: logicResults.map((result) => result.documents).flat(),
             }];
         jest.spyOn(indexutils, "expandConsolidateAndGroupByDstPath")
+            .mockResolvedValueOnce(journalDstPathLogicDocsMap)
+            .mockResolvedValueOnce(transactionalDstPathLogicDocsMap)
             .mockResolvedValueOnce(highPriorityDstPathLogicDocsMap)
             .mockResolvedValueOnce(normalPriorityDstPathLogicDocsMap)
             .mockResolvedValueOnce(lowPriorityDstPathLogicDocsMap);
@@ -633,25 +1091,32 @@ describe("onFormSubmit", () => {
         await (0, index_1.onFormSubmit)(event);
         // Test that the runBusinessLogics function was called with the correct parameters
         expect(runBusinessLogicsSpy).toHaveBeenCalled();
-        expect(docMock.set).toHaveBeenCalledTimes(11);
+        expect(setMock).toHaveBeenCalledTimes(18);
         expect(refMock.update).toHaveBeenCalledTimes(3);
         expect(refMock.update).toHaveBeenNthCalledWith(1, { "@status": "processing" });
         expect(refMock.update).toHaveBeenNthCalledWith(2, { "@status": "submitted" });
         expect(refMock.update).toHaveBeenNthCalledWith(3, { "@status": "finished" });
         // Test that the functions are called in the correct sequence
-        expect(indexutils.expandConsolidateAndGroupByDstPath).toHaveBeenNthCalledWith(1, highPriorityDocs);
+        expect(indexutils.expandConsolidateAndGroupByDstPath).toHaveBeenNthCalledWith(1, journalDocs);
+        console.debug("set", transactionSetMock.mock.calls);
+        console.debug("update", transactionUpdateMock.mock.calls);
+        expect(transactionMock.set).toHaveBeenCalledTimes(3);
+        expect(transactionMock.update).toHaveBeenCalledTimes(11);
+        expect(indexutils.expandConsolidateAndGroupByDstPath).toHaveBeenNthCalledWith(2, transactionalDocs);
+        expect(transactionMock.delete).toHaveBeenCalledTimes(1);
+        expect(indexutils.expandConsolidateAndGroupByDstPath).toHaveBeenNthCalledWith(3, highPriorityDocs);
         expect(indexutils.groupDocsByTargetDocPath).toHaveBeenNthCalledWith(1, highPriorityDstPathLogicDocsMap, docPath);
         expect(indexutils.distribute).toHaveBeenNthCalledWith(1, highPriorityDocsByDocPath);
         expect(indexutils.distribute).toHaveBeenNthCalledWith(2, highPriorityOtherDocsByDocPath);
-        expect(indexutils.expandConsolidateAndGroupByDstPath).toHaveBeenNthCalledWith(2, [...normalPriorityDocs, ...anotherNormalPriorityDocs]);
+        expect(indexutils.expandConsolidateAndGroupByDstPath).toHaveBeenNthCalledWith(4, [...normalPriorityDocs, ...additionalNormalPriorityDocs]);
         expect(indexutils.groupDocsByTargetDocPath).toHaveBeenNthCalledWith(2, normalPriorityDstPathLogicDocsMap, docPath);
         expect(indexutils.distribute).toHaveBeenNthCalledWith(3, normalPriorityDocsByDocPath);
         expect(indexutils.distributeLater).toHaveBeenNthCalledWith(1, normalPriorityOtherDocsByDocPath);
-        expect(indexutils.expandConsolidateAndGroupByDstPath).toHaveBeenNthCalledWith(3, lowPriorityDocs);
+        expect(indexutils.expandConsolidateAndGroupByDstPath).toHaveBeenNthCalledWith(5, lowPriorityDocs);
         expect(indexutils.groupDocsByTargetDocPath).toHaveBeenNthCalledWith(3, lowPriorityDstPathLogicDocsMap, docPath);
         expect(indexutils.distributeLater).toHaveBeenNthCalledWith(2, lowPriorityDocsByDocPath);
         expect(indexutils.distributeLater).toHaveBeenNthCalledWith(3, lowPriorityOtherDocsByDocPath);
-        expect(indexutils.expandConsolidateAndGroupByDstPath).toHaveBeenCalledTimes(3);
+        expect(indexutils.expandConsolidateAndGroupByDstPath).toHaveBeenCalledTimes(5);
         expect(updateMock).toHaveBeenCalledTimes(1);
         expect(updateMock.mock.calls[0][0]).toEqual({ status: "finished" });
     });