testeranto 0.75.0 → 0.79.3

package/src/PM/main.ts

@@ -1,12 +1,13 @@
 import fs from "fs";
 import path from "path";
-import puppeteer, { ScreenshotOptions } from "puppeteer-core";
+import puppeteer, { Page, ScreenshotOptions } from "puppeteer-core";
 import { PassThrough } from "stream";
 
-import { ITLog } from "../lib";
-import { IBuiltConfig } from "../lib/types";
+import { IBuiltConfig, ITestTypes } from "../lib/types";
 
 import { PM } from "./index.js";
+import { destinationOfRuntime } from "../utils.js";
+import { ITLog } from "../lib/index.js";
 
 type IFPaths = string[];
 
@@ -16,6 +17,9 @@ const files: Record<string, Set<string>> = {}; // = new Set<string>();
 const screenshots: Record<string, Promise<Uint8Array>[]> = {};
 
 export class PM_Main extends PM {
+  customScreenShot(opts: object) {
+    throw new Error("Method not implemented.");
+  }
   configs: IBuiltConfig;
   ports: Record<number, boolean>;
   queue: any[];
@@ -43,6 +47,8 @@ export class PM_Main extends PM {
       contents: string,
       testName: string
     ) => {
+      console.log("globalThis-writeFileSync", filepath);
+
       // Create directories if they don't exist
       const dir = path.dirname(filepath.split("/").slice(0, -1).join("/"));
 
@@ -78,6 +84,46 @@ export class PM_Main extends PM {
       fileStreams3[uid].end();
     };
 
+    globalThis["customScreenShot"] = async (
+      opts: { path: string },
+      page: Page
+    ) => {
+      // // fileStreams3[uid].write(contents);
+      // // console.log("asd", opts.path.split("/").slice(0, -1).join("/"));
+
+      // // const dir = path.dirname(opts.path.split("/").slice(0, -1).join("/"));
+      // // console.log("dir", dir);
+      // fs.mkdirSync(opts.path.split("/").slice(0, -1).join("/"), {
+      //   recursive: true,
+      // });
+
+      // return page.screenshot(opts);
+
+      console.log("main.ts node custom-screenshot", page);
+      const p = opts.path as string;
+      const dir = path.dirname(p);
+      fs.mkdirSync(dir, {
+        recursive: true,
+      });
+      if (!files[opts.path]) {
+        files[opts.path] = new Set();
+      }
+      files[opts.path].add(opts.path as string);
+
+      const sPromise = page.screenshot({
+        ...opts,
+        path: p,
+      });
+
+      if (!screenshots[opts.path]) {
+        screenshots[opts.path] = [];
+      }
+      screenshots[opts.path].push(sPromise);
+
+      await sPromise;
+      return sPromise;
+    };
+
     globalThis["customclose"] = (p: string, testName: string) => {
       if (!files[testName]) {
         files[testName] = new Set();
@@ -151,9 +197,11 @@ export class PM_Main extends PM {
       const openPorts = Object.entries(this.ports).filter(
         ([portnumber, portopen]) => portopen
       );
+      console.log("openPorts", openPorts);
       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
         }
 
@@ -162,7 +210,7 @@ export class PM_Main extends PM {
           name: src,
           // ports: [3333],
           ports: portsToUse,
-          fs: ".",
+          fs: destFolder,
           browserWSEndpoint: this.browser.wsEndpoint(),
         });
       } else {
@@ -176,6 +224,26 @@ export class PM_Main extends PM {
 
     const builtfile = dest + ".mjs";
 
+    await Promise.all(
+      testConfig[3].map((sidecar) => {
+        if (sidecar[1] === "web") {
+          return this.launchWebSideCar(
+            sidecar[0],
+            destinationOfRuntime(sidecar[0], "web", this.configs),
+            sidecar
+          );
+        }
+
+        if (sidecar[1] === "node") {
+          return this.launchNodeSideCar(
+            sidecar[0],
+            destinationOfRuntime(sidecar[0], "node", this.configs),
+            sidecar
+          );
+        }
+      })
+    );
+
     this.server[builtfile] = await import(
       `${builtfile}?cacheBust=${Date.now()}`
     ).then((module) => {
@@ -184,6 +252,7 @@ export class PM_Main extends PM {
           .receiveTestResourceConfig(argz)
           .then((x) => {
             console.log("then", x);
+
             return x;
           })
           .catch((e) => {
@@ -192,14 +261,309 @@ export class PM_Main extends PM {
       });
     });
 
+    console.log("portsToUse", portsToUse);
+    for (let i = 0; i <= portsToUse.length; i++) {
+      if (portsToUse[i]) {
+        this.ports[portsToUse[i]] = "true"; //port is open again
+      }
+    }
+  };
+
+  launchWebSideCar = async (
+    src: string,
+    dest: string,
+    testConfig: ITestTypes
+  ) => {
+    const d = dest + ".mjs";
+    console.log("launchWebSideCar", src, dest, d);
+    const destFolder = dest.replace(".mjs", "");
+    const webArgz = JSON.stringify({
+      name: dest,
+      ports: [].toString(),
+      fs: destFolder,
+      browserWSEndpoint: this.browser.wsEndpoint(),
+    });
+
+    const evaluation = `
+    console.log("importing ${dest}.mjs");
+    import('${dest}.mjs').then(async (x) => {
+      console.log("imported", x.default);
+    })`;
+
+    const fileStreams2: fs.WriteStream[] = [];
+    const doneFileStream2: Promise<any>[] = [];
+
+    return new Promise((res, rej) => {
+      this.browser
+        .newPage()
+        .then((page) => {
+          page.on("console", (msg) => {
+            console.log("web > ", msg.args(), msg.text());
+            // for (let i = 0; i < msg._args.length; ++i)
+            //   console.log(`${i}: ${msg._args[i]}`);
+          });
+
+          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) => {
+          page.on("console", (log) =>
+            console.debug(`Log from client: [${log.text()}] `)
+          );
+          await page.goto(`file://${`${dest}.html`}`, {});
+          res(page);
+
+          // page.evaluate(evaluation).finally(() => {
+          //   console.log("evaluation failed.", dest);
+          // });
+
+          // return page;
+        });
+    });
+  };
+
+  // launchNodeSideCar = async (src: string, dest: string) => {};
+  launchNodeSideCar = async (
+    src: string,
+    dest: string,
+    testConfig: ITestTypes
+  ) => {
+    const d = dest + ".mjs";
+    console.log("launchNodeSideCar", src, dest, d);
+
+    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
+      );
+      console.log("openPorts", openPorts);
+      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";
+
+    // console.log(
+    //   "node builtfile",
+    //   (await import(`${builtfile}?cacheBust=${Date.now()}`)).default
+    // );
+    this.server[builtfile] = await import(
+      `${builtfile}?cacheBust=${Date.now()}`
+    ).then((module) => {
+      return module.default.then((defaultModule) => {
+        console.log("defaultModule", defaultModule);
+        const s = new defaultModule();
+        s.receiveTestResourceConfig(argz);
+        // Object.create(defaultModule);
+
+        // defaultModule
+        //   .receiveTestResourceConfig(argz)
+        //   .then((x) => {
+        //     console.log("then", x);
+        //     return x;
+        //   })
+        //   .catch((e) => {
+        //     console.log("catch", e);
+        //   });
+      });
+    });
+
+    console.log("portsToUse", portsToUse);
     for (let i = 0; i <= portsToUse.length; i++) {
-      this.ports[i] = true; //port is open again
+      if (portsToUse[i]) {
+        this.ports[portsToUse[i]] = "true"; //port is open again
+      }
     }
   };
 
-  launchWeb = (t: string, dest: string) => {
+  launchWeb = (t: string, dest: string, sidecars: ITestTypes[]) => {
     console.log("launchWeb", t, dest);
 
+    sidecars.map((sidecar) => {
+      if (sidecar[1] === "node") {
+        return this.launchNodeSideCar(
+          sidecar[0],
+          destinationOfRuntime(sidecar[0], "node", this.configs),
+          sidecar
+        );
+      }
+    });
+
     const destFolder = dest.replace(".mjs", "");
 
     const webArgz = JSON.stringify({
@@ -209,8 +573,10 @@ export class PM_Main extends PM {
       browserWSEndpoint: this.browser.wsEndpoint(),
     });
 
-    const evaluation = `import('${dest}.mjs').then(async (x) => {
-      console.log("imported", x, (x.default));
+    const evaluation = `
+    console.log("importing ${dest}.mjs");
+    import('${dest}.mjs').then(async (x) => {
+      console.log("imported", x.default);
       try {
         await (await x.default).receiveTestResourceConfig(${webArgz})
       } catch (e) {
@@ -219,15 +585,19 @@ export class PM_Main extends PM {
     })`;
 
     const fileStreams2: fs.WriteStream[] = [];
-
-    // const screenshots2: Promise<any>[] = [];
     const doneFileStream2: Promise<any>[] = [];
 
     this.browser
       .newPage()
       .then((page) => {
+        page.on("console", (msg) => {
+          console.log("web > ", msg.args(), msg.text());
+          // for (let i = 0; i < msg._args.length; ++i)
+          //   console.log(`${i}: ${msg._args[i]}`);
+        });
+
         page.exposeFunction(
-          "custom-screenshot",
+          "customScreenShot",
           async (ssOpts: ScreenshotOptions, testName: string) => {
             console.log("main.ts browser custom-screenshot", testName);
             const p = ssOpts.path as string;
@@ -235,6 +605,9 @@ export class PM_Main extends PM {
             fs.mkdirSync(dir, {
               recursive: true,
             });
+            if (!files[testName]) {
+              files[testName] = new Set();
+            }
             files[testName].add(ssOpts.path as string);
 
             const sPromise = page.screenshot({
@@ -323,6 +696,8 @@ export class PM_Main extends PM {
         });
 
         page.exposeFunction("customclose", (p: string, testName: string) => {
+          console.log("\t closing", p);
+
           fs.writeFileSync(
             p + "/manifest.json",
             JSON.stringify(Array.from(files[testName]))
@@ -360,6 +735,9 @@ export class PM_Main extends PM {
         return page;
       })
       .then(async (page) => {
+        page.on("console", (log) =>
+          console.debug(`Log from client: [${log.text()}] `)
+        );
         await page.goto(`file://${`${dest}.html`}`, {});
 
         page.evaluate(evaluation).finally(() => {

package/src/PM/node.ts

@@ -6,6 +6,7 @@ import { PassThrough } from "stream";
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 
 import { PM } from "./index.js";
+import { Page } from "puppeteer-core/lib/esm/puppeteer";
 
 type IFPaths = string[];
 const fPaths: IFPaths = [];
@@ -22,6 +23,10 @@ export class PM_Node extends PM {
     this.testResourceConfiguration = t;
   }
 
+  customScreenShot(opts: object, page: Page) {
+    return globalThis["customScreenShot"](opts, page);
+  }
+
   existsSync(destFolder: string): boolean {
     return globalThis["existsSync"](
       this.testResourceConfiguration.fs + "/" + destFolder
@@ -37,6 +42,7 @@ export class PM_Node extends PM {
   }
 
   writeFileSync(filepath: string, contents: string) {
+    console.log("pm_node-writeFileSync", this.testResourceConfiguration);
     return globalThis["writeFileSync"](
       this.testResourceConfiguration.fs + "/" + filepath,
       contents,

package/src/PM/web.ts

@@ -15,6 +15,10 @@ export class PM_Web extends PM {
     this.testResourceConfiguration = t;
   }
 
+  customScreenShot(opts: object) {
+    window["customScreenShot"](opts);
+  }
+
   existsSync(destFolder: string): boolean {
     return window["existsSync"](destFolder);
   }

package/src/Project.ts

@@ -109,6 +109,13 @@ export class ITProject {
 
     const [nodeEntryPoints, webEntryPoints] = getRunnables(this.config.tests);
 
+    console.log(
+      `this.getSecondaryEndpointsPoints("web")`,
+      this.getSecondaryEndpointsPoints("web")
+    );
+    // console.log("nodeEntryPoints", nodeEntryPoints);
+    // console.log("webEntryPoints", webEntryPoints);
+
     // nodeEntryPoints.forEach((nep) => {
     //   const f = `${process.cwd()}/${nep}`;
     //   console.log("nep", f);
@@ -208,11 +215,12 @@ export class ITProject {
   public getSecondaryEndpointsPoints(runtime?: IRunTime): string[] {
     const meta = (ts: ITestTypes[], st: Set<string>): Set<string> => {
       ts.forEach((t) => {
+        console.log("getSecondaryEndpointsPoints", t);
         if (t[1] === runtime) {
           st.add(t[0]);
         }
-        if (Array.isArray(t[2])) {
-          meta(t[2], st);
+        if (Array.isArray(t[3])) {
+          meta(t[3], st);
         }
       });
       return st;

package/src/Puppeteer.ts

@@ -7,6 +7,7 @@ import { v4 as uuidv4 } from "uuid";
 import { IBuiltConfig, IRunTime } from "./lib/types";
 
 import { PM_Main } from "./PM/main.js";
+import { destinationOfRuntime } from "./utils.js";
 
 var mode: "DEV" | "PROD" = process.argv[2] === "-dev" ? "DEV" : "PROD";
 
@@ -36,18 +37,20 @@ const main = async () => {
       waitForInitialPage: false,
       executablePath: "/opt/homebrew/bin/chromium",
       headless: true,
-      dumpio: true,
+      // dumpio: true,
       args: [
+        "--disable-features=IsolateOrigins,site-per-process",
+        "--disable-site-isolation-trials",
+        "--allow-insecure-localhost",
         "--allow-file-access-from-files",
         "--allow-running-insecure-content",
-        "--auto-open-devtools-for-tabs",
+        // "--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",
@@ -70,19 +73,11 @@ const main = async () => {
     "."
   );
 
-  const destinationOfRuntime = (f: string, r: IRunTime) => {
-    return path
-      .normalize(`${configs.buildDir}/${r}/${f}`)
-      .split(".")
-      .slice(0, -1)
-      .join(".");
-  };
-
-  configs.tests.forEach(([test, runtime, secondaryArtifacts]) => {
+  configs.tests.forEach(([test, runtime, tr, sidecars]) => {
     if (runtime === "node") {
-      pm.launchNode(test, destinationOfRuntime(test, "node"));
+      pm.launchNode(test, destinationOfRuntime(test, "node", configs));
     } else if (runtime === "web") {
-      pm.launchWeb(test, destinationOfRuntime(test, "web"));
+      pm.launchWeb(test, destinationOfRuntime(test, "web", configs), sidecars);
     } else {
       console.error("runtime makes no sense", runtime);
     }
@@ -96,7 +91,7 @@ const main = async () => {
     },
     (eventType, changedFile) => {
       if (changedFile) {
-        configs.tests.forEach(([test, runtime, secondaryArtifacts]) => {
+        configs.tests.forEach(([test, runtime, tr, sidecars]) => {
           if (eventType === "change" || eventType === "rename") {
             if (
               changedFile ===
@@ -107,7 +102,7 @@ const main = async () => {
                 .concat("mjs")
                 .join(".")
             ) {
-              pm.launchNode(test, destinationOfRuntime(test, "node"));
+              pm.launchNode(test, destinationOfRuntime(test, "node", configs));
             }
 
             if (
@@ -119,7 +114,11 @@ const main = async () => {
                 .concat("mjs")
                 .join(".")
             ) {
-              pm.launchWeb(test, destinationOfRuntime(test, "web"));
+              pm.launchWeb(
+                test,
+                destinationOfRuntime(test, "web", configs),
+                sidecars
+              );
             }
           }
         });