testeranto 0.100.0 → 0.110.0

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

@@ -33,17 +33,17 @@ export default (testInput, testSpecifications, testImplementations, testInterfac
                     } }), []));
             });
         },
-        andWhen: function (s, whenCB) {
+        andWhen: async function (s, whenCB) {
             return whenCB(s);
         },
         butThen: async function (s, thenCB) {
             return thenCB(s);
         },
         afterEach: (testInterface === null || testInterface === void 0 ? void 0 : testInterface.afterEach) ||
-            async function (store, ndx, artificer, utils) {
+            async function (store, ndx, utils) {
                 return store;
             },
-        afterAll: async (store, artificer, utils) => {
+        afterAll: async (store, utils) => {
             // setTimeout(() => {
             //   console.log("This will run after 1 second");
             // }, 1000); // 1000 milliseconds = 1 second

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

@@ -1,6 +1,6 @@
 import { createElement } from "react";
-import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
-import Stream from 'stream';
+import { renderToStaticMarkup, renderToStaticNodeStream, } from "react-dom/server";
+import Stream from "stream";
 import Testeranto from "../../../Node.js";
 export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
 export default (testImplementations, testSpecifications, testInput) => {
@@ -10,7 +10,7 @@ export default (testImplementations, testSpecifications, testInput) => {
                 resolve(null);
             });
         },
-        beforeEach: async (reactComponent, ndx, testRsource, artificer) => {
+        beforeEach: async () => {
             return new Promise((resolve, rej) => {
                 resolve(createElement(testInput));
             });

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

@@ -32,30 +32,31 @@ export default (testImplementations, testSpecifications, testInput) => {
                 }
             });
         },
-        beforeEach: async (subject, initializer, artificer, testResource, pm) => {
-            return new Promise((resolve, rej) => {
-                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);
-            });
+        beforeEach: async (subject) => {
+            return subject;
+            // return new Promise((resolve, rej) => {
+            //   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, tr, utils) {
+        andWhen: async function (s, whenCB, tr, utils) {
             return whenCB(s, utils);
             // return new Promise(async (resolve, rej) => {
             //   // resolve(await whenCB(s, utils));

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

@@ -1,13 +1,7 @@
 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) {
+    butThen: async function (s, thenCB) {
         // console.log("butThen", thenCB.toString());
         return thenCB(s);
     },

package/dist/module/TestReport.js

@@ -0,0 +1,91 @@
+import ReactDom from "react-dom/client";
+import React, { useEffect, useState } from "react";
+import { Col, Nav, Row, Tab } from "react-bootstrap";
+import 'bootstrap/dist/css/bootstrap.min.css';
+import "./style.css";
+import { Footer } from "./Footer";
+const StepPane = ({ step }) => {
+    return React.createElement("div", null,
+        React.createElement("pre", null,
+            React.createElement("code", null, JSON.stringify(step, null, 2))));
+};
+const TestPane = ({ given }) => {
+    return React.createElement("div", null,
+        "    ",
+        React.createElement(Tab.Container, { id: "TestPane-tabs", defaultActiveKey: "first" },
+            React.createElement(Row, null,
+                React.createElement(Col, { sm: 3 },
+                    React.createElement(Nav, { variant: "pills", className: "flex-column" },
+                        React.createElement(Nav.Item, null,
+                            React.createElement(Nav.Link, { eventKey: `bdd-features` }, "features"),
+                            ...given.whens.map((w, ndx) => React.createElement(Nav.Link, { eventKey: `bdd-when-${ndx}` },
+                                "When ",
+                                w.name,
+                                " ",
+                                w.error && "!")),
+                            ...given.thens.map((t, ndx) => React.createElement(Nav.Link, { eventKey: `bdd-then-${ndx}` },
+                                "Then ",
+                                t.name,
+                                " ",
+                                t.error && "!")),
+                            React.createElement(Nav.Link, { eventKey: `bdd-errors` }, "errors")))),
+                React.createElement(Col, { sm: 9 },
+                    React.createElement(Tab.Content, null,
+                        React.createElement(Tab.Pane, { eventKey: `bdd-features` },
+                            React.createElement("pre", null,
+                                React.createElement("code", null, JSON.stringify(given.features, null, 2)))),
+                        ...given.whens.map((w, ndx) => React.createElement(Tab.Pane, { eventKey: `bdd-when-${ndx}` },
+                            React.createElement(StepPane, { step: w }))),
+                        ...given.thens.map((t, ndx) => React.createElement(Tab.Pane, { eventKey: `bdd-then-${ndx}` },
+                            React.createElement(StepPane, { step: t }))),
+                        React.createElement(Tab.Pane, { eventKey: `bdd-errors` },
+                            React.createElement("pre", null,
+                                React.createElement("code", null, JSON.stringify(given.error, null, 2)))))))));
+};
+const BddPage = () => {
+    const [configs, setConfigs] = useState();
+    useEffect(() => {
+        (async () => {
+            fetch('/kokomoBay/docs/testeranto.json')
+                .then(response => response.json())
+                .then(json => {
+                setConfigs(json);
+            })
+                .catch(error => console.error(error));
+        })();
+    }, []);
+    const [bddErrors, setBddErrors] = useState();
+    useEffect(() => {
+        (async () => {
+            setBddErrors(await (await fetch(`tests.json`)).json());
+        })();
+    }, [configs]);
+    if (!configs || !bddErrors) {
+        return React.createElement("div", null, "loading...");
+    }
+    return React.createElement("div", null,
+        "  ",
+        React.createElement(Row, null,
+            React.createElement(Col, { sm: 12 },
+                React.createElement("h2", null, bddErrors.name))),
+        React.createElement(Row, null,
+            React.createElement(Tab.Container, { id: "root-tab-container", defaultActiveKey: "first" },
+                React.createElement(Row, null,
+                    React.createElement(Col, { sm: 3 },
+                        React.createElement(Nav, { variant: "pills", className: "flex-column" }, ...bddErrors.givens.map((g) => React.createElement(Nav.Item, null,
+                            React.createElement(Nav.Link, { eventKey: g.key },
+                                g.key,
+                                ": Given ",
+                                g.name))))),
+                    React.createElement(Col, { sm: 9 },
+                        React.createElement(Tab.Content, null, ...bddErrors.givens.map((g) => React.createElement(Tab.Pane, { eventKey: g.key },
+                            React.createElement(TestPane, { given: g })))))))),
+        React.createElement(Footer, null));
+};
+document.addEventListener("DOMContentLoaded", function () {
+    const elem = document.getElementById("root");
+    if (elem) {
+        ReactDom.createRoot(elem).render(React.createElement(BddPage, {}, []));
+    }
+});
+console.log("hello BddPage!");

package/dist/module/build.js

@@ -0,0 +1,184 @@
+import fs from "fs";
+import path from "path";
+import readline from "readline";
+import { glob } from "glob";
+import esbuild from "esbuild";
+import esbuildNodeConfiger from "./esbuildConfigs/node.js";
+import esbuildWebConfiger from "./esbuildConfigs/web.js";
+import webHtmlFrame from "./web.html.js";
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY)
+    process.stdin.setRawMode(true);
+const getRunnables = (tests, payload = {
+    nodeEntryPoints: {},
+    webEntryPoints: {},
+}) => {
+    return tests.reduce((pt, cv, cndx, cry) => {
+        if (cv[1] === "node") {
+            pt.nodeEntryPoints[cv[0]] = path.resolve(`./docs/node/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`);
+        }
+        else if (cv[1] === "web") {
+            pt.webEntryPoints[cv[0]] = path.resolve(`./docs/web/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`);
+        }
+        if (cv[3].length) {
+            getRunnables(cv[3], payload);
+        }
+        return pt;
+    }, payload);
+};
+import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
+    const rawConfig = module.default;
+    const getSecondaryEndpointsPoints = (runtime) => {
+        const meta = (ts, st) => {
+            ts.forEach((t) => {
+                if (t[1] === runtime) {
+                    st.add(t[0]);
+                }
+                if (Array.isArray(t[3])) {
+                    meta(t[3], st);
+                }
+            });
+            return st;
+        };
+        return Array.from(meta(config.tests, new Set()));
+    };
+    const config = Object.assign(Object.assign({}, rawConfig), { buildDir: process.cwd() + "/" + rawConfig.outdir });
+    let nodeDone = false;
+    let webDone = false;
+    let mode = config.devMode ? "DEV" : "PROD";
+    let status = "build";
+    // let pm: PM_Main | undefined = new PM_Main(config);
+    // const fileHashes = {};
+    const { nodeEntryPoints, webEntryPoints } = getRunnables(config.tests);
+    const onNodeDone = () => {
+        nodeDone = true;
+        onDone();
+    };
+    const onWebDone = () => {
+        webDone = true;
+        onDone();
+    };
+    const onDone = async () => {
+        if (nodeDone && webDone) {
+            status = "built";
+        }
+        if (nodeDone && webDone && status === "built") {
+            // Object.entries(nodeEntryPoints).forEach(([k, outputFile]) => {
+            //   console.log("watching", outputFile);
+            //   try {
+            //     watch(outputFile, async (filename) => {
+            //       const hash = await fileHash(outputFile);
+            //       if (fileHashes[k] !== hash) {
+            //         fileHashes[k] = hash;
+            //         console.log(`< ${filename} `);
+            //         pm.launchNode(k, outputFile);
+            //       }
+            //     });
+            //   } catch (e) {
+            //     console.error(e);
+            //   }
+            // });
+            // Object.entries(webEntryPoints).forEach(([k, outputFile]) => {
+            //   console.log("watching", outputFile);
+            //   watch(outputFile, async (filename) => {
+            //     const hash = await fileHash(outputFile);
+            //     console.log(`< ${filename} ${hash}`);
+            //     if (fileHashes[k] !== hash) {
+            //       fileHashes[k] = hash;
+            //       pm.launchWeb(k, outputFile);
+            //     }
+            //   });
+            // });
+        }
+        if (nodeDone && webDone && mode === "PROD") {
+            console.log("Testeranto-EsBuild is all done. Goodbye!");
+            process.exit();
+        }
+        else {
+            if (mode === "PROD") {
+                console.log("waiting for tests to finish");
+                console.log(JSON.stringify({
+                    nodeDone: nodeDone,
+                    webDone: webDone,
+                    mode: mode,
+                }, null, 2));
+            }
+            else {
+                console.log("waiting for tests to change");
+            }
+            if (config.devMode) {
+                console.log("ready and watching for changes...");
+            }
+            else {
+                // pm.shutDown();
+            }
+            ////////////////////////////////////////////////////////////////////////////////
+        }
+    };
+    console.log(`Press 'q' to shutdown gracefully. Press 'x' to shutdown forcefully.`);
+    process.stdin.on("keypress", (str, key) => {
+        if (key.name === "q") {
+            console.log("Testeranto-Build is shutting down...");
+            mode = "PROD";
+            onDone();
+        }
+        if (key.name === "x") {
+            console.log("Testeranto-Build is shutting down forcefully...");
+            process.exit(-1);
+        }
+    });
+    fs.writeFileSync(`${config.outdir}/testeranto.json`, JSON.stringify(config, null, 2));
+    Promise.resolve(Promise.all([...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
+        const sourceFileSplit = sourceFilePath.split("/");
+        const sourceDir = sourceFileSplit.slice(0, -1);
+        const sourceFileName = sourceFileSplit[sourceFileSplit.length - 1];
+        const sourceFileNameMinusJs = sourceFileName
+            .split(".")
+            .slice(0, -1)
+            .join(".");
+        const htmlFilePath = path.normalize(`${process.cwd()}/${config.outdir}/web/${sourceDir.join("/")}/${sourceFileNameMinusJs}.html`);
+        const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
+        return fs.promises
+            .mkdir(path.dirname(htmlFilePath), { recursive: true })
+            .then((x) => fs.writeFileSync(htmlFilePath, webHtmlFrame(jsfilePath, htmlFilePath)));
+    })));
+    glob(`./${config.outdir}/chunk-*.mjs`, {
+        ignore: "node_modules/**",
+    }).then((chunks) => {
+        chunks.forEach((chunk) => {
+            fs.unlinkSync(chunk);
+        });
+    });
+    await Promise.all([
+        esbuild
+            .context(esbuildNodeConfiger(config, Object.keys(nodeEntryPoints)))
+            .then(async (nodeContext) => {
+            if (config.devMode) {
+                await nodeContext.watch().then((v) => {
+                    onNodeDone();
+                });
+            }
+            else {
+                nodeContext.rebuild().then((v) => {
+                    onNodeDone();
+                });
+            }
+            return nodeContext;
+        }),
+        esbuild
+            .context(esbuildWebConfiger(config, Object.keys(webEntryPoints)))
+            .then(async (webContext) => {
+            if (config.devMode) {
+                await webContext.watch().then((v) => {
+                    onWebDone();
+                });
+            }
+            else {
+                webContext.rebuild().then((v) => {
+                    onWebDone();
+                });
+            }
+            return webContext;
+        }),
+    ]);
+});

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

@@ -1,4 +1,5 @@
 const config = {
+    src: "src",
     outdir: "docs",
     tests: [],
     debugger: true,

package/dist/module/esbuildConfigs/eslint-formatter-testeranto.js

@@ -0,0 +1,3 @@
+export default function (results) {
+    return JSON.stringify(results, null, 2);
+}

package/dist/module/esbuildConfigs/inputFilesPlugin.js

@@ -0,0 +1,22 @@
+import fs from "fs";
+const otherInputs = {};
+const register = (entrypoint, sources) => {
+    if (!otherInputs[entrypoint]) {
+        otherInputs[entrypoint] = new Set();
+    }
+    sources.forEach((s) => otherInputs[entrypoint].add(s));
+};
+export default (platform, entryPoints) => {
+    return {
+        register,
+        inputFilesPluginFactory: {
+            name: "metafileWriter",
+            setup(build) {
+                build.onEnd((result) => {
+                    // console.log("build.onEnd", entryPoints);
+                    fs.writeFileSync(`docs/${platform}/metafile.json`, JSON.stringify(result, null, 2));
+                });
+            },
+        },
+    };
+};

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

@@ -11,18 +11,9 @@ export default (config, entryPoints) => {
             "process.env.FLUENTFFMPEG_COV": "0",
         }, absWorkingDir: process.cwd(), banner: {
             js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
-        }, platform: "node", external: [
-            // "testeranto.json",
-            // "features.test.js",
-            "react",
-            // "events",
-            // "ganache"
-            ...config.externals,
-        ], entryPoints: [...entryPoints], plugins: [
+        }, platform: "node", external: ["react", ...config.externals], entryPoints: [...entryPoints], plugins: [
             featuresPlugin,
-            ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
             inputFilesPluginFactory,
-            // inputFilesPlugin("node", entryPoints),
             {
                 name: "rebuild-notify",
                 setup(build) {
@@ -36,5 +27,6 @@ export default (config, entryPoints) => {
                     });
                 },
             },
+            ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
         ] });
 };

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

@@ -4,19 +4,9 @@ import inputFilesPlugin from "./inputFilesPlugin.js";
 import featuresPlugin from "./featuresPlugin.js";
 export default (config, entryPoints) => {
     const { inputFilesPluginFactory, register } = inputFilesPlugin("web", entryPoints);
-    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { 
-        // inject: ["./node_modules/testeranto/dist/cjs-shim.js"],
-        // banner: {
-        //   js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
-        // },
-        // splitting: true,
-        outdir: config.outdir + "/web", alias: {
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { outdir: config.outdir + "/web", alias: {
             react: path.resolve("./node_modules/react"),
         }, metafile: true, external: [
-            // "testeranto.json",
-            // "features.test.ts",
-            // "url",
-            // "react",
             "path",
             "fs",
             "stream",
@@ -36,8 +26,6 @@ export default (config, entryPoints) => {
             "dns",
         ], platform: "browser", entryPoints: [...entryPoints], plugins: [
             featuresPlugin,
-            // markdownPlugin({}),
-            ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
             inputFilesPluginFactory,
             {
                 name: "rebuild-notify",
@@ -52,5 +40,6 @@ export default (config, entryPoints) => {
                     });
                 },
             },
+            ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
         ] });
 };

package/dist/module/{src/init-docs.js → init-docs.js}

@@ -1,5 +1,5 @@
 import fs from "fs";
-import Init from "../dist/module/src/Init";
+import Init from "./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.");

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

@@ -57,6 +57,7 @@ export class BaseSuite {
                     if (prop === "writeFileSync") {
                         return (fp, contents) => target[prop](`suite-${sNdx}/beforeAll/${fp}`, contents);
                     }
+                    /* @ts-ignore:next-line */
                     return Reflect.get(...arguments);
                 },
             });
@@ -156,6 +157,7 @@ export class BaseGiven {
                     if (prop === "screencast") {
                         return (opts, p) => target.screencast(Object.assign(Object.assign({}, opts), { path: `suite-${suiteNdx}/given-${key}/when/beforeEach/${opts.path}` }), p);
                     }
+                    /* @ts-ignore:next-line */
                     return Reflect.get(...arguments);
                 },
             });
@@ -190,6 +192,7 @@ export class BaseGiven {
                         if (prop === "writeFileSync") {
                             return (fp, contents) => target[prop](`suite-${suiteNdx}/given-${key}/afterEach/${fp}`, contents);
                         }
+                        /* @ts-ignore:next-line */
                         return Reflect.get(...arguments);
                     },
                 });
@@ -226,6 +229,7 @@ export class BaseWhen {
                 if (prop === "writeFileSync") {
                     return (fp, contents) => target[prop](`${filepath}/andWhen/${fp}`, contents);
                 }
+                /* @ts-ignore:next-line */
                 return Reflect.get(...arguments);
             },
         });
@@ -269,6 +273,7 @@ export class BaseThen {
                     if (prop === "writeFileSync") {
                         return (fp, contents) => target[prop](`${filepath}/${fp}`, contents);
                     }
+                    /* @ts-ignore:next-line */
                     return Reflect.get(...arguments);
                 },
             });
@@ -297,7 +302,7 @@ export class BaseCheck {
     }
     async check(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm) {
         tLog(`\n Check: ${this.name}`);
-        const store = await this.checkThat(subject, testResourceConfiguration, artifactory);
+        const store = await this.checkThat(subject, testResourceConfiguration, artifactory, pm);
         await this.checkCB(Object.entries(this.whens).reduce((a, [key, when]) => {
             a[key] = async (payload) => {
                 return await when(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, pm, "x");

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

@@ -39,17 +39,30 @@ export class BaseBuilder {
                     const numberOfFailures = Object.keys(suiteDone.givens).filter((k) => {
                         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(`bdd_errors.txt`, numberOfFailures.toString());
+                    const o = this.toObj();
+                    puppetMaster.writeFileSync(`littleBoard.html`, `
+            <!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta name="description" content="Webpage description goes here" />
+  <meta charset="utf-8" />
+  <title>kokomoBay - testeranto</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="author" content="" />
+
+  <link rel="stylesheet" href="/kokomoBay/docs/TestReport.css" />
+  <script src="/kokomoBay/docs/TestReport.js"></script>
+
+</head>
+
+  <body>
+    <h1>Test report</h1>
+            <div id="root"/>
+  </body>
+            `);
                     puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2));
-                    // console.log(`exiting gracefully with ${numberOfFailures} failures.`);
                     return {
                         failed: numberOfFailures,
                         artifacts: this.artifacts || [],

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

@@ -31,8 +31,6 @@ export class ClassBuilder extends BaseBuilder {
             };
             return a;
         }, {});
-        super(input, classySuites, classyGivens, classyWhens, classyThens, classyChecks, testResourceRequirement, testSpecification
-        // puppetMaster
-        );
+        super(input, classySuites, classyGivens, classyWhens, classyThens, classyChecks, testResourceRequirement, testSpecification);
     }
 }