testeranto 0.121.1 → 0.125.1

package/dist/module/src/SubPackages/react-dom/jsx/static.js

@@ -0,0 +1,53 @@
+import { createElement, useEffect, useRef } from "react";
+import React from "react";
+import ReactDom from "react-dom/client";
+const TesterantoComponent = ({ done, innerComp, }) => {
+    const myContainer = useRef(null);
+    useEffect(() => {
+        done(myContainer.current);
+    }, []);
+    return React.createElement("div", { ref: myContainer }, innerComp());
+};
+export const testInterface = {
+    beforeAll: async (reactElement, itr) => {
+        return await new Promise((resolve, rej) => {
+            const htmlElement = document.getElementById("root");
+            if (htmlElement) {
+                const domRoot = ReactDom.createRoot(htmlElement);
+                domRoot.render(createElement(TesterantoComponent, {
+                    // ...initialProps,
+                    innerComp: reactElement,
+                    done: (reactElement) => {
+                        resolve({
+                            htmlElement,
+                            reactElement,
+                            domRoot,
+                        });
+                    },
+                }, []));
+                // resolve({ htmlElement });
+            }
+        });
+    },
+    beforeEach: async (subject) => {
+        return subject;
+    },
+    andWhen: async function (s, whenCB, tr, utils) {
+        return whenCB(s, utils);
+    },
+    butThen: async function (s, thenCB, tr, utils) {
+        return new Promise((resolve, rej) => {
+            resolve(thenCB(s, utils));
+        });
+    },
+    afterEach: async function (store, ndx, artificer) {
+        return new Promise((resolve, rej) => {
+            resolve({});
+        });
+    },
+    afterAll: (store, artificer) => {
+        return new Promise((resolve, rej) => {
+            resolve({});
+        });
+    },
+};

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

@@ -0,0 +1,11 @@
+import Testeranto from "../../../Web.js";
+import { testInterfacer } from "./dynamic.js";
+export default (testImplementations, testSpecifications, testInput) => {
+    const t = Testeranto(testInput, testSpecifications, testImplementations, testInterfacer(testInput));
+    document.addEventListener("DOMContentLoaded", function () {
+        const rootElement = document.getElementById("root");
+        if (rootElement) {
+        }
+    });
+    return t;
+};

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

@@ -0,0 +1,14 @@
+export {};
+// export type ISuper<T> = T extends infer U ? U : object;
+// export type InitialState = unknown;
+// export type IWhenShape = any;
+// export type IThenShape = any;
+// export type ISelection = renderer.ReactTestRenderer;
+// export type IStore = renderer.ReactTestRenderer;
+// export type ISubject = renderer.ReactTestRenderer;
+// export type IImpl<I extends IT, O extends OT, M> = ITestImplementation<I, O>;
+// export type ITestSpecification<
+//   I extends IT,
+//   O extends OT,
+//   M
+// > = ITestSpecification<I, O>;

package/dist/module/src/SubPackages/react-test-renderer/component/pure.js

@@ -0,0 +1,3 @@
+import Testeranto from "../../../Pure.js";
+import { testInterface } from "./interface";
+export default (testImplementations, testSpecifications, testInput) => Testeranto(testInput, testSpecifications, testImplementations, testInterface);

package/dist/module/src/SubPackages/react-test-renderer/component/test/implementation.js

@@ -0,0 +1,54 @@
+// import { ITestImplementation } from "testeranto/src/Types";
+// import { I } from "testeranto/src/SubPackages/react-test-renderer/component";
+import { assert } from "chai";
+export const testImplementation = {
+    suites: {
+        Default: "default",
+    },
+    givens: {
+        AnEmptyState: () => {
+            return { foo: "bar" };
+        },
+    },
+    whens: {
+        IClickTheButton: () => async (component) => {
+            const button = component.root.findByType("button");
+            button.props.onClick();
+            return component;
+        },
+        IClickTheHeader: () => async (component) => {
+            try {
+                const header = component.root.findByType("h1");
+                header.props.onClick();
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (error) {
+                // Expected error - header click fails
+            }
+            return component;
+        },
+    },
+    thens: {
+        ThePropsIs: (expectation) => (component) => {
+            const propsElement = component.root.findByProps({ id: "theProps" });
+            return assert.deepEqual(JSON.parse(propsElement.props.children), expectation);
+        },
+        TheStatusIs: (expectation) => (component) => {
+            try {
+                const statElement = component.root.findByProps({ id: "theStat" });
+                const actual = JSON.parse(statElement.props.children);
+                assert.deepEqual(actual, expectation, "the status was not as expected");
+                // eslint-disable-next-line @typescript-eslint/no-unused-vars
+            }
+            catch (error) {
+                assert.fail(`Element with id "theStat" not found`);
+            }
+            return component;
+        },
+    },
+    checks: {
+        AnEmptyState: () => {
+            return { foo: "bar" };
+        },
+    },
+};

package/dist/module/src/SubPackages/react-test-renderer/component/test/node.js

@@ -0,0 +1,5 @@
+import test from "../node";
+import component from "../../../../examples/react/component/index";
+import { specification } from "../../../../examples/react/component/test";
+import { testImplementation } from "./implementation";
+export default test(testImplementation, specification, component);

package/dist/module/src/SubPackages/react-test-renderer/component/test/pure.js

@@ -0,0 +1,5 @@
+import test from "../pure";
+import component from "../../../../examples/react/component/index";
+import { specification } from "../../../../examples/react/component/test";
+import { testImplementation } from "./implementation";
+export default test(testImplementation, specification, component);

package/dist/module/src/SubPackages/react-test-renderer/component/test/web.js

@@ -0,0 +1,5 @@
+import test from "../web";
+import component from "../../../../examples/react/component/index";
+import { specification } from "../../../../examples/react/component/test";
+import { testImplementation } from "./implementation";
+export default test(testImplementation, specification, component);

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

@@ -0,0 +1,5 @@
+import test from "../../../Pure.js";
+import { testInterface } from "./index.js";
+export default (testImplementations, testSpecifications, testInput, testInterface2 = testInterface) => {
+    return test(testInput, testSpecifications, testImplementations, testInterface2);
+};

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

@@ -9,7 +9,7 @@ const StepPane = ({ step }) => {
         React.createElement("pre", null,
             React.createElement("code", null, JSON.stringify(step, null, 2))));
 };
-const TestPane = ({ given, log }) => {
+const TestPane = ({ given }) => {
     return React.createElement("div", null,
         "    ",
         React.createElement(Tab.Container, { id: "TestPane-tabs", defaultActiveKey: "first" },
@@ -43,30 +43,30 @@ const TestPane = ({ given, log }) => {
                                 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 [configs, setConfigs] = useState<IBuiltConfig>();
+    // useEffect(() => {
+    //   (async () => {
+    //     fetch('../config.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]);
+    }, []);
     const [log, setLog] = useState();
     useEffect(() => {
         (async () => {
             setLog(await (await fetch(`log.txt`)).text());
         })();
-    }, [configs]);
-    if (!configs || !bddErrors || !log) {
+    }, []);
+    if (!bddErrors || !log) {
         return React.createElement("div", null, "loading...");
     }
     return React.createElement("div", null,
@@ -94,7 +94,10 @@ const BddPage = () => {
 document.addEventListener("DOMContentLoaded", function () {
     const elem = document.getElementById("root");
     if (elem) {
-        ReactDom.createRoot(elem).render(React.createElement(BddPage, {}, []));
+        if (elem) {
+            const root = ReactDom.createRoot(elem);
+            root.render(React.createElement(BddPage, {}));
+        }
     }
 });
 console.log("hello BddPage!");

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

@@ -31,10 +31,7 @@ export class WebTesteranto extends Testeranto {
     async receiveTestResourceConfig(partialTestResource) {
         const t = partialTestResource; //JSON.parse(partialTestResource);
         const pm = new PM_Web(t);
-        const { failed, artifacts, logPromise, features } = await this.testJobs[0].receiveTestResourceConfig(pm);
-        return new Promise((res, rej) => {
-            res({ features, failed });
-        });
+        return await this.testJobs[0].receiveTestResourceConfig(pm);
     }
 }
 export default async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {

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

@@ -2,11 +2,12 @@ import ansiC from "ansi-colors";
 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 esbuildImportConfiger from "./esbuildConfigs/pure.js";
 import webHtmlFrame from "./web.html.js";
+import { getRunnables } from "./utils.js";
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY)
     process.stdin.setRawMode(true);
@@ -57,8 +58,9 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     });
     let nodeDone = false;
     let webDone = false;
+    let importDone = false;
     let status = "build";
-    const { nodeEntryPoints, webEntryPoints } = getRunnables(config.tests);
+    const { nodeEntryPoints, webEntryPoints, importEntryPoints } = getRunnables(config.tests, testName);
     const onNodeDone = () => {
         nodeDone = true;
         onDone();
@@ -67,11 +69,15 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
         webDone = true;
         onDone();
     };
+    const onImportDone = () => {
+        importDone = true;
+        onDone();
+    };
     const onDone = async () => {
-        if (nodeDone && webDone) {
+        if (nodeDone && webDone && importDone) {
             status = "built";
         }
-        if (nodeDone && webDone && mode === "once") {
+        if (nodeDone && webDone && importDone && mode === "once") {
             console.log(ansiC.inverse(`${testName} has been built. Goodbye.`));
             process.exit();
         }
@@ -146,60 +152,34 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
             .mkdir(path.dirname(htmlFilePath), { recursive: true })
             .then((x) => fs.writeFileSync(htmlFilePath, webHtmlFrame(jsfilePath, htmlFilePath)));
     })));
-    glob(`${process.cwd()}/testeranto/bundles/${testName}/chunk-*.mjs`, {
-        ignore: "node_modules/**",
-    }).then((chunks) => {
-        chunks.forEach((chunk) => {
-            fs.unlinkSync(chunk);
-        });
-    });
+    // glob(`${process.cwd()}/testeranto/bundles/${testName}/chunk-*.mjs`, {
+    //   ignore: "node_modules/**",
+    // }).then((chunks) => {
+    //   chunks.forEach((chunk) => {
+    //     fs.unlinkSync(chunk);
+    //   });
+    // });
     await Promise.all([
-        esbuild
-            .context(esbuildNodeConfiger(config, Object.keys(nodeEntryPoints), testName))
-            .then(async (nodeContext) => {
-            if (mode === "dev") {
-                await nodeContext.watch().then((v) => {
-                    onNodeDone();
-                });
-            }
-            else {
-                nodeContext.rebuild().then((v) => {
-                    onNodeDone();
-                });
-            }
-            return nodeContext;
-        }),
-        esbuild
-            .context(esbuildWebConfiger(config, Object.keys(webEntryPoints), testName))
-            .then(async (webContext) => {
-            if (mode === "dev") {
-                await webContext.watch().then((v) => {
-                    onWebDone();
-                });
-            }
-            else {
-                webContext.rebuild().then((v) => {
-                    onWebDone();
-                });
-            }
-            return webContext;
+        ...[
+            [esbuildImportConfiger, importEntryPoints, onImportDone],
+            [esbuildNodeConfiger, nodeEntryPoints, onNodeDone],
+            [esbuildWebConfiger, webEntryPoints, onWebDone],
+        ].map(([configer, entryPoints, done]) => {
+            esbuild
+                .context(configer(config, Object.keys(entryPoints), testName))
+                .then(async (ctx) => {
+                if (mode === "dev") {
+                    await ctx.watch().then((v) => {
+                        done();
+                    });
+                }
+                else {
+                    ctx.rebuild().then((v) => {
+                        done();
+                    });
+                }
+                return ctx;
+            });
         }),
     ]);
 });
-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);
-};

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

@@ -1,16 +1,14 @@
 const config = {
     src: "src",
-    // outdir: "docs",
     tests: [],
     debugger: true,
     clearScreen: false,
-    devMode: true,
     minify: false,
-    // outbase: ".",
     ports: ["3001"],
     externals: [],
     nodePlugins: [],
     webPlugins: [],
+    importPlugins: [],
     featureIngestor: function (s) {
         throw new Error("Function not implemented.");
     },

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

@@ -2,9 +2,7 @@ import baseEsBuildConfig from "./index.js";
 import inputFilesPlugin from "./inputFilesPlugin.js";
 import featuresPlugin from "./featuresPlugin";
 export default (config, entryPoints, testName) => {
-    const { inputFilesPluginFactory, register } = inputFilesPlugin("node", 
-    // entryPoints,
-    testName);
+    const { inputFilesPluginFactory, register } = inputFilesPlugin("node", testName);
     return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { splitting: true, outdir: `testeranto/bundles/node/${testName}/`, 
         // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
         metafile: true, supported: {
@@ -18,7 +16,10 @@ export default (config, entryPoints, testName) => {
             inputFilesPluginFactory,
             {
                 name: "rebuild-notify",
-                setup(build) {
+                setup: (build) => {
+                    build.onStart(() => {
+                        console.log(`> node build starting...`);
+                    });
                     build.onEnd((result) => {
                         console.log(`> node build ended with ${result.errors.length} errors`);
                         if (result.errors.length > 0) {

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

@@ -0,0 +1,36 @@
+import baseEsBuildConfig from "./index.js";
+import inputFilesPlugin from "./inputFilesPlugin.js";
+import featuresPlugin from "./featuresPlugin.js";
+export default (config, entryPoints, testName) => {
+    const { inputFilesPluginFactory, register } = inputFilesPlugin("pure", testName);
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { drop: ["console", "debugger"], splitting: true, outdir: `testeranto/bundles/pure/${testName}/`, 
+        // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
+        metafile: true, supported: {
+            "dynamic-import": true,
+        }, define: {
+            "process.env.FLUENTFFMPEG_COV": "0",
+        }, absWorkingDir: process.cwd(), banner: {
+            js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`,
+        }, platform: "node", external: ["react", ...config.externals], entryPoints: [...entryPoints], plugins: [
+            featuresPlugin,
+            inputFilesPluginFactory,
+            {
+                name: "rebuild-notify",
+                setup: (build) => {
+                    build.onStart(() => {
+                        console.log(`> pure build starting...`);
+                    });
+                    build.onEnd((result) => {
+                        console.log(`> pure build ended with ${result.errors.length} errors`);
+                        if (result.errors.length > 0) {
+                            console.log(result);
+                        }
+                        // console.log(result);
+                        // result.errors.length !== 0 && process.exit(-1);
+                    });
+                },
+            },
+            ...((config.nodePlugins || []).map((p) => p(register, entryPoints)) ||
+                []),
+        ] });
+};

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

@@ -29,7 +29,10 @@ export default (config, entryPoints, testName) => {
             inputFilesPluginFactory,
             {
                 name: "rebuild-notify",
-                setup(build) {
+                setup: (build) => {
+                    build.onStart(() => {
+                        console.log(`> web build starting...`);
+                    });
                     build.onEnd((result) => {
                         console.log(`> web build ended with ${result.errors.length} errors`);
                         if (result.errors.length > 0) {
@@ -40,6 +43,6 @@ export default (config, entryPoints, testName) => {
                     });
                 },
             },
-            ...(config.nodePlugins.map((p) => p(register, entryPoints)) || []),
+            ...((config.webPlugins || []).map((p) => p(register, entryPoints)) || []),
         ] });
 };

package/dist/module/src/examples/react/component/index.js

@@ -0,0 +1,26 @@
+import React from "react";
+export class ClassicalComponent extends React.Component {
+    constructor(props) {
+        super(props);
+        this.state = {
+            count: 0,
+        };
+    }
+    render() {
+        return (React.createElement("div", { style: { border: "3px solid black" } },
+            React.createElement("h1", { id: "theHeader" }, "Hello Marcus"),
+            React.createElement("pre", { id: "theProps" }, JSON.stringify(this.props)),
+            React.createElement("p", null,
+                "foo: ",
+                this.props.foo),
+            React.createElement("pre", { id: "theStat" }, JSON.stringify(this.state)),
+            React.createElement("p", null,
+                "count: ",
+                this.state.count,
+                " times"),
+            React.createElement("button", { id: "theButton", onClick: async () => {
+                    this.setState({ count: this.state.count + 1 });
+                } }, "Click")));
+    }
+}
+export default ClassicalComponent;

package/dist/module/src/examples/react/component/test.js

@@ -0,0 +1,32 @@
+export const specification = (Suite, Given, When, Then) => {
+    return [
+        Suite.Default("a classical react component", {
+            test0: Given.AnEmptyState([`I click 4 times and the count is 3`], [
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheHeader(),
+                // When.IClickTheButton(),
+            ], [
+                Then.ThePropsIs({ foo: "bar", children: [] }),
+                Then.TheStatusIs({ count: 3 }),
+            ]),
+            test1: Given.AnEmptyState([`Count is 1 by default`], [When.IClickTheButton()], [
+                Then.ThePropsIs({ foo: "bar", children: [] }),
+                Then.TheStatusIs({ count: 1 }),
+            ]),
+            test2: Given.AnEmptyState([`0`], [
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+                When.IClickTheButton(),
+            ], [Then.TheStatusIs({ count: 9 })]),
+            test3: Given.AnEmptyState([`0`], [When.IClickTheButton(), When.IClickTheButton()], [Then.TheStatusIs({ count: 2 })]),
+        }, []),
+    ];
+};