testeranto 0.70.0 → 0.74.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testeranto",
   "description": "teeny tiny tightly-typed typescript tests",
-  "version": "0.70.0",
+  "version": "0.74.0",
   "type": "module",
   "types": "./dist/index.d.mts",
   "module": "dist/module/index.js",
@@ -227,10 +227,8 @@
     "ipc": "^0.0.1",
     "jsonc": "^2.0.0",
     "npm-watch": "^0.11.0",
-    "puppeteer": "19.2.2",
-    "puppeteer-core": "19.2.2",
-    "puppeteer-in-electron": "^3.0.5",
-    "react-bootstrap": "^2.7.0",
+    "puppeteer-core": "^23.6.0",
+    "react-bootstrap": "2.10.6",
     "react-sigma": "^1.2.35",
     "react-test-renderer": "18.2.0",
     "selenium-webdriver": "^4.25.0",

package/src/Node.ts

@@ -1,13 +1,10 @@
-import puppeteer from "puppeteer-core";
-
 import Testeranto from "./lib/core.js";
 import {
   defaultTestResourceRequirement,
-  ITestJob,
   ITTestResourceConfiguration,
   ITTestResourceRequest,
 } from "./lib/index.js";
-import { NodeWriter } from "./NodeWriter.js";
+
 import type {
   IBaseTest,
   ITestImplementation,
@@ -15,7 +12,7 @@ import type {
 } from "./Types.js";
 import { ITestInterface, INodeTestInterface } from "./lib/types.js";
 
-import puppeteerConfiger from "./puppeteerConfiger.js";
+import { PM_Node } from "./PM/node.js";
 
 class NodeTesteranto<
   TestShape extends IBaseTest
@@ -32,52 +29,16 @@ class NodeTesteranto<
       testSpecification,
       testImplementation,
       testResourceRequirement,
-      NodeWriter,
       testInterface
     );
-
-    if (process.argv[2]) {
-      const testResourceArg = process.argv[2];
-
-      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
-    }
   }
 
-  async receiveTestResourceConfig(
-    t: ITestJob,
-    partialTestResource: ITTestResourceConfiguration
-  ) {
-    const browser = await puppeteerConfiger("2999").then(async (json) => {
-      const b = await puppeteer.connect({
-        browserWSEndpoint: json.webSocketDebuggerUrl,
-        defaultViewport: null,
-      });
-      console.log("connected!", b.isConnected());
-      return b;
-    });
-
-    const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(
-      partialTestResource,
-      {
-        browser,
-        ipc: process.parentPort,
-      }
-    );
-
-    Promise.all([...artifacts, logPromise]).then(async () => {
-      process.exit((await failed) ? 1 : 0);
-    });
+  async receiveTestResourceConfig(partialTestResource: string) {
+    const t: ITTestResourceConfiguration = JSON.parse(partialTestResource);
+    const pm = new PM_Node(t);
+    const { failed, artifacts, logPromise } =
+      await this.testJobs[0].receiveTestResourceConfig(pm);
+    pm.customclose();
   }
 }
 

package/src/PM/index.ts

@@ -0,0 +1,102 @@
+// import {
+//   Browser,
+//   BrowserContext,
+//   BrowserContextOptions,
+//   DebugInfo,
+//   Page,
+//   PuppeteerNode,
+//   Target,
+// } from "puppeteer-core";
+
+import { Browser } from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser";
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+import { ChildProcess } from "child_process";
+import { PuppeteerLaunchOptions } from "puppeteer-core/lib/esm/puppeteer";
+// import { ILogWriter, ITLog } from "./lib";
+
+type IFPaths = string[];
+const fPaths: IFPaths = [];
+
+export abstract class PM {
+  server: any;
+  browser: Browser;
+  testResourceConfiguration: ITTestResourceConfiguration;
+
+  // constructor(testResourceConfiguration: ITTestResourceConfiguration) {
+  //   this.testResourceConfiguration = testResourceConfiguration;
+  //   console.log("mkdirsync2", this.testResourceConfiguration);
+  // }
+
+  abstract startPuppeteer(options: any, destfolder: string): Promise<Browser>;
+
+  abstract testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise) => void);
+  abstract createWriteStream(filepath: string): any;
+  abstract writeFileSync(fp: string, contents: string);
+  abstract mkdirSync();
+  abstract existsSync(fp: string): boolean;
+  abstract write(accessObject: { uid: number }, contents: string): boolean;
+  abstract end(accessObject: { uid: number }): boolean;
+
+  // pages(): Promise<Page[]>;
+  // pages(): Promise<Page[]> {
+  //   return new Promise<Page[]>((res, rej) => {
+  //     res(super.pages());
+  //   });
+  // }
+}
+
+// export class PuppetMasterBrowser extends Browser {
+//   process(): ChildProcess | null {
+//     return super.process();
+//   }
+//   createBrowserContext(
+//     options?: BrowserContextOptions
+//   ): Promise<BrowserContext> {
+//     throw new Error("Method not implemented.");
+//   }
+//   browserContexts(): BrowserContext[] {
+//     throw new Error("Method not implemented.");
+//   }
+//   defaultBrowserContext(): BrowserContext {
+//     throw new Error("Method not implemented.");
+//   }
+//   wsEndpoint(): string {
+//     throw new Error("Method not implemented.");
+//   }
+//   newPage(): Promise<Page> {
+//     throw new Error("Method not implemented.");
+//   }
+//   targets(): Target[] {
+//     throw new Error("Method not implemented.");
+//   }
+//   target(): Target {
+//     throw new Error("Method not implemented.");
+//   }
+//   version(): Promise<string> {
+//     throw new Error("Method not implemented.");
+//   }
+//   userAgent(): Promise<string> {
+//     throw new Error("Method not implemented.");
+//   }
+//   close(): Promise<void> {
+//     throw new Error("Method not implemented.");
+//   }
+//   disconnect(): Promise<void> {
+//     throw new Error("Method not implemented.");
+//   }
+//   get connected(): boolean {
+//     throw new Error("Method not implemented.");
+//   }
+//   get debugInfo(): DebugInfo {
+//     throw new Error("Method not implemented.");
+//   }
+//   constructor(...z: []) {
+//     super(...z);
+//   }
+//   // pages(): Promise<Page[]>;
+//   pages(): Promise<Page[]> {
+//     return new Promise<Page[]>((res, rej) => {
+//       res(super.pages());
+//     });
+//   }
+// }

package/src/PM/main.ts

@@ -0,0 +1,452 @@
+import fs from "fs";
+import path from "path";
+import puppeteer, { ScreenshotOptions } from "puppeteer-core";
+import { PassThrough } from "stream";
+
+import { ITLog } from "../lib";
+import { IBuiltConfig } from "../lib/types";
+
+import { PM } from "./index.js";
+
+type IFPaths = string[];
+
+const fPaths: IFPaths = [];
+const fileStreams3: fs.WriteStream[] = [];
+const files: Record<string, Set<string>> = {}; // = new Set<string>();
+const screenshots: Record<string, Promise<Uint8Array>[]> = {};
+
+export class PM_Main extends PM {
+  configs: IBuiltConfig;
+  ports: Record<number, boolean>;
+  queue: any[];
+
+  constructor(configs: IBuiltConfig) {
+    super();
+    this.server = {};
+    this.configs = configs;
+    this.ports = {};
+    this.configs.ports.forEach((element) => {
+      this.ports[element] = "true"; // set ports as open
+    });
+
+    globalThis["mkdirSync"] = (fp: string) => {
+      if (!fs.existsSync(fp)) {
+        return fs.mkdirSync(fp, {
+          recursive: true,
+        });
+      }
+      return false;
+    };
+
+    globalThis["writeFileSync"] = (
+      filepath: string,
+      contents: string,
+      testName: string
+    ) => {
+      // Create directories if they don't exist
+      const dir = path.dirname(filepath.split("/").slice(0, -1).join("/"));
+
+      fs.mkdirSync(dir, {
+        recursive: true,
+      });
+      if (!files[testName]) {
+        files[testName] = new Set();
+      }
+      files[testName].add(filepath);
+      return fs.writeFileSync(filepath, contents);
+    };
+
+    globalThis["createWriteStream"] = (filepath: string, testName: string) => {
+      const f = fs.createWriteStream(filepath);
+      fileStreams3.push(f);
+      // files.add(filepath);
+      if (!files[testName]) {
+        files[testName] = new Set();
+      }
+      files[testName].add(filepath);
+      return {
+        ...JSON.parse(JSON.stringify(f)),
+        uid: fileStreams3.length - 1,
+      };
+    };
+
+    globalThis["write"] = (uid: number, contents: string) => {
+      fileStreams3[uid].write(contents);
+    };
+
+    globalThis["end"] = (uid: number) => {
+      fileStreams3[uid].end();
+    };
+
+    globalThis["customclose"] = (p: string, testName: string) => {
+      if (!files[testName]) {
+        files[testName] = new Set();
+      }
+
+      fs.writeFileSync(
+        p + "/manifest.json",
+        JSON.stringify(Array.from(files[testName]))
+      );
+      delete files[testName];
+      // globalThis["writeFileSync"](
+      //   p + "/manifest.json",
+      //   // files.entries()
+      //   JSON.stringify(Array.from(files[testName]))
+      // );
+
+      // fileStreams3[uid].end();
+    };
+    // page.exposeFunction("customclose", () => {
+    //   console.log("closing doneFileStream2", doneFileStream2);
+    //   // console.log("closing doneFileStream2", doneFileStream2);
+    //   Promise.all([...doneFileStream2, ...screenshots2]).then(() => {
+    //     page.close();
+    //   });
+
+    //   // page.close();
+    //   // Promise.all(screenshots).then(() => {
+    //   //   page.close();
+    //   // });
+    //   // setTimeout(() => {
+    //   //   console.log("Delayed for 1 second.");
+    //   //   page.close();
+    //   // }, 5000);
+
+    //   // return page.close();
+    // });
+  }
+
+  async startPuppeteer(options: any, destfolder: string): Promise<any> {
+    this.browser = await puppeteer.launch(options);
+    return this.browser;
+  }
+
+  launchNode = async (src: string, dest: string) => {
+    console.log("launchNode", src);
+
+    const destFolder = dest.replace(".mjs", "");
+
+    let argz = "";
+
+    const testConfig = this.configs.tests.find((t) => {
+      return t[0] === src;
+    });
+
+    if (!testConfig) {
+      console.error("missing test config");
+      process.exit(-1);
+    }
+    const testConfigResource = testConfig[2];
+
+    let portsToUse: string[] = [];
+    if (testConfigResource.ports === 0) {
+      argz = JSON.stringify({
+        scheduled: true,
+        name: src,
+        ports: portsToUse,
+        fs: destFolder,
+        browserWSEndpoint: this.browser.wsEndpoint(),
+      });
+    } else if (testConfigResource.ports > 0) {
+      const openPorts = Object.entries(this.ports).filter(
+        ([portnumber, portopen]) => portopen
+      );
+      if (openPorts.length >= testConfigResource.ports) {
+        for (let i = 0; i < testConfigResource.ports; i++) {
+          portsToUse.push(openPorts[i][0]);
+          this.ports[openPorts[i][0]] = false; // port is now closed
+        }
+
+        argz = JSON.stringify({
+          scheduled: true,
+          name: src,
+          // ports: [3333],
+          ports: portsToUse,
+          fs: ".",
+          browserWSEndpoint: this.browser.wsEndpoint(),
+        });
+      } else {
+        this.queue.push(src);
+        return;
+      }
+    } else {
+      console.error("negative port makes no sense", src);
+      process.exit(-1);
+    }
+
+    const builtfile = dest + ".mjs";
+
+    this.server[builtfile] = await import(
+      `${builtfile}?cacheBust=${Date.now()}`
+    ).then((module) => {
+      return module.default.then((defaultModule) => {
+        defaultModule
+          .receiveTestResourceConfig(argz)
+          .then((x) => {
+            console.log("then", x);
+            return x;
+          })
+          .catch((e) => {
+            console.log("catch", e);
+          });
+      });
+    });
+
+    for (let i = 0; i <= portsToUse.length; i++) {
+      this.ports[i] = true; //port is open again
+    }
+  };
+
+  launchWeb = (t: string, dest: string) => {
+    console.log("launchWeb", t, dest);
+
+    const destFolder = dest.replace(".mjs", "");
+
+    const webArgz = JSON.stringify({
+      name: dest,
+      ports: [].toString(),
+      fs: destFolder,
+      browserWSEndpoint: this.browser.wsEndpoint(),
+    });
+
+    const evaluation = `import('${dest}.mjs').then(async (x) => {
+      console.log("imported", x, (x.default));
+      try {
+        await (await x.default).receiveTestResourceConfig(${webArgz})
+      } catch (e) {
+        console.log("fail", e)
+      }
+    })`;
+
+    const fileStreams2: fs.WriteStream[] = [];
+
+    // const screenshots2: Promise<any>[] = [];
+    const doneFileStream2: Promise<any>[] = [];
+
+    this.browser
+      .newPage()
+      .then((page) => {
+        page.exposeFunction(
+          "custom-screenshot",
+          async (ssOpts: ScreenshotOptions, testName: string) => {
+            console.log("main.ts browser custom-screenshot", testName);
+            const p = ssOpts.path as string;
+            const dir = path.dirname(p);
+            fs.mkdirSync(dir, {
+              recursive: true,
+            });
+            files[testName].add(ssOpts.path as string);
+
+            const sPromise = page.screenshot({
+              ...ssOpts,
+              path: p,
+            });
+
+            if (!screenshots[testName]) {
+              screenshots[testName] = [];
+            }
+            screenshots[testName].push(sPromise);
+            // sPromise.then(())
+            await sPromise;
+            return sPromise;
+            // page.evaluate(`window["screenshot done"]`);
+          }
+        );
+
+        page.exposeFunction(
+          "writeFileSync",
+          (fp: string, contents: string, testName: string) => {
+            const dir = path.dirname(fp);
+
+            fs.mkdirSync(dir, {
+              recursive: true,
+            });
+
+            const p = new Promise<string>(async (res, rej) => {
+              fs.writeFileSync(fp, contents);
+              res(fp);
+            });
+            doneFileStream2.push(p);
+
+            if (!files[testName]) {
+              files[testName] = new Set();
+            }
+            files[testName].add(fp);
+            return p;
+          }
+        );
+
+        page.exposeFunction("existsSync", (fp: string, contents: string) => {
+          return fs.existsSync(fp);
+        });
+
+        page.exposeFunction("mkdirSync", (fp: string) => {
+          if (!fs.existsSync(fp)) {
+            return fs.mkdirSync(fp, {
+              recursive: true,
+            });
+          }
+          return false;
+        });
+
+        page.exposeFunction(
+          "createWriteStream",
+          (fp: string, testName: string) => {
+            const f = fs.createWriteStream(fp);
+
+            if (!files[testName]) {
+              files[testName] = new Set();
+            }
+            files[testName].add(fp);
+
+            const p = new Promise<string>((res, rej) => {
+              res(fp);
+            });
+            doneFileStream2.push(p);
+            f.on("close", async () => {
+              await p;
+            });
+            fileStreams2.push(f);
+            return {
+              ...JSON.parse(JSON.stringify(f)),
+              uid: fileStreams2.length - 1,
+            };
+          }
+        );
+
+        page.exposeFunction("write", async (uid: number, contents: string) => {
+          return fileStreams2[uid].write(contents);
+        });
+
+        page.exposeFunction("end", async (uid: number) => {
+          return fileStreams2[uid].end();
+        });
+
+        page.exposeFunction("customclose", (p: string, testName: string) => {
+          fs.writeFileSync(
+            p + "/manifest.json",
+            JSON.stringify(Array.from(files[testName]))
+          );
+          delete files[testName];
+
+          Promise.all(screenshots[testName] || []).then(() => {
+            delete screenshots[testName];
+            page.close();
+          });
+
+          // globalThis["writeFileSync"](
+          //   p + "/manifest.json",
+          //   // files.entries()
+          //   JSON.stringify(Array.from(files[testName]))
+          // );
+
+          // console.log("closing doneFileStream2", doneFileStream2);
+          // console.log("closing doneFileStream2", doneFileStream2);
+          // Promise.all([...doneFileStream2, ...screenshots2]).then(() => {
+          //   page.close();
+          // });
+
+          // Promise.all(screenshots).then(() => {
+          //   page.close();
+          // });
+          // setTimeout(() => {
+          //   console.log("Delayed for 1 second.");
+          //   page.close();
+          // }, 5000);
+
+          // return page.close();
+        });
+
+        return page;
+      })
+      .then(async (page) => {
+        await page.goto(`file://${`${dest}.html`}`, {});
+
+        page.evaluate(evaluation).finally(() => {
+          console.log("evaluation failed.", dest);
+        });
+
+        return page;
+      });
+  };
+
+  end(accessObject: { uid: number }): boolean {
+    throw new Error("Method not implemented.");
+  }
+
+  existsSync(destFolder: string): boolean {
+    return fs.existsSync(destFolder);
+  }
+
+  async mkdirSync(fp: string) {
+    if (!fs.existsSync(fp)) {
+      return fs.mkdirSync(fp, {
+        recursive: true,
+      });
+    }
+    return false;
+  }
+
+  writeFileSync(fp: string, contents: string) {
+    fs.writeFileSync(fp, contents);
+  }
+
+  createWriteStream(filepath: string): fs.WriteStream {
+    return fs.createWriteStream(filepath);
+  }
+
+  testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise) => void) {
+    return (fPath, value: string | Buffer | PassThrough) => {
+      callback(
+        new Promise<void>((res, rej) => {
+          tLog("testArtiFactory =>", fPath);
+
+          const cleanPath = path.resolve(fPath);
+          fPaths.push(cleanPath.replace(process.cwd(), ``));
+
+          const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+
+          fs.mkdir(targetDir, { recursive: true }, async (error) => {
+            if (error) {
+              console.error(`❗️testArtiFactory failed`, targetDir, error);
+            }
+
+            fs.writeFileSync(
+              path.resolve(
+                targetDir.split("/").slice(0, -1).join("/"),
+                "manifest"
+              ),
+              fPaths.join(`\n`),
+              {
+                encoding: "utf-8",
+              }
+            );
+
+            if (Buffer.isBuffer(value)) {
+              fs.writeFileSync(fPath, value, "binary");
+              res();
+            } else if (`string` === typeof value) {
+              fs.writeFileSync(fPath, value.toString(), {
+                encoding: "utf-8",
+              });
+              res();
+            } else {
+              /* @ts-ignore:next-line */
+              const pipeStream: PassThrough = value;
+              const myFile = fs.createWriteStream(fPath);
+              pipeStream.pipe(myFile);
+              pipeStream.on("close", () => {
+                myFile.close();
+                res();
+              });
+            }
+          });
+        })
+      );
+    };
+  }
+
+  write(accessObject: { uid: number }, contents: string): boolean {
+    throw new Error("Method not implemented.");
+  }
+}