@ryupold/vode 1.8.8 → 1.8.11

package/test/helper.ts

@@ -1,205 +1,358 @@
 import { children, ChildVode, PatchableState, props, tag, Vode } from "../src/vode";
 import { FakeElement, FakeTextNode } from "./mocks";
 
+// Helper to detect if we're in a browser environment with real DOM
+const isBrowser = typeof window !== 'undefined' && typeof HTMLElement !== 'undefined';
+
+// Type guards for real DOM elements
+function isRealElement(node: any): node is HTMLElement {
+    return isBrowser && node instanceof HTMLElement;
+}
+function isRealTextNode(node: any): node is Text {
+    return isBrowser && node instanceof Text;
+}
+
+export const delay = (ms: number) => new Promise(resolve => setTimeout(resolve, ms));
+
+function retry<T = void>(fn: () => Promise<T>, waitTime: number): Promise<T> {
+    const { promise, resolve, reject } = Promise.withResolvers<T>();
+
+    function retryInternal(timeLeft: number) {
+        const start = performance.now();
+        try {
+            const prom = fn();
+            if (typeof prom?.then === "function") {
+                prom.then(resolve).catch((err) => {
+                    if (timeLeft >= 0) {
+                        setTimeout(
+                            () => retryInternal(timeLeft - (performance.now() - start)),
+                            10
+                        );
+                    } else {
+                        reject(err);
+                    }
+                });
+            } else {
+                resolve(prom);
+            }
+        } catch (err) {
+            if (timeLeft >= 0) {
+                setTimeout(() => {
+                    retryInternal(timeLeft - (performance.now() - start))
+                }, 10);
+            } else {
+                reject(err);
+            }
+        }
+    }
+
+    retryInternal(waitTime);
+
+    return promise;
+}
+
 export class Expectation {
     constructor(public readonly what: any) { }
 
+    toBeNotHidden() {
+        if (document.hidden) {
+            throw new ExpectationError(this, `expect the document to be not hidden. if you run this in a real browser this means the window must be in focus in order for the tests to work.`);
+        }
+    }
+
     toBeA(type: "undefined" | "object" | "function" | "bigint" | "boolean" | "number" | "string" | "symbol", failMessage?: string) {
         if (typeof this.what !== type) {
             throw new ExpectationError(this, `expected \n\ntypeof ${this.what}\n\nto be \n\n${type}${failMessage ? `\n\n${failMessage}` : ""}`);
         }
     }
 
-    toEqual(other: any, failMessage?: string) {
-        const failSuffix = failMessage ? `\n\n${failMessage}` : "";
+    toBeGreaterThan(other: number, failMessage?: string) {
+        if (!(this.what > other)) {
+            throw new ExpectationError(this, `expected \n\n${this.what}\n\nto be >\n\n${other}${failMessage ? `\n\n${failMessage}` : ""}`);
+        }
+    }
 
-        function deepCompare(a: any, b: any, path: string[]): string[] | null {
-            if (typeof a !== typeof b) {
-                if (path.length === 0) path.push(``);
-                path[path.length - 1] += ` (type: ${typeof a} != ${typeof b})`;
-                return path;
-            }
+    toBeGreaterOrEqualThan(other: number, failMessage?: string) {
+        if (!(this.what >= other)) {
+            throw new ExpectationError(this, `expected \n\n${this.what}\n\nto be >= \n\n${other}${failMessage ? `\n\n${failMessage}` : ""}`);
+        }
+    }
 
-            if (typeof a !== "object" || a === null) {
-                if (path.length === 0) path.push(``);
-                path[path.length - 1] += ` (value: ${a} != ${b})`;
-                return a !== b ? path : null;
-            }
+    toBeSmallerThan(other: number, failMessage?: string) {
+        if (!(this.what < other)) {
+            throw new ExpectationError(this, `expected \n\n${this.what}\n\nto be <\n\n${other}${failMessage ? `\n\n${failMessage}` : ""}`);
+        }
+    }
 
-            for (const prop of Object.entries(a)) {
-                const [k, v] = prop;
-                const result = deepCompare(v, b[k], [...path, k]);
-                if (result) {
-                    return result;
+    toBeSmallerOrEqual(other: number, failMessage?: string) {
+        if (!(this.what <= other)) {
+            throw new ExpectationError(this, `expected \n\n${this.what}\n\nto be <= \n\n${other}${failMessage ? `\n\n${failMessage}` : ""}`);
+        }
+    }
+
+    async toEqual(other: any, failMessage?: string, waitTimeMs: number = 100) {
+        return await retry(
+            async () => {
+                const failSuffix = failMessage ? `\n\n${failMessage}` : "";
+
+                function deepCompare(a: any, b: any, path: string[]): string[] | null {
+                    if (typeof a !== typeof b) {
+                        if (path.length === 0) path.push(``);
+                        path[path.length - 1] += ` (type: ${typeof a} != ${typeof b})`;
+                        return path;
+                    }
+
+                    if (typeof a !== "object" || a === null) {
+                        if (path.length === 0) path.push(``);
+                        path[path.length - 1] += ` (value: ${a} != ${b})`;
+                        return a !== b ? path : null;
+                    }
+
+                    for (const prop of Object.entries(a)) {
+                        const [k, v] = prop;
+                        const result = deepCompare(v, b[k], [...path, k]);
+                        if (result) {
+                            return result;
+                        }
+                    }
+
+                    for (const prop of Object.entries(b)) {
+                        const [k, v] = prop;
+                        const result = deepCompare(a[k], v, [...path, k]);
+                        if (result) {
+                            return result;
+                        }
+                    }
+
+                    return null;
                 }
-            }
 
-            for (const prop of Object.entries(b)) {
-                const [k, v] = prop;
-                const result = deepCompare(a[k], v, [...path, k]);
-                if (result) {
-                    return result;
+                if (typeof this.what === "object" && typeof other === "object" && this.what !== null && other !== null) {
+                    const unequal = deepCompare(this.what, other, []);
+                    if (unequal) {
+                        throw new ExpectationError(this, `expected \n\n${JSON.stringify(this.what, null, 2)}\n\n to equal \n\n${JSON.stringify(other, null, 2)}\n\nThey differ in: ${unequal.join(".")}${failSuffix}`);
+                    }
                 }
-            }
+                else {
+                    if (this.what !== other) {
+                        throw new ExpectationError(this, `expected (${typeof this.what})\n\n${this.what}\n\nto equal (${typeof other})\n\n${other}${failSuffix}`);
+                    }
+                }
+            },
+            waitTimeMs
+        );
+    }
 
-            return null;
+    toSucceed<Result>(failMessage?: string): Result {
+        const failSuffix = failMessage ? `\n\n${failMessage}` : "";
+        if (typeof this.what !== "function") {
+            throw new ExpectationError(this, `expected a function\n\nbut it is a ${typeof this.what}${failSuffix}`);
         }
+        return this.what();
+    }
 
-        if (typeof this.what === "object" && typeof other === "object" && this.what !== null && other !== null) {
-            const unequal = deepCompare(this.what, other, []);
-            if (unequal) {
-                throw new ExpectationError(this, `expected \n\n${JSON.stringify(this.what, null, 2)}\n\n to equal \n\n${JSON.stringify(other, null, 2)}\n\nThey differ in: ${unequal.join(".")}${failSuffix}`);
-            }
+    toFail(failMessage?: string): Error {
+        const failSuffix = failMessage ? `\n\n${failMessage}` : "";
+        if (typeof this.what !== "function") {
+            throw new ExpectationError(this, `expected a function\n\nbut it is a ${typeof this.what}${failSuffix}`);
         }
-        else {
-            if (this.what !== other) {
-                throw new ExpectationError(this, `expected (${typeof this.what})\n\n${this.what}\n\nto equal (${typeof other})\n\n${other}${failSuffix}`);
-            }
+
+        let r: any;
+        try {
+            r = this.what();
+        } catch (err: any) {
+            return err;
         }
+        throw new ExpectationError(this, `expected function to fail\n\nbut it succeeded with a result of type ${typeof r}\n\n${r}${failSuffix}`);
     }
 
-    toSucceed<Result>(...args: any): Result {
+    toSucceedAsync<Result>(failMessage?: string, waitTime: number = 100): Promise<Result> {
+        const failSuffix = failMessage ? `\n\n${failMessage}` : "";
         if (typeof this.what !== "function") {
-            throw new ExpectationError(this, `expected a function\n\nbut it is a ${typeof this.what}`);
+            throw new ExpectationError(this, `expected a function\n\nbut it is a ${typeof this.what}${failSuffix}`);
         }
-        return this.what(...args);
+        return retry<Result>(() => this.what(), waitTime);
     }
 
-    toFail(...args: any): Error {
+    async toFailAsync(failMessage?: string): Promise<Error> {
+        const failSuffix = failMessage ? `\n\n${failMessage}` : "";
+
         if (typeof this.what !== "function") {
-            throw new ExpectationError(this, `expected a function\n\nbut it is a ${typeof this.what}`);
+            throw new ExpectationError(this, `expected a function\n\nbut it is a ${typeof this.what}${failSuffix}`);
         }
 
         let r: any;
         try {
-            r = this.what(...args);
+            if(typeof this.what === "function")
+                r = await this.what();
+            else
+                r = await this.what;
         } catch (err: any) {
             return err;
         }
-        throw new ExpectationError(this, `expected function to fail\n\nbut it succeeded with a result of type ${typeof r}\n\n${r}`);
+        throw new ExpectationError(this, `expected function to fail\n\nbut it succeeded with a result of type ${typeof r}\n\n${r}${failSuffix}`);
     }
 
-    toMatch(v: ChildVode, state?: PatchableState | null, failMessage?: string) {
-        const failSuffix = failMessage ? `\n\n${failMessage}` : "";
+    async toMatch(v: ChildVode,
+        state?: PatchableState | null,
+        failMessage?: string,
+        waitTimeMs: number = 100
+    ) {
+        return await retry(
+            async () => {
+                const failSuffix = failMessage ? `\n\n${failMessage}` : "";
 
-        if (this.what instanceof FakeElement || this.what instanceof FakeTextNode || typeof this.what === "string" || Array.isArray(this.what) || typeof this.what === "function") {
-            const that = this;
+                // Support FakeElement, FakeTextNode, real HTMLElement, real Text nodes, strings, arrays, functions
+                if (this.what instanceof FakeElement || this.what instanceof FakeTextNode ||
+                    isRealElement(this.what) || isRealTextNode(this.what) ||
+                    typeof this.what === "string" || Array.isArray(this.what) || typeof this.what === "function") {
+                    const that = this;
 
-            function deepCompare(e: FakeElement | FakeTextNode | ChildVode, cv: ChildVode, path: string[]): string[] | null {
+                    function deepCompare(e: FakeElement | FakeTextNode | HTMLElement | Text | ChildVode, cv: ChildVode, path: string[]): string[] | null {
 
-                // unwrap component
-                while (typeof cv === "function") {
-                    if (!state) {
-                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na Component\n\nbut got no state passed in [toMatch]${failSuffix}`);
-                    }
-                    cv = cv(state);
-                }
-                while (typeof e === "function") {
-                    if (!state) {
-                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na Component\n\nbut got no state passed in [toMatch]${failSuffix}`);
-                    }
-                    e = e(state);
-                }
+                        // unwrap component
+                        while (typeof cv === "function") {
+                            if (!state) {
+                                throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na Component\n\nbut got no state passed in [toMatch]${failSuffix}`);
+                            }
+                            cv = cv(state);
+                        }
+                        while (typeof e === "function") {
+                            if (!state) {
+                                throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na Component\n\nbut got no state passed in [toMatch]${failSuffix}`);
+                            }
+                            e = e(state);
+                        }
 
-                // string matches TextNode
-                if (typeof cv === "string" && e instanceof FakeTextNode) {
-                    if (cv !== e.wholeText) {
-                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na text node with\n${cv}\n\nbut text was\n${e.wholeText}${failSuffix}`);
-                    }
-                }
-                // string matches string
-                else if (typeof cv === "string" && typeof e === "string") {
-                    if (cv !== e) {
-                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na text node with\n${cv}\n\nbut text was\n${e}${failSuffix}`);
-                    }
-                }
+                        // string matches TextNode (fake or real)
+                        if (typeof cv === "string" && (e instanceof FakeTextNode || isRealTextNode(e))) {
+                            const text = e instanceof FakeTextNode ? e.wholeText : (e as Text).wholeText;
+                            if (cv !== text) {
+                                throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na text node with\n${cv}\n\nbut text was\n${text}${failSuffix}`);
+                            }
+                        }
+                        // string matches string
+                        else if (typeof cv === "string" && typeof e === "string") {
+                            if (cv !== e) {
+                                throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na text node with\n${cv}\n\nbut text was\n${e}${failSuffix}`);
+                            }
+                        }
 
-                // vode matches element
-                else if (Array.isArray(cv) && e instanceof FakeElement) {
-                    if (tag(cv)?.toUpperCase() !== e.tagName.toUpperCase()) {
-                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)?.toUpperCase()}>\n\nbut got <${e.tagName.toUpperCase()}>${failSuffix}`);
-                    }
+                        // vode matches element (fake or real)
+                        else if (Array.isArray(cv) && (e instanceof FakeElement || isRealElement(e))) {
+                            const tagName = e instanceof FakeElement ? e.tagName : (e as HTMLElement).tagName;
+                            if (tag(cv)?.toUpperCase() !== tagName.toUpperCase()) {
+                                throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)?.toUpperCase()}>\n\nbut got <${tagName.toUpperCase()}>${failSuffix}`);
+                            }
 
-                    // compare attributes/props
-                    const properties = props(cv);
-                    if (properties) {
-                        for (const [k, v] of Object.entries(properties)) {
-                            const attributeValue = e.fakeAttributes[k];
-                            if (!attributeValue) {
-                                throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)?.toUpperCase()}>\n\nwith attribute [${k}="${v}"]\n\nbut it was not found${failSuffix}`);
+                            // compare attributes/props
+                            const properties = props(cv);
+                            if (properties) {
+                                for (const [k, val] of Object.entries(properties)) {
+                                    let attributeValue: string | null;
+                                    if (e instanceof FakeElement) {
+                                        attributeValue = e.fakeAttributes[k] ?? null;
+                                    } else {
+                                        attributeValue = (e as HTMLElement).getAttribute(k);
+                                    }
+                                    if (!attributeValue) {
+                                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)?.toUpperCase()}>\n\nwith attribute [${k}="${val}"]\n\nbut it was not found${failSuffix}`);
+                                    }
+                                    if (attributeValue !== val) {
+                                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)?.toUpperCase()}>\n\nwith attribute [${k}="${val}"]\n\nbut it was [${k}="${attributeValue}"]${failSuffix}`);
+                                    }
+                                }
                             }
-                            if (attributeValue !== v) {
-                                throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)?.toUpperCase()}>\n\nwith attribute [${k}="${v}"]\n\nbut it was [${k}="${attributeValue}"]${failSuffix}`);
+
+                            // compare children - handle browser text node normalization
+                            const kids = children(cv) || [];
+                            const childNodes = e instanceof FakeElement ? e.children : (e as HTMLElement).childNodes;
+
+                            // Check if all kids are text (strings) - browsers may merge these
+                            const allKidsAreText = kids.every(k => typeof k === "string");
+                            if (allKidsAreText && isBrowser && kids.length > 1) {
+                                // Browser likely merged text nodes - compare concatenated text
+                                const expectedText = kids.join("");
+                                const actualText = (e as HTMLElement).textContent || "";
+                                if (expectedText !== actualText) {
+                                    throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\ntext content "${expectedText}"\n\nbut got "${actualText}"${failSuffix}`);
+                                }
+                            } else {
+                                // Normal child-by-child comparison
+                                for (let i = 0; i < kids.length; i++) {
+                                    const childNode = e instanceof FakeElement
+                                        ? childNodes.item(i) as any
+                                        : childNodes.item(i) as any;
+                                    deepCompare(childNode, kids[i], [...path, `[${i}]${tag(kids[i] as Vode)?.toUpperCase() || "#text"}`]);
+                                }
+                                const childCount = e instanceof FakeElement ? e.children.length : (e as HTMLElement).childNodes.length;
+                                if (kids.length !== childCount) {
+                                    throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\n${kids.length} children\n\nbut <${tagName.toUpperCase()}> has ${childCount} children${failSuffix}`);
+                                }
                             }
                         }
-                    }
+                        // vode matches vode
+                        else if (Array.isArray(cv) && Array.isArray(e)) {
+                            if (tag(cv)?.toUpperCase() !== tag(e)?.toUpperCase()) {
+                                throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na vode [${tag(cv)?.toUpperCase()}]\n\nbut got [${tag(e)?.toUpperCase()}]${failSuffix}`);
+                            }
 
-                    // compare children
-                    const kids = children(cv) || [];
-                    for (let i = 0; i < kids.length; i++) {
-                        deepCompare(e.children.item(i) as any, kids[i], [...path, `[${i}]${tag(kids[i] as Vode)?.toUpperCase() || "#text"}`]);
-                    }
-                    if (kids.length !== e.children.length) {
-                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\n${kids.length} children\n\nbut <${e.tagName.toUpperCase()}> has ${e.children.length} children${failSuffix}`);
-                    }
-                }
-                // vode matches vode
-                else if (Array.isArray(cv) && Array.isArray(e)) {
-                    if (tag(cv)?.toUpperCase() !== tag(e)?.toUpperCase()) {
-                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na vode [${tag(cv)?.toUpperCase()}]\n\nbut got [${tag(e)?.toUpperCase()}]${failSuffix}`);
-                    }
+                            // compare attributes/props
+                            const properties = props(cv);
+                            const otherProperties = props(e) || {};
+                            if (properties) {
+                                for (const [k, val] of Object.entries(properties)) {
+                                    const attributeValue = otherProperties[k];
+                                    if (!attributeValue) {
+                                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na vode [${tag(cv)?.toUpperCase()}]\n\nwith attribute [${k}="${val}"]\n\nbut it was not found${failSuffix}`);
+                                    }
+                                    if (attributeValue !== val) {
+                                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na vode [${tag(cv)?.toUpperCase()}]\n\nwith attribute [${k}="${val}"]\n\nbut its value was [${k}="${attributeValue}"]${failSuffix}`);
+                                    }
+                                }
+                            }
 
-                    // compare attributes/props
-                    const properties = props(cv);
-                    const otherProperties = props(e) || {};
-                    if (properties) {
-                        for (const [k, v] of Object.entries(properties)) {
-                            const attributeValue = otherProperties[k];
-                            if (!attributeValue) {
-                                throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na vode [${tag(cv)?.toUpperCase()}]\n\nwith attribute [${k}="${v}"]\n\nbut it was not found${failSuffix}`);
+                            // compare children
+                            const kids = children(cv) || [];
+                            const otherKids = children(e) || [];
+                            for (let i = 0; i < kids.length; i++) {
+                                deepCompare(otherKids[i], kids[i], [...path, `[${i}]${tag(kids[i] as Vode)?.toUpperCase() || "#text"}`]);
                             }
-                            if (attributeValue !== v) {
-                                throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na vode [${tag(cv)?.toUpperCase()}]\n\nwith attribute [${k}="${v}"]\n\nbut its value was [${k}="${attributeValue}"]${failSuffix}`);
+                            if (kids.length !== otherKids.length) {
+                                throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\n${kids.length} children\n\nbut [${tag(e)?.toUpperCase()}] has ${otherKids.length} children${failSuffix}`);
                             }
                         }
-                    }
-
-                    // compare children
-                    const kids = children(cv) || [];
-                    const otherKids = children(e) || [];
-                    for (let i = 0; i < kids.length; i++) {
-                        deepCompare(otherKids[i], kids[i], [...path, `[${i}]${tag(kids[i] as Vode)?.toUpperCase() || "#text"}`]);
-                    }
-                    if (kids.length !== otherKids.length) {
-                        throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\n${kids.length} children\n\nbut [${tag(e)?.toUpperCase()}] has ${otherKids.length} children${failSuffix}`);
-                    }
-                }
 
-                // mismatch between text and element
-                else if (typeof cv === "string" && e instanceof FakeElement) {
-                    throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na text node\n\nbut got <${e.tagName.toUpperCase()}>${failSuffix}`);
-                }
-                // mismatch between text and vode
-                else if (typeof cv === "string" && Array.isArray(e)) {
-                    throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na text node\n\nbut got [${tag(e)?.toUpperCase()}]${failSuffix}`);
-                }
+                        // mismatch between text and element (fake or real)
+                        else if (typeof cv === "string" && (e instanceof FakeElement || isRealElement(e))) {
+                            const tagName = e instanceof FakeElement ? e.tagName : (e as HTMLElement).tagName;
+                            throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na text node\n\nbut got <${tagName.toUpperCase()}>${failSuffix}`);
+                        }
+                        // mismatch between text and vode
+                        else if (typeof cv === "string" && Array.isArray(e)) {
+                            throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\na text node\n\nbut got [${tag(e)?.toUpperCase()}]${failSuffix}`);
+                        }
 
-                // mismatch between vode and text node
-                else if (Array.isArray(cv) && e instanceof FakeTextNode) {
-                    throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)?.toUpperCase()}>\n\nbut got #text (${e.wholeText})${failSuffix}`);
-                }
-                // mismatch between vode and text
-                else if (Array.isArray(cv) && typeof e === "string") {
-                    throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)?.toUpperCase()}>\n\nbut got #text (${e})${failSuffix}`);
-                }
+                        // mismatch between vode and text node (fake or real)
+                        else if (Array.isArray(cv) && (e instanceof FakeTextNode || isRealTextNode(e))) {
+                            const text = e instanceof FakeTextNode ? e.wholeText : (e as Text).wholeText;
+                            throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)?.toUpperCase()}>\n\nbut got #text (${text})${failSuffix}`);
+                        }
+                        // mismatch between vode and text
+                        else if (Array.isArray(cv) && typeof e === "string") {
+                            throw new ExpectationError(that, `expected at\n${path.join(" > ")}\n\nan element <${tag(cv)?.toUpperCase()}>\n\nbut got #text (${e})${failSuffix}`);
+                        }
 
-                return null;
-            }
+                        return null;
+                    }
 
-            deepCompare(this.what, v, [`${tag(v as Vode)?.toUpperCase() || "#text"}`]);
-        } else {
-            throw new ExpectationError(this, `expected an element or text node\n\nbut it is a ${typeof this.what}\n${this.what}${failSuffix}`);
-        }
+                    deepCompare(this.what, v, [`${tag(v as Vode)?.toUpperCase() || "#text"}`]);
+                } else {
+                    throw new ExpectationError(this, `expected an element or text node\n\nbut it is a ${typeof this.what}\n${this.what}${failSuffix}`);
+                }
+            },
+            waitTimeMs
+        );
     }
 };
 
@@ -211,4 +364,4 @@ export class ExpectationError extends Error {
 
 export function expect(what: any) {
     return new Expectation(what);
-}
+}

package/test/index.ts

@@ -1,7 +1,3 @@
-import { resetMocks } from "./mocks";
-import { ExpectationError } from "./helper";
-
-//=== REGISTERED TESTS =========================================
 import vodeTests from "./tests-vode";
 import appTests from "./tests-app";
 import defuseTests from "./tests-defuse";
@@ -22,7 +18,7 @@ import catchTests from "./tests-catch";
 import patchAdvancedTests from "./tests-patch-advanced";
 import patchMergeTests from "./tests-patch-merge";
 
-const tests = {
+export const tests = {
     ...vodeTests,
     ...appTests,
     ...defuseTests,
@@ -46,62 +42,4 @@ const tests = {
     ...catchTests,
     ...patchAdvancedTests,
     ...patchMergeTests,
-};
-//===================================================
-
-const count = {
-    total: 0,
-    passed: 0,
-    failed: <string[]>[],
-}
-const line = "----------------------------------";
-
-async function runTest(test: [string, () => any]) {
-    count.total++;
-    resetMocks();
-    const start = performance.now();
-    try {
-        const result = test[1]();
-        if (result && typeof (result as any)?.then === "function") {
-            await result;
-        }
-        count.passed++;
-        const time = (performance.now() - start).toFixed(3) + " ms";
-        console.log(`#${count.total} ${test[0]}\n-> 🟢 passed ${time}\n${line}`);
-    } catch (err: any) {
-        const time = (performance.now() - start).toFixed(3) + " ms";
-        console.error(`#${count.total} ${test[0]}\n-> 🔴 failed ${time}`);
-        if (err instanceof ExpectationError) {
-            count.failed.push(`#${count.total} ${test[0]}\n-> 🔴 failed:\n${err.message}\n${line}`);
-        }
-        else {
-            count.failed.push(`#${count.total} ${test[0]}\n-> 🔴 failed:\n${err.message}\n${err.stack}\n${line}`);
-        }
-    }
-}
-
-const sw = performance.now();
-(async () => {
-    for (const test of Object.entries(tests)) {
-        await runTest(test);
-    }
-
-    const time = (performance.now() - sw).toFixed(3) + " ms";
-
-    console.log(`
-        total: ${count.total}
-        passed: ${count.passed}
-        failed: ${count.failed.length}
-
-        time: ${time}
-    `);
-
-    if (count.passed === count.total) {
-        console.log("\n\nall tests passed\n");
-    }
-    else {
-        console.error(`${line.replaceAll("-", "=")}\nError summary:\n\n${count.failed.join(`\n${line}\n`)}`);
-
-        throw "\n\nsome tests failed (see output)\n";
-    }
-})();
+};