npm - testeranto - Versions diffs - 0.49.10 → 0.62.0 - Mend

testeranto 0.49.10 → 0.62.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (241) hide show

package/src/Project.ts CHANGED Viewed

@@ -1,50 +1,22 @@
-import esbuild, { BuildOptions } from "esbuild";
+import esbuild from "esbuild";
 import fs from "fs";
-import fsExists from "fs.promises.exists";
 import path from "path";
-import pm2 from "pm2";
 import readline from 'readline';
-import WebSocket, { WebSocketServer } from 'ws';
+import { glob } from "glob";
-import { TesterantoFeatures } from "./Features";
 import { IBaseConfig, IRunTime, ITestTypes } from "./Types";
-import { ITTestResourceRequirement } from './core';
-import { glob } from "glob";
-readline.emitKeypressEvents(process.stdin);
-if (process.stdin.isTTY) process.stdin.setRawMode(true);
+import esbuildNodeConfiger from "./esbuildConfigs/node.js";
+import esbuildWebConfiger from "./esbuildConfigs/web.js";
+import esbuildFeaturesConfiger from "./esbuildConfigs/features.js";
-const TIMEOUT = 2000;
-const OPEN_PORT = "";
-let webSocketServer: WebSocketServer;
-type ISchedulerProtocols = `ipc` | `ws`;
-type IAdios = {
-  name: string;
-  failed: any;
-  testResourceConfiguration: {
-    name: string;
-  };
-  results: {
-    fails: any[];
-    givens: any[];
-    name: string;
-  };
-};
-type IAdiosIPC = {
-  process: {
-    namespace: string;
-    versioning: object;
-    name: string;
-    pm_id: number;
-  };
-  data: IAdios
-  at: string;
-};
+import webHtmlFrame from "./web.html.js";
+import reportHtmlFrame from "./report.html.js";
+import childProcess from 'child_process';
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY) process.stdin.setRawMode(true);
 const getRunnables = (
   tests: ITestTypes[],
@@ -68,34 +40,11 @@ const getRunnables = (
 }
 export class ITProject {
-  clearScreen: boolean;
-  devMode: boolean;
-  exitCodes: Record<number, string> = {};
-  features: TesterantoFeatures;
+  config: IBaseConfig;
   mode: `up` | `down` = `up`;
-  ports: Record<string, string> = {};
-  tests: ITestTypes[];
-  websockets: Record<string, WebSocket> = {};
-  resourceQueue: {
-    requirement: ITTestResourceRequirement,
-    protocol: ISchedulerProtocols,
-  }[] = [];
-  private spinCycle = 0;
-  private spinAnimation = "←↖↑↗→↘↓↙";
   constructor(config: IBaseConfig) {
-    this.clearScreen = config.clearScreen;
-    this.devMode = config.devMode;
-    // mark each port as open
-    Object.values(config.ports).forEach((port) => {
-      this.ports[port] = OPEN_PORT;
-    });
-    const testPath = `${process.cwd()}/${config.tests}`;
-    const featurePath = `${process.cwd()}/${config.features}`;
+    this.config = config;
     process.stdin.on('keypress', (str, key) => {
       if (key.name === 'q') {
@@ -109,712 +58,620 @@ export class ITProject {
       }
     });
-    import(testPath).then((tests) => {
-      this.tests = tests.default;
-      import(featurePath).then(async (features) => {
-        this.features = features.default;
-        await 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}/${sourceDir.join("/")}/${sourceFileNameMinusJs}.html`);
-              const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
-              return fs.promises.mkdir(path.dirname(htmlFilePath), { recursive: true }).then(x => fs.writeFileSync(htmlFilePath,
-                `
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <script type="module" src="${jsfilePath}"></script>
-</head>
-<body>
-  <h1>${htmlFilePath}</h1>
-  <div id="root">
-  </div>
-</body>
-<footer></footer>
-</html>
-`))
-            })
-        ));
-        const [nodeEntryPoints, webEntryPoints] = getRunnables(this.tests);
-        const esbuildConfigNode: BuildOptions = {
-          define: {
-            "process.env.FLUENTFFMPEG_COV": "0"
-          },
-          absWorkingDir: process.cwd(),
-          banner: {
-            js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
-          },
-          target: "esnext",
-          format: "esm",
-          splitting: true,
-          outExtension: { '.js': '.mjs' },
-          platform: "node",
-          external: [
-            "tests.test.js",
-            "features.test.js", "react"],
-          outbase: config.outbase,
-          outdir: config.outdir,
-          jsx: 'transform',
-          entryPoints: [...nodeEntryPoints],
-          bundle: true,
-          minify: config.minify === true,
-          write: true,
-          loader: {
-            '.js': 'jsx',
-            '.png': 'binary',
-            '.jpg': 'binary',
-          },
-          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);
-                })
-              }
-            },
-          ],
-        };
-        const esbuildConfigWeb: BuildOptions = {
-          target: "esnext",
-          format: "esm",
-          splitting: true,
-          outExtension: { '.js': '.mjs' },
-          alias: {
-            react: path.resolve("./node_modules/react")
-          },
-          external: [
-            "tests.test.js",
-            "features.test.js",
-            // "url",
-            // "react",
-            "electron",
-            "path",
-            "fs",
-            "stream",
-          ],
-          platform: "browser",
-          outbase: config.outbase,
-          outdir: config.outdir,
-          jsx: 'transform',
-          entryPoints: [
-            ...webEntryPoints,
-            testPath,
-            featurePath,
-          ],
-          bundle: true,
-          minify: config.minify === true,
-          write: true,
-          loader: {
-            '.js': 'jsx',
-            '.png': 'binary',
-            '.jpg': 'binary',
-          },
-          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);
-                })
-              }
-            },
-          ],
-        };
-        glob('./dist/chunk-*.mjs', { ignore: 'node_modules/**' }).then((chunks) => {
-          console.log("deleting chunks", chunks)
-          chunks.forEach((chunk) => {
-            console.log("deleting chunk", chunk)
-            fs.unlinkSync(chunk);
-          })
-        })
-        esbuild.build({
-          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.test.js", "features.test.js"]
-        });
-        fs.writeFileSync(`${config.outdir}/report.html`, `
-<!DOCTYPE html>
-<html lang="en">
-<head>
-  <meta name="description" content="Webpage description goes here" />
-  <meta charset="utf-8" />
-  <title>kokomoBay - testeranto</title>
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <meta name="author" content="" />
-  <link rel="stylesheet" href="./Report.css" />
-  <script type="importmap">
-    {
-    "imports": {
-      "tests.test.js": "./tests.test.js",
-      "features.test.js": "./features.test.js"
-    }
-  }
-  </script>
-  <script src="./Report.js"></script>
-</head>
-<body>
-  <div id="root">
-    react is loading
-  </div>
-</body>
-</html>
-        `)
-        Promise.all([
-          esbuild.context(esbuildConfigNode)
-            .then(async (nodeContext) => {
-              await nodeContext.watch();
-            }),
-          esbuild.context(esbuildConfigWeb)
-            .then(async (esbuildWeb) => {
-              await esbuildWeb.watch();
-            })
-        ]).then(() => {
-          if (config.devMode === false) {
-            console.log("Your tests were built but not run because devMode was false. Exiting gracefully");
-            process.exit(0);
-          } else {
-            pm2.connect(async (err) => {
-              if (err) {
-                console.error(err);
-                process.exit(-1);
-              } else {
-                console.log(`pm2 is connected`);
-              }
-              // run a websocket as an alternative to node IPC
-              webSocketServer = new WebSocketServer({
-                port: 8080,
-                host: "localhost",
-              });
-              webSocketServer.on('open', () => {
-                console.log('open');
-              });
-              webSocketServer.on('close', (data) => {
-                console.log('webSocketServer close: %s', data);
-              });
-              webSocketServer.on('listening', () => {
-                console.log("webSocketServer listening", webSocketServer.address());
-              });
-              webSocketServer.on('connection', (webSocket: WebSocket) => {
-                webSocket.on('message', (webSocketData) => {
-                  const payload = JSON.parse(webSocketData.valueOf().toString() as any);
-                  const messageType = payload.type;
-                  if (messageType === "testeranto:hola") {
-                    const name = payload.data.requirement.name;
-                    const requestedResources = payload.data;
-                    this.websockets[name] = webSocket
-                    console.log('hola WS! connected: ' + name + ' in ' + Object.getOwnPropertyNames(this.websockets))
-                    this.requestResource(requestedResources.requirement, 'ws');
-                  } else if (messageType === "testeranto:adios") {
-                    console.log("adios WS", payload.data.testResourceConfiguration.name);
-                    this.releaseTestResourceWs(payload as any);
-                  }
-                });
-              });
-              const makePath = (fPath: string, rt: IRunTime): string => {
-                return path.resolve("./" + config.outdir + "/" + fPath.replace(path.extname(fPath), "") + ".mjs");
-              };
-              const bootInterval = setInterval(async () => {
-                const filesToLookup = this.tests
-                  .map(([p, rt]) => {
-                    const filepath = makePath(p, rt);
-                    return {
-                      filepath,
-                      exists: fsExists(filepath),
-                    };
-                  });
-                const allFilesExist = (
-                  await Promise.all(filesToLookup.map((f) => f.exists))
-                ).every((b) => b);
-                if (!allFilesExist) {
-                  console.log(this.spinner(), "waiting for files to build...")
-                  filesToLookup.forEach((f) => {
-                    console.log(f.exists, "\t", f.filepath);
-                  })
-                } else {
-                  clearInterval(bootInterval);
-                  pm2.launchBus((err, pm2_bus) => {
-                    pm2_bus.on("testeranto:hola", (packet: { data: { requirement: ITTestResourceRequirement } }) => {
-                      this.requestResource(
-                        packet.data.requirement,
-                        'ipc'
-                      );
-                    });
-                    pm2_bus.on("testeranto:adios", (payload: IAdiosIPC) => {
-                      this.releaseTestResourcePm2(payload.data);
-                    });
-                  });
-                  this
-                    .tests
-                    .reduce((m, [inputFilePath, runtime]) => {
-                      const script = makePath(inputFilePath, runtime);
-                      const partialTestResourceByCommandLineArg = `${script} '${JSON.stringify(
-                        {
-                          name: inputFilePath,
-                          ports: [],
-                          fs: path.resolve(
-                            process.cwd(),
-                            config.outdir,
-                            inputFilePath
-                          ),
-                        }
-                      )}'`;
-                      if (runtime === "web") {
-                        const fileAsList = inputFilePath.split("/");
-                        const fileListHead = fileAsList.slice(0, -1);
-                        const fname = fileAsList[fileAsList.length - 1];
-                        const fnameOnly = fname.split(".").slice(0, -1).join(".");
-                        const htmlFile = [config.outdir, ...fileListHead, `${fnameOnly}.html`].join("/");
-                        const jsFile = path.resolve(htmlFile.split(".html")[0] + ".mjs")
-                        console.log("watching", jsFile);
-                        pm2.start(
-                          {
-                            script: `yarn electron node_modules/testeranto/dist/common/electron.js ${htmlFile} '${JSON.stringify(
-                              {
-                                scheduled: true,
-                                name: inputFilePath,
-                                ports: [],
-                                fs:
-                                  path.resolve(
-                                    process.cwd(),
-                                    config.outdir,
-                                    inputFilePath
-                                  ),
-                              }
-                            )}'`,
-                            name: inputFilePath,
-                            autorestart: false,
-                            args: partialTestResourceByCommandLineArg,
-                            watch: [jsFile],
-                          },
-                          (err, proc) => {
-                            if (err) {
-                              console.error(err);
-                              return pm2.disconnect();
-                            }
-                          }
-                        );
-                      } else if (runtime === "node") {
-                        const resolvedPath = path.resolve(script);
-                        console.log("watching", resolvedPath);
-                        pm2.start({
-                          name: inputFilePath,
-                          script: `node ${resolvedPath} '${JSON.stringify(
-                            {
-                              scheduled: true,
-                              name: inputFilePath,
-                              ports: [],
-                              fs:
-                                path.resolve(
-                                  process.cwd(),
-                                  config.outdir,
-                                  inputFilePath
-                                ),
-                            }
-                          )}'`,
-                          autorestart: false,
-                          watch: [resolvedPath],
-                          args: partialTestResourceByCommandLineArg
-                        }, (err, proc) => {
-                          if (err) {
-                            console.error(err);
-                            return pm2.disconnect();
-                          }
-                        });
-                      }
-                      this.exitCodes[inputFilePath] = null;
-                      return [inputFilePath, ...m];
-                    }, []);
-                  setInterval(this.mainLoop, TIMEOUT).unref();
-                }
-              }, TIMEOUT).unref();
-            });
-          }
-        })
-      })
-    })
-  }
-  public requestResource(
-    requirement: ITTestResourceRequirement,
-    protocol: ISchedulerProtocols
-  ) {
-    this.resourceQueue.push({ requirement, protocol });
-  }
-  public getSecondaryEndpointsPoints(runtime?: IRunTime): string[] {
-    if (runtime) {
-      return this.tests
-        .filter((t) => {
-          return (t[1] === runtime);
+    const childElectron = childProcess.spawn("yarn", ["electron", "node_modules/testeranto/dist/common/electron.js"]);
+    // childElectron.stdout.on('data', function (msg) {
+    //   console.log(msg.toString())
+    // });
+    const fileStream = fs.createWriteStream(`./${this.config.outdir}/electron.log`);
+    childElectron.stdout?.pipe(fileStream);
+    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)
+          ))
         })
-        .map((tc) => tc[0])
-    }
+    ));
-    return this.tests
-      .map((tc) => tc[0])
-  }
+    const [nodeEntryPoints, webEntryPoints] = getRunnables(this.config.tests);
-  public initiateShutdown(reason: string) {
-    console.log("Shutdown initiated because", reason);
-    this.mode = "down";
-  }
-  private shutdown() {
-    let i = 0;
-    new Promise((res, reh) => {
-      console.log("final results: ");
-      const procsTable: any[] = [];
-      pm2.list((err, procs) => {
-        procs.forEach((proc, ndx) => {
-          const exitCode = this.exitCodes[proc.name as string]
-          if (exitCode !== 0) {
-            i++;
-          }
-          procsTable.push({
-            name: proc.name,
-            pm_id: proc.pm_id,
-            exitCode
-          })
-          if (ndx === procs.length - 1) {
-            console.table(procsTable);
-            res(i)
-          }
-        })
+    glob(`./${config.outdir}/chunk-*.mjs`, { ignore: 'node_modules/**' }).then((chunks) => {
+      console.log("deleting chunks", chunks)
+      chunks.forEach((chunk) => {
+        console.log("deleting chunk", chunk)
+        fs.unlinkSync(chunk);
       })
-    }).then((failures: number) => {
-      pm2.stop("all", (e) => console.error(e));
-      pm2.disconnect();
-      console.log(`gracefully exiting with ${failures} failures`)
-      process.exit(failures);
-    })
-  }
-  private spinner() {
-    this.spinCycle = (this.spinCycle + 1) % this.spinAnimation.length;
-    return this.spinAnimation[this.spinCycle];
-  }
-  private async releaseTestResourceWs(payload: any) {
-    const name = payload.data.testResourceConfiguration.name;
-    const failed = payload.data.failed;
-    this.exitCodes[name] = failed;
-    Object.keys(this.ports).forEach((port: string) => {
-      if (this.ports[port] === name) {
-        this.ports[port] = OPEN_PORT;
-      }
-    });
-  }
-  private async releaseTestResourcePm2(payload: IAdios) {
-    const name = payload.testResourceConfiguration.name;
-    const failed = payload.failed;
-    this.exitCodes[name] = failed;
+    })
-    pm2.list((err, processes) => {
-      processes.forEach((proc: pm2.ProcessDescription) => {
-        if (proc.name === name) {
-          Object.keys(this.ports).forEach((port: string) => {
-            if (this.ports[port] === name) {
-              this.ports[port] = OPEN_PORT;
-            }
-          });
-        }
+    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([
+      esbuild.context(esbuildFeaturesConfiger(config))
+        .then(async (featuresContext) => {
+          console.log("features entry points", config.features);
+          await featuresContext.watch();
+          return featuresContext;
+        }),
+      esbuild.context(esbuildNodeConfiger(config, nodeEntryPoints))
+        .then(async (nodeContext) => {
+          console.log("node entry points", nodeEntryPoints);
+          await nodeContext.watch();
+          return nodeContext;
+        }),
+      esbuild.context(esbuildWebConfiger(config, webEntryPoints))
+        .then(async (esbuildWeb) => {
+          console.log("web entry points", webEntryPoints);
+          await esbuildWeb.watch();
+          return esbuildWeb;
+        }),
+    ]).then(async (contexts) => {
+      Promise.all(
+        config.tests.map(async ([test, runtime]) => {
+          return {
+            test,
+            runtime
+          };
+        })
+      ).then(async (modules) => {
+        fs.writeFileSync(`${config.outdir}/testeranto.json`, JSON.stringify(
+          {
+            modules,
+            buildDir: process.cwd() + "/" + config.outdir
+          }, null, 2));
       });
-    });
-  }
-  private allocateViaWs(resourceRequest: {
-    requirement: ITTestResourceRequirement;
-    protocol: ISchedulerProtocols;
-  }) {
-    const name = resourceRequest.requirement.name;
-    const testResourceRequirement = resourceRequest.requirement;
-    const websocket = this.websockets[name];
-    if (testResourceRequirement?.ports === 0) {
-      websocket.send(JSON.stringify({
-        data: {
-          testResourceConfiguration: {
-            ports: [],
-          },
-        }
-      }));
-    } else if ((testResourceRequirement?.ports || 0) > 0) {
-      // clear any port-slots associated with this job
-      Object.values(this.ports).forEach((jobMaybe, portNumber) => {
-        if (jobMaybe && jobMaybe === name) {
-          this.ports[portNumber] = OPEN_PORT;
-        }
-      });
+      if (config.devMode === false) {
+        console.log("Your tests were built but not run because devMode was false. Exiting gracefully");
+        process.exit(0);
-      // find a list of open ports
-      const foundOpenPorts = Object.keys(this.ports).filter(
-        (p) => this.ports[p] === OPEN_PORT
-      );
-      if (foundOpenPorts.length >= testResourceRequirement.ports) {
-        const selectionOfPorts = foundOpenPorts.slice(
-          0,
-          testResourceRequirement.ports
-        );
-        websocket.send(JSON.stringify({
-          data: {
-            testResourceConfiguration: {
-              ports: selectionOfPorts,
-            },
-          }
-        }));
-        // mark the selected ports as occupied
-        for (const foundOpenPort of selectionOfPorts) {
-          this.ports[foundOpenPort] = name;
-        }
       } else {
-        console.log(
-          `no port was open so send the ${name} job to the back of the resourceQueue`
-        );
-        this.resourceQueue.push(resourceRequest);
+        // no-op
       }
-    }
-  }
-  private allocateViaIpc(resourceRequest: {
-    requirement: ITTestResourceRequirement;
-    protocol: ISchedulerProtocols;
-  }) {
-    const pName = resourceRequest.requirement.name;
-    const testResourceRequirement = resourceRequest.requirement;
-    pm2.list((err, processes) => {
-      console.error(err);
-      processes.forEach((p) => {
-        if (p.name === pName && p.pid) {
-          const message = {
-            // these fields must be present
-            id: p.pid,
-            topic: "some topic",
-            type: "process:msg",
-            // Data to be sent
-            data: {
-              testResourceConfiguration: {
-                ports: [],
-                // fs: fPath,
-              },
-              id: p.pm_id,
-            },
-          };
-          if (testResourceRequirement?.ports === 0) {
-            pm2.sendDataToProcessId(
-              p.pm_id as number,
-              message,
-              function (err, res) {
-                // console.log("sendDataToProcessId", err, res, message);
-              }
-            );
-          }
-          if ((testResourceRequirement?.ports || 0) > 0) {
-            // clear any port-slots associated with this job
-            Object.values(this.ports).forEach((jobMaybe, portNumber) => {
-              if (jobMaybe && jobMaybe === pName) {
-                this.ports[portNumber] = OPEN_PORT;
-              }
-            });
-            // find a list of open ports
-            const foundOpenPorts = Object.keys(this.ports).filter(
-              (p) => this.ports[p] === OPEN_PORT
-            );
-            // if there are enough open port-slots...
-            if (foundOpenPorts.length >= testResourceRequirement.ports) {
-              const selectionOfPorts = foundOpenPorts.slice(
-                0,
-                testResourceRequirement.ports
-              );
-              const message = {
-                // these fields must be present
-                id: p.pid, // id of process from "pm2 list" command or from pm2.list(errback) method
-                topic: "some topic",
-                // process:msg will be send as 'message' on target process
-                type: "process:msg",
-                // Data to be sent
-                data: {
-                  testResourceConfiguration: {
-                    // fs: fPath,
-                    ports: selectionOfPorts,
-                  },
-                  id: p.pid,
-                },
-              };
-              pm2.sendDataToProcessId(
-                p.pm_id as number,
-                message,
-                function (err, res) {
-                  // no-op
-                }
-              );
-              // mark the selected ports as occupied
-              for (const foundOpenPort of selectionOfPorts) {
-                this.ports[foundOpenPort] = p.pid.toString();
-              }
-            } else {
-              console.log(
-                `no port was open so send the ${p.pid} job to the back of the resourceQueue`
-              );
-              this.resourceQueue.push(resourceRequest);
-            }
-          }
-        }
-      })
     })
   }
-  private mainLoop = async () => {
-    if (this.clearScreen) {
-      console.clear();
-    }
-    const procsTable: any[] = [];
-    pm2.list((err, procs) => {
-      procs.forEach((proc) => {
-        procsTable.push({
-          name: proc.name,
-          pid: proc.pid,
-          pm_id: proc.pm_id,
-          mem: proc.monit?.memory,
-          cpu: proc.monit?.cpu,
-          "exit code": this.exitCodes[proc.name as string]
-        })
-      })
-      console.table(procsTable);
-      console.table(this.resourceQueue);
-      console.log("webSocketServer.clients", Object.keys(this.websockets));
-      const resourceRequest = this.resourceQueue.pop();
-      if (!resourceRequest) {
-        if (!this.devMode && this.mode === "up") {
-          this.initiateShutdown("resource request queue is empty");
-        }
+  public getSecondaryEndpointsPoints(runtime?: IRunTime): string[] {
-        if (
-          this.mode === "down" &&
-          (
-            procsTable.every(
-              (p) => p.pid === 0 || p.pid === undefined
-            ) ||
-            procsTable.length === 0
-          )
-        ) {
-          this.shutdown();
+    const meta = (ts: ITestTypes[], st: Set<string>): Set<string> => {
+      ts.forEach((t) => {
+        if (t[1] === runtime) {
+          st.add(t[0]);
         }
-      } else {
-        if (resourceRequest.protocol === "ipc") {
-          this.allocateViaIpc(resourceRequest)
-        } else if (resourceRequest.protocol === "ws") {
-          this.allocateViaWs(resourceRequest)
+        if (Array.isArray(t[2])) {
+          meta(t[2], st);
         }
-      }
+      })
+      return st;
+    }
+    return Array.from(meta(this.config.tests, new Set()));
+  }
-      const upMessage = "Running tests while watching for changes. Use 'q' to initiate shutdown and `x` to kill.";
-      const downMessage = "Shutdown is in progress. Please wait.";
-      if (this.devMode) {
-        if (this.mode === "up") {
-          console.log(this.spinner(), upMessage);
-        } else {
-          console.log(this.spinner(), downMessage);
-        }
+  public initiateShutdown(reason: string) {
+    console.log("Shutdown initiated because", reason);
+    this.mode = "down";
+  }
-      } else {
-        if (this.mode === "up") {
-          console.log(this.spinner(), upMessage);
-        } else {
-          console.log(this.spinner(), downMessage);
-        }
-      }
-    });
-  };
+  // private shutdown() {
+  //   let i = 0;
+  //   new Promise((res, reh) => {
+  //     console.log("final results: ");
+  //     const procsTable: any[] = [];
+  //     // pm2.list((err, procs) => {
+  //     //   procs.forEach((proc, ndx) => {
+  //     //     const exitCode = this.exitCodes[proc.name as string]
+  //     //     if (exitCode !== 0) {
+  //     //       i++;
+  //     //     }
+  //     //     procsTable.push({
+  //     //       name: proc.name,
+  //     //       pm_id: proc.pm_id,
+  //     //       exitCode
+  //     //     })
+  //     //     if (ndx === procs.length - 1) {
+  //     //       console.table(procsTable);
+  //     //       res(i)
+  //     //     }
+  //     //   })
+  //     // })
+  //   }).then((failures: number) => {
+  //     // pm2.stop("all", (e) => console.error(e));
+  //     // pm2.disconnect();
+  //     console.log(`gracefully exiting with ${failures} failures`)
+  //     process.exit(failures);
+  //   })
+  // }
+  // private spinner() {
+  //   this.spinCycle = (this.spinCycle + 1) % this.spinAnimation.length;
+  //   return this.spinAnimation[this.spinCycle];
+  // }
+  // private async releaseTestResourceWs(payload: any) {
+  //   const name = payload.data.testResourceConfiguration.name;
+  //   const failed = payload.data.failed;
+  //   this.exitCodes[name] = failed;
+  //   Object.keys(this.ports).forEach((port: string) => {
+  //     if (this.ports[port] === name) {
+  //       this.ports[port] = OPEN_PORT;
+  //     }
+  //   });
+  // }
+  // private async releaseTestResourcePm2(payload: IAdios) {
+  //   const name = payload.testResourceConfiguration.name;
+  //   const failed = payload.failed;
+  //   this.exitCodes[name] = failed;
+  //   // pm2.list((err, processes) => {
+  //   //   processes.forEach((proc: pm2.ProcessDescription) => {
+  //   //     if (proc.name === name) {
+  //   //       Object.keys(this.ports).forEach((port: string) => {
+  //   //         if (this.ports[port] === name) {
+  //   //           this.ports[port] = OPEN_PORT;
+  //   //         }
+  //   //       });
+  //   //     }
+  //   //   });
+  //   // });
+  // }
+  // private allocateViaWs(resourceRequest: {
+  //   requirement: ITTestResourceRequirement;
+  //   protocol: ISchedulerProtocols;
+  // }) {
+  //   const name = resourceRequest.requirement.name;
+  //   const testResourceRequirement = resourceRequest.requirement;
+  //   const websocket = this.websockets[name];
+  //   if (testResourceRequirement?.ports === 0) {
+  //     websocket.send(JSON.stringify({
+  //       data: {
+  //         testResourceConfiguration: {
+  //           ports: [],
+  //         },
+  //       }
+  //     }));
+  //   } else if ((testResourceRequirement?.ports || 0) > 0) {
+  //     // clear any port-slots associated with this job
+  //     Object.values(this.ports).forEach((jobMaybe, portNumber) => {
+  //       if (jobMaybe && jobMaybe === name) {
+  //         this.ports[portNumber] = OPEN_PORT;
+  //       }
+  //     });
+  //     // find a list of open ports
+  //     const foundOpenPorts = Object.keys(this.ports).filter(
+  //       (p) => this.ports[p] === OPEN_PORT
+  //     );
+  //     if (foundOpenPorts.length >= testResourceRequirement.ports) {
+  //       const selectionOfPorts = foundOpenPorts.slice(
+  //         0,
+  //         testResourceRequirement.ports
+  //       );
+  //       websocket.send(JSON.stringify({
+  //         data: {
+  //           testResourceConfiguration: {
+  //             ports: selectionOfPorts,
+  //           },
+  //         }
+  //       }));
+  //       // mark the selected ports as occupied
+  //       for (const foundOpenPort of selectionOfPorts) {
+  //         this.ports[foundOpenPort] = name;
+  //       }
+  //     } else {
+  //       console.log(
+  //         `no port was open so send the ${name} job to the back of the resourceQueue`
+  //       );
+  //       this.resourceQueue.push(resourceRequest);
+  //     }
+  //   }
+  // }
+  // private allocateViaIpc(resourceRequest: {
+  //   requirement: ITTestResourceRequirement;
+  //   protocol: ISchedulerProtocols;
+  // }) {
+  //   const pName = resourceRequest.requirement.name;
+  //   const testResourceRequirement = resourceRequest.requirement;
+  //   // pm2.list((err, processes) => {
+  //   //   console.error(err);
+  //   //   processes.forEach((p) => {
+  //   //     if (p.name === pName && p.pid) {
+  //   //       const message = {
+  //   //         // these fields must be present
+  //   //         id: p.pid,
+  //   //         topic: "some topic",
+  //   //         type: "process:msg",
+  //   //         // Data to be sent
+  //   //         data: {
+  //   //           testResourceConfiguration: {
+  //   //             ports: [],
+  //   //             // fs: fPath,
+  //   //           },
+  //   //           id: p.pm_id,
+  //   //         },
+  //   //       };
+  //   //       if (testResourceRequirement?.ports === 0) {
+  //   //         pm2.sendDataToProcessId(
+  //   //           p.pm_id as number,
+  //   //           message,
+  //   //           function (err, res) {
+  //   //             // console.log("sendDataToProcessId", err, res, message);
+  //   //           }
+  //   //         );
+  //   //       }
+  //   //       if ((testResourceRequirement?.ports || 0) > 0) {
+  //   //         // clear any port-slots associated with this job
+  //   //         Object.values(this.ports).forEach((jobMaybe, portNumber) => {
+  //   //           if (jobMaybe && jobMaybe === pName) {
+  //   //             this.ports[portNumber] = OPEN_PORT;
+  //   //           }
+  //   //         });
+  //   //         // find a list of open ports
+  //   //         const foundOpenPorts = Object.keys(this.ports).filter(
+  //   //           (p) => this.ports[p] === OPEN_PORT
+  //   //         );
+  //   //         // if there are enough open port-slots...
+  //   //         if (foundOpenPorts.length >= testResourceRequirement.ports) {
+  //   //           const selectionOfPorts = foundOpenPorts.slice(
+  //   //             0,
+  //   //             testResourceRequirement.ports
+  //   //           );
+  //   //           const message = {
+  //   //             // these fields must be present
+  //   //             id: p.pid, // id of process from "pm2 list" command or from pm2.list(errback) method
+  //   //             topic: "some topic",
+  //   //             // process:msg will be send as 'message' on target process
+  //   //             type: "process:msg",
+  //   //             // Data to be sent
+  //   //             data: {
+  //   //               testResourceConfiguration: {
+  //   //                 // fs: fPath,
+  //   //                 ports: selectionOfPorts,
+  //   //               },
+  //   //               id: p.pid,
+  //   //             },
+  //   //           };
+  //   //           pm2.sendDataToProcessId(
+  //   //             p.pm_id as number,
+  //   //             message,
+  //   //             function (err, res) {
+  //   //               // no-op
+  //   //             }
+  //   //           );
+  //   //           // mark the selected ports as occupied
+  //   //           for (const foundOpenPort of selectionOfPorts) {
+  //   //             this.ports[foundOpenPort] = p.pid.toString();
+  //   //           }
+  //   //         } else {
+  //   //           console.log(
+  //   //             `no port was open so send the ${p.pid} job to the back of the resourceQueue`
+  //   //           );
+  //   //           this.resourceQueue.push(resourceRequest);
+  //   //         }
+  //   //       }
+  //   //     }
+  //   //   })
+  //   // })
+  // }
+  // private mainLoop = async () => {
+  //   if (this.clearScreen) {
+  //     console.clear();
+  //   }
+  //   const procsTable: any[] = [];
+  //   //     pm2.list((err, procs) => {
+  //   //       procs.forEach((proc) => {
+  //   //         procsTable.push({
+  //   //           name: proc.name,
+  //   //           pid: proc.pid,
+  //   //           pm_id: proc.pm_id,
+  //   //           mem: proc.monit?.memory,
+  //   //           cpu: proc.monit?.cpu,
+  //   //           "exit code": this.exitCodes[proc.name as string]
+  //   //         })
+  //   //       })
+  //   //       console.table(procsTable);
+  //   //       console.table(this.resourceQueue);
+  //   //       console.log("webSocketServer.clients", Object.keys(this.websockets));
+  //   //       const resourceRequest = this.resourceQueue.pop();
+  //   //       if (!resourceRequest) {
+  //   //         if (!this.devMode && this.mode === "up") {
+  //   //           this.initiateShutdown("resource request queue is empty");
+  //   //         }
+  //   //         if (
+  //   //           this.mode === "down" &&
+  //   //           (
+  //   //             procsTable.every(
+  //   //               (p) => p.pid === 0 || p.pid === undefined
+  //   //             ) ||
+  //   //             procsTable.length === 0
+  //   //           )
+  //   //         ) {
+  //   //           this.shutdown();
+  //   //         }
+  //   //       } else {
+  //   //         if (resourceRequest.protocol === "ipc") {
+  //   //           this.allocateViaIpc(resourceRequest)
+  //   //         } else if (resourceRequest.protocol === "ws") {
+  //   //           this.allocateViaWs(resourceRequest)
+  //   //         }
+  //   //       }
+  //   //       const upMessage = `
+  //   //   Running tests while watching for changes.
+  //   //   Use 'q' to initiate shutdown and 'x' to kill.
+  //   //   esbuild web server - ${JSON.stringify(this.esWebServerDetails)}
+  //   // `;
+  //   //       const downMessage = "Shutdown is in progress. Please wait.";
+  //   //       if (this.devMode) {
+  //   //         if (this.mode === "up") {
+  //   //           console.log(this.spinner(), upMessage);
+  //   //         } else {
+  //   //           console.log(this.spinner(), downMessage);
+  //   //         }
+  //   //       } else {
+  //   //         if (this.mode === "up") {
+  //   //           console.log(this.spinner(), upMessage);
+  //   //         } else {
+  //   //           console.log(this.spinner(), downMessage);
+  //   //         }
+  //   //       }
+  //   //     });
+  // };
 }
+// pm2.connect(async (err) => {
+//   if (err) {
+//     console.error(err);
+//     process.exit(-1);
+//   } else {
+//     console.log(`pm2 is connected`);
+//   }
+//   // run a websocket as an alternative to node IPC
+//   webSocketServer = new WebSocketServer({
+//     port: 8080,
+//     host: "localhost",
+//   });
+//   webSocketServer.on('open', () => {
+//     console.log('open');
+//   });
+//   webSocketServer.on('close', (data) => {
+//     console.log('webSocketServer close: %s', data);
+//   });
+//   webSocketServer.on('listening', () => {
+//     console.log("webSocketServer listening", webSocketServer.address());
+//   });
+//   webSocketServer.on('connection', (webSocket: WebSocket) => {
+//     webSocket.on('message', (webSocketData) => {
+//       const payload = JSON.parse(webSocketData.valueOf().toString() as any);
+//       const messageType = payload.type;
+//       if (messageType === "testeranto:hola") {
+//         const name = payload.data.requirement.name;
+//         const requestedResources = payload.data;
+//         this.websockets[name] = webSocket
+//         console.log('hola WS! connected: ' + name + ' in ' + Object.getOwnPropertyNames(this.websockets))
+//         this.requestResource(requestedResources.requirement, 'ws');
+//       } else if (messageType === "testeranto:adios") {
+//         console.log("adios WS", payload.data.testResourceConfiguration.name);
+//         this.releaseTestResourceWs(payload as any);
+//       }
+//     });
+//   });
+//   const makePath = (fPath: string, rt: IRunTime): string => {
+//     return path.resolve("./" + config.outdir + "/" +
+//       rt +
+//       // (rt === "electron" || rt === "chromium" ? "web" : "node") +
+//       "/" + fPath.replace(path.extname(fPath), "") + ".mjs");
+//   };
+//   const bootInterval = setInterval(async () => {
+//     const filesToLookup = this.tests
+//       .map(([p, rt]) => {
+//         const filepath = makePath(p, rt);
+//         return {
+//           filepath,
+//           exists: fsExists(filepath),
+//         };
+//       });
+//     const allFilesExist = (
+//       await Promise.all(filesToLookup.map((f) => f.exists))
+//     ).every((b) => b);
+//     if (!allFilesExist) {
+//       console.log(this.spinner(), "waiting for files to build...")
+//       filesToLookup.forEach((f) => {
+//         console.log(f.exists, "\t", f.filepath);
+//       })
+//     } else {
+//       clearInterval(bootInterval);
+//       pm2.launchBus((err, pm2_bus) => {
+//         pm2_bus.on("testeranto:hola", (packet: { data: { requirement: ITTestResourceRequirement } }) => {
+//           this.requestResource(
+//             packet.data.requirement,
+//             'ipc'
+//           );
+//         });
+//         pm2_bus.on("testeranto:adios", (payload: IAdiosIPC) => {
+//           this.releaseTestResourcePm2(payload.data);
+//         });
+//       });
+//       this
+//         .tests
+//         .reduce((m, [inputFilePath, runtime]) => {
+//           const script = makePath(inputFilePath, runtime);
+//           const partialTestResourceByCommandLineArg = `${script} '${JSON.stringify(
+//             {
+//               name: inputFilePath,
+//               ports: [],
+//               fs: path.resolve(
+//                 process.cwd(),
+//                 config.outdir,
+//                 inputFilePath
+//               ),
+//             }
+//           )}'`;
+//           if (runtime === "web") {
+//             pm2.start(electron_pm2_StartOptions(
+//               partialTestResourceByCommandLineArg,
+//               inputFilePath,
+//               config
+//             ),
+//               (err, proc) => {
+//                 if (err) {
+//                   console.error(err);
+//                   return pm2.disconnect();
+//                 }
+//               }
+//             );
+//             // } else if (runtime === "chromium") {
+//             //   pm2.start(
+//             //     chromium_pm2_StartOptions(
+//             //       partialTestResourceByCommandLineArg,
+//             //       inputFilePath,
+//             //       config,
+//             //     ),
+//             //     (err, proc) => {
+//             //       if (err) {
+//             //         console.error(err);
+//             //         return pm2.disconnect();
+//             //       }
+//             //     }
+//             //   );
+//           } else if (runtime === "node") {
+//             const resolvedPath = path.resolve(script);
+//             console.log("watching", resolvedPath);
+//             pm2.start(node_pm2_StartOptions(
+//               partialTestResourceByCommandLineArg,
+//               inputFilePath,
+//               config,
+//               resolvedPath
+//             ), (err, proc) => {
+//               if (err) {
+//                 console.error(err);
+//                 return pm2.disconnect();
+//               }
+//             });
+//           }
+//           this.exitCodes[inputFilePath] = null;
+//           return [inputFilePath, ...m];
+//         }, []);
+//       setInterval(this.mainLoop, TIMEOUT).unref();
+//     }
+//   }, TIMEOUT).unref();
+// });
+// public requestResource(
+//   requirement: ITTestResourceRequirement,
+//   protocol: ISchedulerProtocols
+// ) {
+//   this.resourceQueue.push({ requirement, protocol });
+// }
+// const OPEN_PORT = "";
+// type ISchedulerProtocols = `ipc` | `ws`;
+// type IAdios = {
+//   name: string;
+//   failed: any;
+//   testResourceConfiguration: {
+//     name: string;
+//   };
+//   results: {
+//     fails: any[];
+//     givens: any[];
+//     name: string;
+//   };
+// };
+// type IAdiosIPC = {
+//   process: {
+//     namespace: string;
+//     versioning: object;
+//     name: string;
+//     pm_id: number;
+//   };
+//   data: IAdios
+//   at: string;
+// };
+// clearScreen: boolean;
+// devMode: boolean;
+// exitCodes: Record<number, string> = {};
+// features: TesterantoFeatures;
+// ports: Record<string, string> = {};
+// tests: ITestTypes[];
+// websockets: Record<string, WebSocket> = {};
+// resourceQueue: {
+//   requirement: ITTestResourceRequirement,
+//   protocol: ISchedulerProtocols,
+// }[] = [];
+// private spinCycle = 0;
+// private spinAnimation = "←↖↑↗→↘↓↙";
+// console.log("sending", JSON.stringify(this.tests));
+// childElectron.stdin.write(JSON.stringify(this.tests));
+// not necessary
+// this.esWebServerDetails = await eWeb.serve({
+//   servedir: jsonConfig.outdir,
+// });
+// fs.copyFileSync("node_modules/testeranto/dist/index.css", "index.css")
+//