testeranto 0.70.0 → 0.74.0

package/src/lib/abstractBase.ts

@@ -1,7 +1,8 @@
 import { IBaseTest } from "../Types";
 
 import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
-import { IUtils } from "./types";
+import { PM } from "../PM/index.js";
+// import { IUtils } from "./types";
 
 export type IGivens<ITestShape extends IBaseTest> = Record<
   string,
@@ -42,78 +43,153 @@ export abstract class BaseSuite<ITestShape extends IBaseTest> {
     s: ITestShape["iinput"],
     artifactory: ITestArtifactory,
     tr: ITTestResourceConfiguration,
-    utils: IUtils
+    pm: PM
   ): Promise<ITestShape["isubject"]> {
     return new Promise((res) => res(s as unknown as ITestShape["isubject"]));
   }
 
   assertThat(t: ITestShape["then"]): unknown {
-    // console.log("base assertThat")
     return t;
   }
 
+  afterAll(store: ITestShape["istore"], artifactory: ITestArtifactory, pm: PM) {
+    return store;
+  }
+
   async run(
     input: ITestShape["iinput"],
     testResourceConfiguration: ITTestResourceConfiguration,
     artifactory: (fPath: string, value: unknown) => void,
     tLog: (...string) => void,
-    utils: IUtils
+    pm: PM
   ): Promise<BaseSuite<ITestShape>> {
     this.testResourceConfiguration = testResourceConfiguration;
-    tLog("test resources: ", testResourceConfiguration);
+    tLog("test resources: ", JSON.stringify(testResourceConfiguration));
 
     const suiteArtifactory = (fPath: string, value: unknown) =>
       artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
-    const subject = await this.setup(
-      input,
-      suiteArtifactory,
-      testResourceConfiguration,
-      utils
-    );
 
+    console.log("\nSuite:", this.index, this.name);
     tLog("\nSuite:", this.index, this.name);
-    for (const k of Object.keys(this.givens)) {
-      const giver = this.givens[k];
+    const sNdx = this.index;
+    const sName = this.name;
+
+    for (const [gNdx, g] of Object.entries(this.givens)) {
+      const subject = await this.setup(
+        input,
+        suiteArtifactory,
+        testResourceConfiguration,
+        pm
+      );
+
+      const giver = this.givens[gNdx];
       try {
         this.store = await giver.give(
           subject,
-          k,
+          gNdx,
           testResourceConfiguration,
           this.assertThat,
           suiteArtifactory,
           tLog,
-          utils
+          pm,
+          sNdx
         );
       } catch (e) {
         console.error(e);
         this.fails.push(giver);
-        return this;
+        // return this;
       }
     }
-    for (const [ndx, thater] of this.checks.entries()) {
-      await thater.check(
-        subject,
-        thater.name,
-        testResourceConfiguration,
-        this.assertThat,
-        suiteArtifactory,
-        tLog,
-        utils
-      );
+
+    const afterAllProxy = new Proxy(pm, {
+      get(target, prop, receiver) {
+        if (prop === "writeFileSync") {
+          return (fp, contents) =>
+            target[prop](`suite-${sNdx}/afterAll/${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-afterAllProxy",
+                              //   // arguments,
+                              //   // x,
+                              //   window["custom-screenshot"].toString()
+                              // );
+                              return await window["custom-screenshot"]({
+                                ...x,
+                                path:
+                                  `${testResourceConfiguration.fs}/suite-${sNdx}/afterAll` +
+                                  "/" +
+                                  x.path,
+                              });
+                            };
+                          }
+                          // 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);
+      },
+    });
+
+    // pm.browser
+    try {
+      this.afterAll(this.store, artifactory, afterAllProxy);
+    } catch (e) {
+      console.error(e);
+      // this.fails.push(this);
+      // return this;
     }
 
-    // @TODO fix me
-    for (const k of Object.keys(this.givens)) {
-      const giver = this.givens[k];
+    // for (const [ndx, thater] of this.checks.entries()) {
+    //   await thater.check(
+    //     subject,
+    //     thater.name,
+    //     testResourceConfiguration,
+    //     this.assertThat,
+    //     suiteArtifactory,
+    //     tLog,
+    //     pm
+    //   );
+    // }
 
-      try {
-        giver.afterAll(this.store, artifactory, utils);
-      } catch (e) {
-        console.error(e);
-        this.fails.push(giver);
-        return this;
-      }
-    }
+    // @TODO fix me
+    // for (const k of Object.keys(this.givens)) {
+    //   const giver = this.givens[k];
+
+    //   try {
+    //     giver.afterAll(this.store, artifactory, pm);
+    //   } catch (e) {
+    //     console.error(e);
+    //     this.fails.push(giver);
+    //     return this;
+    //   }
+    // }
     ////////////////
 
     return this;
@@ -126,6 +202,7 @@ export abstract class BaseGiven<ITestShape extends IBaseTest> {
   whens: BaseWhen<ITestShape>[];
   thens: BaseThen<ITestShape>[];
   error: Error;
+  fail: any;
   store: ITestShape["istore"];
   recommendedFsPath: string;
   givenCB: ITestShape["given"];
@@ -151,20 +228,13 @@ export abstract class BaseGiven<ITestShape extends IBaseTest> {
     return store;
   }
 
-  afterAll(
-    store: ITestShape["istore"],
-    artifactory: ITestArtifactory,
-    utils: IUtils
-  ) {
-    return store;
-  }
-
   toObj() {
     return {
       name: this.name,
       whens: this.whens.map((w) => w.toObj()),
       thens: this.thens.map((t) => t.toObj()),
       error: this.error ? [this.error, this.error.stack] : null,
+      // fail: this.fail ? [this.fail] : false,
       features: this.features,
     };
   }
@@ -173,14 +243,15 @@ export abstract class BaseGiven<ITestShape extends IBaseTest> {
     subject: ITestShape["isubject"],
     testResourceConfiguration,
     artifactory: ITestArtifactory,
-    givenCB: ITestShape["given"]
+    givenCB: ITestShape["given"],
+    pm: PM
   ): Promise<ITestShape["istore"]>;
 
   async afterEach(
     store: ITestShape["istore"],
     key: string,
     artifactory: ITestArtifactory,
-    utils: IUtils
+    pm: PM
   ): Promise<unknown> {
     return store;
   }
@@ -189,33 +260,58 @@ export abstract class BaseGiven<ITestShape extends IBaseTest> {
     subject: ITestShape["isubject"],
     key: string,
     testResourceConfiguration,
-    tester,
+    tester: (t: Awaited<ITestShape["then"]> | undefined) => boolean,
     artifactory: ITestArtifactory,
     tLog: ITLog,
-    utils: IUtils
+    pm: PM,
+    suiteNdx: number
   ) {
     tLog(`\n Given: ${this.name}`);
 
     const givenArtifactory = (fPath: string, value: unknown) =>
       artifactory(`given-${key}/${fPath}`, value);
     try {
+      // tLog(`\n Given this.store`, this.store);
+
+      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}`,
+                contents
+              );
+          }
+
+          return Reflect.get(...arguments);
+        },
+      });
+
       this.store = await this.givenThat(
         subject,
         testResourceConfiguration,
         givenArtifactory,
-        this.givenCB
+        this.givenCB,
+        beforeEachProxy
       );
 
-      // tLog(`\n Given this.store`, this.store);
-      for (const whenStep of this.whens) {
-        await whenStep.test(this.store, testResourceConfiguration, tLog, utils);
+      for (const [whenNdx, whenStep] of this.whens.entries()) {
+        await whenStep.test(
+          this.store,
+          testResourceConfiguration,
+          tLog,
+          pm,
+          `suite-${suiteNdx}/given-${key}/when/${whenNdx}`
+        );
       }
+
       for (const thenStep of this.thens) {
         const t = await thenStep.test(
           this.store,
           testResourceConfiguration,
           tLog,
-          utils
+          pm
         );
         tester(t);
       }
@@ -226,7 +322,82 @@ export abstract class BaseGiven<ITestShape extends IBaseTest> {
       // throw e;
     } finally {
       try {
-        await this.afterEach(this.store, key, givenArtifactory, utils);
+        // const afterEachProxy = new Proxy(pm, {
+        //   get(target, prop, receiver) {
+        //     if (prop === "writeFileSync") {
+        //       console.log("afterEachProxy", arguments, target[prop]);
+        //       return (fp, contents) =>
+        //         // target[prop](`${key}/andWhen/${fp}`, contents);
+        //         target[prop](`${key}/afterEach/${fp}`, contents);
+        //     }
+
+        //     return Reflect.get(...arguments);
+        //   },
+        // });
+
+        // await this.afterEach(this.store, key, givenArtifactory, afterEachProxy);
+
+        // await this.afterEach(this.store, key, givenArtifactory, pm);
+
+        const afterEachProxy = new Proxy(pm, {
+          get(target, prop, receiver) {
+            if (prop === "writeFileSync") {
+              return (fp, contents) =>
+                target[prop](
+                  `suite-${suiteNdx}/given-${key}/afterAll/${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 await pTarget[pProp]({
+                                    ...x,
+                                    path:
+                                      `${testResourceConfiguration.fs}/suite-${suiteNdx}/given-${key}/afterEach` +
+                                      "/" +
+                                      x.path,
+                                  });
+                                };
+                              }
+                              // 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);
+          },
+        });
+
+        await this.afterEach(this.store, key, givenArtifactory, afterEachProxy);
       } catch (e) {
         console.error("afterEach failed! no error will be recorded!", e);
       }
@@ -251,7 +422,8 @@ export abstract class BaseWhen<ITestShape extends IBaseTest> {
   abstract andWhen(
     store: ITestShape["istore"],
     whenCB: (x: ITestShape["iselection"]) => ITestShape["then"],
-    testResource
+    testResource,
+    pm: PM
   );
 
   toObj() {
@@ -265,11 +437,32 @@ export abstract class BaseWhen<ITestShape extends IBaseTest> {
     store: ITestShape["istore"],
     testResourceConfiguration,
     tLog: ITLog,
-    utils: IUtils
+    pm: PM,
+    key: string
   ) {
     tLog(" When:", this.name);
+
+    const name = this.name;
+    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);
+        }
+
+        return Reflect.get(...arguments);
+      },
+    });
+
     try {
-      return await this.andWhen(store, this.whenCB, testResourceConfiguration);
+      return await this.andWhen(
+        store,
+        this.whenCB,
+        testResourceConfiguration,
+        andWhenProxy
+      );
     } catch (e) {
       this.error = true;
       throw e;
@@ -288,6 +481,7 @@ export abstract class BaseThen<ITestShape extends IBaseTest> {
   ) {
     this.name = name;
     this.thenCB = thenCB;
+    this.error = false;
   }
 
   toObj() {
@@ -307,7 +501,7 @@ export abstract class BaseThen<ITestShape extends IBaseTest> {
     store: ITestShape["istore"],
     testResourceConfiguration,
     tLog: ITLog,
-    utils: IUtils
+    pm: PM
   ): Promise<ITestShape["then"] | undefined> {
     tLog(" Then:", this.name);
     try {
@@ -319,7 +513,7 @@ export abstract class BaseThen<ITestShape extends IBaseTest> {
       return x;
     } catch (e) {
       console.log("test failed", e);
-      this.error = true;
+      this.error = e.message;
       throw e;
     }
   }
@@ -360,7 +554,7 @@ export abstract class BaseCheck<ITestShape extends IBaseTest> {
     store: ITestShape["istore"],
     key: string,
     cb,
-    utils: IUtils
+    pm: PM
   ): Promise<unknown> {
     return;
   }
@@ -372,7 +566,7 @@ export abstract class BaseCheck<ITestShape extends IBaseTest> {
     tester,
     artifactory: ITestArtifactory,
     tLog: ITLog,
-    utils: IUtils
+    pm: PM
   ) {
     tLog(`\n Check: ${this.name}`);
     const store = await this.checkThat(
@@ -387,7 +581,8 @@ export abstract class BaseCheck<ITestShape extends IBaseTest> {
             store,
             testResourceConfiguration,
             tLog,
-            utils
+            pm,
+            "x"
           );
         };
         return a;
@@ -398,7 +593,7 @@ export abstract class BaseCheck<ITestShape extends IBaseTest> {
             store,
             testResourceConfiguration,
             tLog,
-            utils
+            pm
           );
           tester(t);
         };
@@ -406,7 +601,7 @@ export abstract class BaseCheck<ITestShape extends IBaseTest> {
       }, {})
     );
 
-    await this.afterEach(store, key, () => {}, utils);
+    await this.afterEach(store, key, () => {}, pm);
     return;
   }
 }