testeranto 0.49.10 → 0.70.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 { TesterantoFeatures } from "./Features.js";
+import { ITestTypes } from "./lib/types.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,51 @@
+import React from "react";
+
+import Testeranto from "../Node.js";
+
+import {
+  IBaseTest,
+  IPartialNodeInterface,
+  ITestImplementation,
+  ITestSpecification,
+} from "../Types";
+
+type IInput = string;
+type ISelection = any;
+type IStore = any;
+type ISubject = any;
+
+export type IImpl<ISpec extends IBaseTest> = ITestImplementation<ISpec>;
+
+export type ISpec<T extends IBaseTest> = ITestSpecification<T>;
+
+export default <ITestShape extends IBaseTest>(
+  testInput: IInput,
+  testSpecifications: ISpec<ITestShape>,
+  testImplementations: ITestImplementation<ITestShape>,
+  testInterface?: IPartialNodeInterface<ITestShape>
+) => {
+  return Testeranto<ITestShape>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      beforeAll(x) {
+        process.parentPort.postMessage(
+          `/docs/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/react/component/node.ts

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

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

@@ -0,0 +1,43 @@
+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>,
+  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,32 @@
+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>;
+
+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,30 @@
+import {
+  IBaseTest,
+  IPartialInterface,
+  IPartialWebInterface,
+} 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: IPartialWebInterface<ITestShape>
+) => {
+  return Testeranto<ITestShape>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      ...baseInterface,
+      ...testInterface,
+    }
+  );
+};

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

@@ -1,9 +1,17 @@
 import React, { ReactNode, createElement } from "react";
-import { renderToStaticMarkup, renderToStaticNodeStream } from "react-dom/server";
-import Stream from 'stream'
+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;
@@ -13,37 +21,14 @@ export type ISelection = ReactNode;
 export type IStore = ReactNode;
 export type ISubject = ReactNode;
 
-export {
-  renderToStaticMarkup, renderToStaticNodeStream, Stream
-}
+export { renderToStaticMarkup, renderToStaticNodeStream, Stream };
 
-export default <ITestShape extends ITTestShape>(
-  testImplementations: ITestImplementation<
-    InitialState,
-    ISelection,
-    IWhenShape,
-    IThenShape,
-    ITestShape
-  >,
-  testSpecifications: ITestSpecification<
-    ITestShape,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape
-  >,
+export default <ITestShape extends IBaseTest>(
+  testImplementations: ITestImplementation<ITestShape>,
+  testSpecifications: ITestSpecification<ITestShape>,
   testInput: IInput
 ) => {
-  return Testeranto<
-    ITestShape,
-    IInput,
-    ISubject,
-    IStore,
-    ISelection,
-    IThenShape,
-    IWhenShape,
-    InitialState
-  >(
+  return Testeranto<ITestShape>(
     testInput,
     testSpecifications,
     testImplementations,
@@ -71,28 +56,23 @@ 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;
       },
-      afterEach: async function (
-        store: IStore,
-        ndx,
-        artificer
-      ) {
+      afterEach: async function (store: IStore, ndx, artificer) {
         return {};
       },
       afterAll: (store: IStore, artificer) => {
         return;
       },
-    },
-  )
+    }
+  );
 };
 
-
 // type IInput = typeof React.Component;
 // type InitialState = unknown;
 // type IWhenShape = any;
@@ -142,7 +122,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/react-dom/component/web.ts

@@ -0,0 +1,104 @@
+import React, { CElement, createElement } from "react";
+import ReactDom from "react-dom/client";
+
+import Testeranto from "../../../Web.js";
+import {
+  IBaseTest,
+  ITestImplementation,
+  ITestSpecification,
+} from "../../../Types";
+
+type IInput = typeof React.Component;
+type InitialState = unknown;
+type ISelection = {
+  htmlElement: HTMLElement;
+  reactElement: any; //CElement<any, any>;
+};
+
+type IStore = {
+  htmlElement: HTMLElement;
+  reactElement: any; //CElement<any, any>,
+};
+
+type ISubject = {
+  htmlElement: HTMLElement;
+};
+
+export default <ITestShape extends IBaseTest, IWhen, IGiven>(
+  testInput: IInput,
+  testSpecifications: ITestSpecification<ITestShape>,
+  testImplementations: ITestImplementation<ITestShape, any>
+) => {
+  document.addEventListener("DOMContentLoaded", function () {
+    const elem = document.getElementById("root");
+    if (elem) {
+      class TesterantoComponent extends testInput {
+        done: (t: TesterantoComponent) => void;
+        constructor(props) {
+          super(props);
+          this.done = props.done;
+        }
+        componentDidMount() {
+          super.componentDidMount && super.componentDidMount();
+          return this.done(this);
+        }
+      }
+
+      return Testeranto<ITestShape>(
+        testInput,
+        testSpecifications,
+        testImplementations,
+        {
+          beforeAll: async (initialProps, artificer): Promise<ISubject> => {
+            console.log("mark5", initialProps);
+            return await new Promise((resolve, rej) => {
+              const elem = document.getElementById("root");
+              if (elem) {
+                resolve({ htmlElement: elem });
+              }
+            });
+          },
+          beforeEach: async (
+            { htmlElement },
+            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,
+                    done: (reactElement) => {
+                      resolve({
+                        htmlElement,
+                        reactElement,
+                      });
+                    },
+                  },
+                  []
+                )
+              );
+            });
+          },
+          andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+            return whenCB(s);
+          },
+          butThen: async function (s: IStore): Promise<ISelection> {
+            return s;
+          },
+          afterEach: async function (store: IStore, ndx, artificer) {
+            return {};
+          },
+          afterAll: (store: IStore, artificer) => {
+            return;
+          },
+        }
+      );
+    }
+  });
+};

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