testeranto 0.81.3 → 0.84.0

package/dist/module/src/Node.js

@@ -1,16 +1,16 @@
 import Testeranto from "./lib/core.js";
 import { defaultTestResourceRequirement, } from "./lib/index.js";
 import { PM_Node } from "./PM/node.js";
-class NodeTesteranto extends Testeranto {
+export class NodeTesteranto extends Testeranto {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
         super(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
     }
     async receiveTestResourceConfig(partialTestResource) {
         const t = JSON.parse(partialTestResource);
-        console.log("receiveTestResourceConfig", t);
         const pm = new PM_Node(t);
-        const { failed, artifacts, logPromise } = await this.testJobs[0].receiveTestResourceConfig(pm);
+        const { failed, artifacts, logPromise, features } = await this.testJobs[0].receiveTestResourceConfig(pm);
         pm.customclose();
+        return features;
     }
 }
 export default async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {

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

@@ -1,11 +1,12 @@
 import fs from "fs";
 import path from "path";
 import puppeteer from "puppeteer-core";
+import crypto from "crypto";
 import { PM } from "./index.js";
 import { destinationOfRuntime } from "../utils.js";
 const fPaths = [];
 const fileStreams3 = [];
-const files = {}; // = new Set<string>();
+const files = {};
 const screenshots = {};
 export class PM_Main extends PM {
     constructor(configs) {
@@ -23,11 +24,9 @@ export class PM_Main extends PM {
             }
         };
         this.register = (src) => {
-            // console.log("register", src);
             this.registry[src] = false;
         };
         this.deregister = (src) => {
-            // console.log("deregister", src, this.shutdownMode);
             this.registry[src] = true;
             if (this.shutdownMode) {
                 this.checkForShutdown();
@@ -94,6 +93,9 @@ export class PM_Main extends PM {
                 return module.default.then((defaultModule) => {
                     defaultModule
                         .receiveTestResourceConfig(argz)
+                        .then(async (features) => {
+                        this.receiveFeatures(features, destFolder);
+                    })
                         .catch((e) => {
                         console.log("catch", e);
                     })
@@ -119,22 +121,22 @@ export class PM_Main extends PM {
                 fs: destFolder,
                 browserWSEndpoint: this.browser.wsEndpoint(),
             });
-            const evaluation = `
-    console.log("importing ${dest}.mjs");
-    import('${dest}.mjs').then(async (x) => {
-      console.log("imported", x.default);
-    })`;
+            // const evaluation = `
+            // console.log("importing ${dest}.mjs");
+            // import('${dest}.mjs').then(async (x) => {
+            //   console.log("imported", x.default);
+            // })`;
             const fileStreams2 = [];
             const doneFileStream2 = [];
             return new Promise((res, rej) => {
                 this.browser
                     .newPage()
                     .then((page) => {
-                    page.on("console", (msg) => {
-                        console.log("web > ", msg.args(), msg.text());
-                        // for (let i = 0; i < msg._args.length; ++i)
-                        //   console.log(`${i}: ${msg._args[i]}`);
-                    });
+                    // page.on("console", (msg) => {
+                    //   console.log("web > ", msg.args(), msg.text());
+                    //   // for (let i = 0; i < msg._args.length; ++i)
+                    //   //   console.log(`${i}: ${msg._args[i]}`);
+                    // });
                     page.exposeFunction("custom-screenshot", async (ssOpts, testName) => {
                         // console.log("main.ts browser custom-screenshot", testName);
                         const p = ssOpts.path;
@@ -209,35 +211,12 @@ export class PM_Main extends PM {
                             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) => {
-                    page.on("console", (log) => console.debug(`Log from client: [${log.text()}] `));
                     await page.goto(`file://${`${dest}.html`}`, {});
                     res(page);
-                    // page.evaluate(evaluation).finally(() => {
-                    //   console.log("evaluation failed.", dest);
-                    // });
-                    // return page;
                 });
             });
         };
@@ -246,13 +225,6 @@ export class PM_Main extends PM {
             console.log("launchNodeSideCar", src, dest, d);
             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) {
@@ -337,9 +309,9 @@ export class PM_Main extends PM {
             const evaluation = `
     console.log("importing ${dest}.mjs");
     import('${dest}.mjs').then(async (x) => {
-      console.log("imported", x.default);
+      console.log("imported", (await x.default));
       try {
-        await (await x.default).receiveTestResourceConfig(${webArgz})
+        return await (await x.default).receiveTestResourceConfig(${webArgz})
       } catch (e) {
         console.log("fail", e)
       }
@@ -349,13 +321,30 @@ export class PM_Main extends PM {
             this.browser
                 .newPage()
                 .then((page) => {
-                page.on("console", (msg) => {
-                    console.log("web > ", msg.args(), msg.text());
-                    // for (let i = 0; i < msg._args.length; ++i)
-                    //   console.log(`${i}: ${msg._args[i]}`);
+                // page.on("console", (msg) => {
+                //   // console.log("web > ", msg.args(), msg.text());
+                // });
+                page.exposeFunction("screencast", async (ssOpts, testName) => {
+                    const p = ssOpts.path;
+                    const dir = path.dirname(p);
+                    fs.mkdirSync(dir, {
+                        recursive: true,
+                    });
+                    if (!files[testName]) {
+                        files[testName] = new Set();
+                    }
+                    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("customScreenShot", async (ssOpts, testName) => {
-                    // console.log("main.ts browser custom-screenshot", testName);
                     const p = ssOpts.path;
                     const dir = path.dirname(p);
                     fs.mkdirSync(dir, {
@@ -454,13 +443,46 @@ export class PM_Main extends PM {
                     // }, 5000);
                     // return page.close();
                 });
+                page.exposeFunction("page", () => {
+                    return page.mainFrame()._id;
+                });
+                page.exposeFunction("click", (sel) => {
+                    return page.click(sel);
+                });
+                page.exposeFunction("focusOn", (sel) => {
+                    return page.focus(sel);
+                });
+                page.exposeFunction("typeInto", async (value) => await page.keyboard.type(value));
+                page.exposeFunction("getValue", (selector) => page.$eval(selector, (input) => input.getAttribute("value")));
+                page.exposeFunction("getAttribute", async (selector, attribute) => {
+                    const attributeValue = await page.$eval(selector, (input) => {
+                        return input.getAttribute(attribute);
+                    });
+                    return attributeValue;
+                });
+                page.exposeFunction("isDisabled", async (selector) => {
+                    const attributeValue = await page.$eval(selector, (input) => {
+                        return input.disabled;
+                    });
+                    return attributeValue;
+                });
+                page.exposeFunction("$", async (selector) => {
+                    const x = page.$(selector);
+                    const y = await x;
+                    return y;
+                });
                 return page;
             })
                 .then(async (page) => {
-                page.on("console", (log) => console.debug(`Log from client: [${log.text()}] `));
+                // page.on("console", (log) =>
+                //   console.debug(`Log from client: [${log.text()}] `)
+                // );
                 await page.goto(`file://${`${dest}.html`}`, {});
-                page
+                await page
                     .evaluate(evaluation)
+                    .then(async (features) => {
+                    this.receiveFeatures(features, destFolder);
+                })
                     .catch((e) => {
                     console.log("evaluation failed.", dest);
                     console.log(e);
@@ -469,11 +491,62 @@ export class PM_Main extends PM {
                     console.log("evaluation complete.", dest);
                     // page.close();
                     this.deregister(t);
-                    // whyIsNodeRunning();
                 });
                 return page;
             });
         };
+        this.receiveFeatures = (features, destFolder) => {
+            console.log("this.receiveFeatures", features);
+            features
+                .reduce(async (mm, featureStringKey) => {
+                const accum = await mm;
+                const isUrl = isValidUrl(featureStringKey);
+                if (isUrl) {
+                    const u = new URL(featureStringKey);
+                    if (u.protocol === "file:") {
+                        const newPath = `${process.cwd()}/docs/features/internal/${path.relative(process.cwd(), u.pathname)}`;
+                        await fs.promises.mkdir(path.dirname(newPath), { recursive: true });
+                        try {
+                            await fs.unlinkSync(newPath);
+                            // console.log(`Removed existing link at ${newPath}`);
+                        }
+                        catch (error) {
+                            if (error.code !== "ENOENT") {
+                                // throw error;
+                            }
+                        }
+                        fs.symlink(u.pathname, newPath, (err) => {
+                            if (err) {
+                                // console.error("Error creating symlink:", err);
+                            }
+                            else {
+                                // console.log("Symlink created successfully");
+                            }
+                        });
+                        accum.push(newPath);
+                    }
+                    else if (u.protocol === "http:" || u.protocol === "https:") {
+                        const newPath = `${process.cwd()}/docs/features/external${u.hostname}${u.pathname}`;
+                        const body = await this.configs.featureIngestor(featureStringKey);
+                        writeFileAndCreateDir(newPath, body);
+                        accum.push(newPath);
+                    }
+                }
+                else {
+                    const newPath = `${process.cwd()}/docs/features/plain/${await sha256(featureStringKey)}`;
+                    writeFileAndCreateDir(newPath, featureStringKey);
+                    accum.push(newPath);
+                }
+                return accum;
+            }, Promise.resolve([]))
+                .then((features) => {
+                fs.writeFileSync(`${destFolder}/featurePrompt.txt`, features
+                    .map((f) => {
+                    return `/read ${f}`;
+                })
+                    .join("\n"));
+            });
+        };
         this.server = {};
         this.configs = configs;
         this.ports = {};
@@ -544,17 +617,14 @@ export class PM_Main extends PM {
             delete files[testName];
         };
     }
-    shutDown() {
-        console.log("shutting down...");
-        this.shutdownMode = true;
-        this.checkForShutdown();
+    $(selector) {
+        throw new Error("Method not implemented.");
     }
-    customScreenShot(opts) {
+    screencast(opts) {
         throw new Error("Method not implemented.");
     }
-    async startPuppeteer(options, destfolder) {
-        this.browser = (await puppeteer.launch(options));
-        return this.browser;
+    customScreenShot(opts) {
+        throw new Error("Method not implemented.");
     }
     end(accessObject) {
         throw new Error("Method not implemented.");
@@ -617,4 +687,61 @@ export class PM_Main extends PM {
     write(accessObject, contents) {
         throw new Error("Method not implemented.");
     }
+    page() {
+        throw new Error("Method not implemented.");
+    }
+    click(selector) {
+        throw new Error("Method not implemented.");
+    }
+    focusOn(selector) {
+        throw new Error("Method not implemented.");
+    }
+    typeInto(value) {
+        throw new Error("Method not implemented.");
+    }
+    getValue(value) {
+        throw new Error("Method not implemented.");
+    }
+    getAttribute(selector, attribute) {
+        throw new Error("Method not implemented.");
+    }
+    isDisabled(selector) {
+        throw new Error("Method not implemented.");
+    }
+    ////////////////////////////////////////////////////////////////////////////////
+    async startPuppeteer(options, destfolder) {
+        this.browser = (await puppeteer.launch(options));
+    }
+    ////////////////////////////////////////////////////////////////////////////////
+    shutDown() {
+        console.log("shutting down...");
+        this.shutdownMode = true;
+        this.checkForShutdown();
+    }
+}
+async function writeFileAndCreateDir(filePath, data) {
+    const dirPath = path.dirname(filePath);
+    try {
+        await fs.promises.mkdir(dirPath, { recursive: true });
+        await fs.promises.writeFile(filePath, data);
+    }
+    catch (error) {
+        console.error(`Error writing file: ${error}`);
+    }
+}
+async function sha256(rawData) {
+    const data = typeof rawData === "object" ? JSON.stringify(rawData) : String(rawData);
+    const msgBuffer = new TextEncoder().encode(data);
+    const hashBuffer = await crypto.subtle.digest("SHA-256", msgBuffer);
+    const hashArray = Array.from(new Uint8Array(hashBuffer));
+    return hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+function isValidUrl(string) {
+    try {
+        new URL(string);
+        return true;
+    }
+    catch (err) {
+        return false;
+    }
 }

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

@@ -1,6 +1,5 @@
 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 {
@@ -9,8 +8,35 @@ export class PM_Node extends PM {
         this.server = {};
         this.testResourceConfiguration = t;
     }
-    customScreenShot(opts, page) {
-        return globalThis["customScreenShot"](opts, page);
+    $(selector) {
+        throw new Error("Method not implemented.");
+    }
+    screencast(opts) {
+        throw new Error("Method not implemented.");
+    }
+    isDisabled(selector) {
+        throw new Error("Method not implemented.");
+    }
+    getAttribute(selector, attribute) {
+        throw new Error("Method not implemented.");
+    }
+    getValue(selector) {
+        throw new Error("Method not implemented.");
+    }
+    focusOn(selector) {
+        throw new Error("Method not implemented.");
+    }
+    typeInto(value) {
+        throw new Error("Method not implemented.");
+    }
+    page() {
+        return globalThis["page"]();
+    }
+    click(selector) {
+        return globalThis["click"](selector);
+    }
+    customScreenShot(opts) {
+        return globalThis["customScreenShot"](opts);
     }
     existsSync(destFolder) {
         return globalThis["existsSync"](this.testResourceConfiguration.fs + "/" + destFolder);
@@ -22,7 +48,6 @@ export class PM_Node extends PM {
         return globalThis["write"](writeObject.uid, contents);
     }
     writeFileSync(filepath, contents) {
-        // console.log("pm_node-writeFileSync", this.testResourceConfiguration);
         return globalThis["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
     }
     createWriteStream(filepath) {
@@ -74,8 +99,8 @@ export class PM_Node extends PM {
     }
     // launch(options?: PuppeteerLaunchOptions): Promise<Browser>;
     startPuppeteer(options) {
-        return puppeteer.connect(options).then((b) => {
-            this.browser = b;
-        });
+        // return puppeteer.connect(options).then((b) => {
+        //   this.browser = b;
+        // });
     }
 }

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

@@ -1,4 +1,3 @@
-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) {
@@ -6,8 +5,35 @@ export class PM_Web extends PM {
         this.server = {};
         this.testResourceConfiguration = t;
     }
+    $(selector) {
+        return window["$"](selector);
+    }
+    screencast(opts) {
+        throw new Error("Method not implemented.");
+    }
+    isDisabled(selector) {
+        return window["isDisabled"](selector);
+    }
+    getAttribute(selector, attribute) {
+        return window["getValue"](selector, attribute);
+    }
+    getValue(selector) {
+        return window["getValue"](selector);
+    }
+    focusOn(selector) {
+        return window["focusOn"](selector);
+    }
+    typeInto(value) {
+        return window["typeInto"](value);
+    }
+    page() {
+        return window["page"]();
+    }
+    click(selector) {
+        return window["click"](selector);
+    }
     customScreenShot(opts) {
-        window["customScreenShot"](opts);
+        return window["customScreenShot"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), this.testResourceConfiguration.name);
     }
     existsSync(destFolder) {
         return window["existsSync"](destFolder);
@@ -73,53 +99,4 @@ export class PM_Web extends PM {
             }));
         };
     }
-    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;
-            });
-        });
-    }
 }

package/dist/module/src/Project.js

@@ -6,7 +6,6 @@ import { glob } from "glob";
 import esbuildNodeConfiger from "./esbuildConfigs/node.js";
 import esbuildWebConfiger from "./esbuildConfigs/web.js";
 import webHtmlFrame from "./web.html.js";
-// var mode: "DEV" | "PROD" = process.argv[2] === "-dev" ? "DEV" : "PROD";
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
@@ -68,7 +67,6 @@ export class ITProject {
                 .then((x) => fs.writeFileSync(htmlFilePath, webHtmlFrame(jsfilePath, htmlFilePath)));
         })));
         const [nodeEntryPoints, webEntryPoints] = getRunnables(this.config.tests);
-        console.log(`this.getSecondaryEndpointsPoints("web")`, this.getSecondaryEndpointsPoints("web"));
         glob(`./${this.config.outdir}/chunk-*.mjs`, {
             ignore: "node_modules/**",
         }).then((chunks) => {
@@ -112,7 +110,6 @@ export class ITProject {
     getSecondaryEndpointsPoints(runtime) {
         const meta = (ts, st) => {
             ts.forEach((t) => {
-                console.log("getSecondaryEndpointsPoints", t);
                 if (t[1] === runtime) {
                     st.add(t[0]);
                 }

package/dist/module/src/Puppeteer.js

@@ -3,14 +3,9 @@ import fs from "fs";
 import watch from "recursive-watch";
 import { PM_Main } from "./PM/main.js";
 import { destinationOfRuntime } from "./utils.js";
-// var mode: "DEV" | "PROD" = process.argv[2] === "-dev" ? "DEV" : "PROD";
-// const node2web: Record<string, string[]> = {};
-// const web2node: Record<string, string[]> = {};
-// const childProcesses: Record<string, "loaded" | "running" | "done"> = {};
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
-// let shutDownMode = false;
 export default async (partialConfig) => {
     const config = Object.assign(Object.assign({}, partialConfig), { buildDir: process.cwd() + "/" + partialConfig.outdir });
     fs.writeFileSync(`${config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, config), { buildDir: process.cwd() + "/" + config.outdir }), null, 2));
@@ -24,9 +19,11 @@ export default async (partialConfig) => {
         headless: true,
         dumpio: true,
         // timeout: 0,
+        devtools: true,
         args: [
-            // "--auto-open-devtools-for-tabs",
-            "--disable-features=IsolateOrigins,site-per-process",
+            "--auto-open-devtools-for-tabs",
+            `--remote-debugging-port=3234`,
+            // "--disable-features=IsolateOrigins,site-per-process",
             "--disable-site-isolation-trials",
             "--allow-insecure-localhost",
             "--allow-file-access-from-files",
@@ -49,18 +46,21 @@ export default async (partialConfig) => {
             // "--single-process",
             // "--unsafely-treat-insecure-origin-as-secure",
             // "--unsafely-treat-insecure-origin-as-secure=ws://192.168.0.101:3234",
-            `--remote-debugging-port=3234`,
             // "--disk-cache-dir=/dev/null",
             // "--disk-cache-size=1",
             // "--start-maximized",
         ],
     }, ".");
-    console.log("\n Puppeteer is running. Press 'q' to quit\n");
+    console.log("\n Puppeteer is running. Press 'q' to shutdown softly. Press 'x' to shutdown forcefully.\n");
     process.stdin.on("keypress", (str, key) => {
         if (key.name === "q") {
             pm.shutDown();
             // process.exit();
         }
+        if (key.name === "x") {
+            // pm.shutDown();
+            process.exit(-1);
+        }
     });
     config.tests.forEach(([test, runtime, tr, sidecars]) => {
         if (runtime === "node") {
@@ -105,46 +105,4 @@ export default async (partialConfig) => {
     else {
         pm.shutDown();
     }
-    // pm.browser.close();
-    // does not work on linux
-    // fs.watch(
-    //   config.buildDir,
-    //   {
-    //     recursive: true,
-    //   },
-    //   (eventType, changedFile) => {
-    //     if (changedFile) {
-    //       config.tests.forEach(([test, runtime, tr, sidecars]) => {
-    //         if (eventType === "change" || eventType === "rename") {
-    //           if (
-    //             changedFile ===
-    //             test
-    //               .replace("./", "node/")
-    //               .split(".")
-    //               .slice(0, -1)
-    //               .concat("mjs")
-    //               .join(".")
-    //           ) {
-    //             pm.launchNode(test, destinationOfRuntime(test, "node", config));
-    //           }
-    //           if (
-    //             changedFile ===
-    //             test
-    //               .replace("./", "web/")
-    //               .split(".")
-    //               .slice(0, -1)
-    //               .concat("mjs")
-    //               .join(".")
-    //           ) {
-    //             pm.launchWeb(
-    //               test,
-    //               destinationOfRuntime(test, "web", config),
-    //               sidecars
-    //             );
-    //           }
-    //         }
-    //       });
-    //     }
-    //   }
-    // );
 };