testeranto 0.121.1 → 0.125.1

package/src/PM/node.ts

@@ -1,3 +1,4 @@
+import net from "net";
 import fs from "fs";
 import path from "path";
 import { ScreencastOptions } from "puppeteer-core";
@@ -5,132 +6,175 @@ import { PassThrough } from "stream";
 
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 
-import { PM } from "./index.js";
-import { CdpPage, Page } from "puppeteer-core/lib/esm/puppeteer";
+import { PM } from ".";
 
 type IFPaths = string[];
 const fPaths: IFPaths = [];
 
-type PuppetMasterServer = Record<string, Promise<any>>;
-
 export class PM_Node extends PM {
-  server: PuppetMasterServer;
   testResourceConfiguration: ITTestResourceConfiguration;
+  client: net.Socket;
 
   constructor(t: ITTestResourceConfiguration) {
     super();
-    this.server = {};
     this.testResourceConfiguration = t;
   }
 
+  start(): Promise<void> {
+    return new Promise((res) => {
+      process.on("message", (message: { path?: string }) => {
+        if (message.path) {
+          this.client = net.createConnection(message.path, () => {
+            res();
+          });
+        }
+      });
+    });
+  }
+
+  stop(): Promise<void> {
+    throw new Error("Method not implemented.");
+  }
+
+  send<I>(command: string, ...argz): Promise<I> {
+    return new Promise<I>((res) => {
+      const key = Math.random().toString();
+
+      const myListener = (event) => {
+        const x = JSON.parse(event);
+        if (x.key === key) {
+          process.removeListener("message", myListener);
+          res(x.payload);
+        }
+      };
+
+      process.addListener("message", myListener);
+
+      this.client.write(JSON.stringify([command, ...argz, key]));
+    });
+  }
+
+  async pages() {
+    return this.send<string[]>("pages", ...arguments);
+  }
+
   waitForSelector(p: string, s: string): any {
-    return globalThis["waitForSelector"](p, s);
+    return this.send("waitForSelector", ...arguments);
   }
 
-  closePage(p): string {
-    return globalThis["closePage"](p);
+  closePage(p) {
+    return this.send("closePage", ...arguments);
+    // return globalThis["closePage"](p);
   }
 
-  goto(cdpPage: CdpPage, url: string): any {
-    return globalThis["goto"](cdpPage.mainFrame()._id, url);
+  goto(page: string, url: string) {
+    return this.send("goto", ...arguments);
+    // return globalThis["goto"](cdpPage.mainFrame()._id, url);
   }
 
-  newPage(): CdpPage {
-    return globalThis["newPage"]();
+  async newPage() {
+    return this.send<string>("newPage");
   }
 
-  $(selector: string): boolean {
-    throw new Error("Method not implemented.");
+  $(selector: string) {
+    return this.send("$", ...arguments);
   }
 
   isDisabled(selector: string): Promise<boolean> {
-    throw new Error("Method not implemented.");
+    return this.send("isDisabled", ...arguments);
   }
 
   getAttribute(selector: string, attribute: string) {
-    throw new Error("Method not implemented.");
+    return this.send("getAttribute", ...arguments);
   }
+
   getValue(selector: string) {
-    throw new Error("Method not implemented.");
+    return this.send("getValue", ...arguments);
   }
 
   focusOn(selector: string) {
-    throw new Error("Method not implemented.");
+    return this.send("focusOn", ...arguments);
   }
 
-  typeInto(value: string) {
-    throw new Error("Method not implemented.");
+  typeInto(selector: string) {
+    return this.send("typeInto", ...arguments);
   }
 
   page() {
-    return globalThis["page"]();
+    return this.send<string | undefined>("page");
   }
 
-  click(selector: string): string | undefined {
-    return globalThis["click"](selector);
+  click(selector: string) {
+    return this.send("click", ...arguments);
   }
 
-  screencast(opts: ScreencastOptions, page: CdpPage) {
-    return globalThis["screencast"](
+  screencast(opts: ScreencastOptions, page: string) {
+    return this.send(
+      "screencast",
       {
         ...opts,
         path: this.testResourceConfiguration.fs + "/" + opts.path,
       },
-      page.mainFrame()._id,
+      page,
       this.testResourceConfiguration.name
     );
   }
 
   screencastStop(p: string) {
-    return globalThis["screencastStop"](p);
+    return this.send("screencastStop", ...arguments);
   }
 
-  customScreenShot(opts: ScreencastOptions, cdpPage: CdpPage) {
-    return globalThis["customScreenShot"](
+  customScreenShot(opts: ScreencastOptions, page?: string) {
+    return this.send(
+      "customScreenShot",
       {
         ...opts,
         path: this.testResourceConfiguration.fs + "/" + opts.path,
       },
-      cdpPage.mainFrame()._id,
+      page,
       this.testResourceConfiguration.name
     );
   }
 
-  existsSync(destFolder: string): boolean {
-    return globalThis["existsSync"](
+  async existsSync(destFolder: string): Promise<boolean> {
+    return await this.send<boolean>(
+      "existsSync",
       this.testResourceConfiguration.fs + "/" + destFolder
     );
   }
 
   mkdirSync() {
-    return globalThis["mkdirSync"](this.testResourceConfiguration.fs + "/");
+    return this.send("mkdirSync", this.testResourceConfiguration.fs + "/");
   }
 
-  write(writeObject: { uid: number }, contents: string) {
-    return globalThis["write"](writeObject.uid, contents);
+  async write(uid: number, contents: string): Promise<boolean> {
+    return await this.send("write", ...arguments);
   }
 
-  writeFileSync(filepath: string, contents: string) {
-    return globalThis["writeFileSync"](
+  async writeFileSync(filepath: string, contents: string) {
+    return await this.send<boolean>(
+      "writeFileSync",
       this.testResourceConfiguration.fs + "/" + filepath,
       contents,
       this.testResourceConfiguration.name
     );
   }
 
-  createWriteStream(filepath: string): any {
-    return globalThis["createWriteStream"](
+  async createWriteStream(filepath: string) {
+    return await this.send<string>(
+      "createWriteStream",
       this.testResourceConfiguration.fs + "/" + filepath,
       this.testResourceConfiguration.name
     );
   }
 
-  end(writeObject: { uid: number }) {
-    return globalThis["end"](writeObject.uid);
+  async end(uid) {
+    return await this.send<boolean>("end", ...arguments);
   }
 
-  customclose() {
-    globalThis["customclose"](
+  async customclose() {
+    return await this.send(
+      "customclose",
       this.testResourceConfiguration.fs,
       this.testResourceConfiguration.name
     );

package/src/PM/pure.ts

@@ -0,0 +1,209 @@
+import fs from "fs";
+import path from "path";
+import { ScreencastOptions } from "puppeteer-core";
+import { CdpPage } from "puppeteer-core/lib/esm/puppeteer";
+import { PassThrough } from "stream";
+
+import { ITLog, ITTestResourceConfiguration } from "../lib";
+
+import { PM } from ".";
+
+type IFPaths = string[];
+const fPaths: IFPaths = [];
+
+type PuppetMasterServer = Record<string, Promise<any>>;
+
+export class PM_Pure extends PM {
+  server: PuppetMasterServer;
+  testResourceConfiguration: ITTestResourceConfiguration;
+
+  constructor(t: ITTestResourceConfiguration) {
+    super();
+    this.server = {};
+    this.testResourceConfiguration = t;
+  }
+
+  start(): Promise<void> {
+    return new Promise((r) => r());
+  }
+
+  stop(): Promise<void> {
+    return new Promise((r) => r());
+  }
+
+  pages() {
+    return globalThis["pages"]();
+  }
+
+  waitForSelector(p: string, s: string): any {
+    return globalThis["waitForSelector"](p, s);
+  }
+
+  closePage(p): string {
+    return globalThis["closePage"](p);
+  }
+
+  goto(cdpPage: CdpPage, url: string): any {
+    return globalThis["goto"](cdpPage.mainFrame()._id, url);
+  }
+
+  newPage() {
+    return globalThis["newPage"]();
+  }
+
+  $(selector: string): boolean {
+    return globalThis["$"](selector);
+  }
+
+  isDisabled(selector: string): Promise<boolean> {
+    return globalThis["isDisabled"](selector);
+  }
+
+  getAttribute(selector: string, attribute: string) {
+    return globalThis["getAttribute"](selector, attribute);
+  }
+
+  getValue(selector: string) {
+    return globalThis["getValue"](selector);
+  }
+
+  focusOn(selector: string) {
+    return globalThis["focusOn"](selector);
+  }
+
+  typeInto(selector: string, value: string) {
+    return globalThis["typeInto"](selector, value);
+  }
+
+  page() {
+    return globalThis["page"]();
+  }
+
+  click(selector: string): string | undefined {
+    return globalThis["click"](selector);
+  }
+
+  screencast(opts: ScreencastOptions, page: string) {
+    return globalThis["screencast"](
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path,
+      },
+      page,
+      this.testResourceConfiguration.name
+    );
+  }
+
+  screencastStop(p: string) {
+    return globalThis["screencastStop"](p);
+  }
+
+  customScreenShot(opts: ScreencastOptions, page: string) {
+    return globalThis["customScreenShot"](
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path,
+      },
+      page,
+      this.testResourceConfiguration.name
+    );
+  }
+
+  existsSync(destFolder: string): Promise<boolean> {
+    return globalThis["existsSync"](
+      this.testResourceConfiguration.fs + "/" + destFolder
+    );
+  }
+
+  mkdirSync() {
+    return globalThis["mkdirSync"](this.testResourceConfiguration.fs + "/");
+  }
+
+  write(uid: number, contents: string) {
+    return globalThis["write"](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(uid: number) {
+    return globalThis["end"](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): any {
+    // return puppeteer.connect(options).then((b) => {
+    //   this.browser = b;
+    // });
+  }
+}

package/src/PM/web.ts

@@ -1,32 +1,36 @@
 import { PassThrough } from "stream";
 
-import { ITLog, ITTestResourceConfiguration } from "../lib";
-
-import { PM } from "./index.js";
 import { ScreencastOptions, ScreenshotOptions } from "puppeteer-core";
-import { CdpPage } from "puppeteer-core/lib/esm/puppeteer";
+import { CdpPage, Page } from "puppeteer-core/lib/esm/puppeteer";
 
-type PuppetMasterServer = Record<string, Promise<any>>;
+import { ITLog, ITTestResourceConfiguration } from "../lib";
 
-export class PM_Web extends PM {
-  server: PuppetMasterServer;
+export class PM_Web {
+  testResourceConfiguration: ITTestResourceConfiguration;
 
   constructor(t: ITTestResourceConfiguration) {
-    super();
-    this.server = {};
     this.testResourceConfiguration = t;
   }
 
+  start(): Promise<void> {
+    return new Promise((r) => r());
+  }
+
+  stop(): Promise<void> {
+    return new Promise((r) => r());
+  }
+
   waitForSelector(p: string, s: string): any {
     return window["waitForSelector"](p, s);
   }
 
-  screencast(opts: ScreencastOptions) {
+  screencast(opts: ScreencastOptions, page: Page) {
     return window["screencast"](
       {
         ...opts,
         path: this.testResourceConfiguration.fs + "/" + opts.path,
       },
+      page.mainFrame()._id,
       this.testResourceConfiguration.name
     );
   }
@@ -78,7 +82,7 @@ export class PM_Web extends PM {
     return window["click"](selector);
   }
 
-  customScreenShot(opts: ScreenshotOptions) {
+  customScreenShot(opts: ScreenshotOptions, page: Page) {
     return window["customScreenShot"](
       {
         ...opts,
@@ -96,8 +100,8 @@ export class PM_Web extends PM {
     return window["mkdirSync"](this.testResourceConfiguration.fs + "/");
   }
 
-  write(writeObject: { uid: number }, contents: string) {
-    return window["write"](writeObject.uid, contents);
+  write(uid: number, contents: string): Promise<boolean> {
+    return window["write"](uid, contents);
   }
 
   writeFileSync(filepath: string, contents: string) {
@@ -115,8 +119,8 @@ export class PM_Web extends PM {
     );
   }
 
-  end(writeObject: { uid: number }) {
-    return window["end"](writeObject.uid);
+  end(uid: number): boolean {
+    return window["end"](uid);
   }
 
   customclose() {
@@ -131,114 +135,8 @@ export class PM_Web extends PM {
       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) => {
-  //       console.log(json);
-
-  //       return puppeteer
-  //         .connect({
-  //           // "ws://localhost:3234/devtools/browser/01cc60a5-dad6-4b65-a848-09d77764a3fa"
-  //           // browserWSEndpoint: json.webSocketDebuggerUrl,
-  //           browserURL: "http://localhost:3234/json/version",
-  //         })
-  //         .then(async (b) => {
-  //           this.browser = b;
-
-  //           // const t = this.browser.targets()[2];
-  //           // const s = this.browser.defaultBrowserContext().
-  //           console.log(this.browser);
-  //           console.log(this.browser.browserContexts());
-  //           // 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.tsx

@@ -4,10 +4,11 @@ import React, { useEffect, useState } from "react";
 import 'bootstrap/dist/css/bootstrap.min.css';
 import "./style.css"
 
-import { IRunTime, ITestTypes, IBuiltConfig, IConfigV2 } from "./lib";
+
 import { Footer } from "./Footer";
 import { Table } from "react-bootstrap";
-// import { ISummary } from "./utils";
+import { ITestTypes, IRunTime, IBuiltConfig } from "./lib";
+
 
 type ISummary = {
   staticAnalysis: number | "?";
@@ -34,7 +35,9 @@ type ICollations = ICollation[];
 
 const BigBoard = () => {
 
-  const projects = JSON.parse(document.getElementById('bigConfig').innerHTML) as string[];
+  const bigConfigElement = document.getElementById('bigConfig');
+  if (!bigConfigElement) throw new Error('bigConfig element not found');
+  const projects = JSON.parse(bigConfigElement.innerHTML) as string[];
   // const projects = Object.keys(bigConfig.projects);
 
   // const [configs, setConfigs] = useState<IBuiltConfig>();
@@ -190,8 +193,8 @@ const BigBoard = () => {
 document.addEventListener("DOMContentLoaded", function () {
   const elem = document.getElementById("root");
   if (elem) {
-    ReactDom.createRoot(elem).render(React.createElement(BigBoard, {}, []));
+    ReactDom.createRoot(elem).render(React.createElement(BigBoard, {}));
   }
 });
 
-console.log("hello BigBoard!")
+console.log("hello BigBoard!")