testeranto 0.90.0 → 0.100.0

package/src/PM/main.ts

@@ -1,19 +1,20 @@
+import { CdpPage, Page } from "puppeteer-core/lib/esm/puppeteer";
 import fs from "fs";
 import path from "path";
 import puppeteer, {
   Browser,
   ConsoleMessage,
+  LaunchOptions,
+  ScreenRecorder,
   ScreenshotOptions,
 } from "puppeteer-core";
 import { PassThrough } from "stream";
 import crypto from "crypto";
 
-import { IBuiltConfig, ITestTypes } from "../lib/types";
+import { IBuiltConfig, IFinalResults, ITestTypes } from "../lib/types";
+import { ITLog } from "../lib/index.js";
 
 import { PM } from "./index.js";
-import { destinationOfRuntime } from "../utils.js";
-import { ITLog } from "../lib/index.js";
-import { Page } from "puppeteer-core/lib/esm/puppeteer";
 
 const fileStreams3: fs.WriteStream[] = [];
 
@@ -22,8 +23,21 @@ type IFPaths = string[];
 const fPaths: IFPaths = [];
 
 const files: Record<string, Set<string>> = {};
+const recorders: Record<string, ScreenRecorder> = {};
 const screenshots: Record<string, Promise<Uint8Array>[]> = {};
 
+const red = "\x1b[31m";
+const green = "\x1b[32m";
+const reset = "\x1b[0m"; // Resets to default color
+
+const statusMessagePretty = (failures: number, test: string) => {
+  if (failures === 0) {
+    console.log(green + `${test} completed successfully` + reset);
+  } else {
+    console.log(red + `${test} failed ${failures} times` + reset);
+  }
+};
+
 export class PM_Main extends PM {
   browser: Browser;
 
@@ -43,6 +57,46 @@ export class PM_Main extends PM {
       this.ports[element] = "true"; // set ports as open
     });
 
+    globalThis["waitForSelector"] = async (pageKey: string, sel: string) => {
+      console.log("waitForSelector", pageKey, sel);
+      const page = (await this.browser.pages()).find(
+        (p) => p.mainFrame()._id === pageKey
+      );
+      await page?.waitForSelector(sel);
+    };
+
+    globalThis["screencastStop"] = async (path: string) => {
+      return recorders[path].stop();
+    };
+
+    globalThis["closePage"] = async (pageKey) => {
+      const page = (await this.browser.pages()).find(
+        (p) => p.mainFrame()._id === pageKey
+      );
+      return page.close();
+    };
+
+    // globalThis["closePage"] = (p) => {
+    //   console.log("closePage", p);
+    //   return p.close();
+    // };
+
+    globalThis["goto"] = async (pageKey: string, url: string) => {
+      const page = (await this.browser.pages()).find(
+        (p) => p.mainFrame()._id === pageKey
+      );
+      await page?.goto(url);
+      return;
+    };
+
+    globalThis["newPage"] = () => {
+      return this.browser.newPage();
+    };
+
+    globalThis["pages"] = () => {
+      return this.browser.pages();
+    };
+
     globalThis["mkdirSync"] = (fp: string) => {
       if (!fs.existsSync(fp)) {
         return fs.mkdirSync(fp, {
@@ -57,14 +111,19 @@ export class PM_Main extends PM {
       contents: string,
       testName: string
     ) => {
-      // console.log("globalThis-writeFileSync", filepath);
+      // console.log(testName, "writeFileSync", filepath, testName);
 
       // Create directories if they don't exist
-      const dir = path.dirname(filepath.split("/").slice(0, -1).join("/"));
+      const dir = path.dirname(filepath);
+
+      // console.log(testName, "mkdirSync", dir);
 
       fs.mkdirSync(dir, {
         recursive: true,
       });
+
+      // console.log(testName, "mkdirSync2");
+
       if (!files[testName]) {
         files[testName] = new Set();
       }
@@ -94,10 +153,41 @@ export class PM_Main extends PM {
       fileStreams3[uid].end();
     };
 
+    // async (ssOpts: ScreenshotOptions, testName: string) => {
+    //   const p = ssOpts.path as string;
+    //   const dir = path.dirname(p);
+    //   fs.mkdirSync(dir, {
+    //     recursive: true,
+    //   });
+    //   if (!files[testName]) {
+    //     files[testName] = new Set();
+    //   }
+    //   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"]`);
+    // };
+
     globalThis["customScreenShot"] = async (
       opts: { path: string },
-      page: Page
+      pageKey: string,
+      testName: string
     ) => {
+      const page = (await this.browser.pages()).find(
+        (p) => p.mainFrame()._id === pageKey
+      );
+
       const p = opts.path as string;
       const dir = path.dirname(p);
       fs.mkdirSync(dir, {
@@ -122,17 +212,57 @@ export class PM_Main extends PM {
       return sPromise;
     };
 
-    globalThis["customclose"] = (p: string, testName: string) => {
-      if (!files[testName]) {
-        files[testName] = new Set();
-      }
-
-      fs.writeFileSync(
-        p + "/manifest.json",
-        JSON.stringify(Array.from(files[testName]))
+    globalThis["screencast"] = async (
+      opts: ScreenshotOptions,
+      pageKey: string
+    ) => {
+      const page = (await this.browser.pages()).find(
+        (p) => p.mainFrame()._id === pageKey
       );
-      delete files[testName];
+
+      const p = opts.path as string;
+      const dir = path.dirname(p);
+      fs.mkdirSync(dir, {
+        recursive: true,
+      });
+
+      const recorder = await page?.screencast({
+        ...opts,
+        path: p,
+      });
+
+      recorders[opts.path] = recorder;
+
+      return opts.path;
     };
+
+    // 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];
+    // };
+  }
+
+  customclose() {
+    throw new Error("Method not implemented.");
+  }
+  waitForSelector(p: string, s: string): any {
+    throw new Error("Method not implemented.");
+  }
+  closePage(p): any {
+    throw new Error("Method not implemented.");
+  }
+  newPage(): CdpPage {
+    throw new Error("Method not implemented.");
+  }
+  goto(p, url: string): any {
+    throw new Error("Method not implemented.");
   }
 
   $(selector: string): boolean {
@@ -141,7 +271,7 @@ export class PM_Main extends PM {
   screencast(opts: object) {
     throw new Error("Method not implemented.");
   }
-  customScreenShot(opts: object) {
+  customScreenShot(opts: object, cdpPage?: CdpPage) {
     throw new Error("Method not implemented.");
   }
 
@@ -245,9 +375,15 @@ export class PM_Main extends PM {
   isDisabled(selector: string): boolean {
     throw new Error("Method not implemented.");
   }
+  screencastStop(s: string) {
+    throw new Error("Method not implemented.");
+  }
   ////////////////////////////////////////////////////////////////////////////////
 
-  async startPuppeteer(options: any, destfolder: string): Promise<any> {
+  async startPuppeteer(
+    options: LaunchOptions,
+    destfolder: string
+  ): Promise<any> {
     this.browser = (await puppeteer.launch(options)) as any;
   }
 
@@ -283,7 +419,7 @@ export class PM_Main extends PM {
   };
 
   launchNode = async (src: string, dest: string) => {
-    console.log("launchNode", src);
+    console.log("! node", src);
     this.register(src);
 
     const destFolder = dest.replace(".mjs", "");
@@ -338,27 +474,31 @@ export class PM_Main extends PM {
       process.exit(-1);
     }
 
-    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
-          );
-        }
-      })
-    );
+    const builtfile = dest;
+
+    const webSideCares: Page[] = [];
+
+    // await Promise.all(
+    //   testConfig[3].map(async (sidecar) => {
+    //     if (sidecar[1] === "web") {
+    //       const s = await this.launchWebSideCar(
+    //         sidecar[0],
+    //         destinationOfRuntime(sidecar[0], "web", this.configs),
+    //         sidecar
+    //       );
+    //       webSideCares.push(s);
+    //       return s;
+    //     }
+
+    //     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()}`
@@ -366,13 +506,16 @@ export class PM_Main extends PM {
       return module.default.then((defaultModule) => {
         defaultModule
           .receiveTestResourceConfig(argz)
-          .then(async (features: string[]) => {
-            this.receiveFeatures(features, destFolder);
+          .then(async ({ features, failed }: IFinalResults) => {
+            this.receiveFeatures(features, destFolder, src);
+            // console.log(`${src} completed with ${failed} errors`);
+            statusMessagePretty(failed, src);
           })
           .catch((e) => {
-            console.log("catch", e);
+            console.log(`${src} errored with`, e);
           })
           .finally(() => {
+            webSideCares.forEach((webSideCar) => webSideCar.close());
             this.deregister(src);
           });
       });
@@ -390,23 +533,16 @@ export class PM_Main extends PM {
     src: string,
     dest: string,
     testConfig: ITestTypes
-  ) => {
+  ): Promise<Page> => {
     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(),
-    });
-
-    // files[src] = new Set();
-    // const evaluation = `
-    // console.log("importing ${dest}.mjs");
-    // import('${dest}.mjs').then(async (x) => {
-    //   console.log("imported", x.default);
-    // })`;
+    // const webArgz = JSON.stringify({
+    //   name: dest,
+    //   ports: [].toString(),
+    //   fs: destFolder,
+    //   browserWSEndpoint: this.browser.wsEndpoint(),
+    // });
 
     const fileStreams2: fs.WriteStream[] = [];
     const doneFileStream2: Promise<any>[] = [];
@@ -520,18 +656,18 @@ export class PM_Main extends PM {
             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();
-            });
-          });
+          // 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();
+          //   });
+          // });
 
           return page;
         })
@@ -629,19 +765,19 @@ export class PM_Main extends PM {
     }
   };
 
-  launchWeb = (t: string, dest: string, sidecars: ITestTypes[]) => {
-    console.log("launchWeb", t, dest);
+  launchWeb = (t: string, dest: string) => {
+    console.log("! web", t);
     this.register(t);
 
-    sidecars.map((sidecar) => {
-      if (sidecar[1] === "node") {
-        return this.launchNodeSideCar(
-          sidecar[0],
-          destinationOfRuntime(sidecar[0], "node", this.configs),
-          sidecar
-        );
-      }
-    });
+    // sidecars.map((sidecar) => {
+    //   if (sidecar[1] === "node") {
+    //     return this.launchNodeSideCar(
+    //       sidecar[0],
+    //       destinationOfRuntime(sidecar[0], "node", this.configs),
+    //       sidecar
+    //     );
+    //   }
+    // });
 
     const destFolder = dest.replace(".mjs", "");
 
@@ -652,9 +788,11 @@ export class PM_Main extends PM {
       browserWSEndpoint: this.browser.wsEndpoint(),
     });
 
+    const d = `${dest}?cacheBust=${Date.now()}`;
+
     const evaluation = `
-    console.log("importing ${dest}.mjs");
-    import('${dest}.mjs').then(async (x) => {
+    console.log("importing ${d}");
+    import('${d}').then(async (x) => {
       console.log("imported", (await x.default));
       try {
         return await (await x.default).receiveTestResourceConfig(${webArgz})
@@ -666,8 +804,8 @@ export class PM_Main extends PM {
     const fileStreams2: fs.WriteStream[] = [];
     const doneFileStream2: Promise<any>[] = [];
 
-    const stdoutStream = fs.createWriteStream(`${dest}/stdout.log`);
-    const stderrStream = fs.createWriteStream(`${dest}/stderr.log`);
+    const stdoutStream = fs.createWriteStream(`${destFolder}/stdout.log`);
+    const stderrStream = fs.createWriteStream(`${destFolder}/stderr.log`);
 
     this.browser
       .newPage()
@@ -737,23 +875,24 @@ export class PM_Main extends PM {
         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;
+            return globalThis["writeFileSync"](fp, contents, testName);
+            // 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;
           }
         );
 
@@ -803,45 +942,44 @@ export class PM_Main extends PM {
           return fileStreams2[uid].end();
         });
 
-        page.exposeFunction("customclose", (p: string, testName: string) => {
-          // console.log("closing", p);
+        // page.exposeFunction("customclose", (p: string, testName: string) => {
+        //   // console.log("closing", p);
 
-          fs.writeFileSync(
-            p + "/manifest.json",
-            JSON.stringify(Array.from(files[testName]))
-          );
-          delete files[testName];
-
-          // console.log("screenshots[testName]", screenshots[testName]);
-          Promise.all(screenshots[testName] || []).then(() => {
-            delete screenshots[testName];
-            // page.close();
-            // console.log("\t GOODBYE");
-            // whyIsNodeRunning();
-          });
+        //   console.log("\t GOODBYE customclose");
 
-          // globalThis["writeFileSync"](
-          //   p + "/manifest.json",
-          //   // files.entries()
-          //   JSON.stringify(Array.from(files[testName]))
-          // );
+        //   fs.writeFileSync(
+        //     p + "/manifest.json",
+        //     JSON.stringify(Array.from(files[testName]))
+        //   );
+        //   delete 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);
+        //   // console.log("screenshots[testName]", screenshots[testName]);
+        //   Promise.all(screenshots[testName] || []).then(() => {
+        //     delete screenshots[testName];
+        //   });
 
-          // return 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();
+        // });
 
         page.exposeFunction("page", () => {
           return page.mainFrame()._id;
@@ -895,13 +1033,25 @@ export class PM_Main extends PM {
       })
       .then(async (page) => {
         const close = () => {
-          console.log("evaluation complete.", dest);
-          page.off("pageerror");
-          page.close();
+          if (!files[t]) {
+            files[t] = new Set();
+          }
+          // files[t].add(filepath);
+
+          fs.writeFileSync(
+            destFolder + "/manifest.json",
+            JSON.stringify(Array.from(files[t]))
+          );
+          delete files[t];
 
-          this.deregister(t);
-          stderrStream.close();
-          stdoutStream.close();
+          Promise.all(screenshots[t] || []).then(() => {
+            delete screenshots[t];
+            page.close();
+
+            this.deregister(t);
+            stderrStream.close();
+            stdoutStream.close();
+          });
         };
 
         page.on("pageerror", (err: Error) => {
@@ -932,32 +1082,39 @@ export class PM_Main extends PM {
           stdoutStream.write(JSON.stringify(log.location()));
           stdoutStream.write(JSON.stringify(log.stackTrace()));
         });
-        await page.goto(`file://${`${dest}.html`}`, {});
+        await page.goto(`file://${`${destFolder}.html`}`, {});
 
         await page
           .evaluate(evaluation)
-          .then(async (features: string[]) => {
-            this.receiveFeatures(features, destFolder);
+          .then(async ({ failed, features }: IFinalResults) => {
+            this.receiveFeatures(features, destFolder, t);
+            // console.log(`${t} completed with ${failed} errors`);
+            statusMessagePretty(failed, t);
           })
           .catch((e) => {
-            console.log("evaluation failed.", dest);
-            console.log(e);
+            console.log(`${t} errored with`, e);
           })
           .finally(() => {
             close();
-            // console.log("evaluation complete.", dest);
-            // page.close();
-            // this.deregister(t);
-            // stderrStream.close();
-            // stdoutStream.close();
           });
 
         return page;
       });
   };
 
-  receiveFeatures = (features: string[], destFolder: string) => {
-    console.log("this.receiveFeatures", features);
+  receiveFeatures = (
+    features: string[],
+    destFolder: string,
+    srcTest: string
+  ) => {
+    const featureDestination = path.resolve(
+      process.cwd(),
+      "docs",
+      "features",
+      "strings",
+      srcTest.split(".").slice(0, -1).join(".") + ".features.txt"
+    );
+
     features
       .reduce(async (mm, featureStringKey) => {
         const accum = await mm;
@@ -991,29 +1148,38 @@ export class PM_Main extends PM {
                 // console.log("Symlink created successfully");
               }
             });
-            accum.push(newPath);
+            accum.files.push(newPath);
           } else if (u.protocol === "http:" || u.protocol === "https:") {
             const newPath = `${process.cwd()}/docs/features/external${
               u.hostname
             }${u.pathname}`;
             const body = await this.configs.featureIngestor(featureStringKey);
             writeFileAndCreateDir(newPath, body);
-            accum.push(newPath);
+            accum.files.push(newPath);
           }
         } else {
-          const newPath = `${process.cwd()}/docs/features/plain/${await sha256(
-            featureStringKey
-          )}`;
-          writeFileAndCreateDir(newPath, featureStringKey);
-          accum.push(newPath);
+          await fs.promises.mkdir(path.dirname(featureDestination), {
+            recursive: true,
+          });
+          // const newPath = `${process.cwd()}/docs/features/plain/${await sha256(
+          //   featureStringKey
+          // )}`;
+          // writeFileAndCreateDir(
+          //   `${featureDestination}/${await sha256(featureStringKey)}`,
+          //   featureStringKey
+          // );
+          accum.strings.push(featureStringKey);
         }
 
         return accum;
-      }, Promise.resolve([] as string[]))
-      .then((features: string[]) => {
+      }, Promise.resolve({ files: [] as string[], strings: [] as string[] }))
+
+      .then(({ files, strings }: { files: string[]; strings: string[] }) => {
+        // writeFileAndCreateDir(`${featureDestination}`, JSON.stringify(strings));
+
         fs.writeFileSync(
           `${destFolder}/featurePrompt.txt`,
-          features
+          files
             .map((f) => {
               return `/read ${f}`;
             })
@@ -1028,7 +1194,7 @@ async function writeFileAndCreateDir(filePath, data) {
 
   try {
     await fs.promises.mkdir(dirPath, { recursive: true });
-    await fs.promises.writeFile(filePath, data);
+    await fs.appendFileSync(filePath, data);
   } catch (error) {
     console.error(`Error writing file: ${error}`);
   }