testeranto 0.79.6 → 0.79.8

package/dist/module/PM/web.js

@@ -0,0 +1,125 @@
+import puppeteer from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser.js";
+import { PM } from "./index.js";
+export class PM_Web extends PM {
+    constructor(t) {
+        super();
+        this.server = {};
+        this.testResourceConfiguration = t;
+    }
+    customScreenShot(opts) {
+        window["customScreenShot"](opts);
+    }
+    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) {
+        return window["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
+    }
+    createWriteStream(filepath) {
+        return window["createWriteStream"](this.testResourceConfiguration.fs + "/" + filepath, this.testResourceConfiguration.name);
+    }
+    end(writeObject) {
+        return window["end"](writeObject.uid);
+    }
+    customclose() {
+        window["customclose"](this.testResourceConfiguration.fs, this.testResourceConfiguration.name);
+    }
+    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) {
+        const name = this.testResourceConfiguration.name;
+        return fetch(`http://localhost:3234/json/version`)
+            .then((v) => {
+            return v.json();
+        })
+            .then((json) => {
+            return puppeteer
+                .connect({
+                browserWSEndpoint: json.webSocketDebuggerUrl,
+            })
+                .then((b) => {
+                this.browser = b;
+                const handler2 = {
+                    get(target, prop, receiver) {
+                        if (prop === "screenshot") {
+                            return async (x) => {
+                                return await window["custom-screenshot"](Object.assign(Object.assign({}, x), { 
+                                    // path: destFolder + "/" + x.path,
+                                    path: x.path }), name);
+                            };
+                        }
+                        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;
+            });
+        });
+    }
+}

package/dist/module/Project.js

@@ -0,0 +1,179 @@
+import esbuild from "esbuild";
+import fs from "fs";
+import path from "path";
+import readline from "readline";
+import { glob } from "glob";
+import esbuildNodeConfiger from "./esbuildConfigs/node.js";
+import esbuildWebConfiger from "./esbuildConfigs/web.js";
+import esbuildFeaturesConfiger from "./esbuildConfigs/features.js";
+import webHtmlFrame from "./web.html.js";
+import reportHtmlFrame from "./report.html.js";
+var mode = process.argv[2] === "-dev" ? "DEV" : "PROD";
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY)
+    process.stdin.setRawMode(true);
+process.stdin.on("keypress", (str, key) => {
+    if (key.name === "q") {
+        console.log("Testeranto-EsBuild is shutting down...");
+        mode = "PROD";
+        onDone();
+    }
+});
+// setInterval(() => {
+//   const memoryUsage = process.memoryUsage();
+//   console.log("Memory usage:", memoryUsage);
+// }, 10000); // Check every 10 seconds
+let featuresDone, nodeDone, webDone = false;
+const onFeaturesDone = () => {
+    featuresDone = true;
+    onDone();
+};
+const onNodeDone = () => {
+    nodeDone = true;
+    onDone();
+};
+const onWebDone = () => {
+    webDone = true;
+    onDone();
+};
+const onDone = () => {
+    console.log(JSON.stringify({
+        featuresDone,
+        nodeDone,
+        webDone,
+        mode,
+    }, null, 2));
+    if (featuresDone && nodeDone && webDone && mode === "PROD") {
+        console.log("Testeranto-EsBuild is all done. Goodbye!");
+        process.exit();
+    }
+    else {
+        console.log("Testeranto-EsBuild is still working...");
+    }
+};
+export class ITProject {
+    constructor(config) {
+        this.mode = `up`;
+        this.config = config;
+        Promise.resolve(Promise.all([...this.getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
+            const sourceFileSplit = sourceFilePath.split("/");
+            const sourceDir = sourceFileSplit.slice(0, -1);
+            const sourceFileName = sourceFileSplit[sourceFileSplit.length - 1];
+            const sourceFileNameMinusJs = sourceFileName
+                .split(".")
+                .slice(0, -1)
+                .join(".");
+            const htmlFilePath = path.normalize(`${process.cwd()}/${config.outdir}/web/${sourceDir.join("/")}/${sourceFileNameMinusJs}.html`);
+            const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
+            return fs.promises
+                .mkdir(path.dirname(htmlFilePath), { recursive: true })
+                .then((x) => fs.writeFileSync(htmlFilePath, webHtmlFrame(jsfilePath, htmlFilePath)));
+        })));
+        const [nodeEntryPoints, webEntryPoints] = getRunnables(this.config.tests);
+        console.log(`this.getSecondaryEndpointsPoints("web")`, this.getSecondaryEndpointsPoints("web"));
+        // console.log("nodeEntryPoints", nodeEntryPoints);
+        // console.log("webEntryPoints", webEntryPoints);
+        // 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);
+        //       //   });
+        //     });
+        //   });
+        // });
+        glob(`./${config.outdir}/chunk-*.mjs`, { ignore: "node_modules/**" }).then((chunks) => {
+            chunks.forEach((chunk) => {
+                fs.unlinkSync(chunk);
+            });
+        });
+        fs.copyFileSync("./node_modules/testeranto/dist/prebuild/Report.js", "./docs/Report.js");
+        fs.copyFileSync("./node_modules/testeranto/dist/prebuild/Report.css", "./docs/Report.css");
+        fs.writeFileSync(`${config.outdir}/report.html`, reportHtmlFrame());
+        Promise.all([
+            fs.promises.writeFile(`${config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, config), { buildDir: process.cwd() + "/" + config.outdir }), null, 2)),
+            esbuild
+                .context(esbuildFeaturesConfiger(config))
+                .then(async (featuresContext) => {
+                if (mode == "DEV") {
+                    await featuresContext.watch();
+                    onFeaturesDone();
+                }
+                else {
+                    featuresContext.rebuild().then((v) => {
+                        onFeaturesDone();
+                    });
+                }
+                return featuresContext;
+            }),
+            esbuild
+                .context(esbuildNodeConfiger(config, nodeEntryPoints))
+                .then(async (nodeContext) => {
+                if (mode == "DEV") {
+                    await nodeContext.watch().then((v) => {
+                        onNodeDone();
+                    });
+                }
+                else {
+                    nodeContext.rebuild().then((v) => {
+                        onNodeDone();
+                    });
+                }
+                return nodeContext;
+            }),
+            esbuild
+                .context(esbuildWebConfiger(config, webEntryPoints))
+                .then(async (webContext) => {
+                if (mode == "DEV") {
+                    await webContext.watch().then((v) => {
+                        onWebDone();
+                    });
+                }
+                else {
+                    webContext.rebuild().then((v) => {
+                        onWebDone();
+                    });
+                }
+                return webContext;
+            }),
+        ]);
+    }
+    getSecondaryEndpointsPoints(runtime) {
+        const meta = (ts, st) => {
+            ts.forEach((t) => {
+                console.log("getSecondaryEndpointsPoints", t);
+                if (t[1] === runtime) {
+                    st.add(t[0]);
+                }
+                if (Array.isArray(t[3])) {
+                    meta(t[3], st);
+                }
+            });
+            return st;
+        };
+        return Array.from(meta(this.config.tests, new Set()));
+    }
+}
+const getRunnables = (tests, payload = [new Set(), new Set()]) => {
+    return tests.reduce((pt, cv, cndx, cry) => {
+        if (cv[1] === "node") {
+            pt[0].add(cv[0]);
+        }
+        else if (cv[1] === "web") {
+            pt[1].add(cv[0]);
+        }
+        if (cv[3].length) {
+            getRunnables(cv[3], payload);
+        }
+        return pt;
+    }, payload);
+};

package/dist/module/Puppeteer.js

@@ -0,0 +1,99 @@
+import readline from "readline";
+import fs from "fs";
+import { jsonc } from "jsonc";
+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();
+    }
+});
+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: [
+            "--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",
+        ],
+    }, ".");
+    configs.tests.forEach(([test, runtime, tr, sidecars]) => {
+        if (runtime === "node") {
+            pm.launchNode(test, destinationOfRuntime(test, "node", configs));
+        }
+        else if (runtime === "web") {
+            pm.launchWeb(test, destinationOfRuntime(test, "web", configs), sidecars);
+        }
+        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, 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", configs));
+                    }
+                    if (changedFile ===
+                        test
+                            .replace("./", "web/")
+                            .split(".")
+                            .slice(0, -1)
+                            .concat("mjs")
+                            .join(".")) {
+                        pm.launchWeb(test, destinationOfRuntime(test, "web", configs), sidecars);
+                    }
+                }
+            });
+        }
+    });
+};
+main();

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/react/component/node.js

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

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

@@ -0,0 +1,14 @@
+import React from "react";
+import Testeranto from "../../../Web.js";
+export default (testImplementations, testSpecifications, testInput) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, {
+        beforeEach: async () => {
+            return new Promise((resolve, rej) => {
+                resolve(React.createElement(testInput, {}, []));
+            });
+        },
+        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));
+};