@ryupold/vode 1.8.8 → 1.8.11

package/test/tests-children.ts

@@ -2,68 +2,68 @@ import { children, child, childCount, childrenStart, DIV, SPAN, P, Vode } from "
 import { expect } from "./helper";
 
 export default {
-    "children(): tag+props+children returns children array": () => {
+    "children(): tag+props+children returns children array": async () => {
         const v: Vode = [DIV, { class: "x" }, [SPAN, "a"], [P, "b"]];
         const c = children(v);
-        expect(Array.isArray(c)).toEqual(true);
-        expect(c!.length).toEqual(2);
+        await expect(Array.isArray(c)).toEqual(true);
+        await expect(c!.length).toEqual(2);
     },
 
-    "children(): tag+children (no props) returns children array": () => {
+    "children(): tag+children (no props) returns children array": async () => {
         const v: Vode = [DIV, [SPAN, "a"], [P, "b"]];
         const c = children(v);
-        expect(Array.isArray(c)).toEqual(true);
-        expect(c!.length).toEqual(2);
+        await expect(Array.isArray(c)).toEqual(true);
+        await expect(c!.length).toEqual(2);
     },
 
-    "children(): just-tag vode returns null": () => {
-        expect(children([DIV])).toEqual(null);
+    "children(): just-tag vode returns null": async () => {
+        await expect(children([DIV])).toEqual(null);
     },
 
-    "children(): text vode returns null": () => {
-        expect(children("hello")).toEqual(null);
+    "children(): text vode returns null": async () => {
+        await expect(children("hello")).toEqual(null);
     },
 
-    "childrenStart(): with props+children returns 2": () => {
-        expect(childrenStart([DIV, { class: "x" }, [SPAN]])).toEqual(2);
+    "childrenStart(): with props+children returns 2": async () => {
+        await expect(childrenStart([DIV, { class: "x" }, [SPAN]])).toEqual(2);
     },
 
-    "childrenStart(): without props but with children returns 1": () => {
-        expect(childrenStart([DIV, [SPAN]])).toEqual(1);
+    "childrenStart(): without props but with children returns 1": async () => {
+        await expect(childrenStart([DIV, [SPAN]])).toEqual(1);
     },
 
-    "childrenStart(): just-tag returns -1": () => {
-        expect(childrenStart([DIV])).toEqual(-1);
+    "childrenStart(): just-tag returns -1": async () => {
+        await expect(childrenStart([DIV])).toEqual(-1);
     },
 
-    "childrenStart(): text vode returns -1": () => {
-        expect(childrenStart("hello")).toEqual(-1);
+    "childrenStart(): text vode returns -1": async () => {
+        await expect(childrenStart("hello")).toEqual(-1);
     },
 
-    "childCount(): matches actual child count": () => {
-        expect(childCount([DIV, { class: "x" }, [SPAN, "a"], [P, "b"]])).toEqual(2);
-        expect(childCount([DIV, [SPAN]])).toEqual(1);
+    "childCount(): matches actual child count": async () => {
+        await expect(childCount([DIV, { class: "x" }, [SPAN, "a"], [P, "b"]])).toEqual(2);
+        await expect(childCount([DIV, [SPAN]])).toEqual(1);
     },
 
-    "childCount(): returns 0 for no-children vode": () => {
-        expect(childCount([DIV])).toEqual(0);
-        expect(childCount("hello" as any)).toEqual(0);
+    "childCount(): returns 0 for no-children vode": async () => {
+        await expect(childCount([DIV])).toEqual(0);
+        await expect(childCount("hello" as any)).toEqual(0);
     },
 
-    "child(): returns correct child at index": () => {
+    "child(): returns correct child at index": async () => {
         const v: Vode = [DIV, { class: "x" }, [SPAN, "a"], [P, "b"]];
 
-        expect(child(v, 0)).toEqual([SPAN, "a"]);
-        expect(child(v, 1)).toEqual([P, "b"]);
+        await expect(child(v, 0)).toEqual([SPAN, "a"]);
+        await expect(child(v, 1)).toEqual([P, "b"]);
     },
 
-    "child(): returns undefined for out-of-bounds": () => {
-        expect(child([DIV, { class: "x" }, [SPAN]], 5))
+    "child(): returns undefined for out-of-bounds": async () => {
+        await expect(child([DIV, { class: "x" }, [SPAN]], 5))
             .toEqual(undefined);
     },
 
-    "child(): returns undefined for text vode": () => {
-        expect(child("hello" as any, 0))
+    "child(): returns undefined for text vode": async () => {
+        await expect(child("hello" as any, 0))
             .toEqual(undefined);
     }
 };

package/test/tests-createPatch.ts

@@ -2,27 +2,27 @@ import { createPatch } from "../src/vode";
 import { expect } from "./helper";
 
 export default {
-    "createPatch(): just returns the input": () => {
+    "createPatch(): just returns the input": async () => {
         const p = { a: 123 };
-        expect(createPatch(p) === p).toEqual(true);
+        await expect(createPatch(p) === p).toEqual(true);
     },
 
-    "createPatch(): returns undefined as-is": () => {
-        expect(createPatch(undefined)).toEqual(undefined);
+    "createPatch(): returns undefined as-is": async () => {
+        await expect(createPatch(undefined)).toEqual(undefined);
     },
 
-    "createPatch(): returns null as-is": () => {
-        expect(createPatch(null)).toEqual(null);
+    "createPatch(): returns null as-is": async () => {
+        await expect(createPatch(null)).toEqual(null);
     },
 
-    "createPatch(): returns function as-is": () => {
+    "createPatch(): returns function as-is": async () => {
         const fn = () => ({});
-        expect(createPatch(fn) === fn).toEqual(true);
+        await expect(createPatch(fn) === fn).toEqual(true);
     },
 
-    "createPatch(): returns primitive as-is": () => {
-        expect(createPatch(42)).toEqual(42);
-        expect(createPatch("ignored")).toEqual("ignored");
-        expect(createPatch(false)).toEqual(false);
+    "createPatch(): returns primitive as-is": async () => {
+        await expect(createPatch(42)).toEqual(42);
+        await expect(createPatch("ignored")).toEqual("ignored");
+        await expect(createPatch(false)).toEqual(false);
     }
 };

package/test/tests-createState.ts

@@ -2,24 +2,24 @@ import { expect } from "./helper";
 import { createState, app, DIV } from "../index";
 
 export default {
-    "createState(): throws when state is not an object": () => {
+    "createState(): throws when state is not an object": async () => {
         const err = expect(() => createState(null as any)).toFail();
-        expect(err.message)
+        await expect(err.message)
             .toEqual("createState() must be called with a state object");
     },
 
-    "createState(): adds patch function to state": () => {
+    "createState(): adds patch function to state": async () => {
         const state = createState({ x: 1 });
-        expect(typeof (state as any).patch).toEqual("function");
-        expect((state)).toEqual({ x: 1, patch: (state as any).patch });
+        await expect(typeof (state as any).patch).toEqual("function");
+        await expect((state)).toEqual({ x: 1, patch: (state as any).patch });
     },
 
-    "createState(): patch is non-enumerable": () => {
+    "createState(): patch is non-enumerable": async () => {
         const state = createState({ x: 1 });
-        expect(Object.keys(state)).toEqual(["x"]);
+        await expect(Object.keys(state)).toEqual(["x"]);
     },
 
-    "createState(): app picks up queued patches": () => {
+    "createState(): app picks up queued patches": async () => {
         const state: any = createState({ count: 0 });
         state.patch({ count: 1 });
         state.patch({ count: 2 });
@@ -28,16 +28,16 @@ export default {
         root.appendChild(container);
         app(container, state, () => [DIV]);
 
-        expect(state.count)
+        await expect(state.count)
             .toEqual(2);
     },
 
-    "createState(): already-patchable state is kept as-is": () => {
+    "createState(): already-patchable state is kept as-is": async () => {
         const existingPatch = (action: any) => { };
         const state: any = { value: 5, patch: existingPatch };
         const result = createState(state);
 
-        expect(result.patch === existingPatch)
+        await expect(result.patch === existingPatch)
             .toEqual(true);
     },
 };

package/test/tests-defuse.ts

@@ -9,56 +9,56 @@ export default {
             .toSucceed();
     },
 
-    "defuse(): removes _vode from container": () => {
+    "defuse(): removes _vode from container": async () => {
         const root = document.createElement("div");
         const container = document.createElement("div");
         root.appendChild(container);
         app(container, {}, () => [DIV]);
-        expect(typeof (container as any)._vode).toEqual("object");
+        await expect(typeof (container as any)._vode).toEqual("object");
         defuse(container as any);
 
-        expect((container as any)._vode)
+        await expect((container as any)._vode)
             .toEqual(undefined);
     },
 
-    "defuse(): removes patch function from state": () => {
+    "defuse(): removes patch function from state": async () => {
         const root = document.createElement("div");
         const container = document.createElement("div");
         root.appendChild(container);
         const state: any = {};
         app(container, state, () => [DIV]);
-        expect(typeof state.patch).toEqual("function");
+        await expect(typeof state.patch).toEqual("function");
         defuse(container as any);
 
-        expect(state.patch)
+        await expect(state.patch)
             .toEqual(undefined);
     },
 
-    "defuse(): disables renderSync and renderAsync": () => {
+    "defuse(): disables renderSync and renderAsync": async () => {
         const root = document.createElement("div");
         const container = document.createElement("div");
         root.appendChild(container);
         app(container, {}, () => [DIV]);
         defuse(container as any);
 
-        expect((container as any)._vode)
+        await expect((container as any)._vode)
             .toEqual(undefined);
     },
 
-    "defuse(): clears event listeners from rendered elements": () => {
+    "defuse(): clears event listeners from rendered elements": async () => {
         const root = document.createElement("div");
         const container = document.createElement("div");
         root.appendChild(container);
         app(container, {}, () => [DIV, { onclick: () => ({}) }] as any);
         const node = (container as any)._vode.vode.node;
-        expect(typeof node.onclick).toEqual("function");
+        await expect(typeof node.onclick).toEqual("function");
         defuse(container as any);
 
-        expect(node.onclick)
+        await expect(node.onclick)
             .toEqual(null);
     },
 
-    "defuse(): recurses into child containers": () => {
+    "defuse(): recurses into child containers": async () => {
         const root = document.createElement("div");
         const outer = document.createElement("div");
         const inner = document.createElement("div");
@@ -68,11 +68,11 @@ export default {
         app(inner, state, () => [DIV]);
         defuse(outer as any);
 
-        expect(state.patch)
+        await expect(state.patch)
             .toEqual(undefined);
     },
 
-    "defuse(): clears event listeners from child vodes without _vode": () => {
+    "defuse(): clears event listeners from child vodes without _vode": async () => {
         const root = document.createElement("div");
         const container = document.createElement("div");
         root.appendChild(container);
@@ -83,13 +83,13 @@ export default {
         const child1 = (v as any).node;
         const child1onclick = child1.onclick;
         const child2 = (v as any)[2].node;
-        expect(typeof child1onclick).toEqual("function");
-        expect(typeof child2.onclick).toEqual("function");
+        await expect(typeof child1onclick).toEqual("function");
+        await expect(typeof child2.onclick).toEqual("function");
         defuse(container as any);
 
-        expect(child1.onclick)
+        await expect(child1.onclick)
             .toEqual(null);
-        expect(child2.onclick)
+        await expect(child2.onclick)
             .toEqual(null);
     },
 };