testeranto 0.62.0 → 0.73.0

package/dist/module/Puppeteer.js

@@ -0,0 +1,104 @@
+import readline from "readline";
+import fs from "fs";
+import path from "path";
+import { jsonc } from "jsonc";
+import { PM_Main } from "./PM/main.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();
+    }
+});
+const main = async () => {
+    const configs = jsonc.parse((await fs.readFileSync("./docs/testeranto.json")).toString());
+    const pm = new PM_Main(configs);
+    await pm.startPuppeteer({
+        waitForInitialPage: false,
+        executablePath: "/opt/homebrew/bin/chromium",
+        headless: true,
+        dumpio: true,
+        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=*",
+            "--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",
+        ],
+    }, ".");
+    const destinationOfRuntime = (f, r) => {
+        return path
+            .normalize(`${configs.buildDir}/${r}/${f}`)
+            .split(".")
+            .slice(0, -1)
+            .join(".");
+    };
+    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/Reporter.js

@@ -0,0 +1,114 @@
+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`);
+    // const destinationOfRuntime = (f: string, r: IRunTime) => {
+    //   return path
+    //     .normalize(`${configs.buildDir}/${r}/${f}`)
+    //     .split(".")
+    //     .slice(0, -1)
+    //     .join(".");
+    // };
+    // 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

@@ -2,7 +2,9 @@ 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(`/dist/web/src/ClassicalComponent/test.html`);
+            // process.parentPort.postMessage(
+            //   `/docs/web/src/ClassicalComponent/test.html`
+            // );
             return x;
         }, beforeEach: async () => {
             return new Promise((resolve, rej) => {

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

@@ -1,5 +1,5 @@
 import Testeranto from "../../../Node.js";
-import { testInterface as baseInterface } from "./index.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

@@ -1,5 +1,5 @@
 import Testeranto from "../../../Web.js";
-import { testInterface as baseInterface } from "./index.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-dom/component/node.js

@@ -1,6 +1,6 @@
 import { createElement } from "react";
-import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
-import Stream from 'stream';
+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) => {

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

@@ -2,54 +2,107 @@ import { createElement } from "react";
 import ReactDom from "react-dom/client";
 import Testeranto from "../../../Web.js";
 export 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 = Testeranto(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 = 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: 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 Testeranto(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
-                        ReactDom.createRoot(htmlElement).render(createElement(TesterantoComponent, Object.assign(Object.assign({}, initializer.props), { 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/module/SubPackages/react-dom/jsx/web.js

@@ -1,17 +1,17 @@
-import React, { useEffect, useRef, } from "react";
-import { createPortal } from 'react-dom';
+import React, { useEffect, useRef } from "react";
+import { createPortal } from "react-dom";
 import Testeranto from "../../../Web.js";
 export default (testImplementations, testSpecifications, testInput) => {
     document.addEventListener("DOMContentLoaded", function () {
         const rootElement = document.getElementById("root");
         if (rootElement) {
-            const TesterantoComponent = function ({ done, innerComp }) {
+            const TesterantoComponent = function ({ done, innerComp, }) {
                 const myContainer = useRef(null);
                 useEffect(() => {
                     console.log("useEffect called", myContainer.current);
                     done(myContainer.current);
                 }, []);
-                return React.createElement('div', { ref: myContainer }, innerComp());
+                return React.createElement("div", { ref: myContainer }, innerComp());
             };
             Testeranto(testInput, testSpecifications, testImplementations, {
                 beforeAll: async (input, artificer) => {
@@ -27,28 +27,36 @@ export default (testImplementations, testSpecifications, testInput) => {
                                 process.nextTick(() => {
                                     resolve(reactElement);
                                 });
-                            }
+                            },
                         }), rootElement);
                     });
                 },
                 andWhen: function (s, whenCB) {
                     return new Promise((resolve, rej) => {
-                        process.nextTick(() => { resolve(whenCB()(s)); });
+                        process.nextTick(() => {
+                            resolve(whenCB()(s));
+                        });
                     });
                 },
                 butThen: async function (s) {
                     return new Promise((resolve, rej) => {
-                        process.nextTick(() => { resolve(s); });
+                        process.nextTick(() => {
+                            resolve(s);
+                        });
                     });
                 },
                 afterEach: async function (store, ndx, artificer) {
                     return new Promise((resolve, rej) => {
-                        process.nextTick(() => { resolve({}); });
+                        process.nextTick(() => {
+                            resolve({});
+                        });
                     });
                 },
                 afterAll: (store, artificer) => {
                     return new Promise((resolve, rej) => {
-                        process.nextTick(() => { resolve({}); });
+                        process.nextTick(() => {
+                            resolve({});
+                        });
                     });
                 },
             });

package/dist/module/SubPackages/react-test-renderer/MemoExoticComponent/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";
 export default (testImplementations, testSpecifications, testInput) => test(testInput, testSpecifications, testImplementations, {
     beforeEach: function (CComponent, props) {
         let component;

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

@@ -46,7 +46,6 @@ export const testInterface = {
     // },
     butThen: async function (s, thenCB, tr) {
         console.log("butThen", thenCB.toString());
-        // debugger
         return thenCB(s);
     },
     afterEach: async function (store, ndx, artificer) {

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

@@ -1,6 +1,6 @@
-import test from "../../../Web.js";
 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) => {

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

@@ -3,11 +3,9 @@ import renderer, { act } from "react-test-renderer";
 export const testInterface = {
     butThen: async function (s, thenCB, tr) {
         console.log("butThen", thenCB.toString());
-        // debugger
         return thenCB(s);
     },
     beforeEach: function (CComponent, props) {
-        console.log("ASDASDx");
         let component;
         act(() => {
             component = renderer.create(React.createElement(CComponent, props, []));
@@ -17,5 +15,5 @@ export const testInterface = {
     andWhen: async function (renderer, whenCB) {
         await act(() => whenCB(renderer));
         return renderer;
-    }
+    },
 };

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

@@ -1,5 +1,5 @@
-import { testInterface } from "./index.js";
 import test from "../../../Web.js";
+import { testInterface } from "./index.js";
 export default (testImplementations, testSpecifications, testInput, testInterface2 = testInterface) => {
     return test(testInput, testSpecifications, testImplementations, testInterface2);
 };

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

@@ -12,5 +12,5 @@ export const testInterface = {
     andWhen: async function (renderer, whenCB) {
         await act(() => whenCB()(renderer));
         return renderer;
-    }
+    },
 };

package/dist/module/Types.js

@@ -1,30 +1,3 @@
-// export class TPage extends Page {
-//   // screenshot(options?: puppeteer.ScreenshotOptions) {
-//   //   return super.screenshot({
-//   //     ...options,
-//   //     path: "dist/" + (options ? options : { path: "" }).path,
-//   //   });
-//   // }
-// }
-export class TBrowser {
-    constructor(browser) {
-        this.browser = browser;
-    }
-    pages() {
-        return new Promise(async (res, rej) => {
-            res((await this.browser.pages()).map((p) => {
-                // const handler = {
-                //   apply: function (target, thisArg, argumentsList) {
-                //     console.log('screenshot was called with ' + JSON.stringify(argumentsList));
-                //     const x: ScreenshotOptions = argumentsList[0]
-                //     x.path = "./dist/" + x.path;
-                //     console.log('x.path' + x.path, target, thisArg);
-                //     return target(...argumentsList);
-                //   }
-                // };
-                // p.screenshot = new Proxy(p.screenshot, handler);
-                return p;
-            }));
-        });
-    }
-}
+export {};
+// export type ITTestShape = {
+// };

package/dist/module/Web.js

@@ -1,47 +1,35 @@
+import { PM_Web } from "./PM/web";
 import Testeranto from "./lib/core.js";
-import { defaultTestResourceRequirement } from "./lib/index.js";
-const remote = require('@electron/remote');
+import { defaultTestResourceRequirement, } from "./lib/index.js";
 class WebTesteranto extends Testeranto {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
-        super(input, testSpecification, testImplementation, testResourceRequirement, window.NodeWriter, testInterface);
-        if (process.argv[2]) {
-            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);
-            }
-        }
-        else {
-            // no-op
-        }
-        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);
-            }
-        }
-        // const t: ITestJob = this.testJobs[0];
+        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
     }
-    async receiveTestResourceConfig(t, partialTestResource) {
-        const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(partialTestResource, remote);
-        Promise.all([...artifacts, logPromise]).then(async () => {
-            var window = remote.getCurrentWindow();
-            // window.close();
-        });
+    async receiveTestResourceConfig(partialTestResource) {
+        const t = partialTestResource; //JSON.parse(partialTestResource);
+        const pm = new PM_Web(t);
+        const { failed, artifacts, logPromise } = await this.testJobs[0].receiveTestResourceConfig(pm);
+        console.log("test is done, awaiting test result write to fs");
+        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"]());
+        // });
     }
 }
-;
 export default async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {
     return new WebTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
 };