testeranto 0.47.29 → 0.47.31

package/src/Web.ts

@@ -8,11 +8,23 @@ import {
   defaultTestResourceRequirement,
 } from "./core";
 import TesterantoLevelTwo from "./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 as any).exit(failed)
+  })
+}
+
+const receiveTestResourceConfigScheduled = async (t, testresource) => {
   const {
     failed,
     artifacts,
@@ -120,17 +132,12 @@ export default async <
       testResourceArg
     ) as ITTestResourceConfiguration;
 
-    if (partialTestResource.fs && partialTestResource.ports) {
-      receiveTestResourceConfig(t, partialTestResource);
-
+    console.log("initial test resource", partialTestResource);
 
-    } else {
-      console.log("test configuration is incomplete", partialTestResource);
-      console.log(
-        "requesting test resources via ws",
-        testResourceRequirement
-      );
+    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);
@@ -139,7 +146,10 @@ export default async <
         const r = JSON.stringify({
           type: "testeranto:hola",
           data: {
-            testResourceRequirement,
+            requirement: {
+              ...testResourceRequirement,
+              name: partialTestResource.name
+            }
           },
         });
 
@@ -150,20 +160,72 @@ export default async <
           async (msg: MessageEvent<any>) => {
             console.log("message: ", msg);
 
-            const resourcesFromPm2 = msg.data.testResourceConfiguration;
+            const resourcesFromWs = JSON.parse(msg.data);
+            console.log("secondary test resource", resourcesFromWs);
+
             const secondTestResource = {
               fs: ".",
               ...JSON.parse(JSON.stringify(partialTestResource)),
-              ...JSON.parse(JSON.stringify(resourcesFromPm2)),
+              ...JSON.parse(JSON.stringify(resourcesFromWs)),
             } as ITTestResourceConfiguration;
 
-            console.log("secondTestResource", secondTestResource);
-            receiveTestResourceConfig(t, secondTestResource);
+            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);
     // process.exit(-1);

package/src/core.ts

@@ -1,4 +1,9 @@
-const defaultTestResource: ITTestResourceConfiguration = { name: "", fs: ".", ports: [] };
+const defaultTestResource: ITTestResourceConfiguration = {
+  name: "",
+  fs: ".",
+  ports: [],
+  scheduled: false
+};
 
 export type IImplementer<IImplementation> = {
   name: string;
@@ -10,6 +15,7 @@ export type ITTestResourceConfiguration = {
   name: string;
   fs: string;
   ports: number[];
+  scheduled: boolean;
 };
 
 export type ITTestResourceRequirement = {

package/src/electron.ts

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

package/src/preload.ts

@@ -6,3 +6,26 @@ import { ipcRenderer } from "electron";
   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/src/subPackages/react/jsx/index.ts

@@ -0,0 +1,64 @@
+import { CElement, useEffect, useRef } from "react";
+import React from "react";
+
+import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
+
+export type IWhenShape = any;
+export type IThenShape = any;
+export type InitialState = unknown;
+export type IInput = () => JSX.Element;
+export type ISelection = CElement<any, any>
+export type IStore = CElement<any, any>
+export type ISubject = CElement<any, any>
+
+export type ITestImpl<
+  ITestShape extends ITTestShape
+> = ITestImplementation<
+  InitialState,
+  ISelection,
+  IWhenShape,
+  IThenShape,
+  ITestShape
+>
+
+export type ITestSpec<
+  ITestShape extends ITTestShape
+> = ITestSpecification<
+  ITestShape,
+  ISubject,
+  IStore,
+  ISelection,
+  IThenShape
+>
+
+// 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
+    ): Promise<IStore> => {
+      return new Promise((resolve, rej) => {
+        resolve(testInput())
+      });
+    },
+    andWhen: function (s: IStore, actioner): Promise<ISelection> {
+      return actioner()(s);
+    },
+  }
+}

package/src/subPackages/react/jsx/node.ts

@@ -1,32 +1,14 @@
-import React, { CElement } from "react";
-
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
 import Testeranto from "../../../Node";
 
-type IWhenShape = any;
-type IThenShape = any;
+import { ITTestShape } from "../../../core";
 
-type InitialState = unknown;
-type IInput = typeof React.Component;
-type ISelection = CElement<any, any>
-type IStore = CElement<any, any>
-type ISubject = CElement<any, any>
+import {
+  ITestImpl, ITestSpec, IInput, ISubject, IStore, ISelection, IThenShape, IWhenShape, InitialState, testInterface
+} from ".";
 
 export default <ITestShape extends ITTestShape>(
-  testImplementations: ITestImplementation<
-    InitialState,
-    ISelection,
-    IWhenShape,
-    IThenShape,
-    ITestShape
-  >,
-  testSpecifications: ITestSpecification<
-    ITestShape,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape
-  >,
+  testImplementations: ITestImpl<ITestShape>,
+  testSpecifications: ITestSpec<ITestShape>,
   testInput: IInput
 ) => {
   return Testeranto<
@@ -42,17 +24,6 @@ export default <ITestShape extends ITTestShape>(
     testInput,
     testSpecifications,
     testImplementations,
-    {
-      beforeEach: async (
-      ): Promise<IStore> => {
-        return new Promise((resolve, rej) => {
-          resolve(React.createElement(testInput, {
-          }, []));
-        });
-      },
-      andWhen: function (s: IStore, actioner): Promise<ISelection> {
-        return actioner()(s);
-      },
-    },
+    testInterface(testInput),
   )
 };

package/src/subPackages/react/jsx/web.ts

@@ -1,34 +1,14 @@
-import React from "react";
-
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
 import Testeranto from "../../../Web";
 
-import { CElement } from "react";
-
-type IWhenShape = any;
-type IThenShape = any;
+import { ITTestShape } from "../../../core";
 
-type InitialState = unknown;
-type IInput = typeof React.Component;
-type ISelection = CElement<any, any>
-type IStore = CElement<any, any>
-type ISubject = CElement<any, any>
+import {
+  ITestImpl, ITestSpec, IInput, ISubject, IStore, ISelection, IThenShape, IWhenShape, InitialState, testInterface
+} from ".";
 
 export default <ITestShape extends ITTestShape>(
-  testImplementations: ITestImplementation<
-    InitialState,
-    ISelection,
-    IWhenShape,
-    IThenShape,
-    ITestShape
-  >,
-  testSpecifications: ITestSpecification<
-    ITestShape,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape
-  >,
+  testImplementations: ITestImpl<ITestShape>,
+  testSpecifications: ITestSpec<ITestShape>,
   testInput: IInput
 ) => {
   return Testeranto<
@@ -44,17 +24,6 @@ export default <ITestShape extends ITTestShape>(
     testInput,
     testSpecifications,
     testImplementations,
-    {
-      beforeEach: async (
-      ): Promise<IStore> => {
-        return new Promise((resolve, rej) => {
-          resolve(React.createElement(testInput, {
-          }, []));
-        });
-      },
-      andWhen: function (s: IStore, actioner): Promise<ISelection> {
-        return actioner()(s);
-      },
-    },
+    testInterface(testInput),
   )
 };

package/src/subPackages/react-dom/component/node.ts

@@ -1,5 +1,6 @@
-import React, { CElement } from "react";
-import ReactDom from "react-dom/client";
+import React, { ReactNode, createElement } from "react";
+import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
+import Stream from 'stream'
 
 import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
 import Testeranto from "../../../Node";
@@ -7,20 +8,14 @@ import Testeranto from "../../../Node";
 type IInput = typeof React.Component;
 type InitialState = unknown;
 type IWhenShape = any;
-type IThenShape = any;
-type ISelection = {
-  htmlElement: HTMLElement,
-  reactElement: CElement<any, any>,
-};
-
-type IStore = {
-  htmlElement: HTMLElement,
-  reactElement: CElement<any, any>,
-};
+export type IThenShape = any;
+export type ISelection = ReactNode;
+export type IStore = ReactNode;
+export type ISubject = ReactNode;
 
-type ISubject = {
-  htmlElement: HTMLElement
-};
+export {
+  renderToStaticMarkup, renderToStaticNodeStream, Stream
+}
 
 export default <ITestShape extends ITTestShape>(
   testImplementations: ITestImplementation<
@@ -39,18 +34,6 @@ export default <ITestShape extends ITTestShape>(
   >,
   testInput: IInput
 ) => {
-  class TesterantoComponent extends testInput {
-    done: (t: TesterantoComponent) => void;
-    constructor(props) {
-      super(props);
-      this.done = props.done;
-    }
-    componentDidMount() {
-      super.componentDidMount && super.componentDidMount();
-      return this.done(this);
-    }
-  }
-
   return Testeranto<
     ITestShape,
     IInput,
@@ -65,41 +48,32 @@ export default <ITestShape extends ITTestShape>(
     testSpecifications,
     testImplementations,
     {
-      beforeAll: async (
-        prototype,
-        artificer
-      ): Promise<ISubject> => {
-        return await new Promise((resolve, rej) => {
-          document.addEventListener("DOMContentLoaded", function () {
-            const elem = document.getElementById("root");
-            if (elem) {
-              resolve({ htmlElement: elem });
-            }
-          });
-        })
-      },
+      // beforeAll: async (
+      //   prototype,
+      //   artificer
+      // ): Promise<ISubject> => {
+      //   return await new Promise((resolve, rej) => {
+      //     const elem = document.getElementById("root");
+      //     if (elem) {
+      //       resolve({ htmlElement: elem });
+      //     }
+
+      //   })
+      // },
       beforeEach: async (
-        { htmlElement },
+        reactComponent,
         ndx,
         testRsource,
         artificer
       ): Promise<IStore> => {
         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: IStore, actioner): Promise<ISelection> {
-        return actioner()(s);
+      andWhen: async function (s: IStore, actioner): Promise<ISelection> {
+        // return actioner()(s);
+        return s
       },
       butThen: async function (s: IStore): Promise<ISelection> {
         return s;
@@ -117,3 +91,60 @@ export default <ITestShape extends ITTestShape>(
     },
   )
 };
+
+
+// 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`);
+//       }
+//     },
+//   )
+// };