testeranto 0.62.0 → 0.73.0

package/src/SubPackages/react/component/node.ts

@@ -2,54 +2,42 @@ import React from "react";
 
 import Testeranto from "../../../Node.js";
 
-import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
 
 type IInput = typeof React.Component;
-type ISelection = React.CElement<any, any>
-type IStore = React.CElement<any, any>
-type ISubject = React.CElement<any, any>
+type ISelection = React.CElement<any, any>;
+type IStore = React.CElement<any, any>;
+type ISubject = React.CElement<any, any>;
 
-export type IImpl<
-  ISpec extends IBaseTest,
-  IState
-> = ITestImplementation<
-  ISpec, object
->
-
-export type ISpec<
-  T extends IBaseTest
-> = ITestSpecification<
-  T
+export type IImpl<ISpec extends IBaseTest, IState> = ITestImplementation<
+  ISpec,
+  object
 >;
 
-export default <
-  ITestShape extends IBaseTest,
-  IState
->(
-  testImplementations: ITestImplementation<
-    ITestShape,
-    object
-  >,
+export type ISpec<T extends IBaseTest> = ITestSpecification<T>;
+
+export default <ITestShape extends IBaseTest, IState>(
+  testImplementations: ITestImplementation<ITestShape>,
   testSpecifications: ISpec<ITestShape>,
   testInput: IInput
 ) => {
-  return Testeranto<
-    ITestShape
-  >(
+  return Testeranto<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
     {
-      beforeEach: async (
-      ): Promise<IStore> => {
+      beforeEach: async (): Promise<IStore> => {
         return new Promise((resolve, rej) => {
-          resolve(React.createElement(testInput, {
-          }, []));
+          resolve(React.createElement(testInput, {}, []));
         });
       },
       andWhen: function (s: IStore, whenCB): Promise<ISelection> {
         return whenCB()(s);
       },
-    },
-  )
+    }
+  );
 };

package/src/SubPackages/react/component/web.ts

@@ -2,52 +2,42 @@ import React from "react";
 
 import Testeranto from "../../../Web.js";
 
-import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
 
 type IInput = typeof React.Component;
-type ISelection = React.CElement<any, any>
-type Store = React.CElement<any, any>
-type Subject = React.CElement<any, any>
+type ISelection = React.CElement<any, any>;
+type Store = React.CElement<any, any>;
+// type Subject = React.CElement<any, any>;
 
-export type IImpl<
-  ISpec extends IBaseTest,
-  IState
-> = ITestImplementation<
-  ISpec, object
->
-
-export type ISpec<
-  T extends IBaseTest
-> = ITestSpecification<
-  T
+export type IImpl<ISpec extends IBaseTest, IState> = ITestImplementation<
+  ISpec,
+  object
 >;
 
-export default <
-  ITestShape extends IBaseTest,
->(
-  testImplementations: ITestImplementation<
-    ITestShape, object
-  >,
+export type ISpec<T extends IBaseTest> = ITestSpecification<T>;
+
+export default <ITestShape extends IBaseTest>(
+  testImplementations: ITestImplementation<ITestShape>,
   testSpecifications: ISpec<ITestShape>,
   testInput: IInput
 ) => {
-  return Testeranto<
-    ITestShape
-  >(
+  return Testeranto<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
     {
-      beforeEach: async (
-      ): Promise<Store> => {
+      beforeEach: async (): Promise<Store> => {
         return new Promise((resolve, rej) => {
-          resolve(React.createElement(testInput, {
-          }, []));
+          resolve(React.createElement(testInput, {}, []));
         });
       },
       andWhen: function (s: Store, whenCB): Promise<ISelection> {
         return whenCB()(s);
       },
-    },
-  )
+    }
+  );
 };

package/src/SubPackages/react/jsx/index.ts

@@ -1,43 +1,32 @@
 import { CElement } from "react";
 
 import {
-  IBaseTest, ITestImplementation, ITestSpecification
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
 } from "../../../Types";
 
 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 ISelection = CElement<any, any>;
+export type IStore = CElement<any, any>;
+export type ISubject = CElement<any, any>;
 
-export type ITestImpl<
-  ITestShape extends IBaseTest
-> = ITestImplementation<
-  ITestShape, object
->
+export type ITestImpl<ITestShape extends IBaseTest> =
+  ITestImplementation<ITestShape>;
 
-export type ITestSpec<
-  ITestShape extends IBaseTest
-> = ITestSpecification<
-  ITestShape
->
+export type ITestSpec<ITestShape extends IBaseTest> =
+  ITestSpecification<ITestShape>;
 
 export const testInterface = {
-
-  beforeEach: async (
-    x,
-    ndx,
-    testRsource,
-    artificer
-  ): Promise<IStore> => {
+  beforeEach: async (x, ndx, testRsource, artificer): Promise<IStore> => {
     return new Promise((resolve, rej) => {
-      resolve(x())
+      resolve(x());
     });
   },
   andWhen: function (s: IStore, whenCB): Promise<ISelection> {
     return whenCB(s);
   },
-
-}
+};

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

@@ -5,25 +5,22 @@ import {
   ITestImpl,
   ITestSpec,
   IInput,
-
-  testInterface as baseInterface
+  testInterface as baseInterface,
 } from "./index.js";
 
 export default <ITestShape extends IBaseTest>(
   testImplementations: ITestImpl<ITestShape>,
   testSpecifications: ITestSpec<ITestShape>,
   testInput: IInput,
-  testInterface: IPartialInterface<ITestShape>,
+  testInterface: IPartialInterface<ITestShape>
 ) => {
-  return Testeranto<
-    ITestShape
-  >(
+  return Testeranto<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
     {
       ...baseInterface,
-      ...testInterface
+      ...testInterface,
     }
-  )
+  );
 };

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

@@ -1,28 +1,30 @@
-import { IBaseTest, IPartialInterface } from "../../../Types";
+import {
+  IBaseTest,
+  IPartialInterface,
+  IPartialWebInterface,
+} from "../../../Types";
 import Testeranto from "../../../Web.js";
 
 import {
   ITestImpl,
   ITestSpec,
   IInput,
-  testInterface as baseInterface
+  testInterface as baseInterface,
 } from "./index.js";
 
 export default <ITestShape extends IBaseTest>(
   testImplementations: ITestImpl<ITestShape>,
   testSpecifications: ITestSpec<ITestShape>,
   testInput: IInput,
-  testInterface: IPartialInterface<ITestShape>
+  testInterface: IPartialWebInterface<ITestShape>
 ) => {
-  return Testeranto<
-    ITestShape
-  >(
+  return Testeranto<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
     {
       ...baseInterface,
-      ...testInterface
+      ...testInterface,
     }
-  )
+  );
 };

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

@@ -1,10 +1,17 @@
 import React, { ReactNode, createElement } from "react";
-import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
-import Stream from 'stream'
+import {
+  renderToStaticMarkup,
+  renderToStaticNodeStream,
+} from "react-dom/server";
+import Stream from "stream";
 
 import Testeranto from "../../../Node.js";
 
-import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
 
 type IInput = typeof React.Component;
 type InitialState = unknown;
@@ -14,22 +21,14 @@ export type ISelection = ReactNode;
 export type IStore = ReactNode;
 export type ISubject = ReactNode;
 
-export {
-  renderToStaticMarkup, renderToStaticNodeStream, Stream
-}
+export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
 
 export default <ITestShape extends IBaseTest>(
-  testImplementations: ITestImplementation<
-    ITestShape, object
-  >,
-  testSpecifications: ITestSpecification<
-    ITestShape
-  >,
+  testImplementations: ITestImplementation<ITestShape>,
+  testSpecifications: ITestSpecification<ITestShape>,
   testInput: IInput
 ) => {
-  return Testeranto<
-    ITestShape
-  >(
+  return Testeranto<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
@@ -64,21 +63,16 @@ export default <ITestShape extends IBaseTest>(
       butThen: async function (s: IStore): Promise<ISelection> {
         return s;
       },
-      afterEach: async function (
-        store: IStore,
-        ndx,
-        artificer
-      ) {
+      afterEach: async function (store: IStore, ndx, artificer) {
         return {};
       },
       afterAll: (store: IStore, artificer) => {
         return;
       },
-    },
-  )
+    }
+  );
 };
 
-
 // type IInput = typeof React.Component;
 // type InitialState = unknown;
 // type IWhenShape = any;

package/src/SubPackages/react-dom/component/web.ts

@@ -5,120 +5,159 @@ import Testeranto from "../../../Web.js";
 import {
   IBaseTest,
   ITestImplementation,
-  ITestSpecification
+  ITestSpecification,
 } from "../../../Types";
 
 type IInput = typeof React.Component;
 type InitialState = unknown;
 type ISelection = {
-  htmlElement: HTMLElement,
-  reactElement: CElement<any, any>,
+  htmlElement: HTMLElement;
+  reactElement: any; //CElement<any, any>;
 };
 
 type IStore = {
-  htmlElement: HTMLElement,
-  reactElement: CElement<any, any>,
+  htmlElement: HTMLElement;
+  reactElement: any; //CElement<any, any>,
+  domRoot: ReactDom.Root;
 };
 
 type ISubject = {
-  htmlElement: HTMLElement
+  htmlElement: HTMLElement;
+  reactElement: any; //CElement<any, any>,
+  domRoot: ReactDom.Root;
 };
 
-export default <
-  ITestShape extends IBaseTest,
-  IWhen,
-  IGiven
->(
+export default <ITestShape extends IBaseTest, IWhen, IGiven>(
   testInput: IInput,
-  testSpecifications: ITestSpecification<
-    ITestShape
-  >,
-  testImplementations: ITestImplementation<
-    ITestShape,
-    any
-  >,
-
+  testSpecifications: ITestSpecification<ITestShape>,
+  testImplementations: ITestImplementation<ITestShape, any>
 ) => {
-  document.addEventListener("DOMContentLoaded", function () {
-    const elem = document.getElementById("root");
-    if (elem) {
-      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
-      >(
-        testInput,
-        testSpecifications,
-        testImplementations,
-        {
-          beforeAll: async (
-            initialProps,
-            artificer
-          ): Promise<ISubject> => {
-            console.log("mark5", initialProps);
-            return await new Promise((resolve, rej) => {
-              const elem = document.getElementById("root");
-              if (elem) {
-                resolve({ htmlElement: elem });
-              }
+  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);
+    }
+  }
 
-            })
-          },
-          beforeEach: async (
-            { htmlElement },
-            initializer,
-            testResource,
-            artificer,
-            initialValues
-          ): Promise<IStore> => {
-            return new Promise((resolve, rej) => {
-              // console.log("beforeEach" + JSON.stringify(initializer) + JSON.stringify(initialValues));
-              // Ignore these type errors
-              ReactDom.createRoot(htmlElement).render(createElement(
-                TesterantoComponent, {
-                ...initializer.props,
-                done: (reactElement) => {
-                  resolve(
-                    {
+  const t = Testeranto<ITestShape>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      beforeAll: async (initialProps, artificer): Promise<ISubject> => {
+        console.log("mark5", initialProps);
+        return await new Promise((resolve, rej) => {
+          const htmlElement = document.getElementById("root");
+          if (htmlElement) {
+            const domRoot = ReactDom.createRoot(htmlElement);
+            // Ignore these type errors
+            domRoot.render(
+              createElement(
+                TesterantoComponent,
+                {
+                  ...initialProps,
+                  done: (reactElement) => {
+                    resolve({
                       htmlElement,
                       reactElement,
-                    }
-                  );
-                }
-              }, []
-              ));
-            });
-          },
-          andWhen: function (s: IStore, whenCB): Promise<ISelection> {
-            return whenCB(s);
-          },
-          butThen: async function (s: IStore): Promise<ISelection> {
-            return s;
-          },
-          afterEach: async function (
-            store: IStore,
-            ndx,
-            artificer
-          ) {
-            return {};
-          },
-          afterAll: (store: IStore, artificer) => {
-            return;
-          },
-        },
-      )
+                      domRoot,
+                    });
+                  },
+                },
+                []
+              )
+            );
+
+            // resolve({ htmlElement });
+          }
+        });
+      },
+      // beforeEach: async (
+      //   s,
+      //   initializer,
+      //   testResource,
+      //   artificer,
+      //   initialValues
+      // ): Promise<IStore> => {
+      //   return new Promise((resolve, rej) => {
+      //     console.log("beforeEach" + TesterantoComponent);
+
+      //     // const domRoot = ReactDom.createRoot(htmlElement);
+      //     // // Ignore these type errors
+      //     // domRoot.render(
+      //     //   createElement(
+      //     //     TesterantoComponent,
+      //     //     {
+      //     //       ...initializer,
+      //     //       done: (reactElement) => {
+      //     //         resolve({
+      //     //           htmlElement,
+      //     //           reactElement,
+      //     //           domRoot,
+      //     //         });
+      //     //       },
+      //     //     },
+      //     //     []
+      //     //   )
+      //     // );
+      //   });
+      // },
+      andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+        return whenCB(s);
+      },
+      butThen: async function (s: IStore, thenCB): Promise<ISelection> {
+        return thenCB(s);
+      },
+      afterEach: async function (store: IStore, ndx, artificer, utils) {
+        console.log("afterEach", store);
+        utils.writeFileSync("aftereachlog", store.toString());
+
+        const page = (await utils.browser.pages()).filter((x) => {
+          const parsedUrl = new URL(x.url());
+          parsedUrl.search = "";
+          const strippedUrl = parsedUrl.toString();
+
+          return (
+            strippedUrl ===
+            "file:///Users/adam/Code/kokomoBay/docs/web/src/ClassicalComponent/react-dom/client.web.test.html"
+          );
+          // return true;
+        })[0];
+
+        const x = await page.screenshot({
+          path: "afterEachLog.jpg",
+        });
+        console.log("x", x);
+        // debugger;
+        // const div_root = document.getElementById("root");
+        // store.domRoot && store.domRoot.unmount(); //React 18
+        //  store.remove();
+        // store.htmlElement.remove();
+        // store.htmlElement = document.createElement("root");
+        return store;
+      },
+      afterAll: async (store: IStore, artificer, utils) => {
+        // setTimeout(() => {
+        //   console.log("This will run after 1 second");
+        // }, 1000); // 1000 milliseconds = 1 second
+        // store.htmlElement.remove();
+        // store.htmlElement = document.createElement("root");
+        return store;
+      },
     }
-  });
+  );
 
+  document.addEventListener("DOMContentLoaded", function () {
+    const elem = document.getElementById("root");
+    if (elem) {
+      return t;
+    }
+  });
 
+  return t;
 };