testeranto 0.100.0 → 0.110.0

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

@@ -3,7 +3,8 @@ import React from "react";
 import Testeranto from "../../../Node.js";
 
 import {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   ITestImplementation,
   ITestSpecification,
 } from "../../../Types";
@@ -13,31 +14,74 @@ 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 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<T extends IBaseTest> = ITestSpecification<T>;
+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 default <ITestShape extends IBaseTest, IState>(
-  testImplementations: ITestImplementation<ITestShape>,
-  testSpecifications: ISpec<ITestShape>,
+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: ITestImplementation<I, O>,
+  testSpecifications: ISpec<I, O>,
   testInput: IInput
 ) => {
-  return Testeranto<ITestShape>(
-    testInput,
-    testSpecifications,
-    testImplementations,
-    {
-      beforeEach: async (): Promise<IStore> => {
-        return new Promise((resolve, rej) => {
-          resolve(React.createElement(testInput, {}, []));
-        });
-      },
-      andWhen: function (s: IStore, whenCB): Promise<ISelection> {
-        return whenCB()(s);
-      },
-    }
-  );
+  return Testeranto<I, O>(testInput, testSpecifications, testImplementations, {
+    beforeEach: async (): Promise<IStore> => {
+      return new Promise((resolve, rej) => {
+        resolve(React.createElement(testInput, {}, []));
+      });
+    },
+    andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+      return whenCB()(s);
+    },
+  });
 };

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

@@ -3,7 +3,8 @@ import React from "react";
 import Testeranto from "../../../Web.js";
 
 import {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   ITestImplementation,
   ITestSpecification,
 } from "../../../Types";
@@ -11,33 +12,75 @@ import {
 type IInput = typeof React.Component;
 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 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<T extends IBaseTest> = ITestSpecification<T>;
+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 default <ITestShape extends IBaseTest>(
-  testImplementations: ITestImplementation<ITestShape>,
-  testSpecifications: ISpec<ITestShape>,
+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: ITestImplementation<I, O>,
+  testSpecifications: ISpec<I, O>,
   testInput: IInput
 ) => {
-  return Testeranto<ITestShape>(
-    testInput,
-    testSpecifications,
-    testImplementations,
-    {
-      beforeEach: async (): Promise<Store> => {
-        return new Promise((resolve, rej) => {
-          resolve(React.createElement(testInput, {}, []));
-        });
-      },
-      andWhen: function (s: Store, whenCB): Promise<ISelection> {
-        return whenCB()(s);
-      },
-    }
-  );
+  return Testeranto<I, O>(testInput, testSpecifications, testImplementations, {
+    beforeEach: async (): Promise<Store> => {
+      return new Promise((resolve, rej) => {
+        resolve(React.createElement(testInput, {}, []));
+      });
+    },
+    andWhen: function (s: Store, whenCB): Promise<ISelection> {
+      return whenCB()(s);
+    },
+  });
 };

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

@@ -2,7 +2,8 @@ import { CElement } from "react";
 import React from "react";
 
 import {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   IPartialInterface,
   ITestImplementation,
   ITestSpecification,
@@ -16,30 +17,50 @@ 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>;
+export type ITestImpl<
+  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 ITestSpec<ITestShape extends IBaseTest> =
-  ITestSpecification<ITestShape>;
+export type ITestSpec<
+  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 const testInterface: IPartialInterface<any> = {
-  // beforeAll: async (proto, testResource, artificer, pm): Promise<IStore> => {
-  //   return React.createElement(proto);
-  //   // return new Promise((resolve, rej) => {
-  //   //   resolve(x());
-  //   // });
-  // },
-  // beforeEach: async (subject, initializer, artificer): Promise<IStore> => {
-  //   return new Promise((resolve, rej) => {
-  //     resolve(React.createElement(subject));
-  //   });
-  // },
-  andWhen: async (s: IStore, whenCB): Promise<IStore> => {
+  andWhen: async (s, whenCB) => {
     await whenCB(s());
     return new Promise((resolve, rej) => {
       resolve(React.createElement(s));
     });
-    // return whenCB(s);
   },
   butThen: async (subject, thenCB) => {
     await thenCB(subject());

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

@@ -1,5 +1,5 @@
 import Testeranto from "../../../Node.js";
-import { IBaseTest, IPartialInterface } from "../../../Types";
+import { Ibdd_in, Ibdd_out, IPartialInterface } from "../../../Types";
 
 import {
   ITestImpl,
@@ -9,14 +9,16 @@ import {
 } from "./index.js";
 
 export default <
-  ITestShape extends IBaseTest<
-    IInput,
-    number,
-    number,
-    number,
+  I extends Ibdd_in<
     unknown,
     unknown,
     unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
     Record<string, any>,
     Record<string, any>,
     Record<string, any>,
@@ -24,12 +26,12 @@ export default <
     Record<string, any>
   >
 >(
-  testImplementations: ITestImpl<ITestShape>,
-  testSpecifications: ITestSpec<ITestShape>,
+  testImplementations: ITestImpl<I, O>,
+  testSpecifications: ITestSpec<I, O>,
   testInput: IInput,
-  testInterface: IPartialInterface<ITestShape> = baseInterface
+  testInterface: IPartialInterface<I> = baseInterface
 ) => {
-  return Testeranto<ITestShape>(
+  return Testeranto<I, O>(
     testInput,
     testSpecifications,
     testImplementations,

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

@@ -1,5 +1,6 @@
 import {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   IPartialInterface,
   IPartialWebInterface,
 } from "../../../Types";
@@ -12,19 +13,31 @@ import {
   testInterface as baseInterface,
 } from "./index.js";
 
-export default <ITestShape extends IBaseTest>(
-  testImplementations: ITestImpl<ITestShape>,
-  testSpecifications: ITestSpec<ITestShape>,
+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: ITestImpl<I, O>,
+  testSpecifications: ITestSpec<I, O>,
   testInput: IInput,
-  testInterface: IPartialWebInterface<ITestShape>
+  testInterface: IPartialWebInterface<I>
 ) => {
-  return Testeranto<ITestShape>(
-    testInput,
-    testSpecifications,
-    testImplementations,
-    {
-      ...baseInterface,
-      ...testInterface,
-    }
-  );
+  return Testeranto<I, O>(testInput, testSpecifications, testImplementations, {
+    ...baseInterface,
+    ...testInterface,
+  });
 };

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

@@ -8,69 +8,61 @@ import Stream from "stream";
 import Testeranto from "../../../Node.js";
 
 import {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   ITestImplementation,
   ITestSpecification,
 } from "../../../Types";
 
 type IInput = typeof React.Component;
-type InitialState = unknown;
-type IWhenShape = any;
-export type IThenShape = any;
+
 export type ISelection = ReactNode;
 export type IStore = ReactNode;
 export type ISubject = ReactNode;
 
 export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
 
-export default <ITestShape extends IBaseTest>(
-  testImplementations: ITestImplementation<ITestShape>,
-  testSpecifications: ITestSpecification<ITestShape>,
+export default <
+  I extends Ibdd_in<
+    IInput,
+    ISubject,
+    IStore,
+    ISelection,
+    unknown,
+    (s: IStore) => IStore,
+    unknown
+  >,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+>(
+  testImplementations: ITestImplementation<I, O>,
+  testSpecifications: ITestSpecification<I, O>,
   testInput: IInput
 ) => {
-  return Testeranto<ITestShape>(
-    testInput,
-    testSpecifications,
-    testImplementations,
-    {
-      // beforeAll: async (
-      //   prototype,
-      //   artificer
-      // ): Promise<ISubject> => {
-      //   return await new Promise((resolve, rej) => {
-      //     const elem = document.getElementById("root");
-      //     if (elem) {
-      //       resolve({ htmlElement: elem });
-      //     }
-
-      //   })
-      // },
-      beforeEach: async (
-        reactComponent,
-        ndx,
-        testRsource,
-        artificer
-      ): Promise<IStore> => {
-        return new Promise((resolve, rej) => {
-          // Ignore these type errors
-          resolve(createElement(testInput));
-        });
-      },
-      andWhen: async function (s: IStore, whenCB): Promise<ISelection> {
-        return whenCB(s);
-        // return s
-      },
-      butThen: async function (s: IStore): Promise<ISelection> {
-        return s;
-      },
-      afterEach: async function (store: IStore, ndx, artificer) {
-        return {};
-      },
-      afterAll: (store: IStore, artificer) => {
-        return;
-      },
-    }
-  );
+  return Testeranto<I, O>(testInput, testSpecifications, testImplementations, {
+    beforeEach: async (): Promise<IStore> => {
+      return new Promise((resolve, rej) => {
+        resolve(createElement(testInput));
+      });
+    },
+    andWhen: async function (s, whenCB) {
+      return whenCB(s);
+    },
+    butThen: async function (s) {
+      return s;
+    },
+    afterEach: async function () {
+      return {};
+    },
+    afterAll: () => {
+      return;
+    },
+  });
 };
 
 // type IInput = typeof React.Component;

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

@@ -3,7 +3,8 @@ import ReactDom from "react-dom/client";
 
 import Testeranto from "../../../Web.js";
 import {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   IPartialInterface,
   IPartialWebInterface,
   ITestImplementation,
@@ -11,10 +12,10 @@ import {
 } from "../../../Types";
 
 type IInput = typeof React.Component;
-type InitialState = unknown;
 type ISelection = {
   htmlElement: HTMLElement;
   reactElement: any; //CElement<any, any>;
+  domRoot: ReactDom.Root;
 };
 
 export type IStore = {
@@ -29,10 +30,27 @@ type ISubject = {
   domRoot: ReactDom.Root;
 };
 
-export default <ITestShape extends IBaseTest, IWhen, IGiven>(
+export default <
+  I extends Ibdd_in<
+    IInput,
+    ISubject,
+    ISelection,
+    IStore,
+    (s: IStore) => IStore,
+    (s: IStore) => IStore,
+    (s: IStore) => IStore
+  >,
+  O extends Ibdd_out<
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+>(
   testInput: IInput,
-  testSpecifications: ITestSpecification<ITestShape>,
-  testImplementations: ITestImplementation<ITestShape, any>,
+  testSpecifications: ITestSpecification<I, O>,
+  testImplementations: ITestImplementation<I, O>,
   testInterface?: IPartialWebInterface<any>
 ) => {
   class TesterantoComponent extends testInput {
@@ -47,7 +65,7 @@ export default <ITestShape extends IBaseTest, IWhen, IGiven>(
     }
   }
 
-  const t = Testeranto<ITestShape>(
+  const t = Testeranto<I, O>(
     testInput,
     testSpecifications,
     testImplementations,
@@ -86,19 +104,19 @@ export default <ITestShape extends IBaseTest, IWhen, IGiven>(
           );
         });
       },
-      andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+      andWhen: async function (s, whenCB) {
         return whenCB(s);
       },
-      butThen: async function (s: IStore, thenCB): Promise<ISelection> {
+      butThen: async function (s, thenCB) {
         return thenCB(s);
       },
       afterEach:
         testInterface?.afterEach ||
-        async function (store: IStore, ndx, artificer, utils) {
+        async function (store: IStore, ndx, utils) {
           return store;
         },
 
-      afterAll: async (store: IStore, artificer, utils) => {
+      afterAll: async (store: IStore, utils) => {
         // setTimeout(() => {
         //   console.log("This will run after 1 second");
         // }, 1000); // 1000 milliseconds = 1 second