testeranto 0.85.0 → 0.94.0

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

@@ -12,14 +12,22 @@ exports.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_1.default.createElement(subject);
-            console.log("react-element", x);
-            resolve(x);
+            resolve(react_1.default.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_1.default.createElement(subject));
+        });
     },
 };

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

@@ -5,6 +5,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const Node_js_1 = __importDefault(require("../../../Node.js"));
 const index_js_1 = require("./index.js");
-exports.default = (testImplementations, testSpecifications, testInput, testInterface) => {
-    return (0, Node_js_1.default)(testInput, testSpecifications, testImplementations, Object.assign(Object.assign({}, index_js_1.testInterface), testInterface));
+exports.default = (testImplementations, testSpecifications, testInput, testInterface = index_js_1.testInterface) => {
+    return (0, Node_js_1.default)(testInput, testSpecifications, testImplementations, testInterface
+    // {
+    //   ...baseInterface,
+    //   ...testInterface,
+    // }
+    );
 };

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

@@ -18,52 +18,26 @@ exports.default = (testInput, testSpecifications, testImplementations, testInter
         }
     }
     const t = (0, Web_js_1.default)(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 = client_1.default.createRoot(htmlElement);
-                    // Ignore these type errors
-                    domRoot.render((0, react_1.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((0, react_1.createElement)(TesterantoComponent, Object.assign(Object.assign({}, initialValues), { done: (reactElement) => {
+                        resolve({
+                            htmlElement,
+                            reactElement,
+                            domRoot,
+                        });
+                    } }), []));
+            });
+        },
         andWhen: function (s, whenCB) {
             return whenCB(s);
         },

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

@@ -31,22 +31,17 @@ const react_1 = __importDefault(require("react"));
 const react_test_renderer_1 = __importStar(require("react-test-renderer"));
 exports.testInterface = {
     beforeEach: function (CComponent, propsAndChildren) {
-        function Link(props) {
-            const p = props.props;
-            const c = props.children;
-            return react_1.default.createElement(CComponent, p, c);
+        function Link(proper) {
+            return react_1.default.createElement(CComponent, proper(), []);
         }
         return new Promise((res, rej) => {
             (0, react_test_renderer_1.act)(async () => {
-                const p = propsAndChildren;
-                const y = new CComponent(p.props);
                 const testRenderer = await react_test_renderer_1.default.create(Link(propsAndChildren));
                 res(testRenderer);
             });
         });
     },
     andWhen: async function (renderer, whenCB) {
-        // console.log("andWhen", whenCB)
         await (0, react_test_renderer_1.act)(() => whenCB(renderer));
         return renderer;
     },
@@ -54,15 +49,12 @@ exports.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/common/src/Web.js

@@ -7,36 +7,40 @@ exports.WebTesteranto = void 0;
 const web_1 = require("./PM/web");
 const core_js_1 = __importDefault(require("./lib/core.js"));
 const index_js_1 = require("./lib/index.js");
+let errorCallback = (e) => { };
+let unhandledrejectionCallback = (event) => {
+    console.log("window.addEventListener unhandledrejection", event);
+    // cb({ error: event.reason.message });
+    // throw event;
+};
 class WebTesteranto extends core_js_1.default {
     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 web_1.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"]());
-        // });
     }
 }
 exports.WebTesteranto = WebTesteranto;

package/dist/common/{run-tests.js → src/build-tests.js}

@@ -27,8 +27,13 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const process_1 = __importDefault(require("process"));
-process_1.default.chdir(__dirname);
-const Puppeteer_js_1 = __importDefault(require("./src/Puppeteer.js"));
-console.log(process_1.default.argv);
-const Project = await Promise.resolve().then(() => __importStar(require(process_1.default.argv[2])));
-exports.default = (0, Puppeteer_js_1.default)(Project);
+const Project_1 = require("./Project");
+if (!process_1.default.argv[2]) {
+    console.log("You didn't pass a config file");
+    process_1.default.exit(-1);
+}
+else {
+    Promise.resolve().then(() => __importStar(require(process_1.default.cwd() + "/" + process_1.default.argv[2]))).then((module) => {
+        new Project_1.ITProject(module.default);
+    });
+}

package/dist/common/src/defaultConfig.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config = {
+    outdir: "docs",
+    tests: [],
+    debugger: true,
+    clearScreen: false,
+    devMode: true,
+    minify: false,
+    outbase: ".",
+    ports: ["3001"],
+    externals: [],
+    nodePlugins: [],
+    webPlugins: [],
+    featureIngestor: function (s) {
+        throw new Error("Function not implemented.");
+    },
+};
+exports.default = config;

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

@@ -7,20 +7,20 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("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) {
-    return [
-        key,
-        ...meta.inputs[key].imports
-            .filter((x) => x.external !== true)
-            .filter((x) => x.path.split("/")[0] !== "node_modules")
-            .map((f) => f.path),
-    ];
+    const outputKey = Object.keys(meta.outputs).find((k) => {
+        return meta.outputs[k].entryPoint === key;
+    });
+    if (!outputKey) {
+        console.error("No outputkey found");
+        process.exit(-1);
+    }
+    return Object.keys(meta.outputs[outputKey].inputs).filter((k) => k.startsWith("src"));
 }
 exports.default = (platform, entryPoints) => {
     return {
@@ -39,7 +39,9 @@ exports.default = (platform, entryPoints) => {
                             }
                             const promptPath = path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `prompt.txt`);
                             const testPaths = path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `tests.json`);
-                            const featuresPath = path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `featurePrompt.txt`); // /read ${featuresPath}
+                            const featuresPath = path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `featurePrompt.txt`);
+                            const stderrPath = path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `stderr.log`);
+                            const stdoutPath = path_1.default.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `stdout.log`);
                             if (result.metafile) {
                                 const addableFiles = tree(result.metafile, entryPoint.split("/").slice(1).join("/"))
                                     .map((y) => {
@@ -49,23 +51,31 @@ exports.default = (platform, entryPoints) => {
                                     return y;
                                 })
                                     .flat();
+                                const typeErrorFiles = addableFiles.map((t) => `docs/types/${t}.type_errors.txt`);
                                 fs_1.default.writeFileSync(promptPath, `
-${[...addableFiles]
+${addableFiles
                                     .map((x) => {
                                     return `/add ${x}`;
                                 })
                                     .join("\n")}
-${[...addableFiles]
+  
+${typeErrorFiles
                                     .map((x) => {
-                                    const f = `docs/ts/${x}.type_errors.txt`;
-                                    if (fs_1.default.existsSync(f)) {
-                                        return `/read ${f}`;
-                                    }
+                                    // const f = `docs/types/${x}.type_errors.txt`;
+                                    return `/read ${x}`;
+                                    // if (fs.existsSync(f)) {
+                                    //   return `/read ${f}`;
+                                    // }
                                 })
                                     .join("\n")}
+  
 /read ${testPaths}
+/read ${stdoutPath}
+/read ${stderrPath}
+
 /load ${featuresPath}
-/code Fix the failing tests described in ${testPaths}. Correct any type signature errors. Implement any method which throws "Function not implemented."
+
+/code Fix the failing tests described in ${testPaths}. Correct any type signature errors described in the files [${typeErrorFiles.join(", ")}]. Implement any method which throws "Function not implemented."
 `);
                             }
                         });

package/dist/common/src/init-docs.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const fs_1 = __importDefault(require("fs"));
+const Init_1 = __importDefault(require("../dist/module/src/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.");
+    fs_1.default.writeFileSync("testeranto.mts", fs_1.default.readFileSync("node_modules/testeranto/src/defaultConfig.ts"));
+    Promise.resolve().then(() => __importStar(require(process.cwd() + "/" + "testeranto.mts"))).then((module) => {
+        (0, Init_1.default)(module.default);
+    });
+}
+else {
+    Promise.resolve().then(() => __importStar(require(process.cwd() + "/" + process.argv[2]))).then((module) => {
+        (0, Init_1.default)(module.default);
+    });
+}