testeranto 0.85.0 → 0.94.0

package/src/Project.ts

@@ -1,3 +1,5 @@
+import { spawn } from "child_process";
+
 import esbuild from "esbuild";
 import fs from "fs";
 import path from "path";
@@ -12,6 +14,105 @@ import { ITestTypes, IBaseConfig, IRunTime } from "./lib/types.js";
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY) process.stdin.setRawMode(true);
 
+const logContent: string[] = [];
+
+function parseTsErrors(): void {
+  try {
+    // const logContent = fs.readFileSync(logPath, "utf-8").split("\n");
+    const regex = /(^src(.*?))\(\d*,\d*\): error/gm;
+    const brokenFilesToLines: Record<string, Set<number>> = {};
+
+    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<number>();
+        }
+        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: string[] = [];
+
+          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;
+        }, {} as any)[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(`tsc stdout: ${data}`);
+      const lines = data.toString().split("\n");
+      logContent.push(...lines);
+    });
+
+    tsc.stderr.on("data", (data) => {
+      console.error(`stderr: ${data}`);
+      process.exit(-1);
+    });
+
+    tsc.on("close", (code) => {
+      parseTsErrors();
+      console.log("tsc done");
+      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 {
   config: IBaseConfig;
   mode: `DEV` | `PROD`;
@@ -86,6 +187,8 @@ export class ITProject {
     });
 
     Promise.all([
+      compile(),
+
       esbuild
         .context(esbuildNodeConfiger(this.config, nodeEntryPoints))
         .then(async (nodeContext) => {

package/src/Puppeteer.ts

@@ -83,10 +83,8 @@ export default async (partialConfig) => {
   process.stdin.on("keypress", (str, key) => {
     if (key.name === "q") {
       pm.shutDown();
-      // process.exit();
     }
     if (key.name === "x") {
-      // pm.shutDown();
       process.exit(-1);
     }
   });

package/src/SubPackages/puppeteer.ts

@@ -29,7 +29,7 @@ export default <ITestShape extends IBaseTest>(
     testSpecifications,
     testImplementations,
     {
-      beforeAll(x) {
+      beforeAll: (x) => {
         // process.parentPort.postMessage(
         //   `/docs/web/src/ClassicalComponent/test.html`
         // );

package/src/SubPackages/react/jsx/index.ts

@@ -1,4 +1,5 @@
 import { CElement } from "react";
+import React from "react";
 
 import {
   IBaseTest,
@@ -6,7 +7,6 @@ import {
   ITestImplementation,
   ITestSpecification,
 } from "../../../Types";
-import React from "react";
 
 export type IWhenShape = any;
 export type IThenShape = any;
@@ -29,14 +29,22 @@ export const testInterface: IPartialInterface<any> = {
   //   //   resolve(x());
   //   // });
   // },
-  beforeEach: async (subject, initializer, artificer): Promise<IStore> => {
+  // beforeEach: async (subject, initializer, artificer): Promise<IStore> => {
+  //   return new Promise((resolve, rej) => {
+  //     resolve(React.createElement(subject));
+  //   });
+  // },
+  andWhen: async (s: IStore, whenCB): Promise<IStore> => {
+    await whenCB(s());
     return new Promise((resolve, rej) => {
-      const x = React.createElement(subject);
-      console.log("react-element", x);
-      resolve(x);
+      resolve(React.createElement(s));
     });
+    // return whenCB(s);
   },
-  andWhen: function (s: IStore, whenCB): Promise<ISelection> {
-    return whenCB(s);
+  butThen: async (subject, thenCB) => {
+    await thenCB(subject());
+    return new Promise((resolve, rej) => {
+      resolve(React.createElement(subject));
+    });
   },
 };

package/src/SubPackages/react/jsx/node.ts

@@ -12,15 +12,16 @@ export default <ITestShape extends IBaseTest>(
   testImplementations: ITestImpl<ITestShape>,
   testSpecifications: ITestSpec<ITestShape>,
   testInput: IInput,
-  testInterface: IPartialInterface<ITestShape>
+  testInterface: IPartialInterface<ITestShape> = baseInterface
 ) => {
   return Testeranto<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
-    {
-      ...baseInterface,
-      ...testInterface,
-    }
+    testInterface
+    // {
+    //   ...baseInterface,
+    //   ...testInterface,
+    // }
   );
 };

package/src/SubPackages/react-dom/component/web.ts

@@ -25,7 +25,7 @@ export type IStore = {
 
 type ISubject = {
   htmlElement: HTMLElement;
-  reactElement: any; //CElement<any, any>,
+  // reactElement: any; //CElement<any, any>,
   domRoot: ReactDom.Root;
 };
 
@@ -52,63 +52,40 @@ export default <ITestShape extends IBaseTest, IWhen, IGiven>(
     testSpecifications,
     testImplementations,
     {
-      beforeAll: async (initialProps, artificer): Promise<ISubject> => {
+      beforeAll: async (subject, artificer): Promise<ISubject> => {
         return await new Promise((resolve, rej) => {
           const htmlElement = document.getElementById("root");
           if (htmlElement) {
             const domRoot = ReactDom.createRoot(htmlElement);
-            // Ignore these type errors
-            domRoot.render(
-              createElement(
-                TesterantoComponent,
-                {
-                  ...initialProps,
-                  done: (reactElement) => {
-                    resolve({
-                      htmlElement,
-                      reactElement,
-                      domRoot,
-                    });
-                  },
-                },
-                []
-              )
-            );
-
-            // resolve({ htmlElement });
+            resolve({ domRoot, htmlElement });
           }
         });
       },
-      // beforeEach: async (
-      //   s,
-      //   initializer,
-      //   testResource,
-      //   artificer,
-      //   initialValues
-      // ): Promise<IStore> => {
-      //   return new Promise((resolve, rej) => {
-      //     console.log("beforeEach" + TesterantoComponent);
-
-      //     // const domRoot = ReactDom.createRoot(htmlElement);
-      //     // // Ignore these type errors
-      //     // domRoot.render(
-      //     //   createElement(
-      //     //     TesterantoComponent,
-      //     //     {
-      //     //       ...initializer,
-      //     //       done: (reactElement) => {
-      //     //         resolve({
-      //     //           htmlElement,
-      //     //           reactElement,
-      //     //           domRoot,
-      //     //         });
-      //     //       },
-      //     //     },
-      //     //     []
-      //     //   )
-      //     // );
-      //   });
-      // },
+      beforeEach: async (
+        { domRoot, htmlElement },
+        initialValues,
+        testResource,
+        artificer
+      ): Promise<IStore> => {
+        return new Promise(async (resolve, rej) => {
+          domRoot.render(
+            createElement(
+              TesterantoComponent,
+              {
+                ...initialValues,
+                done: (reactElement) => {
+                  resolve({
+                    htmlElement,
+                    reactElement,
+                    domRoot,
+                  });
+                },
+              },
+              []
+            )
+          );
+        });
+      },
       andWhen: function (s: IStore, whenCB): Promise<ISelection> {
         return whenCB(s);
       },

package/src/SubPackages/react-test-renderer/component/interface.ts

@@ -1,21 +1,18 @@
 import React from "react";
 import renderer, { act } from "react-test-renderer";
+
 import { ISelection, IStore } from ".";
 
 export const testInterface = {
   beforeEach: function (
     CComponent,
-    propsAndChildren
+    propsAndChildren: () => any
   ): Promise<renderer.ReactTestRenderer> {
-    function Link(props) {
-      const p = props.props;
-      const c = props.children;
-      return React.createElement(CComponent, p, c);
+    function Link(proper) {
+      return React.createElement(CComponent, proper(), []);
     }
     return new Promise((res, rej) => {
       act(async () => {
-        const p = propsAndChildren;
-        const y = new CComponent(p.props);
         const testRenderer = await renderer.create(Link(propsAndChildren));
         res(testRenderer);
       });
@@ -25,7 +22,6 @@ export const testInterface = {
     renderer: renderer.ReactTestRenderer,
     whenCB: any
   ): Promise<renderer.ReactTestRenderer> {
-    // console.log("andWhen", whenCB)
     await act(() => whenCB(renderer));
     return renderer;
   },
@@ -34,15 +30,12 @@ export const testInterface = {
   //   return whenCB()(s);
   // },
   butThen: async function (s: IStore, thenCB, tr): Promise<ISelection> {
-    console.log("butThen", thenCB.toString());
     return thenCB(s);
   },
   afterEach: async function (store: IStore, ndx, artificer) {
-    // console.log("afterEach", store);
     return {};
   },
   afterAll: (store: IStore, artificer) => {
-    // console.log("afterAll", store);
     return;
   },
 };

package/src/Web.ts

@@ -1,3 +1,4 @@
+import { error } from "console";
 import { PM_Web } from "./PM/web";
 import type {
   IBaseTest,
@@ -10,7 +11,14 @@ import {
   ITTestResourceRequest,
   defaultTestResourceRequirement,
 } from "./lib/index.js";
-import { ITestInterface, IWebTestInterface } from "./lib/types";
+import { IFinalResults, ITestInterface, IWebTestInterface } from "./lib/types";
+
+let errorCallback = (e: any) => {};
+let unhandledrejectionCallback = (event: PromiseRejectionEvent) => {
+  console.log("window.addEventListener unhandledrejection", event);
+  // cb({ error: event.reason.message });
+  // throw event;
+};
 
 export class WebTesteranto<
   TestShape extends IBaseTest<
@@ -40,7 +48,40 @@ export class WebTesteranto<
       testSpecification,
       testImplementation,
       testResourceRequirement,
-      testInterface
+      testInterface,
+      (cb) => {
+        window.removeEventListener("error", errorCallback);
+
+        errorCallback = (e) => {
+          console.log("window.addEventListener error", e);
+          cb(e);
+          // throw e;
+        };
+
+        window.addEventListener("error", errorCallback);
+
+        window.removeEventListener(
+          "unhandledrejection",
+          unhandledrejectionCallback
+        );
+        /////////////////////
+
+        window.removeEventListener(
+          "unhandledrejection",
+          unhandledrejectionCallback
+        );
+
+        unhandledrejectionCallback = (event: PromiseRejectionEvent) => {
+          console.log("window.addEventListener unhandledrejection", event);
+          cb({ error: event.reason.message });
+          // throw event;
+        };
+
+        window.addEventListener(
+          "unhandledrejection",
+          unhandledrejectionCallback
+        );
+      }
     );
   }
 
@@ -49,28 +90,9 @@ export class WebTesteranto<
     const pm = new PM_Web(t);
     const { failed, artifacts, logPromise, features } =
       await this.testJobs[0].receiveTestResourceConfig(pm);
-    pm.customclose();
-    return new Promise<string[]>((res, rej) => {
-      res(features);
+    return new Promise<IFinalResults>((res, rej) => {
+      res({ features, failed });
     });
-    // return features;
-    // Promise.all([...artifacts, logPromise]).then(async () => {
-    //   console.log("hello world");
-    //   pm.customclose();
-    //   // we can't close the window becuase we might be taking a screenshot
-    //   // window.close();
-    //   // console.log(
-    //   //   "(window as any).browser",
-    //   //   JSON.stringify(await (window as any).browser)
-    //   // );
-    //   // var currentWindow = (await (window as any).browser).getCurrentWindow();
-    //   // window.close();
-    //   // var customWindow = window.open("", "_blank", "");
-    //   // customWindow.close();
-    //   // this.puppetMaster.browser.page
-    //   // window["customclose"]();
-    //   // console.log("goodbye", window["customclose"]());
-    // });
   }
 }
 

package/src/build-tests.ts

@@ -0,0 +1,12 @@
+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/src/defaultConfig.ts

@@ -0,0 +1,20 @@
+import { IBaseConfig } from "testeranto/src/lib/types.js";
+
+const config: IBaseConfig = {
+  outdir: "docs",
+  tests: [],
+  debugger: true,
+  clearScreen: false,
+  devMode: true,
+  minify: false,
+  outbase: ".",
+  ports: ["3001"],
+  externals: [],
+  nodePlugins: [],
+  webPlugins: [],
+  featureIngestor: function (s: string): Promise<string> {
+    throw new Error("Function not implemented.");
+  },
+};
+
+export default config;

package/src/esbuildConfigs/inputFilesPlugin.ts

@@ -5,7 +5,6 @@ import type { ImportKind, Metafile, Plugin } from "esbuild";
 const otherInputs: Record<string, Set<string>> = {};
 
 const register = (entrypoint: string, sources: string[]): void => {
-  console.log("register", entrypoint, sources);
   if (!otherInputs[entrypoint]) {
     otherInputs[entrypoint] = new Set();
   }
@@ -13,13 +12,18 @@ const register = (entrypoint: string, sources: string[]): void => {
 };
 
 function tree(meta: Metafile, key: string) {
-  return [
-    key,
-    ...meta.inputs[key].imports
-      .filter((x) => x.external !== true)
-      .filter((x) => x.path.split("/")[0] !== "node_modules")
-      .map((f) => f.path),
-  ];
+  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 (
@@ -72,7 +76,20 @@ export default (
                 platform,
                 entryPoint.split(".").slice(0, -1).join("."),
                 `featurePrompt.txt`
-              ); // /read ${featuresPath}
+              );
+
+              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(
@@ -87,26 +104,38 @@ export default (
                   })
                   .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/src/init-docs.ts

@@ -0,0 +1,19 @@
+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);
+  });
+}