testeranto 0.90.0 → 0.94.0

package/dist/module/src/Node.js

@@ -3,14 +3,16 @@ import { defaultTestResourceRequirement, } from "./lib/index.js";
 import { PM_Node } from "./PM/node.js";
 export class NodeTesteranto extends Testeranto {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
-        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
+        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface, () => {
+            // no-op
+        });
     }
     async receiveTestResourceConfig(partialTestResource) {
         const t = JSON.parse(partialTestResource);
         const pm = new PM_Node(t);
         const { failed, artifacts, logPromise, features } = await this.testJobs[0].receiveTestResourceConfig(pm);
-        pm.customclose();
-        return features;
+        // pm.customclose();
+        return { features, failed };
     }
 }
 export default async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {

package/dist/module/src/PM/main.js

@@ -81,9 +81,12 @@ export class PM_Main extends PM {
                 process.exit(-1);
             }
             const builtfile = dest + ".mjs";
-            await Promise.all(testConfig[3].map((sidecar) => {
+            const webSideCares = [];
+            await Promise.all(testConfig[3].map(async (sidecar) => {
                 if (sidecar[1] === "web") {
-                    return this.launchWebSideCar(sidecar[0], destinationOfRuntime(sidecar[0], "web", this.configs), sidecar);
+                    const s = await this.launchWebSideCar(sidecar[0], destinationOfRuntime(sidecar[0], "web", this.configs), sidecar);
+                    webSideCares.push(s);
+                    return s;
                 }
                 if (sidecar[1] === "node") {
                     return this.launchNodeSideCar(sidecar[0], destinationOfRuntime(sidecar[0], "node", this.configs), sidecar);
@@ -93,13 +96,15 @@ export class PM_Main extends PM {
                 return module.default.then((defaultModule) => {
                     defaultModule
                         .receiveTestResourceConfig(argz)
-                        .then(async (features) => {
+                        .then(async ({ features, failed }) => {
                         this.receiveFeatures(features, destFolder);
+                        console.log(`${src} completed with ${failed} errors`);
                     })
                         .catch((e) => {
-                        console.log("catch", e);
+                        console.log(`${src} errored with`, e);
                     })
                         .finally(() => {
+                        webSideCares.forEach((webSideCar) => webSideCar.close());
                         this.deregister(src);
                     });
                 });
@@ -115,18 +120,12 @@ export class PM_Main extends PM {
             const d = dest + ".mjs";
             console.log("launchWebSideCar", src, dest, d);
             const destFolder = dest.replace(".mjs", "");
-            const webArgz = JSON.stringify({
-                name: dest,
-                ports: [].toString(),
-                fs: destFolder,
-                browserWSEndpoint: this.browser.wsEndpoint(),
-            });
-            // files[src] = new Set();
-            // const evaluation = `
-            // console.log("importing ${dest}.mjs");
-            // import('${dest}.mjs').then(async (x) => {
-            //   console.log("imported", x.default);
-            // })`;
+            // const webArgz = JSON.stringify({
+            //   name: dest,
+            //   ports: [].toString(),
+            //   fs: destFolder,
+            //   browserWSEndpoint: this.browser.wsEndpoint(),
+            // });
             const fileStreams2 = [];
             const doneFileStream2 = [];
             return new Promise((res, rej) => {
@@ -205,14 +204,17 @@ export class PM_Main extends PM {
                     page.exposeFunction("end", async (uid) => {
                         return fileStreams2[uid].end();
                     });
-                    page.exposeFunction("customclose", (p, testName) => {
-                        fs.writeFileSync(p + "/manifest.json", JSON.stringify(Array.from(files[testName])));
-                        delete files[testName];
-                        Promise.all(screenshots[testName] || []).then(() => {
-                            delete screenshots[testName];
-                            // page.close();
-                        });
-                    });
+                    // page.exposeFunction("customclose", (p: string, testName: string) => {
+                    //   fs.writeFileSync(
+                    //     p + "/manifest.json",
+                    //     JSON.stringify(Array.from(files[testName]))
+                    //   );
+                    //   delete files[testName];
+                    //   Promise.all(screenshots[testName] || []).then(() => {
+                    //     delete screenshots[testName];
+                    //     // page.close();
+                    //   });
+                    // });
                     return page;
                 })
                     .then(async (page) => {
@@ -368,20 +370,21 @@ export class PM_Main extends PM {
                     // page.evaluate(`window["screenshot done"]`);
                 });
                 page.exposeFunction("writeFileSync", (fp, contents, testName) => {
-                    const dir = path.dirname(fp);
-                    fs.mkdirSync(dir, {
-                        recursive: true,
-                    });
-                    const p = new Promise(async (res, rej) => {
-                        fs.writeFileSync(fp, contents);
-                        res(fp);
-                    });
-                    doneFileStream2.push(p);
-                    if (!files[testName]) {
-                        files[testName] = new Set();
-                    }
-                    files[testName].add(fp);
-                    return p;
+                    return globalThis["writeFileSync"](fp, contents, testName);
+                    // const dir = path.dirname(fp);
+                    // fs.mkdirSync(dir, {
+                    //   recursive: true,
+                    // });
+                    // const p = new Promise<string>(async (res, rej) => {
+                    //   fs.writeFileSync(fp, contents);
+                    //   res(fp);
+                    // });
+                    // doneFileStream2.push(p);
+                    // if (!files[testName]) {
+                    //   files[testName] = new Set();
+                    // }
+                    // files[testName].add(fp);
+                    // return p;
                 });
                 page.exposeFunction("existsSync", (fp, contents) => {
                     return fs.existsSync(fp);
@@ -416,36 +419,37 @@ export class PM_Main extends PM {
                 page.exposeFunction("end", async (uid) => {
                     return fileStreams2[uid].end();
                 });
-                page.exposeFunction("customclose", (p, testName) => {
-                    // console.log("closing", p);
-                    fs.writeFileSync(p + "/manifest.json", JSON.stringify(Array.from(files[testName])));
-                    delete files[testName];
-                    // console.log("screenshots[testName]", screenshots[testName]);
-                    Promise.all(screenshots[testName] || []).then(() => {
-                        delete screenshots[testName];
-                        // page.close();
-                        // console.log("\t GOODBYE");
-                        // whyIsNodeRunning();
-                    });
-                    // globalThis["writeFileSync"](
-                    //   p + "/manifest.json",
-                    //   // files.entries()
-                    //   JSON.stringify(Array.from(files[testName]))
-                    // );
-                    // console.log("closing doneFileStream2", doneFileStream2);
-                    // console.log("closing doneFileStream2", doneFileStream2);
-                    // Promise.all([...doneFileStream2, ...screenshots2]).then(() => {
-                    //   page.close();
-                    // });
-                    // Promise.all(screenshots).then(() => {
-                    //   page.close();
-                    // });
-                    // setTimeout(() => {
-                    //   console.log("Delayed for 1 second.");
-                    //   page.close();
-                    // }, 5000);
-                    // return page.close();
-                });
+                // page.exposeFunction("customclose", (p: string, testName: string) => {
+                //   // console.log("closing", p);
+                //   console.log("\t GOODBYE customclose");
+                //   fs.writeFileSync(
+                //     p + "/manifest.json",
+                //     JSON.stringify(Array.from(files[testName]))
+                //   );
+                //   delete files[testName];
+                //   // console.log("screenshots[testName]", screenshots[testName]);
+                //   Promise.all(screenshots[testName] || []).then(() => {
+                //     delete screenshots[testName];
+                //   });
+                //   // globalThis["writeFileSync"](
+                //   //   p + "/manifest.json",
+                //   //   // files.entries()
+                //   //   JSON.stringify(Array.from(files[testName]))
+                //   // );
+                //   // console.log("closing doneFileStream2", doneFileStream2);
+                //   // console.log("closing doneFileStream2", doneFileStream2);
+                //   // Promise.all([...doneFileStream2, ...screenshots2]).then(() => {
+                //   //   page.close();
+                //   // });
+                //   // Promise.all(screenshots).then(() => {
+                //   //   page.close();
+                //   // });
+                //   // setTimeout(() => {
+                //   //   console.log("Delayed for 1 second.");
+                //   //   page.close();
+                //   // }, 5000);
+                //   // return page.close();
+                // });
                 page.exposeFunction("page", () => {
                     return page.mainFrame()._id;
                 });
@@ -478,12 +482,19 @@ export class PM_Main extends PM {
             })
                 .then(async (page) => {
                 const close = () => {
-                    console.log("evaluation complete.", dest);
-                    page.off("pageerror");
-                    page.close();
-                    this.deregister(t);
-                    stderrStream.close();
-                    stdoutStream.close();
+                    if (!files[t]) {
+                        files[t] = new Set();
+                    }
+                    // files[t].add(filepath);
+                    fs.writeFileSync(dest + "/manifest.json", JSON.stringify(Array.from(files[t])));
+                    delete files[t];
+                    Promise.all(screenshots[t] || []).then(() => {
+                        delete screenshots[t];
+                        page.close();
+                        this.deregister(t);
+                        stderrStream.close();
+                        stdoutStream.close();
+                    });
                 };
                 page.on("pageerror", (err) => {
                     console.debug(`Error from ${t}: [${err.name}] `);
@@ -513,26 +524,20 @@ export class PM_Main extends PM {
                 await page.goto(`file://${`${dest}.html`}`, {});
                 await page
                     .evaluate(evaluation)
-                    .then(async (features) => {
+                    .then(async ({ failed, features }) => {
                     this.receiveFeatures(features, destFolder);
+                    console.log(`${t} completed with ${failed} errors`);
                 })
                     .catch((e) => {
-                    console.log("evaluation failed.", dest);
-                    console.log(e);
+                    console.log(`${t} errored with`, e);
                 })
                     .finally(() => {
                     close();
-                    // console.log("evaluation complete.", dest);
-                    // page.close();
-                    // this.deregister(t);
-                    // stderrStream.close();
-                    // stdoutStream.close();
                 });
                 return page;
             });
         };
         this.receiveFeatures = (features, destFolder) => {
-            console.log("this.receiveFeatures", features);
             features
                 .reduce(async (mm, featureStringKey) => {
                 const accum = await mm;
@@ -599,12 +604,14 @@ export class PM_Main extends PM {
             return false;
         };
         globalThis["writeFileSync"] = (filepath, contents, testName) => {
-            // console.log("globalThis-writeFileSync", filepath);
+            // console.log(testName, "writeFileSync", filepath, testName);
             // Create directories if they don't exist
-            const dir = path.dirname(filepath.split("/").slice(0, -1).join("/"));
+            const dir = path.dirname(filepath);
+            // console.log(testName, "mkdirSync", dir);
             fs.mkdirSync(dir, {
                 recursive: true,
             });
+            // console.log(testName, "mkdirSync2");
             if (!files[testName]) {
                 files[testName] = new Set();
             }
@@ -645,13 +652,16 @@ export class PM_Main extends PM {
             await sPromise;
             return sPromise;
         };
-        globalThis["customclose"] = (p, testName) => {
-            if (!files[testName]) {
-                files[testName] = new Set();
-            }
-            fs.writeFileSync(p + "/manifest.json", JSON.stringify(Array.from(files[testName])));
-            delete files[testName];
-        };
+        // globalThis["customclose"] = (p: string, testName: string) => {
+        //   if (!files[testName]) {
+        //     files[testName] = new Set();
+        //   }
+        //   fs.writeFileSync(
+        //     p + "/manifest.json",
+        //     JSON.stringify(Array.from(files[testName]))
+        //   );
+        //   delete files[testName];
+        // };
     }
     $(selector) {
         throw new Error("Method not implemented.");

package/dist/module/src/Project.js

@@ -69,15 +69,17 @@ const compile = () => {
     return new Promise((resolve, reject) => {
         const tsc = spawn("tsc", ["-noEmit"]);
         tsc.stdout.on("data", (data) => {
-            // console.log(`stdout: ${data}`);
+            // console.log(`tsc stdout: ${data}`);
             const lines = data.toString().split("\n");
             logContent.push(...lines);
         });
         tsc.stderr.on("data", (data) => {
-            // console.error(`stderr: ${data}`);
+            console.error(`stderr: ${data}`);
+            process.exit(-1);
         });
         tsc.on("close", (code) => {
             parseTsErrors();
+            console.log("tsc done");
             resolve(`tsc process exited with code ${code}`);
             // if (code !== 0) {
             //   resolve(`tsc process exited with code ${code}`);
@@ -131,7 +133,6 @@ export class ITProject {
             }
         });
         fs.writeFileSync(`${this.config.outdir}/testeranto.json`, JSON.stringify(Object.assign(Object.assign({}, this.config), { buildDir: process.cwd() + "/" + this.config.outdir }), null, 2));
-        compile();
         Promise.resolve(Promise.all([...this.getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
             const sourceFileSplit = sourceFilePath.split("/");
             const sourceDir = sourceFileSplit.slice(0, -1);
@@ -155,6 +156,7 @@ export class ITProject {
             });
         });
         Promise.all([
+            compile(),
             esbuild
                 .context(esbuildNodeConfiger(this.config, nodeEntryPoints))
                 .then(async (nodeContext) => {

package/dist/module/src/Puppeteer.js

@@ -16,7 +16,7 @@ export default async (partialConfig) => {
         executablePath: 
         // process.env.CHROMIUM_PATH || "/opt/homebrew/bin/chromium",
         "/opt/homebrew/bin/chromium",
-        headless: false,
+        headless: true,
         dumpio: true,
         // timeout: 0,
         devtools: true,
@@ -55,10 +55,8 @@ export default async (partialConfig) => {
     process.stdin.on("keypress", (str, key) => {
         if (key.name === "q") {
             pm.shutDown();
-            // process.exit();
         }
         if (key.name === "x") {
-            // pm.shutDown();
             process.exit(-1);
         }
     });

package/dist/module/src/SubPackages/puppeteer.js

@@ -1,7 +1,7 @@
 import React from "react";
 import Testeranto from "../Node.js";
 export default (testInput, testSpecifications, testImplementations, testInterface) => {
-    return Testeranto(testInput, testSpecifications, testImplementations, Object.assign({ beforeAll(x) {
+    return Testeranto(testInput, testSpecifications, testImplementations, Object.assign({ beforeAll: (x) => {
             // process.parentPort.postMessage(
             //   `/docs/web/src/ClassicalComponent/test.html`
             // );

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

@@ -6,14 +6,22 @@ export const testInterface = {
     //   //   resolve(x());
     //   // });
     // },
-    beforeEach: async (subject, initializer, artificer) => {
+    // beforeEach: async (subject, initializer, artificer): Promise<IStore> => {
+    //   return new Promise((resolve, rej) => {
+    //     resolve(React.createElement(subject));
+    //   });
+    // },
+    andWhen: async (s, whenCB) => {
+        await whenCB(s());
         return new Promise((resolve, rej) => {
-            const x = React.createElement(subject);
-            console.log("react-element", x);
-            resolve(x);
+            resolve(React.createElement(s));
         });
+        // return whenCB(s);
     },
-    andWhen: function (s, whenCB) {
-        return whenCB(s);
+    butThen: async (subject, thenCB) => {
+        await thenCB(subject());
+        return new Promise((resolve, rej) => {
+            resolve(React.createElement(subject));
+        });
     },
 };

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

@@ -1,5 +1,10 @@
 import Testeranto from "../../../Node.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));
+export default (testImplementations, testSpecifications, testInput, testInterface = baseInterface) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, testInterface
+    // {
+    //   ...baseInterface,
+    //   ...testInterface,
+    // }
+    );
 };

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

@@ -13,52 +13,26 @@ export default (testInput, testSpecifications, testImplementations, testInterfac
         }
     }
     const t = Testeranto(testInput, testSpecifications, testImplementations, {
-        beforeAll: async (initialProps, artificer) => {
+        beforeAll: async (subject, artificer) => {
             return await new Promise((resolve, rej) => {
                 const htmlElement = document.getElementById("root");
                 if (htmlElement) {
                     const domRoot = ReactDom.createRoot(htmlElement);
-                    // Ignore these type errors
-                    domRoot.render(createElement(TesterantoComponent, Object.assign(Object.assign({}, initialProps), { done: (reactElement) => {
-                            resolve({
-                                htmlElement,
-                                reactElement,
-                                domRoot,
-                            });
-                        } }), []));
-                    // resolve({ htmlElement });
+                    resolve({ domRoot, htmlElement });
                 }
             });
         },
-        // beforeEach: async (
-        //   s,
-        //   initializer,
-        //   testResource,
-        //   artificer,
-        //   initialValues
-        // ): Promise<IStore> => {
-        //   return new Promise((resolve, rej) => {
-        //     console.log("beforeEach" + TesterantoComponent);
-        //     // const domRoot = ReactDom.createRoot(htmlElement);
-        //     // // Ignore these type errors
-        //     // domRoot.render(
-        //     //   createElement(
-        //     //     TesterantoComponent,
-        //     //     {
-        //     //       ...initializer,
-        //     //       done: (reactElement) => {
-        //     //         resolve({
-        //     //           htmlElement,
-        //     //           reactElement,
-        //     //           domRoot,
-        //     //         });
-        //     //       },
-        //     //     },
-        //     //     []
-        //     //   )
-        //     // );
-        //   });
-        // },
+        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: function (s, whenCB) {
             return whenCB(s);
         },

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

@@ -2,22 +2,17 @@ import React from "react";
 import renderer, { act } from "react-test-renderer";
 export const testInterface = {
     beforeEach: function (CComponent, propsAndChildren) {
-        function Link(props) {
-            const p = props.props;
-            const c = props.children;
-            return React.createElement(CComponent, p, c);
+        function Link(proper) {
+            return React.createElement(CComponent, proper(), []);
         }
         return new Promise((res, rej) => {
             act(async () => {
-                const p = propsAndChildren;
-                const y = new CComponent(p.props);
                 const testRenderer = await renderer.create(Link(propsAndChildren));
                 res(testRenderer);
             });
         });
     },
     andWhen: async function (renderer, whenCB) {
-        // console.log("andWhen", whenCB)
         await act(() => whenCB(renderer));
         return renderer;
     },
@@ -25,15 +20,12 @@ export const testInterface = {
     //   return whenCB()(s);
     // },
     butThen: async function (s, thenCB, tr) {
-        console.log("butThen", thenCB.toString());
         return thenCB(s);
     },
     afterEach: async function (store, ndx, artificer) {
-        // console.log("afterEach", store);
         return {};
     },
     afterAll: (store, artificer) => {
-        // console.log("afterAll", store);
         return;
     },
 };

package/dist/module/src/Web.js

@@ -1,36 +1,40 @@
 import { PM_Web } from "./PM/web";
 import Testeranto from "./lib/core.js";
 import { defaultTestResourceRequirement, } from "./lib/index.js";
+let errorCallback = (e) => { };
+let unhandledrejectionCallback = (event) => {
+    console.log("window.addEventListener unhandledrejection", event);
+    // cb({ error: event.reason.message });
+    // throw event;
+};
 export class WebTesteranto extends Testeranto {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
-        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
+        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface, (cb) => {
+            window.removeEventListener("error", errorCallback);
+            errorCallback = (e) => {
+                console.log("window.addEventListener error", e);
+                cb(e);
+                // throw e;
+            };
+            window.addEventListener("error", errorCallback);
+            window.removeEventListener("unhandledrejection", unhandledrejectionCallback);
+            /////////////////////
+            window.removeEventListener("unhandledrejection", unhandledrejectionCallback);
+            unhandledrejectionCallback = (event) => {
+                console.log("window.addEventListener unhandledrejection", event);
+                cb({ error: event.reason.message });
+                // throw event;
+            };
+            window.addEventListener("unhandledrejection", unhandledrejectionCallback);
+        });
     }
     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);
-        pm.customclose();
         return new Promise((res, rej) => {
-            res(features);
+            res({ features, failed });
         });
-        // return features;
-        // Promise.all([...artifacts, logPromise]).then(async () => {
-        //   console.log("hello world");
-        //   pm.customclose();
-        //   // we can't close the window becuase we might be taking a screenshot
-        //   // window.close();
-        //   // console.log(
-        //   //   "(window as any).browser",
-        //   //   JSON.stringify(await (window as any).browser)
-        //   // );
-        //   // var currentWindow = (await (window as any).browser).getCurrentWindow();
-        //   // window.close();
-        //   // var customWindow = window.open("", "_blank", "");
-        //   // customWindow.close();
-        //   // this.puppetMaster.browser.page
-        //   // window["customclose"]();
-        //   // console.log("goodbye", window["customclose"]());
-        // });
     }
 }
 export default async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {

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

@@ -2,14 +2,12 @@ import fs from "fs";
 import path from "path";
 const otherInputs = {};
 const register = (entrypoint, sources) => {
-    console.log("register", entrypoint, sources);
     if (!otherInputs[entrypoint]) {
         otherInputs[entrypoint] = new Set();
     }
     sources.forEach((s) => otherInputs[entrypoint].add(s));
 };
 function tree(meta, key) {
-    console.log("searching metafile for", key);
     const outputKey = Object.keys(meta.outputs).find((k) => {
         return meta.outputs[k].entryPoint === key;
     });