testeranto 0.84.0 → 0.90.0

package/dist/module/src/Init.js

@@ -1,5 +1,35 @@
 import fs from "fs";
 export default async (partialConfig) => {
     const config = Object.assign(Object.assign({}, partialConfig), { buildDir: process.cwd() + "/" + partialConfig.outdir });
+    try {
+        fs.mkdirSync(`${process.cwd()}/${config.outdir}`);
+    }
+    catch (_a) {
+        // console.log()
+    }
     fs.writeFileSync(`${config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, config), { buildDir: process.cwd() + "/" + config.outdir }), null, 2));
+    try {
+        fs.mkdirSync(`${process.cwd()}/${config.outdir}/node`);
+    }
+    catch (_b) {
+        // console.log()
+    }
+    try {
+        fs.mkdirSync(`${process.cwd()}/${config.outdir}/web`);
+    }
+    catch (_c) {
+        // console.log()
+    }
+    try {
+        fs.mkdirSync(`${process.cwd()}/${config.outdir}/features`);
+    }
+    catch (_d) {
+        // console.log()
+    }
+    try {
+        fs.mkdirSync(`${process.cwd()}/${config.outdir}/ts`);
+    }
+    catch (_e) {
+        // console.log()
+    }
 };

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

@@ -4,8 +4,8 @@ import puppeteer from "puppeteer-core";
 import crypto from "crypto";
 import { PM } from "./index.js";
 import { destinationOfRuntime } from "../utils.js";
-const fPaths = [];
 const fileStreams3 = [];
+const fPaths = [];
 const files = {};
 const screenshots = {};
 export class PM_Main extends PM {
@@ -121,6 +121,7 @@ export class PM_Main extends PM {
                 fs: destFolder,
                 browserWSEndpoint: this.browser.wsEndpoint(),
             });
+            // files[src] = new Set();
             // const evaluation = `
             // console.log("importing ${dest}.mjs");
             // import('${dest}.mjs').then(async (x) => {
@@ -184,9 +185,9 @@ export class PM_Main extends PM {
                     });
                     page.exposeFunction("createWriteStream", (fp, testName) => {
                         const f = fs.createWriteStream(fp);
-                        if (!files[testName]) {
-                            files[testName] = new Set();
-                        }
+                        // if (!files[testName]) {
+                        //   files[testName] = new Set();
+                        // }
                         files[testName].add(fp);
                         const p = new Promise((res, rej) => {
                             res(fp);
@@ -318,6 +319,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`);
             this.browser
                 .newPage()
                 .then((page) => {
@@ -474,9 +477,39 @@ export class PM_Main extends PM {
                 return page;
             })
                 .then(async (page) => {
-                // page.on("console", (log) =>
-                //   console.debug(`Log from client: [${log.text()}] `)
-                // );
+                const close = () => {
+                    console.log("evaluation complete.", dest);
+                    page.off("pageerror");
+                    page.close();
+                    this.deregister(t);
+                    stderrStream.close();
+                    stdoutStream.close();
+                };
+                page.on("pageerror", (err) => {
+                    console.debug(`Error from ${t}: [${err.name}] `);
+                    stderrStream.write(err.name);
+                    if (err.cause) {
+                        console.debug(`Error from ${t} cause: [${err.cause}] `);
+                        stderrStream.write(err.cause);
+                    }
+                    if (err.stack) {
+                        console.debug(`Error from stack ${t}: [${err.stack}] `);
+                        stderrStream.write(err.stack);
+                    }
+                    console.debug(`Error from message ${t}: [${err.message}] `);
+                    stderrStream.write(err.message);
+                    // close();
+                });
+                page.on("console", (log) => {
+                    // console.debug(`Log from ${t}: [${log.text()}] `);
+                    // console.debug(`Log from ${t}: [${JSON.stringify(log.location())}] `);
+                    // console.debug(
+                    //   `Log from ${t}: [${JSON.stringify(log.stackTrace())}] `
+                    // );
+                    stdoutStream.write(log.text());
+                    stdoutStream.write(JSON.stringify(log.location()));
+                    stdoutStream.write(JSON.stringify(log.stackTrace()));
+                });
                 await page.goto(`file://${`${dest}.html`}`, {});
                 await page
                     .evaluate(evaluation)
@@ -488,9 +521,12 @@ export class PM_Main extends PM {
                     console.log(e);
                 })
                     .finally(() => {
-                    console.log("evaluation complete.", dest);
+                    close();
+                    // console.log("evaluation complete.", dest);
                     // page.close();
-                    this.deregister(t);
+                    // this.deregister(t);
+                    // stderrStream.close();
+                    // stdoutStream.close();
                 });
                 return page;
             });

package/dist/module/src/Project.js

@@ -1,3 +1,4 @@
+import { spawn } from "child_process";
 import esbuild from "esbuild";
 import fs from "fs";
 import path from "path";
@@ -9,6 +10,84 @@ import webHtmlFrame from "./web.html.js";
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
+const logContent = [];
+function parseTsErrors() {
+    try {
+        // const logContent = fs.readFileSync(logPath, "utf-8").split("\n");
+        const regex = /(^src(.*?))\(\d*,\d*\): error/gm;
+        const brokenFilesToLines = {};
+        for (let i = 0; i < logContent.length - 1; i++) {
+            let m;
+            while ((m = regex.exec(logContent[i])) !== null) {
+                // This is necessary to avoid infinite loops with zero-width matches
+                if (m.index === regex.lastIndex) {
+                    regex.lastIndex++;
+                }
+                if (!brokenFilesToLines[m[1]]) {
+                    brokenFilesToLines[m[1]] = new Set();
+                }
+                brokenFilesToLines[m[1]].add(i);
+            }
+        }
+        const final = Object.keys(brokenFilesToLines).reduce((mm, lm, ndx) => {
+            mm[lm] = Array.from(brokenFilesToLines[lm]).map((l, ndx3) => {
+                const a = Array.from(brokenFilesToLines[lm]);
+                return Object.keys(a).reduce((mm2, lm2, ndx2) => {
+                    const acc = [];
+                    let j = a[lm2] + 1;
+                    let working = true;
+                    while (j < logContent.length - 1 && working) {
+                        if (!logContent[j].match(regex) &&
+                            working &&
+                            !logContent[j].match(/^..\/(.*?)\(\d*,\d*\)/)) {
+                            acc.push(logContent[j]);
+                        }
+                        else {
+                            working = false;
+                        }
+                        j++;
+                    }
+                    mm2[lm] = [logContent[l], ...acc];
+                    return mm2;
+                }, {})[lm];
+            });
+            return mm;
+        }, {});
+        Object.keys(final).forEach((k) => {
+            fs.mkdirSync(`./docs/types/${k.split("/").slice(0, -1).join("/")}`, {
+                recursive: true,
+            });
+            fs.writeFileSync(`./docs/types/${k}.type_errors.txt`, final[k].flat().flat().join("\r\n"));
+        });
+    }
+    catch (error) {
+        console.error("Error reading or parsing the log file:", error);
+        process.exit(1);
+    }
+}
+const compile = () => {
+    return new Promise((resolve, reject) => {
+        const tsc = spawn("tsc", ["-noEmit"]);
+        tsc.stdout.on("data", (data) => {
+            // console.log(`stdout: ${data}`);
+            const lines = data.toString().split("\n");
+            logContent.push(...lines);
+        });
+        tsc.stderr.on("data", (data) => {
+            // console.error(`stderr: ${data}`);
+        });
+        tsc.on("close", (code) => {
+            parseTsErrors();
+            resolve(`tsc process exited with code ${code}`);
+            // if (code !== 0) {
+            //   resolve(`tsc process exited with code ${code}`);
+            //   // reject(`tsc process exited with code ${code}`);
+            // } else {
+            //   resolve({});
+            // }
+        });
+    });
+};
 export class ITProject {
     constructor(configs) {
         this.nodeDone = false;
@@ -52,6 +131,7 @@ export class ITProject {
             }
         });
         fs.writeFileSync(`${this.config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, this.config), { buildDir: process.cwd() + "/" + this.config.outdir }), null, 2));
+        compile();
         Promise.resolve(Promise.all([...this.getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
             const sourceFileSplit = sourceFilePath.split("/");
             const sourceDir = sourceFileSplit.slice(0, -1);

package/dist/module/src/Puppeteer.js

@@ -16,7 +16,7 @@ export default async (partialConfig) => {
         executablePath: 
         // process.env.CHROMIUM_PATH || "/opt/homebrew/bin/chromium",
         "/opt/homebrew/bin/chromium",
-        headless: true,
+        headless: false,
         dumpio: true,
         // timeout: 0,
         devtools: true,

package/dist/module/src/build-tests.js

@@ -0,0 +1,11 @@
+import process from "process";
+import { ITProject } from "./Project";
+if (!process.argv[2]) {
+    console.log("You didn't pass a config file");
+    process.exit(-1);
+}
+else {
+    import(process.cwd() + "/" + process.argv[2]).then((module) => {
+        new ITProject(module.default);
+    });
+}

package/dist/module/src/defaultConfig.js

@@ -0,0 +1,17 @@
+const config = {
+    outdir: "docs",
+    tests: [],
+    debugger: true,
+    clearScreen: false,
+    devMode: true,
+    minify: false,
+    outbase: ".",
+    ports: ["3001"],
+    externals: [],
+    nodePlugins: [],
+    webPlugins: [],
+    featureIngestor: function (s) {
+        throw new Error("Function not implemented.");
+    },
+};
+export default config;

package/dist/module/src/esbuildConfigs/inputFilesPlugin.js

@@ -9,13 +9,15 @@ const register = (entrypoint, sources) => {
     sources.forEach((s) => otherInputs[entrypoint].add(s));
 };
 function tree(meta, key) {
-    return [
-        key,
-        ...meta.inputs[key].imports
-            .filter((x) => x.external !== true)
-            .filter((x) => x.path.split("/")[0] !== "node_modules")
-            .map((f) => f.path),
-    ];
+    console.log("searching metafile for", key);
+    const outputKey = Object.keys(meta.outputs).find((k) => {
+        return meta.outputs[k].entryPoint === key;
+    });
+    if (!outputKey) {
+        console.error("No outputkey found");
+        process.exit(-1);
+    }
+    return Object.keys(meta.outputs[outputKey].inputs).filter((k) => k.startsWith("src"));
 }
 export default (platform, entryPoints) => {
     return {
@@ -34,7 +36,9 @@ export default (platform, entryPoints) => {
                             }
                             const promptPath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `prompt.txt`);
                             const testPaths = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `tests.json`);
-                            const featuresPath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `featurePrompt.txt`); // /read ${featuresPath}
+                            const featuresPath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `featurePrompt.txt`);
+                            const stderrPath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `stderr.log`);
+                            const stdoutPath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `stdout.log`);
                             if (result.metafile) {
                                 const addableFiles = tree(result.metafile, entryPoint.split("/").slice(1).join("/"))
                                     .map((y) => {
@@ -44,23 +48,31 @@ export default (platform, entryPoints) => {
                                     return y;
                                 })
                                     .flat();
+                                const typeErrorFiles = addableFiles.map((t) => `docs/types/${t}.type_errors.txt`);
                                 fs.writeFileSync(promptPath, `
-${[...addableFiles]
+${addableFiles
                                     .map((x) => {
                                     return `/add ${x}`;
                                 })
                                     .join("\n")}
-${[...addableFiles]
+  
+${typeErrorFiles
                                     .map((x) => {
-                                    const f = `docs/ts/${x}.type_errors.txt`;
-                                    if (fs.existsSync(f)) {
-                                        return `/read ${f}`;
-                                    }
+                                    // const f = `docs/types/${x}.type_errors.txt`;
+                                    return `/read ${x}`;
+                                    // if (fs.existsSync(f)) {
+                                    //   return `/read ${f}`;
+                                    // }
                                 })
                                     .join("\n")}
+  
 /read ${testPaths}
+/read ${stdoutPath}
+/read ${stderrPath}
+
 /load ${featuresPath}
-/code Fix the failing tests described in ${testPaths}. Correct any type signature errors. Implement any method which throws "Function not implemented."
+
+/code Fix the failing tests described in ${testPaths}. Correct any type signature errors described in the files [${typeErrorFiles.join(", ")}]. Implement any method which throws "Function not implemented."
 `);
                             }
                         });

package/dist/module/src/init-docs.js

@@ -0,0 +1,15 @@
+import fs from "fs";
+import Init from "../dist/module/src/Init";
+console.log("Initializing a testeranto project");
+if (!process.argv[2]) {
+    console.log("You didn't pass a config file, so I will create one for you.");
+    fs.writeFileSync("testeranto.mts", fs.readFileSync("node_modules/testeranto/src/defaultConfig.ts"));
+    import(process.cwd() + "/" + "testeranto.mts").then((module) => {
+        Init(module.default);
+    });
+}
+else {
+    import(process.cwd() + "/" + process.argv[2]).then((module) => {
+        Init(module.default);
+    });
+}

package/dist/module/src/lib/abstractBase.js

@@ -286,70 +286,6 @@ export class BaseGiven {
                         if (prop === "writeFileSync") {
                             return (fp, contents) => target[prop](`suite-${suiteNdx}/given-${key}/afterEach/${fp}`, contents);
                         }
-                        // if (prop === "browser") {
-                        //   return new Proxy(target[prop], {
-                        //     get(bTarget, bProp, bReceiver) {
-                        //       if (bProp === "pages") {
-                        //         return async () => {
-                        //           return bTarget.pages().then((pages) => {
-                        //             return pages.map((page) => {
-                        //               return new Proxy(page, {
-                        //                 get(pTarget, pProp, pReciever) {
-                        //                   if (pProp === "screenshot") {
-                        //                     return async (x) => {
-                        //                       // console.log(
-                        //                       //   "custom-screenshot-MARK-afterEachProxy",
-                        //                       //   window["custom-screenshot"].toString()
-                        //                       // );
-                        //                       return pm.customScreenShot(
-                        //                         {
-                        //                           ...x,
-                        //                           path:
-                        //                             `${testResourceConfiguration.fs}/suite-${suiteNdx}/given-${key}/afterEach` +
-                        //                             "/" +
-                        //                             x.path,
-                        //                         },
-                        //                         page
-                        //                       );
-                        //                       // return await pTarget[pProp]({
-                        //                       //   ...x,
-                        //                       //   path:
-                        //                       //     `${testResourceConfiguration.fs}/suite-${suiteNdx}/given-${key}/afterEach` +
-                        //                       //     "/" +
-                        //                       //     x.path,
-                        //                       // });
-                        //                     };
-                        //                   } else if (pProp === "mainFrame") {
-                        //                     return () => pTarget[pProp]();
-                        //                     // return target[pProp];
-                        //                     // return Reflect.get(...arguments);
-                        //                   } else if (pProp === "exposeFunction") {
-                        //                     // return Reflect.get(target, prop, receiver);
-                        //                     return (...a) => pTarget[pProp](...a);
-                        //                     // return target[pProp];
-                        //                   } else if (pProp === "removeExposedFunction") {
-                        //                     // return Reflect.get(target, prop, receiver);
-                        //                     return pTarget[pProp].bind(pTarget);
-                        //                     // return target[pProp];
-                        //                   }
-                        //                   // else if (pProp === "#frameManager") {
-                        //                   //   return () => target[pProp](...arguments);
-                        //                   // }
-                        //                   else {
-                        //                     return Reflect.get(...arguments);
-                        //                   }
-                        //                 },
-                        //               });
-                        //             });
-                        //           });
-                        //           // return (await target.pages()).map((page) => {
-                        //           //   return new Proxy(page, handler2);
-                        //           // });
-                        //         };
-                        //       }
-                        //     },
-                        //   });
-                        // }
                         return Reflect.get(...arguments);
                     },
                 });

package/dist/module/src/lib/core.js

@@ -37,9 +37,11 @@ export default class Testeranto extends ClassBuilder {
             }
         }, class Given extends BaseGiven {
             async givenThat(subject, testResource, artifactory, initializer, pm) {
-                return fullTestInterface.beforeEach(subject, initializer, (fPath, value) => 
-                // TODO does not work?
-                artifactory(`beforeEach/${fPath}`, value), testResource, this.initialValues, pm);
+                return fullTestInterface.beforeEach(subject, initializer, 
+                // (fPath: string, value: unknown) =>
+                //   // TODO does not work?
+                //   artifactory(`beforeEach/${fPath}`, value),
+                testResource, this.initialValues, pm);
             }
             afterEach(store, key, artifactory, pm) {
                 return new Promise((res) => res(fullTestInterface.afterEach(store, key, (fPath, value) => artifactory(`after/${fPath}`, value), pm)));

package/dist/module/src/run-tests.js

@@ -0,0 +1,11 @@
+import Puppeteer from "./Puppeteer.js";
+import process from "process";
+if (!process.argv[2]) {
+    console.log("You didn't pass a config file");
+    process.exit(-1);
+}
+else {
+    import(process.cwd() + "/" + process.argv[2]).then((module) => {
+        Puppeteer(module.default);
+    });
+}