testeranto 0.70.0 → 0.73.0

package/dist/module/Node.js

@@ -1,42 +1,22 @@
-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(
+    // t: ITestJob,
+    partialTestResource) {
+        console.log("receiveTestResourceConfig!!", this.testJobs[0].receiveTestResourceConfig);
+        const t = JSON.parse(partialTestResource);
+        const pm = new PM_Node(t);
+        const { failed, artifacts, logPromise } = await this.testJobs[0].receiveTestResourceConfig(pm);
+        console.log("test is done, awaiting test result write to fs");
+        pm.customclose();
+        // Promise.all([...artifacts, logPromise]).then(async () => {
+        //   // process.exit((await failed) ? 1 : 0);
+        // });
     }
 }
 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,331 @@
+import fs from "fs";
+import path from "path";
+import puppeteer from "puppeteer-core";
+import { PM } from "./index.js";
+const fPaths = [];
+const fileStreams3 = [];
+const screenshots3 = [];
+const doneFileStream3 = [];
+export class PM_Main extends PM {
+    // testResourceConfiguration: ITTestResourceConfiguration;
+    constructor(configs
+    // testResourceConfig: ITTestResourceConfiguration
+    ) {
+        super();
+        this.launchNode = async (src, dest) => {
+            console.log("launchNode", src);
+            // childProcesses[src] = "running";
+            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];
+            console.log("mark22 testConfigResource", testConfigResource);
+            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 testResourceConfiguration = this.testResourceConfiguration;
+            // childProcesses[t] = "running";
+            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 = [];
+            const doneFileStream2 = [];
+            this.browser
+                .newPage()
+                .then((page) => {
+                page.exposeFunction("custom-screenshot", async (ssOpts) => {
+                    const p = ssOpts.path;
+                    console.log("custom-screenshot", ssOpts);
+                    const dir = path.dirname(p);
+                    console.log("dir", dir);
+                    fs.mkdirSync(dir, {
+                        recursive: true,
+                    });
+                    return page.screenshot(Object.assign(Object.assign({}, ssOpts), { path: p }));
+                    // screenshots.push(
+                    //   page.screenshot({
+                    //     ...ssOpts,
+                    //     path: ssOpts.path,
+                    //   })
+                    // );
+                    // const sPromise = page.screenshot({
+                    //   ...ssOpts,
+                    //   path: p,
+                    // });
+                    // await sPromise;
+                    // page.evaluate(`window["screenshot done"]`);
+                });
+                page.exposeFunction("writeFileSync", (fp, contents) => {
+                    console.log("writeFileSync", fp);
+                    // Create directories if they don't exist
+                    const dir = path.dirname(fp);
+                    console.log("dir", dir);
+                    fs.mkdirSync(dir, {
+                        recursive: true,
+                    });
+                    // return fs.writeFileSync(fp, contents);
+                    const p = new Promise(async (res, rej) => {
+                        fs.writeFileSync(fp, contents);
+                        res(fp);
+                    });
+                    doneFileStream2.push(p);
+                    return p;
+                });
+                page.exposeFunction("existsSync", (fp, contents) => {
+                    return fs.existsSync(fp);
+                });
+                page.exposeFunction("mkdirSync", (fp) => {
+                    console.log("mkdirsync", fp);
+                    if (!fs.existsSync(fp)) {
+                        return fs.mkdirSync(fp, {
+                            recursive: true,
+                        });
+                    }
+                    return false;
+                });
+                page.exposeFunction("createWriteStream", (fp) => {
+                    const f = fs.createWriteStream(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", () => {
+                    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();
+                });
+                return page;
+            })
+                .then(async (page) => {
+                await page.goto(`file://${`${dest}.html`}`, {
+                // waitUntil: "load",
+                // timeout: 0,
+                });
+                page.evaluate(evaluation).finally(() => {
+                    console.log("evaluation failed.", dest);
+                });
+                return page;
+            })
+                .then((page) => {
+                // console.log("qwe", page);
+                // page.close();
+            });
+        };
+        // this.testResourceConfiguration = testResourceConfig;
+        // console.log("mkdirsync4", testResourceConfig);
+        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"] = (fp, contents) => {
+            // Create directories if they don't exist
+            const dir = path.dirname(fp.split("/").slice(0, -1).join("/"));
+            console.log("dir", dir);
+            fs.mkdirSync(dir, {
+                recursive: true,
+            });
+            return fs.writeFileSync(fp, contents);
+        };
+        globalThis["createWriteStream"] = (filepath) => {
+            const f = fs.createWriteStream(filepath);
+            fileStreams3.push(f);
+            return Object.assign(Object.assign({}, JSON.parse(JSON.stringify(f))), { uid: fileStreams3.length - 1 });
+        };
+        globalThis["write"] = (uid, contents) => {
+            console.log("write", uid, contents);
+            // process.exit();
+            fileStreams3[uid].write(contents);
+        };
+        globalThis["end"] = (uid) => {
+            fileStreams3[uid].end();
+        };
+        globalThis["customclose"] = () => {
+            // 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,168 @@
+// import puppeteer from "puppeteer";
+import fs from "fs";
+import path from "path";
+// import puppeteer from "puppeteer-core/lib/esm/puppeteer/puppeteer-core";
+import puppeteer from "puppeteer-core";
+import { PM } from "./index.js";
+const fPaths = [];
+export function addPageBinding(type, name, prefix) {
+    // Depending on the frame loading state either Runtime.evaluate or
+    // Page.addScriptToEvaluateOnNewDocument might succeed. Let's check that we
+    // don't re-wrap Puppeteer's binding.
+    if (globalThis[name]) {
+        return;
+    }
+    // We replace the CDP binding with a Puppeteer binding.
+    Object.assign(globalThis, {
+        [name](...args) {
+            var _a, _b, _c;
+            // This is the Puppeteer binding.
+            const callPuppeteer = globalThis[name];
+            (_a = callPuppeteer.args) !== null && _a !== void 0 ? _a : (callPuppeteer.args = new Map());
+            (_b = callPuppeteer.callbacks) !== null && _b !== void 0 ? _b : (callPuppeteer.callbacks = new Map());
+            const seq = ((_c = callPuppeteer.lastSeq) !== null && _c !== void 0 ? _c : 0) + 1;
+            callPuppeteer.lastSeq = seq;
+            callPuppeteer.args.set(seq, args);
+            // Needs to be the same as CDP_BINDING_PREFIX.
+            globalThis[prefix + name](JSON.stringify({
+                type,
+                name,
+                seq,
+                args,
+                isTrivial: !args.some((value) => {
+                    return value instanceof Node;
+                }),
+            }));
+            return new Promise((resolve, reject) => {
+                callPuppeteer.callbacks.set(seq, {
+                    resolve(value) {
+                        callPuppeteer.args.delete(seq);
+                        resolve(value);
+                    },
+                    reject(value) {
+                        callPuppeteer.args.delete(seq);
+                        reject(value);
+                    },
+                });
+            });
+        },
+    });
+}
+const files = new Set();
+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) {
+        files.add(filepath);
+        return globalThis["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents);
+    }
+    createWriteStream(filepath) {
+        files.add(filepath);
+        return globalThis["createWriteStream"](this.testResourceConfiguration.fs + "/" + filepath);
+    }
+    end(writeObject) {
+        return globalThis["end"](writeObject.uid);
+    }
+    customclose() {
+        console.log("node-customclose");
+        // globalThis["writeFileSync"](
+        //   this.testResourceConfiguration.fs + "/manifest.json",
+        //   // files.entries()
+        //   JSON.stringify(Array.from(files))
+        // ).then(() => {
+        //   globalThis["customclose"]();
+        // });
+    }
+    // write(accessObject: { uid: number; }, contents: string): boolean {
+    //   throw new Error("Method not implemented.");
+    // }
+    // existsSync(destFolder: string): boolean {
+    //   return fs.existsSync(destFolder);
+    // }
+    // async mkdirSync(destFolder: string) {
+    //   if (!fs.existsSync(destFolder)) {
+    //     return fs.mkdirSync(destFolder, { recursive: true });
+    //   }
+    //   return false;
+    // }
+    // writeFileSync(fp: string, contents: string) {
+    //   fs.writeFileSync(fp, contents);
+    // }
+    // createWriteStream(filepath: string): fs.WriteStream {
+    //   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();
+                        });
+                    }
+                });
+            }));
+        };
+    }
+    // launch(options?: PuppeteerLaunchOptions): Promise<Browser>;
+    startPuppeteer(options) {
+        console.log("start1");
+        return puppeteer.connect(options).then((b) => {
+            this.browser = b;
+        });
+        // return new Promise<Browser>((res, rej) => {
+        //   // this.browser = await puppeteer.connect(options);
+        //   // console.log("start2", this.browser);
+        //   // console.log("mark5", this.browser);
+        //   // res(this.browser);
+        // });
+    }
+}
+// class PuppetMasterServer extends AbstractPuppetMaster {
+//   // constructor(...z: []) {
+//   //   super(...z);
+//   // }
+//   // // pages(): Promise<Page[]>;
+//   // pages(): Promise<Page[]> {
+//   //   return new Promise<Page[]>((res, rej) => {
+//   //     res(super.pages());
+//   //   });
+//   // }
+// }