testeranto 0.114.1 → 0.125.0

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

@@ -0,0 +1,18 @@
+import Testeranto from "../../../Pure.js";
+
+import { ITestImplementation, ITestSpecification, OT } from "../../../Types";
+
+import { I, testInterface } from "./static.js";
+
+export default <O extends OT, M>(
+  testImplementations: ITestImplementation<I, O, M>,
+  testSpecifications: ITestSpecification<I, O>,
+  testInput: I["iinput"]
+) => {
+  return Testeranto<I, O, M>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterface
+  );
+};

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

@@ -0,0 +1,87 @@
+import { createElement, useEffect, useRef } from "react";
+import React from "react";
+import ReactDom from "react-dom/client";
+
+import { Ibdd_in, IPartialInterface } from "../../../Types";
+
+import { IInput, ISelection, IStore } from ".";
+import { IPM } from "../../../lib/types";
+
+export type I = Ibdd_in<
+  IInput,
+  HTMLElement,
+  ISelection,
+  IStore,
+  unknown,
+  (s: HTMLElement, p: IPM) => any,
+  (s: HTMLElement, p: IPM) => any
+>;
+
+const TesterantoComponent = ({
+  done,
+  innerComp,
+}: {
+  done: (ref: React.MutableRefObject<any>) => any;
+  innerComp: IInput;
+}) => {
+  const myContainer = useRef<any>(null);
+  useEffect(() => {
+    done(myContainer.current);
+  }, []);
+
+  return React.createElement("div", { ref: myContainer }, innerComp());
+};
+
+export const testInterface: IPartialInterface<I> = {
+  beforeAll: async (reactElement, itr): Promise<any> => {
+    return await new Promise((resolve, rej) => {
+      const htmlElement = document.getElementById("root");
+
+      if (htmlElement) {
+        const domRoot = ReactDom.createRoot(htmlElement);
+
+        domRoot.render(
+          createElement(
+            TesterantoComponent,
+            {
+              // ...initialProps,
+              innerComp: reactElement,
+              done: (reactElement) => {
+                resolve({
+                  htmlElement,
+                  reactElement,
+                  domRoot,
+                });
+              },
+            },
+            []
+          )
+        );
+
+        // resolve({ htmlElement });
+      }
+    });
+  },
+
+  beforeEach: async (subject) => {
+    return subject;
+  },
+  andWhen: async function (s, whenCB, tr, utils) {
+    return whenCB(s, utils);
+  },
+  butThen: async function (s, thenCB, tr, utils) {
+    return new Promise((resolve, rej) => {
+      resolve(thenCB(s, utils));
+    });
+  },
+  afterEach: async function (store, ndx, artificer) {
+    return new Promise((resolve, rej) => {
+      resolve({});
+    });
+  },
+  afterAll: (store, artificer) => {
+    return new Promise((resolve, rej) => {
+      resolve({});
+    });
+  },
+};

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

@@ -1,147 +1,19 @@
-import React, { useEffect, useRef } from "react";
-import { CElement, createElement } from "react";
-import ReactDom from "react-dom";
-
 import Testeranto from "../../../Web.js";
-import {
-  Ibdd_in,
-  Ibdd_out,
-  ITestImplementation,
-  ITestSpecification,
-} from "../../../Types";
-
-import type {
-  IInput,
-  ISelection,
-  IStore,
-  IThenShape,
-  IWhenShape,
-} from "./index";
-
-export type ISubject = HTMLElement;
+import { ITestImplementation, ITestSpecification, OT } from "../../../Types";
 
-const TesterantoComponent = ({
-  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());
-};
+import type { IInput } from "./index";
+import { I, testInterfacer } from "./dynamic.js";
 
-export default <
-  I extends Ibdd_in<
-    IInput,
-    ISubject,
-    ISelection,
-    IStore,
-    unknown,
-    IWhenShape,
-    IThenShape
-  >,
-  O extends Ibdd_out<
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
-  >
->(
-  testImplementations: ITestImplementation<I, O>,
+export default <O extends OT, M>(
+  testImplementations: ITestImplementation<I, O, M>,
   testSpecifications: ITestSpecification<I, O>,
   testInput: IInput
 ) => {
-  const t = Testeranto<I, O>(
+  const t = Testeranto<I, O, M>(
     testInput,
     testSpecifications,
     testImplementations,
-    {
-      beforeAll: async (reactElement, itr): Promise<any> => {
-        return await new Promise((resolve, rej) => {
-          const htmlElement = document.getElementById("root");
-
-          if (htmlElement) {
-            const domRoot = ReactDom.createRoot(htmlElement);
-
-            domRoot.render(
-              createElement(
-                TesterantoComponent,
-                {
-                  // ...initialProps,
-                  innerComp: reactElement,
-                  done: (reactElement) => {
-                    resolve({
-                      htmlElement,
-                      reactElement,
-                      domRoot,
-                    });
-                  },
-                },
-                []
-              )
-            );
-
-            // resolve({ htmlElement });
-          }
-        });
-      },
-
-      beforeEach: async (subject) => {
-        return subject;
-        // return new Promise((resolve, rej) => {
-        //   resolve(subject);
-        //   // const tc = TesterantoComponent({
-        //   //   innerComp: () =>
-        //   //     testInput({
-        //   //       port: 3003,
-        //   //       address: "some-address",
-        //   //       secretKey: "someSecretKey",
-        //   //       abi: "foo",
-        //   //     }),
-        //   //   done: (reactElement: any) => {
-        //   //     console.log("mark9");
-        //   //     resolve(reactElement);
-        //   //     // process.nextTick(() => {
-        //   //     //   resolve(reactElement);
-        //   //     // });
-        //   //   },
-        //   // });
-        //   // console.log("mark9", tc);
-        //   // createPortal(tc, subject.domRoot);
-        // });
-      },
-      andWhen: async function (s, whenCB, tr, utils) {
-        return whenCB(s, utils);
-        // return new Promise(async (resolve, rej) => {
-        //   // resolve(await whenCB(s, utils));
-        //   // process.nextTick(() => {
-        //   //   resolve(whenCB()(s));
-        //   // });
-        // });
-      },
-      butThen: async function (s, thenCB, tr, utils) {
-        return new Promise((resolve, rej) => {
-          resolve(thenCB(s, utils));
-        });
-      },
-      afterEach: async function (store: IStore, ndx, artificer) {
-        return new Promise((resolve, rej) => {
-          resolve({});
-        });
-      },
-      afterAll: (store: IStore, artificer) => {
-        return new Promise((resolve, rej) => {
-          resolve({});
-        });
-      },
-    }
+    testInterfacer(testInput)
   );
 
   document.addEventListener("DOMContentLoaded", function () {

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

@@ -1,56 +1,32 @@
 import React from "react";
-import renderer, { act } from "react-test-renderer";
+import { ReactTestRenderer } from "react-test-renderer";
 
-import type {
-  Ibdd_in,
-  Ibdd_out,
-  ITestImplementation,
-  ITestSpecification,
-} from "../../../Types";
-
-export type ISuper<T> = T extends infer U ? U : object;
+import type { Ibdd_in } from "../../../Types";
 
 export type IInput<P, S> = typeof React.Component<P, S>;
-export type InitialState = unknown;
-export type IWhenShape = any;
-export type IThenShape = any;
-export type ISelection = renderer.ReactTestRenderer;
-export type IStore = renderer.ReactTestRenderer;
-export type ISubject = renderer.ReactTestRenderer;
 
-export type IImpl<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >,
-  O extends Ibdd_out<
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
-  >
-> = ITestImplementation<I, O>;
-export type ISpec<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >,
-  O extends Ibdd_out<
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
-  >
-> = ITestSpecification<I, O>;
+export type I = Ibdd_in<
+  IInput<any, any>,
+  ReactTestRenderer,
+  ReactTestRenderer,
+  ReactTestRenderer,
+  unknown,
+  unknown,
+  (r: ReactTestRenderer) => ReactTestRenderer
+>;
+
+// export type ISuper<T> = T extends infer U ? U : object;
+
+// export type InitialState = unknown;
+// export type IWhenShape = any;
+// export type IThenShape = any;
+// export type ISelection = renderer.ReactTestRenderer;
+// export type IStore = renderer.ReactTestRenderer;
+// export type ISubject = renderer.ReactTestRenderer;
+
+// export type IImpl<I extends IT, O extends OT, M> = ITestImplementation<I, O>;
+// export type ITestSpecification<
+//   I extends IT,
+//   O extends OT,
+//   M
+// > = ITestSpecification<I, O>;

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

@@ -1,9 +1,11 @@
 import React from "react";
 import renderer, { act } from "react-test-renderer";
 
-import { ISelection, IStore } from ".";
+import { IPartialInterface } from "../../../Types";
 
-export const testInterface = {
+import { I } from ".";
+
+export const testInterface: IPartialInterface<I> = {
   beforeEach: function (
     CComponent,
     propsAndChildren: () => any
@@ -29,13 +31,13 @@ export const testInterface = {
   // andWhen: function (s: Store, whenCB): Promise<Selection> {
   //   return whenCB()(s);
   // },
-  butThen: async function (s: IStore, thenCB, tr): Promise<ISelection> {
+  butThen: async function (s, thenCB, tr) {
     return thenCB(s);
   },
-  afterEach: async function (store: IStore, ndx, artificer) {
+  afterEach: async function (store, ndx, artificer) {
     return {};
   },
-  afterAll: (store: IStore, artificer) => {
+  afterAll: (store, artificer) => {
     return;
   },
 };

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

@@ -1,34 +1,16 @@
 import Testeranto from "../../../Node.js";
-import { Ibdd_in, Ibdd_out } from "../../../Types.js";
 
-import { IImpl, ISpec, IInput } from "./index.js";
+import { ITestImplementation, ITestSpecification, OT } from "../../../Types.js";
+
+import { IInput, I } from "./index.js";
 import { testInterface } from "./interface.js";
 
-export default <
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >,
-  O extends Ibdd_out<
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
-  >,
-  IProps,
-  IState
->(
-  testImplementations: IImpl<I, O>,
-  testSpecifications: ISpec<I, O>,
+export default <O extends OT, IProps, IState, M = {}>(
+  testImplementations: ITestImplementation<I, O, M>,
+  testSpecifications: ITestSpecification<I, O>,
   testInput: IInput<IProps, IState>
 ) =>
-  Testeranto<I, O>(
+  Testeranto<I, O, M>(
     testInput,
     testSpecifications,
     testImplementations,

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

@@ -0,0 +1,18 @@
+import Testeranto from "../../../Pure.js";
+
+import { ITestImplementation, ITestSpecification, OT } from "../../../Types.js";
+
+import { IInput, I } from "./index.js";
+import { testInterface } from "./interface";
+
+export default <O extends OT, M = {}>(
+  testImplementations: ITestImplementation<I, O, M>,
+  testSpecifications: ITestSpecification<I, O>,
+  testInput: IInput<any, any>
+) =>
+  Testeranto<I, O, M>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    testInterface
+  );

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

@@ -0,0 +1,63 @@
+// import { ITestImplementation } from "testeranto/src/Types";
+// import { I } from "testeranto/src/SubPackages/react-test-renderer/component";
+
+import { ReactTestRenderer } from "react-test-renderer";
+import { assert } from "chai";
+
+import { O } from "../../../../examples/react/component/test";
+import { I } from "..";
+import { ITestImplementation } from "../../../../Types";
+
+export const testImplementation: ITestImplementation<I, O> = {
+  suites: {
+    Default: "default",
+  },
+  givens: {
+    AnEmptyState: (): { foo: string } => {
+      return { foo: "bar" };
+    },
+  },
+  whens: {
+    IClickTheButton: () => async (component) => {
+      const button = component.root.findByType("button");
+      button.props.onClick();
+      return component;
+    },
+    IClickTheHeader: () => async (component) => {
+      try {
+        const header = component.root.findByType("h1");
+        header.props.onClick();
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      } catch (error) {
+        // Expected error - header click fails
+      }
+      return component;
+    },
+  },
+  thens: {
+    ThePropsIs: (expectation) => (component) => {
+      const propsElement = component.root.findByProps({ id: "theProps" });
+      return assert.deepEqual(
+        JSON.parse(propsElement.props.children),
+        expectation
+      );
+    },
+
+    TheStatusIs: (expectation) => (component) => {
+      try {
+        const statElement = component.root.findByProps({ id: "theStat" });
+        const actual = JSON.parse(statElement.props.children);
+        assert.deepEqual(actual, expectation, "the status was not as expected");
+        // eslint-disable-next-line @typescript-eslint/no-unused-vars
+      } catch (error) {
+        assert.fail(`Element with id "theStat" not found`);
+      }
+      return component;
+    },
+  },
+  checks: {
+    AnEmptyState: () => {
+      return { foo: "bar" };
+    },
+  },
+};

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

@@ -0,0 +1,14 @@
+import test from "../node";
+
+import { O } from "../../../../examples/react/component/test";
+import { IProps, IState } from "../../../../examples/react/component";
+import component from "../../../../examples/react/component/index";
+import { specification } from "../../../../examples/react/component/test";
+
+import { testImplementation } from "./implementation";
+
+export default test<O, IProps, IState>(
+  testImplementation,
+  specification,
+  component
+);

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

@@ -0,0 +1,14 @@
+import test from "../pure";
+
+import { O } from "../../../../examples/react/component/test";
+import { IProps, IState } from "../../../../examples/react/component";
+import component from "../../../../examples/react/component/index";
+import { specification } from "../../../../examples/react/component/test";
+
+import { testImplementation } from "./implementation";
+
+export default test<O, IProps, IState>(
+  testImplementation,
+  specification,
+  component
+);

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

@@ -0,0 +1,14 @@
+import test from "../web";
+
+import { O } from "../../../../examples/react/component/test";
+import { IProps, IState } from "../../../../examples/react/component";
+import component from "../../../../examples/react/component/index";
+import { specification } from "../../../../examples/react/component/test";
+
+import { testImplementation } from "./implementation";
+
+export default test<O, IProps, IState>(
+  testImplementation,
+  specification,
+  component
+);

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

@@ -1,32 +1,16 @@
-import { Ibdd_in, Ibdd_out } from "../../../Types.js";
 import Testeranto from "../../../Web.js";
 
-import { IImpl, ISpec, IInput } from "./index.js";
+import { ITestImplementation, ITestSpecification, OT } from "../../../Types.js";
+
+import { IInput, I } from "./index.js";
 import { testInterface } from "./interface";
 
-export default <
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >,
-  O extends Ibdd_out<
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
-  >
->(
-  testImplementations: IImpl<I, O>,
-  testSpecifications: ISpec<I, O>,
+export default <O extends OT, IProps, IState, M = {}>(
+  testImplementations: ITestImplementation<I, O, M>,
+  testSpecifications: ITestSpecification<I, O>,
   testInput: IInput<any, any>
 ) =>
-  Testeranto<I, O>(
+  Testeranto<I, O, M>(
     testInput,
     testSpecifications,
     testImplementations,

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

@@ -1,60 +1,27 @@
 import React from "react";
-import renderer, { act } from "react-test-renderer";
+import renderer, { act, ReactTestRenderer } from "react-test-renderer";
 
-import {
-  Ibdd_in,
-  Ibdd_out,
-  ITestImplementation,
-  ITestSpecification,
-} from "../../../Types";
+import { Ibdd_in, IPartialInterface } from "../../../Types";
 
 export type IWhenShape = any;
-export type IThenShape = any;
+export type IThenShape = void;
 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<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    renderer.ReactTestRenderer,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >,
-  O extends Ibdd_out<
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
-  >
-> = ITestImplementation<I, O>;
+export type I = Ibdd_in<
+  (props?) => JSX.Element,
+  ReactTestRenderer,
+  ReactTestRenderer,
+  ReactTestRenderer,
+  unknown,
+  IWhenShape,
+  IThenShape
+>;
 
-export type ITestSpec<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    renderer.ReactTestRenderer,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >,
-  O extends Ibdd_out<
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
-  >
-> = ITestSpecification<I, O>;
-
-export const testInterface = {
+export const testInterface: IPartialInterface<I> = {
   butThen: async function (s: IStore, thenCB): Promise<ISelection> {
     // console.log("butThen", thenCB.toString());
     return thenCB(s);