@arrai-innovations/reactive-helpers 10.4.2 → 11.0.1

package/tests/unit/use/listFilter.spec.js

@@ -1,152 +1,64 @@
 import { useListFilters, useListSort } from "../../../use/index.js";
 import { doAwaitNot } from "../../../utils/watches.js";
-import { nextTick, reactive, ref } from "vue";
+import { ref, unref, reactive } from "vue";
 import { deepUnref } from "vue-deepunref";
 
 describe("use/listFilter", () => {
-    let useListInstance, useListFilter, setDefaultSearchOptions;
+    let useListInstance, useListFilter, useListCalculated, useListRelated;
     beforeEach(async () => {
         const listInstanceModule = await import("../../../use/listInstance");
         useListInstance = listInstanceModule.useListInstance;
         const listFilterModule = await import("../../../use/listFilter");
         useListFilter = listFilterModule.useListFilter;
-        const searchModule = await import("../../../use/search");
-        setDefaultSearchOptions = searchModule.setDefaultSearchOptions;
-        setDefaultSearchOptions({
-            throttle: 0,
-        });
+        const listRelatedModule = await import("../../../use/listRelated");
+        useListRelated = listRelatedModule.useListRelated;
+        const listCalculatedModule = await import("../../../use/listCalculated");
+        useListCalculated = listCalculatedModule.useListCalculated;
     });
 
-    it("should match an allowed values list", async () => {
-        const list = useListInstance({ props: {} });
-        const filter = useListFilter({
-            parentState: list.state,
-            allowedValues: reactive({
-                1: true,
-                3: true,
-            }),
-        });
-        await nextTick();
-        expect(filter.state.objects).toEqual({});
-        list.addListObject({ id: 1, name: "one", has_things: true });
-        await nextTick();
-        expect(filter.state.objects).toEqual({
-            1: { id: 1, name: "one", has_things: true },
-        });
-        list.addListObject({ id: 2, name: "two", has_things: true });
-        await nextTick();
-        expect(filter.state.objects).toEqual({
-            1: { id: 1, name: "one", has_things: true },
-        });
-        list.addListObject({ id: 3, name: "three", has_things: true });
-        await nextTick();
-        expect(filter.state.objects).toEqual({
-            1: { id: 1, name: "one", has_things: true },
-            3: { id: 3, name: "three", has_things: true },
-        });
-        list.addListObject({ id: 4, name: "four", has_things: true });
-        await nextTick();
-        expect(filter.state.objects).toEqual({
-            1: { id: 1, name: "one", has_things: true },
-            3: { id: 3, name: "three", has_things: true },
-        });
-    });
     it("should match an allowed filter function", async () => {
         const list = useListInstance({ props: {} });
         const filter = useListFilter({
             parentState: list.state,
-            allowedFilter: (object) => object.id == 1 || object.id == 3,
-        });
-        await nextTick();
-        expect(filter.state.objects).toEqual({});
-        list.addListObject({ id: 1, name: "one", has_things: true });
-        await nextTick();
-        expect(filter.state.objects).toEqual({
-            1: { id: 1, name: "one", has_things: true },
-        });
-        list.addListObject({ id: 2, name: "two", has_things: true });
-        await nextTick();
-        expect(filter.state.objects).toEqual({
-            1: { id: 1, name: "one", has_things: true },
-        });
-        list.addListObject({ id: 3, name: "three", has_things: true });
-        await nextTick();
-        expect(filter.state.objects).toEqual({
-            1: { id: 1, name: "one", has_things: true },
-            3: { id: 3, name: "three", has_things: true },
-        });
-        list.addListObject({ id: 4, name: "four", has_things: true });
-        await nextTick();
-        expect(filter.state.objects).toEqual({
-            1: { id: 1, name: "one", has_things: true },
-            3: { id: 3, name: "three", has_things: true },
-        });
-    });
-    it("should match by search term", async () => {
-        const textSearchValue = ref("one");
-        const list = useListInstance({ props: {} });
-        const filter = useListFilter({
-            parentState: list.state,
-            useTextSearch: true,
-            textSearchRules: ["name"],
-            textSearchValue,
-        });
-        await nextTick();
-        // todo: it would be nice to wait for all searches to finish, instead of awaiting the first one back.
-        await doAwaitNot({
-            obj: filter.state,
-            prop: "searching",
+            allowedFilter: (object) => object.id === 1 || object.id === 3,
         });
-        await nextTick();
         expect(filter.state.objects).toEqual({});
         list.addListObject({ id: 1, name: "one", has_things: true });
-        await nextTick();
         await doAwaitNot({
             obj: filter.state,
-            prop: "searching",
+            prop: "running",
+            timeout: 100,
         });
-        await nextTick();
         expect(filter.state.objects).toEqual({
             1: { id: 1, name: "one", has_things: true },
         });
         list.addListObject({ id: 2, name: "two", has_things: true });
-        await nextTick();
         await doAwaitNot({
             obj: filter.state,
-            prop: "searching",
+            prop: "running",
+            timeout: 100,
         });
-        await nextTick();
         expect(filter.state.objects).toEqual({
             1: { id: 1, name: "one", has_things: true },
         });
         list.addListObject({ id: 3, name: "three", has_things: true });
-        await nextTick();
         await doAwaitNot({
             obj: filter.state,
-            prop: "searching",
+            prop: "running",
+            timeout: 100,
         });
-        await nextTick();
         expect(filter.state.objects).toEqual({
             1: { id: 1, name: "one", has_things: true },
-        });
-        textSearchValue.value = "three";
-        await nextTick();
-        await doAwaitNot({
-            obj: filter.state,
-            prop: "searching",
-        });
-        await nextTick();
-        expect(filter.state.objects).toEqual({
             3: { id: 3, name: "three", has_things: true },
         });
         list.addListObject({ id: 4, name: "four", has_things: true });
-        await nextTick();
         await doAwaitNot({
             obj: filter.state,
-            prop: "searching",
+            prop: "running",
+            timeout: 100,
         });
-        await nextTick();
         expect(filter.state.objects).toEqual({
+            1: { id: 1, name: "one", has_things: true },
             3: { id: 3, name: "three", has_things: true },
         });
     });
@@ -156,60 +68,41 @@ describe("use/listFilter", () => {
             parentState: list.state,
             excludedFilter: (object) => object.id == 2 || object.id == 4,
         });
-        await nextTick();
         expect(filter.state.objects).toEqual({});
         list.addListObject({ id: 1, name: "one", has_things: true });
-        await nextTick();
-        expect(filter.state.objects).toEqual({
-            1: { id: 1, name: "one", has_things: true },
-        });
-        list.addListObject({ id: 2, name: "two", has_things: true });
-        await nextTick();
-        expect(filter.state.objects).toEqual({
-            1: { id: 1, name: "one", has_things: true },
-        });
-        list.addListObject({ id: 3, name: "three", has_things: true });
-        await nextTick();
-        expect(filter.state.objects).toEqual({
-            1: { id: 1, name: "one", has_things: true },
-            3: { id: 3, name: "three", has_things: true },
-        });
-        list.addListObject({ id: 4, name: "four", has_things: true });
-        await nextTick();
-        expect(filter.state.objects).toEqual({
-            1: { id: 1, name: "one", has_things: true },
-            3: { id: 3, name: "three", has_things: true },
-        });
-    });
-    it("should exclude an excludedValues parameter", async () => {
-        const list = useListInstance({ props: {} });
-        const filter = useListFilter({
-            parentState: list.state,
-            excludedValues: reactive({
-                2: true,
-                4: true,
-            }),
+        await doAwaitNot({
+            obj: filter.state,
+            prop: "running",
+            timeout: 100,
         });
-        await nextTick();
-        expect(filter.state.objects).toEqual({});
-        list.addListObject({ id: 1, name: "one", has_things: true });
-        await nextTick();
         expect(filter.state.objects).toEqual({
             1: { id: 1, name: "one", has_things: true },
         });
         list.addListObject({ id: 2, name: "two", has_things: true });
-        await nextTick();
+        await doAwaitNot({
+            obj: filter.state,
+            prop: "running",
+            timeout: 100,
+        });
         expect(filter.state.objects).toEqual({
             1: { id: 1, name: "one", has_things: true },
         });
         list.addListObject({ id: 3, name: "three", has_things: true });
-        await nextTick();
+        await doAwaitNot({
+            obj: filter.state,
+            prop: "running",
+            timeout: 100,
+        });
         expect(filter.state.objects).toEqual({
             1: { id: 1, name: "one", has_things: true },
             3: { id: 3, name: "three", has_things: true },
         });
         list.addListObject({ id: 4, name: "four", has_things: true });
-        await nextTick();
+        await doAwaitNot({
+            obj: filter.state,
+            prop: "running",
+            timeout: 100,
+        });
         expect(filter.state.objects).toEqual({
             1: { id: 1, name: "one", has_things: true },
             3: { id: 3, name: "three", has_things: true },
@@ -228,9 +121,7 @@ describe("use/listFilter", () => {
         }
         const filter = useListFilter({
             parentState: listInstance.state,
-            useTextSearch: true,
         });
-        await nextTick();
         expect(filter.state.objects).toEqual(listInstance.state.objects);
     });
     describe("useListFilter operates on parentState modified by useListSort", () => {
@@ -259,7 +150,10 @@ describe("use/listFilter", () => {
             const filter = useListFilter({
                 parentState: listSort.state,
             });
-            await nextTick();
+            await doAwaitNot({
+                obj: filter.state,
+                prop: "running",
+            });
             expect(filter.state.order).toEqual(expectedOrder);
             expect(filter.state.objectsInOrder).toEqual(orderedObjects);
         });
@@ -286,32 +180,22 @@ describe("use/listFilter", () => {
                     },
                 },
             });
+            const excludedFilter = (object) => object.id === 1 || object.name === "three";
+            const allowedFilter = (object) => object.id === 2 || object.name === "four";
             const listFilterA = useListFilter({
                 parentState: listInstanceA.state,
-                excludedValues: {
-                    id: 1,
-                    name: "three",
-                },
+                excludedFilter,
             });
             const listFilterB = useListFilter({
                 parentState: listInstanceB.state,
-                allowedValues: {
-                    id: 2,
-                    name: "four",
-                },
+                allowedFilter,
             });
             const listFilterArgs = {
                 A: {
-                    excludedValues: {
-                        id: 1,
-                        name: "three",
-                    },
+                    excludedFilter,
                 },
                 B: {
-                    allowedValues: {
-                        id: 2,
-                        name: "four",
-                    },
+                    allowedFilter,
                 },
             };
             const listInstances = {
@@ -320,12 +204,298 @@ describe("use/listFilter", () => {
             };
             const listFilters = useListFilters(listFilterArgs, listInstances);
 
-            expect(listFilters.A.state.excludedValues).toEqual({ id: 1, name: "three" });
-            expect(listFilters.B.state.allowedValues).toEqual({ id: 2, name: "four" });
-            expect(deepUnref(listFilters.A.parentState)).toEqual(deepUnref(listFilterA.parentState));
-            expect(deepUnref(listFilters.B.parentState)).toEqual(deepUnref(listFilterB.parentState));
+            expect(listFilters.A.state.excludedFilter).toEqual(listFilterArgs.A.excludedFilter);
+            expect(listFilters.B.state.allowedFilter).toEqual(listFilterArgs.B.allowedFilter);
+            expect(unref(listFilters.A.parentState)).toEqual(unref(listFilterA.parentState));
+            expect(unref(listFilters.B.parentState)).toEqual(unref(listFilterB.parentState));
             expect(deepUnref(listFilters.A.state)).toEqual(deepUnref(listFilterA.state));
             expect(deepUnref(listFilters.B.state)).toEqual(deepUnref(listFilterB.state));
         });
     });
+    describe("useListFilters updates index when", () => {
+        it("parentInstance.objects is updated", async () => {
+            const list = useListInstance({ props: {} });
+            const filter = useListFilter({
+                parentState: list.state,
+                allowedFilter: (object) => !!object.allowed?.every((e) => e),
+            });
+            await doAwaitNot({
+                obj: filter.state,
+                prop: "running",
+                timeout: 100,
+            });
+            expect(filter.state.objects).toEqual({});
+            list.addListObject({ id: 1, name: "one", has_things: true, allowed: [true, true] });
+            await doAwaitNot({
+                obj: filter.state,
+                prop: "running",
+                timeout: 100,
+            });
+            expect(filter.state.objects).toEqual({
+                1: { id: 1, name: "one", has_things: true, allowed: [true, true] },
+            });
+            list.addListObject({ id: 2, name: "two", has_things: true, allowed: [true, false] });
+            await doAwaitNot({
+                obj: filter.state,
+                prop: "running",
+                timeout: 100,
+            });
+            expect(filter.state.objects).toEqual({
+                1: { id: 1, name: "one", has_things: true, allowed: [true, true] },
+            });
+            list.state.objects[1].allowed[0] = false;
+            list.state.objects[2].allowed[1] = true;
+            await doAwaitNot({
+                obj: filter.state,
+                prop: "running",
+                timeout: 100,
+            });
+            expect(filter.state.objects).toEqual({
+                2: { id: 2, name: "two", has_things: true, allowed: [true, true] },
+            });
+        });
+        it("parentInstance.relatedObjects is updated", async () => {
+            const list = useListInstance({ props: {} });
+            const relatedList = useListInstance({ props: {} });
+            const related = useListRelated({
+                parentState: list.state,
+                relatedObjectsRules: {
+                    relatedRuleName: {
+                        objects: relatedList.state.objects,
+                        pkKey: "related_id",
+                    },
+                },
+            });
+            const allowedFilter = ref();
+            allowedFilter.value = (object, relatedObject) =>
+                relatedObject.relatedRuleName.allowed && relatedObject.relatedRuleName.has_things && object.has_things;
+            const filter = useListFilter({
+                parentState: related.state,
+                allowedFilter,
+            });
+            await doAwaitNot({
+                obj: filter.state,
+                prop: "running",
+                timeout: 100,
+            });
+            expect(filter.state.objects).toEqual({});
+            relatedList.addListObject({ id: 2, name: "two", has_things: true, allowed: true });
+            list.addListObject({ id: 1, name: "one", has_things: true, related_id: 2 });
+            await doAwaitNot({
+                obj: filter.state,
+                prop: "running",
+                timeout: 100,
+            });
+            expect(filter.state.objects).toEqual({
+                1: { id: 1, name: "one", has_things: true, related_id: 2 },
+            });
+            relatedList.addListObject({ id: 4, name: "four", has_things: true, allowed: false });
+            list.addListObject({ id: 3, name: "three", has_things: true, related_id: 4 });
+            await doAwaitNot({
+                obj: filter.state,
+                prop: "running",
+                timeout: 100,
+            });
+            expect(filter.state.objects).toEqual({
+                1: { id: 1, name: "one", has_things: true, related_id: 2 },
+            });
+            relatedList.state.objects[2].allowed = false;
+            relatedList.state.objects[4].allowed = true;
+            await doAwaitNot({
+                obj: filter.state,
+                prop: "running",
+                timeout: 100,
+            });
+            expect(filter.state.objects).toEqual({
+                3: { id: 3, name: "three", has_things: true, related_id: 4 },
+            });
+        });
+        it("parentInstance.calculatedObjects is updated", async () => {
+            const list = useListInstance({ props: {} });
+            const calculated = useListCalculated({
+                parentState: list.state,
+                calculatedObjectsRules: reactive({
+                    calculatedRuleName: (object) => object.things_count + object.other_things_count,
+                }),
+            });
+            const allowedFilter = ref();
+            allowedFilter.value = (object, relatedObject, calculatedObject) => calculatedObject.calculatedRuleName > 5;
+            const filter = useListFilter({
+                parentState: calculated.state,
+                allowedFilter,
+            });
+            await doAwaitNot({
+                obj: filter.state,
+                prop: "running",
+            });
+            expect(filter.state.objects).toEqual({});
+            list.addListObject({ id: 1, name: "one", has_things: true, things_count: 2, other_things_count: 3 });
+            await doAwaitNot({
+                obj: filter.state,
+                prop: "running",
+            });
+            expect(filter.state.objects).toEqual({});
+            list.addListObject({ id: 2, name: "two", has_things: true, things_count: 2, other_things_count: 4 });
+            await doAwaitNot({
+                obj: filter.state,
+                prop: "running",
+            });
+            expect(filter.state.objects).toEqual({
+                2: { id: 2, name: "two", has_things: true, things_count: 2, other_things_count: 4 },
+            });
+            list.state.objects[1].things_count = 4;
+            list.state.objects[2].other_things_count = 0;
+            await doAwaitNot({
+                obj: filter.state,
+                prop: "running",
+            });
+            expect(filter.state.objects).toEqual({
+                1: { id: 1, name: "one", has_things: true, things_count: 4, other_things_count: 3 },
+            });
+        });
+    });
+    it("you can use nested useListFilters", async () => {
+        const list = useListInstance({ props: {} });
+
+        function filter1AllowedFilter(object) {
+            return object.has_things && object.has_stuff;
+        }
+
+        function filter2AllowedFilter(object) {
+            return object.has_things && object.has_other_stuff;
+        }
+
+        const filter1 = useListFilter({
+            parentState: list.state,
+            allowedFilter: filter1AllowedFilter,
+        });
+        const filter2 = useListFilter({
+            parentState: filter1.state,
+            allowedFilter: filter2AllowedFilter,
+        });
+        await doAwaitNot({
+            obj: filter1.state,
+            prop: "running",
+        });
+        await doAwaitNot({
+            obj: filter2.state,
+            prop: "running",
+        });
+        expect(filter1.state.objects).toEqual({});
+        expect(filter1.state.order).toEqual([]);
+        expect(filter2.state.objects).toEqual({});
+        expect(filter2.state.order).toEqual([]);
+        list.addListObject({ id: 1, name: "one", has_things: true, has_stuff: true, has_other_stuff: true });
+        await doAwaitNot({
+            obj: filter1.state,
+            prop: "running",
+        });
+        await doAwaitNot({
+            obj: filter2.state,
+            prop: "running",
+        });
+        expect(filter1.state.objects).toEqual({
+            1: { id: 1, name: "one", has_things: true, has_stuff: true, has_other_stuff: true },
+        });
+        expect(filter1.state.order).toEqual(["1"]);
+        expect(filter2.state.objects).toEqual({
+            1: { id: 1, name: "one", has_things: true, has_stuff: true, has_other_stuff: true },
+        });
+        expect(filter2.state.order).toEqual(["1"]);
+        list.addListObject({ id: 2, name: "two", has_things: true, has_stuff: true, has_other_stuff: false });
+        await doAwaitNot({
+            obj: filter1.state,
+            prop: "running",
+        });
+        await doAwaitNot({
+            obj: filter2.state,
+            prop: "running",
+        });
+        expect(filter1.state.objects).toEqual({
+            1: { id: 1, name: "one", has_things: true, has_stuff: true, has_other_stuff: true },
+            2: { id: 2, name: "two", has_things: true, has_stuff: true, has_other_stuff: false },
+        });
+        expect(filter1.state.order).toEqual(["1", "2"]);
+        expect(filter2.state.objects).toEqual({
+            1: { id: 1, name: "one", has_things: true, has_stuff: true, has_other_stuff: true },
+        });
+        expect(filter2.state.order).toEqual(["1"]);
+        list.addListObject({ id: 3, name: "three", has_things: true, has_stuff: false, has_other_stuff: true });
+        await doAwaitNot({
+            obj: filter1.state,
+            prop: "running",
+        });
+        await doAwaitNot({
+            obj: filter2.state,
+            prop: "running",
+        });
+        expect(filter1.state.objects).toEqual({
+            1: { id: 1, name: "one", has_things: true, has_stuff: true, has_other_stuff: true },
+            2: { id: 2, name: "two", has_things: true, has_stuff: true, has_other_stuff: false },
+        });
+        expect(filter1.state.order).toEqual(["1", "2"]);
+        expect(filter2.state.objects).toEqual({
+            1: { id: 1, name: "one", has_things: true, has_stuff: true, has_other_stuff: true },
+        });
+        expect(filter2.state.order).toEqual(["1"]);
+        list.addListObject({ id: 4, name: "four", has_things: true, has_stuff: false, has_other_stuff: false });
+        await doAwaitNot({
+            obj: filter1.state,
+            prop: "running",
+        });
+        await doAwaitNot({
+            obj: filter2.state,
+            prop: "running",
+        });
+        expect(filter1.state.objects).toEqual({
+            1: { id: 1, name: "one", has_things: true, has_stuff: true, has_other_stuff: true },
+            2: { id: 2, name: "two", has_things: true, has_stuff: true, has_other_stuff: false },
+        });
+        expect(filter1.state.order).toEqual(["1", "2"]);
+        expect(filter2.state.objects).toEqual({
+            1: { id: 1, name: "one", has_things: true, has_stuff: true, has_other_stuff: true },
+        });
+        expect(filter2.state.order).toEqual(["1"]);
+        list.state.objects[1].has_stuff = false;
+        list.state.objects[2].has_other_stuff = true;
+        await doAwaitNot({
+            obj: filter1.state,
+            prop: "running",
+        });
+        await doAwaitNot({
+            obj: filter2.state,
+            prop: "running",
+        });
+        expect(filter1.state.objects).toEqual({
+            2: { id: 2, name: "two", has_things: true, has_stuff: true, has_other_stuff: true },
+        });
+        expect(filter1.state.order).toEqual(["2"]);
+        expect(filter2.state.objects).toEqual({
+            2: { id: 2, name: "two", has_things: true, has_stuff: true, has_other_stuff: true },
+        });
+        expect(filter2.state.order).toEqual(["2"]);
+        list.addListObject({ id: 5, name: "five", has_things: true, has_stuff: false, has_other_stuff: true });
+        list.addListObject({ id: 6, name: "six", has_things: true, has_stuff: true, has_other_stuff: false });
+        list.addListObject({ id: 7, name: "seven", has_things: false, has_stuff: true, has_other_stuff: true });
+        list.addListObject({ id: 8, name: "eight", has_things: true, has_stuff: true, has_other_stuff: true });
+        await doAwaitNot({
+            obj: filter1.state,
+            prop: "running",
+        });
+        await doAwaitNot({
+            obj: filter2.state,
+            prop: "running",
+        });
+        expect(filter1.state.objects).toEqual({
+            2: { id: 2, name: "two", has_things: true, has_stuff: true, has_other_stuff: true },
+            6: { id: 6, name: "six", has_things: true, has_stuff: true, has_other_stuff: false },
+            8: { id: 8, name: "eight", has_things: true, has_stuff: true, has_other_stuff: true },
+        });
+        expect(filter1.state.order).toEqual(["2", "6", "8"]);
+        expect(filter2.state.objects).toEqual({
+            2: { id: 2, name: "two", has_things: true, has_stuff: true, has_other_stuff: true },
+            8: { id: 8, name: "eight", has_things: true, has_stuff: true, has_other_stuff: true },
+        });
+        expect(filter2.state.order).toEqual(["2", "8"]);
+    });
 });

package/tests/unit/use/listInstance.spec.js

@@ -1,3 +1,4 @@
+import { doAwaitNot } from "../../../utils/index.js";
 import { expectErrorToBeNull } from "../expectHelpers.js";
 import flushPromises from "flush-promises";
 import keyBy from "lodash-es/keyBy.js";
@@ -308,6 +309,7 @@ describe("use/listInstance.spec.js", function () {
             expect(listInstance.state.errored).toBe(false);
             expect(listInstance.state.loading).toBe(false);
             expect({ ...listInstance.state.objects }).toEqual(crudListResolvedObjects2);
+            await nextTick();
             await flushPromises();
             expect(listInstance.state.order).toEqual(Object.keys(crudListResolvedObjects2));
             expect(listInstance.state.objectsInOrder).toEqual(Object.values(crudListResolvedObjects2));
@@ -429,7 +431,7 @@ describe("use/listInstance.spec.js", function () {
             expect(fakeId).toBeTruthy();
         });
     });
-    it("computes objectsInOrder and maintains state", () => {
+    it("computes objectsInOrder and maintains state", async () => {
         const crudListResolvedPage3 = [
             {
                 id: 3,
@@ -447,6 +449,7 @@ describe("use/listInstance.spec.js", function () {
                 name: "zxcv",
             },
         ];
+        const crudListResolvedObjects3 = keyBy(crudListResolvedPage3, "id");
         const addObject = {
             id: 4,
             __str__: "yuio",
@@ -467,12 +470,22 @@ describe("use/listInstance.spec.js", function () {
 
         passedPageCallback(crudListResolvedPage3);
         crudListResolve();
+        await doAwaitNot({
+            obj: listInstance.state,
+            prop: "loading",
+        });
+        expect(listInstance.state.objects).toEqual(crudListResolvedObjects3);
+        expect(listInstance.state.order).toEqual(crudListResolvedPage3.map((e) => e.id.toString()));
         expect(listInstance.state.objectsInOrder).toEqual(crudListResolvedPage3);
         listInstance.addListObject(addObject);
         crudListResolvedPage3.push(addObject);
+        await nextTick();
+        expect(listInstance.state.order).toEqual(crudListResolvedPage3.map((e) => e.id.toString()));
         expect(listInstance.state.objectsInOrder).toEqual(crudListResolvedPage3);
         listInstance.deleteListObject(8);
         crudListResolvedPage3.splice(1, 1);
+        await nextTick();
+        expect(listInstance.state.order).toEqual(crudListResolvedPage3.map((e) => e.id.toString()));
         expect(listInstance.state.objectsInOrder).toEqual(crudListResolvedPage3);
     });
 });