testeranto 0.49.10 → 0.62.0

package/src/electron.ts

@@ -1,59 +1,250 @@
-import { app, BrowserWindow, ipcMain } from "electron";
+import { app, BrowserWindow, utilityProcess } 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 url from "url";
+import { jsonc } from 'jsonc';
 
-let win: BrowserWindow;
+const remoteMain = require("@electron/remote/main");
 
-function createWindow() {
-  win = new BrowserWindow({
+remoteMain.initialize();
 
-    webPreferences: {
-      devTools: true,
-      nodeIntegration: true,
-      nodeIntegrationInWorker: true,
-      contextIsolation: false,
-      preload: path.join(app.getAppPath(), 'preload.js'),
-      sandbox: false
+const main = async () => {
 
-    },
-    width: 800,
-    height: 600,
-    show: true,
-  });
-  const u = url.format({
-    pathname: path.join(process.cwd(), process.argv[2]),
-    protocol: "file:",
-    slashes: true,
-    query: {
-      requesting: encodeURIComponent(process.argv[3]),
-    }
+  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,
+        }
+      }
+    );
+
+    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 = (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 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,
+        }
+      }
+
+    )
+    remoteMain.enable(subWin.webContents);
+    subWin.webContents.openDevTools()
+    subWin.loadFile(htmlFile);
+
+  }
+
+  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,
+        }
+      }
+
+    )
+    remoteMain.enable(subWin.webContents);
+    // subWin.webContents.openDevTools()
+
+    const htmlFile = changedFile.split(".").slice(0, -1).concat("html").join(".")
+
+    subWin.loadFile(htmlFile, {
+      query: {
+        requesting: encodeURIComponent(JSON.stringify({
+          name: changedFile,
+          ports: [].toString(),
+          fs:
+            path.resolve(
+              configs.buildDir,
+              "web",
+              t,
+            ),
+        }
+        ))
+      }
+    })
+
+  }
+
+  const watcher = (test: string, runtime: IRunTime) => {
+    return path.normalize(
+      `${configs.buildDir}/${runtime}/${test.split('.').slice(0, -1).concat('mjs').join('.')}`
+    );
+  };
+
+  const changer = (f: string) => {
+    return path.normalize(`${configs.buildDir}/${f}`);
+  };
+  const changer2 = (f: string, r: IRunTime) => {
+    return path.normalize(`${configs.buildDir}/${r}/${f}`);
+  };
+
+  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"));
+        } else {
+          console.error("runtime makes no sense", t.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);
+              }
+            }
+          })
+        }
+
+      })
+    });
   });
-  console.log("loading", u);
-  win.loadURL(u);
-  win.webContents.openDevTools()
-}
 
-app.on("ready", createWindow);
+  await pie.connect(app, puppeteer);
+
+};
+
+main();
+
+// ipcMain.handle('web-log', (x, message: string) => {
+//   console.log("web-log)", message);
+// });
 
-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-error', (x, message: string) => {
-  console.log("web-error)", message);
-});
+// ipcMain.handle('web-warn', (x, message: string) => {
+//   console.log("web-warn)", 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('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);
+// });
 
-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[]);
+// });
 
-export { };
+// const watchables = (tests: ITestTypes[]) => {
+//   return tests.map((t) => {
+//     return [t[1], `dist/${t[1]}/${t[0].replace(".mts", ".mjs")}`]
+//   })
+// }

package/src/esbuildConfigs/features.ts

@@ -0,0 +1,18 @@
+import { IBaseConfig } from "../Types";
+
+import { BuildOptions } from "esbuild";
+
+export default (config: IBaseConfig): BuildOptions => {
+  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/src/esbuildConfigs/index.ts

@@ -0,0 +1,22 @@
+import { BuildOptions } from "esbuild";
+import { config } from "process";
+import { IBaseConfig } from "../Types";
+
+export default (config: IBaseConfig): BuildOptions => {
+  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/src/esbuildConfigs/node.ts

@@ -0,0 +1,59 @@
+import { BuildOptions } from "esbuild";
+
+import { IBaseConfig, IJsonConfig } from "../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,
+  entryPoints: Set<string> | string[]
+): BuildOptions => {
+  return {
+    ...baseEsBuildConfig(config),
+
+    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`);
+            console.log(result)
+            result.errors.length !== 0 && process.exit(-1);
+          })
+        }
+      },
+    ],
+  };
+}

package/src/esbuildConfigs/report.ts

@@ -0,0 +1,51 @@
+// import { jsonc } from "jsonc";
+
+// import { IBaseConfig, IJsonConfig } from "../Types";
+
+// import baseEsBuildConfig from "./index.js";
+
+// import fs from "fs"
+// import { BuildOptions } from "esbuild";
+// // import { CssModulesPlugin } from 'esbuild-css-modules-plugin';
+// const jsonConfig = jsonc.parse((await fs.readFileSync("./testeranto.json")).toString()) as IJsonConfig;
+
+// export default (config: IBaseConfig): BuildOptions => {
+//   return {
+//     bundle: true,
+//     entryPoints: ["./node_modules/testeranto/dist/module/report.js"],
+//     minify: config.minify === true,
+//     outbase: config.outbase,
+//     write: true,
+//     outfile: `${jsonConfig.outdir}/report.js`,
+//     external: [
+//       "tests.json",
+//       "features.test.js"
+//     ],
+//     // plugins: [
+//     //   CssModulesPlugin({
+//     //     // @see https://github.com/indooorsman/esbuild-css-modules-plugin/blob/main/index.d.ts for more details
+//     //     force: true,
+//     //     emitDeclarationFile: true,
+//     //     localsConvention: 'camelCaseOnly',
+//     //     namedExports: true,
+//     //     inject: false
+//     //   })
+//     // ]
+//   }
+//   // return {
+//   //   bundle: true,
+//   //   entryPoints: [
+//   //     "./node_modules/testeranto/dist/module/Report.js",
+//   //     jsonConfig.features
+//   //   ],
+//   //   minify: config.minify === true,
+//   //   outbase: ".",
+//   //   outdir: 'docs',
+//   //   write: true,
+//   //   // outfile: `${jsonConfig.outdir}/Report.js`,
+//   //   external: [
+//   //     "features.test.js",
+//   //     "testeranto.json"
+//   //   ]
+//   // }
+// }

package/src/esbuildConfigs/tests.ts

@@ -0,0 +1,20 @@
+import { jsonc } from "jsonc";
+
+import { IBaseConfig, IJsonConfig } from "../Types";
+
+import fs from "fs"
+import { BuildOptions } from "esbuild";
+
+// const jsonConfig = jsonc.parse((await fs.readFileSync("./testeranto.json")).toString()) as IJsonConfig;
+
+export default (config: IBaseConfig): BuildOptions => {
+  return {
+    bundle: true,
+    entryPoints: [config.features],
+    minify: config.minify === true,
+    outbase: config.outbase,
+    write: true,
+    outfile: `${config.outdir}/tests.test.js`,
+    // external: ["graphology"]
+  }
+}

package/src/esbuildConfigs/web.ts

@@ -0,0 +1,73 @@
+import { BuildOptions } from "esbuild";
+import path from "path";
+
+import { IBaseConfig, IJsonConfig } from "../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,
+  entryPoints: Set<string> | string[]
+): BuildOptions => {
+  return {
+
+    ...baseEsBuildConfig(config),
+
+    // inject: ['./node_modules/testeranto/dist/cjs-shim.js'],
+    // banner: {
+    //   js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+    // },
+
+    outdir: config.outdir + "/web",
+
+    alias: {
+      react: path.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`);
+            console.log(result)
+            result.errors.length !== 0 && process.exit(-1);
+          })
+        }
+      },
+    ],
+  };
+}