testeranto 0.49.10 → 0.62.0

package/src/Report.tsx

@@ -10,8 +10,8 @@ import { Sigma, RandomizeNodePositions, RelativeSize } from 'react-sigma';
 
 import 'bootstrap/dist/css/bootstrap.min.css';
 
-import { ITestTypes } from "./Types";
-import { TesterantoFeatures } from "./Features";
+import type { ITestTypes } from "./Types";
+import { TesterantoFeatures } from "./Features.js";
 
 type IGraphData = {
   nodes: { id: string, label: string }[],
@@ -46,8 +46,13 @@ document.addEventListener("DOMContentLoaded", function () {
 
 const Report = () => {
   const [tests, setTests] = useState<
-    ITestTypes[]
-  >([]);
+    {
+      tests: ITestTypes[]
+    }
+
+  >({
+    tests: []
+  });
   const [features, setFeatures] = useState<TesterantoFeatures>(
     new TesterantoFeatures({}, {
       undirected: [],
@@ -57,21 +62,31 @@ const Report = () => {
   );
 
   useEffect(() => {
-    const importTests = async () => {
-      const module = await import('tests.test.js');
-      setTests(module.default);
+    const importFeatures = async () => {
+      const module = await import('features.test.js');
+      console.log("imported features", module.default);
+      setFeatures(module.default);
     };
-
-    importTests();
+    importFeatures();
   }, []);
 
+
   useEffect(() => {
-    const importFeatures = async () => {
-      const module = await import('features.test.js');
-      setFeatures(module.default);
+    const importTests = async () => {
+      const x = await fetch("./testeranto.json")
+      const y = await x.json();
+      console.log("imported tests", y);
+      setTests(y as any);
+      // const module = await import('tests.json', {
+      //   with: {
+      //     type: 'json'
+      //   }
+      // });
+      // console.log("imported tests", module.default);
+      // setTests(module.default);
     };
 
-    importFeatures();
+    importTests();
   }, []);
 
 
@@ -336,14 +351,14 @@ footer {
               </Col>
               <Col sm={6}>
                 <Tab.Content>
-                  {tests.map((t, ndx) => {
+                  {/* {tests.tests.map((t, ndx) => {
                     return (
                       <Tab.Pane eventKey={`feature-${ndx}`} key={ndx}>
                         <pre>{JSON.stringify(t, null, 2)}</pre>
                       </Tab.Pane>
                     )
                   }
-                  )}
+                  )} */}
                 </Tab.Content>
               </Col>
 

package/src/SubPackages/puppeteer.ts

@@ -0,0 +1,46 @@
+import React from "react";
+
+import Testeranto from "../Node.js";
+
+import { IBaseTest, IPartialInterface, ITestImplementation, ITestSpecification } from "../Types";
+
+type IInput = string;
+type ISelection = any;
+type IStore = any
+type ISubject = any
+
+export type IImpl<ISpec extends IBaseTest> = ITestImplementation<ISpec, object>
+
+export type ISpec<T extends IBaseTest> = ITestSpecification<T>;
+
+export default <ITestShape extends IBaseTest>(
+  testInput: IInput,
+  testSpecifications: ISpec<ITestShape>,
+  testImplementations: ITestImplementation<ITestShape, object>,
+  testInterface?: IPartialInterface<ITestShape>
+) => {
+  return Testeranto<ITestShape>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      beforeAll(x) {
+        process.parentPort.postMessage(`/dist/web/src/ClassicalComponent/test.html`)
+
+        return x;
+      },
+      beforeEach: async (
+      ): Promise<IStore> => {
+        return new Promise((resolve, rej) => {
+          resolve(React.createElement(testInput, {
+          }, []));
+        });
+      },
+      andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+        return whenCB()(s);
+      },
+
+      ...testInterface
+    },
+  )
+};

package/src/{subPackages → SubPackages}/react/component/node.ts

@@ -1,10 +1,8 @@
 import React from "react";
 
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
-import Testeranto from "../../../Node";
+import Testeranto from "../../../Node.js";
 
-type IWhenShape = any;
-type IThenShape = any;
+import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
 
 type IInput = typeof React.Component;
 type ISelection = React.CElement<any, any>
@@ -12,49 +10,31 @@ type IStore = React.CElement<any, any>
 type ISubject = React.CElement<any, any>
 
 export type IImpl<
-  ISpec extends ITTestShape,
+  ISpec extends IBaseTest,
   IState
 > = ITestImplementation<
-  IState,
-  ISelection,
-  IWhenShape,
-  IThenShape,
-  ISpec
+  ISpec, object
 >
 
 export type ISpec<
-  T extends ITTestShape
+  T extends IBaseTest
 > = ITestSpecification<
-  T,
-  ISubject,
-  IStore,
-  ISelection,
-  IThenShape
+  T
 >;
 
 export default <
-  ITestShape extends ITTestShape,
+  ITestShape extends IBaseTest,
   IState
 >(
   testImplementations: ITestImplementation<
-    IState,
-    ISelection,
-    IWhenShape,
-    IThenShape,
-    ITestShape
+    ITestShape,
+    object
   >,
   testSpecifications: ISpec<ITestShape>,
   testInput: IInput
 ) => {
   return Testeranto<
-    ITestShape,
-    IInput,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape,
-    IWhenShape,
-    IState
+    ITestShape
   >(
     testInput,
     testSpecifications,
@@ -67,8 +47,8 @@ export default <
           }, []));
         });
       },
-      andWhen: function (s: IStore, actioner): Promise<ISelection> {
-        return actioner()(s);
+      andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+        return whenCB()(s);
       },
     },
   )

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

@@ -0,0 +1,53 @@
+import React from "react";
+
+import Testeranto from "../../../Web.js";
+
+import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
+
+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 ISpec<
+  T extends IBaseTest
+> = ITestSpecification<
+  T
+>;
+
+export default <
+  ITestShape extends IBaseTest,
+>(
+  testImplementations: ITestImplementation<
+    ITestShape, object
+  >,
+  testSpecifications: ISpec<ITestShape>,
+  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);
+      },
+    },
+  )
+};

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

@@ -0,0 +1,43 @@
+import { CElement } from "react";
+
+import {
+  IBaseTest, ITestImplementation, ITestSpecification
+} from "../../../Types";
+
+export type IWhenShape = any;
+export type IThenShape = any;
+export type InitialState = unknown;
+export type IInput = () => JSX.Element;
+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, object
+>
+
+export type ITestSpec<
+  ITestShape extends IBaseTest
+> = ITestSpecification<
+  ITestShape
+>
+
+export const testInterface = {
+
+  beforeEach: async (
+    x,
+    ndx,
+    testRsource,
+    artificer
+  ): Promise<IStore> => {
+    return new Promise((resolve, rej) => {
+      resolve(x())
+    });
+  },
+  andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+    return whenCB(s);
+  },
+
+}

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

@@ -0,0 +1,29 @@
+import Testeranto from "../../../Node.js";
+import { IBaseTest, IPartialInterface } from "../../../Types";
+
+import {
+  ITestImpl,
+  ITestSpec,
+  IInput,
+
+  testInterface as baseInterface
+} from "./index.js";
+
+export default <ITestShape extends IBaseTest>(
+  testImplementations: ITestImpl<ITestShape>,
+  testSpecifications: ITestSpec<ITestShape>,
+  testInput: IInput,
+  testInterface: IPartialInterface<ITestShape>,
+) => {
+  return Testeranto<
+    ITestShape
+  >(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      ...baseInterface,
+      ...testInterface
+    }
+  )
+};

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

@@ -0,0 +1,28 @@
+import { IBaseTest, IPartialInterface } from "../../../Types";
+import Testeranto from "../../../Web.js";
+
+import {
+  ITestImpl,
+  ITestSpec,
+  IInput,
+  testInterface as baseInterface
+} from "./index.js";
+
+export default <ITestShape extends IBaseTest>(
+  testImplementations: ITestImpl<ITestShape>,
+  testSpecifications: ITestSpec<ITestShape>,
+  testInput: IInput,
+  testInterface: IPartialInterface<ITestShape>
+) => {
+  return Testeranto<
+    ITestShape
+  >(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      ...baseInterface,
+      ...testInterface
+    }
+  )
+};

package/src/{subPackages → SubPackages}/react-dom/component/node.ts

@@ -2,8 +2,9 @@ import React, { ReactNode, createElement } from "react";
 import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
 import Stream from 'stream'
 
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
-import Testeranto from "../../../Node";
+import Testeranto from "../../../Node.js";
+
+import { IBaseTest, ITestImplementation, ITestSpecification } from "../../../Types";
 
 type IInput = typeof React.Component;
 type InitialState = unknown;
@@ -17,32 +18,17 @@ export {
   renderToStaticMarkup, renderToStaticNodeStream, Stream
 }
 
-export default <ITestShape extends ITTestShape>(
+export default <ITestShape extends IBaseTest>(
   testImplementations: ITestImplementation<
-    InitialState,
-    ISelection,
-    IWhenShape,
-    IThenShape,
-    ITestShape
+    ITestShape, object
   >,
   testSpecifications: ITestSpecification<
-    ITestShape,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape
+    ITestShape
   >,
   testInput: IInput
 ) => {
   return Testeranto<
-    ITestShape,
-    IInput,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape,
-    IWhenShape,
-    InitialState
+    ITestShape
   >(
     testInput,
     testSpecifications,
@@ -71,9 +57,9 @@ export default <ITestShape extends ITTestShape>(
           resolve(createElement(testInput));
         });
       },
-      andWhen: async function (s: IStore, actioner): Promise<ISelection> {
-        // return actioner()(s);
-        return s
+      andWhen: async function (s: IStore, whenCB): Promise<ISelection> {
+        return whenCB(s);
+        // return s
       },
       butThen: async function (s: IStore): Promise<ISelection> {
         return s;
@@ -142,7 +128,7 @@ export default <ITestShape extends ITTestShape>(
 //           resolve(ReactDOMServer.renderToStaticMarkup(element));
 //         });
 //       },
-//       andWhen: function (s: IStore, actioner): Promise<ISelection> {
+//       andWhen: function (s: IStore, whenCB): Promise<ISelection> {
 //         throw new Error(`"andWhens" are not permitted`);
 //       }
 //     },

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

@@ -1,13 +1,15 @@
 import React, { CElement, createElement } from "react";
 import ReactDom from "react-dom/client";
 
-import { ITTestShape, ITestImplementation, ITestSpecification } from "../../../core";
-import Testeranto from "../../../Web";
+import Testeranto from "../../../Web.js";
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification
+} from "../../../Types";
 
 type IInput = typeof React.Component;
 type InitialState = unknown;
-type IWhenShape = any;
-type IThenShape = any;
 type ISelection = {
   htmlElement: HTMLElement,
   reactElement: CElement<any, any>,
@@ -22,26 +24,22 @@ type ISubject = {
   htmlElement: HTMLElement
 };
 
-export default <ITestShape extends ITTestShape>(
-  testImplementations: ITestImplementation<
-    InitialState,
-    ISelection,
-    IWhenShape,
-    IThenShape,
+export default <
+  ITestShape extends IBaseTest,
+  IWhen,
+  IGiven
+>(
+  testInput: IInput,
+  testSpecifications: ITestSpecification<
     ITestShape
   >,
-  testSpecifications: ITestSpecification<
+  testImplementations: ITestImplementation<
     ITestShape,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape
+    any
   >,
-  testInput: IInput
-) => {
 
+) => {
   document.addEventListener("DOMContentLoaded", function () {
-    console.log("DOMContentLoaded")
     const elem = document.getElementById("root");
     if (elem) {
       class TesterantoComponent extends testInput {
@@ -57,23 +55,17 @@ export default <ITestShape extends ITTestShape>(
       }
 
       return Testeranto<
-        ITestShape,
-        IInput,
-        ISubject,
-        IStore,
-        ISelection,
-        IThenShape,
-        IWhenShape,
-        InitialState
+        ITestShape
       >(
         testInput,
         testSpecifications,
         testImplementations,
         {
           beforeAll: async (
-            prototype,
+            initialProps,
             artificer
           ): Promise<ISubject> => {
+            console.log("mark5", initialProps);
             return await new Promise((resolve, rej) => {
               const elem = document.getElementById("root");
               if (elem) {
@@ -84,14 +76,17 @@ export default <ITestShape extends ITTestShape>(
           },
           beforeEach: async (
             { htmlElement },
-            ndx,
-            testRsource,
-            artificer
+            initializer,
+            testResource,
+            artificer,
+            initialValues
           ): Promise<IStore> => {
             return new Promise((resolve, rej) => {
+              // console.log("beforeEach" + JSON.stringify(initializer) + JSON.stringify(initialValues));
               // Ignore these type errors
               ReactDom.createRoot(htmlElement).render(createElement(
                 TesterantoComponent, {
+                ...initializer.props,
                 done: (reactElement) => {
                   resolve(
                     {
@@ -104,8 +99,8 @@ export default <ITestShape extends ITTestShape>(
               ));
             });
           },
-          andWhen: function (s: IStore, actioner): Promise<ISelection> {
-            return actioner()(s);
+          andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+            return whenCB(s);
           },
           butThen: async function (s: IStore): Promise<ISelection> {
             return s;

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

@@ -2,6 +2,5 @@ export type IInput = (props?) => JSX.Element;
 export type IState = unknown;
 export type ISelection = HTMLElement;
 export type IStore = HTMLElement;
-
 export type IWhenShape = any;
 export type IThenShape = any;

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

@@ -0,0 +1,68 @@
+import { createElement } from "react";
+import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
+import Stream from 'stream'
+
+import Testeranto from "../../../Node.js";
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification
+} from "../../../Types";
+
+export {
+  renderToStaticMarkup, renderToStaticNodeStream, Stream
+}
+
+export default <ITestShape extends IBaseTest>(
+
+  testImplementations: ITestImplementation<ITestShape, any>,
+  testSpecifications: ITestSpecification<ITestShape>,
+  testInput: ITestShape['iinput']
+
+) => {
+  return Testeranto<
+    ITestShape
+  >(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      beforeAll: async (
+        prototype,
+        artificer
+      ) => {
+        return await new Promise((resolve, rej) => {
+          resolve(null);
+        })
+      },
+      beforeEach: async (
+        reactComponent,
+        ndx,
+        testRsource,
+        artificer
+      ): Promise<ITestShape['istore']> => {
+        return new Promise((resolve, rej) => {
+          resolve(createElement(testInput));
+        });
+      },
+      andWhen: async function (s, whenCB) {
+        return s
+      },
+      butThen: async function (s: ITestShape['istore']): Promise<ITestShape['iselection']> {
+        return s;
+      },
+      afterEach: async function (
+        store: ITestShape['istore'],
+        ndx,
+        artificer
+      ) {
+        return {};
+      },
+      afterAll: (
+        store: ITestShape['istore'],
+        artificer) => {
+        return;
+      },
+    },
+  )
+};