testeranto 0.75.0 → 0.79.3

package/src/Report.tsx

@@ -12,6 +12,7 @@ import 'bootstrap/dist/css/bootstrap.min.css';
 
 import { TesterantoFeatures } from "./Features.js";
 import { IRunTime, ITestTypes } from "./lib/types.js";
+import ExampleTab from "./ExampleTab.js";
 
 type IGraphData = {
   nodes: { id: string, label: string }[],
@@ -101,26 +102,6 @@ const Report = () => {
         res({ src, exitcode, log, testresults, manifest })
       })
     }))
-    // const results = await config.tests.reduce(async (p, test) => {
-    //   const src: string = test[0];
-    //   const runtime: IRunTime = test[1];
-    //   console.log(runtime)
-    //   const s: string = [tests.buildDir, runtime as string].concat(src.split(".").slice(0, - 1).join(".")).join("/");
-    //   // const srr
-    //   console.log("s", s)
-
-    //   const exitcode = await (await fetch(config.buildDir + "/" + s + "/exitcode")).text()
-    //   const log = await (await fetch(config.buildDir + "/" + s + "/log.txt")).text()
-    //   const testresults = await (await fetch(config.buildDir + "/" + s + "/tests.json")).text()
-
-    //   // setResults({ src, exitcode, log, testresults })
-    //   // console.log("a", await a.text())
-    //   p[src] = { exitcode, log, testresults }
-    //   return p
-    // }, {});
-
-    console.log("results", results)
-
 
     setState({ tests: config.tests as any, results, features: features as any, buildDir: config.buildDir })
   };
@@ -149,41 +130,25 @@ const Report = () => {
         const runtime: IRunTime = test[1];
         console.log(runtime)
         const s: string = [tests.buildDir, runtime as string].concat(src.split(".").slice(0, - 1).join(".")).join("/");
-        // const srr
-        // console.log(s)
-
         const exitcode = await (await fetch(s + "/exitcode")).text()
         const log = await (await fetch(s + "/log.txt")).text()
         const testresults = await (await fetch(s + "/tests.json")).text()
 
-        // setResults({ src, exitcode, log, testresults })
-        // console.log("a", await a.text())
         p[src] = { exitcode, log, testresults }
       }, {});
 
       setResults(r);
-      // const x = await fetch("./testeranto.json")
-      // const y = await x.json();
-      // setTests(y as any);
-      // const module = await import('tests.json', {
-      //   with: {
-      //     type: 'json'
-      //   }
-      // });
-      // console.log("imported tests", module.default);
-      // setResults("foo");
+
     };
     collateResults();
   }, []);
 
-  console.log("state.results", state.results);
-
   return (
     <div>
       <style>
         {`
 pre, code, p {
-  max-width: 30rem;
+  max-width: 40rem;
   text-wrap: auto;
 }
 footer {
@@ -197,9 +162,17 @@ footer {
           `}
       </style>
 
-      {features && tests && < Tabs defaultActiveKey="config" >
-
+      {features && tests && < Tabs defaultActiveKey="manual" >
 
+        <Tab eventKey="manual" title="manual">
+          <article>
+            <h1>Testeranto</h1>
+            <h2>What is testeranto?</h2>
+            <p>
+              Testeranto is a novel testing framework for typescript project. Inspired by Behavior Driven Development, testeranto allows you to wrap you typescript with gherkin-like semantics, producing a report in the form of a static website. Testeranto runs it's tests both in node and chromium.
+            </p>
+          </article>
+        </Tab>
 
         <Tab eventKey="config" title="config">
           <pre>{JSON.stringify(state, null, 2)}</pre>
@@ -512,6 +485,10 @@ footer {
           </Tab.Container>
         </Tab>
 
+        <Tab eventKey="examples" title="examples">
+          <ExampleTab />
+        </Tab>
+
       </Tabs >}
 
       <footer>made with ❤️ and <a href="https://adamwong246.github.io/testeranto/" >testeranto </a></footer>

package/src/Reporter.ts

@@ -71,15 +71,7 @@ const main = async () => {
   await page.setViewport({ width: 0, height: 0 });
 
   console.log("Requesting url...");
-  await page.goto(`file://${process.cwd()}/docs/report.html`);
-
-  // const destinationOfRuntime = (f: string, r: IRunTime) => {
-  //   return path
-  //     .normalize(`${configs.buildDir}/${r}/${f}`)
-  //     .split(".")
-  //     .slice(0, -1)
-  //     .join(".");
-  // };
+  await page.goto(`file://${process.cwd()}/docs/report.html?local=true`);
 
   // configs.tests.forEach(([test, runtime, secondaryArtifacts]) => {
   //   if (runtime === "node") {

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

@@ -4,6 +4,8 @@ import ReactDom from "react-dom/client";
 import Testeranto from "../../../Web.js";
 import {
   IBaseTest,
+  IPartialInterface,
+  IPartialWebInterface,
   ITestImplementation,
   ITestSpecification,
 } from "../../../Types";
@@ -15,7 +17,7 @@ type ISelection = {
   reactElement: any; //CElement<any, any>;
 };
 
-type IStore = {
+export type IStore = {
   htmlElement: HTMLElement;
   reactElement: any; //CElement<any, any>,
   domRoot: ReactDom.Root;
@@ -30,7 +32,8 @@ type ISubject = {
 export default <ITestShape extends IBaseTest, IWhen, IGiven>(
   testInput: IInput,
   testSpecifications: ITestSpecification<ITestShape>,
-  testImplementations: ITestImplementation<ITestShape, any>
+  testImplementations: ITestImplementation<ITestShape, any>,
+  testInterface?: IPartialWebInterface<any>
 ) => {
   class TesterantoComponent extends testInput {
     done: (t: TesterantoComponent) => void;
@@ -50,7 +53,6 @@ export default <ITestShape extends IBaseTest, IWhen, IGiven>(
     testImplementations,
     {
       beforeAll: async (initialProps, artificer): Promise<ISubject> => {
-        console.log("mark5", initialProps);
         return await new Promise((resolve, rej) => {
           const htmlElement = document.getElementById("root");
           if (htmlElement) {
@@ -113,34 +115,12 @@ export default <ITestShape extends IBaseTest, IWhen, IGiven>(
       butThen: async function (s: IStore, thenCB): Promise<ISelection> {
         return thenCB(s);
       },
-      afterEach: async function (store: IStore, ndx, artificer, utils) {
-        console.log("afterEach", store);
-        utils.writeFileSync("aftereachlog", store.toString());
+      afterEach:
+        testInterface?.afterEach ||
+        async function (store: IStore, ndx, artificer, utils) {
+          return store;
+        },
 
-        const page = (await utils.browser.pages()).filter((x) => {
-          const parsedUrl = new URL(x.url());
-          parsedUrl.search = "";
-          const strippedUrl = parsedUrl.toString();
-
-          return (
-            strippedUrl ===
-            "file:///Users/adam/Code/kokomoBay/docs/web/src/ClassicalComponent/react-dom/client.web.test.html"
-          );
-          // return true;
-        })[0];
-
-        const x = await page.screenshot({
-          path: "afterEachLog.jpg",
-        });
-        console.log("x", x);
-        // debugger;
-        // const div_root = document.getElementById("root");
-        // store.domRoot && store.domRoot.unmount(); //React 18
-        //  store.remove();
-        // store.htmlElement.remove();
-        // store.htmlElement = document.createElement("root");
-        return store;
-      },
       afterAll: async (store: IStore, artificer, utils) => {
         // setTimeout(() => {
         //   console.log("This will run after 1 second");

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

@@ -1,4 +1,6 @@
 import React, { useEffect, useRef } from "react";
+import { CElement, createElement } from "react";
+import ReactDom from "react-dom/client";
 import { createPortal } from "react-dom";
 
 import Testeranto from "../../../Web.js";
@@ -17,86 +19,121 @@ export default <ITestShape extends IBaseTest>(
   testSpecifications: ITestSpecification<ITestShape>,
   testInput: IInput
 ) => {
-  document.addEventListener("DOMContentLoaded", function () {
-    const rootElement = document.getElementById("root");
-    if (rootElement) {
-      const TesterantoComponent = function ({
-        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);
-        }, []);
+  console.log("testInput", testInput);
+  const TesterantoComponent = function ({
+    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());
-      };
+    // debugger;
+    return React.createElement("div", { ref: myContainer }, innerComp());
+  };
 
-      Testeranto<ITestShape>(
-        testInput,
-        testSpecifications,
-        testImplementations,
-        {
-          beforeAll: async (input, artificer): Promise<HTMLElement> => {
-            return await new Promise((resolve, rej) => {
-              resolve(rootElement);
-            });
-          },
+  const t = Testeranto<ITestShape>(
+    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);
 
-          beforeEach: async (
-            subject,
-            ndx,
-            testRsource,
-            artificer
-          ): Promise<IStore> => {
-            return new Promise((resolve, rej) => {
-              createPortal(
-                TesterantoComponent({
-                  innerComp: testInput,
-                  done: (reactElement: any) => {
-                    process.nextTick(() => {
-                      resolve(reactElement);
+            domRoot.render(
+              createElement(
+                TesterantoComponent,
+                {
+                  // ...initialProps,
+                  innerComp: reactElement,
+                  done: (reactElement) => {
+                    resolve({
+                      htmlElement,
+                      reactElement,
+                      domRoot,
                     });
                   },
+                },
+                []
+              )
+            );
+
+            // resolve({ htmlElement });
+          }
+        });
+      },
+
+      beforeEach: async (
+        subject,
+        initializer,
+        artificer,
+        testResource,
+        pm
+      ): Promise<IStore> => {
+        return new Promise((resolve, rej) => {
+          createPortal(
+            TesterantoComponent({
+              innerComp: () =>
+                testInput({
+                  port: 3003,
+                  address: "some-address",
+                  secretKey: "someSecretKey",
+                  abi: "foo",
                 }),
-                rootElement
-              );
-            });
-          },
-          andWhen: function (s: IStore, whenCB): Promise<ISelection> {
-            return new Promise((resolve, rej) => {
-              process.nextTick(() => {
-                resolve(whenCB()(s));
-              });
-            });
-          },
-          butThen: async function (s: IStore): Promise<ISelection> {
-            return new Promise((resolve, rej) => {
-              process.nextTick(() => {
-                resolve(s);
-              });
-            });
-          },
-          afterEach: async function (store: IStore, ndx, artificer) {
-            return new Promise((resolve, rej) => {
-              process.nextTick(() => {
-                resolve({});
-              });
-            });
-          },
-          afterAll: (store: IStore, artificer) => {
-            return new Promise((resolve, rej) => {
-              process.nextTick(() => {
-                resolve({});
-              });
-            });
-          },
-        }
-      );
+              done: (reactElement: any) => {
+                process.nextTick(() => {
+                  resolve(reactElement);
+                });
+              },
+            }),
+            subject.domRoot
+          );
+        });
+      },
+      andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+        return new Promise((resolve, rej) => {
+          process.nextTick(() => {
+            resolve(whenCB()(s));
+          });
+        });
+      },
+      butThen: async function (s: IStore): Promise<ISelection> {
+        return new Promise((resolve, rej) => {
+          process.nextTick(() => {
+            resolve(s);
+          });
+        });
+      },
+      afterEach: async function (store: IStore, ndx, artificer) {
+        return new Promise((resolve, rej) => {
+          process.nextTick(() => {
+            resolve({});
+          });
+        });
+      },
+      afterAll: (store: IStore, artificer) => {
+        return new Promise((resolve, rej) => {
+          process.nextTick(() => {
+            resolve({});
+          });
+        });
+      },
+    }
+  );
+
+  document.addEventListener("DOMContentLoaded", function () {
+    const rootElement = document.getElementById("root");
+    if (rootElement) {
     }
   });
+
+  return t;
 };

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

@@ -21,69 +21,3 @@ export type IImpl<ITestShape extends IBaseTest> =
   ITestImplementation<ITestShape>;
 export type ISpec<ITestShape extends IBaseTest> =
   ITestSpecification<ITestShape>;
-
-// export const testInterface = {
-//   beforeEach: function (CComponent, props): Promise<renderer.ReactTestRenderer> {
-//     return new Promise((res, rej) => {
-//       let component: renderer.ReactTestRenderer;
-//       act(() => {
-//         component = renderer.create(
-//           CComponent(props)
-//         );
-//         res(component);
-//       });
-//     });
-//   },
-//   andWhen: async function (
-//     renderer: renderer.ReactTestRenderer,
-//     whenCB: () => (any) => any
-//   ): Promise<renderer.ReactTestRenderer> {
-//     await act(() => whenCB()(renderer));
-//     return renderer
-//   }
-// }
-
-export const testInterface = {
-  beforeEach: function (
-    CComponent,
-    propsAndChildren
-  ): Promise<renderer.ReactTestRenderer> {
-    function Link(props) {
-      const p = props.props;
-      const c = props.children;
-      return React.createElement(CComponent, p, c);
-    }
-    return new Promise((res, rej) => {
-      act(async () => {
-        const p = propsAndChildren;
-        const y = new CComponent(p.props);
-        const testRenderer = await renderer.create(Link(propsAndChildren));
-        res(testRenderer);
-      });
-    });
-  },
-  andWhen: async function (
-    renderer: renderer.ReactTestRenderer,
-    whenCB: any
-  ): Promise<renderer.ReactTestRenderer> {
-    // console.log("andWhen", whenCB)
-    await act(() => whenCB(renderer));
-    return renderer;
-  },
-
-  // andWhen: function (s: Store, whenCB): Promise<Selection> {
-  //   return whenCB()(s);
-  // },
-  butThen: async function (s: IStore, thenCB, tr): Promise<ISelection> {
-    console.log("butThen", thenCB.toString());
-    return thenCB(s);
-  },
-  afterEach: async function (store: IStore, ndx, artificer) {
-    // console.log("afterEach", store);
-    return {};
-  },
-  afterAll: (store: IStore, artificer) => {
-    // console.log("afterAll", store);
-    return;
-  },
-};

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

@@ -0,0 +1,48 @@
+import React from "react";
+import renderer, { act } from "react-test-renderer";
+import { ISelection, IStore } from ".";
+
+export const testInterface = {
+  beforeEach: function (
+    CComponent,
+    propsAndChildren
+  ): Promise<renderer.ReactTestRenderer> {
+    function Link(props) {
+      const p = props.props;
+      const c = props.children;
+      return React.createElement(CComponent, p, c);
+    }
+    return new Promise((res, rej) => {
+      act(async () => {
+        const p = propsAndChildren;
+        const y = new CComponent(p.props);
+        const testRenderer = await renderer.create(Link(propsAndChildren));
+        res(testRenderer);
+      });
+    });
+  },
+  andWhen: async function (
+    renderer: renderer.ReactTestRenderer,
+    whenCB: any
+  ): Promise<renderer.ReactTestRenderer> {
+    // console.log("andWhen", whenCB)
+    await act(() => whenCB(renderer));
+    return renderer;
+  },
+
+  // andWhen: function (s: Store, whenCB): Promise<Selection> {
+  //   return whenCB()(s);
+  // },
+  butThen: async function (s: IStore, thenCB, tr): Promise<ISelection> {
+    console.log("butThen", thenCB.toString());
+    return thenCB(s);
+  },
+  afterEach: async function (store: IStore, ndx, artificer) {
+    // console.log("afterEach", store);
+    return {};
+  },
+  afterAll: (store: IStore, artificer) => {
+    // console.log("afterAll", store);
+    return;
+  },
+};

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

@@ -1,7 +1,8 @@
 import Testeranto from "../../../Node.js";
 import type { IBaseTest } from "../../../Types";
 
-import { IImpl, ISpec, IInput, testInterface } from "./index.js";
+import { IImpl, ISpec, IInput } from "./index.js";
+import { testInterface } from "./interface.js";
 
 export default <ITestShape extends IBaseTest, IProps, IState>(
   testImplementations: IImpl<ITestShape>,

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

@@ -1,7 +1,8 @@
 import { IBaseTest } from "../../../Types";
 import Testeranto from "../../../Web.js";
 
-import { IImpl, ISpec, IInput, testInterface } from "./index.js";
+import { IImpl, ISpec, IInput } from "./index.js";
+import { testInterface } from "./interface";
 
 export default <ITestShape extends IBaseTest, IProps, IState>(
   testImplementations: IImpl<ITestShape>,