testeranto 0.70.0 → 0.73.0

package/dist/common/PM/node.js

@@ -0,0 +1,176 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM_Node = exports.addPageBinding = void 0;
+// import puppeteer from "puppeteer";
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// import puppeteer from "puppeteer-core/lib/esm/puppeteer/puppeteer-core";
+const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
+const index_js_1 = require("./index.js");
+const fPaths = [];
+function addPageBinding(type, name, prefix) {
+    // Depending on the frame loading state either Runtime.evaluate or
+    // Page.addScriptToEvaluateOnNewDocument might succeed. Let's check that we
+    // don't re-wrap Puppeteer's binding.
+    if (globalThis[name]) {
+        return;
+    }
+    // We replace the CDP binding with a Puppeteer binding.
+    Object.assign(globalThis, {
+        [name](...args) {
+            var _a, _b, _c;
+            // This is the Puppeteer binding.
+            const callPuppeteer = globalThis[name];
+            (_a = callPuppeteer.args) !== null && _a !== void 0 ? _a : (callPuppeteer.args = new Map());
+            (_b = callPuppeteer.callbacks) !== null && _b !== void 0 ? _b : (callPuppeteer.callbacks = new Map());
+            const seq = ((_c = callPuppeteer.lastSeq) !== null && _c !== void 0 ? _c : 0) + 1;
+            callPuppeteer.lastSeq = seq;
+            callPuppeteer.args.set(seq, args);
+            // Needs to be the same as CDP_BINDING_PREFIX.
+            globalThis[prefix + name](JSON.stringify({
+                type,
+                name,
+                seq,
+                args,
+                isTrivial: !args.some((value) => {
+                    return value instanceof Node;
+                }),
+            }));
+            return new Promise((resolve, reject) => {
+                callPuppeteer.callbacks.set(seq, {
+                    resolve(value) {
+                        callPuppeteer.args.delete(seq);
+                        resolve(value);
+                    },
+                    reject(value) {
+                        callPuppeteer.args.delete(seq);
+                        reject(value);
+                    },
+                });
+            });
+        },
+    });
+}
+exports.addPageBinding = addPageBinding;
+const files = new Set();
+class PM_Node extends index_js_1.PM {
+    constructor(t) {
+        super();
+        this.server = {};
+        this.testResourceConfiguration = t;
+    }
+    existsSync(destFolder) {
+        return globalThis["existsSync"](this.testResourceConfiguration.fs + "/" + destFolder);
+    }
+    mkdirSync() {
+        return globalThis["mkdirSync"](this.testResourceConfiguration.fs + "/");
+    }
+    write(writeObject, contents) {
+        return globalThis["write"](writeObject.uid, contents);
+    }
+    writeFileSync(filepath, contents) {
+        files.add(filepath);
+        return globalThis["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents);
+    }
+    createWriteStream(filepath) {
+        files.add(filepath);
+        return globalThis["createWriteStream"](this.testResourceConfiguration.fs + "/" + filepath);
+    }
+    end(writeObject) {
+        return globalThis["end"](writeObject.uid);
+    }
+    customclose() {
+        console.log("node-customclose");
+        // globalThis["writeFileSync"](
+        //   this.testResourceConfiguration.fs + "/manifest.json",
+        //   // files.entries()
+        //   JSON.stringify(Array.from(files))
+        // ).then(() => {
+        //   globalThis["customclose"]();
+        // });
+    }
+    // write(accessObject: { uid: number; }, contents: string): boolean {
+    //   throw new Error("Method not implemented.");
+    // }
+    // existsSync(destFolder: string): boolean {
+    //   return fs.existsSync(destFolder);
+    // }
+    // async mkdirSync(destFolder: string) {
+    //   if (!fs.existsSync(destFolder)) {
+    //     return fs.mkdirSync(destFolder, { recursive: true });
+    //   }
+    //   return false;
+    // }
+    // writeFileSync(fp: string, contents: string) {
+    //   fs.writeFileSync(fp, contents);
+    // }
+    // createWriteStream(filepath: string): fs.WriteStream {
+    //   return fs.createWriteStream(filepath);
+    // }
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            callback(new Promise((res, rej) => {
+                tLog("testArtiFactory =>", fPath);
+                const cleanPath = path_1.default.resolve(fPath);
+                fPaths.push(cleanPath.replace(process.cwd(), ``));
+                const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+                fs_1.default.mkdir(targetDir, { recursive: true }, async (error) => {
+                    if (error) {
+                        console.error(`❗️testArtiFactory failed`, targetDir, error);
+                    }
+                    fs_1.default.writeFileSync(path_1.default.resolve(targetDir.split("/").slice(0, -1).join("/"), "manifest"), fPaths.join(`\n`), {
+                        encoding: "utf-8",
+                    });
+                    if (Buffer.isBuffer(value)) {
+                        fs_1.default.writeFileSync(fPath, value, "binary");
+                        res();
+                    }
+                    else if (`string` === typeof value) {
+                        fs_1.default.writeFileSync(fPath, value.toString(), {
+                            encoding: "utf-8",
+                        });
+                        res();
+                    }
+                    else {
+                        /* @ts-ignore:next-line */
+                        const pipeStream = value;
+                        const myFile = fs_1.default.createWriteStream(fPath);
+                        pipeStream.pipe(myFile);
+                        pipeStream.on("close", () => {
+                            myFile.close();
+                            res();
+                        });
+                    }
+                });
+            }));
+        };
+    }
+    // launch(options?: PuppeteerLaunchOptions): Promise<Browser>;
+    startPuppeteer(options) {
+        console.log("start1");
+        return puppeteer_core_1.default.connect(options).then((b) => {
+            this.browser = b;
+        });
+        // return new Promise<Browser>((res, rej) => {
+        //   // this.browser = await puppeteer.connect(options);
+        //   // console.log("start2", this.browser);
+        //   // console.log("mark5", this.browser);
+        //   // res(this.browser);
+        // });
+    }
+}
+exports.PM_Node = PM_Node;
+// class PuppetMasterServer extends AbstractPuppetMaster {
+//   // constructor(...z: []) {
+//   //   super(...z);
+//   // }
+//   // // pages(): Promise<Page[]>;
+//   // pages(): Promise<Page[]> {
+//   //   return new Promise<Page[]>((res, rej) => {
+//   //     res(super.pages());
+//   //   });
+//   // }
+// }

package/dist/common/PM/web.js

@@ -0,0 +1,174 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM_Web = void 0;
+const index_js_1 = require("./index.js");
+const puppeteer_core_browser_js_1 = __importDefault(require("puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser.js"));
+function waitForFunctionCall() {
+    return new Promise((resolve) => {
+        window["myFunction"] = () => {
+            // Do something when myFunction is called
+            console.log("myFunction was called!");
+            resolve(); // Resolve the promise
+        };
+    });
+}
+const files = new Set();
+class PM_Web extends index_js_1.PM {
+    // testResourceConfiguration: ITTestResourceConfiguration;
+    constructor(t) {
+        super();
+        this.server = {};
+        this.testResourceConfiguration = t;
+    }
+    existsSync(destFolder) {
+        return window["existsSync"](destFolder);
+    }
+    mkdirSync() {
+        return window["mkdirSync"](this.testResourceConfiguration.fs + "/");
+    }
+    write(writeObject, contents) {
+        return window["write"](writeObject.uid, contents);
+    }
+    writeFileSync(filepath, contents) {
+        console.log("WEB writeFileSync", filepath);
+        files.add(filepath);
+        return window["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents);
+    }
+    createWriteStream(filepath) {
+        files.add(filepath);
+        return window["createWriteStream"](this.testResourceConfiguration.fs + "/" + filepath);
+    }
+    end(writeObject) {
+        return window["end"](writeObject.uid);
+    }
+    customclose() {
+        window["writeFileSync"](this.testResourceConfiguration.fs + "/manifest.json", 
+        // files.entries()
+        JSON.stringify(Array.from(files))).then(() => {
+            window["customclose"]();
+        });
+    }
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            callback(new Promise((res, rej) => {
+                tLog("testArtiFactory =>", fPath);
+                // const cleanPath = path.resolve(fPath);
+                // fPaths.push(cleanPath.replace(process.cwd(), ``));
+                // const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+                // fs.mkdir(targetDir, { recursive: true }, async (error) => {
+                //   if (error) {
+                //     console.error(`❗️testArtiFactory failed`, targetDir, error);
+                //   }
+                //   fs.writeFileSync(
+                //     path.resolve(
+                //       targetDir.split("/").slice(0, -1).join("/"),
+                //       "manifest"
+                //     ),
+                //     fPaths.join(`\n`),
+                //     {
+                //       encoding: "utf-8",
+                //     }
+                //   );
+                //   if (Buffer.isBuffer(value)) {
+                //     fs.writeFileSync(fPath, value, "binary");
+                //     res();
+                //   } else if (`string` === typeof value) {
+                //     fs.writeFileSync(fPath, value.toString(), {
+                //       encoding: "utf-8",
+                //     });
+                //     res();
+                //   } else {
+                //     /* @ts-ignore:next-line */
+                //     const pipeStream: PassThrough = value;
+                //     const myFile = fs.createWriteStream(fPath);
+                //     pipeStream.pipe(myFile);
+                //     pipeStream.on("close", () => {
+                //       myFile.close();
+                //       res();
+                //     });
+                //   }
+                // });
+            }));
+        };
+    }
+    startPuppeteer(options, destFolder) {
+        return fetch(`http://localhost:3234/json/version`)
+            .then((v) => {
+            return v.json();
+        })
+            .then((json) => {
+            console.log("found endpoint", json.webSocketDebuggerUrl);
+            return puppeteer_core_browser_js_1.default
+                .connect({
+                browserWSEndpoint: json.webSocketDebuggerUrl,
+            })
+                .then((b) => {
+                this.browser = b;
+                const handler2 = {
+                    get(target, prop, receiver) {
+                        if (prop === "screenshot") {
+                            return async (x) => {
+                                // debugger;
+                                files.add(x.path);
+                                console.log("aloha", files);
+                                return await window["custom-screenshot"](Object.assign(Object.assign({}, x), { path: destFolder + "/" + x.path }));
+                            };
+                        }
+                        else if (prop === "mainFrame") {
+                            return () => target[prop](...arguments);
+                        }
+                        else {
+                            return Reflect.get(...arguments);
+                        }
+                    },
+                };
+                const handler1 = {
+                    get(target, prop, receiver) {
+                        if (prop === "pages") {
+                            return async () => {
+                                return target.pages().then((pages) => {
+                                    return pages.map((p) => {
+                                        return new Proxy(p, handler2);
+                                    });
+                                });
+                            };
+                        }
+                        return Reflect.get(...arguments);
+                    },
+                };
+                const proxy3 = new Proxy(this.browser, handler1);
+                this.browser = proxy3;
+            });
+        });
+        // console.log("connecting to ws://localhost:3234/devtools/browser/RANDOM");
+        // return puppeteer
+        //   .connect({
+        //     ...options,
+        //   })
+        //   .finally(() => {
+        //     console.log("idk");
+        //   });
+        // return new Promise<Browser>(async (res, rej) => {
+        //   console.log("connecting with options", options);
+        //   this.browser = await puppeteer.connect({
+        //     ...options,
+        //   });
+        //   res(this.browser);
+        // });
+    }
+}
+exports.PM_Web = PM_Web;
+// class PuppetMasterServer extends AbstractPuppetMaster {
+//   // constructor(...z: []) {
+//   //   super(...z);
+//   // }
+//   // // pages(): Promise<Page[]>;
+//   // pages(): Promise<Page[]> {
+//   //   return new Promise<Page[]>((res, rej) => {
+//   //     res(super.pages());
+//   //   });
+//   // }
+// }

package/dist/common/Project.js

@@ -76,6 +76,24 @@ class ITProject {
                 .then((x) => fs_1.default.writeFileSync(htmlFilePath, (0, web_html_js_1.default)(jsfilePath, htmlFilePath)));
         })));
         const [nodeEntryPoints, webEntryPoints] = getRunnables(this.config.tests);
+        // nodeEntryPoints.forEach((nep) => {
+        //   const f = `${process.cwd()}/${nep}`;
+        //   console.log("nep", f);
+        //   import(f).then((module) => {
+        //     return module.default.then((defaultModule) => {
+        //       console.log("defaultModule", defaultModule);
+        //       // defaultModule
+        //       //   .receiveTestResourceConfig(argz)
+        //       //   .then((x) => {
+        //       //     console.log("then", x);
+        //       //     return x;
+        //       //   })
+        //       //   .catch((e) => {
+        //       //     console.log("catch", e);
+        //       //   });
+        //     });
+        //   });
+        // });
         (0, glob_1.glob)(`./${config.outdir}/chunk-*.mjs`, { ignore: "node_modules/**" }).then((chunks) => {
             chunks.forEach((chunk) => {
                 fs_1.default.unlinkSync(chunk);
@@ -156,8 +174,8 @@ const getRunnables = (tests, payload = [new Set(), new Set()]) => {
         else if (cv[1] === "web") {
             pt[1].add(cv[0]);
         }
-        if (cv[2].length) {
-            getRunnables(cv[2], payload);
+        if (cv[3].length) {
+            getRunnables(cv[3], payload);
         }
         return pt;
     }, payload);

package/dist/common/Puppeteer.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline_1 = __importDefault(require("readline"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const jsonc_1 = require("jsonc");
+const main_js_1 = require("./PM/main.js");
+var mode = process.argv[2] === "-dev" ? "DEV" : "PROD";
+const node2web = {};
+const web2node = {};
+const childProcesses = {};
+readline_1.default.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_1.jsonc.parse((await fs_1.default.readFileSync("./docs/testeranto.json")).toString());
+    const pm = new main_js_1.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_1.default
+            .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_1.default.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/common/Reporter.js

@@ -0,0 +1,119 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const readline_1 = __importDefault(require("readline"));
+const fs_1 = __importDefault(require("fs"));
+const jsonc_1 = require("jsonc");
+const puppeteer_core_1 = __importDefault(require("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_1.default.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_1.jsonc.parse((await fs_1.default.readFileSync("./docs/testeranto.json")).toString());
+    // const pm = new PM_Main(configs);
+    // await puppeteer.launch(options);
+    const browser = await puppeteer_core_1.default.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/common/Scheduler.js

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

package/dist/common/SubPackages/puppeteer.js

@@ -7,7 +7,9 @@ const react_1 = __importDefault(require("react"));
 const Node_js_1 = __importDefault(require("../Node.js"));
 exports.default = (testInput, testSpecifications, testImplementations, testInterface) => {
     return (0, Node_js_1.default)(testInput, testSpecifications, testImplementations, Object.assign({ beforeAll(x) {
-            process.parentPort.postMessage(`/docs/web/src/ClassicalComponent/test.html`);
+            // process.parentPort.postMessage(
+            //   `/docs/web/src/ClassicalComponent/test.html`
+            // );
             return x;
         }, beforeEach: async () => {
             return new Promise((resolve, rej) => {