testeranto 0.90.0 → 0.100.0

package/dist/common/src/PM/web.js

@@ -8,11 +8,26 @@ class PM_Web extends index_js_1.PM {
         this.server = {};
         this.testResourceConfiguration = t;
     }
-    $(selector) {
-        return window["$"](selector);
+    waitForSelector(p, s) {
+        return window["waitForSelector"](p, s);
     }
     screencast(opts) {
-        throw new Error("Method not implemented.");
+        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);
@@ -41,7 +56,7 @@ class PM_Web extends index_js_1.PM {
     existsSync(destFolder) {
         return window["existsSync"](destFolder);
     }
-    mkdirSync() {
+    mkdirSync(x) {
         return window["mkdirSync"](this.testResourceConfiguration.fs + "/");
     }
     write(writeObject, contents) {

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

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const react_1 = __importDefault(require("react"));
 const Node_js_1 = __importDefault(require("../Node.js"));
 exports.default = (testInput, testSpecifications, testImplementations, testInterface) => {
-    return (0, Node_js_1.default)(testInput, testSpecifications, testImplementations, Object.assign({ beforeAll(x) {
+    return (0, Node_js_1.default)(testInput, testSpecifications, testImplementations, Object.assign({ beforeAll: (x) => {
             // process.parentPort.postMessage(
             //   `/docs/web/src/ClassicalComponent/test.html`
             // );

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,6 @@ 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);
 };

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;