testeranto 0.47.25 → 0.47.26

package/src/Node.ts

@@ -43,43 +43,49 @@ const receiveTestResourceConfig = async (t, testresource) => {
 export default async <
   TestShape extends ITTestShape,
   IInput,
-  Subject,
-  Store,
+  ISubject,
+  IStore,
   ISelection,
-  WhenShape,
-  ThenShape,
+  IWhenShape,
+  IThenShape,
   IState
 >(
   input: IInput,
-  testSpecification: ITestSpecification<TestShape>,
+  testSpecification: ITestSpecification<
+    TestShape,
+    ISubject,
+    IStore,
+    ISelection,
+    IThenShape
+  >,
   testImplementation,
   testInterface: {
     actionHandler?: (b: (...any) => any) => any;
     andWhen: (
-      store: Store,
+      store: IStore,
       actioner,
       testResource: ITTestResourceConfiguration
     ) => Promise<ISelection>;
     butThen?: (
-      store: Store,
+      store: IStore,
       callback,
       testResource: ITTestResourceConfiguration
     ) => Promise<ISelection>;
-    assertioner?: (t: ThenShape) => any;
+    assertioner?: (t: IThenShape) => any;
 
-    afterAll?: (store: Store, artificer: ITestArtificer) => any;
+    afterAll?: (store: IStore, artificer: ITestArtificer) => any;
     afterEach?: (
-      store: Store,
+      store: IStore,
       key: string,
       artificer: ITestArtificer
     ) => Promise<unknown>;
-    beforeAll?: (input: IInput, artificer: ITestArtificer) => Promise<Subject>;
+    beforeAll?: (input: IInput, artificer: ITestArtificer) => Promise<ISubject>;
     beforeEach?: (
-      subject: Subject,
+      subject: ISubject,
       initialValues,
       testResource: ITTestResourceConfiguration,
       artificer: ITestArtificer
-    ) => Promise<Store>;
+    ) => Promise<IStore>;
   },
   testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement,
 ) => {
@@ -91,11 +97,11 @@ export default async <
     testInterface,
     testResourceRequirement,
     testInterface.assertioner || (async (t) => t as any),
-    testInterface.beforeEach || async function (subject: Subject, initialValues: any, testResource: any) {
+    testInterface.beforeEach || async function (subject: ISubject, initialValues: any, testResource: any) {
       return subject as any;
     },
     testInterface.afterEach || (async (s) => s),
-    testInterface.afterAll || ((store: Store) => undefined),
+    testInterface.afterAll || ((store: IStore) => undefined),
     testInterface.butThen || (async (a) => a as any),
     testInterface.andWhen,
     testInterface.actionHandler ||

package/src/Web.ts

@@ -40,43 +40,49 @@ const receiveTestResourceConfig = async (t, testresource) => {
 export default async <
   TestShape extends ITTestShape,
   IInput,
-  Subject,
-  Store,
+  ISubject,
+  IStore,
   ISelection,
   WhenShape,
-  ThenShape,
+  IThenShape,
   IState
 >(
   input: IInput,
-  testSpecification: ITestSpecification<TestShape>,
+  testSpecification: ITestSpecification<
+    TestShape,
+    ISubject,
+    IStore,
+    ISelection,
+    IThenShape
+  >,
   testImplementation,
   testInterface: {
     actionHandler?: (b: (...any) => any) => any;
     andWhen: (
-      store: Store,
+      store: IStore,
       actioner,
       testResource: ITTestResourceConfiguration
     ) => Promise<ISelection>;
     butThen?: (
-      store: Store,
+      store: IStore,
       callback,
       testResource: ITTestResourceConfiguration
     ) => Promise<ISelection>;
-    assertioner?: (t: ThenShape) => any;
+    assertioner?: (t: IThenShape) => any;
 
-    afterAll?: (store: Store, artificer: ITestArtificer) => any;
+    afterAll?: (store: IStore, artificer: ITestArtificer) => any;
     afterEach?: (
-      store: Store,
+      store: IStore,
       key: string,
       artificer: ITestArtificer
     ) => Promise<unknown>;
-    beforeAll?: (input: IInput, artificer: ITestArtificer) => Promise<Subject>;
+    beforeAll?: (input: IInput, artificer: ITestArtificer) => Promise<ISubject>;
     beforeEach?: (
-      subject: Subject,
+      subject: ISubject,
       initialValues,
       testResource: ITTestResourceConfiguration,
       artificer: ITestArtificer
-    ) => Promise<Store>;
+    ) => Promise<IStore>;
   },
   testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement
 ) => {
@@ -93,7 +99,7 @@ export default async <
       return subject as any;
     },
     testInterface.afterEach || (async (s) => s),
-    testInterface.afterAll || ((store: Store) => undefined),
+    testInterface.afterAll || ((store: IStore) => undefined),
     testInterface.butThen || (async (a) => a as any),
     testInterface.andWhen,
     testInterface.actionHandler ||

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

@@ -1,26 +1,49 @@
-import React, { CElement } from "react";
+import React from "react";
 
 import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
 import Testeranto from "../../../Node";
 
-type WhenShape = any;
-type ThenShape = any;
+type IWhenShape = any;
+type IThenShape = any;
 
-type InitialState = unknown;
 type IInput = typeof React.Component;
-type ISelection = CElement<any, any>
-type Store = CElement<any, any>
-type Subject = CElement<any, any>
+type ISelection = React.CElement<any, any>
+type Store = React.CElement<any, any>
+type Subject = React.CElement<any, any>
 
-export default <ITestShape extends ITTestShape>(
+export type IImpl<
+  ISpec extends ITTestShape,
+  IState
+> = ITestImplementation<
+  IState,
+  ISelection,
+  IWhenShape,
+  IThenShape,
+  ISpec
+>
+
+export type ISpec<
+  T extends ITTestShape
+> = ITestSpecification<
+  T,
+  Subject,
+  Store,
+  ISelection,
+  IThenShape
+>;
+
+export default <
+  ITestShape extends ITTestShape,
+  IState
+>(
   testImplementations: ITestImplementation<
-    InitialState,
+    IState,
     ISelection,
-    WhenShape,
-    ThenShape,
+    IWhenShape,
+    IThenShape,
     ITestShape
   >,
-  testSpecifications: ITestSpecification<ITestShape>,
+  testSpecifications: ISpec<ITestShape>,
   testInput: IInput
 ) => {
   return Testeranto<
@@ -29,9 +52,9 @@ export default <ITestShape extends ITTestShape>(
     Subject,
     Store,
     ISelection,
-    ThenShape,
-    WhenShape,
-    InitialState
+    IThenShape,
+    IWhenShape,
+    IState
   >(
     testInput,
     testSpecifications,

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

@@ -3,34 +3,40 @@ import React, { CElement } from "react";
 import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
 import Testeranto from "../../../Node";
 
-type WhenShape = any;
-type ThenShape = any;
+type IWhenShape = any;
+type IThenShape = any;
 
 type InitialState = unknown;
 type IInput = typeof React.Component;
 type ISelection = CElement<any, any>
-type Store = CElement<any, any>
-type Subject = CElement<any, any>
+type IStore = CElement<any, any>
+type ISubject = CElement<any, any>
 
 export default <ITestShape extends ITTestShape>(
   testImplementations: ITestImplementation<
     InitialState,
     ISelection,
-    WhenShape,
-    ThenShape,
+    IWhenShape,
+    IThenShape,
     ITestShape
   >,
-  testSpecifications: ITestSpecification<ITestShape>,
+  testSpecifications: ITestSpecification<
+    ITestShape,
+    ISubject,
+    IStore,
+    ISelection,
+    IThenShape
+  >,
   testInput: IInput
 ) => {
   return Testeranto<
     ITestShape,
     IInput,
-    Subject,
-    Store,
+    ISubject,
+    IStore,
     ISelection,
-    ThenShape,
-    WhenShape,
+    IThenShape,
+    IWhenShape,
     InitialState
   >(
     testInput,
@@ -38,13 +44,13 @@ export default <ITestShape extends ITTestShape>(
     testImplementations,
     {
       beforeEach: async (
-      ): Promise<Store> => {
+      ): Promise<IStore> => {
         return new Promise((resolve, rej) => {
           resolve(React.createElement(testInput, {
           }, []));
         });
       },
-      andWhen: function (s: Store, actioner): Promise<ISelection> {
+      andWhen: function (s: IStore, actioner): Promise<ISelection> {
         return actioner()(s);
       },
     },

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

@@ -5,34 +5,40 @@ import Testeranto from "../../../Web";
 
 import { CElement } from "react";
 
-type WhenShape = any;
-type ThenShape = any;
+type IWhenShape = any;
+type IThenShape = any;
 
 type InitialState = unknown;
 type IInput = typeof React.Component;
 type ISelection = CElement<any, any>
-type Store = CElement<any, any>
-type Subject = CElement<any, any>
+type IStore = CElement<any, any>
+type ISubject = CElement<any, any>
 
 export default <ITestShape extends ITTestShape>(
   testImplementations: ITestImplementation<
     InitialState,
     ISelection,
-    WhenShape,
-    ThenShape,
+    IWhenShape,
+    IThenShape,
     ITestShape
   >,
-  testSpecifications: ITestSpecification<ITestShape>,
+  testSpecifications: ITestSpecification<
+    ITestShape,
+    ISubject,
+    IStore,
+    ISelection,
+    IThenShape
+  >,
   testInput: IInput
 ) => {
   return Testeranto<
     ITestShape,
     IInput,
-    Subject,
-    Store,
+    ISubject,
+    IStore,
     ISelection,
-    ThenShape,
-    WhenShape,
+    IThenShape,
+    IWhenShape,
     InitialState
   >(
     testInput,
@@ -40,13 +46,13 @@ export default <ITestShape extends ITTestShape>(
     testImplementations,
     {
       beforeEach: async (
-      ): Promise<Store> => {
+      ): Promise<IStore> => {
         return new Promise((resolve, rej) => {
           resolve(React.createElement(testInput, {
           }, []));
         });
       },
-      andWhen: function (s: Store, actioner): Promise<ISelection> {
+      andWhen: function (s: IStore, actioner): Promise<ISelection> {
         return actioner()(s);
       },
     },

package/src/subPackages/{react/jsx/mounted.web.ts → react-dom/component/node.ts}

@@ -2,23 +2,23 @@ import React, { CElement } from "react";
 import ReactDom from "react-dom/client";
 
 import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
-import Testeranto from "../../../Web";
+import Testeranto from "../../../Node";
 
 type IInput = typeof React.Component;
 type InitialState = unknown;
-type WhenShape = any;
-type ThenShape = any;
+type IWhenShape = any;
+type IThenShape = any;
 type ISelection = {
   htmlElement: HTMLElement,
   reactElement: CElement<any, any>,
 };
 
-type Store = {
+type IStore = {
   htmlElement: HTMLElement,
   reactElement: CElement<any, any>,
 };
 
-type Subject = {
+type ISubject = {
   htmlElement: HTMLElement
 };
 
@@ -26,11 +26,17 @@ export default <ITestShape extends ITTestShape>(
   testImplementations: ITestImplementation<
     InitialState,
     ISelection,
-    WhenShape,
-    ThenShape,
+    IWhenShape,
+    IThenShape,
     ITestShape
   >,
-  testSpecifications: ITestSpecification<ITestShape>,
+  testSpecifications: ITestSpecification<
+    ITestShape,
+    ISubject,
+    IStore,
+    ISelection,
+    IThenShape
+  >,
   testInput: IInput
 ) => {
   class TesterantoComponent extends testInput {
@@ -48,11 +54,11 @@ export default <ITestShape extends ITTestShape>(
   return Testeranto<
     ITestShape,
     IInput,
-    Subject,
-    Store,
+    ISubject,
+    IStore,
     ISelection,
-    ThenShape,
-    WhenShape,
+    IThenShape,
+    IWhenShape,
     InitialState
   >(
     testInput,
@@ -62,7 +68,7 @@ export default <ITestShape extends ITTestShape>(
       beforeAll: async (
         prototype,
         artificer
-      ): Promise<Subject> => {
+      ): Promise<ISubject> => {
         return await new Promise((resolve, rej) => {
           document.addEventListener("DOMContentLoaded", function () {
             const elem = document.getElementById("root");
@@ -77,7 +83,7 @@ export default <ITestShape extends ITTestShape>(
         ndx,
         testRsource,
         artificer
-      ): Promise<Store> => {
+      ): Promise<IStore> => {
         return new Promise((resolve, rej) => {
           const reactElement = React.createElement(TesterantoComponent, {
             done: (reactElement) => {
@@ -92,20 +98,20 @@ export default <ITestShape extends ITTestShape>(
           ReactDom.createRoot(htmlElement).render(reactElement);
         });
       },
-      andWhen: function (s: Store, actioner): Promise<ISelection> {
+      andWhen: function (s: IStore, actioner): Promise<ISelection> {
         return actioner()(s);
       },
-      butThen: async function (s: Store): Promise<ISelection> {
+      butThen: async function (s: IStore): Promise<ISelection> {
         return s;
       },
       afterEach: async function (
-        store: Store,
+        store: IStore,
         ndx,
         artificer
       ) {
         return {};
       },
-      afterAll: (store: Store, artificer) => {
+      afterAll: (store: IStore, artificer) => {
         return;
       },
     },

package/src/subPackages/{react/component/mounted.web.ts → react-dom/component/web.ts}

@@ -6,19 +6,19 @@ import Testeranto from "../../../Web";
 
 type IInput = typeof React.Component;
 type InitialState = unknown;
-type WhenShape = any;
-type ThenShape = any;
+type IWhenShape = any;
+type IThenShape = any;
 type ISelection = {
   htmlElement: HTMLElement,
   reactElement: CElement<any, any>,
 };
 
-type Store = {
+type IStore = {
   htmlElement: HTMLElement,
   reactElement: CElement<any, any>,
 };
 
-type Subject = {
+type ISubject = {
   htmlElement: HTMLElement
 };
 
@@ -26,11 +26,17 @@ export default <ITestShape extends ITTestShape>(
   testImplementations: ITestImplementation<
     InitialState,
     ISelection,
-    WhenShape,
-    ThenShape,
+    IWhenShape,
+    IThenShape,
     ITestShape
   >,
-  testSpecifications: ITestSpecification<ITestShape>,
+  testSpecifications: ITestSpecification<
+    ITestShape,
+    ISubject,
+    IStore,
+    ISelection,
+    IThenShape
+  >,
   testInput: IInput
 ) => {
   class TesterantoComponent extends testInput {
@@ -48,11 +54,11 @@ export default <ITestShape extends ITTestShape>(
   return Testeranto<
     ITestShape,
     IInput,
-    Subject,
-    Store,
+    ISubject,
+    IStore,
     ISelection,
-    ThenShape,
-    WhenShape,
+    IThenShape,
+    IWhenShape,
     InitialState
   >(
     testInput,
@@ -62,7 +68,7 @@ export default <ITestShape extends ITTestShape>(
       beforeAll: async (
         prototype,
         artificer
-      ): Promise<Subject> => {
+      ): Promise<ISubject> => {
         return await new Promise((resolve, rej) => {
           document.addEventListener("DOMContentLoaded", function () {
             const elem = document.getElementById("root");
@@ -77,7 +83,7 @@ export default <ITestShape extends ITTestShape>(
         ndx,
         testRsource,
         artificer
-      ): Promise<Store> => {
+      ): Promise<IStore> => {
         return new Promise((resolve, rej) => {
           const reactElement = React.createElement(TesterantoComponent, {
             done: (reactElement) => {
@@ -92,20 +98,20 @@ export default <ITestShape extends ITTestShape>(
           ReactDom.createRoot(htmlElement).render(reactElement);
         });
       },
-      andWhen: function (s: Store, actioner): Promise<ISelection> {
+      andWhen: function (s: IStore, actioner): Promise<ISelection> {
         return actioner()(s);
       },
-      butThen: async function (s: Store): Promise<ISelection> {
+      butThen: async function (s: IStore): Promise<ISelection> {
         return s;
       },
       afterEach: async function (
-        store: Store,
+        store: IStore,
         ndx,
         artificer
       ) {
         return {};
       },
-      afterAll: (store: Store, artificer) => {
+      afterAll: (store: IStore, artificer) => {
         return;
       },
     },

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

@@ -0,0 +1,117 @@
+import React, {
+  useEffect, useRef,
+} from "react";
+import ReactDom from "react-dom/client";
+
+import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
+import Testeranto from "../../../../src/Web";
+
+type Input = [string, (string) => string, any];
+type InitialState = unknown;
+type IWhenShape = any;
+type IThenShape = any;
+type ISelection = IStore;
+
+type Prototype = () => JSX.Element;
+type IStore = {
+  root: HTMLElement,
+  react: HTMLElement,
+};
+type ISubject = {
+  root: HTMLElement
+};
+
+export default <ITestShape extends ITTestShape>(
+  testImplementations: ITestImplementation<
+    InitialState,
+    ISelection,
+    IWhenShape,
+    IThenShape,
+    ITestShape
+  >,
+  testSpecifications: ITestSpecification<
+    ITestShape,
+    ISubject,
+    IStore,
+    ISelection,
+    IThenShape
+  >,
+  testInput: Prototype
+) => {
+  const TesterantoComponent = function (props) {
+    const myContainer = useRef(null);
+
+    useEffect(() => {
+      console.log(
+        "This only happens ONCE. It happens AFTER the initial render."
+      );
+      // eslint-disable-next-line react/prop-types
+      props.done(myContainer.current);
+    }, []);
+
+    return React.createElement('div', { ref: myContainer }, testInput());  //testInput();
+  };
+
+  return Testeranto<
+    ITestShape,
+    Prototype,
+    ISubject,
+    IStore,
+    ISelection,
+    IThenShape,
+    IWhenShape,
+    InitialState
+  >(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      beforeAll: async (
+        prototype,
+        artificer
+      ): Promise<ISubject> => {
+        artificer("./before.txt", "hello artificer");
+        return await new Promise((resolve, rej) => {
+          document.addEventListener("DOMContentLoaded", function () {
+            const elem = document.getElementById("root");
+            if (elem) {
+              resolve({ root: elem });
+            }
+          });
+        })
+      },
+      beforeEach: async (
+        { root },
+        ndx,
+        testRsource,
+        artificer
+      ): Promise<IStore> => {
+        return new Promise((resolve, rej) => {
+          ReactDom.createRoot(root).
+            render(
+              React.createElement(
+                TesterantoComponent, {
+                done: (react) => resolve({ root, react })
+              }, []));
+        });
+      },
+      andWhen: function (s: IStore, actioner): Promise<ISelection> {
+        return actioner()(s);
+      },
+      butThen: async function (s: IStore): Promise<ISelection> {
+        return s;
+      },
+      afterEach: async function (
+        store: IStore,
+        ndx,
+        artificer
+      ) {
+        return {};
+      },
+      afterAll: (store: IStore, artificer) => {
+        // store.page.browser().close();
+        return;
+      },
+    },
+  )
+};