testeranto 0.70.0 → 0.74.0

package/dist/module/Node.js

@@ -1,42 +1,15 @@
-import puppeteer from "puppeteer-core";
 import Testeranto from "./lib/core.js";
 import { defaultTestResourceRequirement, } from "./lib/index.js";
-import { NodeWriter } from "./NodeWriter.js";
-import puppeteerConfiger from "./puppeteerConfiger.js";
+import { PM_Node } from "./PM/node.js";
 class NodeTesteranto extends Testeranto {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
-        super(input, testSpecification, testImplementation, testResourceRequirement, NodeWriter, testInterface);
-        if (process.argv[2]) {
-            const testResourceArg = process.argv[2];
-            try {
-                const partialTestResource = JSON.parse(testResourceArg);
-                this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
-            }
-            catch (e) {
-                console.error(e);
-                // process.exit(-1);
-            }
-        }
-        else {
-            // no-op
-        }
+        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
     }
-    async receiveTestResourceConfig(t, partialTestResource) {
-        const browser = await puppeteerConfiger("2999").then(async (json) => {
-            const b = await puppeteer.connect({
-                browserWSEndpoint: json.webSocketDebuggerUrl,
-                defaultViewport: null,
-            });
-            console.log("connected!", b.isConnected());
-            return b;
-        });
-        const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(partialTestResource, {
-            browser,
-            ipc: process.parentPort,
-        });
-        Promise.all([...artifacts, logPromise]).then(async () => {
-            process.exit((await failed) ? 1 : 0);
-        });
+    async receiveTestResourceConfig(partialTestResource) {
+        const t = JSON.parse(partialTestResource);
+        const pm = new PM_Node(t);
+        const { failed, artifacts, logPromise } = await this.testJobs[0].receiveTestResourceConfig(pm);
+        pm.customclose();
     }
 }
 export default async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {

package/dist/module/PM/index.js

@@ -0,0 +1,67 @@
+// import {
+//   Browser,
+//   BrowserContext,
+//   BrowserContextOptions,
+//   DebugInfo,
+//   Page,
+//   PuppeteerNode,
+//   Target,
+// } from "puppeteer-core";
+const fPaths = [];
+export class PM {
+}
+// export class PuppetMasterBrowser extends Browser {
+//   process(): ChildProcess | null {
+//     return super.process();
+//   }
+//   createBrowserContext(
+//     options?: BrowserContextOptions
+//   ): Promise<BrowserContext> {
+//     throw new Error("Method not implemented.");
+//   }
+//   browserContexts(): BrowserContext[] {
+//     throw new Error("Method not implemented.");
+//   }
+//   defaultBrowserContext(): BrowserContext {
+//     throw new Error("Method not implemented.");
+//   }
+//   wsEndpoint(): string {
+//     throw new Error("Method not implemented.");
+//   }
+//   newPage(): Promise<Page> {
+//     throw new Error("Method not implemented.");
+//   }
+//   targets(): Target[] {
+//     throw new Error("Method not implemented.");
+//   }
+//   target(): Target {
+//     throw new Error("Method not implemented.");
+//   }
+//   version(): Promise<string> {
+//     throw new Error("Method not implemented.");
+//   }
+//   userAgent(): Promise<string> {
+//     throw new Error("Method not implemented.");
+//   }
+//   close(): Promise<void> {
+//     throw new Error("Method not implemented.");
+//   }
+//   disconnect(): Promise<void> {
+//     throw new Error("Method not implemented.");
+//   }
+//   get connected(): boolean {
+//     throw new Error("Method not implemented.");
+//   }
+//   get debugInfo(): DebugInfo {
+//     throw new Error("Method not implemented.");
+//   }
+//   constructor(...z: []) {
+//     super(...z);
+//   }
+//   // pages(): Promise<Page[]>;
+//   pages(): Promise<Page[]> {
+//     return new Promise<Page[]>((res, rej) => {
+//       res(super.pages());
+//     });
+//   }
+// }

package/dist/module/PM/main.js

@@ -0,0 +1,340 @@
+import fs from "fs";
+import path from "path";
+import puppeteer from "puppeteer-core";
+import { PM } from "./index.js";
+const fPaths = [];
+const fileStreams3 = [];
+const files = {}; // = new Set<string>();
+const screenshots = {};
+export class PM_Main extends PM {
+    constructor(configs) {
+        super();
+        this.launchNode = async (src, dest) => {
+            console.log("launchNode", src);
+            const destFolder = dest.replace(".mjs", "");
+            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 = [];
+            if (testConfigResource.ports === 0) {
+                argz = JSON.stringify({
+                    scheduled: true,
+                    name: src,
+                    ports: portsToUse,
+                    fs: destFolder,
+                    browserWSEndpoint: this.browser.wsEndpoint(),
+                });
+            }
+            else if (testConfigResource.ports > 0) {
+                const openPorts = Object.entries(this.ports).filter(([portnumber, portopen]) => portopen);
+                if (openPorts.length >= testConfigResource.ports) {
+                    for (let i = 0; i < testConfigResource.ports; i++) {
+                        portsToUse.push(openPorts[i][0]);
+                        this.ports[openPorts[i][0]] = false; // port is now closed
+                    }
+                    argz = JSON.stringify({
+                        scheduled: true,
+                        name: src,
+                        // ports: [3333],
+                        ports: portsToUse,
+                        fs: ".",
+                        browserWSEndpoint: this.browser.wsEndpoint(),
+                    });
+                }
+                else {
+                    this.queue.push(src);
+                    return;
+                }
+            }
+            else {
+                console.error("negative port makes no sense", src);
+                process.exit(-1);
+            }
+            const builtfile = dest + ".mjs";
+            this.server[builtfile] = await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
+                return module.default.then((defaultModule) => {
+                    defaultModule
+                        .receiveTestResourceConfig(argz)
+                        .then((x) => {
+                        console.log("then", x);
+                        return x;
+                    })
+                        .catch((e) => {
+                        console.log("catch", e);
+                    });
+                });
+            });
+            for (let i = 0; i <= portsToUse.length; i++) {
+                this.ports[i] = true; //port is open again
+            }
+        };
+        this.launchWeb = (t, dest) => {
+            console.log("launchWeb", t, dest);
+            const destFolder = dest.replace(".mjs", "");
+            const webArgz = JSON.stringify({
+                name: dest,
+                ports: [].toString(),
+                fs: destFolder,
+                browserWSEndpoint: this.browser.wsEndpoint(),
+            });
+            const evaluation = `import('${dest}.mjs').then(async (x) => {
+      console.log("imported", x, (x.default));
+      try {
+        await (await x.default).receiveTestResourceConfig(${webArgz})
+      } catch (e) {
+        console.log("fail", e)
+      }
+    })`;
+            const fileStreams2 = [];
+            // const screenshots2: Promise<any>[] = [];
+            const doneFileStream2 = [];
+            this.browser
+                .newPage()
+                .then((page) => {
+                page.exposeFunction("custom-screenshot", async (ssOpts, testName) => {
+                    console.log("main.ts browser custom-screenshot", testName);
+                    const p = ssOpts.path;
+                    const dir = path.dirname(p);
+                    fs.mkdirSync(dir, {
+                        recursive: true,
+                    });
+                    files[testName].add(ssOpts.path);
+                    const sPromise = page.screenshot(Object.assign(Object.assign({}, 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("writeFileSync", (fp, contents, testName) => {
+                    const dir = path.dirname(fp);
+                    fs.mkdirSync(dir, {
+                        recursive: true,
+                    });
+                    const p = new Promise(async (res, rej) => {
+                        fs.writeFileSync(fp, contents);
+                        res(fp);
+                    });
+                    doneFileStream2.push(p);
+                    if (!files[testName]) {
+                        files[testName] = new Set();
+                    }
+                    files[testName].add(fp);
+                    return p;
+                });
+                page.exposeFunction("existsSync", (fp, contents) => {
+                    return fs.existsSync(fp);
+                });
+                page.exposeFunction("mkdirSync", (fp) => {
+                    if (!fs.existsSync(fp)) {
+                        return fs.mkdirSync(fp, {
+                            recursive: true,
+                        });
+                    }
+                    return false;
+                });
+                page.exposeFunction("createWriteStream", (fp, testName) => {
+                    const f = fs.createWriteStream(fp);
+                    if (!files[testName]) {
+                        files[testName] = new Set();
+                    }
+                    files[testName].add(fp);
+                    const p = new Promise((res, rej) => {
+                        res(fp);
+                    });
+                    doneFileStream2.push(p);
+                    f.on("close", async () => {
+                        await p;
+                    });
+                    fileStreams2.push(f);
+                    return Object.assign(Object.assign({}, JSON.parse(JSON.stringify(f))), { uid: fileStreams2.length - 1 });
+                });
+                page.exposeFunction("write", async (uid, contents) => {
+                    return fileStreams2[uid].write(contents);
+                });
+                page.exposeFunction("end", async (uid) => {
+                    return fileStreams2[uid].end();
+                });
+                page.exposeFunction("customclose", (p, testName) => {
+                    fs.writeFileSync(p + "/manifest.json", JSON.stringify(Array.from(files[testName])));
+                    delete files[testName];
+                    Promise.all(screenshots[testName] || []).then(() => {
+                        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) => {
+                await page.goto(`file://${`${dest}.html`}`, {});
+                page.evaluate(evaluation).finally(() => {
+                    console.log("evaluation failed.", dest);
+                });
+                return page;
+            });
+        };
+        this.server = {};
+        this.configs = configs;
+        this.ports = {};
+        this.configs.ports.forEach((element) => {
+            this.ports[element] = "true"; // set ports as open
+        });
+        globalThis["mkdirSync"] = (fp) => {
+            if (!fs.existsSync(fp)) {
+                return fs.mkdirSync(fp, {
+                    recursive: true,
+                });
+            }
+            return false;
+        };
+        globalThis["writeFileSync"] = (filepath, contents, testName) => {
+            // Create directories if they don't exist
+            const dir = path.dirname(filepath.split("/").slice(0, -1).join("/"));
+            fs.mkdirSync(dir, {
+                recursive: true,
+            });
+            if (!files[testName]) {
+                files[testName] = new Set();
+            }
+            files[testName].add(filepath);
+            return fs.writeFileSync(filepath, contents);
+        };
+        globalThis["createWriteStream"] = (filepath, testName) => {
+            const f = fs.createWriteStream(filepath);
+            fileStreams3.push(f);
+            // files.add(filepath);
+            if (!files[testName]) {
+                files[testName] = new Set();
+            }
+            files[testName].add(filepath);
+            return Object.assign(Object.assign({}, JSON.parse(JSON.stringify(f))), { uid: fileStreams3.length - 1 });
+        };
+        globalThis["write"] = (uid, contents) => {
+            fileStreams3[uid].write(contents);
+        };
+        globalThis["end"] = (uid) => {
+            fileStreams3[uid].end();
+        };
+        globalThis["customclose"] = (p, testName) => {
+            if (!files[testName]) {
+                files[testName] = new Set();
+            }
+            fs.writeFileSync(p + "/manifest.json", JSON.stringify(Array.from(files[testName])));
+            delete files[testName];
+            // globalThis["writeFileSync"](
+            //   p + "/manifest.json",
+            //   // files.entries()
+            //   JSON.stringify(Array.from(files[testName]))
+            // );
+            // fileStreams3[uid].end();
+        };
+        // page.exposeFunction("customclose", () => {
+        //   console.log("closing doneFileStream2", doneFileStream2);
+        //   // console.log("closing doneFileStream2", doneFileStream2);
+        //   Promise.all([...doneFileStream2, ...screenshots2]).then(() => {
+        //     page.close();
+        //   });
+        //   // page.close();
+        //   // Promise.all(screenshots).then(() => {
+        //   //   page.close();
+        //   // });
+        //   // setTimeout(() => {
+        //   //   console.log("Delayed for 1 second.");
+        //   //   page.close();
+        //   // }, 5000);
+        //   // return page.close();
+        // });
+    }
+    async startPuppeteer(options, destfolder) {
+        this.browser = await puppeteer.launch(options);
+        return this.browser;
+    }
+    end(accessObject) {
+        throw new Error("Method not implemented.");
+    }
+    existsSync(destFolder) {
+        return fs.existsSync(destFolder);
+    }
+    async mkdirSync(fp) {
+        if (!fs.existsSync(fp)) {
+            return fs.mkdirSync(fp, {
+                recursive: true,
+            });
+        }
+        return false;
+    }
+    writeFileSync(fp, contents) {
+        fs.writeFileSync(fp, contents);
+    }
+    createWriteStream(filepath) {
+        return fs.createWriteStream(filepath);
+    }
+    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();
+                        });
+                    }
+                });
+            }));
+        };
+    }
+    write(accessObject, contents) {
+        throw new Error("Method not implemented.");
+    }
+}

package/dist/module/PM/node.js

@@ -0,0 +1,77 @@
+import fs from "fs";
+import path from "path";
+import puppeteer from "puppeteer-core";
+import { PM } from "./index.js";
+const fPaths = [];
+export class PM_Node extends PM {
+    constructor(t) {
+        super();
+        this.server = {};
+        this.testResourceConfiguration = t;
+    }
+    existsSync(destFolder) {
+        return globalThis["existsSync"](this.testResourceConfiguration.fs + "/" + destFolder);
+    }
+    mkdirSync() {
+        return globalThis["mkdirSync"](this.testResourceConfiguration.fs + "/");
+    }
+    write(writeObject, contents) {
+        return globalThis["write"](writeObject.uid, contents);
+    }
+    writeFileSync(filepath, contents) {
+        return globalThis["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
+    }
+    createWriteStream(filepath) {
+        return globalThis["createWriteStream"](this.testResourceConfiguration.fs + "/" + filepath, this.testResourceConfiguration.name);
+    }
+    end(writeObject) {
+        return globalThis["end"](writeObject.uid);
+    }
+    customclose() {
+        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;
+        });
+    }
+}

package/dist/module/PM/web.js

@@ -0,0 +1,122 @@
+import puppeteer from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser.js";
+import { PM } from "./index.js";
+export class PM_Web extends PM {
+    constructor(t) {
+        super();
+        this.server = {};
+        this.testResourceConfiguration = t;
+    }
+    existsSync(destFolder) {
+        return window["existsSync"](destFolder);
+    }
+    mkdirSync() {
+        return window["mkdirSync"](this.testResourceConfiguration.fs + "/");
+    }
+    write(writeObject, contents) {
+        return window["write"](writeObject.uid, contents);
+    }
+    writeFileSync(filepath, contents) {
+        return window["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
+    }
+    createWriteStream(filepath) {
+        return window["createWriteStream"](this.testResourceConfiguration.fs + "/" + filepath, this.testResourceConfiguration.name);
+    }
+    end(writeObject) {
+        return window["end"](writeObject.uid);
+    }
+    customclose() {
+        window["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: PassThrough = value;
+                //     const myFile = fs.createWriteStream(fPath);
+                //     pipeStream.pipe(myFile);
+                //     pipeStream.on("close", () => {
+                //       myFile.close();
+                //       res();
+                //     });
+                //   }
+                // });
+            }));
+        };
+    }
+    startPuppeteer(options, destFolder) {
+        const name = this.testResourceConfiguration.name;
+        return fetch(`http://localhost:3234/json/version`)
+            .then((v) => {
+            return v.json();
+        })
+            .then((json) => {
+            return puppeteer
+                .connect({
+                browserWSEndpoint: json.webSocketDebuggerUrl,
+            })
+                .then((b) => {
+                this.browser = b;
+                const handler2 = {
+                    get(target, prop, receiver) {
+                        if (prop === "screenshot") {
+                            return async (x) => {
+                                return await window["custom-screenshot"](Object.assign(Object.assign({}, 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;
+            });
+        });
+    }
+}