@ryupold/vode 1.8.7 → 1.8.10

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,7 +68,28 @@ 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": async () => {
+        const root = document.createElement("div");
+        const container = document.createElement("div");
+        root.appendChild(container);
+        app(container, {}, () => [DIV, { onclick: () => ({}) },
+            [DIV, { onclick: () => ({}) }]
+        ] as any);
+        const v = (container as any)._vode.vode;
+        const child1 = (v as any).node;
+        const child1onclick = child1.onclick;
+        const child2 = (v as any)[2].node;
+        await expect(typeof child1onclick).toEqual("function");
+        await expect(typeof child2.onclick).toEqual("function");
+        defuse(container as any);
+
+        await expect(child1.onclick)
+            .toEqual(null);
+        await expect(child2.onclick)
+            .toEqual(null);
+    },
 };