testeranto 0.49.9 → 0.62.0

package/dist/module/SubPackages/puppeteer.js

@@ -0,0 +1,14 @@
+import React from "react";
+import Testeranto from "../Node.js";
+export default (testInput, testSpecifications, testImplementations, testInterface) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, Object.assign({ beforeAll(x) {
+            process.parentPort.postMessage(`/dist/web/src/ClassicalComponent/test.html`);
+            return x;
+        }, beforeEach: async () => {
+            return new Promise((resolve, rej) => {
+                resolve(React.createElement(testInput, {}, []));
+            });
+        }, andWhen: function (s, whenCB) {
+            return whenCB()(s);
+        } }, testInterface));
+};

package/dist/module/{subPackages → SubPackages}/react/component/node.js

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

package/dist/module/{subPackages → SubPackages}/react/component/web.js

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

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

@@ -0,0 +1,10 @@
+export const testInterface = {
+    beforeEach: async (x, ndx, testRsource, artificer) => {
+        return new Promise((resolve, rej) => {
+            resolve(x());
+        });
+    },
+    andWhen: function (s, whenCB) {
+        return whenCB(s);
+    },
+};

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) => {
+    return Testeranto(testInput, testSpecifications, testImplementations, Object.assign(Object.assign({}, baseInterface), 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 → SubPackages}/react-dom/component/node.js

@@ -1,7 +1,7 @@
 import { createElement } from "react";
 import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
 import Stream from 'stream';
-import Testeranto from "../../../Node";
+import Testeranto from "../../../Node.js";
 export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
 export default (testImplementations, testSpecifications, testInput) => {
     return Testeranto(testInput, testSpecifications, testImplementations, {
@@ -22,9 +22,9 @@ export default (testImplementations, testSpecifications, testInput) => {
                 resolve(createElement(testInput));
             });
         },
-        andWhen: async function (s, actioner) {
-            // return actioner()(s);
-            return s;
+        andWhen: async function (s, whenCB) {
+            return whenCB(s);
+            // return s
         },
         butThen: async function (s) {
             return s;
@@ -85,7 +85,7 @@ export default (testImplementations, testSpecifications, testInput) => {
 //           resolve(ReactDOMServer.renderToStaticMarkup(element));
 //         });
 //       },
-//       andWhen: function (s: IStore, actioner): Promise<ISelection> {
+//       andWhen: function (s: IStore, whenCB): Promise<ISelection> {
 //         throw new Error(`"andWhens" are not permitted`);
 //       }
 //     },

package/dist/module/{subPackages → SubPackages}/react-dom/component/web.js

@@ -1,9 +1,8 @@
 import { createElement } from "react";
 import ReactDom from "react-dom/client";
-import Testeranto from "../../../Web";
-export default (testImplementations, testSpecifications, testInput) => {
+import Testeranto from "../../../Web.js";
+export default (testInput, testSpecifications, testImplementations) => {
     document.addEventListener("DOMContentLoaded", function () {
-        console.log("DOMContentLoaded");
         const elem = document.getElementById("root");
         if (elem) {
             class TesterantoComponent extends testInput {
@@ -17,7 +16,8 @@ export default (testImplementations, testSpecifications, testInput) => {
                 }
             }
             return Testeranto(testInput, testSpecifications, testImplementations, {
-                beforeAll: async (prototype, artificer) => {
+                beforeAll: async (initialProps, artificer) => {
+                    console.log("mark5", initialProps);
                     return await new Promise((resolve, rej) => {
                         const elem = document.getElementById("root");
                         if (elem) {
@@ -25,21 +25,20 @@ export default (testImplementations, testSpecifications, testInput) => {
                         }
                     });
                 },
-                beforeEach: async ({ htmlElement }, ndx, testRsource, artificer) => {
+                beforeEach: async ({ htmlElement }, initializer, testResource, artificer, initialValues) => {
                     return new Promise((resolve, rej) => {
+                        // console.log("beforeEach" + JSON.stringify(initializer) + JSON.stringify(initialValues));
                         // Ignore these type errors
-                        ReactDom.createRoot(htmlElement).render(createElement(TesterantoComponent, {
-                            done: (reactElement) => {
+                        ReactDom.createRoot(htmlElement).render(createElement(TesterantoComponent, Object.assign(Object.assign({}, initializer.props), { done: (reactElement) => {
                                 resolve({
                                     htmlElement,
                                     reactElement,
                                 });
-                            }
-                        }, []));
+                            } }), []));
                     });
                 },
-                andWhen: function (s, actioner) {
-                    return actioner()(s);
+                andWhen: function (s, whenCB) {
+                    return whenCB(s);
                 },
                 butThen: async function (s) {
                     return s;

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 (reactComponent, ndx, testRsource, artificer) => {
+            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;
+        },
+    });
+};

package/dist/module/{subPackages → SubPackages}/react-dom/jsx/web.js

@@ -1,60 +1,39 @@
-import Testeranto from "../../../Web";
 import React, { useEffect, useRef, } from "react";
 import { createPortal } from 'react-dom';
+import Testeranto from "../../../Web.js";
 export default (testImplementations, testSpecifications, testInput) => {
     document.addEventListener("DOMContentLoaded", function () {
-        console.log("DOMContentLoaded");
         const rootElement = document.getElementById("root");
         if (rootElement) {
             const TesterantoComponent = function ({ done, innerComp }) {
                 const myContainer = useRef(null);
                 useEffect(() => {
                     console.log("useEffect called", myContainer.current);
-                    if (!myContainer.current) {
-                        // do componentDidMount logic
-                        myContainer.current = true;
-                    }
-                    else {
-                        // do componentDidUpdate logic
-                    }
                     done(myContainer.current);
                 }, []);
                 return React.createElement('div', { ref: myContainer }, innerComp());
             };
             Testeranto(testInput, testSpecifications, testImplementations, {
                 beforeAll: async (input, artificer) => {
-                    console.log("beforeAll", input);
                     return await new Promise((resolve, rej) => {
                         resolve(rootElement);
                     });
                 },
                 beforeEach: async (subject, ndx, testRsource, artificer) => {
                     return new Promise((resolve, rej) => {
-                        console.log("beforeEach", subject);
                         createPortal(TesterantoComponent({
                             innerComp: testInput,
                             done: (reactElement) => {
                                 process.nextTick(() => {
-                                    resolve(reactElement); // do something
+                                    resolve(reactElement);
                                 });
                             }
-                        }), 
-                        // ignore this type error
-                        // React.createElement(
-                        //   TesterantoComponent, {
-                        //   done: (reactElement: any) => {
-                        //     process.nextTick(() => {
-                        //       resolve(reactElement)// do something
-                        //     });
-                        //   },
-                        //   innerComp: testInput
-                        // }),
-                        rootElement);
+                        }), rootElement);
                     });
                 },
-                andWhen: function (s, actioner) {
+                andWhen: function (s, whenCB) {
                     return new Promise((resolve, rej) => {
-                        process.nextTick(() => { resolve(actioner()(s)); });
+                        process.nextTick(() => { resolve(whenCB()(s)); });
                     });
                 },
                 butThen: async function (s) {

package/dist/module/{subPackages → SubPackages}/react-test-renderer/MemoExoticComponent/node.js

@@ -9,8 +9,8 @@ export default (testImplementations, testSpecifications, testInput) => test(test
         });
         return component;
     },
-    andWhen: async function (renderer, actioner) {
-        await act(() => actioner()(renderer));
+    andWhen: async function (renderer, whenCB) {
+        await act(() => whenCB()(renderer));
         return renderer;
     },
 });

package/dist/module/{subPackages → SubPackages}/react-test-renderer/component/index.js

@@ -1,3 +1,4 @@
+import React from "react";
 import renderer, { act } from "react-test-renderer";
 // export const testInterface = {
 //   beforeEach: function (CComponent, props): Promise<renderer.ReactTestRenderer> {
@@ -13,33 +14,40 @@ import renderer, { act } from "react-test-renderer";
 //   },
 //   andWhen: async function (
 //     renderer: renderer.ReactTestRenderer,
-//     actioner: () => (any) => any
+//     whenCB: () => (any) => any
 //   ): Promise<renderer.ReactTestRenderer> {
-//     await act(() => actioner()(renderer));
+//     await act(() => whenCB()(renderer));
 //     return renderer
 //   }
 // }
 export const testInterface = {
-    beforeEach: function (CComponent, props) {
+    beforeEach: function (CComponent, propsAndChildren) {
+        function Link(props) {
+            const p = props.props;
+            const c = props.children;
+            return React.createElement(CComponent, p, c);
+        }
         return new Promise((res, rej) => {
-            act(() => {
-                const x = renderer.create(new CComponent(props));
-                console.log("beforeEach", x.getInstance());
-                res(x);
+            act(async () => {
+                const p = propsAndChildren;
+                const y = new CComponent(p.props);
+                const testRenderer = await renderer.create(Link(propsAndChildren));
+                res(testRenderer);
             });
         });
     },
-    andWhen: async function (renderer, actioner) {
-        // console.log("andWhen", renderer)
-        await act(() => actioner()(renderer));
+    andWhen: async function (renderer, whenCB) {
+        // console.log("andWhen", whenCB)
+        await act(() => whenCB(renderer));
         return renderer;
     },
-    // andWhen: function (s: Store, actioner): Promise<Selection> {
-    //   return actioner()(s);
+    // andWhen: function (s: Store, whenCB): Promise<Selection> {
+    //   return whenCB()(s);
     // },
-    butThen: async function (s) {
-        // console.log("butThen", s)
-        return s;
+    butThen: async function (s, thenCB, tr) {
+        console.log("butThen", thenCB.toString());
+        // debugger
+        return thenCB(s);
     },
     afterEach: async function (store, ndx, artificer) {
         // console.log("afterEach", store);

package/dist/module/{subPackages → SubPackages}/react-test-renderer/component/node.js

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

package/dist/module/{subPackages → SubPackages}/react-test-renderer/component/web.js

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

package/dist/module/{subPackages → SubPackages}/react-test-renderer/fc/node.js

@@ -1,6 +1,6 @@
-import test from "../../../Node";
 import React from "react";
 import renderer, { act } from "react-test-renderer";
+import test from "../../../Node.js";
 export default (testImplementations, testSpecifications, testInput) => test(testInput, testSpecifications, testImplementations, {
     beforeEach: function (CComponent, props) {
         return new Promise((res, rej) => {
@@ -11,8 +11,8 @@ export default (testImplementations, testSpecifications, testInput) => test(test
             });
         });
     },
-    andWhen: async function (renderer, actioner) {
-        await act(() => actioner()(renderer));
+    andWhen: async function (renderer, whenCB) {
+        await act(() => whenCB()(renderer));
         return renderer;
     },
     afterEach: async (store, key, artificer) => {

package/dist/module/{subPackages → SubPackages}/react-test-renderer/fc/web.js

@@ -1,4 +1,4 @@
-import test from "../../../Web";
+import test from "../../../Web.js";
 import React from "react";
 import renderer, { act } from "react-test-renderer";
 export default (testImplementations, testSpecifications, testInput) => test(testInput, testSpecifications, testImplementations, {
@@ -11,8 +11,8 @@ export default (testImplementations, testSpecifications, testInput) => test(test
             });
         });
     },
-    andWhen: async function (renderer, actioner) {
-        await act(() => actioner()(renderer));
+    andWhen: async function (renderer, whenCB) {
+        await act(() => whenCB()(renderer));
         return renderer;
     },
     afterEach: async (store, key, artificer) => {

package/dist/module/{subPackages → SubPackages}/react-test-renderer/jsx/index.js

@@ -1,15 +1,21 @@
 import React from "react";
 import renderer, { act } from "react-test-renderer";
 export const testInterface = {
+    butThen: async function (s, thenCB, tr) {
+        console.log("butThen", thenCB.toString());
+        // debugger
+        return thenCB(s);
+    },
     beforeEach: function (CComponent, props) {
+        console.log("ASDASDx");
         let component;
         act(() => {
             component = renderer.create(React.createElement(CComponent, props, []));
         });
         return component;
     },
-    andWhen: async function (renderer, actioner) {
-        await act(() => actioner()(renderer));
+    andWhen: async function (renderer, whenCB) {
+        await act(() => whenCB(renderer));
         return renderer;
     }
 };

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

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

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

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

package/dist/module/{subPackages → SubPackages}/react-test-renderer/jsx-promised/index.js

@@ -9,8 +9,8 @@ export const testInterface = {
             res(component);
         });
     },
-    andWhen: async function (renderer, actioner) {
-        await act(() => actioner()(renderer));
+    andWhen: async function (renderer, whenCB) {
+        await act(() => whenCB()(renderer));
         return renderer;
     }
 };

package/dist/module/{subPackages/react-test-renderer/jsx → SubPackages/react-test-renderer/jsx-promised}/node.js

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

package/dist/module/Types.js

@@ -1 +1,30 @@
-export {};
+// export class TPage extends Page {
+//   // screenshot(options?: puppeteer.ScreenshotOptions) {
+//   //   return super.screenshot({
+//   //     ...options,
+//   //     path: "dist/" + (options ? options : { path: "" }).path,
+//   //   });
+//   // }
+// }
+export class TBrowser {
+    constructor(browser) {
+        this.browser = browser;
+    }
+    pages() {
+        return new Promise(async (res, rej) => {
+            res((await this.browser.pages()).map((p) => {
+                // const handler = {
+                //   apply: function (target, thisArg, argumentsList) {
+                //     console.log('screenshot was called with ' + JSON.stringify(argumentsList));
+                //     const x: ScreenshotOptions = argumentsList[0]
+                //     x.path = "./dist/" + x.path;
+                //     console.log('x.path' + x.path, target, thisArg);
+                //     return target(...argumentsList);
+                //   }
+                // };
+                // p.screenshot = new Proxy(p.screenshot, handler);
+                return p;
+            }));
+        });
+    }
+}

package/dist/module/Web.js

@@ -1,118 +1,47 @@
-import { defaultTestResourceRequirement, } from "./core";
-import TesterantoLevelTwo from "./core";
-let webSocket;
-try {
-    webSocket = new WebSocket("ws://localhost:8080");
-}
-catch (e) {
-    console.error(e);
-}
-const receiveTestResourceConfigUnscheduled = async (t, testresource) => {
-    const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(testresource);
-    Promise.all([...artifacts, logPromise]).then(async () => {
-        // ipcRenderer.invoke('quit-app', failed);
-        window.exit(failed);
-    });
-};
-const receiveTestResourceConfigScheduled = async (t, testresource) => {
-    const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(testresource);
-    webSocket.send(JSON.stringify({
-        type: "testeranto:adios",
-        data: {
-            failed,
-            testResourceConfiguration: t.test.testResourceConfiguration,
-            results: t.toObj(),
-        },
-    }));
-    Promise.all([...artifacts, logPromise]).then(async () => {
-        // ipcRenderer.invoke('quit-app', failed);
-        window.exit(failed);
-    });
-};
-export default async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {
-    console.log("web NodeWriter", window.NodeWriter);
-    const mrt = new TesterantoLevelTwo(input, testSpecification, testImplementation, testInterface, testResourceRequirement, testInterface.assertioner || (async (t) => t), testInterface.beforeEach ||
-        async function (subject, initialValues, testResource) {
-            return subject;
-        }, testInterface.afterEach || (async (s) => s), testInterface.afterAll || ((store) => undefined), testInterface.butThen || (async (a) => a), testInterface.andWhen, testInterface.actionHandler ||
-        function (b) {
-            return b;
-        }, window.NodeWriter);
-    const tl2 = mrt;
-    const t = tl2.testJobs[0];
-    const testResourceArg = decodeURIComponent(new URLSearchParams(location.search).get('requesting') || '');
-    try {
-        const partialTestResource = JSON.parse(testResourceArg);
-        console.log("initial test resource", partialTestResource);
-        if (partialTestResource.scheduled) {
-            console.log("test is scheduled");
-            console.log("awaiting test resources via WS...");
-            webSocket.addEventListener("open", (event) => {
-                webSocket.addEventListener("message", (event) => {
-                    console.log("Message from server ", event.data);
-                });
-                const r = JSON.stringify({
-                    type: "testeranto:hola",
-                    data: {
-                        requirement: Object.assign(Object.assign({}, testResourceRequirement), { name: partialTestResource.name })
-                    },
-                });
-                webSocket.send(r);
-                console.log("awaiting test resources via websocket...", r);
-                webSocket.onmessage = (async (msg) => {
-                    console.log("message: ", msg);
-                    const resourcesFromWs = JSON.parse(msg.data);
-                    console.log("secondary test resource", resourcesFromWs);
-                    const secondTestResource = Object.assign(Object.assign({ fs: "." }, JSON.parse(JSON.stringify(partialTestResource))), JSON.parse(JSON.stringify(resourcesFromWs)));
-                    console.log("final test resource", secondTestResource);
-                    receiveTestResourceConfigScheduled(t, secondTestResource);
-                });
-            });
+import Testeranto from "./lib/core.js";
+import { defaultTestResourceRequirement } from "./lib/index.js";
+const remote = require('@electron/remote');
+class WebTesteranto extends Testeranto {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
+        super(input, testSpecification, testImplementation, testResourceRequirement, window.NodeWriter, testInterface);
+        if (process.argv[2]) {
+            const testResourceArg = decodeURIComponent(new URLSearchParams(location.search).get('requesting') || '');
+            try {
+                const partialTestResource = JSON.parse(testResourceArg);
+                this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
+            }
+            catch (e) {
+                console.error(e);
+                // process.exit(-1);
+            }
         }
         else {
-            receiveTestResourceConfigUnscheduled(t, partialTestResource);
+            // no-op
+        }
+        const requesting = new URLSearchParams(location.search).get('requesting');
+        if (requesting) {
+            const testResourceArg = decodeURIComponent(requesting);
+            try {
+                const partialTestResource = JSON.parse(testResourceArg);
+                console.log("initial test resource", partialTestResource);
+                this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
+            }
+            catch (e) {
+                console.error(e);
+                // process.exit(-1);
+            }
         }
-        // const partialTestResource = JSON.parse(
-        //   testResourceArg
-        // ) as ITTestResourceConfiguration;
-        // if (partialTestResource.fs && partialTestResource.ports) {
-        //   receiveTestResourceConfig(t, partialTestResource);
-        // } else {
-        //   console.log("test configuration is incomplete", partialTestResource);
-        //   console.log(
-        //     "requesting test resources via ws",
-        //     testResourceRequirement
-        //   );
-        //   webSocket.addEventListener("open", (event) => {
-        //     webSocket.addEventListener("message", (event) => {
-        //       console.log("Message from server ", event.data);
-        //     });
-        //     const r = JSON.stringify({
-        //       type: "testeranto:hola",
-        //       data: {
-        //         testResourceRequirement,
-        //       },
-        //     });
-        //     webSocket.send(r);
-        //     console.log("awaiting test resources via websocket...", r);
-        //     webSocket.onmessage = (
-        //       async (msg: MessageEvent<any>) => {
-        //         console.log("message: ", msg);
-        //         const resourcesFromPm2 = msg.data.testResourceConfiguration;
-        //         const secondTestResource = {
-        //           fs: ".",
-        //           ...JSON.parse(JSON.stringify(partialTestResource)),
-        //           ...JSON.parse(JSON.stringify(resourcesFromPm2)),
-        //         } as ITTestResourceConfiguration;
-        //         console.log("secondTestResource", secondTestResource);
-        //         receiveTestResourceConfig(t, secondTestResource);
-        //       }
-        //     );
-        //   });
-        // }
+        // const t: ITestJob = this.testJobs[0];
     }
-    catch (e) {
-        console.error(e);
-        // process.exit(-1);
+    async receiveTestResourceConfig(t, partialTestResource) {
+        const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(partialTestResource, remote);
+        Promise.all([...artifacts, logPromise]).then(async () => {
+            var window = remote.getCurrentWindow();
+            // window.close();
+        });
     }
+}
+;
+export default async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {
+    return new WebTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
 };