testeranto 0.94.0 → 0.100.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "testeranto",
   "description": "the AI powered BDD test framework for typescript projects",
-  "version": "0.94.0",
+  "version": "0.100.0",
   "engines": {
     "node": "18.18.0"
   },
@@ -144,10 +144,6 @@
       "import": "./src/Node.ts",
       "require": "./src/Node.ts"
     },
-    "./src/Aider": {
-      "import": "./dist/module/src/Aider.js",
-      "require": "./dist/common/src/Aider.js"
-    },
     "./src/Init": {
       "import": "./dist/module/src/Init.js",
       "require": "./dist/common/src/Init.js"
@@ -200,12 +196,15 @@
     "@types/react": "18.2.0",
     "@types/react-dom": "18.2.0",
     "@types/react-test-renderer": "19.0.0",
+    "eslint": "9.23.0",
     "react": "18.2.0",
     "react-dom": "18.2.0",
     "ts-node": "^10.9.1",
-    "typescript": "4.8.2"
+    "typescript": "4.8.2",
+    "typescript-eslint": "^8.29.0"
   },
   "devDependencies": {
+    "@eslint/js": "^9.23.0",
     "@swc/core": "^1.3.26",
     "@types/express": "^5.0.0",
     "@types/express-session": "^1.18.1",
@@ -218,9 +217,13 @@
     "@typescript-eslint/eslint-plugin": "^5.46.0",
     "@typescript-eslint/parser": "^5.46.0",
     "ts-node": "^10.9.1",
-    "typescript": "4.8.2"
+    "typescript": "^5.8.2"
   },
   "dependencies": {
+    "@bscotch/debounce-watch": "^1.1.0",
+    "@humanwhocodes/config-array": "^0.13.0",
+    "@types/eslint": "^9.6.1",
+    "@ungap/structured-clone": "^1.3.0",
     "babel-loader": "^8.2.5",
     "chai": "^5.2.0",
     "chromium": "^3.0.3",
@@ -229,7 +232,7 @@
     "esbuild-plugin-external-package": "^1.0.0",
     "esbuild-plugin-import-map": "^2.1.0",
     "esbuild-plugin-markdown": "^0.0.3",
-    "eslint": "^8.29.0",
+    "eslint-plugin-import": "^2.31.0",
     "eslint-plugin-react": "^7.31.11",
     "eslint-plugin-react-hooks": "^5.1.0",
     "express": "^4.21.2",

package/src/PM/index.ts

@@ -1,9 +1,6 @@
-import {
-  Browser,
-  Page,
-} from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser";
+import { CdpPage } from "puppeteer-core/lib/esm/puppeteer/puppeteer-core-browser";
+import { ScreenRecorderOptions } from "puppeteer-core/lib/esm/puppeteer";
 import { ITLog, ITTestResourceConfiguration } from "../lib";
-// import { Page } from "puppeteer-core";
 
 type IFPaths = string[];
 const fPaths: IFPaths = [];
@@ -12,7 +9,6 @@ export abstract class PM {
   server: any;
   testResourceConfiguration: ITTestResourceConfiguration;
 
-  // abstract startPuppeteer(options: any, destfolder: string): Promise<Browser>;
   abstract testArtiFactoryfileWriter(tLog: ITLog, callback: (Promise) => void);
   abstract createWriteStream(filepath: string): any;
   abstract writeFileSync(fp: string, contents: string);
@@ -20,8 +16,9 @@ export abstract class PM {
   abstract existsSync(fp: string): boolean;
   abstract write(accessObject: { uid: number }, contents: string): boolean;
   abstract end(accessObject: { uid: number }): boolean;
-  abstract customScreenShot(opts: object): any;
-  abstract screencast(opts: object): any;
+  abstract customScreenShot(opts: object, page?: string): any;
+  abstract screencast(opts: ScreenRecorderOptions, p?): any;
+  abstract screencastStop(s: string): any;
 
   abstract page(): string | undefined;
   abstract click(selector: string): any;
@@ -31,4 +28,11 @@ export abstract class PM {
   abstract getAttribute(selector: string, attribute: string): any;
   abstract isDisabled(selector: string): boolean;
   abstract $(selector: string): any;
+
+  abstract newPage(): CdpPage;
+  abstract goto(p, url: string): any;
+  abstract closePage(p): any;
+
+  abstract waitForSelector(p, sel: string);
+  abstract customclose();
 }

package/src/PM/main.ts

@@ -1,19 +1,20 @@
+import { CdpPage, Page } from "puppeteer-core/lib/esm/puppeteer";
 import fs from "fs";
 import path from "path";
 import puppeteer, {
   Browser,
   ConsoleMessage,
+  LaunchOptions,
+  ScreenRecorder,
   ScreenshotOptions,
 } from "puppeteer-core";
 import { PassThrough } from "stream";
 import crypto from "crypto";
 
 import { IBuiltConfig, IFinalResults, ITestTypes } from "../lib/types";
+import { ITLog } from "../lib/index.js";
 
 import { PM } from "./index.js";
-import { destinationOfRuntime } from "../utils.js";
-import { ITLog } from "../lib/index.js";
-import { Page } from "puppeteer-core/lib/esm/puppeteer";
 
 const fileStreams3: fs.WriteStream[] = [];
 
@@ -22,8 +23,21 @@ type IFPaths = string[];
 const fPaths: IFPaths = [];
 
 const files: Record<string, Set<string>> = {};
+const recorders: Record<string, ScreenRecorder> = {};
 const screenshots: Record<string, Promise<Uint8Array>[]> = {};
 
+const red = "\x1b[31m";
+const green = "\x1b[32m";
+const reset = "\x1b[0m"; // Resets to default color
+
+const statusMessagePretty = (failures: number, test: string) => {
+  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 {
   browser: Browser;
 
@@ -43,6 +57,46 @@ export class PM_Main extends PM {
       this.ports[element] = "true"; // set ports as open
     });
 
+    globalThis["waitForSelector"] = async (pageKey: string, sel: string) => {
+      console.log("waitForSelector", pageKey, sel);
+      const page = (await this.browser.pages()).find(
+        (p) => p.mainFrame()._id === pageKey
+      );
+      await page?.waitForSelector(sel);
+    };
+
+    globalThis["screencastStop"] = async (path: string) => {
+      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: string, url: string) => {
+      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: string) => {
       if (!fs.existsSync(fp)) {
         return fs.mkdirSync(fp, {
@@ -99,10 +153,41 @@ export class PM_Main extends PM {
       fileStreams3[uid].end();
     };
 
+    // 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: { path: string },
-      page: Page
+      pageKey: string,
+      testName: string
     ) => {
+      const page = (await this.browser.pages()).find(
+        (p) => p.mainFrame()._id === pageKey
+      );
+
       const p = opts.path as string;
       const dir = path.dirname(p);
       fs.mkdirSync(dir, {
@@ -127,6 +212,30 @@ export class PM_Main extends PM {
       return sPromise;
     };
 
+    globalThis["screencast"] = async (
+      opts: ScreenshotOptions,
+      pageKey: string
+    ) => {
+      const page = (await this.browser.pages()).find(
+        (p) => p.mainFrame()._id === pageKey
+      );
+
+      const p = opts.path as string;
+      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;
+    };
+
     // globalThis["customclose"] = (p: string, testName: string) => {
     //   if (!files[testName]) {
     //     files[testName] = new Set();
@@ -140,13 +249,29 @@ export class PM_Main extends PM {
     // };
   }
 
+  customclose() {
+    throw new Error("Method not implemented.");
+  }
+  waitForSelector(p: string, s: string): any {
+    throw new Error("Method not implemented.");
+  }
+  closePage(p): any {
+    throw new Error("Method not implemented.");
+  }
+  newPage(): CdpPage {
+    throw new Error("Method not implemented.");
+  }
+  goto(p, url: string): any {
+    throw new Error("Method not implemented.");
+  }
+
   $(selector: string): boolean {
     throw new Error("Method not implemented.");
   }
   screencast(opts: object) {
     throw new Error("Method not implemented.");
   }
-  customScreenShot(opts: object) {
+  customScreenShot(opts: object, cdpPage?: CdpPage) {
     throw new Error("Method not implemented.");
   }
 
@@ -250,9 +375,15 @@ export class PM_Main extends PM {
   isDisabled(selector: string): boolean {
     throw new Error("Method not implemented.");
   }
+  screencastStop(s: string) {
+    throw new Error("Method not implemented.");
+  }
   ////////////////////////////////////////////////////////////////////////////////
 
-  async startPuppeteer(options: any, destfolder: string): Promise<any> {
+  async startPuppeteer(
+    options: LaunchOptions,
+    destfolder: string
+  ): Promise<any> {
     this.browser = (await puppeteer.launch(options)) as any;
   }
 
@@ -288,7 +419,7 @@ export class PM_Main extends PM {
   };
 
   launchNode = async (src: string, dest: string) => {
-    console.log("launchNode", src);
+    console.log("! node", src);
     this.register(src);
 
     const destFolder = dest.replace(".mjs", "");
@@ -343,31 +474,31 @@ export class PM_Main extends PM {
       process.exit(-1);
     }
 
-    const builtfile = dest + ".mjs";
+    const builtfile = dest;
 
     const webSideCares: Page[] = [];
 
-    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()}`
@@ -376,8 +507,9 @@ export class PM_Main extends PM {
         defaultModule
           .receiveTestResourceConfig(argz)
           .then(async ({ features, failed }: IFinalResults) => {
-            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);
@@ -633,19 +765,19 @@ export class PM_Main extends PM {
     }
   };
 
-  launchWeb = (t: string, dest: string, sidecars: ITestTypes[]) => {
-    console.log("launchWeb", t, dest);
+  launchWeb = (t: string, dest: string) => {
+    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", "");
 
@@ -656,9 +788,11 @@ export class PM_Main extends PM {
       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})
@@ -670,8 +804,8 @@ export class PM_Main extends PM {
     const fileStreams2: fs.WriteStream[] = [];
     const doneFileStream2: Promise<any>[] = [];
 
-    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()
@@ -905,7 +1039,7 @@ export class PM_Main extends PM {
           // files[t].add(filepath);
 
           fs.writeFileSync(
-            dest + "/manifest.json",
+            destFolder + "/manifest.json",
             JSON.stringify(Array.from(files[t]))
           );
           delete files[t];
@@ -948,13 +1082,14 @@ 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 }: IFinalResults) => {
-            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);
@@ -967,7 +1102,19 @@ export class PM_Main extends PM {
       });
   };
 
-  receiveFeatures = (features: string[], destFolder: string) => {
+  receiveFeatures = (
+    features: string[],
+    destFolder: string,
+    srcTest: string
+  ) => {
+    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;
@@ -1001,29 +1148,38 @@ 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([] as string[]))
-      .then((features: string[]) => {
+      }, Promise.resolve({ files: [] as string[], strings: [] as string[] }))
+
+      .then(({ files, strings }: { files: string[]; strings: string[] }) => {
+        // writeFileAndCreateDir(`${featureDestination}`, JSON.stringify(strings));
+
         fs.writeFileSync(
           `${destFolder}/featurePrompt.txt`,
-          features
+          files
             .map((f) => {
               return `/read ${f}`;
             })
@@ -1038,7 +1194,7 @@ async function writeFileAndCreateDir(filePath, data) {
 
   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/src/PM/node.ts

@@ -1,12 +1,12 @@
 import fs from "fs";
 import path from "path";
-import puppeteer from "puppeteer-core";
+import puppeteer, { ScreencastOptions, ScreenRecorder } from "puppeteer-core";
 import { PassThrough } from "stream";
 
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 
 import { PM } from "./index.js";
-import { Page } from "puppeteer-core/lib/esm/puppeteer";
+import { CdpPage, Page } from "puppeteer-core/lib/esm/puppeteer";
 
 type IFPaths = string[];
 const fPaths: IFPaths = [];
@@ -23,10 +23,23 @@ export class PM_Node extends PM {
     this.testResourceConfiguration = t;
   }
 
-  $(selector: string): boolean {
-    throw new Error("Method not implemented.");
+  waitForSelector(p: string, s: string): any {
+    return globalThis["waitForSelector"](p, s);
   }
-  screencast(opts: object) {
+
+  closePage(p): string {
+    return globalThis["closePage"](p);
+  }
+
+  goto(cdpPage: CdpPage, url: string): any {
+    return globalThis["goto"](cdpPage.mainFrame()._id, url);
+  }
+
+  newPage(): CdpPage {
+    return globalThis["newPage"]();
+  }
+
+  $(selector: string): boolean {
     throw new Error("Method not implemented.");
   }
 
@@ -57,8 +70,30 @@ export class PM_Node extends PM {
     return globalThis["click"](selector);
   }
 
-  customScreenShot(opts: object) {
-    return globalThis["customScreenShot"](opts);
+  screencast(opts: ScreencastOptions, page: CdpPage) {
+    return globalThis["screencast"](
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path,
+      },
+      page.mainFrame()._id,
+      this.testResourceConfiguration.name
+    );
+  }
+
+  screencastStop(p: string) {
+    return globalThis["screencastStop"](p);
+  }
+
+  customScreenShot(opts: ScreencastOptions, cdpPage: CdpPage) {
+    return globalThis["customScreenShot"](
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path,
+      },
+      cdpPage.mainFrame()._id,
+      this.testResourceConfiguration.name
+    );
   }
 
   existsSync(destFolder: string): boolean {

package/src/PM/web.ts

@@ -3,7 +3,8 @@ import { PassThrough } from "stream";
 import { ITLog, ITTestResourceConfiguration } from "../lib";
 
 import { PM } from "./index.js";
-import { ScreenshotOptions } from "puppeteer-core";
+import { ScreencastOptions, ScreenshotOptions } from "puppeteer-core";
+import { CdpPage } from "puppeteer-core/lib/esm/puppeteer";
 
 type PuppetMasterServer = Record<string, Promise<any>>;
 
@@ -16,12 +17,39 @@ export class PM_Web extends PM {
     this.testResourceConfiguration = t;
   }
 
+  waitForSelector(p: string, s: string): any {
+    return window["waitForSelector"](p, s);
+  }
+
+  screencast(opts: ScreencastOptions) {
+    return window["screencast"](
+      {
+        ...opts,
+        path: this.testResourceConfiguration.fs + "/" + opts.path,
+      },
+      this.testResourceConfiguration.name
+    );
+  }
+
+  screencastStop(recorder: string) {
+    return window["screencastStop"](recorder);
+  }
+
+  closePage(p): string {
+    return window["closePage"](p);
+  }
+
+  goto(p, url: string): any {
+    return window["goto"](p, url);
+  }
+
+  newPage(): CdpPage {
+    return window["newPage"]();
+  }
+
   $(selector: string): boolean {
     return window["$"](selector);
   }
-  screencast(opts: object) {
-    throw new Error("Method not implemented.");
-  }
 
   isDisabled(selector: string): boolean {
     return window["isDisabled"](selector);
@@ -64,7 +92,7 @@ export class PM_Web extends PM {
     return window["existsSync"](destFolder);
   }
 
-  mkdirSync() {
+  mkdirSync(x) {
     return window["mkdirSync"](this.testResourceConfiguration.fs + "/");
   }