testeranto 0.129.0 → 0.134.0

package/dist/module/src/PM/node.js

@@ -1,30 +1,44 @@
+/* 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";
 import { PM } from ".";
 const fPaths = [];
 export class PM_Node extends PM {
-    constructor(t) {
+    constructor(t, ipcFile) {
         super();
         this.testResourceConfiguration = t;
+        this.client = net.createConnection(ipcFile, () => {
+            return;
+        });
     }
     start() {
-        return new Promise((res) => {
-            process.on("message", (message) => {
-                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() {
-        throw new Error("Method not implemented.");
+        throw new Error("stop not implemented.");
     }
     send(command, ...argz) {
+        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((res) => {
-            const key = Math.random().toString();
             const myListener = (event) => {
                 const x = JSON.parse(event);
                 if (x.key === key) {
@@ -36,6 +50,12 @@ export class PM_Node extends PM {
             this.client.write(JSON.stringify([command, ...argz, key]));
         });
     }
+    async launchSideCar(n) {
+        return this.send("launchSideCar", n, this.testResourceConfiguration.name);
+    }
+    stopSideCar(n) {
+        return this.send("stopSideCar", n, this.testResourceConfiguration.name);
+    }
     async pages() {
         return this.send("pages", ...arguments);
     }
@@ -53,18 +73,21 @@ export class PM_Node extends PM {
     async newPage() {
         return this.send("newPage");
     }
-    $(selector) {
+    $(selector, page) {
         return this.send("$", ...arguments);
     }
     isDisabled(selector) {
         return this.send("isDisabled", ...arguments);
     }
-    getAttribute(selector, attribute) {
+    getAttribute(selector, attribute, p) {
         return this.send("getAttribute", ...arguments);
     }
-    getValue(selector) {
-        return this.send("getValue", ...arguments);
+    getInnerHtml(selector, p) {
+        return this.send("getInnerHtml", ...arguments);
     }
+    // setValue(selector: string) {
+    //   return this.send("getValue", ...arguments);
+    // }
     focusOn(selector) {
         return this.send("focusOn", ...arguments);
     }
@@ -83,8 +106,10 @@ export class PM_Node extends PM {
     screencastStop(p) {
         return this.send("screencastStop", ...arguments);
     }
-    customScreenShot(opts, page) {
-        return this.send("customScreenShot", Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page, this.testResourceConfiguration.name);
+    customScreenShot(x, y) {
+        const opts = x[0];
+        const page = x[1];
+        return this.send("customScreenShot", Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), this.testResourceConfiguration.name, page);
     }
     async existsSync(destFolder) {
         return await this.send("existsSync", this.testResourceConfiguration.fs + "/" + destFolder);
@@ -96,6 +121,7 @@ export class PM_Node extends PM {
         return await this.send("write", ...arguments);
     }
     async writeFileSync(filepath, contents) {
+        // console.log("mark55");
         return await this.send("writeFileSync", this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
     }
     async createWriteStream(filepath) {
@@ -132,7 +158,6 @@ export class PM_Node extends PM {
                         res();
                     }
                     else {
-                        /* @ts-ignore:next-line */
                         const pipeStream = value;
                         const myFile = fs.createWriteStream(fPath);
                         pipeStream.pipe(myFile);

package/dist/module/src/PM/nodeSidecar.js

@@ -0,0 +1,58 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable prefer-rest-params */
+import net from "net";
+import { PM_sidecar } from "./sidecar";
+const fPaths = [];
+export class PM_Node_Sidecar extends PM_sidecar {
+    constructor(t) {
+        super();
+        this.testResourceConfiguration = t;
+        this.client = {};
+    }
+    start(stopper) {
+        return new Promise((res) => {
+            process.on("message", async (message) => {
+                if (message === "stop") {
+                    console.log("STOP!", stopper.toString());
+                    await stopper();
+                    process.exit();
+                }
+                else if (message.path) {
+                    this.client = net.createConnection(message.path, () => {
+                        res();
+                    });
+                }
+            });
+        });
+    }
+    stop() {
+        return new Promise((resolve) => {
+            if (this.client) {
+                this.client.end(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            callback(Promise.resolve());
+        };
+    }
+    send(command, ...argz) {
+        return new Promise((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/dist/module/src/PM/pure.js

@@ -1,8 +1,16 @@
-import fs from "fs";
-import path from "path";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { PM } from ".";
 const fPaths = [];
 export class PM_Pure extends PM {
+    getInnerHtml(selector, page) {
+        throw new Error("pure.ts getInnHtml not implemented");
+        return Promise.resolve("");
+    }
+    stopSideCar(uid) {
+        throw new Error("pure.ts getInnHtml not implemented");
+        return Promise.resolve(true);
+    }
     constructor(t) {
         super();
         this.server = {};
@@ -14,6 +22,9 @@ export class PM_Pure extends PM {
     stop() {
         return new Promise((r) => r());
     }
+    launchSideCar(n) {
+        return globalThis["launchSideCar"](n, this.testResourceConfiguration.name);
+    }
     pages() {
         return globalThis["pages"]();
     }
@@ -84,47 +95,47 @@ export class PM_Pure extends PM {
         globalThis["customclose"](this.testResourceConfiguration.fs, this.testResourceConfiguration.name);
     }
     testArtiFactoryfileWriter(tLog, callback) {
-        return (fPath, value) => {
-            callback(new Promise((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 = value;
-                        const myFile = fs.createWriteStream(fPath);
-                        pipeStream.pipe(myFile);
-                        pipeStream.on("close", () => {
-                            myFile.close();
-                            res();
-                        });
-                    }
-                });
-            }));
-        };
-    }
-    // launch(options?: PuppeteerLaunchOptions): Promise<Browser>;
-    startPuppeteer(options) {
-        // 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();
+        //           });
+        //         }
+        //       });
+        //     })
+        //   );
+        // };
     }
 }

package/dist/module/src/PM/pureSidecar.js

@@ -0,0 +1,41 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable prefer-rest-params */
+import net from "net";
+import { PM_sidecar } from "./sidecar";
+const fPaths = [];
+export class PM_Pure_Sidecar extends PM_sidecar {
+    constructor(t) {
+        super();
+        this.testResourceConfiguration = t;
+    }
+    start() {
+        return new Promise((res) => {
+            process.on("message", (message) => {
+                if (message.path) {
+                    this.client = net.createConnection(message.path, () => {
+                        // super.start()
+                        res();
+                    });
+                }
+            });
+        });
+    }
+    stop() {
+        throw new Error("stop not implemented.");
+    }
+    send(command, ...argz) {
+        return new Promise((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/dist/module/src/PM/sidecar.js

@@ -0,0 +1,7 @@
+export class PM_sidecar {
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            callback(Promise.resolve());
+        };
+    }
+}

package/dist/module/src/PM/web.js

@@ -1,5 +1,7 @@
-export class PM_Web {
+import { PM } from ".";
+export class PM_Web extends PM {
     constructor(t) {
+        super();
         this.testResourceConfiguration = t;
     }
     start() {
@@ -8,10 +10,22 @@ export class PM_Web {
     stop() {
         return new Promise((r) => r());
     }
+    getInnerHtml(selector, page) {
+        throw new Error("web.ts getInnHtml not implemented");
+    }
+    pages() {
+        throw new Error("Method not implemented.");
+    }
+    stopSideCar(n) {
+        return window["stopSideCar"](n, this.testResourceConfiguration.name);
+    }
+    launchSideCar(n) {
+        return window["launchSideCar"](n, this.testResourceConfiguration.name);
+    }
     waitForSelector(p, s) {
         return window["waitForSelector"](p, s);
     }
-    screencast(opts, page) {
+    screencast(o, p) {
         return window["screencast"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page.mainFrame()._id, this.testResourceConfiguration.name);
     }
     screencastStop(recorder) {
@@ -44,14 +58,18 @@ export class PM_Web {
     typeInto(value) {
         return window["typeInto"](value);
     }
-    page() {
-        return window["page"]();
+    async page(x) {
+        return window["page"](x);
     }
     click(selector) {
         return window["click"](selector);
     }
-    customScreenShot(opts, page) {
-        return window["customScreenShot"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), this.testResourceConfiguration.name);
+    customScreenShot(x, y) {
+        const opts = x[0];
+        const page = x[1];
+        console.log("customScreenShot 2 opts", opts);
+        console.log("customScreenShot 2 page", page);
+        return window["customScreenShot"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), this.testResourceConfiguration.name, page);
     }
     existsSync(destFolder) {
         return window["existsSync"](destFolder);

package/dist/module/src/PM/webSidecar.js

@@ -0,0 +1,40 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable prefer-rest-params */
+import net from "net";
+import { PM_sidecar } from "./sidecar";
+const fPaths = [];
+export class PM_Web_Sidecar extends PM_sidecar {
+    constructor(t) {
+        super();
+        this.testResourceConfiguration = t;
+    }
+    start() {
+        return new Promise((res) => {
+            process.on("message", (message) => {
+                if (message.path) {
+                    this.client = net.createConnection(message.path, () => {
+                        res();
+                    });
+                }
+            });
+        });
+    }
+    stop() {
+        throw new Error("stop not implemented.");
+    }
+    send(command, ...argz) {
+        return new Promise((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]));
+        });
+    }
+}