testeranto 0.79.69 → 0.81.0

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

@@ -14,29 +14,27 @@ import type { IInput, ISelection, IStore } from "./index";
 
 export type ISubject = HTMLElement;
 
+const TesterantoComponent = ({
+  done,
+  innerComp,
+}: {
+  done: (ref: React.MutableRefObject<any>) => any;
+  innerComp: IInput;
+}) => {
+  const myContainer = useRef<any>(null);
+  useEffect(() => {
+    console.log("useEffect called!", myContainer.current);
+    done(myContainer.current);
+  }, []);
+
+  return React.createElement("div", { ref: myContainer }, innerComp());
+};
+
 export default <ITestShape extends IBaseTest>(
   testImplementations: ITestImplementation<ITestShape>,
   testSpecifications: ITestSpecification<ITestShape>,
   testInput: IInput
 ) => {
-  console.log("testInput", testInput);
-  const TesterantoComponent = function ({
-    done,
-    innerComp,
-  }: {
-    done: (ref: React.MutableRefObject<any>) => any;
-    innerComp: IInput;
-  }) {
-    const myContainer = useRef<any>(null);
-    useEffect(() => {
-      console.log("useEffect called!", myContainer.current);
-      done(myContainer.current);
-    }, []);
-
-    // debugger;
-    return React.createElement("div", { ref: myContainer }, innerComp());
-  };
-
   const t = Testeranto<ITestShape>(
     testInput,
     testSpecifications,
@@ -45,6 +43,7 @@ export default <ITestShape extends IBaseTest>(
       beforeAll: async (reactElement, itr): Promise<any> => {
         return await new Promise((resolve, rej) => {
           const htmlElement = document.getElementById("root");
+
           if (htmlElement) {
             const domRoot = ReactDom.createRoot(htmlElement);
 
@@ -79,51 +78,49 @@ export default <ITestShape extends IBaseTest>(
         pm
       ): Promise<IStore> => {
         return new Promise((resolve, rej) => {
-          createPortal(
-            TesterantoComponent({
-              innerComp: () =>
-                testInput({
-                  port: 3003,
-                  address: "some-address",
-                  secretKey: "someSecretKey",
-                  abi: "foo",
-                }),
-              done: (reactElement: any) => {
-                process.nextTick(() => {
-                  resolve(reactElement);
-                });
-              },
-            }),
-            subject.domRoot
-          );
+          resolve(subject);
+          // const tc = TesterantoComponent({
+          //   innerComp: () =>
+          //     testInput({
+          //       port: 3003,
+          //       address: "some-address",
+          //       secretKey: "someSecretKey",
+          //       abi: "foo",
+          //     }),
+          //   done: (reactElement: any) => {
+          //     console.log("mark9");
+          //     resolve(reactElement);
+          //     // process.nextTick(() => {
+          //     //   resolve(reactElement);
+          //     // });
+          //   },
+          // });
+          // console.log("mark9", tc);
+          // createPortal(tc, subject.domRoot);
         });
       },
-      andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+      andWhen: function (s: IStore, whenCB, tr, utils): Promise<ISelection> {
         return new Promise((resolve, rej) => {
-          process.nextTick(() => {
-            resolve(whenCB()(s));
-          });
+          console.log("mark9", s, whenCB);
+          resolve(whenCB(s, utils));
+          // process.nextTick(() => {
+          //   resolve(whenCB()(s));
+          // });
         });
       },
-      butThen: async function (s: IStore): Promise<ISelection> {
+      butThen: async function (s: IStore, thenCB): Promise<ISelection> {
         return new Promise((resolve, rej) => {
-          process.nextTick(() => {
-            resolve(s);
-          });
+          resolve(thenCB(s));
         });
       },
       afterEach: async function (store: IStore, ndx, artificer) {
         return new Promise((resolve, rej) => {
-          process.nextTick(() => {
-            resolve({});
-          });
+          resolve({});
         });
       },
       afterAll: (store: IStore, artificer) => {
         return new Promise((resolve, rej) => {
-          process.nextTick(() => {
-            resolve({});
-          });
+          resolve({});
         });
       },
     }

package/src/SubPackages/react-test-renderer/jsx/index.ts

@@ -23,9 +23,17 @@ export type ITestImpl<ITestShape extends IBaseTest> = ITestImplementation<
 export type ITestSpec<ITestShape extends IBaseTest> =
   ITestSpecification<ITestShape>;
 
+const Context = React.createContext({});
+
+const AppContext = React.createContext({});
+const contextValue = {
+  ingredients: ["flour", "sugar", "eggs"],
+  temperature: "200",
+};
+
 export const testInterface = {
   butThen: async function (s: IStore, thenCB, tr): Promise<ISelection> {
-    console.log("butThen", thenCB.toString());
+    // console.log("butThen", thenCB.toString());
     return thenCB(s);
   },
   beforeEach: function (
@@ -34,7 +42,22 @@ export const testInterface = {
   ): Promise<renderer.ReactTestRenderer> {
     let component;
     act(() => {
-      component = renderer.create(React.createElement(CComponent, props, []));
+      // component = renderer.create(
+      //   React.createElement(
+      //     AppContext.Provider,
+      //     { value: contextValue },
+      //     React.createElement(AppContext.Consumer, null, (context) =>
+      //       React.createElement(CComponent, Object.assign({}, context, {}))
+      //     )
+      //   )
+      // );
+      component = renderer.create(
+        React.createElement(
+          CComponent,
+          props,
+          React.createElement(CComponent, props, [])
+        )
+      );
     });
     return component;
   },

package/src/Types.ts

@@ -13,6 +13,7 @@ import {
   ITestInterface,
   IWebTestInterface,
 } from "./lib/types.js";
+import { PM } from "./PM/index.js";
 
 export type IPartialInterface<
   I extends IBaseTest<
@@ -112,6 +113,7 @@ export type ITestSpecification<
   },
   Given: {
     [K in keyof ITestShape["givens"]]: (
+      features: string[],
       whens: BaseWhen<ITestShape>[],
       thens: BaseThen<ITestShape>[],
       ...xtrasB: ITestShape["givens"][K]
@@ -159,7 +161,7 @@ export type ITestImplementation<
     whens: {
       [K in keyof ITestShape["whens"]]: (
         ...Iw: ITestShape["whens"][K]
-      ) => (zel: ITestShape["iselection"]) => ITestShape["when"];
+      ) => (zel: ITestShape["iselection"], utils: PM) => ITestShape["when"];
     };
     thens: {
       [K in keyof ITestShape["thens"]]: (

package/src/esbuildConfigs/inputFilesPlugin.ts

@@ -17,6 +17,18 @@ export default (
               entryPoint.split(".").slice(0, -1).join("."),
               `inputFiles.json`
             );
+            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 dirName = path.dirname(filePath);
 
@@ -24,39 +36,74 @@ export default (
               fs.mkdirSync(dirName, { recursive: true });
             }
 
+            const j = Object.keys(
+              Object.keys(result.metafile.outputs)
+                .filter((s: string) => {
+                  if (!result.metafile.outputs[s].entryPoint) {
+                    return false;
+                  }
+                  return (
+                    path.resolve(result.metafile.outputs[s].entryPoint) ===
+                    path.resolve(entryPoint)
+                  );
+                })
+                .reduce((mm: string[], el) => {
+                  mm.push(result.metafile.outputs[el].inputs);
+                  return mm;
+                }, [])[0]
+            ).filter((f: string) => {
+              const regex = /^src\/.*/g;
+              const matches = f.match(regex);
+              const passes = matches?.length === 1;
+              return passes;
+            });
+            // .filter((f: string) => {
+            //   const regex = /.*\.test\..*/g;
+            //   const matches = f.match(regex);
+            //   const passes = matches?.length === 1;
+            //   return !passes;
+            // })
+
+            const jsonContent = JSON.stringify(j);
+
+            fs.writeFileSync(filePath, jsonContent);
+
             fs.writeFileSync(
-              filePath,
-              JSON.stringify(
-                Object.keys(
-                  Object.keys(result.metafile.outputs)
-                    .filter((s: string) => {
-                      if (!result.metafile.outputs[s].entryPoint) {
-                        return false;
-                      }
-                      return (
-                        path.resolve(result.metafile.outputs[s].entryPoint) ===
-                        path.resolve(entryPoint)
-                      );
-                    })
-                    .reduce((mm: string[], el) => {
-                      mm.push(result.metafile.outputs[el].inputs);
-                      return mm;
-                    }, [])[0]
-                )
-                  .filter((f: string) => {
-                    const regex = /^src\/.*/g;
-                    const matches = f.match(regex);
-                    const passes = matches?.length === 1;
-                    return passes;
-                  })
-                  .filter((f: string) => {
-                    const regex = /.*\.test\..*/g;
-                    const matches = f.match(regex);
-                    const passes = matches?.length === 1;
-                    return !passes;
-                  })
-              )
+              promptPath,
+              `
+${j
+  .map((x) => {
+    return `/add ${x}`;
+  })
+  .join("\n")}
+/read ${testPaths}
+  
+/code fix the failing tests described in ${filePath}.
+`
             );
+
+            //             fs.writeFileSync(
+            //               promptPath,
+            //               `
+            // from aider.coders import Coder
+            // from aider.models import Model
+            // import os
+
+            // model = Model("deepseek")
+
+            // coder = Coder.create(main_model=model)
+
+            // coder.run("/read-only", "${testPaths}")
+
+            // ${j
+            //   .map((x) => {
+            //     return `coder.run("/add", "${x}")`;
+            //   })
+            //   .join("\n")}
+
+            // coder.run("fix the failing tests described in ${filePath}.")
+            // `
+            //             );
           });
         }
       });

package/src/esbuildConfigs/node.ts

@@ -3,7 +3,7 @@ import { BuildOptions } from "esbuild";
 import { IBaseConfig } from "../lib/types";
 
 import baseEsBuildConfig from "./index.js";
-import inputFilesPlugin from "./inputFilesPlugin";
+import inputFilesPlugin from "./inputFilesPlugin.js";
 
 export default (
   config: IBaseConfig,
@@ -16,7 +16,7 @@ export default (
 
     outdir: config.outdir + "/node",
 
-    inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
+    // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
     metafile: true,
     supported: {
       "dynamic-import": true,

package/src/esbuildConfigs/web.ts

@@ -29,10 +29,10 @@ export default (
     metafile: true,
 
     external: [
-      "testeranto.json",
-      "features.test.ts",
+      // "testeranto.json",
+      // "features.test.ts",
       // "url",
-      "react",
+      // "react",
 
       "path",
       "fs",
@@ -60,7 +60,7 @@ export default (
 
     plugins: [
       ...(config.webPlugins || []),
-      inputFilesPlugin("node", entryPoints),
+      inputFilesPlugin("web", entryPoints),
       {
         name: "rebuild-notify",
         setup(build) {

package/src/lib/abstractBase.ts

@@ -58,10 +58,22 @@ export abstract class BaseSuite<
   }
 
   public toObj() {
+    const givens = Object.keys(this.givens).map((k) => this.givens[k].toObj());
+    const features = Object.keys(this.givens)
+      .map((k) => this.givens[k].features)
+      .flat()
+      .filter((value, index, array) => {
+        return array.indexOf(value) === index;
+      })
+      .reduce((mm, lm) => {
+        mm[lm] = lm;
+        return mm;
+      }, {});
     return {
       name: this.name,
-      givens: Object.keys(this.givens).map((k) => this.givens[k].toObj()),
+      givens,
       fails: this.fails,
+      features,
     };
   }
 
@@ -406,6 +418,7 @@ export abstract class BaseGiven<
         this.givenCB,
         beforeEachProxy
       );
+      // console.log("mark6", this.store);
 
       for (const [whenNdx, whenStep] of this.whens.entries()) {
         await whenStep.test(
@@ -428,9 +441,11 @@ export abstract class BaseGiven<
         tester(t);
       }
     } catch (e) {
+      console.error(e);
       this.error = e;
-      tLog(e);
-      tLog("\u0007"); // bell
+      tLog(e.stack);
+      // tLog("\u0007"); // bell
+
       // throw e;
     } finally {
       try {
@@ -532,6 +547,7 @@ export abstract class BaseGiven<
           },
         });
 
+        // console.log("mark5", this.store, key);
         await this.afterEach(this.store, key, givenArtifactory, afterEachProxy);
       } catch (e) {
         console.error("afterEach failed! no error will be recorded!", e);
@@ -579,6 +595,15 @@ export abstract class BaseWhen<ITestShape extends IBaseTest> {
 
     const name = this.name;
     const andWhenProxy = new Proxy(pm, {
+      // set(obj, prop, value) {
+      //   return Reflect.set(...arguments);
+      //   // if (prop === "eyeCount" && value % 2 !== 0) {
+      //   //   console.log("Monsters must have an even number of eyes");
+      //   // } else {
+      //   //   return Reflect.set(...arguments);
+      //   // }
+      // },
+
       get(target, prop, receiver) {
         if (prop === "writeFileSync") {
           return (fp, contents) =>
@@ -597,13 +622,9 @@ export abstract class BaseWhen<ITestShape extends IBaseTest> {
                     return pages.map((page) => {
                       return new Proxy(page, {
                         get(pTarget, pProp, pReciever) {
+                          // console.log("mark get", pTarget, pProp, pReciever);
                           if (pProp === "screenshot") {
                             return async (x) => {
-                              // console.log(
-                              //   "custom-screenshot-MARK-afterEachProxy",
-                              //   window["custom-screenshot"].toString()
-                              // );
-
                               return pm.customScreenShot(
                                 {
                                   ...x,
@@ -614,14 +635,6 @@ export abstract class BaseWhen<ITestShape extends IBaseTest> {
                                 },
                                 page
                               );
-
-                              // return await pTarget[pProp]({
-                              //   ...x,
-                              //   path:
-                              //     `${testResourceConfiguration.fs}/suite-${suiteNdx}/given-${key}/afterEach` +
-                              //     "/" +
-                              //     x.path,
-                              // });
                             };
                           } else if (pProp === "mainFrame") {
                             return () => pTarget[pProp]();
@@ -635,6 +648,32 @@ export abstract class BaseWhen<ITestShape extends IBaseTest> {
                             // return Reflect.get(target, prop, receiver);
                             return pTarget[pProp].bind(pTarget);
                             // return target[pProp];
+                          } else if (pProp === "click") {
+                            // console.log("mark12", arguments);
+                            // return Reflect.get(target, prop, receiver);
+                            // return pTarget[pProp].bind(pTarget);
+                            // return target[pProp];
+                            return (selector, options) => {
+                              // console.log("mark13", selector, options);
+                              // debugger;
+                              pTarget[pProp](selector, options);
+                            };
+                          } else if (pProp === "$") {
+                            return Reflect.get(...arguments);
+                            // return Reflect.get(target, prop, receiver);
+                            // return pTarget[pProp].bind(pTarget);
+                            // return target[pProp];
+                            // return pTarget[pProp].bind(pTarget);
+
+                            // return async (s) => {
+                            //   console.log("mark17", s);
+                            //   console.log("pTarget", pTarget);
+                            //   console.log("pProp", pProp);
+                            //   console.log("pReciever", pReciever);
+                            //   // return "XXX";
+                            //   // debugger;
+                            //   return await pTarget[pProp](s);
+                            // };
                           } else {
                             return Reflect.get(...arguments);
                           }
@@ -657,17 +696,26 @@ export abstract class BaseWhen<ITestShape extends IBaseTest> {
       },
     });
 
-    try {
-      return await this.andWhen(
-        store,
-        this.whenCB,
-        testResourceConfiguration,
-        andWhenProxy
-      );
-    } catch (e) {
+    return this.andWhen(
+      store,
+      this.whenCB,
+      testResourceConfiguration,
+      andWhenProxy
+    ).catch((e) => {
       this.error = true;
-      throw e;
-    }
+      // throw e;
+    });
+    // try {
+    //   return await this.andWhen(
+    //     store,
+    //     this.whenCB,
+    //     testResourceConfiguration,
+    //     andWhenProxy
+    //   );
+    // } catch (e) {
+    //   this.error = true;
+    //   throw e;
+    // }
   }
 }
 
@@ -791,14 +839,24 @@ export abstract class BaseThen<
         },
       });
 
-      const x = await this.butThen(
+      // const x = await this.butThen(
+      //   store,
+      //   this.thenCB,
+      //   testResourceConfiguration,
+      //   butThenProxy
+      // );
+      // return x;
+
+      return this.butThen(
         store,
         this.thenCB,
         testResourceConfiguration,
         butThenProxy
-        // pm
-      );
-      return x;
+      ).catch((e) => {
+        console.log("mar123");
+        this.error = true;
+        throw e;
+      });
     } catch (e) {
       console.log("test failed", e);
       this.error = e.message;

package/src/lib/basebuilder.ts

@@ -89,7 +89,7 @@ export abstract class BaseBuilder<
           puppetMaster: PM,
           tLog: ITLog
         ): Promise<BaseSuite<ITestShape>> => {
-          await puppetMaster.startPuppeteer(
+          const puppeteerBrowser = await puppetMaster.startPuppeteer(
             {
               browserWSEndpoint:
                 puppetMaster.testResourceConfiguration.browserWSEndpoint,
@@ -97,7 +97,7 @@ export abstract class BaseBuilder<
             puppetMaster.testResourceConfiguration.fs
           );
 
-          return await suite.run(
+          const x = await suite.run(
             input,
             puppetMaster.testResourceConfiguration,
             (fPath: string, value: string | Buffer | PassThrough) =>
@@ -110,6 +110,10 @@ export abstract class BaseBuilder<
             tLog,
             puppetMaster
           );
+
+          // await puppetMaster.browser.disconnect();
+          // puppeteerBrowser.close();
+          return x;
         };
 
       const runner = suiteRunner(suite);
@@ -124,7 +128,7 @@ export abstract class BaseBuilder<
         runner,
 
         receiveTestResourceConfig: async function (puppetMaster: PM) {
-          await puppetMaster.mkdirSync();
+          // await puppetMaster.mkdirSync();
 
           const logFilePath = "log.txt";
           const access = await puppetMaster.createWriteStream(logFilePath);
@@ -147,11 +151,21 @@ export abstract class BaseBuilder<
           }).length;
           puppetMaster.writeFileSync(`exitcode`, numberOfFailures.toString());
 
+          // if (numberOfFailures > 0) {
+          //   puppetMaster.writeFileSync(
+          //     `prompt`,
+          //     `
+          //     aider --message "make a script that prints hello" hello.js
+          //     `
+          //   );
+          // }
+
           puppetMaster.writeFileSync(
             `tests.json`,
             JSON.stringify(this.toObj(), null, 2)
           );
           console.log(`exiting gracefully with ${numberOfFailures} failures.`);
+
           return {
             failed: numberOfFailures,
             artifacts: this.artifacts || [],