testeranto 0.79.69 → 0.81.0

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

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+exports.default = (platform, entryPoints) => {
+    return {
+        name: "metafileWriter",
+        setup(build) {
+            build.onEnd((result) => {
+                if (result.errors.length === 0) {
+                    entryPoints.forEach((entryPoint) => {
+                        const filePath = path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `inputFiles.json`);
+                        const promptPath = path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `prompt.txt`);
+                        const testPaths = path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `tests.json`);
+                        const dirName = path_1.default.dirname(filePath);
+                        if (!fs_1.default.existsSync(dirName)) {
+                            fs_1.default.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_1.default.resolve(result.metafile.outputs[s].entryPoint) ===
+                                path_1.default.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_1.default.writeFileSync(filePath, jsonContent);
+                        fs_1.default.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/common/{esbuildConfigs → src/esbuildConfigs}/node.js

@@ -4,9 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const index_js_1 = __importDefault(require("./index.js"));
-const inputFilesPlugin_1 = __importDefault(require("./inputFilesPlugin"));
+const inputFilesPlugin_js_1 = __importDefault(require("./inputFilesPlugin.js"));
 exports.default = (config, entryPoints) => {
-    return Object.assign(Object.assign({}, (0, index_js_1.default)(config)), { splitting: true, outdir: config.outdir + "/node", inject: [`./node_modules/testeranto/dist/cjs-shim.js`], metafile: true, supported: {
+    return Object.assign(Object.assign({}, (0, index_js_1.default)(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",
@@ -21,7 +23,7 @@ exports.default = (config, entryPoints) => {
             ...config.externals,
         ], entryPoints: [...entryPoints], plugins: [
             ...(config.nodePlugins || []),
-            (0, inputFilesPlugin_1.default)("node", entryPoints),
+            (0, inputFilesPlugin_js_1.default)("node", entryPoints),
             {
                 name: "rebuild-notify",
                 setup(build) {

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

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

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

@@ -10,10 +10,22 @@ 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) {
@@ -230,6 +242,7 @@ 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}`);
             }
@@ -239,9 +252,10 @@ class BaseGiven {
             }
         }
         catch (e) {
+            console.error(e);
             this.error = e;
-            tLog(e);
-            tLog("\u0007"); // bell
+            tLog(e.stack);
+            // tLog("\u0007"); // bell
             // throw e;
         }
         finally {
@@ -327,6 +341,7 @@ class BaseGiven {
                         return Reflect.get(...arguments);
                     },
                 });
+                // console.log("mark5", this.store, key);
                 await this.afterEach(this.store, key, givenArtifactory, afterEachProxy);
             }
             catch (e) {
@@ -352,6 +367,14 @@ 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) => 
@@ -368,22 +391,12 @@ 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") {
@@ -401,6 +414,33 @@ 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);
                                                     }
@@ -420,13 +460,21 @@ 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;
+        // }
     }
 }
 exports.BaseWhen = BaseWhen;
@@ -507,10 +555,18 @@ 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/common/{lib → src/lib}/basebuilder.js

@@ -16,12 +16,15 @@ 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 {
@@ -31,7 +34,7 @@ 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) => {
@@ -46,6 +49,14 @@ 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/common/{lib → src/lib}/core.js

@@ -48,11 +48,55 @@ class Testeranto extends classBuilder_js_1.ClassBuilder {
             }
         }, class When extends abstractBase_js_1.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 abstractBase_js_1.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 abstractBase_js_1.BaseCheck {
             constructor(name, features, checkCallback, whens, thens, initialValues) {

package/dist/common/testeranto.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.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: [],
+};