testeranto 0.79.68 → 0.80.0

package/dist/module/build-tests.js

@@ -0,0 +1,10 @@
+// import { ITProject } from "./src/Project.js";
+// import Project from "./testeranto.js";
+import process from "process";
+import { ITProject } from "./src/Project";
+// import { ITProject } from "testeranto/src/Project";
+// process.chdir(__dirname);
+// import Puppeteer from "./src/Puppeteer.js";
+console.log(process.argv);
+const Project = await import(process.argv[2]);
+export default new ITProject(Project);

package/dist/module/init-docs.js

@@ -0,0 +1,3 @@
+import Init from "./src/Init.js";
+import Project from "./testeranto.js";
+export default Init(Project);

package/dist/module/run-tests.js

@@ -0,0 +1,6 @@
+import process from "process";
+process.chdir(__dirname);
+import Puppeteer from "./src/Puppeteer.js";
+console.log(process.argv);
+const Project = await import(process.argv[2]);
+export default Puppeteer(Project);

package/dist/module/src/Aider.js

@@ -0,0 +1,89 @@
+import fs from "fs";
+import { spawn } from "child_process";
+export const execCommand = async (command) => {
+    return new Promise((resolve, reject) => {
+        const [cmd, ...args] = command.split(" ");
+        const childProcess = spawn(cmd, args);
+        childProcess.stdout.on("data", (data) => {
+            process.stdout.write(data.toString());
+        });
+        childProcess.stderr.on("data", (data) => {
+            process.stderr.write(data.toString());
+        });
+        childProcess.on("error", (error) => {
+            reject(error);
+        });
+        childProcess.on("exit", (code) => {
+            if (code === 0) {
+                resolve();
+            }
+            else {
+                reject(new Error(`Command exited with code ${code}.`));
+            }
+        });
+    });
+};
+const key = process.argv[2];
+console.log(key);
+const exitcode = fs.readFileSync(`${key}/exitcode`).toString();
+console.log("exitcode", exitcode);
+// if (exitcode != "0") {
+if (exitcode != "0") {
+    const inputFiles = JSON.parse(fs.readFileSync(`${key}/inputFiles.json`).toString());
+    inputFiles.push(`${key}/tests.json`);
+    const features = await (await Promise.all(Array.from(new Set(JSON.parse(fs.readFileSync(`${key}/tests.json`).toString())
+        .givens.reduce((mm, lm) => {
+        mm.push(lm.features.reduce((mm2, lm2) => {
+            mm2.push(lm2);
+            return mm2;
+        }, []));
+        return mm;
+    }, [])
+        .flat()
+        .flat()))))
+        .reduce(async (mm, feature) => {
+        const req = await octokit.request(`GET /repos/adamwong246/kokomobay-taskman/contents/Task/${feature}.json`, {
+            owner: "adamwong246",
+            repo: "kokomoBay-taskman",
+            path: `Task/${feature}.json`,
+            headers: {
+                "X-GitHub-Api-Version": "2022-11-28",
+            },
+        });
+        const j = JSON.parse(atob(req.data.content));
+        (await mm).push([
+            feature,
+            JSON.stringify({
+                name: j.name,
+                body: j.body,
+            }),
+        ]);
+        return mm;
+    }, Promise.resolve([]))
+        .then((z) => {
+        const final = z.reduce((mm, [k, v], ndx) => {
+            mm[k] = v;
+            return mm;
+        }, {});
+        const as = JSON.stringify(final);
+        fs.writeFile(`./${key}/features.json`, as, () => {
+            inputFiles.push(`./${key}/features.json`);
+            const scriptCommand = `aider --model deepseek --api-key deepseek=${process.env.DEEPSEEK_KEY} --message "Fix the failing tests" ${inputFiles.join(" ")}`;
+            console.log("scriptCommand", scriptCommand);
+            execCommand(scriptCommand);
+            // itermTab(scriptCommand).then(() => console.log("yay"));
+            // const child = spawn("xterm -e", scriptCommand.split(" "), {
+            //   detached: true,
+            //   stdio: "ignore",
+            // });
+            // runCommandInITerm(scriptCommand);
+        });
+        //
+    });
+    // features.then((x) => {
+    //   console.log("done", x);
+    // });
+}
+else {
+    console.log("that test is not failing");
+}

package/dist/module/src/Init.js

@@ -0,0 +1,5 @@
+import fs from "fs";
+export default async (partialConfig) => {
+    const config = Object.assign(Object.assign({}, partialConfig), { buildDir: process.cwd() + "/" + partialConfig.outdir });
+    fs.writeFileSync(`${config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, config), { buildDir: process.cwd() + "/" + config.outdir }), null, 2));
+};

package/dist/module/{PM → src/PM}/main.js

@@ -408,7 +408,7 @@ export class PM_Main extends PM {
                     delete files[testName];
                     Promise.all(screenshots[testName] || []).then(() => {
                         delete screenshots[testName];
-                        page.close();
+                        // page.close();
                     });
                     // globalThis["writeFileSync"](
                     //   p + "/manifest.json",
@@ -434,8 +434,14 @@ export class PM_Main extends PM {
                 .then(async (page) => {
                 page.on("console", (log) => console.debug(`Log from client: [${log.text()}] `));
                 await page.goto(`file://${`${dest}.html`}`, {});
-                page.evaluate(evaluation).finally(() => {
+                page
+                    .evaluate(evaluation)
+                    .catch((e) => {
                     console.log("evaluation failed.", dest);
+                    console.log(e);
+                })
+                    .finally(() => {
+                    console.log("evaluation complete.", dest);
                 });
                 return page;
             });
@@ -544,7 +550,7 @@ export class PM_Main extends PM {
         throw new Error("Method not implemented.");
     }
     async startPuppeteer(options, destfolder) {
-        this.browser = await puppeteer.launch(options);
+        this.browser = (await puppeteer.launch(options));
         return this.browser;
     }
     end(accessObject) {

package/dist/module/{Puppeteer.js → src/Puppeteer.js}

@@ -10,7 +10,7 @@ const childProcesses = {};
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
-console.log("hello Puppeteer", process.env);
+// console.log("hello Puppeteer", process.env);
 console.log("\n Puppeteer is running. Press 'q' to quit\n");
 process.stdin.on("keypress", (str, key) => {
     if (key.name === "q") {
@@ -22,17 +22,21 @@ export default async (partialConfig) => {
     fs.writeFileSync(`${config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, config), { buildDir: process.cwd() + "/" + config.outdir }), null, 2));
     const pm = new PM_Main(config);
     await pm.startPuppeteer({
+        // timeout: 1,
         waitForInitialPage: false,
-        executablePath: process.env.CHROMIUM_PATH || "/opt/homebrew/bin/chromium",
+        executablePath: 
+        // process.env.CHROMIUM_PATH || "/opt/homebrew/bin/chromium",
+        "/opt/homebrew/bin/chromium",
         headless: true,
-        // dumpio: true,
+        dumpio: true,
+        // timeout: 0,
         args: [
+            // "--auto-open-devtools-for-tabs",
             "--disable-features=IsolateOrigins,site-per-process",
             "--disable-site-isolation-trials",
             "--allow-insecure-localhost",
             "--allow-file-access-from-files",
             "--allow-running-insecure-content",
-            // "--auto-open-devtools-for-tabs",
             "--disable-dev-shm-usage",
             "--disable-extensions",
             "--disable-gpu",

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/{esbuildConfigs → src/esbuildConfigs}/inputFilesPlugin.js

@@ -1,18 +1,20 @@
 import fs from "fs";
 import path from "path";
 export default (platform, entryPoints) => {
+    console.log("mark3", platform);
     return {
         name: "metafileWriter",
         setup(build) {
             build.onEnd((result) => {
                 if (result.errors.length === 0) {
                     entryPoints.forEach((entryPoint) => {
+                        console.log("mark1", entryPoint);
                         const filePath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `inputFiles.json`);
                         const dirName = path.dirname(filePath);
                         if (!fs.existsSync(dirName)) {
                             fs.mkdirSync(dirName, { recursive: true });
                         }
-                        fs.writeFileSync(filePath, JSON.stringify(Object.keys(Object.keys(result.metafile.outputs)
+                        const jsonContent = JSON.stringify(Object.keys(Object.keys(result.metafile.outputs)
                             .filter((s) => {
                             if (!result.metafile.outputs[s].entryPoint) {
                                 return false;
@@ -35,7 +37,8 @@ export default (platform, entryPoints) => {
                             const matches = f.match(regex);
                             const passes = (matches === null || matches === void 0 ? void 0 : matches.length) === 1;
                             return !passes;
-                        })));
+                        }));
+                        fs.writeFileSync(filePath, jsonContent);
                     });
                 }
             });

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

@@ -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

@@ -226,6 +226,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 +236,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 +325,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 +350,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 +374,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 +397,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);
                                                     }

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

@@ -43,6 +43,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/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: [],
+};