testeranto 0.62.0 → 0.70.0

package/src/electron.ts

@@ -1,31 +1,79 @@
-import { app, BrowserWindow, utilityProcess } from "electron";
+import readline from "readline";
+import { app, BrowserWindow, utilityProcess, ipcMain } from "electron";
 import pie from "puppeteer-in-electron";
 import puppeteer from "puppeteer-core";
-import { IBuiltConfig, IJsonConfig, IRunTime, ITestTypes } from "./Types";
 import fs from "fs";
 import path from "path";
-import { jsonc } from 'jsonc';
+import { jsonc } from "jsonc";
+import { v4 as uuidv4 } from "uuid";
+
+import { IBuiltConfig, IRunTime } from "./lib/types";
+
+var mode: "DEV" | "PROD" = process.argv[2] === "-dev" ? "DEV" : "PROD";
+
+console.log("hello electron", mode);
+
+const nodeChildren: Record<string, Electron.UtilityProcess> = {};
+const webChildren: Record<string, BrowserWindow> = {};
+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 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();
+    } else {
+      console.log(childProcesses);
+    }
+  }
+});
+
+const onDone = (test: string) => {
+  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.parse(
     (await fs.readFileSync("./docs/testeranto.json")).toString()
   ) as IBuiltConfig;
 
   const loadReport = (configs: IBuiltConfig) => {
-    const win = new BrowserWindow(
-      {
-        show: true,
-        webPreferences: {
-          offscreen: false,
-          devTools: true,
-        }
-      }
-    );
+    const win = new BrowserWindow({
+      show: true,
+      webPreferences: {
+        offscreen: false,
+        devTools: true,
+      },
+    });
 
     win.loadFile(`/${configs.buildDir}/report.html`).then(async (x) => {
       // pie.connect(app, puppeteer).then(async (browser) => {
@@ -35,216 +83,235 @@ const main = async () => {
       //     });
       //   })
       // })
-    })
-  }
+    });
+  };
 
-  const launchNode = (t: string, x: string) => {
-    const f = x.replace(".ts", ".mjs");
-
-    const a = JSON.stringify(
-      {
-        scheduled: true,
-        name: x,
-        ports: [],
-        fs:
-          path.resolve(
-            configs.buildDir,
-            "node",
-            t,
-          ),
-      }
-    )
-    console.log("launchNode", f, a);
-
-    const child = utilityProcess.fork(f, [a], {});
-    child.postMessage({ message: 'hello' })
-    child.on('message', (data) => {
-      console.log("from child", data);
-      launchWebSecondary(process.cwd() + data);
-    })
-    child.on('exit', (data) => {
-      console.log("node process ended with: ", data);
-      fileStream.close()
-    })
-    // child.stdout
-    // child..on("", (data) => {
-    //   console.log("from child", data) // hello world!
-    //   launchWebSecondary(process.cwd() + data);
-    // })
-    // Create a write stream for the file
-    const fileStream = fs.createWriteStream('errors.txt');
-
-    // Pipe the child process's stdout to the file
-    child.stdout?.pipe(fileStream);
-
-    // // Handle errors
-    // child.on('error', (err) => {
-    //   console.error('Error spawning child process:', err);
-    // });
-
-    // fileStream.on('error', (err) => {
-    //   console.error('Error writing to file:', err);
-    // });
-
-    // // Log a message when the child process exits
-    // child.on('close', (code) => {
-    //   console.log(`Child process exited with code ${code}`);
-    // });
-    // console.log("child", child);
-    // child.stdout?.on("data", (x) => {
-    //   console.log("x", x)
-    // })
-  }
+  const launchNode = (src: string, dest: string) => {
+    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: ".",
+    });
 
-  const launchWebSecondary = (htmlFile: string) => {
-    console.log("launchWebSecondary", htmlFile)
-    const subWin = new BrowserWindow(
-      {
-        show: true,
-
-        webPreferences: {
-          nodeIntegration: true,
-          nodeIntegrationInWorker: true,
-          contextIsolation: false,
-          preload: path.join(app.getAppPath(), 'preload.js'),
-          offscreen: false,
-          devTools: false,
+    // console.log("launchNode", src, dest, " -> ", destFolder, argz);
+
+    const child = utilityProcess.fork(dest + ".mjs", [argz], {
+      cwd: destFolder,
+      stdio: "pipe",
+    });
+    const nodeGuid = uuidv4();
+    nodeChildren[nodeGuid] = child;
+
+    if (!fs.existsSync(destFolder)) {
+      fs.mkdirSync(destFolder, { recursive: true });
+    }
+
+    fs.rmSync(`${destFolder}/stdout.log`, { force: true });
+    fs.rmSync(`${destFolder}/stderr.log`, { force: true });
+    const stdout = fs.createWriteStream(`${destFolder}/stdout.log`);
+    const stderr = fs.createWriteStream(`${destFolder}/stderr.log`);
+
+    child
+      .on("message", (data) => {
+        console.log("from child", JSON.stringify(data));
+        if (data.launchWeb) {
+          const guid = uuidv4();
+          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);
+      });
+
+    child.stdout?.pipe(stdout);
+    child.stderr?.pipe(stderr);
+  };
 
-    )
+  const launchWebSecondary = (htmlFile: string): BrowserWindow => {
+    console.log("launchWebSecondary", htmlFile);
+    const subWin = new BrowserWindow({
+      show: false,
+
+      webPreferences: {
+        nodeIntegration: true,
+        nodeIntegrationInWorker: true,
+        contextIsolation: false,
+        preload: path.join(app.getAppPath(), "preload.js"),
+        offscreen: false,
+        devTools: true,
+      },
+    });
     remoteMain.enable(subWin.webContents);
-    subWin.webContents.openDevTools()
+    subWin.webContents.openDevTools();
     subWin.loadFile(htmlFile);
+    return subWin;
 
-  }
+    // const uuid = uuidv4();
+    // windows[uuid] = subWin;
+    // return uuid;
+  };
 
-  const launchWeb = (t: string, changedFile: string) => {
-    console.log("launchWeb", changedFile)
-    const subWin = new BrowserWindow(
-      {
-        show: true,
-
-        webPreferences: {
-          nodeIntegration: true,
-          nodeIntegrationInWorker: true,
-          contextIsolation: false,
-          preload: path.join(app.getAppPath(), 'preload.js'),
-          offscreen: false,
-          devTools: true,
-        }
-      }
+  const launchWeb = (t: string, dest: string) => {
+    console.log("launchWeb", t);
+    childProcesses[t] = "running";
+    const destFolder = dest.replace(".mjs", "");
+
+    const subWin = new BrowserWindow({
+      show: true,
+      webPreferences: {
+        nodeIntegration: true,
+        nodeIntegrationInWorker: true,
+        contextIsolation: false,
+        preload: path.join(app.getAppPath(), "preload.js"),
+        offscreen: false,
+        devTools: true,
+      },
+    });
+
+    webChildren[uuidv4()] = subWin;
 
-    )
     remoteMain.enable(subWin.webContents);
-    // subWin.webContents.openDevTools()
 
-    const htmlFile = changedFile.split(".").slice(0, -1).concat("html").join(".")
+    const webArgz = JSON.stringify({
+      name: dest,
+      ports: [].toString(),
+      fs: destFolder,
+    });
 
-    subWin.loadFile(htmlFile, {
+    // console.log("webArgz", webArgz);
+    subWin.loadFile(`${dest}.html`, {
       query: {
-        requesting: encodeURIComponent(JSON.stringify({
-          name: changedFile,
-          ports: [].toString(),
-          fs:
-            path.resolve(
-              configs.buildDir,
-              "web",
-              t,
-            ),
-        }
-        ))
-      }
-    })
-
-  }
+        requesting: encodeURIComponent(webArgz),
+      },
+    });
 
-  const watcher = (test: string, runtime: IRunTime) => {
-    return path.normalize(
-      `${configs.buildDir}/${runtime}/${test.split('.').slice(0, -1).concat('mjs').join('.')}`
+    if (!fs.existsSync(destFolder)) {
+      fs.mkdirSync(destFolder, { recursive: true });
+    }
+    const stdout = fs.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);
+    });
+    ipcMain.on("message", (message, data) => {
+      console.log("ipcMain message: " + JSON.stringify(data));
+      // process.exit();
+    });
   };
 
-  const changer = (f: string) => {
-    return path.normalize(`${configs.buildDir}/${f}`);
-  };
-  const changer2 = (f: string, r: IRunTime) => {
-    return path.normalize(`${configs.buildDir}/${r}/${f}`);
+  const destinationOfRuntime = (f: string, r: IRunTime) => {
+    return path
+      .normalize(`${configs.buildDir}/${r}/${f}`)
+      .split(".")
+      .slice(0, -1)
+      .join(".");
   };
 
   pie.initialize(app, 2999).then(async () => {
-
     app.on("ready", () => {
       loadReport(configs);
 
-      console.log("running all the tests once initially");;
-      configs.modules.forEach((t) => {
-        if (t.runtime === "node") {
-          launchNode(t.test, changer2(t.test, "node"));
-        } else if (t.runtime === "web") {
-          launchWeb(t.test, changer2(t.test, "web"));
+      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", t.runtime);
+          console.error("runtime makes no sense", runtime);
         }
-      })
-
+      });
 
       console.log("ready and watching for changes...", configs.buildDir);
-      fs.watch(configs.buildDir, {
-        recursive: true,
-      }, (eventType, changedFile) => {
-        console.log(eventType, changedFile);
-        if (changedFile) {
-          configs.modules.forEach((t) => {
-            if (watcher(t.test, t.runtime) === changer(changedFile)) {
-              if (t.runtime === "node") {
-                launchNode(t.test, changer(changedFile))
-              } else if (t.runtime === "web") {
-                launchWeb(t.test, changer(changedFile))
-              } else {
-                console.error("runtime makes no sense", t.runtime);
+      fs.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 pie.connect(app, puppeteer);
-
 };
 
 main();
-
-// ipcMain.handle('web-log', (x, message: string) => {
-//   console.log("web-log)", message);
-// });
-
-// ipcMain.handle('web-error', (x, message: string) => {
-//   console.log("web-error)", message);
-// });
-
-// ipcMain.handle('web-warn', (x, message: string) => {
-//   console.log("web-warn)", message);
-// });
-
-// ipcMain.handle('web-info', (x, message: string) => {
-//   console.log("web-info)", message);
-// });
-
-// ipcMain.handle('quit-app', (x, failed: number) => {
-//   console.log("quit-app", failed);
-//   app.exit(failed);
-// });
-
-// process.stdin.on("data", (configTests) => {
-//   main(JSON.parse(configTests.toString()) as ITestTypes[]);
-// });
-
-// const watchables = (tests: ITestTypes[]) => {
-//   return tests.map((t) => {
-//     return [t[1], `dist/${t[1]}/${t[0].replace(".mts", ".mjs")}`]
-//   })
-// }

package/src/esbuildConfigs/features.ts

@@ -1,6 +1,5 @@
-import { IBaseConfig } from "../Types";
-
 import { BuildOptions } from "esbuild";
+import { IBaseConfig } from "../lib/types";
 
 export default (config: IBaseConfig): BuildOptions => {
   return {
@@ -14,5 +13,5 @@ export default (config: IBaseConfig): BuildOptions => {
     // external: ["graphology"],
 
     format: "esm",
-  }
-}
+  };
+};

package/src/esbuildConfigs/index.ts

@@ -1,22 +1,22 @@
 import { BuildOptions } from "esbuild";
-import { config } from "process";
-import { IBaseConfig } from "../Types";
+
+import { IBaseConfig } from "../lib/types";
 
 export default (config: IBaseConfig): BuildOptions => {
   return {
     target: "esnext",
     format: "esm",
     splitting: true,
-    outExtension: { '.js': '.mjs' },
+    outExtension: { ".js": ".mjs" },
     outbase: config.outbase,
-    jsx: 'transform',
+    jsx: "transform",
     bundle: true,
     minify: config.minify === true,
     write: true,
     loader: {
-      '.js': 'jsx',
-      '.png': 'binary',
-      '.jpg': 'binary',
+      ".js": "jsx",
+      ".png": "binary",
+      ".jpg": "binary",
     },
   };
-}
+};

package/src/esbuildConfigs/node.ts

@@ -1,12 +1,8 @@
 import { BuildOptions } from "esbuild";
 
-import { IBaseConfig, IJsonConfig } from "../Types";
+import { IBaseConfig } from "../lib/types";
 
 import baseEsBuildConfig from "./index.js";
-import { jsonc } from "jsonc";
-import fs from "fs"
-
-// const jsonConfig = jsonc.parse((await fs.readFileSync("./testeranto.json")).toString()) as IJsonConfig;
 
 export default (
   config: IBaseConfig,
@@ -15,45 +11,50 @@ export default (
   return {
     ...baseEsBuildConfig(config),
 
+    splitting: true,
+
     outdir: config.outdir + "/node",
 
     inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
 
     supported: {
-      "dynamic-import": true
+      "dynamic-import": true,
     },
 
     define: {
-      "process.env.FLUENTFFMPEG_COV": "0"
+      "process.env.FLUENTFFMPEG_COV": "0",
     },
     absWorkingDir: process.cwd(),
     banner: {
-      js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+      js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
     },
     platform: "node",
 
     external: [
-      "testeranto.json",
-      "features.test.js",
-      "react",
-      "events",
+      // "testeranto.json",
+      // "features.test.js",
+      // "react",
+      // "events",
       // "ganache"
-      ...config.externals
+      ...config.externals,
     ],
 
     entryPoints: [...entryPoints],
     plugins: [
       ...(config.nodePlugins || []),
       {
-        name: 'rebuild-notify',
+        name: "rebuild-notify",
         setup(build) {
-          build.onEnd(result => {
+          build.onEnd((result) => {
             console.log(`node build ended with ${result.errors.length} errors`);
-            console.log(result)
-            result.errors.length !== 0 && process.exit(-1);
-          })
-        }
+            if (result.errors.length > 0) {
+              console.log(result);
+            }
+            // console.log(result);
+            // result.errors.length !== 0 && process.exit(-1);
+          });
+        },
       },
     ],
   };
-}
+};