testeranto 0.128.0 → 0.134.0

package/src/PM/node.ts

@@ -1,3 +1,6 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable prefer-rest-params */
 import net from "net";
 import fs from "fs";
 import path from "path";
@@ -15,31 +18,46 @@ export class PM_Node extends PM {
   testResourceConfiguration: ITTestResourceConfiguration;
   client: net.Socket;
 
-  constructor(t: ITTestResourceConfiguration) {
+  constructor(t: ITTestResourceConfiguration, ipcFile: string) {
     super();
     this.testResourceConfiguration = t;
+
+    this.client = net.createConnection(ipcFile, () => {
+      return;
+    });
   }
 
   start(): Promise<void> {
-    return new Promise((res) => {
-      process.on("message", (message: { path?: string }) => {
-        if (message.path) {
-          this.client = net.createConnection(message.path, () => {
-            res();
-          });
-        }
-      });
-    });
+    throw new Error("DEPREFECATED");
+    // console.log("START");
+    // return new Promise((res) => {
+    //   process.on("message", (message: { path?: string }) => {
+    //     console.log("MESSAGE");
+    //     if (message.path) {
+    //       this.client = net.createConnection(message.path, () => {
+    //         res();
+    //       });
+    //     }
+    //   });
+    // });
   }
 
   stop(): Promise<void> {
-    throw new Error("Method not implemented.");
+    throw new Error("stop not implemented.");
   }
 
   send<I>(command: string, ...argz): Promise<I> {
-    return new Promise<I>((res) => {
-      const key = Math.random().toString();
+    const key = Math.random().toString();
+    // console.log("SEND", key, command, ...argz);
+
+    if (!this.client) {
+      console.error(
+        `Tried to send "${command} (${argz})" but the test has not been started and the IPC client is not established. Exiting as failure!`
+      );
+      process.exit(-1);
+    }
 
+    return new Promise<I>((res) => {
       const myListener = (event) => {
         const x = JSON.parse(event);
         if (x.key === key) {
@@ -54,6 +72,24 @@ export class PM_Node extends PM {
     });
   }
 
+  async launchSideCar(
+    n: number
+  ): Promise<[number, ITTestResourceConfiguration]> {
+    return this.send<[number, ITTestResourceConfiguration]>(
+      "launchSideCar",
+      n,
+      this.testResourceConfiguration.name
+    );
+  }
+
+  stopSideCar(n: number): Promise<any> {
+    return this.send<ITTestResourceConfiguration>(
+      "stopSideCar",
+      n,
+      this.testResourceConfiguration.name
+    );
+  }
+
   async pages() {
     return this.send<string[]>("pages", ...arguments);
   }
@@ -76,7 +112,7 @@ export class PM_Node extends PM {
     return this.send<string>("newPage");
   }
 
-  $(selector: string) {
+  $(selector: string, page: string) {
     return this.send("$", ...arguments);
   }
 
@@ -84,14 +120,18 @@ export class PM_Node extends PM {
     return this.send("isDisabled", ...arguments);
   }
 
-  getAttribute(selector: string, attribute: string) {
+  getAttribute(selector: string, attribute: string, p: string) {
     return this.send("getAttribute", ...arguments);
   }
 
-  getValue(selector: string) {
-    return this.send("getValue", ...arguments);
+  getInnerHtml(selector: string, p: string) {
+    return this.send("getInnerHtml", ...arguments);
   }
 
+  // setValue(selector: string) {
+  //   return this.send("getValue", ...arguments);
+  // }
+
   focusOn(selector: string) {
     return this.send("focusOn", ...arguments);
   }
@@ -124,15 +164,19 @@ export class PM_Node extends PM {
     return this.send("screencastStop", ...arguments);
   }
 
-  customScreenShot(opts: ScreencastOptions, page?: string) {
+  customScreenShot(x: ScreencastOptions, y?: string) {
+    const opts = x[0];
+    const page = x[1];
+
     return this.send(
       "customScreenShot",
       {
         ...opts,
         path: this.testResourceConfiguration.fs + "/" + opts.path,
       },
-      page,
-      this.testResourceConfiguration.name
+
+      this.testResourceConfiguration.name,
+      page
     );
   }
 
@@ -152,6 +196,7 @@ export class PM_Node extends PM {
   }
 
   async writeFileSync(filepath: string, contents: string) {
+    // console.log("mark55");
     return await this.send<boolean>(
       "writeFileSync",
       this.testResourceConfiguration.fs + "/" + filepath,
@@ -180,8 +225,8 @@ export class PM_Node extends PM {
     );
   }
 
-  testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise) => void) {
-    return (fPath, value: string | Buffer | PassThrough) => {
+  testArtiFactoryfileWriter(tLog: ITLog, callback: (p: Promise<void>) => void) {
+    return (fPath: string, value: string | Buffer | PassThrough) => {
       callback(
         new Promise<void>((res, rej) => {
           tLog("testArtiFactory =>", fPath);
@@ -216,7 +261,6 @@ export class PM_Node extends PM {
               });
               res();
             } else {
-              /* @ts-ignore:next-line */
               const pipeStream: PassThrough = value;
               const myFile = fs.createWriteStream(fPath);
               pipeStream.pipe(myFile);

package/src/PM/nodeSidecar.ts

@@ -0,0 +1,73 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable prefer-rest-params */
+import net from "net";
+
+import { ITTestResourceConfiguration } from "../lib";
+
+import { PM_sidecar } from "./sidecar";
+
+type IFPaths = string[];
+const fPaths: IFPaths = [];
+
+export class PM_Node_Sidecar extends PM_sidecar {
+  testResourceConfiguration: ITTestResourceConfiguration;
+  client: net.Socket;
+  mockListener?: jest.Mock;
+
+  constructor(t: ITTestResourceConfiguration) {
+    super();
+    this.testResourceConfiguration = t;
+    this.client = {} as net.Socket;
+  }
+
+  start(stopper: () => any): Promise<void> {
+    return new Promise((res) => {
+      process.on("message", async (message: { path: string } | "stop") => {
+        if (message === "stop") {
+          console.log("STOP!", stopper.toString());
+          await stopper();
+          process.exit();
+        } else if (message.path) {
+          this.client = net.createConnection(message.path, () => {
+            res();
+          });
+        }
+      });
+    });
+  }
+
+  stop(): Promise<void> {
+    return new Promise((resolve) => {
+      if (this.client) {
+        this.client.end(() => resolve());
+      } else {
+        resolve();
+      }
+    });
+  }
+
+  testArtiFactoryfileWriter(tLog: ITLog, callback: (p: Promise<void>) => void) {
+    return (fPath: string, value: string | Buffer | PassThrough) => {
+      callback(Promise.resolve());
+    };
+  }
+
+  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]));
+    });
+  }
+}

package/src/PM/pure.ts

@@ -1,5 +1,9 @@
-import fs from "fs";
-import path from "path";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+// 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";
@@ -14,6 +18,15 @@ const fPaths: IFPaths = [];
 type PuppetMasterServer = Record<string, Promise<any>>;
 
 export class PM_Pure extends PM {
+  getInnerHtml(selector: string, page: string): Promise<string> {
+    throw new Error("pure.ts getInnHtml not implemented");
+    return Promise.resolve("");
+  }
+
+  stopSideCar(uid: number): Promise<boolean> {
+    throw new Error("pure.ts getInnHtml not implemented");
+    return Promise.resolve(true);
+  }
   server: PuppetMasterServer;
   testResourceConfiguration: ITTestResourceConfiguration;
 
@@ -31,6 +44,10 @@ export class PM_Pure extends PM {
     return new Promise((r) => r());
   }
 
+  launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]> {
+    return globalThis["launchSideCar"](n, this.testResourceConfiguration.name);
+  }
+
   pages() {
     return globalThis["pages"]();
   }
@@ -150,60 +167,53 @@ export class PM_Pure extends PM {
   }
 
   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;
-    // });
-  }
+    // return (fPath, value: string | Buffer | PassThrough) => {
+    //   callback(
+    //     new Promise<void>((res) => {
+    //       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 {
+    //           const pipeStream: PassThrough = value;
+    //           const myFile = fs.createWriteStream(fPath);
+    //           pipeStream.pipe(myFile);
+    //           pipeStream.on("close", () => {
+    //             myFile.close();
+    //             res();
+    //           });
+    //         }
+    //       });
+    //     })
+    //   );
+    // };
+  }
+
+  // startPuppeteer(options?: any): any {
+  //   // return puppeteer.connect(options).then((b) => {
+  //   //   this.browser = b;
+  //   // });
+  // }
 }

package/src/PM/pureSidecar.ts

@@ -0,0 +1,56 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable prefer-rest-params */
+import net from "net";
+
+import { ITTestResourceConfiguration } from "../lib";
+
+import { PM_sidecar } from "./sidecar";
+
+type IFPaths = string[];
+const fPaths: IFPaths = [];
+
+export class PM_Pure_Sidecar extends PM_sidecar {
+  testResourceConfiguration: ITTestResourceConfiguration;
+  client: net.Socket;
+
+  constructor(t: ITTestResourceConfiguration) {
+    super();
+    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, () => {
+            // super.start()
+            res();
+          });
+        }
+      });
+    });
+  }
+
+  stop(): Promise<void> {
+    throw new Error("stop 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]));
+    });
+  }
+}

package/src/PM/sidecar.ts

@@ -0,0 +1,48 @@
+import { ITTestResourceConfiguration } from "../lib";
+
+import { ITLog } from "../lib";
+
+export abstract class PM_sidecar {
+  testResourceConfiguration: ITTestResourceConfiguration;
+
+  abstract start(stopper: () => any): Promise<void>;
+  abstract stop(): Promise<void>;
+  
+  testArtiFactoryfileWriter(tLog: ITLog, callback: (p: Promise<void>) => void) {
+    return (fPath: string, value: unknown) => {
+      callback(Promise.resolve());
+    };
+  }
+
+  // abstract $(selector: string): any;
+  // abstract click(selector: string): any;
+  // abstract closePage(p): any;
+  // abstract createWriteStream(
+  //   filepath: string,
+  //   testName: string
+  // ): Promise<string>;
+  // abstract customclose();
+  // abstract customScreenShot(opts: object, page?: string): any;
+  // abstract end(uid: number): Promise<boolean>;
+  // abstract existsSync(fp: string): Promise<boolean>;
+  // abstract focusOn(selector: string): any;
+  // abstract getAttribute(selector: string, attribute: string): any;
+  // abstract getValue(value: string): any;
+  // abstract goto(p, url: string): any;
+  // abstract isDisabled(selector: string): Promise<boolean>;
+  // abstract mkdirSync(a: string);
+  // abstract newPage(): Promise<string>;
+  // abstract page(): Promise<string | undefined>;
+  // abstract pages(): Promise<string[]>;
+  // abstract screencast(o: ScreenRecorderOptions, p: Page | string): any;
+  // abstract screencastStop(s: string): any;
+  // abstract typeInto(selector: string, value: string): any;
+  // abstract waitForSelector(p, sel: string);
+  // abstract write(uid: number, contents: string): Promise<boolean>;
+  // abstract writeFileSync(f: string, c: string, t: string): Promise<boolean>;
+
+  // abstract launchSideCar(
+  //   n: number
+  // ): Promise<[number, ITTestResourceConfiguration]>;
+  // abstract stopSideCar(n: number): Promise<any>;
+}

package/src/PM/web.ts

@@ -1,14 +1,24 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { PassThrough } from "stream";
 
-import { ScreencastOptions, ScreenshotOptions } from "puppeteer-core";
-import { CdpPage, Page } from "puppeteer-core/lib/esm/puppeteer";
+import { ScreencastOptions, ScreenshotOptions, Frame } from "puppeteer-core";
+
+declare module "puppeteer-core" {
+  interface Frame {
+    _id: string;
+  }
+}
+import { Page } from "puppeteer-core";
 
 import { ITLog, ITTestResourceConfiguration } from "../lib";
+import { PM } from ".";
 
-export class PM_Web {
+export class PM_Web extends PM {
   testResourceConfiguration: ITTestResourceConfiguration;
 
   constructor(t: ITTestResourceConfiguration) {
+    super();
     this.testResourceConfiguration = t;
   }
 
@@ -20,11 +30,27 @@ export class PM_Web {
     return new Promise((r) => r());
   }
 
+  getInnerHtml(selector: string, page: string) {
+    throw new Error("web.ts getInnHtml not implemented");
+  }
+
+  pages(): Promise<string[]> {
+    throw new Error("Method not implemented.");
+  }
+
+  stopSideCar(n: number): Promise<any> {
+    return window["stopSideCar"](n, this.testResourceConfiguration.name);
+  }
+
+  launchSideCar(n: number): Promise<[number, ITTestResourceConfiguration]> {
+    return window["launchSideCar"](n, this.testResourceConfiguration.name);
+  }
+
   waitForSelector(p: string, s: string): any {
     return window["waitForSelector"](p, s);
   }
 
-  screencast(opts: ScreencastOptions, page: Page) {
+  screencast(o: ScreencastOptions, p: string | Page): Promise<string> {
     return window["screencast"](
       {
         ...opts,
@@ -47,7 +73,7 @@ export class PM_Web {
     return window["goto"](p, url);
   }
 
-  newPage(): CdpPage {
+  newPage() {
     return window["newPage"]();
   }
 
@@ -74,25 +100,30 @@ export class PM_Web {
     return window["typeInto"](value);
   }
 
-  page(): string | undefined {
-    return window["page"]();
+  async page(x?): Promise<string | undefined> {
+    return window["page"](x);
   }
 
   click(selector: string): any {
     return window["click"](selector);
   }
 
-  customScreenShot(opts: ScreenshotOptions, page: Page) {
+  customScreenShot(x: ScreenshotOptions, y: any) {
+    const opts = x[0];
+    const page = x[1];
+    console.log("customScreenShot 2 opts", opts);
+    console.log("customScreenShot 2 page", page);
     return window["customScreenShot"](
       {
         ...opts,
         path: this.testResourceConfiguration.fs + "/" + opts.path,
       },
-      this.testResourceConfiguration.name
+      this.testResourceConfiguration.name,
+      page
     );
   }
 
-  existsSync(destFolder: string): boolean {
+  existsSync(destFolder: string): Promise<boolean> {
     return window["existsSync"](destFolder);
   }
 
@@ -119,7 +150,7 @@ export class PM_Web {
     );
   }
 
-  end(uid: number): boolean {
+  end(uid: number): Promise<boolean> {
     return window["end"](uid);
   }
 

package/src/PM/webSidecar.ts

@@ -0,0 +1,55 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable prefer-rest-params */
+import net from "net";
+
+import { ITTestResourceConfiguration } from "../lib";
+
+import { PM_sidecar } from "./sidecar";
+
+type IFPaths = string[];
+const fPaths: IFPaths = [];
+
+export class PM_Web_Sidecar extends PM_sidecar {
+  testResourceConfiguration: ITTestResourceConfiguration;
+  client: net.Socket;
+
+  constructor(t: ITTestResourceConfiguration) {
+    super();
+    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("stop 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]));
+    });
+  }
+}