testeranto 0.90.0 → 0.100.0

package/dist/prebuild/{run-tests.mjs → cli2.mjs}

@@ -1,13 +1,11 @@
 import { createRequire } from 'module';const require = createRequire(import.meta.url);
 
-// src/Puppeteer.ts
-import readline from "readline";
-import fs2 from "fs";
-import watch from "recursive-watch";
+// src/cli2.ts
+import { watch } from "fs";
 
 // src/PM/main.ts
 import fs from "fs";
-import path2 from "path";
+import path from "path";
 import puppeteer from "puppeteer-core";
 import crypto from "crypto";
 
@@ -15,17 +13,22 @@ import crypto from "crypto";
 var PM = class {
 };
 
-// src/utils.ts
-import path from "path";
-var destinationOfRuntime = (f, r, configs) => {
-  return path.normalize(`${configs.buildDir}/${r}/${f}`).split(".").slice(0, -1).join(".");
-};
-
 // src/PM/main.ts
 var fileStreams3 = [];
 var fPaths = [];
 var files = {};
+var recorders = {};
 var screenshots = {};
+var red = "\x1B[31m";
+var green = "\x1B[32m";
+var reset = "\x1B[0m";
+var statusMessagePretty = (failures, test) => {
+  if (failures === 0) {
+    console.log(green + `${test} completed successfully` + reset);
+  } else {
+    console.log(red + `${test} failed ${failures} times` + reset);
+  }
+};
 var PM_Main = class extends PM {
   constructor(configs) {
     super();
@@ -50,7 +53,7 @@ var PM_Main = class 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 = "";
@@ -96,32 +99,17 @@ var PM_Main = class extends PM {
         console.error("negative port makes no sense", src);
         process.exit(-1);
       }
-      const builtfile = dest + ".mjs";
-      await Promise.all(
-        testConfig[3].map((sidecar) => {
-          if (sidecar[1] === "web") {
-            return this.launchWebSideCar(
-              sidecar[0],
-              destinationOfRuntime(sidecar[0], "web", this.configs),
-              sidecar
-            );
-          }
-          if (sidecar[1] === "node") {
-            return this.launchNodeSideCar(
-              sidecar[0],
-              destinationOfRuntime(sidecar[0], "node", this.configs),
-              sidecar
-            );
-          }
-        })
-      );
+      const builtfile = dest;
+      const webSideCares = [];
       this.server[builtfile] = await import(`${builtfile}?cacheBust=${Date.now()}`).then((module) => {
         return module.default.then((defaultModule) => {
-          defaultModule.receiveTestResourceConfig(argz).then(async (features) => {
-            this.receiveFeatures(features, destFolder);
+          defaultModule.receiveTestResourceConfig(argz).then(async ({ features, failed }) => {
+            this.receiveFeatures(features, destFolder, src);
+            statusMessagePretty(failed, src);
           }).catch((e) => {
-            console.log("catch", e);
+            console.log(`${src} errored with`, e);
           }).finally(() => {
+            webSideCares.forEach((webSideCar) => webSideCar.close());
             this.deregister(src);
           });
         });
@@ -136,12 +124,6 @@ var PM_Main = class extends PM {
       const d = dest + ".mjs";
       console.log("launchWebSideCar", src, dest, d);
       const destFolder = dest.replace(".mjs", "");
-      const webArgz = JSON.stringify({
-        name: dest,
-        ports: [].toString(),
-        fs: destFolder,
-        browserWSEndpoint: this.browser.wsEndpoint()
-      });
       const fileStreams2 = [];
       const doneFileStream2 = [];
       return new Promise((res, rej) => {
@@ -150,7 +132,7 @@ var PM_Main = class extends PM {
             "custom-screenshot",
             async (ssOpts, testName) => {
               const p = ssOpts.path;
-              const dir = path2.dirname(p);
+              const dir = path.dirname(p);
               fs.mkdirSync(dir, {
                 recursive: true
               });
@@ -170,7 +152,7 @@ var PM_Main = class extends PM {
           page.exposeFunction(
             "writeFileSync",
             (fp, contents, testName) => {
-              const dir = path2.dirname(fp);
+              const dir = path.dirname(fp);
               fs.mkdirSync(dir, {
                 recursive: true
               });
@@ -225,16 +207,6 @@ var PM_Main = class extends PM {
           page.exposeFunction("end", async (uid) => {
             return fileStreams2[uid].end();
           });
-          page.exposeFunction("customclose", (p, testName) => {
-            fs.writeFileSync(
-              p + "/manifest.json",
-              JSON.stringify(Array.from(files[testName]))
-            );
-            delete files[testName];
-            Promise.all(screenshots[testName] || []).then(() => {
-              delete screenshots[testName];
-            });
-          });
           return page;
         }).then(async (page) => {
           await page.goto(`file://${`${dest}.html`}`, {});
@@ -295,18 +267,9 @@ var PM_Main = class 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
-          );
-        }
-      });
       const destFolder = dest.replace(".mjs", "");
       const webArgz = JSON.stringify({
         name: dest,
@@ -314,9 +277,10 @@ var PM_Main = class 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})
@@ -326,14 +290,14 @@ var PM_Main = class 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) => {
         page.exposeFunction(
           "screencast",
           async (ssOpts, testName) => {
             const p = ssOpts.path;
-            const dir = path2.dirname(p);
+            const dir = path.dirname(p);
             fs.mkdirSync(dir, {
               recursive: true
             });
@@ -357,7 +321,7 @@ var PM_Main = class extends PM {
           "customScreenShot",
           async (ssOpts, testName) => {
             const p = ssOpts.path;
-            const dir = path2.dirname(p);
+            const dir = path.dirname(p);
             fs.mkdirSync(dir, {
               recursive: true
             });
@@ -380,20 +344,7 @@ var PM_Main = class extends PM {
         page.exposeFunction(
           "writeFileSync",
           (fp, contents, testName) => {
-            const dir = path2.dirname(fp);
-            fs.mkdirSync(dir, {
-              recursive: true
-            });
-            const p = new Promise(async (res, rej) => {
-              fs.writeFileSync(fp, contents);
-              res(fp);
-            });
-            doneFileStream2.push(p);
-            if (!files[testName]) {
-              files[testName] = /* @__PURE__ */ new Set();
-            }
-            files[testName].add(fp);
-            return p;
+            return globalThis["writeFileSync"](fp, contents, testName);
           }
         );
         page.exposeFunction("existsSync", (fp, contents) => {
@@ -435,16 +386,6 @@ var PM_Main = class extends PM {
         page.exposeFunction("end", async (uid) => {
           return fileStreams2[uid].end();
         });
-        page.exposeFunction("customclose", (p, testName) => {
-          fs.writeFileSync(
-            p + "/manifest.json",
-            JSON.stringify(Array.from(files[testName]))
-          );
-          delete files[testName];
-          Promise.all(screenshots[testName] || []).then(() => {
-            delete screenshots[testName];
-          });
-        });
         page.exposeFunction("page", () => {
           return page.mainFrame()._id;
         });
@@ -488,12 +429,21 @@ var PM_Main = class extends PM {
         return page;
       }).then(async (page) => {
         const close = () => {
-          console.log("evaluation complete.", dest);
-          page.off("pageerror");
-          page.close();
-          this.deregister(t);
-          stderrStream.close();
-          stdoutStream.close();
+          if (!files[t]) {
+            files[t] = /* @__PURE__ */ new Set();
+          }
+          fs.writeFileSync(
+            destFolder + "/manifest.json",
+            JSON.stringify(Array.from(files[t]))
+          );
+          delete files[t];
+          Promise.all(screenshots[t] || []).then(() => {
+            delete screenshots[t];
+            page.close();
+            this.deregister(t);
+            stderrStream.close();
+            stdoutStream.close();
+          });
         };
         page.on("pageerror", (err) => {
           console.debug(`Error from ${t}: [${err.name}] `);
@@ -514,31 +464,37 @@ var PM_Main = class extends PM {
           stdoutStream.write(JSON.stringify(log.location()));
           stdoutStream.write(JSON.stringify(log.stackTrace()));
         });
-        await page.goto(`file://${`${dest}.html`}`, {});
-        await page.evaluate(evaluation).then(async (features) => {
-          this.receiveFeatures(features, destFolder);
+        await page.goto(`file://${`${destFolder}.html`}`, {});
+        await page.evaluate(evaluation).then(async ({ failed, features }) => {
+          this.receiveFeatures(features, destFolder, t);
+          statusMessagePretty(failed, t);
         }).catch((e) => {
-          console.log("evaluation failed.", dest);
-          console.log(e);
+          console.log(`${t} errored with`, e);
         }).finally(() => {
           close();
         });
         return page;
       });
     };
-    this.receiveFeatures = (features, destFolder) => {
-      console.log("this.receiveFeatures", features);
+    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;
         const isUrl = isValidUrl(featureStringKey);
         if (isUrl) {
           const u = new URL(featureStringKey);
           if (u.protocol === "file:") {
-            const newPath = `${process.cwd()}/docs/features/internal/${path2.relative(
+            const newPath = `${process.cwd()}/docs/features/internal/${path.relative(
               process.cwd(),
               u.pathname
             )}`;
-            await fs.promises.mkdir(path2.dirname(newPath), { recursive: true });
+            await fs.promises.mkdir(path.dirname(newPath), { recursive: true });
             try {
               await fs.unlinkSync(newPath);
             } catch (error) {
@@ -550,25 +506,24 @@ var PM_Main = class extends PM {
               } else {
               }
             });
-            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
+          });
+          accum.strings.push(featureStringKey);
         }
         return accum;
-      }, Promise.resolve([])).then((features2) => {
+      }, Promise.resolve({ files: [], strings: [] })).then(({ files: files2, strings }) => {
         fs.writeFileSync(
           `${destFolder}/featurePrompt.txt`,
-          features2.map((f) => {
+          files2.map((f) => {
             return `/read ${f}`;
           }).join("\n")
         );
@@ -581,6 +536,35 @@ var PM_Main = class extends PM {
     this.configs.ports.forEach((element) => {
       this.ports[element] = "true";
     });
+    globalThis["waitForSelector"] = async (pageKey, sel) => {
+      console.log("waitForSelector", pageKey, sel);
+      const page = (await this.browser.pages()).find(
+        (p) => p.mainFrame()._id === pageKey
+      );
+      await page?.waitForSelector(sel);
+    };
+    globalThis["screencastStop"] = async (path3) => {
+      return recorders[path3].stop();
+    };
+    globalThis["closePage"] = async (pageKey) => {
+      const page = (await this.browser.pages()).find(
+        (p) => p.mainFrame()._id === pageKey
+      );
+      return page.close();
+    };
+    globalThis["goto"] = async (pageKey, url) => {
+      const page = (await this.browser.pages()).find(
+        (p) => p.mainFrame()._id === pageKey
+      );
+      await 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, {
@@ -590,7 +574,7 @@ var PM_Main = class extends PM {
       return false;
     };
     globalThis["writeFileSync"] = (filepath, contents, testName) => {
-      const dir = path2.dirname(filepath.split("/").slice(0, -1).join("/"));
+      const dir = path.dirname(filepath);
       fs.mkdirSync(dir, {
         recursive: true
       });
@@ -618,9 +602,12 @@ var PM_Main = class extends PM {
     globalThis["end"] = (uid) => {
       fileStreams3[uid].end();
     };
-    globalThis["customScreenShot"] = async (opts, page) => {
+    globalThis["customScreenShot"] = async (opts, pageKey, testName) => {
+      const page = (await this.browser.pages()).find(
+        (p2) => p2.mainFrame()._id === pageKey
+      );
       const p = opts.path;
-      const dir = path2.dirname(p);
+      const dir = path.dirname(p);
       fs.mkdirSync(dir, {
         recursive: true
       });
@@ -639,24 +626,45 @@ var PM_Main = class extends PM {
       await sPromise;
       return sPromise;
     };
-    globalThis["customclose"] = (p, testName) => {
-      if (!files[testName]) {
-        files[testName] = /* @__PURE__ */ new Set();
-      }
-      fs.writeFileSync(
-        p + "/manifest.json",
-        JSON.stringify(Array.from(files[testName]))
+    globalThis["screencast"] = async (opts, pageKey) => {
+      const page = (await this.browser.pages()).find(
+        (p2) => p2.mainFrame()._id === pageKey
       );
-      delete files[testName];
+      const p = opts.path;
+      const dir = path.dirname(p);
+      fs.mkdirSync(dir, {
+        recursive: true
+      });
+      const recorder = await page?.screencast({
+        ...opts,
+        path: p
+      });
+      recorders[opts.path] = recorder;
+      return opts.path;
     };
   }
+  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) {
@@ -684,7 +692,7 @@ var PM_Main = class extends PM {
       callback(
         new Promise((res, rej) => {
           tLog("testArtiFactory =>", fPath);
-          const cleanPath = path2.resolve(fPath);
+          const cleanPath = path.resolve(fPath);
           fPaths.push(cleanPath.replace(process.cwd(), ``));
           const targetDir = cleanPath.split("/").slice(0, -1).join("/");
           fs.mkdir(targetDir, { recursive: true }, async (error) => {
@@ -692,7 +700,7 @@ var PM_Main = class extends PM {
               console.error(`\u2757\uFE0FtestArtiFactory failed`, targetDir, error);
             }
             fs.writeFileSync(
-              path2.resolve(
+              path.resolve(
                 targetDir.split("/").slice(0, -1).join("/"),
                 "manifest"
               ),
@@ -748,6 +756,9 @@ var PM_Main = class 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);
@@ -760,21 +771,14 @@ var PM_Main = class extends PM {
   }
 };
 async function writeFileAndCreateDir(filePath, data) {
-  const dirPath = path2.dirname(filePath);
+  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}`);
   }
 }
-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);
@@ -784,36 +788,64 @@ function isValidUrl(string) {
   }
 }
 
-// src/Puppeteer.ts
-readline.emitKeypressEvents(process.stdin);
-if (process.stdin.isTTY)
-  process.stdin.setRawMode(true);
-var Puppeteer_default = async (partialConfig) => {
+// src/cli2.ts
+import path2 from "path";
+import crypto2 from "node:crypto";
+import fs2 from "fs";
+var fileHashes = {};
+async function fileHash(filePath, algorithm = "md5") {
+  return new Promise((resolve, reject) => {
+    const hash = crypto2.createHash(algorithm);
+    const fileStream = fs2.createReadStream(filePath);
+    fileStream.on("data", (data) => {
+      hash.update(data);
+    });
+    fileStream.on("end", () => {
+      const fileHash2 = hash.digest("hex");
+      resolve(fileHash2);
+    });
+    fileStream.on("error", (error) => {
+      reject(`Error reading file: ${error.message}`);
+    });
+  });
+}
+var getRunnables = (tests, payload = {
+  nodeEntryPoints: {},
+  webEntryPoints: {}
+}) => {
+  return tests.reduce((pt, cv, cndx, cry) => {
+    if (cv[1] === "node") {
+      pt.nodeEntryPoints[cv[0]] = path2.resolve(
+        `./docs/node/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
+      );
+    } else if (cv[1] === "web") {
+      pt.webEntryPoints[cv[0]] = path2.resolve(
+        `./docs/web/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
+      );
+    }
+    if (cv[3].length) {
+      getRunnables(cv[3], payload);
+    }
+    return pt;
+  }, payload);
+};
+import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
+  const rawConfig = module.default;
   const config = {
-    ...partialConfig,
-    buildDir: process.cwd() + "/" + partialConfig.outdir
+    ...rawConfig,
+    buildDir: process.cwd() + "/" + rawConfig.outdir
   };
-  fs2.writeFileSync(
-    `${config.outdir}/testeranto.json`,
-    JSON.stringify(
-      {
-        ...config,
-        buildDir: process.cwd() + "/" + config.outdir
-      },
-      null,
-      2
-    )
-  );
-  const pm = new PM_Main(config);
+  let pm = new PM_Main(config);
   await pm.startPuppeteer(
     {
+      slowMo: 1,
       // timeout: 1,
       waitForInitialPage: false,
       executablePath: (
         // process.env.CHROMIUM_PATH || "/opt/homebrew/bin/chromium",
         "/opt/homebrew/bin/chromium"
       ),
-      headless: false,
+      headless: true,
       dumpio: true,
       // timeout: 0,
       devtools: true,
@@ -850,58 +882,37 @@ var Puppeteer_default = async (partialConfig) => {
     },
     "."
   );
-  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();
-    }
-    if (key.name === "x") {
-      process.exit(-1);
-    }
-  });
-  config.tests.forEach(([test, runtime, tr, sidecars]) => {
-    if (runtime === "node") {
-      pm.launchNode(test, destinationOfRuntime(test, "node", config));
-    } else if (runtime === "web") {
-      pm.launchWeb(test, destinationOfRuntime(test, "web", config), sidecars);
-    } else {
-      console.error("runtime makes no sense", runtime);
-    }
-  });
-  if (config.devMode) {
-    console.log("ready and watching for changes...", config.buildDir);
-    watch(config.buildDir, (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
-              );
-            }
+  const { nodeEntryPoints, webEntryPoints } = getRunnables(config.tests);
+  Object.entries(nodeEntryPoints).forEach(
+    ([k, outputFile]) => {
+      console.log("watching and running", outputFile);
+      pm.launchNode(k, outputFile);
+      try {
+        watch(outputFile, async (e, filename) => {
+          const hash = await fileHash(outputFile);
+          if (fileHashes[k] !== hash) {
+            fileHashes[k] = hash;
+            console.log(`< ${e} ${filename} ${hash}`);
+            pm.launchNode(k, outputFile);
           }
         });
+      } catch (e) {
+        console.error(e);
       }
-    });
-  } else {
-    pm.shutDown();
-  }
-};
-
-// src/run-tests.ts
-import process2 from "process";
-if (!process2.argv[2]) {
-  console.log("You didn't pass a config file");
-  process2.exit(-1);
-} else {
-  import(process2.cwd() + "/" + process2.argv[2]).then((module) => {
-    Puppeteer_default(module.default);
-  });
-}
+    }
+  );
+  Object.entries(webEntryPoints).forEach(
+    ([k, outputFile]) => {
+      console.log("watching and running", outputFile);
+      pm.launchWeb(k, outputFile);
+      watch(outputFile, async (e, filename) => {
+        const hash = await fileHash(outputFile);
+        console.log(`< ${e} ${filename} ${hash}`);
+        if (fileHashes[k] !== hash) {
+          fileHashes[k] = hash;
+          pm.launchWeb(k, outputFile);
+        }
+      });
+    }
+  );
+});