testeranto 0.70.0 → 0.74.0

package/src/PM/node.ts

@@ -0,0 +1,122 @@
+import fs from "fs";
+import path from "path";
+import puppeteer from "puppeteer-core";
+import { PassThrough } from "stream";
+
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+
+import { PM } from "./index.js";
+
+type IFPaths = string[];
+const fPaths: IFPaths = [];
+
+type PuppetMasterServer = Record<string, Promise<any>>;
+
+export class PM_Node extends PM {
+  server: PuppetMasterServer;
+  testResourceConfiguration: ITTestResourceConfiguration;
+
+  constructor(t: ITTestResourceConfiguration) {
+    super();
+    this.server = {};
+    this.testResourceConfiguration = t;
+  }
+
+  existsSync(destFolder: string): boolean {
+    return globalThis["existsSync"](
+      this.testResourceConfiguration.fs + "/" + destFolder
+    );
+  }
+
+  mkdirSync() {
+    return globalThis["mkdirSync"](this.testResourceConfiguration.fs + "/");
+  }
+
+  write(writeObject: { uid: number }, contents: string) {
+    return globalThis["write"](writeObject.uid, contents);
+  }
+
+  writeFileSync(filepath: string, contents: string) {
+    return globalThis["writeFileSync"](
+      this.testResourceConfiguration.fs + "/" + filepath,
+      contents,
+      this.testResourceConfiguration.name
+    );
+  }
+
+  createWriteStream(filepath: string): any {
+    return globalThis["createWriteStream"](
+      this.testResourceConfiguration.fs + "/" + filepath,
+      this.testResourceConfiguration.name
+    );
+  }
+
+  end(writeObject: { uid: number }) {
+    return globalThis["end"](writeObject.uid);
+  }
+
+  customclose() {
+    globalThis["customclose"](
+      this.testResourceConfiguration.fs,
+      this.testResourceConfiguration.name
+    );
+  }
+
+  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();
+              });
+            }
+          });
+        })
+      );
+    };
+  }
+
+  // launch(options?: PuppeteerLaunchOptions): Promise<Browser>;
+  startPuppeteer(options?: any): Promise<any> {
+    return puppeteer.connect(options).then((b) => {
+      this.browser = b;
+    });
+  }
+}

package/src/PM/web.ts

@@ -0,0 +1,162 @@
+import { PassThrough } from "stream";
+import puppeteer from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser.js";
+
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+import { PM } from "./index.js";
+
+type PuppetMasterServer = Record<string, Promise<any>>;
+
+export class PM_Web extends PM {
+  server: PuppetMasterServer;
+
+  constructor(t: ITTestResourceConfiguration) {
+    super();
+    this.server = {};
+    this.testResourceConfiguration = t;
+  }
+
+  existsSync(destFolder: string): boolean {
+    return window["existsSync"](destFolder);
+  }
+
+  mkdirSync() {
+    return window["mkdirSync"](this.testResourceConfiguration.fs + "/");
+  }
+
+  write(writeObject: { uid: number }, contents: string) {
+    return window["write"](writeObject.uid, contents);
+  }
+
+  writeFileSync(filepath: string, contents: string) {
+    return window["writeFileSync"](
+      this.testResourceConfiguration.fs + "/" + filepath,
+      contents,
+      this.testResourceConfiguration.name
+    );
+  }
+
+  createWriteStream(filepath: string): any {
+    return window["createWriteStream"](
+      this.testResourceConfiguration.fs + "/" + filepath,
+      this.testResourceConfiguration.name
+    );
+  }
+
+  end(writeObject: { uid: number }) {
+    return window["end"](writeObject.uid);
+  }
+
+  customclose() {
+    window["customclose"](
+      this.testResourceConfiguration.fs,
+      this.testResourceConfiguration.name
+    );
+  }
+
+  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();
+          //     });
+          //   }
+          // });
+        })
+      );
+    };
+  }
+
+  startPuppeteer(options, destFolder: string): Promise<any> {
+    const name = this.testResourceConfiguration.name;
+
+    return fetch(`http://localhost:3234/json/version`)
+      .then((v) => {
+        return v.json();
+      })
+      .then((json) => {
+        return puppeteer
+          .connect({
+            browserWSEndpoint: json.webSocketDebuggerUrl,
+          })
+          .then((b) => {
+            this.browser = b;
+            const handler2 = {
+              get(target, prop, receiver) {
+                if (prop === "screenshot") {
+                  return async (x) => {
+                    return await window["custom-screenshot"](
+                      {
+                        ...x,
+                        // path: destFolder + "/" + x.path,
+                        path: x.path,
+                      },
+                      name
+                    );
+                  };
+                } else if (prop === "mainFrame") {
+                  return () => target[prop](...arguments);
+                } else {
+                  return Reflect.get(...arguments);
+                }
+              },
+            };
+            const handler1 = {
+              get(target, prop, receiver) {
+                if (prop === "pages") {
+                  return async () => {
+                    return target.pages().then((pages) => {
+                      return pages.map((p) => {
+                        return new Proxy(p, handler2);
+                      });
+                    });
+                  };
+                }
+
+                return Reflect.get(...arguments);
+              },
+            };
+
+            const proxy3 = new Proxy(this.browser, handler1);
+            this.browser = proxy3;
+          });
+      });
+  }
+}

package/src/Project.ts

@@ -109,6 +109,25 @@ export class ITProject {
 
     const [nodeEntryPoints, webEntryPoints] = getRunnables(this.config.tests);
 
+    // nodeEntryPoints.forEach((nep) => {
+    //   const f = `${process.cwd()}/${nep}`;
+    //   console.log("nep", f);
+    //   import(f).then((module) => {
+    //     return module.default.then((defaultModule) => {
+    //       console.log("defaultModule", defaultModule);
+    //       // defaultModule
+    //       //   .receiveTestResourceConfig(argz)
+    //       //   .then((x) => {
+    //       //     console.log("then", x);
+    //       //     return x;
+    //       //   })
+    //       //   .catch((e) => {
+    //       //     console.log("catch", e);
+    //       //   });
+    //     });
+    //   });
+    // });
+
     glob(`./${config.outdir}/chunk-*.mjs`, { ignore: "node_modules/**" }).then(
       (chunks) => {
         chunks.forEach((chunk) => {
@@ -213,8 +232,8 @@ const getRunnables = (
       pt[1].add(cv[0]);
     }
 
-    if (cv[2].length) {
-      getRunnables(cv[2], payload);
+    if (cv[3].length) {
+      getRunnables(cv[3], payload);
     }
 
     return pt;

package/src/Puppeteer.ts

@@ -0,0 +1,131 @@
+import readline from "readline";
+import fs from "fs";
+import path from "path";
+import { jsonc } from "jsonc";
+import { v4 as uuidv4 } from "uuid";
+
+import { IBuiltConfig, IRunTime } from "./lib/types";
+
+import { PM_Main } from "./PM/main.js";
+
+var mode: "DEV" | "PROD" = process.argv[2] === "-dev" ? "DEV" : "PROD";
+
+const node2web: Record<string, string[]> = {};
+const web2node: Record<string, string[]> = {};
+const childProcesses: Record<string, "loaded" | "running" | "done"> = {};
+
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY) process.stdin.setRawMode(true);
+
+console.log("\n Puppeteer is running. Press 'q' to quit\n");
+process.stdin.on("keypress", (str, key) => {
+  if (key.name === "q") {
+    process.exit();
+  }
+});
+
+const main = async () => {
+  const configs = jsonc.parse(
+    (await fs.readFileSync("./docs/testeranto.json")).toString()
+  ) as IBuiltConfig;
+
+  const pm = new PM_Main(configs);
+
+  await pm.startPuppeteer(
+    {
+      waitForInitialPage: false,
+      executablePath: "/opt/homebrew/bin/chromium",
+      headless: true,
+      dumpio: true,
+      args: [
+        "--allow-file-access-from-files",
+        "--allow-running-insecure-content",
+        "--auto-open-devtools-for-tabs",
+        "--disable-dev-shm-usage",
+        "--disable-extensions",
+        "--disable-gpu",
+        "--disable-setuid-sandbox",
+        "--disable-site-isolation-trials",
+        "--disable-web-security",
+        "--disable-web-security",
+        "--no-first-run",
+        "--no-sandbox",
+        "--no-startup-window",
+        // "--no-zygote",
+        "--reduce-security-for-testing",
+        "--remote-allow-origins=*",
+        "--unsafely-treat-insecure-origin-as-secure=*",
+        // "--disable-features=IsolateOrigins",
+        // "--remote-allow-origins=ws://localhost:3234",
+        // "--single-process",
+        // "--unsafely-treat-insecure-origin-as-secure",
+        // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
+        `--remote-debugging-port=3234`,
+
+        // "--disk-cache-dir=/dev/null",
+        // "--disk-cache-size=1",
+        // "--start-maximized",
+      ],
+    },
+    "."
+  );
+
+  const destinationOfRuntime = (f: string, r: IRunTime) => {
+    return path
+      .normalize(`${configs.buildDir}/${r}/${f}`)
+      .split(".")
+      .slice(0, -1)
+      .join(".");
+  };
+
+  configs.tests.forEach(([test, runtime, secondaryArtifacts]) => {
+    if (runtime === "node") {
+      pm.launchNode(test, destinationOfRuntime(test, "node"));
+    } else if (runtime === "web") {
+      pm.launchWeb(test, destinationOfRuntime(test, "web"));
+    } else {
+      console.error("runtime makes no sense", runtime);
+    }
+  });
+
+  console.log("ready and watching for changes...", configs.buildDir);
+  fs.watch(
+    configs.buildDir,
+    {
+      recursive: true,
+    },
+    (eventType, changedFile) => {
+      if (changedFile) {
+        configs.tests.forEach(([test, runtime, secondaryArtifacts]) => {
+          if (eventType === "change" || eventType === "rename") {
+            if (
+              changedFile ===
+              test
+                .replace("./", "node/")
+                .split(".")
+                .slice(0, -1)
+                .concat("mjs")
+                .join(".")
+            ) {
+              pm.launchNode(test, destinationOfRuntime(test, "node"));
+            }
+
+            if (
+              changedFile ===
+              test
+                .replace("./", "web/")
+                .split(".")
+                .slice(0, -1)
+                .concat("mjs")
+                .join(".")
+            ) {
+              pm.launchWeb(test, destinationOfRuntime(test, "web"));
+            }
+          }
+        });
+      }
+    }
+  );
+};
+
+main();