testeranto 0.74.0 → 0.79.3

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}`,
@@ -306,12 +417,13 @@ 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);
       }
@@ -365,16 +477,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 {
@@ -446,12 +581,78 @@ export abstract class BaseWhen<ITestShape extends IBaseTest> {
     const andWhenProxy = new Proxy(pm, {
       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) {
+                          if (pProp === "screenshot") {
+                            return async (x) => {
+                              // console.log(
+                              //   "custom-screenshot-MARK-afterEachProxy",
+                              //   window["custom-screenshot"].toString()
+                              // );
+
+                              return pm.customScreenShot(
+                                {
+                                  ...x,
+                                  path:
+                                    `${testResourceConfiguration.fs}/${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 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 {
+                            return Reflect.get(...arguments);
+                          }
+                        },
+                      });
+                    });
+                  });
+                  // return (await target.pages()).map((page) => {
+                  //   return new Proxy(page, handler2);
+                  // });
+                };
+              }
+            },
+          });
+        }
+
+        ///////////////////////
+
         return Reflect.get(...arguments);
       },
     });
@@ -470,7 +671,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 +710,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 +807,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;

package/src/lib/basebuilder.ts

@@ -1,12 +1,6 @@
 import { PassThrough } from "stream";
 
-import {
-  ITTestResourceRequest,
-  ITestJob,
-  ITLog,
-  ILogWriter,
-  ITTestResourceConfiguration,
-} from ".";
+import { ITTestResourceRequest, ITestJob, ITLog } from ".";
 import { IBaseTest, ITestSpecification } from "../Types.js";
 
 import {
@@ -15,9 +9,7 @@ import {
   IWhenKlasser,
   IThenKlasser,
   ICheckKlasser,
-  // IUtils,
 } from "./types.js";
-
 import {
   BaseCheck,
   BaseSuite,
@@ -28,7 +20,20 @@ import {
 import { PM } from "../PM/index.js";
 
 export abstract class BaseBuilder<
-  ITestShape extends IBaseTest,
+  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>
+  >,
   SuiteExtensions,
   GivenExtensions,
   WhenExtensions,
@@ -59,7 +64,6 @@ export abstract class BaseBuilder<
     checkOverides: Record<keyof CheckExtensions, ICheckKlasser<ITestShape>>,
     testResourceRequirement: ITTestResourceRequest,
     testSpecification: any
-    // puppetMaster: PM
   ) {
     this.artifacts = [];
     this.testResourceRequirement = testResourceRequirement;
@@ -69,7 +73,6 @@ export abstract class BaseBuilder<
     this.thenOverides = thenOverides;
     this.checkOverides = checkOverides;
     this.testSpecification = testSpecification;
-    // this.puppetMaster = puppetMaster;
 
     this.specs = testSpecification(
       this.Suites(),
@@ -83,7 +86,6 @@ export abstract class BaseBuilder<
       const suiteRunner =
         (suite: BaseSuite<ITestShape>) =>
         async (
-          // testResourceConfiguration: ITTestResourceConfiguration,
           puppetMaster: PM,
           tLog: ITLog
         ): Promise<BaseSuite<ITestShape>> => {
@@ -114,7 +116,6 @@ export abstract class BaseBuilder<
 
       return {
         test: suite,
-        // testResourceRequirement,
 
         toObj: () => {
           return suite.toObj();
@@ -122,48 +123,12 @@ export abstract class BaseBuilder<
 
         runner,
 
-        receiveTestResourceConfig: async function (
-          // testResourceConfiguration = {
-          //   name: "",
-          //   fs: ".",
-          //   ports: [],
-          //   browserWSEndpoint: "",
-          // },
-          puppetMaster: PM
-        ) {
-          // console.log(
-          //   `testResourceConfiguration! ${JSON.stringify(
-          //     testResourceConfiguration,
-          //     null,
-          //     2
-          //   )}`
-          // );
-          // console.log("puppetMaster", puppetMaster);
-
-          await puppetMaster
-            .mkdirSync
-            // ""
-            // puppetMaster.testResourceConfiguration.fs + "/"
-            ();
-          //  if (!puppetMaster.existsSync(destFolder)) {
-          //    puppetMaster.mkdirSync(destFolder, { recursive: true });
-          //  }
-
-          // puppetMaster.writeFileSync(
-          //   // puppetMaster.testResourceConfiguration.fs + `/tests.json`,
-          //   `tests.json`,
-          //   JSON.stringify(this.toObj(), null, 2)
-          // );
+        receiveTestResourceConfig: async function (puppetMaster: PM) {
+          await puppetMaster.mkdirSync();
 
           const logFilePath = "log.txt";
-          // puppetMaster.testResourceConfiguration.fs + `/log.txt`;
-
           const access = await puppetMaster.createWriteStream(logFilePath);
-
-          // console.log("access", access);
           const tLog = (...l: string[]) => {
-            // access.write(`${l.toString()}\n`);
-            // console.log("tLog", l);
             puppetMaster.write(access, `${l.toString()}\n`);
           };
 

package/src/lib/classBuilder.ts

@@ -17,7 +17,20 @@ import { PM } from "../PM/index.js";
 import { ITTestResourceRequest } from "./index.js";
 
 export abstract class ClassBuilder<
-  ITestShape extends IBaseTest
+  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>
+  >
 > extends BaseBuilder<ITestShape, any, any, any, any, any> {
   constructor(
     testImplementation: ITestImplementation<ITestShape, any>,
@@ -29,7 +42,6 @@ export abstract class ClassBuilder<
     thenKlasser: IThenKlasser<ITestShape>,
     checkKlasser: ICheckKlasser<ITestShape>,
     testResourceRequirement: ITTestResourceRequest
-    // puppetMaster: PM
   ) {
     const classySuites = Object.entries(testImplementation.suites).reduce(
       (a, [key], index) => {

package/src/lib/core.ts

@@ -8,11 +8,8 @@ import {
 import { ITestInterface } from "./types.js";
 import {
   DefaultTestInterface,
-  ILogWriter,
-  ITTestResourceConfiguration,
   ITTestResourceRequest,
   ITestArtifactory,
-  ITestJob,
   defaultTestResourceRequirement,
 } from "./index.js";
 import {
@@ -26,7 +23,20 @@ import { ClassBuilder } from "./classBuilder.js";
 import { PM } from "../PM/index";
 
 export default abstract class Testeranto<
-  ITestShape extends IBaseTest
+  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>
+  >
 > extends ClassBuilder<ITestShape> {
   constructor(
     input: ITestShape["iinput"],
@@ -34,7 +44,6 @@ export default abstract class Testeranto<
     testImplementation: ITestImplementation<ITestShape>,
     testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement,
     testInterface: Partial<ITestInterface<ITestShape>>
-    // puppetMaster: PM
   ) {
     const fullTestInterface = DefaultTestInterface(testInterface);
     super(
@@ -146,12 +155,14 @@ export default abstract class Testeranto<
         async butThen(
           store: any,
           thenCB,
-          testResourceConfiguration?: any
+          testResourceConfiguration: any,
+          pm: PM
         ): Promise<ITestShape["iselection"]> {
           return await fullTestInterface.butThen(
             store,
             thenCB,
-            testResourceConfiguration
+            testResourceConfiguration,
+            pm
           );
         }
       } as any,