testeranto 0.49.10 → 0.70.0

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

@@ -0,0 +1,102 @@
+import React, { useEffect, useRef } from "react";
+import { createPortal } from "react-dom";
+
+import Testeranto from "../../../Web.js";
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
+
+import type { IInput, ISelection, IStore } from "./index";
+
+export type ISubject = HTMLElement;
+
+export default <ITestShape extends IBaseTest>(
+  testImplementations: ITestImplementation<ITestShape>,
+  testSpecifications: ITestSpecification<ITestShape>,
+  testInput: IInput
+) => {
+  document.addEventListener("DOMContentLoaded", function () {
+    const rootElement = document.getElementById("root");
+    if (rootElement) {
+      const TesterantoComponent = function ({
+        done,
+        innerComp,
+      }: {
+        done: (ref: React.MutableRefObject<any>) => any;
+        innerComp: IInput;
+      }) {
+        const myContainer = useRef<any>(null);
+        useEffect(() => {
+          console.log("useEffect called", myContainer.current);
+          done(myContainer.current);
+        }, []);
+
+        return React.createElement("div", { ref: myContainer }, innerComp());
+      };
+
+      Testeranto<ITestShape>(
+        testInput,
+        testSpecifications,
+        testImplementations,
+        {
+          beforeAll: async (input, artificer): Promise<HTMLElement> => {
+            return await new Promise((resolve, rej) => {
+              resolve(rootElement);
+            });
+          },
+
+          beforeEach: async (
+            subject,
+            ndx,
+            testRsource,
+            artificer
+          ): Promise<IStore> => {
+            return new Promise((resolve, rej) => {
+              createPortal(
+                TesterantoComponent({
+                  innerComp: testInput,
+                  done: (reactElement: any) => {
+                    process.nextTick(() => {
+                      resolve(reactElement);
+                    });
+                  },
+                }),
+                rootElement
+              );
+            });
+          },
+          andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+            return new Promise((resolve, rej) => {
+              process.nextTick(() => {
+                resolve(whenCB()(s));
+              });
+            });
+          },
+          butThen: async function (s: IStore): Promise<ISelection> {
+            return new Promise((resolve, rej) => {
+              process.nextTick(() => {
+                resolve(s);
+              });
+            });
+          },
+          afterEach: async function (store: IStore, ndx, artificer) {
+            return new Promise((resolve, rej) => {
+              process.nextTick(() => {
+                resolve({});
+              });
+            });
+          },
+          afterAll: (store: IStore, artificer) => {
+            return new Promise((resolve, rej) => {
+              process.nextTick(() => {
+                resolve({});
+              });
+            });
+          },
+        }
+      );
+    }
+  });
+};

package/src/SubPackages/react-test-renderer/MemoExoticComponent/node.ts

@@ -0,0 +1,38 @@
+import React from "react";
+import renderer, { act } from "react-test-renderer";
+
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
+import test from "../../../Node";
+
+type IInput = React.MemoExoticComponent<() => JSX.Element>;
+type WhenShape = unknown;
+type ThenShape = unknown;
+
+export default <ITestShape extends IBaseTest, PropShape>(
+  testImplementations: ITestImplementation<ITestShape>,
+  testSpecifications: ITestSpecification<ITestShape>,
+  testInput: IInput
+) =>
+  test<ITestShape>(testInput, testSpecifications, testImplementations, {
+    beforeEach: function (
+      CComponent,
+      props
+    ): Promise<renderer.ReactTestRenderer> {
+      let component;
+      act(() => {
+        component = renderer.create(React.createElement(CComponent, props, []));
+      });
+      return component;
+    },
+    andWhen: async function (
+      renderer: renderer.ReactTestRenderer,
+      whenCB: () => (a: any) => any
+    ): Promise<renderer.ReactTestRenderer> {
+      await act(() => whenCB()(renderer));
+      return renderer;
+    },
+  });

package/src/{subPackages → SubPackages}/react-test-renderer/component/index.ts

@@ -1,11 +1,14 @@
 import React from "react";
 import renderer, { act } from "react-test-renderer";
 
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
+import type {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
 
 export type ISuper<T> = T extends infer U ? U : object;
 
-// export type IInput<P, S> = React.Component<P, S>
 export type IInput<P, S> = typeof React.Component<P, S>;
 export type InitialState = unknown;
 export type IWhenShape = any;
@@ -14,25 +17,10 @@ export type ISelection = renderer.ReactTestRenderer;
 export type IStore = renderer.ReactTestRenderer;
 export type ISubject = renderer.ReactTestRenderer;
 
-export type IImpl<
-  ITestShape extends ITTestShape,
-  IProps
-> = ITestImplementation<
-  IProps,
-  renderer.ReactTestRenderer,
-  IWhenShape,
-  IThenShape,
-  ITestShape
->
-export type ISpec<
-  ITestShape extends ITTestShape
-> = ITestSpecification<
-  ITestShape,
-  ISubject,
-  IStore,
-  ISelection,
-  IThenShape
->
+export type IImpl<ITestShape extends IBaseTest> =
+  ITestImplementation<ITestShape>;
+export type ISpec<ITestShape extends IBaseTest> =
+  ITestSpecification<ITestShape>;
 
 // export const testInterface = {
 //   beforeEach: function (CComponent, props): Promise<renderer.ReactTestRenderer> {
@@ -48,54 +36,54 @@ export type ISpec<
 //   },
 //   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): Promise<renderer.ReactTestRenderer> {
-
+  beforeEach: function (
+    CComponent,
+    propsAndChildren
+  ): Promise<renderer.ReactTestRenderer> {
+    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: renderer.ReactTestRenderer,
-    actioner: any
+    whenCB: any
   ): Promise<renderer.ReactTestRenderer> {
-    // console.log("andWhen", renderer)
-    await act(() => actioner()(renderer));
-    return renderer
+    // 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: IStore): Promise<ISelection> {
-
-    // console.log("butThen", s)
-    return s;
+  butThen: async function (s: IStore, thenCB, tr): Promise<ISelection> {
+    console.log("butThen", thenCB.toString());
+    return thenCB(s);
   },
-  afterEach: async function (
-    store: IStore,
-    ndx,
-    artificer
-  ) {
+  afterEach: async function (store: IStore, ndx, artificer) {
     // console.log("afterEach", store);
-    return {
-
-    };
+    return {};
   },
   afterAll: (store: IStore, artificer) => {
     // console.log("afterAll", store);
     return;
   },
-
-}
+};

package/src/SubPackages/react-test-renderer/component/node.ts

@@ -0,0 +1,16 @@
+import Testeranto from "../../../Node.js";
+import type { IBaseTest } from "../../../Types";
+
+import { IImpl, ISpec, IInput, testInterface } from "./index.js";
+
+export default <ITestShape extends IBaseTest, IProps, IState>(
+  testImplementations: IImpl<ITestShape>,
+  testSpecifications: ISpec<ITestShape>,
+  testInput: IInput<IProps, IState>
+) =>
+  Testeranto<ITestShape>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterface
+  );

package/src/SubPackages/react-test-renderer/component/web.ts

@@ -0,0 +1,16 @@
+import { IBaseTest } from "../../../Types";
+import Testeranto from "../../../Web.js";
+
+import { IImpl, ISpec, IInput, testInterface } from "./index.js";
+
+export default <ITestShape extends IBaseTest, IProps, IState>(
+  testImplementations: IImpl<ITestShape>,
+  testSpecifications: ISpec<ITestShape>,
+  testInput: IInput<any, any>
+) =>
+  Testeranto<ITestShape>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterface
+  );

package/src/SubPackages/react-test-renderer/fc/node.ts

@@ -0,0 +1,49 @@
+import React from "react";
+import renderer, { act } from "react-test-renderer";
+
+import test from "../../../Node.js";
+
+import {
+  ITestSpecification,
+  ITestImplementation,
+  IBaseTest,
+} from "../../../Types";
+
+export type IInput = React.FC;
+export type IWhenShape = unknown;
+export type IThenShape = unknown;
+
+export type ISpec<ITestShape extends IBaseTest> =
+  ITestSpecification<ITestShape>;
+export default <ITestShape extends IBaseTest>(
+  testImplementations: ITestImplementation<ITestShape>,
+  testSpecifications: ISpec<ITestShape>,
+  testInput: IInput
+) =>
+  test<ITestShape>(testInput, testSpecifications, testImplementations, {
+    beforeEach: function (
+      CComponent,
+      props
+    ): Promise<renderer.ReactTestRenderer> {
+      return new Promise((res, rej) => {
+        let component: renderer.ReactTestRenderer;
+        act(() => {
+          component = renderer.create(
+            React.createElement(CComponent, props, [])
+          );
+          res(component);
+        });
+      });
+    },
+    andWhen: async function (
+      renderer: renderer.ReactTestRenderer,
+      whenCB: () => (a: any) => any
+    ): Promise<renderer.ReactTestRenderer> {
+      await act(() => whenCB()(renderer));
+      return renderer;
+    },
+    afterEach: async (store, key, artificer) => {
+      console.log("afterall");
+      store.unmount();
+    },
+  });

package/src/SubPackages/react-test-renderer/fc/web.ts

@@ -0,0 +1,48 @@
+import React from "react";
+import renderer, { act } from "react-test-renderer";
+
+import {
+  ITestSpecification,
+  ITestImplementation,
+  IBaseTest,
+} from "../../../Types";
+import test from "../../../Web.js";
+
+export type IInput = React.FC;
+export type IWhenShape = unknown;
+export type IThenShape = unknown;
+
+export type ISpec<ITestShape extends IBaseTest> =
+  ITestSpecification<ITestShape>;
+export default <ITestShape extends IBaseTest, IPropShape>(
+  testImplementations: ITestImplementation<ITestShape>,
+  testSpecifications: ISpec<ITestShape>,
+  testInput: IInput
+) =>
+  test<ITestShape>(testInput, testSpecifications, testImplementations, {
+    beforeEach: function (
+      CComponent,
+      props
+    ): Promise<renderer.ReactTestRenderer> {
+      return new Promise((res, rej) => {
+        let component: renderer.ReactTestRenderer;
+        act(() => {
+          component = renderer.create(
+            React.createElement(CComponent, props, [])
+          );
+          res(component);
+        });
+      });
+    },
+    andWhen: async function (
+      renderer: renderer.ReactTestRenderer,
+      whenCB: () => (a: any) => any
+    ): Promise<renderer.ReactTestRenderer> {
+      await act(() => whenCB()(renderer));
+      return renderer;
+    },
+    afterEach: async (store, key, artificer) => {
+      console.log("afterall");
+      store.unmount();
+    },
+  });

package/src/SubPackages/react-test-renderer/jsx/index.ts

@@ -0,0 +1,49 @@
+import React from "react";
+import renderer, { act } from "react-test-renderer";
+
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
+
+export type IWhenShape = any;
+export type IThenShape = any;
+export type InitialState = unknown;
+export type IInput = (props?) => JSX.Element;
+export type ISelection = renderer.ReactTestRenderer;
+export type IStore = renderer.ReactTestRenderer;
+export type ISubject = renderer.ReactTestRenderer;
+
+export type ITestImpl<ITestShape extends IBaseTest> = ITestImplementation<
+  ITestShape,
+  object
+>;
+
+export type ITestSpec<ITestShape extends IBaseTest> =
+  ITestSpecification<ITestShape>;
+
+export const testInterface = {
+  butThen: async function (s: IStore, thenCB, tr): Promise<ISelection> {
+    console.log("butThen", thenCB.toString());
+    return thenCB(s);
+  },
+  beforeEach: function (
+    CComponent,
+    props
+  ): Promise<renderer.ReactTestRenderer> {
+    console.log("ASDASDx");
+    let component;
+    act(() => {
+      component = renderer.create(React.createElement(CComponent, props, []));
+    });
+    return component;
+  },
+  andWhen: async function (
+    renderer: renderer.ReactTestRenderer,
+    whenCB: (any) => any
+  ): Promise<renderer.ReactTestRenderer> {
+    await act(() => whenCB(renderer));
+    return renderer;
+  },
+};

package/src/SubPackages/react-test-renderer/jsx/node.ts

@@ -0,0 +1,20 @@
+import test from "../../../Node.js";
+import { IBaseTest } from "../../../Types";
+
+import type { ITestImpl, ITestSpec } from "../jsx-promised";
+
+import { IInput, testInterface } from "./index.js";
+
+export default <ITestShape extends IBaseTest>(
+  testImplementations: ITestImpl<ITestShape>,
+  testSpecifications: ITestSpec<ITestShape>,
+  testInput: IInput,
+  testInterface2 = testInterface
+) => {
+  return test<ITestShape>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterface2
+  );
+};

package/src/SubPackages/react-test-renderer/jsx/web.ts

@@ -0,0 +1,20 @@
+import { IBaseTest } from "../../../Types";
+import test from "../../../Web.js";
+
+import { ITestImpl, ITestSpec } from "../jsx-promised";
+
+import { IInput, testInterface } from "./index.js";
+
+export default <ITestShape extends IBaseTest>(
+  testImplementations: ITestImpl<ITestShape>,
+  testSpecifications: ITestSpec<ITestShape>,
+  testInput: IInput,
+  testInterface2 = testInterface
+) => {
+  return test<ITestShape>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterface2
+  );
+};

package/src/{subPackages → SubPackages}/react-test-renderer/jsx-promised/index.ts

@@ -1,6 +1,10 @@
 import renderer, { act } from "react-test-renderer";
 
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
 
 export type IWhenShape = any;
 export type IThenShape = any;
@@ -10,25 +14,11 @@ export type ISelection = renderer.ReactTestRenderer;
 export type IStore = renderer.ReactTestRenderer;
 export type ISubject = renderer.ReactTestRenderer;
 
-export type ITestImpl<
-  ITestShape extends ITTestShape
-> = ITestImplementation<
-  InitialState,
-  ISelection,
-  IWhenShape,
-  IThenShape,
-  ITestShape
->
+export type ITestImpl<ITestShape extends IBaseTest> =
+  ITestImplementation<ITestShape>;
 
-export type ITestSpec<
-  ITestShape extends ITTestShape
-> = ITestSpecification<
-  ITestShape,
-  ISubject,
-  IStore,
-  ISelection,
-  IThenShape
->
+export type ITestSpec<ITestShape extends IBaseTest> =
+  ITestSpecification<ITestShape>;
 
 export const testInterface = {
   beforeEach: async (CComponent): Promise<renderer.ReactTestRenderer> => {
@@ -38,14 +28,13 @@ export const testInterface = {
         component = renderer.create(CComponent);
       });
       res(component);
-    })
-
+    });
   },
   andWhen: async function (
     renderer: renderer.ReactTestRenderer,
-    actioner: () => (any) => any
+    whenCB: () => (any) => any
   ): Promise<renderer.ReactTestRenderer> {
-    await act(() => actioner()(renderer));
-    return renderer
-  }
-}
+    await act(() => whenCB()(renderer));
+    return renderer;
+  },
+};

package/src/SubPackages/react-test-renderer/jsx-promised/node.ts

@@ -0,0 +1,19 @@
+import { IInput, testInterface } from ".";
+import test from "../../../Node";
+import { IBaseTest } from "../../../Types";
+import { ITestImpl, ITestSpec } from "../../react/jsx";
+
+export default <ITestShape extends IBaseTest>(
+  testImplementations: ITestImpl<ITestShape>,
+  testSpecifications: ITestSpec<ITestShape>,
+  testInput: IInput
+) => {
+  return test<
+    ITestShape
+  >(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterface,
+  )
+};

package/src/SubPackages/react-test-renderer/jsx-promised/web.ts

@@ -0,0 +1,22 @@
+import { IBaseTest } from "../../../Types";
+import test from "../../../Web";
+import { ITestImpl, ITestSpec } from "../../react/jsx";
+
+import {
+  testInterface, IInput
+} from "./index";
+
+export default <ITestShape extends IBaseTest>(
+  testImplementations: ITestImpl<ITestShape>,
+  testSpecifications: ITestSpec<ITestShape>,
+  testInput: IInput
+) => {
+  return test<
+    ITestShape
+  >(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterface,
+  )
+};