testeranto 0.94.0 → 0.110.0

package/src/lib/abstractBase.ts

@@ -1,34 +1,33 @@
-import { IBaseTest } from "../Types";
+// import { IBaseTest } from "../Types";
 import { PM } from "../PM/index.js";
 
 import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
+import { IBaseTest } from "../../dist/types/src/Types.js";
+import { Ibdd_in, Ibdd_out } from "../Types.js";
 
 export type IGivens<
-  ITestShape extends IBaseTest<
+  I extends Ibdd_in<
     unknown,
     unknown,
     unknown,
     unknown,
     unknown,
     unknown,
-    unknown,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
+    unknown
   >
-> = Record<string, BaseGiven<ITestShape>>;
+> = Record<string, BaseGiven<I>>;
 
 export abstract class BaseSuite<
-  ITestShape extends IBaseTest<
-    unknown,
+  I extends Ibdd_in<
     unknown,
     unknown,
     unknown,
     unknown,
     unknown,
     unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
     Record<string, any>,
     Record<string, any>,
     Record<string, any>,
@@ -37,18 +36,18 @@ export abstract class BaseSuite<
   >
 > {
   name: string;
-  givens: IGivens<ITestShape>;
-  checks: BaseCheck<ITestShape>[];
-  store: ITestShape["istore"];
-  fails: BaseGiven<ITestShape>[];
+  givens: IGivens<I>;
+  checks: BaseCheck<I, O>[];
+  store: I["istore"];
+  fails: BaseGiven<I>[];
   testResourceConfiguration: ITTestResourceConfiguration;
   index: number;
 
   constructor(
     name: string,
     index: number,
-    givens: IGivens<ITestShape> = {},
-    checks: BaseCheck<ITestShape>[] = []
+    givens: IGivens<I> = {},
+    checks: BaseCheck<I, O>[] = []
   ) {
     this.name = name;
     this.index = index;
@@ -83,29 +82,29 @@ export abstract class BaseSuite<
   }
 
   setup(
-    s: ITestShape["iinput"],
+    s: I["iinput"],
     artifactory: ITestArtifactory,
     tr: ITTestResourceConfiguration,
     pm: PM
-  ): Promise<ITestShape["isubject"]> {
-    return new Promise((res) => res(s as unknown as ITestShape["isubject"]));
+  ): Promise<I["isubject"]> {
+    return new Promise((res) => res(s as unknown as I["isubject"]));
   }
 
-  assertThat(t: ITestShape["then"]): unknown {
+  assertThat(t: I["then"]): unknown {
     return t;
   }
 
-  afterAll(store: ITestShape["istore"], artifactory: ITestArtifactory, pm: PM) {
+  afterAll(store: I["istore"], artifactory: ITestArtifactory, pm: PM) {
     return store;
   }
 
   async run(
-    input: ITestShape["iinput"],
+    input: I["iinput"],
     testResourceConfiguration: ITTestResourceConfiguration,
     artifactory: (fPath: string, value: unknown) => void,
     tLog: (...string) => void,
     pm: PM
-  ): Promise<BaseSuite<ITestShape>> {
+  ): Promise<BaseSuite<I, O>> {
     this.testResourceConfiguration = testResourceConfiguration;
     tLog("test resources: ", JSON.stringify(testResourceConfiguration));
 
@@ -122,12 +121,15 @@ export abstract class BaseSuite<
       const beforeAllProxy = new Proxy(pm, {
         get(target, prop, receiver) {
           if (prop === "customScreenShot") {
-            return (opts) =>
-              target.customScreenShot({
-                ...opts,
-                // path: `${filepath}/${opts.path}`,
-                path: `suite-${sNdx}/beforeAll/${opts.path}`,
-              });
+            return (opts, p) =>
+              target.customScreenShot(
+                {
+                  ...opts,
+                  // path: `${filepath}/${opts.path}`,
+                  path: `suite-${sNdx}/beforeAll/${opts.path}`,
+                },
+                p
+              );
           }
 
           if (prop === "writeFileSync") {
@@ -135,6 +137,7 @@ export abstract class BaseSuite<
               target[prop](`suite-${sNdx}/beforeAll/${fp}`, contents);
           }
 
+          /* @ts-ignore:next-line */
           return Reflect.get(...arguments);
         },
       });
@@ -209,39 +212,34 @@ export abstract class BaseSuite<
 }
 
 export abstract class BaseGiven<
-  ITestShape extends IBaseTest<
-    unknown,
+  I extends Ibdd_in<
     unknown,
     unknown,
     unknown,
     unknown,
     unknown,
     unknown,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
+    unknown
   >
 > {
   name: string;
   features: string[];
-  whens: BaseWhen<ITestShape>[];
-  thens: BaseThen<ITestShape>[];
+  whens: BaseWhen<I>[];
+  thens: BaseThen<I>[];
   error: Error;
   fail: any;
-  store: ITestShape["istore"];
+  store: I["istore"];
   recommendedFsPath: string;
-  givenCB: ITestShape["given"];
+  givenCB: I["given"];
   initialValues: any;
   key: string;
 
   constructor(
     name: string,
     features: string[],
-    whens: BaseWhen<ITestShape>[],
-    thens: BaseThen<ITestShape>[],
-    givenCB: ITestShape["given"],
+    whens: BaseWhen<I>[],
+    thens: BaseThen<I>[],
+    givenCB: I["given"],
     initialValues: any
     // key: string
   ) {
@@ -254,7 +252,7 @@ export abstract class BaseGiven<
   }
 
   beforeAll(
-    store: ITestShape["istore"],
+    store: I["istore"],
     // artifactory: ITestArtifactory
     // subject,
     initializer,
@@ -279,16 +277,16 @@ export abstract class BaseGiven<
   }
 
   abstract givenThat(
-    subject: ITestShape["isubject"],
+    subject: I["isubject"],
     testResourceConfiguration,
     artifactory: ITestArtifactory,
-    givenCB: ITestShape["given"],
+    givenCB: I["given"],
     initialValues: any,
     pm: PM
-  ): Promise<ITestShape["istore"]>;
+  ): Promise<I["istore"]>;
 
   async afterEach(
-    store: ITestShape["istore"],
+    store: I["istore"],
     key: string,
     artifactory: ITestArtifactory,
     pm: PM
@@ -299,21 +297,22 @@ export abstract class BaseGiven<
   abstract uberCatcher(e);
 
   async give(
-    subject: ITestShape["isubject"],
+    subject: I["isubject"],
     key: string,
     testResourceConfiguration: ITTestResourceConfiguration,
-    tester: (t: Awaited<ITestShape["then"]> | undefined) => boolean,
+    tester: (t: Awaited<I["then"]> | undefined) => boolean,
     artifactory: ITestArtifactory,
     tLog: ITLog,
     pm: PM,
     suiteNdx: number
   ) {
     this.key = key;
+
     tLog(`\n ${this.key}`);
     tLog(`\n Given: ${this.name}`);
 
     const givenArtifactory = (fPath: string, value: unknown) =>
-      artifactory(`given-${this.key}/${fPath}`, value);
+      artifactory(`given-${key}/${fPath}`, value);
     try {
       // tLog(`\n Given this.store`, this.store);
 
@@ -322,19 +321,34 @@ export abstract class BaseGiven<
           if (prop === "writeFileSync") {
             return (fp, contents) =>
               target[prop](
-                `suite-${suiteNdx}/given-${this.key}/when/beforeEach/${fp}`,
+                `suite-${suiteNdx}/given-${key}/when/beforeEach/${fp}`,
                 contents
               );
           }
 
           if (prop === "customScreenShot") {
-            return (opts) =>
-              target.customScreenShot({
-                ...opts,
-                path: `suite-${suiteNdx}/given-${this.key}/when/beforeEach/${opts.path}`,
-              });
+            return (opts, p) =>
+              target.customScreenShot(
+                {
+                  ...opts,
+                  path: `suite-${suiteNdx}/given-${key}/when/beforeEach/${opts.path}`,
+                },
+                p
+              );
+          }
+
+          if (prop === "screencast") {
+            return (opts, p) =>
+              target.screencast(
+                {
+                  ...opts,
+                  path: `suite-${suiteNdx}/given-${key}/when/beforeEach/${opts.path}`,
+                },
+                p
+              );
           }
 
+          /* @ts-ignore:next-line */
           return Reflect.get(...arguments);
         },
       });
@@ -360,7 +374,7 @@ export abstract class BaseGiven<
           testResourceConfiguration,
           tLog,
           pm,
-          `suite-${suiteNdx}/given-${this.key}/when/${whenNdx}`
+          `suite-${suiteNdx}/given-${key}/when/${whenNdx}`
         );
       }
 
@@ -370,7 +384,7 @@ export abstract class BaseGiven<
           testResourceConfiguration,
           tLog,
           pm,
-          `suite-${suiteNdx}/given-${this.key}/then-${thenNdx}`
+          `suite-${suiteNdx}/given-${key}/then-${thenNdx}`
         );
         tester(t);
       }
@@ -386,21 +400,25 @@ export abstract class BaseGiven<
         const afterEachProxy = new Proxy(pm, {
           get(target, prop, receiver) {
             if (prop === "customScreenShot") {
-              return (opts) =>
-                target.customScreenShot({
-                  ...opts,
-                  path: `suite-${suiteNdx}/given-${this.key}/afterEach/${opts.path}`,
-                });
+              return (opts, p) =>
+                target.customScreenShot(
+                  {
+                    ...opts,
+                    path: `suite-${suiteNdx}/given-${key}/afterEach/${opts.path}`,
+                  },
+                  p
+                );
             }
 
             if (prop === "writeFileSync") {
               return (fp, contents) =>
                 target[prop](
-                  `suite-${suiteNdx}/given-${this.key}/afterEach/${fp}`,
+                  `suite-${suiteNdx}/given-${key}/afterEach/${fp}`,
                   contents
                 );
             }
 
+            /* @ts-ignore:next-line */
             return Reflect.get(...arguments);
           },
         });
@@ -420,22 +438,29 @@ export abstract class BaseGiven<
   }
 }
 
-export abstract class BaseWhen<ITestShape extends IBaseTest> {
+export abstract class BaseWhen<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >
+> {
   public name: string;
-  whenCB: (x: ITestShape["iselection"]) => ITestShape["then"];
+  whenCB: (x: I["iselection"]) => I["then"];
   error: boolean;
 
-  constructor(
-    name: string,
-    whenCB: (xyz: ITestShape["iselection"]) => ITestShape["then"]
-  ) {
+  constructor(name: string, whenCB: (xyz: I["iselection"]) => I["then"]) {
     this.name = name;
     this.whenCB = whenCB;
   }
 
   abstract andWhen(
-    store: ITestShape["istore"],
-    whenCB: (x: ITestShape["iselection"]) => ITestShape["then"],
+    store: I["istore"],
+    whenCB: (x: I["iselection"]) => I["then"],
     testResource,
     pm: PM
   ): Promise<any>;
@@ -448,7 +473,7 @@ export abstract class BaseWhen<ITestShape extends IBaseTest> {
   }
 
   async test(
-    store: ITestShape["istore"],
+    store: I["istore"],
     testResourceConfiguration,
     tLog: ITLog,
     pm: PM,
@@ -460,101 +485,21 @@ export abstract class BaseWhen<ITestShape extends IBaseTest> {
     const andWhenProxy = new Proxy(pm, {
       get(target, prop, receiver) {
         if (prop === "customScreenShot") {
-          return (opts) =>
-            target.customScreenShot({
-              ...opts,
-              path: `${filepath}/${opts.path}`,
-            });
+          return (opts, p) =>
+            target.customScreenShot(
+              {
+                ...opts,
+                path: `${filepath}/${opts.path}`,
+              },
+              p
+            );
         }
         if (prop === "writeFileSync") {
           return (fp, contents) =>
             target[prop](`${filepath}/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) => {
-        //                       pTarget[pProp](selector, options);
-        //                     };
-        //                   } else if (pProp === "$eval") {
-        //                     // return pTarget[pProp].bind(pTarget);
-        //                     return (selector, options) => {
-        //                       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);
-        //           // });
-        //         };
-        //       }
-        //     },
-        //   });
-        // }
-
-        ///////////////////////
-
+        /* @ts-ignore:next-line */
         return Reflect.get(...arguments);
       },
     });
@@ -583,29 +528,21 @@ export abstract class BaseWhen<ITestShape extends IBaseTest> {
 }
 
 export abstract class BaseThen<
-  ITestShape extends IBaseTest<
-    unknown,
+  I extends Ibdd_in<
     unknown,
     unknown,
     unknown,
     unknown,
     unknown,
     unknown,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
+    unknown
   >
 > {
   public name: string;
-  thenCB: (storeState: ITestShape["iselection"]) => ITestShape["then"];
+  thenCB: (storeState: I["iselection"]) => I["then"];
   error: boolean;
 
-  constructor(
-    name: string,
-    thenCB: (val: ITestShape["iselection"]) => ITestShape["then"]
-  ) {
+  constructor(name: string, thenCB: (val: I["iselection"]) => I["then"]) {
     this.name = name;
     this.thenCB = thenCB;
     this.error = false;
@@ -619,29 +556,32 @@ export abstract class BaseThen<
   }
 
   abstract butThen(
-    store: ITestShape["istore"],
+    store: I["istore"],
     thenCB,
     testResourceConfiguration: ITTestResourceConfiguration,
     pm: PM
-  ): Promise<ITestShape["iselection"]>;
+  ): Promise<I["iselection"]>;
 
   async test(
-    store: ITestShape["istore"],
+    store: I["istore"],
     testResourceConfiguration,
     tLog: ITLog,
     pm: PM,
     filepath: string
-  ): Promise<ITestShape["then"] | undefined> {
+  ): Promise<I["then"] | undefined> {
     tLog(" Then:", this.name);
     try {
       const butThenProxy = new Proxy(pm, {
         get(target, prop, receiver) {
           if (prop === "customScreenShot") {
-            return (opts) =>
-              target.customScreenShot({
-                ...opts,
-                path: `${filepath}/${opts.path}`,
-              });
+            return (opts, p) =>
+              target.customScreenShot(
+                {
+                  ...opts,
+                  path: `${filepath}/${opts.path}`,
+                },
+                p
+              );
           }
 
           if (prop === "writeFileSync") {
@@ -649,6 +589,7 @@ export abstract class BaseThen<
               target[prop](`${filepath}/${fp}`, contents);
           }
 
+          /* @ts-ignore:next-line */
           return Reflect.get(...arguments);
         },
       });
@@ -671,14 +612,16 @@ export abstract class BaseThen<
 }
 
 export abstract class BaseCheck<
-  ITestShape extends IBaseTest<
-    unknown,
+  I extends Ibdd_in<
     unknown,
     unknown,
     unknown,
     unknown,
     unknown,
     unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
     Record<string, any>,
     Record<string, any>,
     Record<string, any>,
@@ -690,10 +633,10 @@ export abstract class BaseCheck<
   features: string[];
   checkCB: (whens, thens) => any;
   whens: {
-    [K in keyof ITestShape["whens"]]: (p, tc) => BaseWhen<ITestShape>;
+    [K in keyof O["whens"]]: (p, tc) => BaseWhen<I>;
   };
   thens: {
-    [K in keyof ITestShape["thens"]]: (p, tc) => BaseThen<ITestShape>;
+    [K in keyof O["thens"]]: (p, tc) => BaseThen<I>;
   };
 
   constructor(
@@ -711,13 +654,14 @@ export abstract class BaseCheck<
   }
 
   abstract checkThat(
-    subject: ITestShape["isubject"],
+    subject: I["isubject"],
     testResourceConfiguration,
-    artifactory: ITestArtifactory
-  ): Promise<ITestShape["istore"]>;
+    artifactory: ITestArtifactory,
+    pm: PM
+  ): Promise<I["istore"]>;
 
   async afterEach(
-    store: ITestShape["istore"],
+    store: I["istore"],
     key: string,
     cb,
     pm: PM
@@ -726,7 +670,7 @@ export abstract class BaseCheck<
   }
 
   async check(
-    subject: ITestShape["isubject"],
+    subject: I["isubject"],
     key: string,
     testResourceConfiguration,
     tester,
@@ -738,7 +682,8 @@ export abstract class BaseCheck<
     const store = await this.checkThat(
       subject,
       testResourceConfiguration,
-      artifactory
+      artifactory,
+      pm
     );
     await this.checkCB(
       Object.entries(this.whens).reduce((a, [key, when]) => {