testeranto 0.111.0 → 0.112.0

package/dist/module/PM/node.js

@@ -0,0 +1,121 @@
+import fs from "fs";
+import path from "path";
+import { PM } from "./index.js";
+const fPaths = [];
+export class PM_Node extends PM {
+    constructor(t) {
+        super();
+        this.server = {};
+        this.testResourceConfiguration = t;
+    }
+    waitForSelector(p, s) {
+        return globalThis["waitForSelector"](p, s);
+    }
+    closePage(p) {
+        return globalThis["closePage"](p);
+    }
+    goto(cdpPage, url) {
+        return globalThis["goto"](cdpPage.mainFrame()._id, url);
+    }
+    newPage() {
+        return globalThis["newPage"]();
+    }
+    $(selector) {
+        throw new Error("Method not implemented.");
+    }
+    isDisabled(selector) {
+        throw new Error("Method not implemented.");
+    }
+    getAttribute(selector, attribute) {
+        throw new Error("Method not implemented.");
+    }
+    getValue(selector) {
+        throw new Error("Method not implemented.");
+    }
+    focusOn(selector) {
+        throw new Error("Method not implemented.");
+    }
+    typeInto(value) {
+        throw new Error("Method not implemented.");
+    }
+    page() {
+        return globalThis["page"]();
+    }
+    click(selector) {
+        return globalThis["click"](selector);
+    }
+    screencast(opts, page) {
+        return globalThis["screencast"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page.mainFrame()._id, this.testResourceConfiguration.name);
+    }
+    screencastStop(p) {
+        return globalThis["screencastStop"](p);
+    }
+    customScreenShot(opts, cdpPage) {
+        return globalThis["customScreenShot"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), cdpPage.mainFrame()._id, this.testResourceConfiguration.name);
+    }
+    existsSync(destFolder) {
+        return globalThis["existsSync"](this.testResourceConfiguration.fs + "/" + destFolder);
+    }
+    mkdirSync() {
+        return globalThis["mkdirSync"](this.testResourceConfiguration.fs + "/");
+    }
+    write(writeObject, contents) {
+        return globalThis["write"](writeObject.uid, contents);
+    }
+    writeFileSync(filepath, contents) {
+        return globalThis["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
+    }
+    createWriteStream(filepath) {
+        return globalThis["createWriteStream"](this.testResourceConfiguration.fs + "/" + filepath, this.testResourceConfiguration.name);
+    }
+    end(writeObject) {
+        return globalThis["end"](writeObject.uid);
+    }
+    customclose() {
+        globalThis["customclose"](this.testResourceConfiguration.fs, this.testResourceConfiguration.name);
+    }
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            callback(new Promise((res, rej) => {
+                tLog("testArtiFactory =>", fPath);
+                const cleanPath = path.resolve(fPath);
+                fPaths.push(cleanPath.replace(process.cwd(), ``));
+                const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+                fs.mkdir(targetDir, { recursive: true }, async (error) => {
+                    if (error) {
+                        console.error(`❗️testArtiFactory failed`, targetDir, error);
+                    }
+                    fs.writeFileSync(path.resolve(targetDir.split("/").slice(0, -1).join("/"), "manifest"), fPaths.join(`\n`), {
+                        encoding: "utf-8",
+                    });
+                    if (Buffer.isBuffer(value)) {
+                        fs.writeFileSync(fPath, value, "binary");
+                        res();
+                    }
+                    else if (`string` === typeof value) {
+                        fs.writeFileSync(fPath, value.toString(), {
+                            encoding: "utf-8",
+                        });
+                        res();
+                    }
+                    else {
+                        /* @ts-ignore:next-line */
+                        const pipeStream = value;
+                        const myFile = fs.createWriteStream(fPath);
+                        pipeStream.pipe(myFile);
+                        pipeStream.on("close", () => {
+                            myFile.close();
+                            res();
+                        });
+                    }
+                });
+            }));
+        };
+    }
+    // launch(options?: PuppeteerLaunchOptions): Promise<Browser>;
+    startPuppeteer(options) {
+        // return puppeteer.connect(options).then((b) => {
+        //   this.browser = b;
+        // });
+    }
+}

package/dist/module/PM/web.js

@@ -0,0 +1,117 @@
+import { PM } from "./index.js";
+export class PM_Web extends PM {
+    constructor(t) {
+        super();
+        this.server = {};
+        this.testResourceConfiguration = t;
+    }
+    waitForSelector(p, s) {
+        return window["waitForSelector"](p, s);
+    }
+    screencast(opts) {
+        return window["screencast"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), this.testResourceConfiguration.name);
+    }
+    screencastStop(recorder) {
+        return window["screencastStop"](recorder);
+    }
+    closePage(p) {
+        return window["closePage"](p);
+    }
+    goto(p, url) {
+        return window["goto"](p, url);
+    }
+    newPage() {
+        return window["newPage"]();
+    }
+    $(selector) {
+        return window["$"](selector);
+    }
+    isDisabled(selector) {
+        return window["isDisabled"](selector);
+    }
+    getAttribute(selector, attribute) {
+        return window["getValue"](selector, attribute);
+    }
+    getValue(selector) {
+        return window["getValue"](selector);
+    }
+    focusOn(selector) {
+        return window["focusOn"](selector);
+    }
+    typeInto(value) {
+        return window["typeInto"](value);
+    }
+    page() {
+        return window["page"]();
+    }
+    click(selector) {
+        return window["click"](selector);
+    }
+    customScreenShot(opts) {
+        return window["customScreenShot"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), this.testResourceConfiguration.name);
+    }
+    existsSync(destFolder) {
+        return window["existsSync"](destFolder);
+    }
+    mkdirSync(x) {
+        return window["mkdirSync"](this.testResourceConfiguration.fs + "/");
+    }
+    write(writeObject, contents) {
+        return window["write"](writeObject.uid, contents);
+    }
+    writeFileSync(filepath, contents) {
+        return window["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
+    }
+    createWriteStream(filepath) {
+        return window["createWriteStream"](this.testResourceConfiguration.fs + "/" + filepath, this.testResourceConfiguration.name);
+    }
+    end(writeObject) {
+        return window["end"](writeObject.uid);
+    }
+    customclose() {
+        window["customclose"](this.testResourceConfiguration.fs, this.testResourceConfiguration.name);
+    }
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            callback(new Promise((res, rej) => {
+                tLog("testArtiFactory =>", fPath);
+                // const cleanPath = path.resolve(fPath);
+                // fPaths.push(cleanPath.replace(process.cwd(), ``));
+                // const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+                // fs.mkdir(targetDir, { recursive: true }, async (error) => {
+                //   if (error) {
+                //     console.error(`❗️testArtiFactory failed`, targetDir, error);
+                //   }
+                //   fs.writeFileSync(
+                //     path.resolve(
+                //       targetDir.split("/").slice(0, -1).join("/"),
+                //       "manifest"
+                //     ),
+                //     fPaths.join(`\n`),
+                //     {
+                //       encoding: "utf-8",
+                //     }
+                //   );
+                //   if (Buffer.isBuffer(value)) {
+                //     fs.writeFileSync(fPath, value, "binary");
+                //     res();
+                //   } else if (`string` === typeof value) {
+                //     fs.writeFileSync(fPath, value.toString(), {
+                //       encoding: "utf-8",
+                //     });
+                //     res();
+                //   } else {
+                //     /* @ts-ignore:next-line */
+                //     const pipeStream: PassThrough = value;
+                //     const myFile = fs.createWriteStream(fPath);
+                //     pipeStream.pipe(myFile);
+                //     pipeStream.on("close", () => {
+                //       myFile.close();
+                //       res();
+                //     });
+                //   }
+                // });
+            }));
+        };
+    }
+}

package/dist/module/ReportClient.js

@@ -0,0 +1,97 @@
+import ReactDom from "react-dom/client";
+import React, { useEffect, useState } from "react";
+import 'bootstrap/dist/css/bootstrap.min.css';
+import "./style.css";
+import { Footer } from "./Footer";
+import { Table } from "react-bootstrap";
+const BigBoard = () => {
+    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 [bigBoard, setBigBoard] = useState({});
+    useEffect(() => {
+        (async () => {
+            fetch('/kokomoBay/docs/summary.json')
+                .then(response => response.json())
+                .then(json => {
+                setBigBoard(json);
+            })
+                .catch(error => console.error(error));
+        })();
+    }, []);
+    // const [staticAnalysis, setStaticAnalysis] = useState<Record<string, string>>({});
+    // useEffect(() => {
+    //   (async () => {
+    //     let accumulator = {};
+    //     for (const t of (configs || { tests: [] as ITestTypes[] }).tests) {
+    //       accumulator[t[0]] = await (await fetch(`/kokomoBay/docs/${t[1]}/${t[0].split(".").slice(0, -1).join(".")}/lint_errors.txt`)).text()
+    //     }
+    //     setStaticAnalysis(accumulator);
+    //   })();
+    // }, [configs, bigBoard]);
+    // const [typeErrors, setTypeErrors] = useState<Record<string, string>>({});
+    // useEffect(() => {
+    //   (async () => {
+    //     let accumulator = {};
+    //     for (const t of (configs || { tests: [] as ITestTypes[] }).tests) {
+    //       accumulator[t[0]] = await (await fetch(`/kokomoBay/docs/${t[1]}/${t[0].split(".").slice(0, -1).join(".")}/type_errors.txt`)).text()
+    //     }
+    //     setTypeErrors(accumulator);
+    //   })();
+    // }, [configs, bigBoard]);
+    // const [bddErrors, setBddErrors] = useState<Record<string, string>>({});
+    // useEffect(() => {
+    //   (async () => {
+    //     let accumulator = {};
+    //     for (const t of (configs || { tests: [] as ITestTypes[] }).tests) {
+    //       accumulator[t[0]] = await (await fetch(`/kokomoBay/docs/${t[1]}/${t[0].split(".").slice(0, -1).join(".")}/bdd_errors.txt`)).text()
+    //     }
+    //     setBddErrors(accumulator);
+    //   })();
+    // }, [configs, bigBoard]);
+    if (!configs) {
+        return React.createElement("div", null, "loading...");
+    }
+    const collated = configs.tests.map((c) => {
+        return Object.assign(Object.assign({}, bigBoard[c[0]]), { name: c[0], runTime: c[1], tr: c[2], sidecars: c[3], staticAnalysis: bigBoard[c[0]].staticErrors, typeErrors: bigBoard[c[0]].typeErrors, bddErrors: bigBoard[c[0]].runTimeError, prompt: bigBoard[c[0]].prompt });
+    });
+    return React.createElement("div", null,
+        React.createElement(Table, { striped: true, bordered: true, hover: true },
+            React.createElement("thead", null,
+                React.createElement("tr", null,
+                    React.createElement("th", null),
+                    React.createElement("th", null, "platform"),
+                    React.createElement("th", null, "BDD errors"),
+                    React.createElement("th", null, "Lint errors"),
+                    React.createElement("th", null, "Type errors"),
+                    React.createElement("th", null, "prompt"))),
+            React.createElement("tbody", null, ...collated.map((c) => {
+                return React.createElement("tr", null,
+                    React.createElement("td", null, c.name),
+                    React.createElement("td", null, c.runTime),
+                    React.createElement("td", null,
+                        React.createElement("a", { href: `${c.runTime}/${c.name.split(".").slice(0, -1).join(".")}/littleBoard.html` }, c.bddErrors)),
+                    React.createElement("td", null,
+                        React.createElement("a", { href: `${c.runTime}/${c.name.split(".").slice(0, -1).join(".")}/lint_errors.json` }, c.staticAnalysis)),
+                    React.createElement("td", null,
+                        React.createElement("a", { href: `${c.runTime}/${c.name.split(".").slice(0, -1).join(".")}/type_errors.txt` }, c.typeErrors)),
+                    React.createElement("td", null,
+                        React.createElement("pre", null, c.prompt)));
+            }))),
+        React.createElement(Footer, null));
+};
+document.addEventListener("DOMContentLoaded", function () {
+    const elem = document.getElementById("root");
+    if (elem) {
+        ReactDom.createRoot(elem).render(React.createElement(BigBoard, {}, []));
+    }
+});
+console.log("hello BigBoard!");

package/dist/module/ReportServer.js

@@ -0,0 +1,17 @@
+import staticServer from "node-static";
+import http from "http";
+const main = async () => {
+    process.chdir("../"); // Navigate one level up
+    const fileServer = new staticServer.Server(".", {});
+    http
+        .createServer(function (request, response) {
+        request
+            .addListener("end", function () {
+            fileServer.serve(request, response);
+        })
+            .resume();
+    })
+        .listen(8080);
+    console.log("Server running on port 8080");
+};
+main();

package/dist/module/SubPackages/react/component/node.js

@@ -0,0 +1,14 @@
+import React from "react";
+import Testeranto from "../../../Node.js";
+export default (testImplementations, testSpecifications, testInput) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, {
+        beforeEach: async () => {
+            return new Promise((resolve, rej) => {
+                resolve(React.createElement(testInput, {}, []));
+            });
+        },
+        andWhen: function (s, whenCB) {
+            return whenCB()(s);
+        },
+    });
+};

package/dist/module/SubPackages/react/component/web.js

@@ -0,0 +1,14 @@
+import React from "react";
+import Testeranto from "../../../Web.js";
+export default (testImplementations, testSpecifications, testInput) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, {
+        beforeEach: async () => {
+            return new Promise((resolve, rej) => {
+                resolve(React.createElement(testInput, {}, []));
+            });
+        },
+        andWhen: function (s, whenCB) {
+            return whenCB()(s);
+        },
+    });
+};

package/dist/module/SubPackages/react/jsx/index.js

@@ -0,0 +1,15 @@
+import React from "react";
+export const testInterface = {
+    andWhen: async (s, whenCB) => {
+        await whenCB(s());
+        return new Promise((resolve, rej) => {
+            resolve(React.createElement(s));
+        });
+    },
+    butThen: async (subject, thenCB) => {
+        await thenCB(subject());
+        return new Promise((resolve, rej) => {
+            resolve(React.createElement(subject));
+        });
+    },
+};

package/dist/module/SubPackages/react/jsx/node.js

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

package/dist/module/SubPackages/react/jsx/web.js

@@ -0,0 +1,5 @@
+import Testeranto from "../../../Web.js";
+import { testInterface as baseInterface, } from "./index.js";
+export default (testImplementations, testSpecifications, testInput, testInterface) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, Object.assign(Object.assign({}, baseInterface), testInterface));
+};

package/dist/module/SubPackages/react-dom/component/node.js

@@ -0,0 +1,80 @@
+import { createElement } from "react";
+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) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, {
+        beforeEach: async () => {
+            return new Promise((resolve, rej) => {
+                resolve(createElement(testInput));
+            });
+        },
+        andWhen: async function (s, whenCB) {
+            return whenCB(s);
+        },
+        butThen: async function (s) {
+            return s;
+        },
+        afterEach: async function () {
+            return {};
+        },
+        afterAll: () => {
+            return;
+        },
+    });
+};
+// type IInput = typeof React.Component;
+// type InitialState = unknown;
+// type IWhenShape = any;
+// type IThenShape = any;
+// type ISelection = string;
+// type IStore = string;
+// type ISubject = string
+// export default <ITestShape extends ITTestShape>(
+//   testImplementations: ITestImplementation<
+//     InitialState,
+//     ISelection,
+//     IWhenShape,
+//     IThenShape,
+//     ITestShape
+//   >,
+//   testSpecifications: ITestSpecification<
+//     ITestShape,
+//     ISubject,
+//     IStore,
+//     ISelection,
+//     IThenShape
+//   >,
+//   testInput: IInput
+// ) => {
+//   return Testeranto<
+//     ITestShape,
+//     IInput,
+//     ISubject,
+//     IStore,
+//     ISelection,
+//     IThenShape,
+//     IWhenShape,
+//     InitialState
+//   >(
+//     testInput,
+//     testSpecifications,
+//     testImplementations,
+//     {
+//       beforeEach: async (
+//         element,
+//         ndx,
+//         testResource,
+//         artificer
+//       ): Promise<IStore> => {
+//         return new Promise((resolve, rej) => {
+//           resolve(ReactDOMServer.renderToStaticMarkup(element));
+//         });
+//       },
+//       andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+//         throw new Error(`"andWhens" are not permitted`);
+//       }
+//     },
+//   )
+// };

package/dist/module/SubPackages/react-dom/component/web.js

@@ -0,0 +1,62 @@
+import { createElement } from "react";
+import ReactDom from "react-dom/client";
+import Testeranto from "../../../Web.js";
+export default (testInput, testSpecifications, testImplementations, testInterface) => {
+    class TesterantoComponent extends testInput {
+        constructor(props) {
+            super(props);
+            this.done = props.done;
+        }
+        componentDidMount() {
+            super.componentDidMount && super.componentDidMount();
+            return this.done(this);
+        }
+    }
+    const t = Testeranto(testInput, testSpecifications, testImplementations, {
+        beforeAll: async (subject, artificer) => {
+            return await new Promise((resolve, rej) => {
+                const htmlElement = document.getElementById("root");
+                if (htmlElement) {
+                    const domRoot = ReactDom.createRoot(htmlElement);
+                    resolve({ domRoot, htmlElement });
+                }
+            });
+        },
+        beforeEach: async ({ domRoot, htmlElement }, initialValues, testResource, artificer) => {
+            return new Promise(async (resolve, rej) => {
+                domRoot.render(createElement(TesterantoComponent, Object.assign(Object.assign({}, initialValues), { done: (reactElement) => {
+                        resolve({
+                            htmlElement,
+                            reactElement,
+                            domRoot,
+                        });
+                    } }), []));
+            });
+        },
+        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, utils) {
+                return store;
+            },
+        afterAll: async (store, utils) => {
+            // setTimeout(() => {
+            //   console.log("This will run after 1 second");
+            // }, 1000); // 1000 milliseconds = 1 second
+            // store.htmlElement.remove();
+            // store.htmlElement = document.createElement("root");
+            return store;
+        },
+    });
+    document.addEventListener("DOMContentLoaded", function () {
+        const elem = document.getElementById("root");
+        if (elem) {
+            return t;
+        }
+    });
+    return t;
+};

package/dist/module/SubPackages/react-dom/jsx/index.js

@@ -0,0 +1 @@
+export {};

package/dist/module/SubPackages/react-dom/jsx/node.js

@@ -0,0 +1,31 @@
+import { createElement } from "react";
+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) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, {
+        beforeAll: async (prototype, artificer) => {
+            return await new Promise((resolve, rej) => {
+                resolve(null);
+            });
+        },
+        beforeEach: async () => {
+            return new Promise((resolve, rej) => {
+                resolve(createElement(testInput));
+            });
+        },
+        andWhen: async function (s, whenCB) {
+            return s;
+        },
+        butThen: async function (s) {
+            return s;
+        },
+        afterEach: async function (store, ndx, artificer) {
+            return {};
+        },
+        afterAll: (store, artificer) => {
+            return;
+        },
+    });
+};