testeranto 0.47.34 → 0.47.52

package/dist/module/Puppeteer.js

@@ -0,0 +1,98 @@
+import readline from "readline";
+import fs from "fs";
+import { PM_Main } from "./PM/main.js";
+import { destinationOfRuntime } from "./utils.js";
+var mode = process.argv[2] === "-dev" ? "DEV" : "PROD";
+const node2web = {};
+const web2node = {};
+const childProcesses = {};
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY)
+    process.stdin.setRawMode(true);
+console.log("\n Puppeteer is running. Press 'q' to quit\n");
+process.stdin.on("keypress", (str, key) => {
+    if (key.name === "q") {
+        process.exit();
+    }
+});
+export default async (partialConfig) => {
+    const config = Object.assign(Object.assign({}, partialConfig), { buildDir: process.cwd() + "/" + partialConfig.outdir });
+    fs.writeFileSync(`${config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, config), { buildDir: process.cwd() + "/" + config.outdir }), null, 2));
+    const pm = new PM_Main(config);
+    await pm.startPuppeteer({
+        waitForInitialPage: false,
+        executablePath: "/opt/homebrew/bin/chromium",
+        headless: true,
+        // dumpio: true,
+        args: [
+            "--disable-features=IsolateOrigins,site-per-process",
+            "--disable-site-isolation-trials",
+            "--allow-insecure-localhost",
+            "--allow-file-access-from-files",
+            "--allow-running-insecure-content",
+            // "--auto-open-devtools-for-tabs",
+            "--disable-dev-shm-usage",
+            "--disable-extensions",
+            "--disable-gpu",
+            "--disable-setuid-sandbox",
+            "--disable-site-isolation-trials",
+            "--disable-web-security",
+            "--no-first-run",
+            "--no-sandbox",
+            "--no-startup-window",
+            // "--no-zygote",
+            "--reduce-security-for-testing",
+            "--remote-allow-origins=*",
+            "--unsafely-treat-insecure-origin-as-secure=*",
+            // "--disable-features=IsolateOrigins",
+            // "--remote-allow-origins=ws://localhost:3234",
+            // "--single-process",
+            // "--unsafely-treat-insecure-origin-as-secure",
+            // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
+            `--remote-debugging-port=3234`,
+            // "--disk-cache-dir=/dev/null",
+            // "--disk-cache-size=1",
+            // "--start-maximized",
+        ],
+    }, ".");
+    config.tests.forEach(([test, runtime, tr, sidecars]) => {
+        if (runtime === "node") {
+            pm.launchNode(test, destinationOfRuntime(test, "node", config));
+        }
+        else if (runtime === "web") {
+            pm.launchWeb(test, destinationOfRuntime(test, "web", config), sidecars);
+        }
+        else {
+            console.error("runtime makes no sense", runtime);
+        }
+    });
+    console.log("ready and watching for changes...", config.buildDir);
+    fs.watch(config.buildDir, {
+        recursive: true,
+    }, (eventType, changedFile) => {
+        if (changedFile) {
+            config.tests.forEach(([test, runtime, tr, sidecars]) => {
+                if (eventType === "change" || eventType === "rename") {
+                    if (changedFile ===
+                        test
+                            .replace("./", "node/")
+                            .split(".")
+                            .slice(0, -1)
+                            .concat("mjs")
+                            .join(".")) {
+                        pm.launchNode(test, destinationOfRuntime(test, "node", config));
+                    }
+                    if (changedFile ===
+                        test
+                            .replace("./", "web/")
+                            .split(".")
+                            .slice(0, -1)
+                            .concat("mjs")
+                            .join(".")) {
+                        pm.launchWeb(test, destinationOfRuntime(test, "web", config), sidecars);
+                    }
+                }
+            });
+        }
+    });
+};

package/dist/module/Reporter.js

@@ -0,0 +1,107 @@
+import readline from "readline";
+import fs from "fs";
+import { jsonc } from "jsonc";
+import puppeteer from "puppeteer-core";
+// import { PM_Main } from "./PM/main.js";
+// var mode: "DEV" | "PROD" = process.argv[2] === "-dev" ? "DEV" : "PROD";
+// const node2web: Record<string, string[]> = {};
+// const web2node: Record<string, string[]> = {};
+// const childProcesses: Record<string, "loaded" | "running" | "done"> = {};
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY)
+    process.stdin.setRawMode(true);
+console.log("\n Puppeteer is running. Press 'q' to quit\n");
+process.stdin.on("keypress", (str, key) => {
+    if (key.name === "q") {
+        process.exit();
+    }
+});
+const main = async () => {
+    const configs = jsonc.parse((await fs.readFileSync("./docs/testeranto.json")).toString());
+    // const pm = new PM_Main(configs);
+    // await puppeteer.launch(options);
+    const browser = await puppeteer.launch({
+        waitForInitialPage: false,
+        executablePath: "/opt/homebrew/bin/chromium",
+        headless: false,
+        args: [
+            "--allow-file-access-from-files",
+            "--allow-running-insecure-content",
+            // "--auto-open-devtools-for-tabs",
+            "--disable-dev-shm-usage",
+            "--disable-extensions",
+            "--disable-gpu",
+            "--disable-setuid-sandbox",
+            "--disable-site-isolation-trials",
+            "--disable-web-security",
+            "--disable-web-security",
+            "--no-first-run",
+            "--no-sandbox",
+            "--no-startup-window",
+            "--no-zygote",
+            "--reduce-security-for-testing",
+            "--remote-allow-origins=*",
+            // "--remote-allow-origins=ws://localhost:3234",
+            "--unsafely-treat-insecure-origin-as-secure=*",
+            // "--disable-features=IsolateOrigins",
+            // "--single-process",
+            // "--unsafely-treat-insecure-origin-as-secure",
+            // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
+            // `--remote-debugging-port=3234`,
+        ],
+    }
+    // "."
+    );
+    console.log("Creating new page...");
+    const page = await browser.newPage();
+    await page.setViewport({ width: 0, height: 0 });
+    console.log("Requesting url...");
+    await page.goto(`file://${process.cwd()}/docs/report.html?local=true`);
+    // configs.tests.forEach(([test, runtime, secondaryArtifacts]) => {
+    //   if (runtime === "node") {
+    //     pm.launchNode(test, destinationOfRuntime(test, "node"));
+    //   } else if (runtime === "web") {
+    //     pm.launchWeb(test, destinationOfRuntime(test, "web"));
+    //   } else {
+    //     console.error("runtime makes no sense", runtime);
+    //   }
+    // });
+    // console.log("ready and watching for changes...", configs.buildDir);
+    // fs.watch(
+    //   configs.buildDir,
+    //   {
+    //     recursive: true,
+    //   },
+    //   (eventType, changedFile) => {
+    //     if (changedFile) {
+    //       configs.tests.forEach(([test, runtime, secondaryArtifacts]) => {
+    //         if (eventType === "change" || eventType === "rename") {
+    //           if (
+    //             changedFile ===
+    //             test
+    //               .replace("./", "node/")
+    //               .split(".")
+    //               .slice(0, -1)
+    //               .concat("mjs")
+    //               .join(".")
+    //           ) {
+    //             pm.launchNode(test, destinationOfRuntime(test, "node"));
+    //           }
+    //           if (
+    //             changedFile ===
+    //             test
+    //               .replace("./", "web/")
+    //               .split(".")
+    //               .slice(0, -1)
+    //               .concat("mjs")
+    //               .join(".")
+    //           ) {
+    //             pm.launchWeb(test, destinationOfRuntime(test, "web"));
+    //           }
+    //         }
+    //       });
+    //     }
+    //   }
+    // );
+};
+main();

package/dist/module/Scheduler.js

@@ -0,0 +1 @@
+"use strict";

package/dist/module/SubPackages/puppeteer.js

@@ -0,0 +1,16 @@
+import React from "react";
+import Testeranto from "../Node.js";
+export default (testInput, testSpecifications, testImplementations, testInterface) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, Object.assign({ beforeAll(x) {
+            // process.parentPort.postMessage(
+            //   `/docs/web/src/ClassicalComponent/test.html`
+            // );
+            return x;
+        }, beforeEach: async () => {
+            return new Promise((resolve, rej) => {
+                resolve(React.createElement(testInput, {}, []));
+            });
+        }, andWhen: function (s, whenCB) {
+            return whenCB()(s);
+        } }, testInterface));
+};

package/dist/module/{subPackages → SubPackages}/react/component/node.js

@@ -1,5 +1,5 @@
 import React from "react";
-import Testeranto from "../../../Node";
+import Testeranto from "../../../Node.js";
 export default (testImplementations, testSpecifications, testInput) => {
     return Testeranto(testInput, testSpecifications, testImplementations, {
         beforeEach: async () => {
@@ -7,8 +7,8 @@ export default (testImplementations, testSpecifications, testInput) => {
                 resolve(React.createElement(testInput, {}, []));
             });
         },
-        andWhen: function (s, actioner) {
-            return actioner()(s);
+        andWhen: function (s, whenCB) {
+            return whenCB()(s);
         },
     });
 };

package/dist/module/{subPackages → SubPackages}/react/component/web.js

@@ -1,5 +1,5 @@
 import React from "react";
-import Testeranto from "../../../Web";
+import Testeranto from "../../../Web.js";
 export default (testImplementations, testSpecifications, testInput) => {
     return Testeranto(testInput, testSpecifications, testImplementations, {
         beforeEach: async () => {
@@ -7,8 +7,8 @@ export default (testImplementations, testSpecifications, testInput) => {
                 resolve(React.createElement(testInput, {}, []));
             });
         },
-        andWhen: function (s, actioner) {
-            return actioner()(s);
+        andWhen: function (s, whenCB) {
+            return whenCB()(s);
         },
     });
 };

package/dist/module/SubPackages/react/jsx/index.js

@@ -0,0 +1,19 @@
+import React from "react";
+export const testInterface = {
+    // beforeAll: async (proto, testResource, artificer, pm): Promise<IStore> => {
+    //   return React.createElement(proto);
+    //   // return new Promise((resolve, rej) => {
+    //   //   resolve(x());
+    //   // });
+    // },
+    beforeEach: async (subject, initializer, artificer) => {
+        return new Promise((resolve, rej) => {
+            const x = React.createElement(subject);
+            console.log("react-element", x);
+            resolve(x);
+        });
+    },
+    andWhen: function (s, whenCB) {
+        return whenCB(s);
+    },
+};

package/dist/module/SubPackages/react/jsx/node.js

@@ -0,0 +1,5 @@
+import Testeranto from "../../../Node.js";
+import { testInterface as baseInterface, } from "./index.js";
+export default (testImplementations, testSpecifications, testInput, testInterface) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, Object.assign(Object.assign({}, baseInterface), testInterface));
+};

package/dist/module/SubPackages/react/jsx/web.js

@@ -0,0 +1,5 @@
+import Testeranto from "../../../Web.js";
+import { testInterface as baseInterface, } from "./index.js";
+export default (testImplementations, testSpecifications, testInput, testInterface) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, Object.assign(Object.assign({}, baseInterface), testInterface));
+};

package/dist/module/{subPackages → SubPackages}/react-dom/component/node.js

@@ -1,7 +1,7 @@
 import { createElement } from "react";
-import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
-import Stream from 'stream';
-import Testeranto from "../../../Node";
+import { renderToStaticMarkup, renderToStaticNodeStream, } from "react-dom/server";
+import Stream from "stream";
+import Testeranto from "../../../Node.js";
 export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
 export default (testImplementations, testSpecifications, testInput) => {
     return Testeranto(testInput, testSpecifications, testImplementations, {
@@ -22,9 +22,9 @@ export default (testImplementations, testSpecifications, testInput) => {
                 resolve(createElement(testInput));
             });
         },
-        andWhen: async function (s, actioner) {
-            // return actioner()(s);
-            return s;
+        andWhen: async function (s, whenCB) {
+            return whenCB(s);
+            // return s
         },
         butThen: async function (s) {
             return s;
@@ -85,7 +85,7 @@ export default (testImplementations, testSpecifications, testInput) => {
 //           resolve(ReactDOMServer.renderToStaticMarkup(element));
 //         });
 //       },
-//       andWhen: function (s: IStore, actioner): Promise<ISelection> {
+//       andWhen: function (s: IStore, whenCB): Promise<ISelection> {
 //         throw new Error(`"andWhens" are not permitted`);
 //       }
 //     },

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

@@ -0,0 +1,88 @@
+import { createElement } from "react";
+import ReactDom from "react-dom/client";
+import Testeranto from "../../../Web.js";
+export default (testInput, testSpecifications, testImplementations, testInterface) => {
+    class TesterantoComponent extends testInput {
+        constructor(props) {
+            super(props);
+            this.done = props.done;
+        }
+        componentDidMount() {
+            super.componentDidMount && super.componentDidMount();
+            return this.done(this);
+        }
+    }
+    const t = Testeranto(testInput, testSpecifications, testImplementations, {
+        beforeAll: async (initialProps, artificer) => {
+            return await new Promise((resolve, rej) => {
+                const htmlElement = document.getElementById("root");
+                if (htmlElement) {
+                    const domRoot = ReactDom.createRoot(htmlElement);
+                    // Ignore these type errors
+                    domRoot.render(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: (testInterface === null || testInterface === void 0 ? void 0 : testInterface.afterEach) ||
+            async function (store, ndx, artificer, utils) {
+                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) {
+            return t;
+        }
+    });
+    return t;
+};

package/dist/module/SubPackages/react-dom/jsx/node.js

@@ -0,0 +1,31 @@
+import { createElement } from "react";
+import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
+import Stream from 'stream';
+import Testeranto from "../../../Node.js";
+export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
+export default (testImplementations, testSpecifications, testInput) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, {
+        beforeAll: async (prototype, artificer) => {
+            return await new Promise((resolve, rej) => {
+                resolve(null);
+            });
+        },
+        beforeEach: async (reactComponent, ndx, testRsource, artificer) => {
+            return new Promise((resolve, rej) => {
+                resolve(createElement(testInput));
+            });
+        },
+        andWhen: async function (s, whenCB) {
+            return s;
+        },
+        butThen: async function (s) {
+            return s;
+        },
+        afterEach: async function (store, ndx, artificer) {
+            return {};
+        },
+        afterAll: (store, artificer) => {
+            return;
+        },
+    });
+};

package/dist/module/SubPackages/react-dom/jsx/web.js

@@ -0,0 +1,90 @@
+import React, { useEffect, useRef } from "react";
+import { createElement } from "react";
+import ReactDom from "react-dom/client";
+import { createPortal } from "react-dom";
+import Testeranto from "../../../Web.js";
+export default (testImplementations, testSpecifications, testInput) => {
+    console.log("testInput", testInput);
+    const TesterantoComponent = function ({ done, innerComp, }) {
+        const myContainer = useRef(null);
+        useEffect(() => {
+            console.log("useEffect called!", myContainer.current);
+            done(myContainer.current);
+        }, []);
+        // debugger;
+        return React.createElement("div", { ref: myContainer }, innerComp());
+    };
+    const t = Testeranto(testInput, testSpecifications, testImplementations, {
+        beforeAll: async (reactElement, itr) => {
+            return await new Promise((resolve, rej) => {
+                const htmlElement = document.getElementById("root");
+                if (htmlElement) {
+                    const domRoot = ReactDom.createRoot(htmlElement);
+                    domRoot.render(createElement(TesterantoComponent, {
+                        // ...initialProps,
+                        innerComp: reactElement,
+                        done: (reactElement) => {
+                            resolve({
+                                htmlElement,
+                                reactElement,
+                                domRoot,
+                            });
+                        },
+                    }, []));
+                    // resolve({ htmlElement });
+                }
+            });
+        },
+        beforeEach: async (subject, initializer, artificer, testResource, pm) => {
+            return new Promise((resolve, rej) => {
+                createPortal(TesterantoComponent({
+                    innerComp: () => testInput({
+                        port: 3003,
+                        address: "some-address",
+                        secretKey: "someSecretKey",
+                        abi: "foo",
+                    }),
+                    done: (reactElement) => {
+                        process.nextTick(() => {
+                            resolve(reactElement);
+                        });
+                    },
+                }), subject.domRoot);
+            });
+        },
+        andWhen: function (s, whenCB) {
+            return new Promise((resolve, rej) => {
+                process.nextTick(() => {
+                    resolve(whenCB()(s));
+                });
+            });
+        },
+        butThen: async function (s) {
+            return new Promise((resolve, rej) => {
+                process.nextTick(() => {
+                    resolve(s);
+                });
+            });
+        },
+        afterEach: async function (store, ndx, artificer) {
+            return new Promise((resolve, rej) => {
+                process.nextTick(() => {
+                    resolve({});
+                });
+            });
+        },
+        afterAll: (store, artificer) => {
+            return new Promise((resolve, rej) => {
+                process.nextTick(() => {
+                    resolve({});
+                });
+            });
+        },
+    });
+    document.addEventListener("DOMContentLoaded", function () {
+        const rootElement = document.getElementById("root");
+        if (rootElement) {
+        }
+    });
+    return t;
+};

package/dist/module/SubPackages/react-test-renderer/MemoExoticComponent/node.js

@@ -0,0 +1,16 @@
+import React from "react";
+import renderer, { act } from "react-test-renderer";
+import test from "../../../Node";
+export default (testImplementations, testSpecifications, testInput) => test(testInput, testSpecifications, testImplementations, {
+    beforeEach: function (CComponent, props) {
+        let component;
+        act(() => {
+            component = renderer.create(React.createElement(CComponent, props, []));
+        });
+        return component;
+    },
+    andWhen: async function (renderer, whenCB) {
+        await act(() => whenCB()(renderer));
+        return renderer;
+    },
+});

package/dist/module/SubPackages/react-test-renderer/component/index.js

@@ -0,0 +1 @@
+export {};

package/dist/module/SubPackages/react-test-renderer/component/interface.js

@@ -0,0 +1,39 @@
+import React from "react";
+import renderer, { act } from "react-test-renderer";
+export const testInterface = {
+    beforeEach: function (CComponent, propsAndChildren) {
+        function Link(props) {
+            const p = props.props;
+            const c = props.children;
+            return React.createElement(CComponent, p, c);
+        }
+        return new Promise((res, rej) => {
+            act(async () => {
+                const p = propsAndChildren;
+                const y = new CComponent(p.props);
+                const testRenderer = await renderer.create(Link(propsAndChildren));
+                res(testRenderer);
+            });
+        });
+    },
+    andWhen: async function (renderer, whenCB) {
+        // console.log("andWhen", whenCB)
+        await act(() => whenCB(renderer));
+        return renderer;
+    },
+    // andWhen: function (s: Store, whenCB): Promise<Selection> {
+    //   return whenCB()(s);
+    // },
+    butThen: async function (s, thenCB, tr) {
+        console.log("butThen", thenCB.toString());
+        return thenCB(s);
+    },
+    afterEach: async function (store, ndx, artificer) {
+        // console.log("afterEach", store);
+        return {};
+    },
+    afterAll: (store, artificer) => {
+        // console.log("afterAll", store);
+        return;
+    },
+};

package/dist/module/{subPackages → SubPackages}/react-test-renderer/component/node.js

@@ -1,3 +1,3 @@
-import Testeranto from "../../../Node";
-import { testInterface } from ".";
+import Testeranto from "../../../Node.js";
+import { testInterface } from "./interface.js";
 export default (testImplementations, testSpecifications, testInput) => Testeranto(testInput, testSpecifications, testImplementations, testInterface);

package/dist/module/{subPackages → SubPackages}/react-test-renderer/component/web.js

@@ -1,3 +1,3 @@
-import Testeranto from "../../../Web";
-import { testInterface } from ".";
+import Testeranto from "../../../Web.js";
+import { testInterface } from "./interface";
 export default (testImplementations, testSpecifications, testInput) => Testeranto(testInput, testSpecifications, testImplementations, testInterface);

package/dist/module/{subPackages → SubPackages}/react-test-renderer/fc/node.js

@@ -1,6 +1,6 @@
-import test from "../../../Node";
 import React from "react";
 import renderer, { act } from "react-test-renderer";
+import test from "../../../Node.js";
 export default (testImplementations, testSpecifications, testInput) => test(testInput, testSpecifications, testImplementations, {
     beforeEach: function (CComponent, props) {
         return new Promise((res, rej) => {
@@ -11,8 +11,8 @@ export default (testImplementations, testSpecifications, testInput) => test(test
             });
         });
     },
-    andWhen: async function (renderer, actioner) {
-        await act(() => actioner()(renderer));
+    andWhen: async function (renderer, whenCB) {
+        await act(() => whenCB()(renderer));
         return renderer;
     },
     afterEach: async (store, key, artificer) => {

package/dist/module/SubPackages/react-test-renderer/fc/web.js

@@ -0,0 +1,22 @@
+import React from "react";
+import renderer, { act } from "react-test-renderer";
+import test from "../../../Web.js";
+export default (testImplementations, testSpecifications, testInput) => test(testInput, testSpecifications, testImplementations, {
+    beforeEach: function (CComponent, props) {
+        return new Promise((res, rej) => {
+            let component;
+            act(() => {
+                component = renderer.create(React.createElement(CComponent, props, []));
+                res(component);
+            });
+        });
+    },
+    andWhen: async function (renderer, whenCB) {
+        await act(() => whenCB()(renderer));
+        return renderer;
+    },
+    afterEach: async (store, key, artificer) => {
+        console.log("afterall");
+        store.unmount();
+    },
+});