testeranto 0.47.30 → 0.47.31

package/dist/common/Web.js

@@ -5,9 +5,15 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 const core_1 = require("./core");
 const core_2 = __importDefault(require("./core"));
-// import { ipcRenderer } from "electron";
 const webSocket = new WebSocket("ws://localhost:8080");
-const receiveTestResourceConfig = async (t, testresource) => {
+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",
@@ -35,12 +41,10 @@ exports.default = async (input, testSpecification, testImplementation, testInter
     const testResourceArg = decodeURIComponent(new URLSearchParams(location.search).get('requesting') || '');
     try {
         const partialTestResource = JSON.parse(testResourceArg);
-        if (partialTestResource.fs && partialTestResource.ports) {
-            receiveTestResourceConfig(t, partialTestResource);
-        }
-        else {
-            console.log("test configuration is incomplete", partialTestResource);
-            console.log("requesting test resources via ws", testResourceRequirement);
+        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);
@@ -48,20 +52,62 @@ exports.default = async (input, testSpecification, testImplementation, testInter
                 const r = JSON.stringify({
                     type: "testeranto:hola",
                     data: {
-                        testResourceRequirement,
+                        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 resourcesFromPm2 = msg.data.testResourceConfiguration;
-                    const secondTestResource = Object.assign(Object.assign({ fs: "." }, JSON.parse(JSON.stringify(partialTestResource))), JSON.parse(JSON.stringify(resourcesFromPm2)));
-                    console.log("secondTestResource", secondTestResource);
-                    receiveTestResourceConfig(t, secondTestResource);
+                    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);
                 });
             });
         }
+        else {
+            receiveTestResourceConfigUnscheduled(t, partialTestResource);
+        }
+        // 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);
+        //       }
+        //     );
+        //   });
+        // }
     }
     catch (e) {
         console.error(e);

package/dist/common/core.js

@@ -1,7 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BaseCheck = exports.BaseThen = exports.BaseWhen = exports.BaseGiven = exports.BaseSuite = exports.defaultTestResourceRequirement = void 0;
-const defaultTestResource = { name: "", fs: ".", ports: [] };
+const defaultTestResource = {
+    name: "",
+    fs: ".",
+    ports: [],
+    scheduled: false
+};
 exports.defaultTestResourceRequirement = {
     ports: 0
 };

package/dist/common/electron.js

@@ -19,7 +19,7 @@ function createWindow() {
         },
         width: 800,
         height: 600,
-        // show: false,
+        show: false,
     });
     const u = url_1.default.format({
         pathname: path_1.default.join(process.cwd(), process.argv[2]),
@@ -34,7 +34,19 @@ function createWindow() {
     win.webContents.openDevTools();
 }
 electron_1.app.on("ready", createWindow);
+electron_1.ipcMain.handle('web-log', (x, message) => {
+    console.log("web-log)", message);
+});
+electron_1.ipcMain.handle('web-error', (x, message) => {
+    console.log("web-error)", message);
+});
+electron_1.ipcMain.handle('web-warn', (x, message) => {
+    console.log("web-warn)", message);
+});
+electron_1.ipcMain.handle('web-info', (x, message) => {
+    console.log("web-info)", message);
+});
 electron_1.ipcMain.handle('quit-app', (x, failed) => {
     console.log("quit-app", failed);
-    // app.exit(failed);
+    electron_1.app.exit(failed);
 });

package/dist/common/preload.js

@@ -6,3 +6,23 @@ window.NodeWriter = NodeWriter_1.NodeWriter;
 window.exit = (x) => {
     electron_1.ipcRenderer.invoke('quit-app', x);
 };
+var oldLog = console.log;
+console.log = function (message) {
+    electron_1.ipcRenderer.invoke('web-log', message);
+    oldLog.apply(console, arguments);
+};
+var oldLog = console.error;
+console.error = function (message) {
+    electron_1.ipcRenderer.invoke('web-error', message);
+    oldLog.apply(console, arguments);
+};
+var oldLog = console.warn;
+console.warn = function (message) {
+    electron_1.ipcRenderer.invoke('web-warn', message);
+    oldLog.apply(console, arguments);
+};
+var oldLog = console.info;
+console.info = function (message) {
+    electron_1.ipcRenderer.invoke('web-info', message);
+    oldLog.apply(console, arguments);
+};

package/dist/common/subPackages/react/jsx/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testInterface = void 0;
+// const TesterantoComponent = (testInput) => (props) => {
+//   const myContainer = useRef(null);
+//   useEffect(() => {
+//     console.log(
+//       "useeffectCalled"
+//     );
+//     props.done(myContainer.current);
+//   }, []);
+//   return React.createElement('div', { ref: myContainer }, testInput());  //testInput();
+// };
+const testInterface = (testInput) => {
+    return {
+        beforeEach: async (x, ndx, testRsource, artificer) => {
+            return new Promise((resolve, rej) => {
+                resolve(testInput());
+            });
+        },
+        andWhen: function (s, actioner) {
+            return actioner()(s);
+        },
+    };
+};
+exports.testInterface = testInterface;

package/dist/common/subPackages/react/jsx/node.js

@@ -3,17 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = __importDefault(require("react"));
 const Node_1 = __importDefault(require("../../../Node"));
+const _1 = require(".");
 exports.default = (testImplementations, testSpecifications, testInput) => {
-    return (0, Node_1.default)(testInput, testSpecifications, testImplementations, {
-        beforeEach: async () => {
-            return new Promise((resolve, rej) => {
-                resolve(react_1.default.createElement(testInput, {}, []));
-            });
-        },
-        andWhen: function (s, actioner) {
-            return actioner()(s);
-        },
-    });
+    return (0, Node_1.default)(testInput, testSpecifications, testImplementations, (0, _1.testInterface)(testInput));
 };

package/dist/common/subPackages/react/jsx/web.js

@@ -3,17 +3,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = __importDefault(require("react"));
 const Web_1 = __importDefault(require("../../../Web"));
+const _1 = require(".");
 exports.default = (testImplementations, testSpecifications, testInput) => {
-    return (0, Web_1.default)(testInput, testSpecifications, testImplementations, {
-        beforeEach: async () => {
-            return new Promise((resolve, rej) => {
-                resolve(react_1.default.createElement(testInput, {}, []));
-            });
-        },
-        andWhen: function (s, actioner) {
-            return actioner()(s);
-        },
-    });
+    return (0, Web_1.default)(testInput, testSpecifications, testImplementations, (0, _1.testInterface)(testInput));
 };

package/dist/common/subPackages/react-dom/component/node.js

@@ -3,46 +3,36 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = __importDefault(require("react"));
-const client_1 = __importDefault(require("react-dom/client"));
+exports.Stream = exports.renderToStaticNodeStream = exports.renderToStaticMarkup = void 0;
+const react_1 = require("react");
+const server_1 = require("react-dom/server");
+Object.defineProperty(exports, "renderToStaticMarkup", { enumerable: true, get: function () { return server_1.renderToStaticMarkup; } });
+Object.defineProperty(exports, "renderToStaticNodeStream", { enumerable: true, get: function () { return server_1.renderToStaticNodeStream; } });
+const stream_1 = __importDefault(require("stream"));
+exports.Stream = stream_1.default;
 const Node_1 = __importDefault(require("../../../Node"));
 exports.default = (testImplementations, testSpecifications, testInput) => {
-    class TesterantoComponent extends testInput {
-        constructor(props) {
-            super(props);
-            this.done = props.done;
-        }
-        componentDidMount() {
-            super.componentDidMount && super.componentDidMount();
-            return this.done(this);
-        }
-    }
     return (0, Node_1.default)(testInput, testSpecifications, testImplementations, {
-        beforeAll: async (prototype, artificer) => {
-            return await new Promise((resolve, rej) => {
-                document.addEventListener("DOMContentLoaded", function () {
-                    const elem = document.getElementById("root");
-                    if (elem) {
-                        resolve({ htmlElement: elem });
-                    }
-                });
-            });
-        },
-        beforeEach: async ({ htmlElement }, ndx, testRsource, artificer) => {
+        // beforeAll: async (
+        //   prototype,
+        //   artificer
+        // ): Promise<ISubject> => {
+        //   return await new Promise((resolve, rej) => {
+        //     const elem = document.getElementById("root");
+        //     if (elem) {
+        //       resolve({ htmlElement: elem });
+        //     }
+        //   })
+        // },
+        beforeEach: async (reactComponent, ndx, testRsource, artificer) => {
             return new Promise((resolve, rej) => {
-                const reactElement = react_1.default.createElement(TesterantoComponent, {
-                    done: (reactElement) => {
-                        resolve({
-                            htmlElement,
-                            reactElement,
-                        });
-                    }
-                }, []);
-                client_1.default.createRoot(htmlElement).render(reactElement);
+                // Ignore these type errors
+                resolve((0, react_1.createElement)(testInput));
             });
         },
-        andWhen: function (s, actioner) {
-            return actioner()(s);
+        andWhen: async function (s, actioner) {
+            // return actioner()(s);
+            return s;
         },
         butThen: async function (s) {
             return s;
@@ -55,3 +45,57 @@ exports.default = (testImplementations, testSpecifications, testInput) => {
         },
     });
 };
+// 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, actioner): Promise<ISelection> {
+//         throw new Error(`"andWhens" are not permitted`);
+//       }
+//     },
+//   )
+// };

package/dist/common/subPackages/react-dom/component/web.js

@@ -3,55 +3,59 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const react_1 = __importDefault(require("react"));
+const react_1 = require("react");
 const client_1 = __importDefault(require("react-dom/client"));
 const Web_1 = __importDefault(require("../../../Web"));
 exports.default = (testImplementations, testSpecifications, testInput) => {
-    class TesterantoComponent extends testInput {
-        constructor(props) {
-            super(props);
-            this.done = props.done;
-        }
-        componentDidMount() {
-            super.componentDidMount && super.componentDidMount();
-            return this.done(this);
-        }
-    }
-    return (0, Web_1.default)(testInput, testSpecifications, testImplementations, {
-        beforeAll: async (prototype, artificer) => {
-            return await new Promise((resolve, rej) => {
-                document.addEventListener("DOMContentLoaded", function () {
-                    const elem = document.getElementById("root");
-                    if (elem) {
-                        resolve({ htmlElement: elem });
-                    }
-                });
+    document.addEventListener("DOMContentLoaded", function () {
+        console.log("DOMContentLoaded");
+        const elem = document.getElementById("root");
+        if (elem) {
+            class TesterantoComponent extends testInput {
+                constructor(props) {
+                    super(props);
+                    this.done = props.done;
+                }
+                componentDidMount() {
+                    super.componentDidMount && super.componentDidMount();
+                    return this.done(this);
+                }
+            }
+            return (0, Web_1.default)(testInput, testSpecifications, testImplementations, {
+                beforeAll: async (prototype, artificer) => {
+                    return await new Promise((resolve, rej) => {
+                        const elem = document.getElementById("root");
+                        if (elem) {
+                            resolve({ htmlElement: elem });
+                        }
+                    });
+                },
+                beforeEach: async ({ htmlElement }, ndx, testRsource, artificer) => {
+                    return new Promise((resolve, rej) => {
+                        // Ignore these type errors
+                        client_1.default.createRoot(htmlElement).render((0, react_1.createElement)(TesterantoComponent, {
+                            done: (reactElement) => {
+                                resolve({
+                                    htmlElement,
+                                    reactElement,
+                                });
+                            }
+                        }, []));
+                    });
+                },
+                andWhen: function (s, actioner) {
+                    return actioner()(s);
+                },
+                butThen: async function (s) {
+                    return s;
+                },
+                afterEach: async function (store, ndx, artificer) {
+                    return {};
+                },
+                afterAll: (store, artificer) => {
+                    return;
+                },
             });
-        },
-        beforeEach: async ({ htmlElement }, ndx, testRsource, artificer) => {
-            return new Promise((resolve, rej) => {
-                const reactElement = react_1.default.createElement(TesterantoComponent, {
-                    done: (reactElement) => {
-                        resolve({
-                            htmlElement,
-                            reactElement,
-                        });
-                    }
-                }, []);
-                client_1.default.createRoot(htmlElement).render(reactElement);
-            });
-        },
-        andWhen: function (s, actioner) {
-            return actioner()(s);
-        },
-        butThen: async function (s) {
-            return s;
-        },
-        afterEach: async function (store, ndx, artificer) {
-            return {};
-        },
-        afterAll: (store, artificer) => {
-            return;
-        },
+        }
     });
 };

package/dist/common/subPackages/react-dom/jsx/node.js

@@ -0,0 +1,101 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Stream = exports.renderToStaticNodeStream = exports.renderToStaticMarkup = void 0;
+const react_1 = require("react");
+const server_1 = require("react-dom/server");
+Object.defineProperty(exports, "renderToStaticMarkup", { enumerable: true, get: function () { return server_1.renderToStaticMarkup; } });
+Object.defineProperty(exports, "renderToStaticNodeStream", { enumerable: true, get: function () { return server_1.renderToStaticNodeStream; } });
+const stream_1 = __importDefault(require("stream"));
+exports.Stream = stream_1.default;
+const Node_1 = __importDefault(require("../../../Node"));
+exports.default = (testImplementations, testSpecifications, testInput) => {
+    return (0, Node_1.default)(testInput, testSpecifications, testImplementations, {
+        // beforeAll: async (
+        //   prototype,
+        //   artificer
+        // ): Promise<ISubject> => {
+        //   return await new Promise((resolve, rej) => {
+        //     const elem = document.getElementById("root");
+        //     if (elem) {
+        //       resolve({ htmlElement: elem });
+        //     }
+        //   })
+        // },
+        beforeEach: async (reactComponent, ndx, testRsource, artificer) => {
+            return new Promise((resolve, rej) => {
+                // Ignore these type errors
+                resolve((0, react_1.createElement)(testInput));
+            });
+        },
+        andWhen: async function (s, actioner) {
+            // return actioner()(s);
+            return s;
+        },
+        butThen: async function (s) {
+            return s;
+        },
+        afterEach: async function (store, ndx, artificer) {
+            return {};
+        },
+        afterAll: (store, artificer) => {
+            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, actioner): Promise<ISelection> {
+//         throw new Error(`"andWhens" are not permitted`);
+//       }
+//     },
+//   )
+// };

package/dist/common/subPackages/react-test-renderer/component/index.js

@@ -0,0 +1,78 @@
+"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;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testInterface = void 0;
+const react_test_renderer_1 = __importStar(require("react-test-renderer"));
+// export const testInterface = {
+//   beforeEach: function (CComponent, props): Promise<renderer.ReactTestRenderer> {
+//     return new Promise((res, rej) => {
+//       let component: renderer.ReactTestRenderer;
+//       act(() => {
+//         component = renderer.create(
+//           CComponent(props)
+//         );
+//         res(component);
+//       });
+//     });
+//   },
+//   andWhen: async function (
+//     renderer: renderer.ReactTestRenderer,
+//     actioner: () => (any) => any
+//   ): Promise<renderer.ReactTestRenderer> {
+//     await act(() => actioner()(renderer));
+//     return renderer
+//   }
+// }
+exports.testInterface = {
+    beforeEach: function (CComponent, props) {
+        return new Promise((res, rej) => {
+            (0, react_test_renderer_1.act)(() => {
+                const x = react_test_renderer_1.default.create(new CComponent(props));
+                console.log("beforeEach", x.getInstance());
+                res(x);
+            });
+        });
+    },
+    andWhen: async function (renderer, actioner) {
+        // console.log("andWhen", renderer)
+        await (0, react_test_renderer_1.act)(() => actioner()(renderer));
+        return renderer;
+    },
+    // andWhen: function (s: Store, actioner): Promise<Selection> {
+    //   return actioner()(s);
+    // },
+    butThen: async function (s) {
+        // console.log("butThen", s)
+        return s;
+    },
+    afterEach: async function (store, ndx, artificer) {
+        // console.log("afterEach", store);
+        return {};
+    },
+    afterAll: (store, artificer) => {
+        // console.log("afterAll", store);
+        return;
+    },
+};

package/dist/common/subPackages/react-test-renderer/component/node.js

@@ -0,0 +1,8 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Node_1 = __importDefault(require("../../../Node"));
+const _1 = require(".");
+exports.default = (testImplementations, testSpecifications, testInput) => (0, Node_1.default)(testInput, testSpecifications, testImplementations, _1.testInterface);