testeranto 0.49.10 → 0.70.0

package/dist/common/Web.js

@@ -3,121 +3,57 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const core_1 = require("./core");
-const core_2 = __importDefault(require("./core"));
-let webSocket;
-try {
-    webSocket = new WebSocket("ws://localhost:8080");
-}
-catch (e) {
-    console.error(e);
-}
-const receiveTestResourceConfigUnscheduled = async (t, testresource) => {
-    const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(testresource);
-    Promise.all([...artifacts, logPromise]).then(async () => {
-        // ipcRenderer.invoke('quit-app', failed);
-        window.exit(failed);
-    });
-};
-const receiveTestResourceConfigScheduled = async (t, testresource) => {
-    const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(testresource);
-    webSocket.send(JSON.stringify({
-        type: "testeranto:adios",
-        data: {
-            failed,
-            testResourceConfiguration: t.test.testResourceConfiguration,
-            results: t.toObj(),
-        },
-    }));
-    Promise.all([...artifacts, logPromise]).then(async () => {
-        // ipcRenderer.invoke('quit-app', failed);
-        window.exit(failed);
-    });
-};
-exports.default = async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = core_1.defaultTestResourceRequirement) => {
-    console.log("web NodeWriter", window.NodeWriter);
-    const mrt = new core_2.default(input, testSpecification, testImplementation, testInterface, testResourceRequirement, testInterface.assertioner || (async (t) => t), testInterface.beforeEach ||
-        async function (subject, initialValues, testResource) {
-            return subject;
-        }, testInterface.afterEach || (async (s) => s), testInterface.afterAll || ((store) => undefined), testInterface.butThen || (async (a) => a), testInterface.andWhen, testInterface.actionHandler ||
-        function (b) {
-            return b;
-        }, window.NodeWriter);
-    const tl2 = mrt;
-    const t = tl2.testJobs[0];
-    const testResourceArg = decodeURIComponent(new URLSearchParams(location.search).get('requesting') || '');
-    try {
-        const partialTestResource = JSON.parse(testResourceArg);
-        console.log("initial test resource", partialTestResource);
-        if (partialTestResource.scheduled) {
-            console.log("test is scheduled");
-            console.log("awaiting test resources via WS...");
-            webSocket.addEventListener("open", (event) => {
-                webSocket.addEventListener("message", (event) => {
-                    console.log("Message from server ", event.data);
-                });
-                const r = JSON.stringify({
-                    type: "testeranto:hola",
-                    data: {
-                        requirement: Object.assign(Object.assign({}, testResourceRequirement), { name: partialTestResource.name })
-                    },
-                });
-                webSocket.send(r);
-                console.log("awaiting test resources via websocket...", r);
-                webSocket.onmessage = (async (msg) => {
-                    console.log("message: ", msg);
-                    const resourcesFromWs = JSON.parse(msg.data);
-                    console.log("secondary test resource", resourcesFromWs);
-                    const secondTestResource = Object.assign(Object.assign({ fs: "." }, JSON.parse(JSON.stringify(partialTestResource))), JSON.parse(JSON.stringify(resourcesFromWs)));
-                    console.log("final test resource", secondTestResource);
-                    receiveTestResourceConfigScheduled(t, secondTestResource);
-                });
-            });
+const core_js_1 = __importDefault(require("./lib/core.js"));
+const index_js_1 = require("./lib/index.js");
+// const remote = require("@electron/remote");
+// import remote from "@electron/remote";
+// const electron = require("electron");
+// const remote =
+//   process.type === "browser" ? electron : require("@electron/remote");
+class WebTesteranto extends core_js_1.default {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
+        super(input, testSpecification, testImplementation, testResourceRequirement, window.NodeWriter, testInterface);
+        const testResourceArg = decodeURIComponent(new URLSearchParams(location.search).get("requesting") || "");
+        try {
+            const partialTestResource = JSON.parse(testResourceArg);
+            this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
+        }
+        catch (e) {
+            console.error(e);
+            // process.exit(-1);
         }
-        else {
-            receiveTestResourceConfigUnscheduled(t, partialTestResource);
+        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 partialTestResource = JSON.parse(
-        //   testResourceArg
-        // ) as ITTestResourceConfiguration;
-        // if (partialTestResource.fs && partialTestResource.ports) {
-        //   receiveTestResourceConfig(t, partialTestResource);
-        // } else {
-        //   console.log("test configuration is incomplete", partialTestResource);
-        //   console.log(
-        //     "requesting test resources via ws",
-        //     testResourceRequirement
-        //   );
-        //   webSocket.addEventListener("open", (event) => {
-        //     webSocket.addEventListener("message", (event) => {
-        //       console.log("Message from server ", event.data);
-        //     });
-        //     const r = JSON.stringify({
-        //       type: "testeranto:hola",
-        //       data: {
-        //         testResourceRequirement,
-        //       },
-        //     });
-        //     webSocket.send(r);
-        //     console.log("awaiting test resources via websocket...", r);
-        //     webSocket.onmessage = (
-        //       async (msg: MessageEvent<any>) => {
-        //         console.log("message: ", msg);
-        //         const resourcesFromPm2 = msg.data.testResourceConfiguration;
-        //         const secondTestResource = {
-        //           fs: ".",
-        //           ...JSON.parse(JSON.stringify(partialTestResource)),
-        //           ...JSON.parse(JSON.stringify(resourcesFromPm2)),
-        //         } as ITTestResourceConfiguration;
-        //         console.log("secondTestResource", secondTestResource);
-        //         receiveTestResourceConfig(t, secondTestResource);
-        //       }
-        //     );
-        //   });
-        // }
     }
-    catch (e) {
-        console.error(e);
-        // process.exit(-1);
+    async receiveTestResourceConfig(t, partialTestResource) {
+        const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(partialTestResource, {
+            browser: await window.browser,
+            ipc: window.ipcRenderer,
+        });
+        console.log("test is done, awaiting test result write to fs");
+        Promise.all([...artifacts, logPromise]).then(async () => {
+            // we can't close the window becuase we might be taking a screenshot
+            // window.close();
+            // console.log(
+            //   "(window as any).browser",
+            //   JSON.stringify(await (window as any).browser)
+            // );
+            // var currentWindow = (await (window as any).browser).getCurrentWindow();
+            // currentWindow.close();
+        });
     }
+}
+exports.default = async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = index_js_1.defaultTestResourceRequirement) => {
+    return new WebTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
 };

package/dist/common/electron.js

@@ -3,50 +3,264 @@ 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 electron_1 = require("electron");
+const puppeteer_in_electron_1 = __importDefault(require("puppeteer-in-electron"));
+const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
+const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const url_1 = __importDefault(require("url"));
-let win;
-function createWindow() {
-    win = new electron_1.BrowserWindow({
-        webPreferences: {
-            devTools: true,
-            nodeIntegration: true,
-            nodeIntegrationInWorker: true,
-            contextIsolation: false,
-            preload: path_1.default.join(electron_1.app.getAppPath(), 'preload.js'),
-            sandbox: false
-        },
-        width: 800,
-        height: 600,
-        show: true,
-    });
-    const u = url_1.default.format({
-        pathname: path_1.default.join(process.cwd(), process.argv[2]),
-        protocol: "file:",
-        slashes: true,
-        query: {
-            requesting: encodeURIComponent(process.argv[3]),
+const jsonc_1 = require("jsonc");
+const uuid_1 = require("uuid");
+var mode = process.argv[2] === "-dev" ? "DEV" : "PROD";
+console.log("hello electron", mode);
+const nodeChildren = {};
+const webChildren = {};
+const node2web = {};
+const web2node = {};
+const childProcesses = {};
+readline_1.default.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY)
+    process.stdin.setRawMode(true);
+console.log("\n Electron is running. Press 'q' to quit\n");
+process.stdin.on("keypress", (str, key) => {
+    if (key.name === "q") {
+        mode = "PROD";
+        // process.exit();
+        console.log("Switching to prod mode. Begin shutdown sequence...");
+        // process.exit(-1);
+        const allDone = Object.values(childProcesses).every((v) => v === "done");
+        if (allDone && mode === "PROD") {
+            console.log("Goodbye Testeranto by manual shutdown");
+            process.exit();
         }
-    });
-    console.log("loading", u);
-    win.loadURL(u);
-    win.webContents.openDevTools();
-}
-electron_1.app.on("ready", createWindow);
-electron_1.ipcMain.handle('web-log', (x, message) => {
-    console.log("web-log)", message);
-});
-electron_1.ipcMain.handle('web-error', (x, message) => {
-    console.log("web-error)", message);
-});
-electron_1.ipcMain.handle('web-warn', (x, message) => {
-    console.log("web-warn)", message);
-});
-electron_1.ipcMain.handle('web-info', (x, message) => {
-    console.log("web-info)", message);
+        else {
+            console.log(childProcesses);
+        }
+    }
 });
-electron_1.ipcMain.handle('quit-app', (x, failed) => {
-    console.log("quit-app", failed);
-    // app.exit(failed);
+const onDone = (test) => {
+    console.log("onDone", test);
+    childProcesses[test] = "done";
+    const allDone = Object.values(childProcesses).every((v) => v === "done");
+    if (allDone && mode === "PROD") {
+        console.log("Goodbye Testeranto by auto shutdown");
+        process.exit();
+    }
+    else {
+        console.log(childProcesses);
+    }
+};
+process.on("message", function (message) {
+    console.log("message: " + message);
+    process.exit();
 });
+const remoteMain = require("@electron/remote/main");
+remoteMain.initialize();
+const main = async () => {
+    const configs = jsonc_1.jsonc.parse((await fs_1.default.readFileSync("./docs/testeranto.json")).toString());
+    const loadReport = (configs) => {
+        const win = new electron_1.BrowserWindow({
+            show: true,
+            webPreferences: {
+                offscreen: false,
+                devTools: true,
+            },
+        });
+        win.loadFile(`/${configs.buildDir}/report.html`).then(async (x) => {
+            // pie.connect(app, puppeteer).then(async (browser) => {
+            //   pie.getPage(browser, win).then(async (page) => {
+            //     await page.screenshot({
+            //       path: 'electron-puppeteer-screenshot1.jpg'
+            //     });
+            //   })
+            // })
+        });
+    };
+    const launchNode = (src, dest) => {
+        var _a, _b;
+        console.log("launchNode", src);
+        childProcesses[src] = "running";
+        const destFolder = dest.replace(".mjs", "");
+        const argz = JSON.stringify({
+            scheduled: true,
+            name: src,
+            ports: [3333],
+            // fs: path.resolve(configs.buildDir, "web", destFolder + "/"),
+            // fs: destFolder,
+            fs: ".",
+        });
+        // console.log("launchNode", src, dest, " -> ", destFolder, argz);
+        const child = electron_1.utilityProcess.fork(dest + ".mjs", [argz], {
+            cwd: destFolder,
+            stdio: "pipe",
+        });
+        const nodeGuid = (0, uuid_1.v4)();
+        nodeChildren[nodeGuid] = child;
+        if (!fs_1.default.existsSync(destFolder)) {
+            fs_1.default.mkdirSync(destFolder, { recursive: true });
+        }
+        fs_1.default.rmSync(`${destFolder}/stdout.log`, { force: true });
+        fs_1.default.rmSync(`${destFolder}/stderr.log`, { force: true });
+        const stdout = fs_1.default.createWriteStream(`${destFolder}/stdout.log`);
+        const stderr = fs_1.default.createWriteStream(`${destFolder}/stderr.log`);
+        child
+            .on("message", (data) => {
+            console.log("from child", JSON.stringify(data));
+            if (data.launchWeb) {
+                const guid = (0, uuid_1.v4)();
+                const webChild = launchWebSecondary(process.cwd() + data.launchWeb);
+                // child.postMessage({ webLaunched: guid });
+                webChild.webContents.on("did-finish-load", () => {
+                    // webChild.webContents.send("message", "hello world");
+                    child.postMessage({ webLaunched: guid });
+                    webChildren[guid] = webChild;
+                    node2web[nodeGuid] = [...(node2web[nodeGuid] || []), guid];
+                });
+            }
+            if (data.teardown) {
+                webChildren[data.teardown].close();
+                delete webChildren[data.teardown];
+                node2web[nodeGuid] = node2web[nodeGuid].filter((x) => x !== data.teardown);
+            }
+        })
+            .on("exit", (data) => {
+            stdout.close();
+            stderr.close();
+            console.log(`ending node ${src}`);
+            onDone(src);
+        });
+        (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.pipe(stdout);
+        (_b = child.stderr) === null || _b === void 0 ? void 0 : _b.pipe(stderr);
+    };
+    const launchWebSecondary = (htmlFile) => {
+        console.log("launchWebSecondary", htmlFile);
+        const subWin = new electron_1.BrowserWindow({
+            show: false,
+            webPreferences: {
+                nodeIntegration: true,
+                nodeIntegrationInWorker: true,
+                contextIsolation: false,
+                preload: path_1.default.join(electron_1.app.getAppPath(), "preload.js"),
+                offscreen: false,
+                devTools: true,
+            },
+        });
+        remoteMain.enable(subWin.webContents);
+        subWin.webContents.openDevTools();
+        subWin.loadFile(htmlFile);
+        return subWin;
+        // const uuid = uuidv4();
+        // windows[uuid] = subWin;
+        // return uuid;
+    };
+    const launchWeb = (t, dest) => {
+        console.log("launchWeb", t);
+        childProcesses[t] = "running";
+        const destFolder = dest.replace(".mjs", "");
+        const subWin = new electron_1.BrowserWindow({
+            show: true,
+            webPreferences: {
+                nodeIntegration: true,
+                nodeIntegrationInWorker: true,
+                contextIsolation: false,
+                preload: path_1.default.join(electron_1.app.getAppPath(), "preload.js"),
+                offscreen: false,
+                devTools: true,
+            },
+        });
+        webChildren[(0, uuid_1.v4)()] = subWin;
+        remoteMain.enable(subWin.webContents);
+        const webArgz = JSON.stringify({
+            name: dest,
+            ports: [].toString(),
+            fs: destFolder,
+        });
+        // console.log("webArgz", webArgz);
+        subWin.loadFile(`${dest}.html`, {
+            query: {
+                requesting: encodeURIComponent(webArgz),
+            },
+        });
+        if (!fs_1.default.existsSync(destFolder)) {
+            fs_1.default.mkdirSync(destFolder, { recursive: true });
+        }
+        const stdout = fs_1.default.createWriteStream(`${destFolder}/stdout.log`);
+        subWin.webContents.on("console-message", (event, level, message, line, sourceId) => {
+            stdout.write(JSON.stringify({
+                event,
+                level,
+                message: JSON.stringify(message),
+                line,
+                sourceId,
+            }, null, 2));
+            stdout.write("\n");
+        });
+        subWin.on("closed", () => {
+            stdout.close();
+            console.log(`ending web ${t}`);
+            // childProcesses[t] = "done";
+            onDone(t);
+        });
+        electron_1.ipcMain.on("message", (message, data) => {
+            console.log("ipcMain message: " + JSON.stringify(data));
+            // process.exit();
+        });
+    };
+    const destinationOfRuntime = (f, r) => {
+        return path_1.default
+            .normalize(`${configs.buildDir}/${r}/${f}`)
+            .split(".")
+            .slice(0, -1)
+            .join(".");
+    };
+    puppeteer_in_electron_1.default.initialize(electron_1.app, 2999).then(async () => {
+        electron_1.app.on("ready", () => {
+            loadReport(configs);
+            console.log("running all the tests once initially");
+            configs.tests.forEach(([test, runtime, secondaryArtifacts]) => {
+                childProcesses[test] = "loaded";
+                if (runtime === "node") {
+                    launchNode(test, destinationOfRuntime(test, "node"));
+                }
+                else if (runtime === "web") {
+                    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) => {
+                // console.log(eventType);
+                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(".")) {
+                                launchNode(test, destinationOfRuntime(test, "node"));
+                            }
+                            if (changedFile ===
+                                test
+                                    .replace("./", "web/")
+                                    .split(".")
+                                    .slice(0, -1)
+                                    .concat("mjs")
+                                    .join(".")) {
+                                launchWeb(test, destinationOfRuntime(test, "web"));
+                            }
+                        }
+                    });
+                }
+            });
+        });
+    });
+    await puppeteer_in_electron_1.default.connect(electron_1.app, puppeteer_core_1.default);
+};
+main();

package/dist/common/esbuildConfigs/features.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (config) => {
+    return {
+        bundle: true,
+        entryPoints: [config.features],
+        minify: config.minify === true,
+        outbase: config.outbase,
+        write: true,
+        outfile: `${config.outdir}/features.test.js`,
+        // external: ["graphology"],
+        format: "esm",
+    };
+};

package/dist/common/esbuildConfigs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (config) => {
+    return {
+        target: "esnext",
+        format: "esm",
+        splitting: true,
+        outExtension: { ".js": ".mjs" },
+        outbase: config.outbase,
+        jsx: "transform",
+        bundle: true,
+        minify: config.minify === true,
+        write: true,
+        loader: {
+            ".js": "jsx",
+            ".png": "binary",
+            ".jpg": "binary",
+        },
+    };
+};

package/dist/common/esbuildConfigs/node.js

@@ -0,0 +1,37 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = __importDefault(require("./index.js"));
+exports.default = (config, entryPoints) => {
+    return Object.assign(Object.assign({}, (0, index_js_1.default)(config)), { splitting: true, outdir: config.outdir + "/node", inject: [`./node_modules/testeranto/dist/cjs-shim.js`], supported: {
+            "dynamic-import": true,
+        }, define: {
+            "process.env.FLUENTFFMPEG_COV": "0",
+        }, absWorkingDir: process.cwd(), banner: {
+            js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
+        }, platform: "node", external: [
+            // "testeranto.json",
+            // "features.test.js",
+            // "react",
+            // "events",
+            // "ganache"
+            ...config.externals,
+        ], entryPoints: [...entryPoints], plugins: [
+            ...(config.nodePlugins || []),
+            {
+                name: "rebuild-notify",
+                setup(build) {
+                    build.onEnd((result) => {
+                        console.log(`node build ended with ${result.errors.length} errors`);
+                        if (result.errors.length > 0) {
+                            console.log(result);
+                        }
+                        // console.log(result);
+                        // result.errors.length !== 0 && process.exit(-1);
+                    });
+                },
+            },
+        ] });
+};

package/dist/common/esbuildConfigs/report.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (config) => {
+    return {
+        bundle: true,
+        entryPoints: ["./node_modules/testeranto/dist/module/report.js"],
+        minify: config.minify === true,
+        outbase: config.outbase,
+        write: true,
+        outfile: `${config.outdir}/report.js`,
+        external: ["tests.json", "features.test.js"],
+    };
+};

package/dist/common/esbuildConfigs/tests.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = (config) => {
+    return {
+        bundle: true,
+        entryPoints: [config.features],
+        minify: config.minify === true,
+        outbase: config.outbase,
+        write: true,
+        outfile: `${config.outdir}/tests.test.js`,
+        // external: ["graphology"]
+    };
+};

package/dist/common/esbuildConfigs/web.js

@@ -0,0 +1,53 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const index_js_1 = __importDefault(require("./index.js"));
+exports.default = (config, entryPoints) => {
+    return Object.assign(Object.assign({}, (0, index_js_1.default)(config)), { 
+        // inject: ["./node_modules/testeranto/dist/cjs-shim.js"],
+        // banner: {
+        //   js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
+        // },
+        // splitting: true,
+        outdir: config.outdir + "/web", alias: {
+            react: path_1.default.resolve("./node_modules/react"),
+        }, external: [
+            "testeranto.json",
+            "features.test.ts",
+            // "url",
+            "react",
+            "electron",
+            "path",
+            "fs",
+            "stream",
+            "http",
+            "constants",
+            "net",
+            "assert",
+            "tls",
+            "os",
+            "child_process",
+            "readline",
+            "zlib",
+            "crypto",
+            "https",
+        ], platform: "browser", entryPoints: [...entryPoints], plugins: [
+            ...(config.webPlugins || []),
+            {
+                name: "rebuild-notify",
+                setup(build) {
+                    build.onEnd((result) => {
+                        console.log(`web build ended with ${result.errors.length} errors`);
+                        if (result.errors.length > 0) {
+                            console.log(result);
+                        }
+                        // console.log(result);
+                        // result.errors.length !== 0 && process.exit(-1);
+                    });
+                },
+            },
+        ] });
+};