testeranto 0.49.9 → 0.62.0

package/src/{subPackages → SubPackages}/react-dom/jsx/web.ts

@@ -1,55 +1,36 @@
-import Testeranto from "../../../Web";
-
-import React, {
-  useEffect, useRef,
-} from "react";
-import ReactDom from "react-dom/client";
+import React, { useEffect, useRef, } from "react";
 import { createPortal } from 'react-dom';
 
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
-import {
-  IInput, ISelection, IStore,
-  IThenShape, IWhenShape, IState
-} from ".";
+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 ITTestShape>(
+export default <ITestShape extends IBaseTest>(
   testImplementations: ITestImplementation<
-    IState,
-    ISelection,
-    IWhenShape,
-    IThenShape,
-    ITestShape
+    ITestShape,
+    object
   >,
   testSpecifications: ITestSpecification<
-    ITestShape,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape
+    ITestShape
   >,
   testInput: IInput
 ) => {
   document.addEventListener("DOMContentLoaded", function () {
-    console.log("DOMContentLoaded");
     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
           );
-
-          if (!myContainer.current) {
-            // do componentDidMount logic
-            myContainer.current = true;
-          } else {
-            // do componentDidUpdate logic
-          }
-
           done(myContainer.current);
         }, []);
 
@@ -61,14 +42,7 @@ export default <ITestShape extends ITTestShape>(
       };
 
       Testeranto<
-        ITestShape,
-        IInput,
-        ISubject,
-        IStore,
-        ISelection,
-        IThenShape,
-        IWhenShape,
-        IState
+        ITestShape
       >(
         testInput,
         testSpecifications,
@@ -77,8 +51,7 @@ export default <ITestShape extends ITTestShape>(
           beforeAll: async (
             input,
             artificer
-          ): Promise<ISubject> => {
-            console.log("beforeAll", input);
+          ): Promise<HTMLElement> => {
             return await new Promise((resolve, rej) => {
               resolve(rootElement);
             })
@@ -91,39 +64,23 @@ export default <ITestShape extends ITTestShape>(
             artificer
           ): Promise<IStore> => {
             return new Promise((resolve, rej) => {
-
-              console.log("beforeEach", subject);
-
               createPortal(
                 TesterantoComponent({
                   innerComp: testInput,
                   done: (reactElement: any) => {
                     process.nextTick(() => {
-                      resolve(reactElement)// do something
+                      resolve(reactElement)
                     })
                   }
-                }
-                  ,
+                },
                 ),
-
-                // ignore this type error
-                // React.createElement(
-                //   TesterantoComponent, {
-                //   done: (reactElement: any) => {
-                //     process.nextTick(() => {
-                //       resolve(reactElement)// do something
-                //     });
-
-                //   },
-                //   innerComp: testInput
-                // }),
                 rootElement
               );
             });
           },
-          andWhen: function (s: IStore, actioner): Promise<ISelection> {
+          andWhen: function (s: IStore, whenCB): Promise<ISelection> {
             return new Promise((resolve, rej) => {
-              process.nextTick(() => { resolve(actioner()(s)) })
+              process.nextTick(() => { resolve(whenCB()(s)) })
             });
           },
           butThen: async function (s: IStore): Promise<ISelection> {

package/src/{subPackages → SubPackages}/react-test-renderer/MemoExoticComponent/node.ts

@@ -3,42 +3,23 @@ import test from "../../../Node";
 import React from "react";
 import renderer, { act } from "react-test-renderer";
 
-import {
-  ITestImplementation,
-  ITestSpecification,
-  ITTestShape,
-} from "../../../core";
+import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
 
-type Input = React.MemoExoticComponent<() => JSX.Element>;
+type IInput = React.MemoExoticComponent<() => JSX.Element>;
 type WhenShape = unknown;
 type ThenShape = unknown;
 
-export default <ITestShape extends ITTestShape, PropShape>(
+export default <ITestShape extends IBaseTest, PropShape>(
   testImplementations: ITestImplementation<
-    PropShape,
-    renderer.ReactTestRenderer,
-    WhenShape,
-    ThenShape,
-    ITestShape
+    ITestShape, object
   >,
   testSpecifications: ITestSpecification<
-    ITestShape,
-    any,
-    any,
-    any,
-    any
+    ITestShape
   >,
-  testInput: Input
+  testInput: IInput
 ) =>
   test<
-    ITestShape,
-    Input,
-    any,
-    any,
-    unknown,
-    unknown,
-    unknown,
-    unknown
+    ITestShape
   >(
     testInput,
     testSpecifications,
@@ -58,9 +39,9 @@ export default <ITestShape extends ITTestShape, PropShape>(
       },
       andWhen: async function (
         renderer: renderer.ReactTestRenderer,
-        actioner: () => (a: any) => any
+        whenCB: () => (a: any) => any
       ): Promise<renderer.ReactTestRenderer> {
-        await act(() => actioner()(renderer));
+        await act(() => whenCB()(renderer));
         return renderer;
       },
     }

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

@@ -1,11 +1,12 @@
 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;
@@ -15,23 +16,15 @@ export type IStore = renderer.ReactTestRenderer;
 export type ISubject = renderer.ReactTestRenderer;
 
 export type IImpl<
-  ITestShape extends ITTestShape,
+  ITestShape extends IBaseTest,
   IProps
 > = ITestImplementation<
-  IProps,
-  renderer.ReactTestRenderer,
-  IWhenShape,
-  IThenShape,
-  ITestShape
+  ITestShape, object
 >
 export type ISpec<
-  ITestShape extends ITTestShape
+  ITestShape extends IBaseTest
 > = ITestSpecification<
-  ITestShape,
-  ISubject,
-  IStore,
-  ISelection,
-  IThenShape
+  ITestShape
 >
 
 // export const testInterface = {
@@ -48,40 +41,49 @@ 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));
+    // 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> {
+  butThen: async function (s: IStore, thenCB, tr): Promise<ISelection> {
 
-    // console.log("butThen", s)
-    return s;
+    console.log("butThen", thenCB.toString())
+    // debugger
+    return thenCB(s);
   },
   afterEach: async function (
     store: IStore,

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

@@ -0,0 +1,22 @@
+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, object>,
+  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,22 @@
+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, object>,
+  testSpecifications: ISpec<ITestShape>,
+  testInput: IInput<any, any>,
+) =>
+  Testeranto<
+    ITestShape
+  >(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterface
+  )

package/src/{subPackages → SubPackages}/react-test-renderer/fc/node.ts

@@ -1,45 +1,28 @@
-import test from "../../../Node";
-
 import React from "react";
 import renderer, { act } from "react-test-renderer";
 
-import {
-  ITTestShape,
-  ITestImplementation,
-  ITestSpecification
-} from "../../../core";
+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 ITTestShape> = ITestSpecification<
-  ITestShape,
-  any,
-  any,
-  any,
-  IThenShape
+export type ISpec<ITestShape extends IBaseTest> = ITestSpecification<
+  ITestShape
 >
 export default <
-  ITestShape extends ITTestShape,
-  IPropShape
+  ITestShape extends IBaseTest
 >(
   testImplementations: ITestImplementation<
-    IPropShape,
-    renderer.ReactTestRenderer,
-    IWhenShape,
-    IThenShape,
-    ITestShape
+    ITestShape, object
   >,
   testSpecifications: ISpec<ITestShape>,
   testInput: IInput
 ) =>
   test<
-    ITestShape,
-    IInput,
-    any,
-    renderer.ReactTestRenderer,
-    unknown, unknown, unknown, unknown
+    ITestShape
   >(
     testInput,
     testSpecifications,
@@ -54,7 +37,10 @@ export default <
           let component: renderer.ReactTestRenderer;
           act(() => {
             component = renderer.create(
-              React.createElement(CComponent, props, [])
+              React.createElement(
+                CComponent,
+                props,
+                [])
             );
             res(component);
           });
@@ -64,9 +50,9 @@ export default <
       },
       andWhen: async function (
         renderer: renderer.ReactTestRenderer,
-        actioner: () => (a: any) => any
+        whenCB: () => (a: any) => any
       ): Promise<renderer.ReactTestRenderer> {
-        await act(() => actioner()(renderer));
+        await act(() => whenCB()(renderer));
         return renderer;
       },
       afterEach: async (store, key, artificer) => {

package/src/{subPackages → SubPackages}/react-test-renderer/fc/web.ts

@@ -1,45 +1,29 @@
-import test from "../../../Web";
+import test from "../../../Web.js";
 
 import React from "react";
 import renderer, { act } from "react-test-renderer";
 
-import {
-  ITTestShape,
-  ITestImplementation,
-  ITestSpecification
-} from "../../../core";
+import { ITestSpecification, ITestImplementation, IBaseTest } from "../../../Types";
 
 export type IInput = React.FC;
 export type IWhenShape = unknown;
 export type IThenShape = unknown;
 
-export type ISpec<ITestShape extends ITTestShape> = ITestSpecification<
-  ITestShape,
-  any,
-  any,
-  any,
-  IThenShape
+export type ISpec<ITestShape extends IBaseTest> = ITestSpecification<
+  ITestShape
 >
 export default <
-  ITestShape extends ITTestShape,
+  ITestShape extends IBaseTest,
   IPropShape
 >(
   testImplementations: ITestImplementation<
-    IPropShape,
-    renderer.ReactTestRenderer,
-    IWhenShape,
-    IThenShape,
-    ITestShape
+    ITestShape, object
   >,
   testSpecifications: ISpec<ITestShape>,
   testInput: IInput
 ) =>
   test<
-    ITestShape,
-    IInput,
-    any,
-    renderer.ReactTestRenderer,
-    unknown, unknown, unknown, unknown
+    ITestShape
   >(
     testInput,
     testSpecifications,
@@ -64,9 +48,9 @@ export default <
       },
       andWhen: async function (
         renderer: renderer.ReactTestRenderer,
-        actioner: () => (a: any) => any
+        whenCB: () => (a: any) => any
       ): Promise<renderer.ReactTestRenderer> {
-        await act(() => actioner()(renderer));
+        await act(() => whenCB()(renderer));
         return renderer;
       },
       afterEach: async (store, key, artificer) => {

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

@@ -1,7 +1,11 @@
 import React from "react";
 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;
@@ -12,27 +16,26 @@ export type IStore = renderer.ReactTestRenderer;
 export type ISubject = renderer.ReactTestRenderer;
 
 export type ITestImpl<
-  ITestShape extends ITTestShape
+  ITestShape extends IBaseTest
 > = ITestImplementation<
-  InitialState,
-  ISelection,
-  IWhenShape,
-  IThenShape,
-  ITestShape
+  ITestShape, object
 >
 
 export type ITestSpec<
-  ITestShape extends ITTestShape
+  ITestShape extends IBaseTest
 > = ITestSpecification<
-  ITestShape,
-  ISubject,
-  IStore,
-  ISelection,
-  IThenShape
+  ITestShape
 >
 
 export const testInterface = {
+  butThen: async function (s: IStore, thenCB, tr): Promise<ISelection> {
+
+    console.log("butThen", thenCB.toString())
+    // debugger
+    return thenCB(s);
+  },
   beforeEach: function (CComponent, props): Promise<renderer.ReactTestRenderer> {
+    console.log("ASDASDx")
     let component;
     act(() => {
       component = renderer.create(
@@ -43,9 +46,9 @@ export const testInterface = {
   },
   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
   }
-}
+};

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

@@ -0,0 +1,24 @@
+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 { IInput, testInterface } from "./index.js";
+import { IBaseTest } from "../../../Types";
+import test from "../../../Web.js";
+import { ITestImpl, ITestSpec } from "../jsx-promised";
+
+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,6 @@
 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;
@@ -11,23 +11,15 @@ export type IStore = renderer.ReactTestRenderer;
 export type ISubject = renderer.ReactTestRenderer;
 
 export type ITestImpl<
-  ITestShape extends ITTestShape
+  ITestShape extends IBaseTest
 > = ITestImplementation<
-  InitialState,
-  ISelection,
-  IWhenShape,
-  IThenShape,
-  ITestShape
+  ITestShape, object
 >
 
 export type ITestSpec<
-  ITestShape extends ITTestShape
+  ITestShape extends IBaseTest
 > = ITestSpecification<
-  ITestShape,
-  ISubject,
-  IStore,
-  ISelection,
-  IThenShape
+  ITestShape
 >
 
 export const testInterface = {
@@ -43,9 +35,9 @@ export const testInterface = {
   },
   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
   }
 }

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,
+  )
+};