testeranto 0.70.0 → 0.74.0

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

@@ -18,10 +18,13 @@ type ISelection = {
 type IStore = {
   htmlElement: HTMLElement;
   reactElement: any; //CElement<any, any>,
+  domRoot: ReactDom.Root;
 };
 
 type ISubject = {
   htmlElement: HTMLElement;
+  reactElement: any; //CElement<any, any>,
+  domRoot: ReactDom.Root;
 };
 
 export default <ITestShape extends IBaseTest, IWhen, IGiven>(
@@ -29,76 +32,132 @@ export default <ITestShape extends IBaseTest, IWhen, IGiven>(
   testSpecifications: ITestSpecification<ITestShape>,
   testImplementations: ITestImplementation<ITestShape, any>
 ) => {
+  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);
+    }
+  }
+
+  const t = Testeranto<ITestShape>(
+    testInput,
+    testSpecifications,
+    testImplementations,
+    {
+      beforeAll: async (initialProps, artificer): Promise<ISubject> => {
+        console.log("mark5", initialProps);
+        return await new Promise((resolve, rej) => {
+          const htmlElement = document.getElementById("root");
+          if (htmlElement) {
+            const domRoot = ReactDom.createRoot(htmlElement);
+            // Ignore these type errors
+            domRoot.render(
+              createElement(
+                TesterantoComponent,
+                {
+                  ...initialProps,
+                  done: (reactElement) => {
+                    resolve({
+                      htmlElement,
+                      reactElement,
+                      domRoot,
+                    });
+                  },
+                },
+                []
+              )
+            );
+
+            // resolve({ htmlElement });
+          }
+        });
+      },
+      // beforeEach: async (
+      //   s,
+      //   initializer,
+      //   testResource,
+      //   artificer,
+      //   initialValues
+      // ): Promise<IStore> => {
+      //   return new Promise((resolve, rej) => {
+      //     console.log("beforeEach" + TesterantoComponent);
+
+      //     // const domRoot = ReactDom.createRoot(htmlElement);
+      //     // // Ignore these type errors
+      //     // domRoot.render(
+      //     //   createElement(
+      //     //     TesterantoComponent,
+      //     //     {
+      //     //       ...initializer,
+      //     //       done: (reactElement) => {
+      //     //         resolve({
+      //     //           htmlElement,
+      //     //           reactElement,
+      //     //           domRoot,
+      //     //         });
+      //     //       },
+      //     //     },
+      //     //     []
+      //     //   )
+      //     // );
+      //   });
+      // },
+      andWhen: function (s: IStore, whenCB): Promise<ISelection> {
+        return whenCB(s);
+      },
+      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());
+
+        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");
+        // }, 1000); // 1000 milliseconds = 1 second
+        // store.htmlElement.remove();
+        // store.htmlElement = document.createElement("root");
+        return store;
+      },
+    }
+  );
+
   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;
-          },
-        }
-      );
+      return t;
     }
   });
+
+  return t;
 };

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

@@ -32,7 +32,6 @@ export const testInterface = {
     CComponent,
     props
   ): Promise<renderer.ReactTestRenderer> {
-    console.log("ASDASDx");
     let component;
     act(() => {
       component = renderer.create(React.createElement(CComponent, props, []));

package/src/Web.ts

@@ -1,3 +1,4 @@
+import { PM_Web } from "./PM/web";
 import type {
   IBaseTest,
   ITestImplementation,
@@ -7,21 +8,9 @@ import Testeranto from "./lib/core.js";
 import {
   ITTestResourceConfiguration,
   ITTestResourceRequest,
-  ITestJob,
   defaultTestResourceRequirement,
 } from "./lib/index.js";
-import {
-  INodeUtils,
-  ITestInterface,
-  IWebTestInterface,
-  IWebUtils,
-} from "./lib/types";
-
-// const remote = require("@electron/remote");
-// import remote from "@electron/remote";
-// const electron = require("electron");
-// const remote =
-//   process.type === "browser" ? electron : require("@electron/remote");
+import { ITestInterface, IWebTestInterface } from "./lib/types";
 
 class WebTesteranto<TestShape extends IBaseTest> extends Testeranto<TestShape> {
   constructor(
@@ -36,66 +25,33 @@ class WebTesteranto<TestShape extends IBaseTest> extends Testeranto<TestShape> {
       testSpecification,
       testImplementation,
       testResourceRequirement,
-      (window as any).NodeWriter,
       testInterface
     );
-
-    const testResourceArg = decodeURIComponent(
-      new URLSearchParams(location.search).get("requesting") || ""
-    );
-
-    try {
-      const partialTestResource = JSON.parse(
-        testResourceArg
-      ) as ITTestResourceConfiguration;
-
-      this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
-    } catch (e) {
-      console.error(e);
-      // process.exit(-1);
-    }
-
-    const requesting = new URLSearchParams(location.search).get("requesting");
-    if (requesting) {
-      const testResourceArg = decodeURIComponent(requesting);
-
-      try {
-        const partialTestResource = JSON.parse(
-          testResourceArg
-        ) as ITTestResourceConfiguration;
-
-        console.log("initial test resource", partialTestResource);
-        this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
-      } catch (e) {
-        console.error(e);
-        // process.exit(-1);
-      }
-    }
   }
 
-  async receiveTestResourceConfig(
-    t: ITestJob<IWebUtils>,
-    partialTestResource: ITTestResourceConfiguration
-  ) {
-    const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(
-      partialTestResource,
-      {
-        browser: await (window as any).browser,
-        ipc: (window as any).ipcRenderer,
-      }
-    );
-
-    console.log("test is done, awaiting test result write to fs");
-    Promise.all([...artifacts, logPromise]).then(async () => {
-      // we can't close the window becuase we might be taking a screenshot
-      // window.close();
-      // console.log(
-      //   "(window as any).browser",
-      //   JSON.stringify(await (window as any).browser)
-      // );
-      // var currentWindow = (await (window as any).browser).getCurrentWindow();
-      // currentWindow.close();
-    });
+  async receiveTestResourceConfig(partialTestResource: any) {
+    const t: ITTestResourceConfiguration = partialTestResource; //JSON.parse(partialTestResource);
+    const pm = new PM_Web(t);
+    const { failed, artifacts, logPromise } =
+      await this.testJobs[0].receiveTestResourceConfig(pm);
+    pm.customclose();
+    // Promise.all([...artifacts, logPromise]).then(async () => {
+    //   console.log("hello world");
+    //   pm.customclose();
+    //   // we can't close the window becuase we might be taking a screenshot
+    //   // window.close();
+    //   // console.log(
+    //   //   "(window as any).browser",
+    //   //   JSON.stringify(await (window as any).browser)
+    //   // );
+    //   // var currentWindow = (await (window as any).browser).getCurrentWindow();
+    //   // window.close();
+    //   // var customWindow = window.open("", "_blank", "");
+    //   // customWindow.close();
+    //   // this.puppetMaster.browser.page
+    //   // window["customclose"]();
+    //   // console.log("goodbye", window["customclose"]());
+    // });
   }
 }
 

package/src/esbuildConfigs/web.ts

@@ -29,9 +29,7 @@ export default (
       "testeranto.json",
       "features.test.ts",
       // "url",
-
       "react",
-      "electron",
 
       "path",
       "fs",
@@ -47,6 +45,10 @@ export default (
       "zlib",
       "crypto",
       "https",
+
+      "util",
+      "process",
+      "dns",
     ],
 
     platform: "browser",