emberflow 1.0.20 → 1.0.22

package/lib/tests/index.test.js

@@ -29,11 +29,13 @@ const admin = __importStar(require("firebase-admin"));
 const firebase_admin_1 = require("firebase-admin");
 var Timestamp = firebase_admin_1.firestore.Timestamp;
 const db_structure_1 = require("../sample-custom/db-structure");
-admin.initializeApp();
+const paths = __importStar(require("../utils/paths"));
 // TODO: Create unit test for all new functions and modified functions
 const projectConfig = {
     projectId: "your-project-id",
     budgetAlertTopicName: "budget-alerts",
+    region: "us-central1",
+    rtdbName: "rtdb",
     maxCostLimitPerFunction: 100,
     specialCostLimitPerFunction: {
         function1: 50,
@@ -41,179 +43,158 @@ const projectConfig = {
         function3: 120,
     },
 };
-const funcName = "testFunction";
+jest.spyOn(admin, "initializeApp").mockImplementation();
+const dataMock = jest.fn().mockReturnValue({});
+const getMock = {
+    data: dataMock,
+};
+const docMock = {
+    set: jest.fn(),
+    get: jest.fn().mockResolvedValue(getMock),
+    update: jest.fn(),
+    collection: jest.fn(),
+};
+const collectionMock = {
+    doc: jest.fn(() => docMock),
+};
+const firestoreMock = jest.spyOn(admin, "firestore")
+    .mockImplementation(() => {
+    return {
+        collection: jest.fn(() => collectionMock),
+        doc: jest.fn(() => docMock),
+    };
+});
+const refMock = {
+    update: jest.fn(),
+};
+const rtdbMock = jest.spyOn(admin, "database")
+    .mockImplementation(() => {
+    return {
+        ref: jest.fn(() => refMock),
+    };
+});
+console.log(firestoreMock, rtdbMock);
+const parseEntityMock = jest.fn();
+jest.spyOn(paths, "parseEntity")
+    .mockImplementation(parseEntityMock);
+admin.initializeApp();
 (0, index_1.initializeEmberFlow)(projectConfig, admin, db_structure_1.dbStructure, db_structure_1.Entity, {}, {}, []);
-function createDocumentSnapshot(data, refPath, exists = true) {
+function createDocumentSnapshot(form) {
     return {
-        exists,
-        id: "test-id",
+        key: "test-id",
         ref: {
-            id: "test-id",
-            path: refPath,
-            set: jest.fn(),
             update: jest.fn(),
-            delete: jest.fn(),
-            get: jest.fn(),
         },
-        data: () => data,
-        get: jest.fn(),
-        isEqual: jest.fn(),
-        create_time: index_1._mockable.createNowTimestamp(),
-        update_time: index_1._mockable.createNowTimestamp(),
-        readTime: index_1._mockable.createNowTimestamp(),
+        val: () => form,
     };
 }
-function createChange(beforeData, afterData, refPath) {
+function createEvent(form) {
     return {
-        before: createDocumentSnapshot(beforeData, refPath),
-        after: createDocumentSnapshot(afterData, refPath),
+        id: "test-id",
+        data: createDocumentSnapshot(form),
+        params: {
+            formId: "test-fid",
+            userId: "test-uid",
+        },
     };
 }
 describe("onDocChange", () => {
     const entity = "user";
-    const refPath = "/example/test-id";
-    const contextWithoutAuth = {
-        auth: undefined,
-        authType: "ADMIN",
-        eventId: "test-event-id",
-        eventType: "test-event-type",
-        params: {},
-        resource: {
-            name: "projects/test-project/databases/(default)/documents/test",
-            service: "firestore.googleapis.com",
-            type: "type",
-        },
-        timestamp: "2022-03-15T18:52:04.369Z",
-    };
-    const contextWithAuth = {
-        auth: {
-            uid: "test-uid",
-            token: {
-                email: "test-email",
-                email_verified: true,
-                name: "test-name",
-                picture: "test-picture",
-                sub: "test-sub",
-            },
-        },
-        authType: "ADMIN",
-        eventId: "test-event-id",
-        eventType: "test-event-type",
-        params: {},
-        resource: {
-            name: "projects/test-project/databases/(default)/documents/test",
-            service: "firestore.googleapis.com",
-            type: "type",
-        },
-        timestamp: "2022-03-15T18:52:04.369Z",
+    const eventContext = {
+        id: "test-id",
+        uid: "test-uid",
+        formId: "test-fid",
+        docId: "test-uid",
+        docPath: "users/test-uid",
+        entity,
     };
     beforeEach(() => {
-        // ...
-        jest.spyOn(admin, "initializeApp").mockImplementation();
-        const docMock = {
-            set: jest.fn(),
-            get: jest.fn(),
-            update: jest.fn(),
-            delete: jest.fn(),
-            parent: {},
-            path: "",
-            firestore: {},
-            id: "",
-            isEqual: jest.fn(),
-            // Add the missing properties and methods
-            collection: jest.fn(),
-            listCollections: jest.fn(),
-            create: jest.fn(),
-            onSnapshot: jest.fn(),
-            withConverter: jest.fn(),
-            // Add other required properties/methods as needed
-        };
-        const collectionMock = {
-            doc: jest.fn(() => docMock),
-            // Add other required properties/methods as needed
-        };
-        // Mock admin.firestore
-        const firestoreMock = jest.spyOn(admin, "firestore");
-        const firestoreInstance = {
-            collection: jest.fn(() => collectionMock),
-            settings: jest.fn(),
-            doc: jest.fn(),
-            collectionGroup: jest.fn(),
-            getAll: jest.fn(),
-            runTransaction: jest.fn(),
-            batch: jest.fn(),
-            terminate: jest.fn(),
-            // Add the missing methods
-            recursiveDelete: jest.fn(),
-            listCollections: jest.fn(),
-            bulkWriter: jest.fn(),
-            bundle: jest.fn(),
-        };
-        firestoreMock.mockImplementation(() => firestoreInstance);
         // Add the spy for _mockable
         jest.spyOn(index_1._mockable, "createNowTimestamp").mockReturnValue(Timestamp.now());
         jest.spyOn(console, "log").mockImplementation();
+        jest.spyOn(console, "warn").mockImplementation();
+        parseEntityMock.mockReturnValue({
+            entity: "user",
+            entityId: "test-uid",
+        });
+        refMock.update.mockReset();
     });
-    afterEach(() => {
-        jest.restoreAllMocks();
-    });
-    it("should not execute when auth is null", async () => {
-        const change = createChange({}, {}, refPath);
-        await (0, index_1.onDocChange)(funcName, entity, change, contextWithoutAuth, "delete");
-        expect(console.log).toHaveBeenCalledWith("Auth is null, then this change is initiated by the service account and should be ignored");
-        expect(console.log).toHaveBeenCalledTimes(1);
-    });
-    it("should re-add deleted document", async () => {
-        const deletedDocumentData = {
-            field1: "value1",
-            field2: "value2",
+    it("should return when there's no matched entity", async () => {
+        const formData = {
+            "field1": "newValue",
+            "field2": "oldValue",
+            "@actionType": "update",
+            "@status": "submit",
+            "@docPath": "users/test-uid",
         };
-        const change = createChange(deletedDocumentData, null, refPath);
-        await (0, index_1.onDocChange)(funcName, entity, change, contextWithAuth, "delete");
-        expect(change.after.ref.set).toHaveBeenCalledWith(deletedDocumentData);
-        expect(change.after.ref.set).toHaveBeenCalledTimes(1);
-        expect(console.log).toHaveBeenCalledWith("Document re-added with ID test-id");
-        expect(console.log).toHaveBeenCalledTimes(4);
-    });
-    it("should revert modifications outside form", async () => {
-        const beforeData = {
-            field1: "oldValue",
-            field2: "oldValue",
-            field3: {
+        const event = createEvent(formData);
+        const document = {
+            "field1": "oldValue",
+            "field2": "oldValue",
+            "field3": {
                 nestedField1: "oldValue",
                 nestedField2: "oldValue",
             },
         };
-        const afterData = {
+        dataMock.mockReturnValue(document);
+        parseEntityMock.mockReturnValue({
+            entityId: "test-id",
+        });
+        await (0, index_1.onFormSubmit)(event);
+        expect(refMock.update).toHaveBeenCalledWith({
+            "@status": "error",
+            "@message": "docPath does not match any known Entity",
+        });
+        expect(console.warn).toHaveBeenCalledWith("docPath does not match any known Entity");
+    });
+    it("should return when target docPath is not allowed for given userId", async () => {
+        const formData = {
             "field1": "newValue",
             "field2": "oldValue",
+            "@actionType": "update",
+            "@status": "submit",
+            "@docPath": "users/another-user-id",
+        };
+        const event = createEvent(formData);
+        const document = {
+            "field1": "oldValue",
+            "field2": "oldValue",
             "field3": {
-                nestedField1: "newValue",
+                nestedField1: "oldValue",
                 nestedField2: "oldValue",
             },
-            "@form": {
-                "@actionType": "update",
-                "@status": "submit",
-            },
         };
-        const change = createChange(beforeData, afterData, refPath);
-        // Mock validateForm to return a validation error
-        jest.spyOn(indexutils, "validateForm").mockResolvedValue([
-            true,
-            {
-                field1: ["error message 1"],
-                field2: ["error message 2"],
+        dataMock.mockReturnValue(document);
+        await (0, index_1.onFormSubmit)(event);
+        expect(refMock.update).toHaveBeenCalledWith({
+            "@status": "error",
+            "@message": "User id from path does not match user id from event params",
+        });
+        expect(console.warn).toHaveBeenCalledWith("User id from path does not match user id from event params");
+    });
+    it("should return when there's no provided @actionType", async () => {
+        const formData = {
+            "field1": "newValue",
+            "field2": "oldValue",
+            "@status": "submit",
+            "@docPath": "users/test-uid",
+        };
+        const event = createEvent(formData);
+        const document = {
+            "field1": "oldValue",
+            "field2": "oldValue",
+            "field3": {
+                nestedField1: "oldValue",
+                nestedField2: "oldValue",
             },
-        ]);
-        const revertModificationsOutsideFormMock = jest.spyOn(indexutils, "revertModificationsOutsideForm").mockResolvedValue();
-        await (0, index_1.onDocChange)(funcName, "user", change, contextWithAuth, "update");
-        expect(revertModificationsOutsideFormMock).toHaveBeenCalledWith(afterData, beforeData, change.after);
-        expect(indexutils.validateForm).toHaveBeenCalledWith("user", afterData, refPath);
-        expect(change.after.ref.update).toHaveBeenCalledWith({
-            "@form.@status": "form-validation-failed",
-            "@form.@message": { "field1": ["error message 1"], "field2": ["error message 2"] },
+        };
+        dataMock.mockReturnValue(document);
+        await (0, index_1.onFormSubmit)(event);
+        expect(refMock.update).toHaveBeenCalledWith({
+            "@status": "error",
+            "@message": "No @actionType found",
         });
-        expect(change.after.ref.update).toHaveBeenCalledTimes(1);
+        expect(console.warn).toHaveBeenCalledWith("No @actionType found");
     });
     it("should return on security check failure", async () => {
         const getSecurityFnMock = jest.spyOn(indexutils, "getSecurityFn");
@@ -223,135 +204,101 @@ describe("onDocChange", () => {
         };
         const securityFnMock = jest.fn().mockResolvedValue(rejectedSecurityResult);
         getSecurityFnMock.mockReturnValue(securityFnMock);
-        const beforeData = {
-            "field1": "oldValue",
+        const formData = {
+            "field1": "newValue",
             "field2": "oldValue",
-            "field3": {
-                nestedField1: "oldValue",
-                nestedField2: "oldValue",
-            },
-            "@form": {
-                "field1": "oldValue",
-                "field2": "oldValue",
-                "@status": "submit",
-            },
+            "@actionType": "update",
+            "@status": "submit",
+            "@docPath": "users/test-uid",
         };
-        const afterData = {
+        const event = createEvent(formData);
+        const document = {
             "field1": "oldValue",
             "field2": "oldValue",
             "field3": {
                 nestedField1: "oldValue",
                 nestedField2: "oldValue",
             },
-            "@form": {
-                "field1": "newValue",
-                "field2": "oldValue",
-                "@actionType": "update",
-                "@status": "submit",
-            },
         };
-        const change = createChange(beforeData, afterData, refPath);
+        dataMock.mockReturnValue(document);
         const validateFormMock = jest.spyOn(indexutils, "validateForm");
         validateFormMock.mockResolvedValue([false, {}]);
-        await (0, index_1.onDocChange)(funcName, entity, change, contextWithAuth, "update");
+        await (0, index_1.onFormSubmit)(event);
         expect(getSecurityFnMock).toHaveBeenCalledWith(entity);
-        expect(validateFormMock).toHaveBeenCalledWith(entity, change.after.data(), refPath);
-        expect(securityFnMock).toHaveBeenCalledWith(entity, change.after.data(), "update", ["field1"]);
-        expect(change.after.ref.update).toHaveBeenCalledWith({
-            "@form.@status": "security-error",
-            "@form.@message": "Unauthorized access",
+        expect(validateFormMock).toHaveBeenCalledWith(entity, event.data.val());
+        expect(securityFnMock).toHaveBeenCalledWith(entity, event.data.val(), document, "update", ["field1"]);
+        expect(refMock.update).toHaveBeenCalledWith({
+            "@status": "security-error",
+            "@message": "Unauthorized access",
         });
         expect(console.log).toHaveBeenCalledWith(`Security check failed: ${rejectedSecurityResult.message}`);
+        getSecurityFnMock.mockReset();
     });
     it("should call delayFormSubmissionAndCheckIfCancelled with correct parameters", async () => {
-        jest.spyOn(indexutils, "revertModificationsOutsideForm").mockResolvedValue();
-        jest.spyOn(indexutils, "validateForm").mockResolvedValue([false, {}]);
-        jest.spyOn(indexutils, "getFormModifiedFields").mockReturnValue(["field1", "field2"]);
-        jest.spyOn(indexutils, "getSecurityFn").mockReturnValue(() => Promise.resolve({ status: "allowed" }));
+        const validateFormMock = jest.spyOn(indexutils, "validateForm").mockResolvedValue([false, {}]);
+        const getFormModifiedFieldsMock = jest.spyOn(indexutils, "getFormModifiedFields").mockReturnValue(["field1", "field2"]);
+        const getSecurityFnMock = jest.spyOn(indexutils, "getSecurityFn").mockReturnValue(() => Promise.resolve({ status: "allowed" }));
         const delayFormSubmissionAndCheckIfCancelledSpy = jest.spyOn(indexutils, "delayFormSubmissionAndCheckIfCancelled").mockResolvedValue(true);
-        const doc = {
-            "@form": {
-                "@delay": 1000,
-                "@status": "submit",
-                "@actionType": "create",
-            },
+        const formData = {
+            "@delay": 1000,
+            "@status": "submit",
+            "@actionType": "create",
             "someField": "exampleValue",
+            "@docPath": "users/test-uid",
         };
-        const change = createChange(null, doc, "/example/test-id");
-        const event = "create";
-        await (0, index_1.onDocChange)(funcName, "user", change, contextWithAuth, event);
+        const event = createEvent(formData);
+        await (0, index_1.onFormSubmit)(event);
         // Test that the delayFormSubmissionAndCheckIfCancelled function is called with the correct parameters
-        expect(delayFormSubmissionAndCheckIfCancelledSpy).toHaveBeenCalledWith(1000, change.after);
-        // Test that snapshot.ref.update is called with the correct parameters
-        expect(change.after.ref.update).toHaveBeenCalledWith({ "@form.@status": "cancelled" });
-    });
-    it("should not process the form if @form.@status is not 'submit'", async () => {
-        jest.spyOn(indexutils, "revertModificationsOutsideForm").mockResolvedValue();
-        jest.spyOn(indexutils, "validateForm").mockResolvedValue([false, {}]);
-        jest.spyOn(indexutils, "getFormModifiedFields").mockReturnValue(["field1", "field2"]);
-        jest.spyOn(indexutils, "getSecurityFn").mockReturnValue(() => Promise.resolve({ status: "allowed" }));
-        const delayFormSubmissionAndCheckIfCancelledSpy = jest.spyOn(indexutils, "delayFormSubmissionAndCheckIfCancelled").mockResolvedValue(true);
-        const doc = {
-            "@form": {
-                "@actionType": "create",
-                "@status": "not-submit",
-                "@delay": 1000,
-            },
-            "someField": "exampleValue",
-        };
-        const change = createChange(null, doc, "/example/test-id");
-        const event = "create";
-        await (0, index_1.onDocChange)(funcName, "user", change, contextWithAuth, event);
-        // Test that the delayFormSubmissionAndCheckIfCancelled function is NOT called
-        expect(indexutils.revertModificationsOutsideForm).toHaveBeenCalled();
-        expect(indexutils.getFormModifiedFields).not.toHaveBeenCalled();
-        expect(indexutils.getSecurityFn).not.toHaveBeenCalled();
-        expect(delayFormSubmissionAndCheckIfCancelledSpy).not.toHaveBeenCalled();
-        // Test that snapshot.ref.update is NOT called
-        expect(change.after.ref.update).not.toHaveBeenCalled();
+        expect(delayFormSubmissionAndCheckIfCancelledSpy).toHaveBeenCalledWith(1000, refMock);
+        expect(refMock.update).toHaveBeenCalledWith({ "@status": "cancelled" });
+        validateFormMock.mockReset();
+        getFormModifiedFieldsMock.mockReset();
+        getSecurityFnMock.mockReset();
+        delayFormSubmissionAndCheckIfCancelledSpy.mockReset();
     });
-    it("should set @form.@status to 'submitted' after passing all checks", async () => {
-        jest.spyOn(indexutils, "revertModificationsOutsideForm").mockResolvedValue();
-        jest.spyOn(indexutils, "validateForm").mockResolvedValue([false, {}]);
-        jest.spyOn(indexutils, "getFormModifiedFields").mockReturnValue(["field1", "field2"]);
-        jest.spyOn(indexutils, "getSecurityFn").mockReturnValue(() => Promise.resolve({ status: "allowed" }));
-        jest.spyOn(indexutils, "delayFormSubmissionAndCheckIfCancelled").mockResolvedValue(false);
-        const setActionSpy = jest.fn().mockResolvedValue({
+    it("should set form @status to 'submitted' after passing all checks", async () => {
+        const validateFormMock = jest.spyOn(indexutils, "validateForm").mockResolvedValue([false, {}]);
+        const getFormModifiedFieldsMock = jest.spyOn(indexutils, "getFormModifiedFields").mockReturnValue(["field1", "field2"]);
+        const getSecurityFnMock = jest.spyOn(indexutils, "getSecurityFn").mockReturnValue(() => Promise.resolve({ status: "allowed" }));
+        const delayFormSubmissionAndCheckIfCancelledMock = jest.spyOn(indexutils, "delayFormSubmissionAndCheckIfCancelled").mockResolvedValue(false);
+        const setActionMock = jest.fn().mockResolvedValue({
             update: jest.fn(),
         });
-        const updateActionSpy = jest.fn().mockResolvedValue({
+        const updateActionMock = jest.fn().mockResolvedValue({
             update: jest.fn(),
         });
-        jest.spyOn(index_1._mockable, "initActionRef").mockResolvedValue({
-            set: setActionSpy,
-            update: updateActionSpy,
+        const initActionRefMock = jest.spyOn(index_1._mockable, "initActionRef").mockResolvedValue({
+            set: setActionMock,
+            update: updateActionMock,
         });
-        const doc = {
-            "@form": {
-                "@actionType": "create",
-                "name": "test",
-                "@status": "submit",
-            },
-            "someField": "exampleValue",
+        const formData = {
+            "@actionType": "create",
+            "name": "test",
+            "@status": "submit",
+            "@docPath": "users/test-uid",
         };
-        const change = createChange(null, doc, "/example/test-id");
-        const event = "create";
-        await (0, index_1.onDocChange)(funcName, "user", change, contextWithAuth, event);
-        // Test that the snapshot.ref.update is called with the correct parameters
-        expect(change.after.ref.update).toHaveBeenCalledWith({ "@form.@status": "processing" });
-        expect(change.after.ref.update).toHaveBeenCalledWith({ "@form.@status": "submitted" });
+        const event = createEvent(formData);
+        await (0, index_1.onFormSubmit)(event);
+        expect(refMock.update).toHaveBeenCalledWith({ "@status": "processing" });
+        expect(refMock.update).toHaveBeenCalledWith({ "@status": "submitted" });
         // Test that addActionSpy is called with the correct parameters
-        expect(setActionSpy).toHaveBeenCalled();
-        expect(updateActionSpy).toHaveBeenCalled();
+        expect(setActionMock).toHaveBeenCalled();
+        expect(updateActionMock).toHaveBeenCalled();
+        validateFormMock.mockReset();
+        getFormModifiedFieldsMock.mockReset();
+        getSecurityFnMock.mockReset();
+        delayFormSubmissionAndCheckIfCancelledMock.mockReset();
+        setActionMock.mockReset();
+        updateActionMock.mockReset();
+        initActionRefMock.mockReset();
     });
-    it("should set @form.@status to 'logic-error' if there are logic error results", async () => {
-        jest.spyOn(indexutils, "revertModificationsOutsideForm").mockResolvedValue();
-        jest.spyOn(indexutils, "validateForm").mockResolvedValue([false, {}]);
-        jest.spyOn(indexutils, "getFormModifiedFields").mockReturnValue(["field1", "field2"]);
-        jest.spyOn(indexutils, "getSecurityFn").mockReturnValue(() => Promise.resolve({ status: "allowed" }));
-        jest.spyOn(indexutils, "delayFormSubmissionAndCheckIfCancelled").mockResolvedValue(false);
+    it("should set @status to 'logic-error' if there are logic error results", async () => {
+        const validateFormMock = jest.spyOn(indexutils, "validateForm").mockResolvedValue([false, {}]);
+        const getFormModifiedFieldsMock = jest.spyOn(indexutils, "getFormModifiedFields").mockReturnValue(["field1", "field2"]);
+        const getSecurityFnMock = jest.spyOn(indexutils, "getSecurityFn").mockReturnValue(() => Promise.resolve({ status: "allowed" }));
+        const delayFormSubmissionAndCheckIfCancelledMock = jest.spyOn(indexutils, "delayFormSubmissionAndCheckIfCancelled").mockResolvedValue(false);
         const errorMessage = "logic error message";
-        const runBusinessLogicsSpy = jest.spyOn(indexutils, "runBusinessLogics").mockResolvedValue([
+        const runBusinessLogicsMock = jest.spyOn(indexutils, "runBusinessLogics").mockResolvedValue([
             {
                 name: "testLogic",
                 status: "error",
@@ -360,77 +307,81 @@ describe("onDocChange", () => {
                 documents: [],
             },
         ]);
-        const setActionSpy = jest.fn().mockResolvedValue({
+        const setActionMock = jest.fn().mockResolvedValue({
             update: jest.fn(),
         });
-        const updateActionSpy = jest.fn().mockResolvedValue({
+        const updateActionMock = jest.fn().mockResolvedValue({
             update: jest.fn(),
         });
-        jest.spyOn(index_1._mockable, "initActionRef").mockResolvedValue({
-            set: setActionSpy,
-            update: updateActionSpy,
+        const initActionRefMock = jest.spyOn(index_1._mockable, "initActionRef").mockResolvedValue({
+            set: setActionMock,
+            update: updateActionMock,
             collection: jest.fn().mockReturnValue({
                 doc: jest.fn().mockReturnValue({
-                    set: setActionSpy,
-                    update: updateActionSpy,
+                    set: setActionMock,
+                    update: updateActionMock,
                 }),
             }),
         });
+        const formData = {
+            "@actionType": "create",
+            "name": "test",
+            "@status": "submit",
+            "@docPath": "users/test-uid",
+        };
         const doc = {
-            "@form": {
-                "@actionType": "create",
-                "name": "test",
-                "@status": "submit",
-            },
-            "someField": "exampleValue",
+            name: "test",
+            description: "test description",
         };
-        const change = createChange(null, doc, "/example/test-id");
-        const event = "create";
-        await (0, index_1.onDocChange)(funcName, "user", change, contextWithAuth, event);
+        dataMock.mockReturnValue(doc);
+        const event = createEvent(formData);
+        await (0, index_1.onFormSubmit)(event);
         // Test that the runBusinessLogics function was called with the correct parameters
-        expect(runBusinessLogicsSpy).toHaveBeenCalledWith("create", ["field1", "field2"], "user", expect.objectContaining({
+        expect(runBusinessLogicsMock).toHaveBeenCalledWith("create", ["field1", "field2"], "user", expect.objectContaining({
+            eventContext,
             actionType: "create",
-            document: {
-                "@form": {
-                    "@actionType": "create",
-                    "@status": "submit",
-                    "name": "test",
-                },
-                "someField": "exampleValue",
+            document: doc,
+            form: {
+                "@actionType": "create",
+                "@status": "submit",
+                "name": "test",
+                "@docPath": "users/test-uid",
             },
             modifiedFields: ["field1", "field2"],
-            path: "/example/test-id",
             status: "processing",
             // TimeCreated is not specified because it's dynamic
         }));
-        // Test that the snapshot.ref.update is called with the correct parameters
-        expect(change.after.ref.update).toHaveBeenCalledTimes(3);
-        const updateMock = change.after.ref.update;
-        expect(updateMock.mock.calls[0][0]).toEqual({ "@form.@status": "processing" });
-        expect(updateMock.mock.calls[1][0]).toEqual({ "@form.@status": "submitted" });
-        expect(updateMock.mock.calls[2][0]).toEqual({ "@form.@status": "finished" });
+        expect(refMock.update).toHaveBeenCalledTimes(3);
+        expect(refMock.update.mock.calls[0][0]).toEqual({ "@status": "processing" });
+        expect(refMock.update.mock.calls[1][0]).toEqual({ "@status": "submitted" });
+        expect(refMock.update.mock.calls[2][0]).toEqual({ "@status": "finished" });
         // Test that collectionAddSpy is not called if there are logic errors
-        expect(setActionSpy).toHaveBeenCalledWith(expect.objectContaining({
+        expect(setActionMock).toHaveBeenCalledWith(expect.objectContaining({
+            eventContext,
             actionType: "create",
-            document: {
-                "@form": {
-                    "@actionType": "create",
-                    "@status": "submit",
-                    "name": "test",
-                },
-                "someField": "exampleValue",
+            document: doc,
+            form: {
+                "@actionType": "create",
+                "@status": "submit",
+                "name": "test",
+                "@docPath": "users/test-uid",
             },
             modifiedFields: ["field1", "field2"],
-            path: "/example/test-id",
             status: "processing",
             // TimeCreated is not specified because it's dynamic
         }));
-        expect(updateActionSpy).toHaveBeenCalledTimes(2);
-        expect(updateActionSpy.mock.calls[0][0]).toEqual({ status: "finished-with-error", message: errorMessage });
+        expect(updateActionMock).toHaveBeenCalledTimes(2);
+        expect(updateActionMock.mock.calls[0][0]).toEqual({ status: "finished-with-error", message: errorMessage });
+        validateFormMock.mockReset();
+        getFormModifiedFieldsMock.mockReset();
+        getSecurityFnMock.mockReset();
+        delayFormSubmissionAndCheckIfCancelledMock.mockReset();
+        runBusinessLogicsMock.mockReset();
+        setActionMock.mockReset();
+        updateActionMock.mockReset();
+        initActionRefMock.mockReset();
     });
-    // ... existing test code ...
     it("should execute the sequence of operations correctly", async () => {
-        jest.spyOn(indexutils, "revertModificationsOutsideForm").mockResolvedValue();
         jest.spyOn(indexutils, "validateForm").mockResolvedValue([false, {}]);
         jest.spyOn(indexutils, "getFormModifiedFields").mockReturnValue(["field1", "field2"]);
         jest.spyOn(indexutils, "getSecurityFn").mockReturnValue(() => Promise.resolve({ status: "allowed" }));
@@ -460,16 +411,13 @@ describe("onDocChange", () => {
                 }),
             }),
         });
-        const doc = {
-            "@form": {
-                "@actionType": "create",
-                "name": "test",
-                "@status": "submit",
-            },
-            "someField": "exampleValue",
+        const formData = {
+            "@actionType": "create",
+            "name": "test",
+            "@status": "submit",
+            "@docPath": "users/test-uid",
         };
-        const change = createChange(null, doc, "/example/test-id");
-        const event = "create";
+        const event = createEvent(formData);
         const consolidatedLogicResults = new Map();
         const consolidatedViewLogicResults = new Map();
         const consolidatedPeerSyncViewLogicResults = new Map();
@@ -500,11 +448,10 @@ describe("onDocChange", () => {
         jest.spyOn(indexutils, "runViewLogics").mockResolvedValue(viewLogicResults);
         jest.spyOn(indexutils, "runPeerSyncViews").mockResolvedValue(peerSyncViewLogicResults);
         jest.spyOn(indexutils, "distribute");
-        await (0, index_1.onDocChange)(funcName, "user", change, contextWithAuth, event);
+        await (0, index_1.onFormSubmit)(event);
         // Test that the runBusinessLogics function was called with the correct parameters
         expect(runBusinessLogicsSpy).toHaveBeenCalled();
-        // Test that the snapshot.ref.update is called with the correct parameters
-        expect(change.after.ref.update).toHaveBeenCalledTimes(3);
+        expect(refMock.update).toHaveBeenCalledTimes(3);
         expect(setActionSpy).toHaveBeenCalledTimes(2);
         // Test that the functions are called in the correct sequence
         expect(indexutils.consolidateAndGroupByDstPath).toHaveBeenNthCalledWith(1, businessLogicResults);
@@ -514,7 +461,7 @@ describe("onDocChange", () => {
         expect(indexutils.groupDocsByUserAndDstPath).toHaveBeenNthCalledWith(2, consolidatedViewLogicResults, "test-uid");
         expect(indexutils.distribute).toHaveBeenNthCalledWith(1, userDocsByDstPath);
         expect(indexutils.distribute).toHaveBeenNthCalledWith(2, userViewDocsByDstPath);
-        expect(change.after.ref.update).toHaveBeenCalledWith({ "@form.@status": "finished" });
+        expect(refMock.update).toHaveBeenCalledWith({ "@status": "finished" });
         expect(indexutils.runPeerSyncViews).toHaveBeenCalledWith(userDocsByDstPath);
         expect(indexutils.consolidateAndGroupByDstPath).toHaveBeenNthCalledWith(3, peerSyncViewLogicResults);
         expect(indexutils.groupDocsByUserAndDstPath).toHaveBeenNthCalledWith(3, consolidatedPeerSyncViewLogicResults, "test-uid");