testeranto 0.70.0 → 0.73.0

package/dist/common/SubPackages/react-dom/component/web.js

@@ -7,54 +7,107 @@ const react_1 = require("react");
 const client_1 = __importDefault(require("react-dom/client"));
 const Web_js_1 = __importDefault(require("../../../Web.js"));
 exports.default = (testInput, testSpecifications, testImplementations) => {
+    class TesterantoComponent extends testInput {
+        constructor(props) {
+            super(props);
+            this.done = props.done;
+        }
+        componentDidMount() {
+            super.componentDidMount && super.componentDidMount();
+            return this.done(this);
+        }
+    }
+    const t = (0, Web_js_1.default)(testInput, testSpecifications, testImplementations, {
+        beforeAll: async (initialProps, artificer) => {
+            console.log("mark5", initialProps);
+            return await new Promise((resolve, rej) => {
+                const htmlElement = document.getElementById("root");
+                if (htmlElement) {
+                    const domRoot = client_1.default.createRoot(htmlElement);
+                    // Ignore these type errors
+                    domRoot.render((0, react_1.createElement)(TesterantoComponent, Object.assign(Object.assign({}, initialProps), { done: (reactElement) => {
+                            resolve({
+                                htmlElement,
+                                reactElement,
+                                domRoot,
+                            });
+                        } }), []));
+                    // resolve({ htmlElement });
+                }
+            });
+        },
+        // beforeEach: async (
+        //   s,
+        //   initializer,
+        //   testResource,
+        //   artificer,
+        //   initialValues
+        // ): Promise<IStore> => {
+        //   return new Promise((resolve, rej) => {
+        //     console.log("beforeEach" + TesterantoComponent);
+        //     // const domRoot = ReactDom.createRoot(htmlElement);
+        //     // // Ignore these type errors
+        //     // domRoot.render(
+        //     //   createElement(
+        //     //     TesterantoComponent,
+        //     //     {
+        //     //       ...initializer,
+        //     //       done: (reactElement) => {
+        //     //         resolve({
+        //     //           htmlElement,
+        //     //           reactElement,
+        //     //           domRoot,
+        //     //         });
+        //     //       },
+        //     //     },
+        //     //     []
+        //     //   )
+        //     // );
+        //   });
+        // },
+        andWhen: function (s, whenCB) {
+            return whenCB(s);
+        },
+        butThen: async function (s, thenCB) {
+            return thenCB(s);
+        },
+        afterEach: async function (store, ndx, artificer, utils) {
+            console.log("afterEach", store);
+            utils.writeFileSync("aftereachlog", store.toString());
+            const page = (await utils.browser.pages()).filter((x) => {
+                const parsedUrl = new URL(x.url());
+                parsedUrl.search = "";
+                const strippedUrl = parsedUrl.toString();
+                return (strippedUrl ===
+                    "file:///Users/adam/Code/kokomoBay/docs/web/src/ClassicalComponent/react-dom/client.web.test.html");
+                // return true;
+            })[0];
+            const x = await page.screenshot({
+                path: "afterEachLog.jpg",
+            });
+            console.log("x", x);
+            // debugger;
+            // const div_root = document.getElementById("root");
+            // store.domRoot && store.domRoot.unmount(); //React 18
+            //  store.remove();
+            // store.htmlElement.remove();
+            // store.htmlElement = document.createElement("root");
+            return store;
+        },
+        afterAll: async (store, artificer, utils) => {
+            // setTimeout(() => {
+            //   console.log("This will run after 1 second");
+            // }, 1000); // 1000 milliseconds = 1 second
+            // store.htmlElement.remove();
+            // store.htmlElement = document.createElement("root");
+            return store;
+        },
+    });
     document.addEventListener("DOMContentLoaded", function () {
         const elem = document.getElementById("root");
         if (elem) {
-            class TesterantoComponent extends testInput {
-                constructor(props) {
-                    super(props);
-                    this.done = props.done;
-                }
-                componentDidMount() {
-                    super.componentDidMount && super.componentDidMount();
-                    return this.done(this);
-                }
-            }
-            return (0, Web_js_1.default)(testInput, testSpecifications, testImplementations, {
-                beforeAll: async (initialProps, artificer) => {
-                    console.log("mark5", initialProps);
-                    return await new Promise((resolve, rej) => {
-                        const elem = document.getElementById("root");
-                        if (elem) {
-                            resolve({ htmlElement: elem });
-                        }
-                    });
-                },
-                beforeEach: async ({ htmlElement }, initializer, testResource, artificer, initialValues) => {
-                    return new Promise((resolve, rej) => {
-                        // console.log("beforeEach" + JSON.stringify(initializer) + JSON.stringify(initialValues));
-                        // Ignore these type errors
-                        client_1.default.createRoot(htmlElement).render((0, react_1.createElement)(TesterantoComponent, Object.assign(Object.assign({}, initializer), { done: (reactElement) => {
-                                resolve({
-                                    htmlElement,
-                                    reactElement,
-                                });
-                            } }), []));
-                    });
-                },
-                andWhen: function (s, whenCB) {
-                    return whenCB(s);
-                },
-                butThen: async function (s) {
-                    return s;
-                },
-                afterEach: async function (store, ndx, artificer) {
-                    return {};
-                },
-                afterAll: (store, artificer) => {
-                    return;
-                },
-            });
+            return t;
         }
     });
+    return t;
 };

package/dist/common/SubPackages/react-test-renderer/jsx/index.js

@@ -35,7 +35,6 @@ exports.testInterface = {
         return thenCB(s);
     },
     beforeEach: function (CComponent, props) {
-        console.log("ASDASDx");
         let component;
         (0, react_test_renderer_1.act)(() => {
             component = react_test_renderer_1.default.create(react_1.default.createElement(CComponent, props, []));

package/dist/common/Web.js

@@ -3,55 +3,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+const web_1 = require("./PM/web");
 const core_js_1 = __importDefault(require("./lib/core.js"));
 const index_js_1 = require("./lib/index.js");
-// const remote = require("@electron/remote");
-// import remote from "@electron/remote";
-// const electron = require("electron");
-// const remote =
-//   process.type === "browser" ? electron : require("@electron/remote");
 class WebTesteranto extends core_js_1.default {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
-        super(input, testSpecification, testImplementation, testResourceRequirement, window.NodeWriter, testInterface);
-        const testResourceArg = decodeURIComponent(new URLSearchParams(location.search).get("requesting") || "");
-        try {
-            const partialTestResource = JSON.parse(testResourceArg);
-            this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
-        }
-        catch (e) {
-            console.error(e);
-            // process.exit(-1);
-        }
-        const requesting = new URLSearchParams(location.search).get("requesting");
-        if (requesting) {
-            const testResourceArg = decodeURIComponent(requesting);
-            try {
-                const partialTestResource = JSON.parse(testResourceArg);
-                console.log("initial test resource", partialTestResource);
-                this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
-            }
-            catch (e) {
-                console.error(e);
-                // process.exit(-1);
-            }
-        }
+        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
     }
-    async receiveTestResourceConfig(t, partialTestResource) {
-        const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(partialTestResource, {
-            browser: await window.browser,
-            ipc: window.ipcRenderer,
-        });
+    async receiveTestResourceConfig(partialTestResource) {
+        const t = partialTestResource; //JSON.parse(partialTestResource);
+        const pm = new web_1.PM_Web(t);
+        const { failed, artifacts, logPromise } = await this.testJobs[0].receiveTestResourceConfig(pm);
         console.log("test is done, awaiting test result write to fs");
-        Promise.all([...artifacts, logPromise]).then(async () => {
-            // we can't close the window becuase we might be taking a screenshot
-            // window.close();
-            // console.log(
-            //   "(window as any).browser",
-            //   JSON.stringify(await (window as any).browser)
-            // );
-            // var currentWindow = (await (window as any).browser).getCurrentWindow();
-            // currentWindow.close();
-        });
+        pm.customclose();
+        // Promise.all([...artifacts, logPromise]).then(async () => {
+        //   console.log("hello world");
+        //   pm.customclose();
+        //   // we can't close the window becuase we might be taking a screenshot
+        //   // window.close();
+        //   // console.log(
+        //   //   "(window as any).browser",
+        //   //   JSON.stringify(await (window as any).browser)
+        //   // );
+        //   // var currentWindow = (await (window as any).browser).getCurrentWindow();
+        //   // window.close();
+        //   // var customWindow = window.open("", "_blank", "");
+        //   // customWindow.close();
+        //   // this.puppetMaster.browser.page
+        //   // window["customclose"]();
+        //   // console.log("goodbye", window["customclose"]());
+        // });
     }
 }
 exports.default = async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = index_js_1.defaultTestResourceRequirement) => {

package/dist/common/esbuildConfigs/web.js

@@ -19,7 +19,6 @@ exports.default = (config, entryPoints) => {
             "features.test.ts",
             // "url",
             "react",
-            "electron",
             "path",
             "fs",
             "stream",
@@ -34,6 +33,9 @@ exports.default = (config, entryPoints) => {
             "zlib",
             "crypto",
             "https",
+            "util",
+            "process",
+            "dns",
         ], platform: "browser", entryPoints: [...entryPoints], plugins: [
             ...(config.webPlugins || []),
             {

package/dist/common/lib/abstractBase.js

@@ -16,45 +16,114 @@ class BaseSuite {
             fails: this.fails,
         };
     }
-    setup(s, artifactory, tr, utils) {
+    setup(s, artifactory, tr, pm) {
         return new Promise((res) => res(s));
     }
     assertThat(t) {
-        // console.log("base assertThat")
         return t;
     }
-    async run(input, testResourceConfiguration, artifactory, tLog, utils) {
+    afterAll(store, artifactory, pm) {
+        return store;
+    }
+    async run(input, testResourceConfiguration, artifactory, tLog, pm) {
         this.testResourceConfiguration = testResourceConfiguration;
-        tLog("test resources: ", testResourceConfiguration);
+        tLog("test resources: ", JSON.stringify(testResourceConfiguration));
         const suiteArtifactory = (fPath, value) => artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
-        const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, utils);
+        console.log("\nSuite:", this.index, this.name);
         tLog("\nSuite:", this.index, this.name);
-        for (const k of Object.keys(this.givens)) {
-            const giver = this.givens[k];
+        const sNdx = this.index;
+        const sName = this.name;
+        for (const [gNdx, g] of Object.entries(this.givens)) {
+            const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, pm);
+            const giver = this.givens[gNdx];
             try {
-                this.store = await giver.give(subject, k, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, utils);
+                this.store = await giver.give(subject, gNdx, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, pm, sNdx);
             }
             catch (e) {
                 console.error(e);
                 this.fails.push(giver);
-                return this;
+                // return this;
             }
         }
-        for (const [ndx, thater] of this.checks.entries()) {
-            await thater.check(subject, thater.name, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, utils);
+        const afterAllProxy = new Proxy(pm, {
+            get(target, prop, receiver) {
+                if (prop === "writeFileSync") {
+                    return (fp, contents) => target[prop](`suite-${sNdx}/afterAll/${fp}`, contents);
+                }
+                if (prop === "browser") {
+                    return new Proxy(target[prop], {
+                        get(bTarget, bProp, bReceiver) {
+                            if (bProp === "pages") {
+                                return async () => {
+                                    return bTarget.pages().then((pages) => {
+                                        return pages.map((page) => {
+                                            return new Proxy(page, {
+                                                get(pTarget, pProp, pReciever) {
+                                                    if (pProp === "screenshot") {
+                                                        return async (x) => {
+                                                            // console.log(
+                                                            //   "custom-screenshot-MARK-afterAllProxy",
+                                                            //   // arguments,
+                                                            //   // x,
+                                                            //   window["custom-screenshot"].toString()
+                                                            // );
+                                                            return await window["custom-screenshot"](Object.assign(Object.assign({}, x), { path: `${testResourceConfiguration.fs}/suite-${sNdx}/afterAll` +
+                                                                    "/" +
+                                                                    x.path }));
+                                                        };
+                                                    }
+                                                    // else if (pProp === "mainFrame") {
+                                                    //   return () => target[pProp](...arguments);
+                                                    // }
+                                                    else {
+                                                        return Reflect.get(...arguments);
+                                                    }
+                                                },
+                                            });
+                                        });
+                                    });
+                                    // return (await target.pages()).map((page) => {
+                                    //   return new Proxy(page, handler2);
+                                    // });
+                                };
+                            }
+                        },
+                    });
+                }
+                return Reflect.get(...arguments);
+            },
+        });
+        // pm.browser
+        try {
+            this.afterAll(this.store, artifactory, afterAllProxy);
         }
-        // @TODO fix me
-        for (const k of Object.keys(this.givens)) {
-            const giver = this.givens[k];
-            try {
-                giver.afterAll(this.store, artifactory, utils);
-            }
-            catch (e) {
-                console.error(e);
-                this.fails.push(giver);
-                return this;
-            }
+        catch (e) {
+            console.error(e);
+            // this.fails.push(this);
+            // return this;
         }
+        // for (const [ndx, thater] of this.checks.entries()) {
+        //   await thater.check(
+        //     subject,
+        //     thater.name,
+        //     testResourceConfiguration,
+        //     this.assertThat,
+        //     suiteArtifactory,
+        //     tLog,
+        //     pm
+        //   );
+        // }
+        // @TODO fix me
+        // for (const k of Object.keys(this.givens)) {
+        //   const giver = this.givens[k];
+        //   try {
+        //     giver.afterAll(this.store, artifactory, pm);
+        //   } catch (e) {
+        //     console.error(e);
+        //     this.fails.push(giver);
+        //     return this;
+        //   }
+        // }
         ////////////////
         return this;
     }
@@ -72,32 +141,39 @@ class BaseGiven {
     beforeAll(store, artifactory) {
         return store;
     }
-    afterAll(store, artifactory, utils) {
-        return store;
-    }
     toObj() {
         return {
             name: this.name,
             whens: this.whens.map((w) => w.toObj()),
             thens: this.thens.map((t) => t.toObj()),
             error: this.error ? [this.error, this.error.stack] : null,
+            // fail: this.fail ? [this.fail] : false,
             features: this.features,
         };
     }
-    async afterEach(store, key, artifactory, utils) {
+    async afterEach(store, key, artifactory, pm) {
         return store;
     }
-    async give(subject, key, testResourceConfiguration, tester, artifactory, tLog, utils) {
+    async give(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm, suiteNdx) {
         tLog(`\n Given: ${this.name}`);
         const givenArtifactory = (fPath, value) => artifactory(`given-${key}/${fPath}`, value);
         try {
-            this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB);
             // tLog(`\n Given this.store`, this.store);
-            for (const whenStep of this.whens) {
-                await whenStep.test(this.store, testResourceConfiguration, tLog, utils);
+            const beforeEachProxy = new Proxy(pm, {
+                get(target, prop, receiver) {
+                    if (prop === "writeFileSync") {
+                        console.log("beforeEachProx", arguments, target[prop]);
+                        return (fp, contents) => target[prop](`suite-${suiteNdx}/given-${key}/when/beforeEach/${fp}`, contents);
+                    }
+                    return Reflect.get(...arguments);
+                },
+            });
+            this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, beforeEachProxy);
+            for (const [whenNdx, whenStep] of this.whens.entries()) {
+                await whenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/when/${whenNdx}`);
             }
             for (const thenStep of this.thens) {
-                const t = await thenStep.test(this.store, testResourceConfiguration, tLog, utils);
+                const t = await thenStep.test(this.store, testResourceConfiguration, tLog, pm);
                 tester(t);
             }
         }
@@ -109,7 +185,66 @@ class BaseGiven {
         }
         finally {
             try {
-                await this.afterEach(this.store, key, givenArtifactory, utils);
+                // const afterEachProxy = new Proxy(pm, {
+                //   get(target, prop, receiver) {
+                //     if (prop === "writeFileSync") {
+                //       console.log("afterEachProxy", arguments, target[prop]);
+                //       return (fp, contents) =>
+                //         // target[prop](`${key}/andWhen/${fp}`, contents);
+                //         target[prop](`${key}/afterEach/${fp}`, contents);
+                //     }
+                //     return Reflect.get(...arguments);
+                //   },
+                // });
+                // await this.afterEach(this.store, key, givenArtifactory, afterEachProxy);
+                // await this.afterEach(this.store, key, givenArtifactory, pm);
+                const afterEachProxy = new Proxy(pm, {
+                    get(target, prop, receiver) {
+                        if (prop === "writeFileSync") {
+                            return (fp, contents) => target[prop](`suite-${suiteNdx}/given-${key}/afterAll/${fp}`, contents);
+                        }
+                        if (prop === "browser") {
+                            return new Proxy(target[prop], {
+                                get(bTarget, bProp, bReceiver) {
+                                    if (bProp === "pages") {
+                                        return async () => {
+                                            return bTarget.pages().then((pages) => {
+                                                return pages.map((page) => {
+                                                    return new Proxy(page, {
+                                                        get(pTarget, pProp, pReciever) {
+                                                            if (pProp === "screenshot") {
+                                                                return async (x) => {
+                                                                    // console.log(
+                                                                    //   "custom-screenshot-MARK-afterEachProxy",
+                                                                    //   window["custom-screenshot"].toString()
+                                                                    // );
+                                                                    return await window["custom-screenshot"](Object.assign(Object.assign({}, x), { path: `${testResourceConfiguration.fs}/suite-${suiteNdx}/given-${key}/afterEach` +
+                                                                            "/" +
+                                                                            x.path }));
+                                                                };
+                                                            }
+                                                            // else if (pProp === "mainFrame") {
+                                                            //   return () => target[pProp](...arguments);
+                                                            // }
+                                                            else {
+                                                                return Reflect.get(...arguments);
+                                                            }
+                                                        },
+                                                    });
+                                                });
+                                            });
+                                            // return (await target.pages()).map((page) => {
+                                            //   return new Proxy(page, handler2);
+                                            // });
+                                        };
+                                    }
+                                },
+                            });
+                        }
+                        return Reflect.get(...arguments);
+                    },
+                });
+                await this.afterEach(this.store, key, givenArtifactory, afterEachProxy);
             }
             catch (e) {
                 console.error("afterEach failed! no error will be recorded!", e);
@@ -130,10 +265,22 @@ class BaseWhen {
             error: this.error,
         };
     }
-    async test(store, testResourceConfiguration, tLog, utils) {
+    async test(store, testResourceConfiguration, tLog, pm, key) {
         tLog(" When:", this.name);
+        const name = this.name;
+        const andWhenProxy = new Proxy(pm, {
+            get(target, prop, receiver) {
+                if (prop === "writeFileSync") {
+                    console.log("andWhenProxy", arguments, target[prop]);
+                    return (fp, contents) => 
+                    // target[prop](`${key}/andWhen/${fp}`, contents);
+                    target[prop](`${key}/andWhen/${fp}`, contents);
+                }
+                return Reflect.get(...arguments);
+            },
+        });
         try {
-            return await this.andWhen(store, this.whenCB, testResourceConfiguration);
+            return await this.andWhen(store, this.whenCB, testResourceConfiguration, andWhenProxy);
         }
         catch (e) {
             this.error = true;
@@ -146,6 +293,7 @@ class BaseThen {
     constructor(name, thenCB) {
         this.name = name;
         this.thenCB = thenCB;
+        this.error = false;
     }
     toObj() {
         return {
@@ -153,7 +301,7 @@ class BaseThen {
             error: this.error,
         };
     }
-    async test(store, testResourceConfiguration, tLog, utils) {
+    async test(store, testResourceConfiguration, tLog, pm) {
         tLog(" Then:", this.name);
         try {
             const x = await this.butThen(store, this.thenCB, testResourceConfiguration);
@@ -161,7 +309,7 @@ class BaseThen {
         }
         catch (e) {
             console.log("test failed", e);
-            this.error = true;
+            this.error = e.message;
             throw e;
         }
     }
@@ -175,25 +323,25 @@ class BaseCheck {
         this.whens = whens;
         this.thens = thens;
     }
-    async afterEach(store, key, cb, utils) {
+    async afterEach(store, key, cb, pm) {
         return;
     }
-    async check(subject, key, testResourceConfiguration, tester, artifactory, tLog, utils) {
+    async check(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm) {
         tLog(`\n Check: ${this.name}`);
         const store = await this.checkThat(subject, testResourceConfiguration, artifactory);
         await this.checkCB(Object.entries(this.whens).reduce((a, [key, when]) => {
             a[key] = async (payload) => {
-                return await when(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, utils);
+                return await when(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, pm, "x");
             };
             return a;
         }, {}), Object.entries(this.thens).reduce((a, [key, then]) => {
             a[key] = async (payload) => {
-                const t = await then(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, utils);
+                const t = await then(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, pm);
                 tester(t);
             };
             return a;
         }, {}));
-        await this.afterEach(store, key, () => { }, utils);
+        await this.afterEach(store, key, () => { }, pm);
         return;
     }
 }