testeranto 0.62.0 → 0.73.0

package/src/lib/abstractBase.ts

@@ -1,41 +1,28 @@
+import { IBaseTest } from "../Types";
+
 import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
-import { IBaseTest, IUtils } from "../Types";
+import { PM } from "../PM/index.js";
+// import { IUtils } from "./types";
 
-export type IGivens<
-  ITestShape extends IBaseTest
-> = Record<
+export type IGivens<ITestShape extends IBaseTest> = Record<
   string,
-  BaseGiven<
-    ITestShape
-  >
+  BaseGiven<ITestShape>
 >;
 
-export abstract class BaseSuite<
-  ITestShape extends IBaseTest
-> {
+export abstract class BaseSuite<ITestShape extends IBaseTest> {
   name: string;
-  givens: IGivens<
-    ITestShape
-  >;
-  checks: BaseCheck<
-    ITestShape
-  >[];
-  store: ITestShape['istore'];
-  fails: BaseGiven<
-    ITestShape
-  >[];
+  givens: IGivens<ITestShape>;
+  checks: BaseCheck<ITestShape>[];
+  store: ITestShape["istore"];
+  fails: BaseGiven<ITestShape>[];
   testResourceConfiguration: ITTestResourceConfiguration;
   index: number;
 
   constructor(
     name: string,
     index: number,
-    givens: IGivens<
-      ITestShape
-    > = {},
-    checks: BaseCheck<
-      ITestShape
-    >[] = []
+    givens: IGivens<ITestShape> = {},
+    checks: BaseCheck<ITestShape>[] = []
   ) {
     this.name = name;
     this.index = index;
@@ -53,114 +40,180 @@ export abstract class BaseSuite<
   }
 
   setup(
-    s: ITestShape['iinput'],
+    s: ITestShape["iinput"],
     artifactory: ITestArtifactory,
     tr: ITTestResourceConfiguration,
-    utils: IUtils
-  ): Promise<ITestShape['isubject']> {
-    return new Promise((res) => res(s as unknown as ITestShape['isubject']));
+    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")
+  assertThat(t: ITestShape["then"]): unknown {
     return t;
   }
 
+  afterAll(store: ITestShape["istore"], artifactory: ITestArtifactory, pm: PM) {
+    return store;
+  }
+
   async run(
-    input: ITestShape['iinput'],
+    input: ITestShape["iinput"],
     testResourceConfiguration: ITTestResourceConfiguration,
-    artifactory: (
-      fPath: string,
-      value: unknown
-    ) => void,
+    artifactory: (fPath: string, value: unknown) => void,
     tLog: (...string) => void,
-    utils: IUtils
-  ): Promise<
-    BaseSuite<
-      ITestShape
-    >
-  > {
+    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
-    );
+      artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
 
+    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;
     }
 
+    // for (const [ndx, thater] of this.checks.entries()) {
+    //   await thater.check(
+    //     subject,
+    //     thater.name,
+    //     testResourceConfiguration,
+    //     this.assertThat,
+    //     suiteArtifactory,
+    //     tLog,
+    //     pm
+    //   );
+    // }
+
     // @TODO fix me
-    for (const k of Object.keys(this.givens)) {
-      const giver = this.givens[k];
-      giver.afterAll(this.store, artifactory, utils);
-    }
+    // 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;
   }
 }
 
-export abstract class BaseGiven<
-  ITestShape extends IBaseTest
-> {
+export abstract class BaseGiven<ITestShape extends IBaseTest> {
   name: string;
   features: string[];
-  whens: BaseWhen<
-    ITestShape
-  >[];
-  thens: BaseThen<
-    ITestShape
-  >[];
+  whens: BaseWhen<ITestShape>[];
+  thens: BaseThen<ITestShape>[];
   error: Error;
-  store: ITestShape['istore'];
+  fail: any;
+  store: ITestShape["istore"];
   recommendedFsPath: string;
-  givenCB: ITestShape['given'];
+  givenCB: ITestShape["given"];
   initialValues: any;
 
   constructor(
     name: string,
     features: string[],
-    whens: BaseWhen<
-      ITestShape
-    >[],
-    thens: BaseThen<
-      ITestShape
-    >[],
-    givenCB: ITestShape['given'],
+    whens: BaseWhen<ITestShape>[],
+    thens: BaseThen<ITestShape>[],
+    givenCB: ITestShape["given"],
     initialValues: any
   ) {
     this.name = name;
@@ -171,19 +224,7 @@ export abstract class BaseGiven<
     this.initialValues = initialValues;
   }
 
-  beforeAll(
-    store: ITestShape['istore'],
-    artifactory: ITestArtifactory,
-
-  ) {
-    return store;
-  }
-
-  afterAll(
-    store: ITestShape['istore'],
-    artifactory: ITestArtifactory,
-    utils: IUtils
-  ) {
+  beforeAll(store: ITestShape["istore"], artifactory: ITestArtifactory) {
     return store;
   }
 
@@ -193,61 +234,84 @@ export abstract class BaseGiven<
       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,
     };
   }
 
   abstract givenThat(
-    subject: ITestShape['isubject'],
+    subject: ITestShape["isubject"],
     testResourceConfiguration,
     artifactory: ITestArtifactory,
-    givenCB: ITestShape['given']
-  ): Promise<ITestShape['istore']>;
+    givenCB: ITestShape["given"],
+    pm: PM
+  ): Promise<ITestShape["istore"]>;
 
   async afterEach(
-    store: ITestShape['istore'],
+    store: ITestShape["istore"],
     key: string,
-    artifactory: ITestArtifactory
+    artifactory: ITestArtifactory,
+    pm: PM
   ): Promise<unknown> {
     return store;
   }
 
   async give(
-    subject: ITestShape['isubject'],
+    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)
+      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) {
+      for (const [whenNdx, whenStep] of this.whens.entries()) {
         await whenStep.test(
           this.store,
           testResourceConfiguration,
           tLog,
-          utils
+          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);
       }
@@ -258,7 +322,82 @@ export abstract class BaseGiven<
       // throw e;
     } finally {
       try {
-        await this.afterEach(this.store, key, givenArtifactory);
+        // 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 window["custom-screenshot"]({
+                                    ...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);
       }
@@ -267,24 +406,24 @@ export abstract class BaseGiven<
   }
 }
 
-export abstract class BaseWhen<
-  ITestShape extends IBaseTest
-> {
+export abstract class BaseWhen<ITestShape extends IBaseTest> {
   public name: string;
-  whenCB: (x: ITestShape['iselection']) => ITestShape['then'];
+  whenCB: (x: ITestShape["iselection"]) => ITestShape["then"];
   error: boolean;
 
   constructor(
     name: string,
-    whenCB: (xyz: ITestShape['iselection']) => ITestShape['then']) {
+    whenCB: (xyz: ITestShape["iselection"]) => ITestShape["then"]
+  ) {
     this.name = name;
     this.whenCB = whenCB;
   }
 
   abstract andWhen(
-    store: ITestShape['istore'],
-    whenCB: (x: ITestShape['iselection']) => ITestShape['then'],
-    testResource
+    store: ITestShape["istore"],
+    whenCB: (x: ITestShape["iselection"]) => ITestShape["then"],
+    testResource,
+    pm: PM
   );
 
   toObj() {
@@ -295,17 +434,34 @@ export abstract class BaseWhen<
   }
 
   async test(
-    store: ITestShape['istore'],
+    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
+        testResourceConfiguration,
+        andWhenProxy
       );
     } catch (e) {
       this.error = true;
@@ -314,16 +470,18 @@ export abstract class BaseWhen<
   }
 }
 
-export abstract class BaseThen<
-  ITestShape extends IBaseTest
-> {
+export abstract class BaseThen<ITestShape extends IBaseTest> {
   public name: string;
-  thenCB: (storeState: ITestShape['iselection']) => ITestShape['then'];
+  thenCB: (storeState: ITestShape["iselection"]) => ITestShape["then"];
   error: boolean;
 
-  constructor(name: string, thenCB: (val: ITestShape['iselection']) => ITestShape['then']) {
+  constructor(
+    name: string,
+    thenCB: (val: ITestShape["iselection"]) => ITestShape["then"]
+  ) {
     this.name = name;
     this.thenCB = thenCB;
+    this.error = false;
   }
 
   toObj() {
@@ -334,54 +492,42 @@ export abstract class BaseThen<
   }
 
   abstract butThen(
-    store: ITestShape['istore'],
+    store: ITestShape["istore"],
     thenCB,
     testResourceConfiguration?
-  ): Promise<ITestShape['iselection']>;
+  ): Promise<ITestShape["iselection"]>;
 
   async test(
-    store: ITestShape['istore'],
+    store: ITestShape["istore"],
     testResourceConfiguration,
     tLog: ITLog,
-    utils: IUtils
-  ): Promise<ITestShape['then'] | undefined> {
+    pm: PM
+  ): Promise<ITestShape["then"] | undefined> {
     tLog(" Then:", this.name);
     try {
-      const x = (await this.butThen(
+      const x = await this.butThen(
         store,
         this.thenCB,
         testResourceConfiguration
-      ));
+      );
       return x;
     } catch (e) {
       console.log("test failed", e);
-      this.error = true;
+      this.error = e.message;
       throw e;
     }
   }
 }
 
-export abstract class BaseCheck<
-  ITestShape extends IBaseTest
-> {
+export abstract class BaseCheck<ITestShape extends IBaseTest> {
   name: string;
   features: string[];
   checkCB: (whens, thens) => any;
   whens: {
-    [K in keyof ITestShape["whens"]]: (
-      p,
-      tc
-    ) => BaseWhen<
-      ITestShape
-    >;
+    [K in keyof ITestShape["whens"]]: (p, tc) => BaseWhen<ITestShape>;
   };
   thens: {
-    [K in keyof ITestShape["thens"]]: (
-      p,
-      tc
-    ) => BaseThen<
-      ITestShape
-    >;
+    [K in keyof ITestShape["thens"]]: (p, tc) => BaseThen<ITestShape>;
   };
 
   constructor(
@@ -399,27 +545,28 @@ export abstract class BaseCheck<
   }
 
   abstract checkThat(
-    subject: ITestShape['isubject'],
+    subject: ITestShape["isubject"],
     testResourceConfiguration,
     artifactory: ITestArtifactory
-  ): Promise<ITestShape['istore']>;
+  ): Promise<ITestShape["istore"]>;
 
   async afterEach(
-    store: ITestShape['istore'],
+    store: ITestShape["istore"],
     key: string,
-    cb?
+    cb,
+    pm: PM
   ): Promise<unknown> {
     return;
   }
 
   async check(
-    subject: ITestShape['isubject'],
+    subject: ITestShape["isubject"],
     key: string,
     testResourceConfiguration,
     tester,
     artifactory: ITestArtifactory,
     tLog: ITLog,
-    utils: IUtils
+    pm: PM
   ) {
     tLog(`\n Check: ${this.name}`);
     const store = await this.checkThat(
@@ -434,7 +581,8 @@ export abstract class BaseCheck<
             store,
             testResourceConfiguration,
             tLog,
-            utils
+            pm,
+            "x"
           );
         };
         return a;
@@ -445,7 +593,7 @@ export abstract class BaseCheck<
             store,
             testResourceConfiguration,
             tLog,
-            utils
+            pm
           );
           tester(t);
         };
@@ -453,7 +601,7 @@ export abstract class BaseCheck<
       }, {})
     );
 
-    await this.afterEach(store, key);
+    await this.afterEach(store, key, () => {}, pm);
     return;
   }
 }