testeranto 0.81.3 → 0.84.0

package/src/PM/main.ts

@@ -1,22 +1,26 @@
 import fs from "fs";
 import path from "path";
-import puppeteer, { Page, ScreenshotOptions } from "puppeteer-core";
+import puppeteer, { Browser, ScreenshotOptions } from "puppeteer-core";
 import { PassThrough } from "stream";
+import crypto from "crypto";
 
 import { IBuiltConfig, ITestTypes } from "../lib/types";
 
 import { PM } from "./index.js";
 import { destinationOfRuntime } from "../utils.js";
 import { ITLog } from "../lib/index.js";
+import { Page } from "puppeteer-core/lib/esm/puppeteer";
 
 type IFPaths = string[];
 
 const fPaths: IFPaths = [];
 const fileStreams3: fs.WriteStream[] = [];
-const files: Record<string, Set<string>> = {}; // = new Set<string>();
+const files: Record<string, Set<string>> = {};
 const screenshots: Record<string, Promise<Uint8Array>[]> = {};
 
 export class PM_Main extends PM {
+  browser: Browser;
+
   shutdownMode = false;
   configs: IBuiltConfig;
   ports: Record<number, boolean>;
@@ -125,19 +129,128 @@ export class PM_Main extends PM {
     };
   }
 
-  shutDown() {
-    console.log("shutting down...");
-    this.shutdownMode = true;
-    this.checkForShutdown();
+  $(selector: string): boolean {
+    throw new Error("Method not implemented.");
+  }
+  screencast(opts: object) {
+    throw new Error("Method not implemented.");
   }
-
   customScreenShot(opts: object) {
     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);
+  }
+
+  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.");
+  }
+  page(): string | undefined {
+    throw new Error("Method not implemented.");
+  }
+  click(selector: string): string | undefined {
+    throw new Error("Method not implemented.");
+  }
+  focusOn(selector: string) {
+    throw new Error("Method not implemented.");
+  }
+  typeInto(value: string) {
+    throw new Error("Method not implemented.");
+  }
+  getValue(value: string) {
+    throw new Error("Method not implemented.");
+  }
+  getAttribute(selector: string, attribute: string) {
+    throw new Error("Method not implemented.");
+  }
+  isDisabled(selector: string): boolean {
+    throw new Error("Method not implemented.");
+  }
+  ////////////////////////////////////////////////////////////////////////////////
+
   async startPuppeteer(options: any, destfolder: string): Promise<any> {
     this.browser = (await puppeteer.launch(options)) as any;
-    return this.browser;
+  }
+
+  ////////////////////////////////////////////////////////////////////////////////
+
+  shutDown() {
+    console.log("shutting down...");
+    this.shutdownMode = true;
+    this.checkForShutdown();
   }
 
   checkForShutdown = () => {
@@ -153,14 +266,11 @@ export class PM_Main extends PM {
   };
 
   register = (src: string) => {
-    // console.log("register", src);
     this.registry[src] = false;
   };
 
   deregister = (src: string) => {
-    // console.log("deregister", src, this.shutdownMode);
     this.registry[src] = true;
-
     if (this.shutdownMode) {
       this.checkForShutdown();
     }
@@ -250,6 +360,9 @@ export class PM_Main extends PM {
       return module.default.then((defaultModule) => {
         defaultModule
           .receiveTestResourceConfig(argz)
+          .then(async (features: string[]) => {
+            this.receiveFeatures(features, destFolder);
+          })
           .catch((e) => {
             console.log("catch", e);
           })
@@ -282,11 +395,11 @@ export class PM_Main extends PM {
       browserWSEndpoint: this.browser.wsEndpoint(),
     });
 
-    const evaluation = `
-    console.log("importing ${dest}.mjs");
-    import('${dest}.mjs').then(async (x) => {
-      console.log("imported", x.default);
-    })`;
+    // 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>[] = [];
@@ -295,11 +408,11 @@ export class PM_Main extends PM {
       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.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",
@@ -411,44 +524,13 @@ export class PM_Main extends PM {
               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;
         });
     });
   };
@@ -465,14 +547,6 @@ export class PM_Main extends PM {
 
     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[] = [];
@@ -574,9 +648,9 @@ export class PM_Main extends PM {
     const evaluation = `
     console.log("importing ${dest}.mjs");
     import('${dest}.mjs').then(async (x) => {
-      console.log("imported", x.default);
+      console.log("imported", (await x.default));
       try {
-        await (await x.default).receiveTestResourceConfig(${webArgz})
+        return await (await x.default).receiveTestResourceConfig(${webArgz})
       } catch (e) {
         console.log("fail", e)
       }
@@ -588,16 +662,42 @@ export class PM_Main extends PM {
     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.on("console", (msg) => {
+        //   // console.log("web > ", msg.args(), msg.text());
+        // });
+
+        page.exposeFunction(
+          "screencast",
+          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"]`);
+          }
+        );
 
         page.exposeFunction(
           "customScreenShot",
           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, {
@@ -733,16 +833,67 @@ export class PM_Main extends PM {
           // return page.close();
         });
 
+        page.exposeFunction("page", () => {
+          return page.mainFrame()._id;
+        });
+
+        page.exposeFunction("click", (sel) => {
+          return page.click(sel);
+        });
+
+        page.exposeFunction("focusOn", (sel) => {
+          return page.focus(sel);
+        });
+
+        page.exposeFunction(
+          "typeInto",
+          async (value) => await page.keyboard.type(value)
+        );
+
+        page.exposeFunction("getValue", (selector) =>
+          page.$eval(selector, (input) => input.getAttribute("value"))
+        );
+
+        page.exposeFunction(
+          "getAttribute",
+          async (selector: string, attribute: string) => {
+            const attributeValue = await page.$eval(selector, (input) => {
+              return input.getAttribute(attribute);
+            });
+            return attributeValue;
+          }
+        );
+
+        page.exposeFunction("isDisabled", async (selector: string) => {
+          const attributeValue = await page.$eval(
+            selector,
+            (input: HTMLButtonElement) => {
+              return input.disabled;
+            }
+          );
+          return attributeValue;
+        });
+
+        page.exposeFunction("$", async (selector: string) => {
+          const x = page.$(selector);
+          const y = await x;
+
+          return y;
+        });
+
         return page;
       })
       .then(async (page) => {
-        page.on("console", (log) =>
-          console.debug(`Log from client: [${log.text()}] `)
-        );
+        // page.on("console", (log) =>
+        //   console.debug(`Log from client: [${log.text()}] `)
+        // );
         await page.goto(`file://${`${dest}.html`}`, {});
 
-        page
+        await page
           .evaluate(evaluation)
+          .then(async (features: string[]) => {
+            this.receiveFeatures(features, destFolder);
+          })
           .catch((e) => {
             console.log("evaluation failed.", dest);
             console.log(e);
@@ -751,90 +902,105 @@ export class PM_Main extends PM {
             console.log("evaluation complete.", dest);
             // page.close();
             this.deregister(t);
-            // whyIsNodeRunning();
           });
 
         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);
-  }
+  receiveFeatures = (features: string[], destFolder: string) => {
+    console.log("this.receiveFeatures", features);
+    features
+      .reduce(async (mm, featureStringKey) => {
+        const accum = await mm;
 
-  createWriteStream(filepath: string): fs.WriteStream {
-    return fs.createWriteStream(filepath);
-  }
+        const isUrl = isValidUrl(featureStringKey);
 
-  testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise) => void) {
-    return (fPath, value: string | Buffer | PassThrough) => {
-      callback(
-        new Promise<void>((res, rej) => {
-          tLog("testArtiFactory =>", fPath);
+        if (isUrl) {
+          const u = new URL(featureStringKey);
 
-          const cleanPath = path.resolve(fPath);
-          fPaths.push(cleanPath.replace(process.cwd(), ``));
+          if (u.protocol === "file:") {
+            const newPath = `${process.cwd()}/docs/features/internal/${path.relative(
+              process.cwd(),
+              u.pathname
+            )}`;
 
-          const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+            await fs.promises.mkdir(path.dirname(newPath), { recursive: true });
 
-          fs.mkdir(targetDir, { recursive: true }, async (error) => {
-            if (error) {
-              console.error(`❗️testArtiFactory failed`, targetDir, error);
+            try {
+              await fs.unlinkSync(newPath);
+              // console.log(`Removed existing link at ${newPath}`);
+            } catch (error) {
+              if (error.code !== "ENOENT") {
+                // throw error;
+              }
             }
 
-            fs.writeFileSync(
-              path.resolve(
-                targetDir.split("/").slice(0, -1).join("/"),
-                "manifest"
-              ),
-              fPaths.join(`\n`),
-              {
-                encoding: "utf-8",
+            fs.symlink(u.pathname, newPath, (err) => {
+              if (err) {
+                // console.error("Error creating symlink:", err);
+              } else {
+                // console.log("Symlink created successfully");
               }
-            );
+            });
+            accum.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);
+          }
+        } else {
+          const newPath = `${process.cwd()}/docs/features/plain/${await sha256(
+            featureStringKey
+          )}`;
+          writeFileAndCreateDir(newPath, featureStringKey);
+          accum.push(newPath);
+        }
 
-            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();
-              });
-            }
-          });
-        })
-      );
-    };
+        return accum;
+      }, Promise.resolve([] as string[]))
+      .then((features: string[]) => {
+        fs.writeFileSync(
+          `${destFolder}/featurePrompt.txt`,
+          features
+            .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}`);
   }
+}
 
-  write(accessObject: { uid: number }, contents: string): boolean {
-    throw new Error("Method not implemented.");
+async function sha256(rawData) {
+  const data =
+    typeof rawData === "object" ? JSON.stringify(rawData) : String(rawData);
+
+  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("");
+}
+
+function isValidUrl(string) {
+  try {
+    new URL(string);
+    return true;
+  } catch (err) {
+    return false;
   }
 }

package/src/PM/node.ts

@@ -23,8 +23,42 @@ export class PM_Node extends PM {
     this.testResourceConfiguration = t;
   }
 
-  customScreenShot(opts: object, page: Page) {
-    return globalThis["customScreenShot"](opts, page);
+  $(selector: string): boolean {
+    throw new Error("Method not implemented.");
+  }
+  screencast(opts: object) {
+    throw new Error("Method not implemented.");
+  }
+
+  isDisabled(selector: string): boolean {
+    throw new Error("Method not implemented.");
+  }
+
+  getAttribute(selector: string, attribute: string) {
+    throw new Error("Method not implemented.");
+  }
+  getValue(selector: string) {
+    throw new Error("Method not implemented.");
+  }
+
+  focusOn(selector: string) {
+    throw new Error("Method not implemented.");
+  }
+
+  typeInto(value: string) {
+    throw new Error("Method not implemented.");
+  }
+
+  page() {
+    return globalThis["page"]();
+  }
+
+  click(selector: string): string | undefined {
+    return globalThis["click"](selector);
+  }
+
+  customScreenShot(opts: object) {
+    return globalThis["customScreenShot"](opts);
   }
 
   existsSync(destFolder: string): boolean {
@@ -42,7 +76,6 @@ 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,
@@ -120,9 +153,9 @@ export class PM_Node extends PM {
   }
 
   // launch(options?: PuppeteerLaunchOptions): Promise<Browser>;
-  startPuppeteer(options?: any): Promise<any> {
-    return puppeteer.connect(options).then((b) => {
-      this.browser = b;
-    });
+  startPuppeteer(options?: any): any {
+    // return puppeteer.connect(options).then((b) => {
+    //   this.browser = b;
+    // });
   }
 }