testeranto 0.94.0 → 0.110.0

package/src/PM/main.ts

@@ -1,29 +1,65 @@
+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, IFinalResults, ITestTypes } from "../lib/types";
+import ansiC from "ansi-colors";
+
+import {
+  IBuiltConfig,
+  IFinalResults,
+  ITestTypes,
+  ITLog,
+} from "../lib/index.js";
+import {
+  bddExitCodePather,
+  lintExitCodePather,
+  tscExitCodePather,
+} from "../utils";
 
 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[] = [];
-
 type IFPaths = string[];
-
 const fPaths: IFPaths = [];
-
 const files: Record<string, Set<string>> = {};
+const recorders: Record<string, ScreenRecorder> = {};
 const screenshots: Record<string, Promise<Uint8Array>[]> = {};
 
+const statusMessagePretty = (failures: number, test: string) => {
+  if (failures === 0) {
+    console.log(ansiC.green(ansiC.inverse(`> ${test} completed successfully`)));
+  } else {
+    console.log(ansiC.red(ansiC.inverse(`> ${test} failed ${failures} times`)));
+  }
+};
+
+async function writeFileAndCreateDir(filePath, data) {
+  const dirPath = path.dirname(filePath);
+
+  try {
+    await fs.promises.mkdir(dirPath, { recursive: true });
+    await fs.appendFileSync(filePath, data);
+  } catch (error) {
+    console.error(`Error writing file: ${error}`);
+  }
+}
+
+function isValidUrl(string) {
+  try {
+    new URL(string);
+    return true;
+  } catch (err) {
+    return false;
+  }
+}
+
 export class PM_Main extends PM {
   browser: Browser;
 
@@ -31,18 +67,71 @@ export class PM_Main extends PM {
   configs: IBuiltConfig;
   ports: Record<number, boolean>;
   queue: any[];
-  registry: Record<string, boolean>;
+
+  bigBoard: Record<
+    string,
+    {
+      status: "?" | "running" | "waiting";
+      runTimeError?: number;
+      typeErrors?: string;
+      staticErrors?: string;
+    }
+  > = {};
 
   constructor(configs: IBuiltConfig) {
     super();
     this.server = {};
     this.configs = configs;
     this.ports = {};
-    this.registry = {};
+
+    this.configs.tests.forEach(([t]) => {
+      this.bigBoard[t] = {
+        status: "?",
+      };
+    });
+
     this.configs.ports.forEach((element) => {
       this.ports[element] = "true"; // set ports as open
     });
 
+    globalThis["waitForSelector"] = async (pageKey: string, sel: string) => {
+      const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
+        (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(
+        /* @ts-ignore:next-line */
+        (p) => p.mainFrame()._id === pageKey
+      );
+      /* @ts-ignore:next-line */
+      return page.close();
+    };
+
+    globalThis["goto"] = async (pageKey: string, url: string) => {
+      const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
+        (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,19 +146,9 @@ export class PM_Main extends PM {
       contents: string,
       testName: string
     ) => {
-      // console.log(testName, "writeFileSync", filepath, testName);
-
-      // Create directories if they don't exist
-      const dir = path.dirname(filepath);
-
-      // console.log(testName, "mkdirSync", dir);
-
-      fs.mkdirSync(dir, {
+      fs.mkdirSync(path.dirname(filepath), {
         recursive: true,
       });
-
-      // console.log(testName, "mkdirSync2");
-
       if (!files[testName]) {
         files[testName] = new Set();
       }
@@ -99,10 +178,42 @@ 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(
+        /* @ts-ignore:next-line */
+        (p) => p.mainFrame()._id === pageKey
+      );
+
       const p = opts.path as string;
       const dir = path.dirname(p);
       fs.mkdirSync(dir, {
@@ -127,6 +238,31 @@ export class PM_Main extends PM {
       return sPromise;
     };
 
+    globalThis["screencast"] = async (
+      opts: ScreenshotOptions,
+      pageKey: string
+    ) => {
+      const page = (await this.browser.pages()).find(
+        /* @ts-ignore:next-line */
+        (p) => p.mainFrame()._id === pageKey
+      );
+
+      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();
@@ -140,20 +276,33 @@ export class PM_Main extends PM {
     // };
   }
 
+  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 {
     throw new Error("Method not implemented.");
   }
   screencast(opts: object) {
     throw new Error("Method not implemented.");
   }
-  customScreenShot(opts: object) {
+  customScreenShot(opts: object, cdpPage?: CdpPage) {
     throw new Error("Method not implemented.");
   }
-
   end(accessObject: { uid: number }): boolean {
     throw new Error("Method not implemented.");
   }
-
   existsSync(destFolder: string): boolean {
     return fs.existsSync(destFolder);
   }
@@ -247,49 +396,85 @@ export class PM_Main extends PM {
   getAttribute(selector: string, attribute: string) {
     throw new Error("Method not implemented.");
   }
-  isDisabled(selector: string): boolean {
+  isDisabled(selector: string): Promise<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;
   }
 
-  ////////////////////////////////////////////////////////////////////////////////
+  // goodbye = () => {
+  //   this.browser.disconnect().then(() => {
+
+  //     console.log("Goodbye");
+  //     process.exit();
+  //   });
+  // };
 
   shutDown() {
-    console.log("shutting down...");
     this.shutdownMode = true;
     this.checkForShutdown();
   }
 
   checkForShutdown = () => {
     const anyRunning: boolean =
-      Object.values(this.registry).filter((x) => x === false).length > 0;
+      Object.values(this.bigBoard).filter((x) => x.status === "running")
+        .length > 0;
     if (anyRunning) {
     } else {
       this.browser.disconnect().then(() => {
-        console.log("Goodbye");
+        const final = {
+          timestamp: Date.now(),
+          tests: this.configs.tests.reduce((mm, t) => {
+            const bddErrors = fs
+              .readFileSync(bddExitCodePather(t[0], t[1]))
+              .toString();
+            const lintErrors = fs
+              .readFileSync(lintExitCodePather(t[0], t[1]))
+              .toString();
+            const typeErrors = fs
+              .readFileSync(tscExitCodePather(t[0], t[1]))
+              .toString();
+            mm[t[0]] = {
+              bddErrors,
+              lintErrors,
+              typeErrors,
+            };
+            return mm;
+          }, {}),
+        };
+
+        const s = JSON.stringify(final, null, 2);
+        fs.writeFileSync("docs/summary.json", s);
+        console.log(ansiC.inverse("Goodbye"));
         process.exit();
       });
     }
   };
 
-  register = (src: string) => {
-    this.registry[src] = false;
+  testIsNowRunning = (src: string) => {
+    this.bigBoard[src].status = "running";
   };
 
-  deregister = (src: string) => {
-    this.registry[src] = true;
+  testIsNowDone = (src: string) => {
+    this.bigBoard[src].status = "waiting";
     if (this.shutdownMode) {
       this.checkForShutdown();
     }
   };
 
   launchNode = async (src: string, dest: string) => {
-    console.log("launchNode", src);
-    this.register(src);
+    // console.log(ansiC.yellow(`! node, ${src}`));
+    console.log(ansiC.green(ansiC.inverse(`! node, ${src}`)));
+    this.testIsNowRunning(src);
 
     const destFolder = dest.replace(".mjs", "");
 
@@ -300,7 +485,7 @@ export class PM_Main extends PM {
     });
 
     if (!testConfig) {
-      console.error("missing test config");
+      console.log(ansiC.inverse("missing test config! Exiting ungracefully!"));
       process.exit(-1);
     }
     const testConfigResource = testConfig[2];
@@ -343,31 +528,31 @@ export class PM_Main extends PM {
       process.exit(-1);
     }
 
-    const builtfile = dest + ".mjs";
+    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
-          );
-        }
-      })
-    );
+    // 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()}`
@@ -376,15 +561,18 @@ export class PM_Main extends PM {
         defaultModule
           .receiveTestResourceConfig(argz)
           .then(async ({ features, failed }: IFinalResults) => {
-            this.receiveFeatures(features, destFolder);
-            console.log(`${src} completed with ${failed} errors`);
+            this.receiveFeatures(features, destFolder, src);
+            // console.log(`${src} completed with ${failed} errors`);
+            statusMessagePretty(failed, src);
+            this.receiveExitCode(src, failed);
           })
           .catch((e) => {
-            console.log(`${src} errored with`, e);
+            console.log(ansiC.red(ansiC.inverse(`${src} errored with: ${e}`)));
+            // console.log(reset, `${src} errored with`, e);
           })
           .finally(() => {
             webSideCares.forEach((webSideCar) => webSideCar.close());
-            this.deregister(src);
+            this.testIsNowDone(src);
           });
       });
     });
@@ -403,7 +591,9 @@ export class PM_Main extends PM {
     testConfig: ITestTypes
   ): Promise<Page> => {
     const d = dest + ".mjs";
-    console.log("launchWebSideCar", src, dest, d);
+    // console.log(green, "launchWebSideCar", src, dest, d);
+    console.log(ansiC.green(ansiC.inverse(`launchWebSideCar ${src}`)));
+
     const destFolder = dest.replace(".mjs", "");
     // const webArgz = JSON.stringify({
     //   name: dest,
@@ -541,6 +731,7 @@ export class PM_Main extends PM {
         })
         .then(async (page) => {
           await page.goto(`file://${`${dest}.html`}`, {});
+
           res(page);
         });
     });
@@ -552,7 +743,8 @@ export class PM_Main extends PM {
     testConfig: ITestTypes
   ) => {
     const d = dest + ".mjs";
-    console.log("launchNodeSideCar", src, dest, d);
+    // console.log(green, "launchNodeSideCar", src, dest, d);
+    console.log(ansiC.green(ansiC.inverse(`launchNodeSideCar ${src}`)));
 
     const destFolder = dest.replace(".mjs", "");
 
@@ -633,19 +825,20 @@ export class PM_Main extends PM {
     }
   };
 
-  launchWeb = (t: string, dest: string, sidecars: ITestTypes[]) => {
-    console.log("launchWeb", t, dest);
-    this.register(t);
-
-    sidecars.map((sidecar) => {
-      if (sidecar[1] === "node") {
-        return this.launchNodeSideCar(
-          sidecar[0],
-          destinationOfRuntime(sidecar[0], "node", this.configs),
-          sidecar
-        );
-      }
-    });
+  launchWeb = (t: string, dest: string) => {
+    // console.log(green, "! web", t);
+    console.log(ansiC.green(ansiC.inverse(`! web ${t}`)));
+    this.testIsNowRunning(t);
+
+    // sidecars.map((sidecar) => {
+    //   if (sidecar[1] === "node") {
+    //     return this.launchNodeSideCar(
+    //       sidecar[0],
+    //       destinationOfRuntime(sidecar[0], "node", this.configs),
+    //       sidecar
+    //     );
+    //   }
+    // });
 
     const destFolder = dest.replace(".mjs", "");
 
@@ -656,10 +849,12 @@ 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("imported", (await x.default));
+
+    import('${d}').then(async (x) => {
+
       try {
         return await (await x.default).receiveTestResourceConfig(${webArgz})
       } catch (e) {
@@ -670,8 +865,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()
@@ -848,7 +1043,7 @@ export class PM_Main extends PM {
         // });
 
         page.exposeFunction("page", () => {
-          return page.mainFrame()._id;
+          return (page.mainFrame() as unknown as { _id: string })._id;
         });
 
         page.exposeFunction("click", (sel) => {
@@ -905,7 +1100,7 @@ export class PM_Main extends PM {
           // files[t].add(filepath);
 
           fs.writeFileSync(
-            dest + "/manifest.json",
+            destFolder + "/manifest.json",
             JSON.stringify(Array.from(files[t]))
           );
           delete files[t];
@@ -914,7 +1109,7 @@ export class PM_Main extends PM {
             delete screenshots[t];
             page.close();
 
-            this.deregister(t);
+            this.testIsNowDone(t);
             stderrStream.close();
             stdoutStream.close();
           });
@@ -936,7 +1131,7 @@ export class PM_Main extends PM {
 
           console.debug(`Error from message ${t}: [${err.message}] `);
           stderrStream.write(err.message);
-          // close();
+          close();
         });
         page.on("console", (log: ConsoleMessage) => {
           // console.debug(`Log from ${t}: [${log.text()}] `);
@@ -948,18 +1143,22 @@ 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 ({ failed, features }: IFinalResults) => {
-            this.receiveFeatures(features, destFolder);
-            console.log(`${t} completed with ${failed} errors`);
+            this.receiveFeatures(features, destFolder, t);
+            // console.log(`${t} completed with ${failed} errors`);
+            statusMessagePretty(failed, t);
+            this.receiveExitCode(t, failed);
           })
           .catch((e) => {
-            console.log(`${t} errored with`, e);
+            // console.log(red, `${t} errored with`, e);
+            console.log(ansiC.red(ansiC.inverse(`${t} errored with: ${e}`)));
           })
           .finally(() => {
+            // this.testIsNowDone(t);
             close();
           });
 
@@ -967,7 +1166,19 @@ export class PM_Main extends PM {
       });
   };
 
-  receiveFeatures = (features: string[], destFolder: string) => {
+  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;
@@ -994,71 +1205,58 @@ export class PM_Main extends PM {
               }
             }
 
-            fs.symlink(u.pathname, newPath, (err) => {
-              if (err) {
-                // console.error("Error creating symlink:", err);
-              } else {
-                // console.log("Symlink created successfully");
-              }
-            });
-            accum.push(newPath);
+            // fs.symlink(u.pathname, newPath, (err) => {
+            //   if (err) {
+            //     // console.error("Error creating symlink:", err);
+            //   } else {
+            //     // console.log("Symlink created successfully");
+            //   }
+            // });
+            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,
+          });
+
+          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}`;
             })
             .join("\n")
         );
       });
-  };
-}
-
-async function writeFileAndCreateDir(filePath, data) {
-  const dirPath = path.dirname(filePath);
 
-  try {
-    await fs.promises.mkdir(dirPath, { recursive: true });
-    await fs.promises.writeFile(filePath, data);
-  } catch (error) {
-    console.error(`Error writing file: ${error}`);
-  }
-}
-
-async function sha256(rawData) {
-  const data =
-    typeof rawData === "object" ? JSON.stringify(rawData) : String(rawData);
+    this.writeBigBoard();
+  };
 
-  const msgBuffer = new TextEncoder().encode(data);
-  const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer);
-  const hashArray = Array.from(new Uint8Array(hashBuffer));
-  return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
-}
+  receiveExitCode = (srcTest: string, failures: number) => {
+    this.bigBoard[srcTest].runTimeError = failures;
+    this.writeBigBoard();
+  };
 
-function isValidUrl(string) {
-  try {
-    new URL(string);
-    return true;
-  } catch (err) {
-    return false;
-  }
+  writeBigBoard = () => {
+    fs.writeFileSync(
+      "./docs/bigBoard.json",
+      JSON.stringify(this.bigBoard, null, 2)
+    );
+  };
 }