testeranto 0.94.0 → 0.100.0

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

@@ -3,11 +3,22 @@ import path from "path";
 import puppeteer from "puppeteer-core";
 import crypto from "crypto";
 import { PM } from "./index.js";
-import { destinationOfRuntime } from "../utils.js";
 const fileStreams3 = [];
 const fPaths = [];
 const files = {};
+const recorders = {};
 const screenshots = {};
+const red = "\x1b[31m";
+const green = "\x1b[32m";
+const reset = "\x1b[0m"; // Resets to default color
+const statusMessagePretty = (failures, test) => {
+    if (failures === 0) {
+        console.log(green + `${test} completed successfully` + reset);
+    }
+    else {
+        console.log(red + `${test} failed ${failures} times` + reset);
+    }
+};
 export class PM_Main extends PM {
     constructor(configs) {
         super();
@@ -33,7 +44,7 @@ export class PM_Main extends PM {
             }
         };
         this.launchNode = async (src, dest) => {
-            console.log("launchNode", src);
+            console.log("! node", src);
             this.register(src);
             const destFolder = dest.replace(".mjs", "");
             let argz = "";
@@ -80,25 +91,36 @@ export class PM_Main extends PM {
                 console.error("negative port makes no sense", src);
                 process.exit(-1);
             }
-            const builtfile = dest + ".mjs";
+            const builtfile = dest;
             const webSideCares = [];
-            await Promise.all(testConfig[3].map(async (sidecar) => {
-                if (sidecar[1] === "web") {
-                    const s = await this.launchWebSideCar(sidecar[0], destinationOfRuntime(sidecar[0], "web", this.configs), sidecar);
-                    webSideCares.push(s);
-                    return s;
-                }
-                if (sidecar[1] === "node") {
-                    return this.launchNodeSideCar(sidecar[0], destinationOfRuntime(sidecar[0], "node", this.configs), sidecar);
-                }
-            }));
+            // await Promise.all(
+            //   testConfig[3].map(async (sidecar) => {
+            //     if (sidecar[1] === "web") {
+            //       const s = await this.launchWebSideCar(
+            //         sidecar[0],
+            //         destinationOfRuntime(sidecar[0], "web", this.configs),
+            //         sidecar
+            //       );
+            //       webSideCares.push(s);
+            //       return s;
+            //     }
+            //     if (sidecar[1] === "node") {
+            //       return this.launchNodeSideCar(
+            //         sidecar[0],
+            //         destinationOfRuntime(sidecar[0], "node", this.configs),
+            //         sidecar
+            //       );
+            //     }
+            //   })
+            // );
             this.server[builtfile] = await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
                 return module.default.then((defaultModule) => {
                     defaultModule
                         .receiveTestResourceConfig(argz)
                         .then(async ({ features, failed }) => {
-                        this.receiveFeatures(features, destFolder);
-                        console.log(`${src} completed with ${failed} errors`);
+                        this.receiveFeatures(features, destFolder, src);
+                        // console.log(`${src} completed with ${failed} errors`);
+                        statusMessagePretty(failed, src);
                     })
                         .catch((e) => {
                         console.log(`${src} errored with`, e);
@@ -294,14 +316,18 @@ export class PM_Main extends PM {
                 }
             }
         };
-        this.launchWeb = (t, dest, sidecars) => {
-            console.log("launchWeb", t, dest);
+        this.launchWeb = (t, dest) => {
+            console.log("! web", t);
             this.register(t);
-            sidecars.map((sidecar) => {
-                if (sidecar[1] === "node") {
-                    return this.launchNodeSideCar(sidecar[0], destinationOfRuntime(sidecar[0], "node", this.configs), sidecar);
-                }
-            });
+            // sidecars.map((sidecar) => {
+            //   if (sidecar[1] === "node") {
+            //     return this.launchNodeSideCar(
+            //       sidecar[0],
+            //       destinationOfRuntime(sidecar[0], "node", this.configs),
+            //       sidecar
+            //     );
+            //   }
+            // });
             const destFolder = dest.replace(".mjs", "");
             const webArgz = JSON.stringify({
                 name: dest,
@@ -309,9 +335,10 @@ export class PM_Main extends PM {
                 fs: destFolder,
                 browserWSEndpoint: this.browser.wsEndpoint(),
             });
+            const d = `${dest}?cacheBust=${Date.now()}`;
             const evaluation = `
-    console.log("importing ${dest}.mjs");
-    import('${dest}.mjs').then(async (x) => {
+    console.log("importing ${d}");
+    import('${d}').then(async (x) => {
       console.log("imported", (await x.default));
       try {
         return await (await x.default).receiveTestResourceConfig(${webArgz})
@@ -321,8 +348,8 @@ export class PM_Main extends PM {
     })`;
             const fileStreams2 = [];
             const doneFileStream2 = [];
-            const stdoutStream = fs.createWriteStream(`${dest}/stdout.log`);
-            const stderrStream = fs.createWriteStream(`${dest}/stderr.log`);
+            const stdoutStream = fs.createWriteStream(`${destFolder}/stdout.log`);
+            const stderrStream = fs.createWriteStream(`${destFolder}/stderr.log`);
             this.browser
                 .newPage()
                 .then((page) => {
@@ -486,7 +513,7 @@ export class PM_Main extends PM {
                         files[t] = new Set();
                     }
                     // files[t].add(filepath);
-                    fs.writeFileSync(dest + "/manifest.json", JSON.stringify(Array.from(files[t])));
+                    fs.writeFileSync(destFolder + "/manifest.json", JSON.stringify(Array.from(files[t])));
                     delete files[t];
                     Promise.all(screenshots[t] || []).then(() => {
                         delete screenshots[t];
@@ -521,12 +548,13 @@ export class PM_Main extends PM {
                     stdoutStream.write(JSON.stringify(log.location()));
                     stdoutStream.write(JSON.stringify(log.stackTrace()));
                 });
-                await page.goto(`file://${`${dest}.html`}`, {});
+                await page.goto(`file://${`${destFolder}.html`}`, {});
                 await page
                     .evaluate(evaluation)
                     .then(async ({ failed, features }) => {
-                    this.receiveFeatures(features, destFolder);
-                    console.log(`${t} completed with ${failed} errors`);
+                    this.receiveFeatures(features, destFolder, t);
+                    // console.log(`${t} completed with ${failed} errors`);
+                    statusMessagePretty(failed, t);
                 })
                     .catch((e) => {
                     console.log(`${t} errored with`, e);
@@ -537,7 +565,8 @@ export class PM_Main extends PM {
                 return page;
             });
         };
-        this.receiveFeatures = (features, destFolder) => {
+        this.receiveFeatures = (features, destFolder, srcTest) => {
+            const featureDestination = path.resolve(process.cwd(), "docs", "features", "strings", srcTest.split(".").slice(0, -1).join(".") + ".features.txt");
             features
                 .reduce(async (mm, featureStringKey) => {
                 const accum = await mm;
@@ -564,24 +593,33 @@ export class PM_Main extends PM {
                                 // console.log("Symlink created successfully");
                             }
                         });
-                        accum.push(newPath);
+                        accum.files.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);
+                        accum.files.push(newPath);
                     }
                 }
                 else {
-                    const newPath = `${process.cwd()}/docs/features/plain/${await sha256(featureStringKey)}`;
-                    writeFileAndCreateDir(newPath, featureStringKey);
-                    accum.push(newPath);
+                    await fs.promises.mkdir(path.dirname(featureDestination), {
+                        recursive: true,
+                    });
+                    // const newPath = `${process.cwd()}/docs/features/plain/${await sha256(
+                    //   featureStringKey
+                    // )}`;
+                    // writeFileAndCreateDir(
+                    //   `${featureDestination}/${await sha256(featureStringKey)}`,
+                    //   featureStringKey
+                    // );
+                    accum.strings.push(featureStringKey);
                 }
                 return accum;
-            }, Promise.resolve([]))
-                .then((features) => {
-                fs.writeFileSync(`${destFolder}/featurePrompt.txt`, features
+            }, Promise.resolve({ files: [], strings: [] }))
+                .then(({ files, strings }) => {
+                // writeFileAndCreateDir(`${featureDestination}`, JSON.stringify(strings));
+                fs.writeFileSync(`${destFolder}/featurePrompt.txt`, files
                     .map((f) => {
                     return `/read ${f}`;
                 })
@@ -595,6 +633,33 @@ export class PM_Main extends PM {
         this.configs.ports.forEach((element) => {
             this.ports[element] = "true"; // set ports as open
         });
+        globalThis["waitForSelector"] = async (pageKey, sel) => {
+            console.log("waitForSelector", pageKey, sel);
+            const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageKey);
+            await (page === null || page === void 0 ? void 0 : page.waitForSelector(sel));
+        };
+        globalThis["screencastStop"] = async (path) => {
+            return recorders[path].stop();
+        };
+        globalThis["closePage"] = async (pageKey) => {
+            const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageKey);
+            return page.close();
+        };
+        // globalThis["closePage"] = (p) => {
+        //   console.log("closePage", p);
+        //   return p.close();
+        // };
+        globalThis["goto"] = async (pageKey, url) => {
+            const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageKey);
+            await (page === null || page === void 0 ? void 0 : page.goto(url));
+            return;
+        };
+        globalThis["newPage"] = () => {
+            return this.browser.newPage();
+        };
+        globalThis["pages"] = () => {
+            return this.browser.pages();
+        };
         globalThis["mkdirSync"] = (fp) => {
             if (!fs.existsSync(fp)) {
                 return fs.mkdirSync(fp, {
@@ -634,7 +699,31 @@ export class PM_Main extends PM {
         globalThis["end"] = (uid) => {
             fileStreams3[uid].end();
         };
-        globalThis["customScreenShot"] = async (opts, page) => {
+        // async (ssOpts: ScreenshotOptions, testName: string) => {
+        //   const p = ssOpts.path as string;
+        //   const dir = path.dirname(p);
+        //   fs.mkdirSync(dir, {
+        //     recursive: true,
+        //   });
+        //   if (!files[testName]) {
+        //     files[testName] = new Set();
+        //   }
+        //   files[testName].add(ssOpts.path as string);
+        //   const sPromise = page.screenshot({
+        //     ...ssOpts,
+        //     path: p,
+        //   });
+        //   if (!screenshots[testName]) {
+        //     screenshots[testName] = [];
+        //   }
+        //   screenshots[testName].push(sPromise);
+        //   // sPromise.then(())
+        //   await sPromise;
+        //   return sPromise;
+        //   // page.evaluate(`window["screenshot done"]`);
+        // };
+        globalThis["customScreenShot"] = async (opts, pageKey, testName) => {
+            const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageKey);
             const p = opts.path;
             const dir = path.dirname(p);
             fs.mkdirSync(dir, {
@@ -652,6 +741,17 @@ export class PM_Main extends PM {
             await sPromise;
             return sPromise;
         };
+        globalThis["screencast"] = async (opts, pageKey) => {
+            const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageKey);
+            const p = opts.path;
+            const dir = path.dirname(p);
+            fs.mkdirSync(dir, {
+                recursive: true,
+            });
+            const recorder = await (page === null || page === void 0 ? void 0 : page.screencast(Object.assign(Object.assign({}, opts), { path: p })));
+            recorders[opts.path] = recorder;
+            return opts.path;
+        };
         // globalThis["customclose"] = (p: string, testName: string) => {
         //   if (!files[testName]) {
         //     files[testName] = new Set();
@@ -663,13 +763,28 @@ export class PM_Main extends PM {
         //   delete files[testName];
         // };
     }
+    customclose() {
+        throw new Error("Method not implemented.");
+    }
+    waitForSelector(p, s) {
+        throw new Error("Method not implemented.");
+    }
+    closePage(p) {
+        throw new Error("Method not implemented.");
+    }
+    newPage() {
+        throw new Error("Method not implemented.");
+    }
+    goto(p, url) {
+        throw new Error("Method not implemented.");
+    }
     $(selector) {
         throw new Error("Method not implemented.");
     }
     screencast(opts) {
         throw new Error("Method not implemented.");
     }
-    customScreenShot(opts) {
+    customScreenShot(opts, cdpPage) {
         throw new Error("Method not implemented.");
     }
     end(accessObject) {
@@ -754,6 +869,9 @@ export class PM_Main extends PM {
     isDisabled(selector) {
         throw new Error("Method not implemented.");
     }
+    screencastStop(s) {
+        throw new Error("Method not implemented.");
+    }
     ////////////////////////////////////////////////////////////////////////////////
     async startPuppeteer(options, destfolder) {
         this.browser = (await puppeteer.launch(options));
@@ -769,7 +887,7 @@ async function writeFileAndCreateDir(filePath, data) {
     const dirPath = path.dirname(filePath);
     try {
         await fs.promises.mkdir(dirPath, { recursive: true });
-        await fs.promises.writeFile(filePath, data);
+        await fs.appendFileSync(filePath, data);
     }
     catch (error) {
         console.error(`Error writing file: ${error}`);

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

@@ -8,10 +8,19 @@ export class PM_Node extends PM {
         this.server = {};
         this.testResourceConfiguration = t;
     }
-    $(selector) {
-        throw new Error("Method not implemented.");
+    waitForSelector(p, s) {
+        return globalThis["waitForSelector"](p, s);
+    }
+    closePage(p) {
+        return globalThis["closePage"](p);
+    }
+    goto(cdpPage, url) {
+        return globalThis["goto"](cdpPage.mainFrame()._id, url);
     }
-    screencast(opts) {
+    newPage() {
+        return globalThis["newPage"]();
+    }
+    $(selector) {
         throw new Error("Method not implemented.");
     }
     isDisabled(selector) {
@@ -35,8 +44,14 @@ export class PM_Node extends PM {
     click(selector) {
         return globalThis["click"](selector);
     }
-    customScreenShot(opts) {
-        return globalThis["customScreenShot"](opts);
+    screencast(opts, page) {
+        return globalThis["screencast"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page.mainFrame()._id, this.testResourceConfiguration.name);
+    }
+    screencastStop(p) {
+        return globalThis["screencastStop"](p);
+    }
+    customScreenShot(opts, cdpPage) {
+        return globalThis["customScreenShot"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), cdpPage.mainFrame()._id, this.testResourceConfiguration.name);
     }
     existsSync(destFolder) {
         return globalThis["existsSync"](this.testResourceConfiguration.fs + "/" + destFolder);

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

@@ -5,11 +5,26 @@ export class PM_Web extends PM {
         this.server = {};
         this.testResourceConfiguration = t;
     }
-    $(selector) {
-        return window["$"](selector);
+    waitForSelector(p, s) {
+        return window["waitForSelector"](p, s);
     }
     screencast(opts) {
-        throw new Error("Method not implemented.");
+        return window["screencast"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), this.testResourceConfiguration.name);
+    }
+    screencastStop(recorder) {
+        return window["screencastStop"](recorder);
+    }
+    closePage(p) {
+        return window["closePage"](p);
+    }
+    goto(p, url) {
+        return window["goto"](p, url);
+    }
+    newPage() {
+        return window["newPage"]();
+    }
+    $(selector) {
+        return window["$"](selector);
     }
     isDisabled(selector) {
         return window["isDisabled"](selector);
@@ -38,7 +53,7 @@ export class PM_Web extends PM {
     existsSync(destFolder) {
         return window["existsSync"](destFolder);
     }
-    mkdirSync() {
+    mkdirSync(x) {
         return window["mkdirSync"](this.testResourceConfiguration.fs + "/");
     }
     write(writeObject, contents) {

package/dist/module/src/SubPackages/react/jsx/node.js

@@ -1,10 +1,5 @@
 import Testeranto from "../../../Node.js";
 import { testInterface as baseInterface, } from "./index.js";
 export default (testImplementations, testSpecifications, testInput, testInterface = baseInterface) => {
-    return Testeranto(testInput, testSpecifications, testImplementations, testInterface
-    // {
-    //   ...baseInterface,
-    //   ...testInterface,
-    // }
-    );
+    return Testeranto(testInput, testSpecifications, testImplementations, testInterface);
 };