testeranto 0.47.30 → 0.47.32

package/dist/module/core.js

@@ -1,4 +1,9 @@
-const defaultTestResource = { name: "", fs: ".", ports: [] };
+const defaultTestResource = {
+    name: "",
+    fs: ".",
+    ports: [],
+    scheduled: false
+};
 export const defaultTestResourceRequirement = {
     ports: 0
 };

package/dist/module/electron.js

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

package/dist/module/preload.js

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

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

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

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

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

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

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

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

@@ -1,43 +1,30 @@
-import React from "react";
-import ReactDom from "react-dom/client";
+import { createElement } from "react";
+import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
+import Stream from 'stream';
 import Testeranto from "../../../Node";
+export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
 export 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 Testeranto(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.createElement(TesterantoComponent, {
-                    done: (reactElement) => {
-                        resolve({
-                            htmlElement,
-                            reactElement,
-                        });
-                    }
-                }, []);
-                ReactDom.createRoot(htmlElement).render(reactElement);
+                // Ignore these type errors
+                resolve(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;
@@ -50,3 +37,57 @@ export 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/module/subPackages/react-dom/component/web.js

@@ -1,52 +1,56 @@
-import React from "react";
+import { createElement } from "react";
 import ReactDom from "react-dom/client";
 import Testeranto from "../../../Web";
 export 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 Testeranto(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 Testeranto(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
+                        ReactDom.createRoot(htmlElement).render(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.createElement(TesterantoComponent, {
-                    done: (reactElement) => {
-                        resolve({
-                            htmlElement,
-                            reactElement,
-                        });
-                    }
-                }, []);
-                ReactDom.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/module/subPackages/react-dom/jsx/node.js

@@ -0,0 +1,93 @@
+import { createElement } from "react";
+import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
+import Stream from 'stream';
+import Testeranto from "../../../Node";
+export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
+export default (testImplementations, testSpecifications, testInput) => {
+    return Testeranto(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(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/module/subPackages/react-test-renderer/component/index.js

@@ -0,0 +1,52 @@
+import renderer, { act } from "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
+//   }
+// }
+export const testInterface = {
+    beforeEach: function (CComponent, props) {
+        return new Promise((res, rej) => {
+            act(() => {
+                const x = renderer.create(new CComponent(props));
+                console.log("beforeEach", x.getInstance());
+                res(x);
+            });
+        });
+    },
+    andWhen: async function (renderer, actioner) {
+        // console.log("andWhen", renderer)
+        await 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/module/subPackages/react-test-renderer/component/node.js

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

package/dist/module/subPackages/react-test-renderer/component/web.js

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

package/dist/module/subPackages/react-test-renderer/fc/node.js

@@ -0,0 +1,22 @@
+import test from "../../../Node";
+import React from "react";
+import renderer, { act } from "react-test-renderer";
+export default (testImplementations, testSpecifications, testInput) => test(testInput, testSpecifications, testImplementations, {
+    beforeEach: function (CComponent, props) {
+        return new Promise((res, rej) => {
+            let component;
+            act(() => {
+                component = renderer.create(React.createElement(CComponent, props, []));
+                res(component);
+            });
+        });
+    },
+    andWhen: async function (renderer, actioner) {
+        await act(() => actioner()(renderer));
+        return renderer;
+    },
+    afterEach: async (store, key, artificer) => {
+        console.log("afterall");
+        store.unmount();
+    },
+});

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

@@ -1,7 +1,6 @@
 import React from "react";
 import renderer, { act } from "react-test-renderer";
-import Testeranto from "../../../Web";
-export default (testImplementations, testSpecifications, testInput) => Testeranto(testInput, testSpecifications, testImplementations, {
+export const testInterface = {
     beforeEach: function (CComponent, props) {
         let component;
         act(() => {
@@ -13,4 +12,4 @@ export default (testImplementations, testSpecifications, testInput) => Testerant
         await act(() => actioner()(renderer));
         return renderer;
     }
-});
+};

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

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

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

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