testeranto 0.49.9 → 0.62.0

package/src/Web.ts

@@ -1,241 +1,115 @@
+import type {
+  IBaseTest,
+  ITestImplementation,
+  ITestInterface,
+  ITestSpecification
+} from "./Types";
+import Testeranto from "./lib/core.js";
 import {
   ITTestResourceConfiguration,
   ITTestResourceRequest,
-  ITTestShape,
-  ITestArtificer,
   ITestJob,
-  ITestSpecification,
-  defaultTestResourceRequirement,
-} from "./core";
-import TesterantoLevelTwo from "./core";
-
-let webSocket: 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 as any).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(),
-      },
+  defaultTestResourceRequirement
+} from "./lib/index.js";
+
+const remote = require('@electron/remote')
+
+class WebTesteranto<
+  TestShape extends IBaseTest,
+> extends Testeranto<
+  TestShape
+> {
+  constructor(
+    input: TestShape["iinput"],
+    testSpecification: ITestSpecification<TestShape>,
+    testImplementation: ITestImplementation<TestShape, object>,
+    testResourceRequirement: ITTestResourceRequest,
+    testInterface: Partial<ITestInterface<TestShape>>,
+  ) {
+    super(
+      input,
+      testSpecification,
+      testImplementation,
+      testResourceRequirement,
+      (window as any).NodeWriter,
+      testInterface,
+      // BrowserWindow
+    );
+
+    if (process.argv[2]) {
+      const testResourceArg = decodeURIComponent(
+        new URLSearchParams(location.search).get('requesting') || ''
+      );
+
+      try {
+        const partialTestResource = JSON.parse(
+          testResourceArg
+        ) as ITTestResourceConfiguration;
+
+        this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
+
+      } catch (e) {
+        console.error(e);
+        // process.exit(-1);
+      }
+    } else {
+      // no-op
+    }
+
+    const requesting = new URLSearchParams(location.search).get('requesting');
+    if (requesting) {
+      const testResourceArg = decodeURIComponent(requesting);
+
+      try {
+        const partialTestResource = JSON.parse(
+          testResourceArg
+        ) as ITTestResourceConfiguration;
+
+        console.log("initial test resource", partialTestResource);
+        this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
+
+      } catch (e) {
+        console.error(e);
+        // process.exit(-1);
+      }
+    }
+    // const t: ITestJob = this.testJobs[0];
+
+
+
+  }
+
+  async receiveTestResourceConfig(t: ITestJob, partialTestResource: ITTestResourceConfiguration) {
+    const {
+      failed,
+      artifacts,
+      logPromise
+    } = await t.receiveTestResourceConfig(
+      partialTestResource,
+      remote
+    );
+
+    Promise.all([...artifacts, logPromise]).then(async () => {
+      var window = remote.getCurrentWindow();
+      // window.close();
     })
-  );
-
-  Promise.all([...artifacts, logPromise]).then(async () => {
-    // ipcRenderer.invoke('quit-app', failed);
-    (window as any).exit(failed)
-  })
-}
-
-export default async <
-  TestShape extends ITTestShape,
-  IInput,
-  ISubject,
-  IStore,
-  ISelection,
-  WhenShape,
-  IThenShape,
-  IState
->(
-  input: IInput,
-  testSpecification: ITestSpecification<
-    TestShape,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape
-  >,
-  testImplementation,
-  testInterface: {
-    actionHandler?: (b: (...any) => any) => any;
-    andWhen: (
-      store: IStore,
-      actioner,
-      testResource: ITTestResourceConfiguration
-    ) => Promise<ISelection>;
-    butThen?: (
-      store: IStore,
-      callback,
-      testResource: ITTestResourceConfiguration
-    ) => Promise<ISelection>;
-    assertioner?: (t: IThenShape) => any;
-
-    afterAll?: (store: IStore, artificer: ITestArtificer) => any;
-    afterEach?: (
-      store: IStore,
-      key: string,
-      artificer: ITestArtificer
-    ) => Promise<unknown>;
-    beforeAll?: (input: IInput, artificer: ITestArtificer) => Promise<ISubject>;
-    beforeEach?: (
-      subject: ISubject,
-      initialValues,
-      testResource: ITTestResourceConfiguration,
-      artificer: ITestArtificer
-    ) => Promise<IStore>;
-  },
-  testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement
-) => {
-
-  console.log("web NodeWriter", (window as any).NodeWriter);
-
-  const mrt = new TesterantoLevelTwo(
+  }
+
+};
+
+export default async <ITestShape extends IBaseTest>(
+  input: ITestShape['iinput'],
+  testSpecification: ITestSpecification<ITestShape>,
+  testImplementation: ITestImplementation<ITestShape, object>,
+  testInterface: Partial<ITestInterface<ITestShape>>,
+  testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement,
+): Promise<Testeranto<ITestShape>> => {
+  return new WebTesteranto<ITestShape>(
     input,
     testSpecification,
     testImplementation,
-    testInterface,
     testResourceRequirement,
-    testInterface.assertioner || (async (t) => t as any),
-    testInterface.beforeEach ||
-    async function (subject: any, initialValues: any, testResource: any) {
-      return subject as any;
-    },
-    testInterface.afterEach || (async (s) => s),
-    testInterface.afterAll || ((store: IStore) => undefined),
-    testInterface.butThen || (async (a) => a as any),
-    testInterface.andWhen,
-    testInterface.actionHandler ||
-    function (b: (...any: any[]) => any) {
-      return b;
-    },
-    (window as any).NodeWriter
-  );
-
-  const tl2: TesterantoLevelTwo<any, any, any, any, any, any, any, any> = mrt;
-  const t: ITestJob = tl2.testJobs[0];
-  const testResourceArg = decodeURIComponent(
-    new URLSearchParams(location.search).get('requesting') || ''
-  );
-
-  try {
-    const partialTestResource = JSON.parse(
-      testResourceArg
-    ) as ITTestResourceConfiguration;
-
-    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: {
-              ...testResourceRequirement,
-              name: partialTestResource.name
-            }
-          },
-        });
-
-        webSocket.send(r);
-
-        console.log("awaiting test resources via websocket...", r);
-        webSocket.onmessage = (
-          async (msg: MessageEvent<any>) => {
-            console.log("message: ", msg);
-
-            const resourcesFromWs = JSON.parse(msg.data);
-            console.log("secondary test resource", resourcesFromWs);
-
-            const secondTestResource = {
-              fs: ".",
-              ...JSON.parse(JSON.stringify(partialTestResource)),
-              ...JSON.parse(JSON.stringify(resourcesFromWs)),
-            } as ITTestResourceConfiguration;
-
-            console.log("final test resource", secondTestResource);
-            receiveTestResourceConfigScheduled(t, secondTestResource);
-          }
-        );
-      });
-    } else {
-      receiveTestResourceConfigUnscheduled(t, partialTestResource);
-    }
+    testInterface,
+  )
 
-    // 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);
-  }
 };

package/src/cjs-shim.js

@@ -0,0 +1,12 @@
+import { createRequire } from 'node:module';
+import path from 'node:path';
+import url from 'node:url';
+
+// globalThis.require = createRequire(import.meta.url);
+// globalThis.__filename = url.fileURLToPath(import.meta.url);
+// globalThis.__dirname = path.dirname(__filename);
+
+// const p = `${import.meta.url}/..`;
+// globalThis.require = createRequire(`${import.meta.url}/..`);
+// globalThis.__filename = url.fileURLToPath(`${import.meta.url}/..`);
+// globalThis.__dirname = path.dirname(`${__filename}/..`);

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',
+    },
+  };
+}