testeranto 0.74.0 → 0.79.0

package/src/esbuildConfigs/node.ts

@@ -3,6 +3,7 @@ import { BuildOptions } from "esbuild";
 import { IBaseConfig } from "../lib/types";
 
 import baseEsBuildConfig from "./index.js";
+import inputFilesPlugin from "./inputFilesPlugin.js";
 
 export default (
   config: IBaseConfig,
@@ -15,8 +16,8 @@ export default (
 
     outdir: config.outdir + "/node",
 
-    inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
-
+    // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
+    metafile: true,
     supported: {
       "dynamic-import": true,
     },
@@ -42,6 +43,7 @@ export default (
     entryPoints: [...entryPoints],
     plugins: [
       ...(config.nodePlugins || []),
+      inputFilesPlugin("node", entryPoints),
       {
         name: "rebuild-notify",
         setup(build) {

package/src/esbuildConfigs/report.ts

@@ -1,15 +1,15 @@
-import { BuildOptions } from "esbuild";
+// import { BuildOptions } from "esbuild";
 
-import { IBaseConfig } from "../lib/types";
+// import { IBaseConfig } from "../lib/types";
 
-export default (config: IBaseConfig): BuildOptions => {
-  return {
-    bundle: true,
-    entryPoints: ["./node_modules/testeranto/dist/module/report.js"],
-    minify: config.minify === true,
-    outbase: config.outbase,
-    write: true,
-    outfile: `${config.outdir}/report.js`,
-    external: ["tests.json", "features.test.js"],
-  };
-};
+// export default (config: IBaseConfig): BuildOptions => {
+//   return {
+//     bundle: true,
+//     entryPoints: ["./node_modules/testeranto/dist/module/report.js"],
+//     minify: config.minify === true,
+//     outbase: config.outbase,
+//     write: true,
+//     outfile: `${config.outdir}/report.js`,
+//     external: ["tests.json", "features.test.js"],
+//   };
+// };

package/src/esbuildConfigs/web.ts

@@ -4,6 +4,7 @@ import path from "path";
 import { IBaseConfig } from "../lib/types.js";
 
 import baseEsBuildConfig from "./index.js";
+import inputFilesPlugin from "./inputFilesPlugin.js";
 
 export default (
   config: IBaseConfig,
@@ -25,6 +26,8 @@ export default (
       react: path.resolve("./node_modules/react"),
     },
 
+    metafile: true,
+
     external: [
       "testeranto.json",
       "features.test.ts",
@@ -57,6 +60,7 @@ export default (
 
     plugins: [
       ...(config.webPlugins || []),
+      inputFilesPlugin("web", entryPoints),
       {
         name: "rebuild-notify",
         setup(build) {

package/src/lib/abstractBase.ts

@@ -1,15 +1,41 @@
 import { IBaseTest } from "../Types";
-
-import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
 import { PM } from "../PM/index.js";
-// import { IUtils } from "./types";
 
-export type IGivens<ITestShape extends IBaseTest> = Record<
-  string,
-  BaseGiven<ITestShape>
->;
+import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
 
-export abstract class BaseSuite<ITestShape extends IBaseTest> {
+export type IGivens<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> = Record<string, BaseGiven<ITestShape>>;
+
+export abstract class BaseSuite<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> {
   name: string;
   givens: IGivens<ITestShape>;
   checks: BaseCheck<ITestShape>[];
@@ -75,11 +101,76 @@ export abstract class BaseSuite<ITestShape extends IBaseTest> {
     const sName = this.name;
 
     for (const [gNdx, g] of Object.entries(this.givens)) {
+      const beforeAllProxy = new Proxy(pm, {
+        get(target, prop, receiver) {
+          if (prop === "writeFileSync") {
+            return (fp, contents) =>
+              target[prop](`suite-${sNdx}/beforeAll/${fp}`, contents);
+          }
+
+          if (prop === "browser") {
+            return new Proxy(target[prop], {
+              get(bTarget, bProp, bReceiver) {
+                if (bProp === "pages") {
+                  return async () => {
+                    return bTarget.pages().then((pages) => {
+                      return pages.map((page) => {
+                        return new Proxy(page, {
+                          get(pTarget, pProp, pReciever) {
+                            if (pProp === "screenshot") {
+                              return async (x) => {
+                                return pm.customScreenShot(
+                                  {
+                                    ...x,
+                                    path:
+                                      `${testResourceConfiguration.fs}/suite-${sNdx}/beforeAll` +
+                                      "/" +
+                                      x.path,
+                                  },
+                                  page
+                                );
+                                // return await window["custom-screenshot"]({
+                                //   ...x,
+                                //   path:
+                                //     `${testResourceConfiguration.fs}/suite-${sNdx}/afterAll` +
+                                //     "/" +
+                                //     x.path,
+                                // });
+                              };
+                            } else if (pProp === "mainFrame") {
+                              return () => pTarget[pProp]();
+                            } else if (pProp === "close") {
+                              return () => pTarget[pProp]();
+                            }
+
+                            // else if (pProp === "mainFrame") {
+                            //   return () => target[pProp](...arguments);
+                            // }
+                            else {
+                              return Reflect.get(...arguments);
+                            }
+                          },
+                        });
+                      });
+                    });
+                    // return (await target.pages()).map((page) => {
+                    //   return new Proxy(page, handler2);
+                    // });
+                  };
+                }
+              },
+            });
+          }
+
+          return Reflect.get(...arguments);
+        },
+      });
+
       const subject = await this.setup(
         input,
         suiteArtifactory,
         testResourceConfiguration,
-        pm
+        beforeAllProxy
       );
 
       const giver = this.givens[gNdx];
@@ -119,21 +210,27 @@ export abstract class BaseSuite<ITestShape extends IBaseTest> {
                         get(pTarget, pProp, pReciever) {
                           if (pProp === "screenshot") {
                             return async (x) => {
-                              // console.log(
-                              //   "custom-screenshot-MARK-afterAllProxy",
-                              //   // arguments,
-                              //   // x,
-                              //   window["custom-screenshot"].toString()
-                              // );
-                              return await window["custom-screenshot"]({
+                              return pm.customScreenShot({
                                 ...x,
                                 path:
                                   `${testResourceConfiguration.fs}/suite-${sNdx}/afterAll` +
                                   "/" +
                                   x.path,
                               });
+                              // return await window["custom-screenshot"]({
+                              //   ...x,
+                              //   path:
+                              //     `${testResourceConfiguration.fs}/suite-${sNdx}/afterAll` +
+                              //     "/" +
+                              //     x.path,
+                              // });
                             };
+                          } else if (pProp === "mainFrame") {
+                            return () => pTarget[pProp]();
+                          } else if (pProp === "close") {
+                            return () => pTarget[pProp]();
                           }
+
                           // else if (pProp === "mainFrame") {
                           //   return () => target[pProp](...arguments);
                           // }
@@ -196,7 +293,22 @@ export abstract class BaseSuite<ITestShape extends IBaseTest> {
   }
 }
 
-export abstract class BaseGiven<ITestShape extends IBaseTest> {
+export abstract class BaseGiven<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> {
   name: string;
   features: string[];
   whens: BaseWhen<ITestShape>[];
@@ -276,7 +388,6 @@ export abstract class BaseGiven<ITestShape extends IBaseTest> {
       const beforeEachProxy = new Proxy(pm, {
         get(target, prop, receiver) {
           if (prop === "writeFileSync") {
-            console.log("beforeEachProx", arguments, target[prop]);
             return (fp, contents) =>
               target[prop](
                 `suite-${suiteNdx}/given-${key}/when/beforeEach/${fp}`,
@@ -295,6 +406,7 @@ export abstract class BaseGiven<ITestShape extends IBaseTest> {
         this.givenCB,
         beforeEachProxy
       );
+      console.log("mark6", this.store);
 
       for (const [whenNdx, whenStep] of this.whens.entries()) {
         await whenStep.test(
@@ -306,19 +418,22 @@ export abstract class BaseGiven<ITestShape extends IBaseTest> {
         );
       }
 
-      for (const thenStep of this.thens) {
+      for (const [thenNdx, thenStep] of this.thens.entries()) {
         const t = await thenStep.test(
           this.store,
           testResourceConfiguration,
           tLog,
-          pm
+          pm,
+          `suite-${suiteNdx}/given-${key}/then-${thenNdx}`
         );
         tester(t);
       }
     } catch (e) {
+      console.error(e);
       this.error = e;
-      tLog(e);
-      tLog("\u0007"); // bell
+      tLog(e.stack);
+      // tLog("\u0007"); // bell
+
       // throw e;
     } finally {
       try {
@@ -365,16 +480,39 @@ export abstract class BaseGiven<ITestShape extends IBaseTest> {
                                   //   window["custom-screenshot"].toString()
                                   // );
 
-                                  return await pTarget[pProp]({
-                                    ...x,
-                                    path:
-                                      `${testResourceConfiguration.fs}/suite-${suiteNdx}/given-${key}/afterEach` +
-                                      "/" +
-                                      x.path,
-                                  });
+                                  return pm.customScreenShot(
+                                    {
+                                      ...x,
+                                      path:
+                                        `${testResourceConfiguration.fs}/suite-${suiteNdx}/given-${key}/afterEach` +
+                                        "/" +
+                                        x.path,
+                                    },
+                                    page
+                                  );
+
+                                  // return await pTarget[pProp]({
+                                  //   ...x,
+                                  //   path:
+                                  //     `${testResourceConfiguration.fs}/suite-${suiteNdx}/given-${key}/afterEach` +
+                                  //     "/" +
+                                  //     x.path,
+                                  // });
                                 };
+                              } else if (pProp === "mainFrame") {
+                                return () => pTarget[pProp]();
+                                // return target[pProp];
+                                // return Reflect.get(...arguments);
+                              } else if (pProp === "exposeFunction") {
+                                // return Reflect.get(target, prop, receiver);
+                                return (...a) => pTarget[pProp](...a);
+                                // return target[pProp];
+                              } else if (pProp === "removeExposedFunction") {
+                                // return Reflect.get(target, prop, receiver);
+                                return pTarget[pProp].bind(pTarget);
+                                // return target[pProp];
                               }
-                              // else if (pProp === "mainFrame") {
+                              // else if (pProp === "#frameManager") {
                               //   return () => target[pProp](...arguments);
                               // }
                               else {
@@ -397,6 +535,7 @@ export abstract class BaseGiven<ITestShape extends IBaseTest> {
           },
         });
 
+        console.log("mark5", this.store, key);
         await this.afterEach(this.store, key, givenArtifactory, afterEachProxy);
       } catch (e) {
         console.error("afterEach failed! no error will be recorded!", e);
@@ -444,14 +583,103 @@ export abstract class BaseWhen<ITestShape extends IBaseTest> {
 
     const name = this.name;
     const andWhenProxy = new Proxy(pm, {
+      // set(obj, prop, value) {
+      //   return Reflect.set(...arguments);
+      //   // if (prop === "eyeCount" && value % 2 !== 0) {
+      //   //   console.log("Monsters must have an even number of eyes");
+      //   // } else {
+      //   //   return Reflect.set(...arguments);
+      //   // }
+      // },
+
       get(target, prop, receiver) {
         if (prop === "writeFileSync") {
-          console.log("andWhenProxy", arguments, target[prop]);
           return (fp, contents) =>
             // target[prop](`${key}/andWhen/${fp}`, contents);
             target[prop](`${key}/andWhen/${fp}`, contents);
         }
 
+        /////////////////////
+
+        if (prop === "browser") {
+          return new Proxy(target[prop], {
+            get(bTarget, bProp, bReceiver) {
+              if (bProp === "pages") {
+                return async () => {
+                  return bTarget.pages().then((pages) => {
+                    return pages.map((page) => {
+                      return new Proxy(page, {
+                        get(pTarget, pProp, pReciever) {
+                          // console.log("mark get", pTarget, pProp, pReciever);
+                          if (pProp === "screenshot") {
+                            return async (x) => {
+                              return pm.customScreenShot(
+                                {
+                                  ...x,
+                                  path:
+                                    `${testResourceConfiguration.fs}/${key}/afterEach` +
+                                    "/" +
+                                    x.path,
+                                },
+                                page
+                              );
+                            };
+                          } else if (pProp === "mainFrame") {
+                            return () => pTarget[pProp]();
+                            // return target[pProp];
+                            // return Reflect.get(...arguments);
+                          } else if (pProp === "exposeFunction") {
+                            // return Reflect.get(target, prop, receiver);
+                            return pTarget[pProp].bind(pTarget);
+                            // return target[pProp];
+                          } else if (pProp === "removeExposedFunction") {
+                            // return Reflect.get(target, prop, receiver);
+                            return pTarget[pProp].bind(pTarget);
+                            // return target[pProp];
+                          } else if (pProp === "click") {
+                            // console.log("mark12", arguments);
+                            // return Reflect.get(target, prop, receiver);
+                            // return pTarget[pProp].bind(pTarget);
+                            // return target[pProp];
+                            return (selector, options) => {
+                              // console.log("mark13", selector, options);
+                              // debugger;
+                              pTarget[pProp](selector, options);
+                            };
+                          } else if (pProp === "$") {
+                            return Reflect.get(...arguments);
+                            // return Reflect.get(target, prop, receiver);
+                            // return pTarget[pProp].bind(pTarget);
+                            // return target[pProp];
+                            // return pTarget[pProp].bind(pTarget);
+
+                            // return async (s) => {
+                            //   console.log("mark17", s);
+                            //   console.log("pTarget", pTarget);
+                            //   console.log("pProp", pProp);
+                            //   console.log("pReciever", pReciever);
+                            //   // return "XXX";
+                            //   // debugger;
+                            //   return await pTarget[pProp](s);
+                            // };
+                          } else {
+                            return Reflect.get(...arguments);
+                          }
+                        },
+                      });
+                    });
+                  });
+                  // return (await target.pages()).map((page) => {
+                  //   return new Proxy(page, handler2);
+                  // });
+                };
+              }
+            },
+          });
+        }
+
+        ///////////////////////
+
         return Reflect.get(...arguments);
       },
     });
@@ -470,7 +698,22 @@ export abstract class BaseWhen<ITestShape extends IBaseTest> {
   }
 }
 
-export abstract class BaseThen<ITestShape extends IBaseTest> {
+export abstract class BaseThen<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> {
   public name: string;
   thenCB: (storeState: ITestShape["iselection"]) => ITestShape["then"];
   error: boolean;
@@ -494,21 +737,93 @@ export abstract class BaseThen<ITestShape extends IBaseTest> {
   abstract butThen(
     store: ITestShape["istore"],
     thenCB,
-    testResourceConfiguration?
+    testResourceConfiguration: ITTestResourceConfiguration,
+    pm: PM
   ): Promise<ITestShape["iselection"]>;
 
   async test(
     store: ITestShape["istore"],
     testResourceConfiguration,
     tLog: ITLog,
-    pm: PM
+    pm: PM,
+    filepath: string
   ): Promise<ITestShape["then"] | undefined> {
     tLog(" Then:", this.name);
     try {
+      const butThenProxy = new Proxy(pm, {
+        get(target, prop, receiver) {
+          if (prop === "writeFileSync") {
+            return (fp, contents) =>
+              target[prop](`${filepath}/${fp}`, contents);
+          }
+
+          if (prop === "browser") {
+            return new Proxy(target[prop], {
+              get(bTarget, bProp, bReceiver) {
+                if (bProp === "pages") {
+                  return async () => {
+                    return bTarget.pages().then((pages) => {
+                      return pages.map((page) => {
+                        return new Proxy(page, {
+                          get(pTarget, pProp, pReciever) {
+                            if (pProp === "screenshot") {
+                              return async (x) => {
+                                return pm.customScreenShot(
+                                  {
+                                    ...x,
+                                    path:
+                                      `${testResourceConfiguration.fs}/${filepath}/butThen` +
+                                      "/" +
+                                      x.path,
+                                  },
+                                  page
+                                );
+                                // return await window["custom-screenshot"]({
+                                //   ...x,
+                                //   path:
+                                //     `${testResourceConfiguration.fs}/suite-${sNdx}/afterAll` +
+                                //     "/" +
+                                //     x.path,
+                                // });
+                              };
+                            } else if (pProp === "close") {
+                              return () => pTarget[pProp]();
+                            } else if (pProp === "mainFrame") {
+                              return () => pTarget[pProp]();
+                            } else if (pProp === "exposeFunction") {
+                              // return Reflect.get(target, prop, receiver);
+                              return (...a) => pTarget[pProp](...a);
+                              // return target[pProp];
+                            } else if (pProp === "removeExposedFunction") {
+                              // return Reflect.get(target, prop, receiver);
+                              return pTarget[pProp].bind(pTarget);
+                              // return target[pProp];
+                            } else {
+                              return Reflect.get(...arguments);
+                            }
+                          },
+                        });
+                      });
+                    });
+                    // return (await target.pages()).map((page) => {
+                    //   return new Proxy(page, handler2);
+                    // });
+                  };
+                }
+              },
+            });
+          }
+
+          return Reflect.get(...arguments);
+        },
+      });
+
       const x = await this.butThen(
         store,
         this.thenCB,
-        testResourceConfiguration
+        testResourceConfiguration,
+        butThenProxy
+        // pm
       );
       return x;
     } catch (e) {
@@ -519,7 +834,22 @@ export abstract class BaseThen<ITestShape extends IBaseTest> {
   }
 }
 
-export abstract class BaseCheck<ITestShape extends IBaseTest> {
+export abstract class BaseCheck<
+  ITestShape extends IBaseTest<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+> {
   name: string;
   features: string[];
   checkCB: (whens, thens) => any;