testeranto 0.82.0 → 0.84.0

package/dist/common/package.json

@@ -0,0 +1,3 @@
+{
+    "type": "commonjs"
+}

package/dist/common/src/Node.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeTesteranto = void 0;
 const core_js_1 = __importDefault(require("./lib/core.js"));
 const index_js_1 = require("./lib/index.js");
 const node_js_1 = require("./PM/node.js");
@@ -18,6 +19,7 @@ class NodeTesteranto extends core_js_1.default {
         return features;
     }
 }
+exports.NodeTesteranto = NodeTesteranto;
 exports.default = async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = index_js_1.defaultTestResourceRequirement) => {
     return new NodeTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
 };

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

@@ -30,11 +30,12 @@ exports.PM_Main = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
+const crypto_1 = __importDefault(require("crypto"));
 const index_js_1 = require("./index.js");
 const utils_js_1 = require("../utils.js");
 const fPaths = [];
 const fileStreams3 = [];
-const files = {}; // = new Set<string>();
+const files = {};
 const screenshots = {};
 class PM_Main extends index_js_1.PM {
     constructor(configs) {
@@ -52,11 +53,9 @@ class PM_Main extends index_js_1.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();
@@ -124,16 +123,7 @@ class PM_Main extends index_js_1.PM {
                     defaultModule
                         .receiveTestResourceConfig(argz)
                         .then(async (features) => {
-                        Object.keys(features)
-                            .reduce(async (mm, lm) => {
-                            const accum = await mm;
-                            const x = await this.configs.featureIngestor(features[lm]);
-                            accum[lm] = x;
-                            return accum;
-                        }, Promise.resolve({}))
-                            .then((x) => {
-                            fs_1.default.writeFileSync(`${destFolder}/features.json`, JSON.stringify(x, null, 2));
-                        });
+                        this.receiveFeatures(features, destFolder);
                     })
                         .catch((e) => {
                         console.log("catch", e);
@@ -160,22 +150,22 @@ class PM_Main extends index_js_1.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;
@@ -250,35 +240,12 @@ class PM_Main extends index_js_1.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;
                 });
             });
         };
@@ -287,13 +254,6 @@ class PM_Main extends index_js_1.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) {
@@ -378,7 +338,7 @@ class PM_Main extends index_js_1.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 {
         return await (await x.default).receiveTestResourceConfig(${webArgz})
       } catch (e) {
@@ -390,13 +350,30 @@ class PM_Main extends index_js_1.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_1.default.dirname(p);
+                    fs_1.default.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_1.default.dirname(p);
                     fs_1.default.mkdirSync(dir, {
@@ -495,24 +472,45 @@ class PM_Main extends index_js_1.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`}`, {});
                 await page
                     .evaluate(evaluation)
                     .then(async (features) => {
-                    Object.keys(features)
-                        .reduce(async (mm, lm) => {
-                        const accum = await mm;
-                        const x = await this.configs.featureIngestor(features[lm]);
-                        accum[lm] = x;
-                        return accum;
-                    }, Promise.resolve({}))
-                        .then((x) => {
-                        fs_1.default.writeFileSync(`${destFolder}/features.json`, JSON.stringify(x, null, 2));
-                    });
+                    this.receiveFeatures(features, destFolder);
                 })
                     .catch((e) => {
                     console.log("evaluation failed.", dest);
@@ -522,11 +520,62 @@ class PM_Main extends index_js_1.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_1.default.relative(process.cwd(), u.pathname)}`;
+                        await fs_1.default.promises.mkdir(path_1.default.dirname(newPath), { recursive: true });
+                        try {
+                            await fs_1.default.unlinkSync(newPath);
+                            // console.log(`Removed existing link at ${newPath}`);
+                        }
+                        catch (error) {
+                            if (error.code !== "ENOENT") {
+                                // throw error;
+                            }
+                        }
+                        fs_1.default.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_1.default.writeFileSync(`${destFolder}/featurePrompt.txt`, features
+                    .map((f) => {
+                    return `/read ${f}`;
+                })
+                    .join("\n"));
+            });
+        };
         this.server = {};
         this.configs = configs;
         this.ports = {};
@@ -597,17 +646,14 @@ class PM_Main extends index_js_1.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_core_1.default.launch(options));
-        return this.browser;
+    customScreenShot(opts) {
+        throw new Error("Method not implemented.");
     }
     end(accessObject) {
         throw new Error("Method not implemented.");
@@ -670,5 +716,62 @@ class PM_Main extends index_js_1.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_core_1.default.launch(options));
+    }
+    ////////////////////////////////////////////////////////////////////////////////
+    shutDown() {
+        console.log("shutting down...");
+        this.shutdownMode = true;
+        this.checkForShutdown();
+    }
 }
 exports.PM_Main = PM_Main;
+async function writeFileAndCreateDir(filePath, data) {
+    const dirPath = path_1.default.dirname(filePath);
+    try {
+        await fs_1.default.promises.mkdir(dirPath, { recursive: true });
+        await fs_1.default.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_1.default.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/common/src/PM/node.js

@@ -6,7 +6,6 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.PM_Node = void 0;
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
-const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
 const index_js_1 = require("./index.js");
 const fPaths = [];
 class PM_Node extends index_js_1.PM {
@@ -15,8 +14,35 @@ class PM_Node extends index_js_1.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);
@@ -79,9 +105,9 @@ class PM_Node extends index_js_1.PM {
     }
     // launch(options?: PuppeteerLaunchOptions): Promise<Browser>;
     startPuppeteer(options) {
-        return puppeteer_core_1.default.connect(options).then((b) => {
-            this.browser = b;
-        });
+        // return puppeteer.connect(options).then((b) => {
+        //   this.browser = b;
+        // });
     }
 }
 exports.PM_Node = PM_Node;

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

@@ -1,10 +1,6 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PM_Web = void 0;
-const puppeteer_core_browser_js_1 = __importDefault(require("puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser.js"));
 const index_js_1 = require("./index.js");
 class PM_Web extends index_js_1.PM {
     constructor(t) {
@@ -12,8 +8,35 @@ class PM_Web extends index_js_1.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);
@@ -79,54 +102,5 @@ class PM_Web extends index_js_1.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_core_browser_js_1.default
-                .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;
-            });
-        });
-    }
 }
 exports.PM_Web = PM_Web;

package/dist/common/src/Project.js

@@ -12,7 +12,6 @@ const glob_1 = require("glob");
 const node_js_1 = __importDefault(require("./esbuildConfigs/node.js"));
 const web_js_1 = __importDefault(require("./esbuildConfigs/web.js"));
 const web_html_js_1 = __importDefault(require("./web.html.js"));
-// var mode: "DEV" | "PROD" = process.argv[2] === "-dev" ? "DEV" : "PROD";
 readline_1.default.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
@@ -74,7 +73,6 @@ class ITProject {
                 .then((x) => fs_1.default.writeFileSync(htmlFilePath, (0, web_html_js_1.default)(jsfilePath, htmlFilePath)));
         })));
         const [nodeEntryPoints, webEntryPoints] = getRunnables(this.config.tests);
-        console.log(`this.getSecondaryEndpointsPoints("web")`, this.getSecondaryEndpointsPoints("web"));
         (0, glob_1.glob)(`./${this.config.outdir}/chunk-*.mjs`, {
             ignore: "node_modules/**",
         }).then((chunks) => {
@@ -118,7 +116,6 @@ class ITProject {
     getSecondaryEndpointsPoints(runtime) {
         const meta = (ts, st) => {
             ts.forEach((t) => {
-                console.log("getSecondaryEndpointsPoints", t);
                 if (t[1] === runtime) {
                     st.add(t[0]);
                 }