testeranto 0.79.69 → 0.81.0

package/dist/module/{SubPackages → src/SubPackages}/react-dom/jsx/web.js

@@ -1,19 +1,16 @@
 import React, { useEffect, useRef } from "react";
 import { createElement } from "react";
 import ReactDom from "react-dom/client";
-import { createPortal } from "react-dom";
 import Testeranto from "../../../Web.js";
+const TesterantoComponent = ({ done, innerComp, }) => {
+    const myContainer = useRef(null);
+    useEffect(() => {
+        console.log("useEffect called!", myContainer.current);
+        done(myContainer.current);
+    }, []);
+    return React.createElement("div", { ref: myContainer }, innerComp());
+};
 export default (testImplementations, testSpecifications, testInput) => {
-    console.log("testInput", testInput);
-    const TesterantoComponent = function ({ done, innerComp, }) {
-        const myContainer = useRef(null);
-        useEffect(() => {
-            console.log("useEffect called!", myContainer.current);
-            done(myContainer.current);
-        }, []);
-        // debugger;
-        return React.createElement("div", { ref: myContainer }, innerComp());
-    };
     const t = Testeranto(testInput, testSpecifications, testImplementations, {
         beforeAll: async (reactElement, itr) => {
             return await new Promise((resolve, rej) => {
@@ -37,47 +34,49 @@ export default (testImplementations, testSpecifications, testInput) => {
         },
         beforeEach: async (subject, initializer, artificer, testResource, pm) => {
             return new Promise((resolve, rej) => {
-                createPortal(TesterantoComponent({
-                    innerComp: () => testInput({
-                        port: 3003,
-                        address: "some-address",
-                        secretKey: "someSecretKey",
-                        abi: "foo",
-                    }),
-                    done: (reactElement) => {
-                        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, whenCB) {
+        andWhen: function (s, whenCB, tr, utils) {
             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) {
+        butThen: async function (s, thenCB) {
             return new Promise((resolve, rej) => {
-                process.nextTick(() => {
-                    resolve(s);
-                });
+                resolve(thenCB(s));
             });
         },
         afterEach: async function (store, ndx, artificer) {
             return new Promise((resolve, rej) => {
-                process.nextTick(() => {
-                    resolve({});
-                });
+                resolve({});
             });
         },
         afterAll: (store, artificer) => {
             return new Promise((resolve, rej) => {
-                process.nextTick(() => {
-                    resolve({});
-                });
+                resolve({});
             });
         },
     });

package/dist/module/src/SubPackages/react-test-renderer/jsx/index.js

@@ -0,0 +1,34 @@
+import React from "react";
+import renderer, { act } from "react-test-renderer";
+const Context = React.createContext({});
+const AppContext = React.createContext({});
+const contextValue = {
+    ingredients: ["flour", "sugar", "eggs"],
+    temperature: "200",
+};
+export const testInterface = {
+    butThen: async function (s, thenCB, tr) {
+        // console.log("butThen", thenCB.toString());
+        return thenCB(s);
+    },
+    beforeEach: function (CComponent, props) {
+        let component;
+        act(() => {
+            // 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;
+    },
+    andWhen: async function (renderer, whenCB) {
+        await act(() => whenCB(renderer));
+        return renderer;
+    },
+};

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

@@ -0,0 +1,74 @@
+import fs from "fs";
+import path from "path";
+export default (platform, entryPoints) => {
+    return {
+        name: "metafileWriter",
+        setup(build) {
+            build.onEnd((result) => {
+                if (result.errors.length === 0) {
+                    entryPoints.forEach((entryPoint) => {
+                        const filePath = path.join("./docs/", platform, 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);
+                        if (!fs.existsSync(dirName)) {
+                            fs.mkdirSync(dirName, { recursive: true });
+                        }
+                        const j = Object.keys(Object.keys(result.metafile.outputs)
+                            .filter((s) => {
+                            if (!result.metafile.outputs[s].entryPoint) {
+                                return false;
+                            }
+                            return (path.resolve(result.metafile.outputs[s].entryPoint) ===
+                                path.resolve(entryPoint));
+                        })
+                            .reduce((mm, el) => {
+                            mm.push(result.metafile.outputs[el].inputs);
+                            return mm;
+                        }, [])[0]).filter((f) => {
+                            const regex = /^src\/.*/g;
+                            const matches = f.match(regex);
+                            const passes = (matches === null || matches === void 0 ? void 0 : 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(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/dist/module/{esbuildConfigs → src/esbuildConfigs}/node.js

@@ -1,7 +1,9 @@
 import baseEsBuildConfig from "./index.js";
-import inputFilesPlugin from "./inputFilesPlugin";
+import inputFilesPlugin from "./inputFilesPlugin.js";
 export default (config, entryPoints) => {
-    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { splitting: true, outdir: config.outdir + "/node", inject: [`./node_modules/testeranto/dist/cjs-shim.js`], metafile: true, supported: {
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { splitting: true, outdir: config.outdir + "/node", 
+        // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
+        metafile: true, supported: {
             "dynamic-import": true,
         }, define: {
             "process.env.FLUENTFFMPEG_COV": "0",

package/dist/module/{esbuildConfigs → src/esbuildConfigs}/web.js

@@ -11,10 +11,10 @@ export default (config, entryPoints) => {
         outdir: config.outdir + "/web", alias: {
             react: path.resolve("./node_modules/react"),
         }, metafile: true, external: [
-            "testeranto.json",
-            "features.test.ts",
+            // "testeranto.json",
+            // "features.test.ts",
             // "url",
-            "react",
+            // "react",
             "path",
             "fs",
             "stream",
@@ -34,7 +34,7 @@ export default (config, entryPoints) => {
             "dns",
         ], platform: "browser", entryPoints: [...entryPoints], plugins: [
             ...(config.webPlugins || []),
-            inputFilesPlugin("node", entryPoints),
+            inputFilesPlugin("web", entryPoints),
             {
                 name: "rebuild-notify",
                 setup(build) {

package/dist/module/{lib → src/lib}/abstractBase.js

@@ -7,10 +7,22 @@ export class BaseSuite {
         this.fails = [];
     }
     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,
         };
     }
     setup(s, artifactory, tr, pm) {
@@ -226,6 +238,7 @@ export class BaseGiven {
                 },
             });
             this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, beforeEachProxy);
+            // console.log("mark6", this.store);
             for (const [whenNdx, whenStep] of this.whens.entries()) {
                 await whenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/when/${whenNdx}`);
             }
@@ -235,9 +248,10 @@ export class BaseGiven {
             }
         }
         catch (e) {
+            console.error(e);
             this.error = e;
-            tLog(e);
-            tLog("\u0007"); // bell
+            tLog(e.stack);
+            // tLog("\u0007"); // bell
             // throw e;
         }
         finally {
@@ -323,6 +337,7 @@ export class BaseGiven {
                         return Reflect.get(...arguments);
                     },
                 });
+                // console.log("mark5", this.store, key);
                 await this.afterEach(this.store, key, givenArtifactory, afterEachProxy);
             }
             catch (e) {
@@ -347,6 +362,14 @@ export class BaseWhen {
         tLog(" When:", this.name);
         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) => 
@@ -363,22 +386,12 @@ export class BaseWhen {
                                         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(Object.assign(Object.assign({}, x), { path: `${testResourceConfiguration.fs}/${key}/afterEach` +
                                                                     "/" +
                                                                     x.path }), page);
-                                                            // return await pTarget[pProp]({
-                                                            //   ...x,
-                                                            //   path:
-                                                            //     `${testResourceConfiguration.fs}/suite-${suiteNdx}/given-${key}/afterEach` +
-                                                            //     "/" +
-                                                            //     x.path,
-                                                            // });
                                                         };
                                                     }
                                                     else if (pProp === "mainFrame") {
@@ -396,6 +409,33 @@ export class BaseWhen {
                                                         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);
                                                     }
@@ -415,13 +455,21 @@ export class BaseWhen {
                 return Reflect.get(...arguments);
             },
         });
-        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;
+        // }
     }
 }
 export class BaseThen {
@@ -501,10 +549,18 @@ export class BaseThen {
                     return Reflect.get(...arguments);
                 },
             });
-            const x = await this.butThen(store, this.thenCB, testResourceConfiguration, butThenProxy
-            // pm
-            );
-            return x;
+            // const x = await this.butThen(
+            //   store,
+            //   this.thenCB,
+            //   testResourceConfiguration,
+            //   butThenProxy
+            // );
+            // return x;
+            return this.butThen(store, this.thenCB, testResourceConfiguration, butThenProxy).catch((e) => {
+                console.log("mar123");
+                this.error = true;
+                throw e;
+            });
         }
         catch (e) {
             console.log("test failed", e);

package/dist/module/{lib → src/lib}/basebuilder.js

@@ -13,12 +13,15 @@ export class BaseBuilder {
         this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then(), this.Check());
         this.testJobs = this.specs.map((suite) => {
             const suiteRunner = (suite) => async (puppetMaster, tLog) => {
-                await puppetMaster.startPuppeteer({
+                const puppeteerBrowser = await puppetMaster.startPuppeteer({
                     browserWSEndpoint: puppetMaster.testResourceConfiguration.browserWSEndpoint,
                 }, puppetMaster.testResourceConfiguration.fs);
-                return await suite.run(input, puppetMaster.testResourceConfiguration, (fPath, value) => puppetMaster.testArtiFactoryfileWriter(tLog, (p) => {
+                const x = await suite.run(input, puppetMaster.testResourceConfiguration, (fPath, value) => puppetMaster.testArtiFactoryfileWriter(tLog, (p) => {
                     this.artifacts.push(p);
                 })(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value), tLog, puppetMaster);
+                // await puppetMaster.browser.disconnect();
+                // puppeteerBrowser.close();
+                return x;
             };
             const runner = suiteRunner(suite);
             return {
@@ -28,7 +31,7 @@ export class BaseBuilder {
                 },
                 runner,
                 receiveTestResourceConfig: async function (puppetMaster) {
-                    await puppetMaster.mkdirSync();
+                    // await puppetMaster.mkdirSync();
                     const logFilePath = "log.txt";
                     const access = await puppetMaster.createWriteStream(logFilePath);
                     const tLog = (...l) => {
@@ -43,6 +46,14 @@ export class BaseBuilder {
                         return suiteDone.givens[k].error;
                     }).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 {

package/dist/module/{lib → src/lib}/core.js

@@ -46,11 +46,55 @@ export default class Testeranto extends ClassBuilder {
             }
         }, class When extends BaseWhen {
             async andWhen(store, whenCB, testResource, pm) {
-                return await fullTestInterface.andWhen(store, whenCB, testResource, pm);
+                try {
+                    return await fullTestInterface.andWhen(store, whenCB, testResource, pm);
+                }
+                catch (e) {
+                    throw e;
+                }
+                // return fullTestInterface
+                //   .andWhen(store, whenCB, testResource, pm)
+                //   .catch((e) => {
+                //     throw e;
+                //   });
+                // return new Promise((res, rej) => {
+                //   fullTestInterface.andWhen(store, whenCB, testResource, pm);
+                // });
+                // return await fullTestInterface.andWhen(
+                //   store,
+                //   whenCB,
+                //   testResource,
+                //   pm
+                // );
             }
         }, class Then extends BaseThen {
-            async butThen(store, thenCB, testResourceConfiguration, pm) {
-                return await fullTestInterface.butThen(store, thenCB, testResourceConfiguration, pm);
+            async butThen(store, thenCB, testResource, pm) {
+                return fullTestInterface
+                    .butThen(store, thenCB, testResource, pm)
+                    .then((v) => {
+                    return v;
+                }, (e) => {
+                    console.log(" ERROR ", e);
+                    throw e;
+                });
+                // try {
+                //   console.log("mark 4");
+                //   return await fullTestInterface.butThen(
+                //     store,
+                //     thenCB,
+                //     testResource,
+                //     pm
+                //   );
+                // } catch (e) {
+                //   console.log("mar123");
+                //   throw e;
+                // }
+                // return await fullTestInterface.butThen(
+                //   store,
+                //   thenCB,
+                //   testResourceConfiguration,
+                //   pm
+                // );
             }
         }, class Check extends BaseCheck {
             constructor(name, features, checkCallback, whens, thens, initialValues) {

package/dist/module/testeranto.js

@@ -0,0 +1,13 @@
+export default {
+    botEmail: "adamwong246@gmail.com",
+    taskman: "adamwong246/kokomobay-taskman",
+    outdir: "docs",
+    tests: [["./src/LoginButton.test.tsx", "web", { ports: 0 }, []]],
+    debugger: true,
+    clearScreen: false,
+    devMode: true,
+    minify: false,
+    outbase: ".",
+    ports: [],
+    externals: [],
+};