testeranto 0.125.2 → 0.128.0

package/src/lib/abstractBase.ts

@@ -2,6 +2,14 @@ import { IT, OT } from "../Types.js";
 
 import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
 import { IPM } from "./types.js";
+import {
+  afterAllProxy,
+  afterEachProxy,
+  andWhenProxy,
+  beforeAllProxy,
+  beforeEachProxy,
+  butThenProxy,
+} from "./pmProxy.js";
 
 export type IGivens<I extends IT> = Record<string, BaseGiven<I>>;
 
@@ -85,37 +93,13 @@ export abstract class BaseSuite<I extends IT = IT, O extends OT = OT> {
     // console.log("\nSuite:", this.index, this.name);
     tLog("\nSuite:", this.index, this.name);
     const sNdx = this.index;
-    const sName = this.name;
-
-    const beforeAllProxy = new Proxy(pm, {
-      get(target, prop, receiver) {
-        if (prop === "customScreenShot") {
-          return (opts, p) =>
-            target.customScreenShot(
-              {
-                ...opts,
-                // path: `${filepath}/${opts.path}`,
-                path: `suite-${sNdx}/beforeAll/${opts.path}`,
-              },
-              p
-            );
-        }
-
-        if (prop === "writeFileSync") {
-          return (fp, contents) =>
-            target[prop](`suite-${sNdx}/beforeAll/${fp}`, contents);
-        }
-
-        /* @ts-ignore:next-line */
-        return Reflect.get(...arguments);
-      },
-    });
+    // const sName = this.name;
 
     const subject = await this.setup(
       input,
       suiteArtifactory,
       testResourceConfiguration,
-      beforeAllProxy
+      beforeAllProxy(pm, sNdx.toString())
     );
 
     for (const [gKey, g] of Object.entries(this.givens)) {
@@ -156,8 +140,7 @@ export abstract class BaseSuite<I extends IT = IT, O extends OT = OT> {
       this.afterAll(
         this.store,
         artifactory,
-        // afterAllProxy
-        pm
+        afterAllProxy(pm, sNdx.toString())
       );
     } catch (e) {
       console.error(e);
@@ -267,43 +250,6 @@ export abstract class BaseGiven<I extends IT = IT> {
     const givenArtifactory = (fPath: string, value: unknown) =>
       artifactory(`given-${key}/${fPath}`, value);
 
-    const beforeEachProxy = new Proxy(pm, {
-      get(target, prop, receiver) {
-        if (prop === "writeFileSync") {
-          return (fp, contents) =>
-            target[prop](
-              `suite-${suiteNdx}/given-${key}/when/beforeEach/${fp}`,
-              contents
-            );
-        }
-
-        if (prop === "customScreenShot") {
-          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);
-      },
-    });
-
     this.uberCatcher((e) => {
       console.error(e);
       this.error = e.error;
@@ -317,9 +263,10 @@ export abstract class BaseGiven<I extends IT = IT> {
         givenArtifactory,
         this.givenCB,
         this.initialValues,
-        beforeEachProxy
+        beforeEachProxy(pm, suiteNdx.toString())
       );
     } catch (e) {
+      console.error("failure 4 ", e);
       this.error = e;
       throw e;
     }
@@ -345,52 +292,30 @@ export abstract class BaseGiven<I extends IT = IT> {
           pm,
           `suite-${suiteNdx}/given-${key}/then-${thenNdx}`
         );
-        tester(t);
+
+        return tester(t);
+        // ((t) => {
+        //   return tester(t);
+        // })();
       }
     } catch (e) {
-      // this.error = e;
       this.failed = true;
       tLog(e.stack);
       throw e;
     } finally {
       try {
-        const afterEachProxy = new Proxy(pm, {
-          get(target, prop, receiver) {
-            if (prop === "customScreenShot") {
-              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-${key}/afterEach/${fp}`,
-                  contents
-                );
-            }
-
-            /* @ts-ignore:next-line */
-            return Reflect.get(...arguments);
-          },
-        });
-
         await this.afterEach(
           this.store,
           this.key,
           givenArtifactory,
-          // pm
-          afterEachProxy
+
+          afterEachProxy(pm, suiteNdx.toString(), key)
         );
       } catch (e) {
+        console.error("afterEach failed!", e);
         this.failed = e;
         throw e;
-        // console.error("afterEach failed!", e);
+
         // this.error = e.message;
       }
     }
@@ -431,61 +356,29 @@ export abstract class BaseWhen<I extends IT> {
   ) {
     tLog(" When:", this.name);
 
-    const andWhenProxy = new Proxy(pm, {
-      get(target, prop, receiver) {
-        if (prop === "customScreenShot") {
-          return (opts, p) =>
-            target.customScreenShot(
-              {
-                ...opts,
-                path: `${filepath}/${opts.path}`,
-              },
-              p
-            );
-        }
-        if (prop === "writeFileSync") {
-          return (fp, contents) =>
-            target[prop](`${filepath}/andWhen/${fp}`, contents);
-        }
-
-        /* @ts-ignore:next-line */
-        return Reflect.get(...arguments);
-      },
-    });
-
     return await this.andWhen(
       store,
       this.whenCB,
       testResourceConfiguration,
-      andWhenProxy
+      andWhenProxy(pm, filepath)
     ).catch((e) => {
       this.error = true;
       // throw e;
     });
-    // try {
-    //   return await this.andWhen(
-    //     store,
-    //     this.whenCB,
-    //     testResourceConfiguration,
-    //     andWhenProxy
-    //   );
-    // } catch (e) {
-    //   this.error = true;
-    //   throw e;
-    // }
   }
 }
 
 export abstract class BaseThen<I extends IT> {
   public name: string;
-  thenCB: (storeState: I["iselection"]) => I["then"];
-  go: (storeState: I["iselection"]) => I["then"];
+  thenCB: (storeState: I["iselection"]) => Promise<I["then"]>;
   error: boolean;
 
-  constructor(name: string, thenCB: (val: I["iselection"]) => I["then"]) {
+  constructor(
+    name: string,
+    thenCB: (val: I["iselection"]) => Promise<I["then"]>
+  ) {
     this.name = name;
     this.thenCB = thenCB;
-
     this.error = false;
   }
 
@@ -498,7 +391,7 @@ export abstract class BaseThen<I extends IT> {
 
   abstract butThen(
     store: I["istore"],
-    thenCB: (s: I["iselection"]) => I["isubject"],
+    thenCB: (s: I["iselection"]) => Promise<I["isubject"]>,
     testResourceConfiguration: ITTestResourceConfiguration,
     pm: IPM,
     ...args: any[]
@@ -511,56 +404,24 @@ export abstract class BaseThen<I extends IT> {
     pm: IPM,
     filepath: string
   ): Promise<I["then"] | undefined> {
-    this.go = async (s: I["iselection"]) => {
-      tLog(" Then!!!:", this.name);
-
-      try {
-        await this.thenCB(s);
-      } catch (e) {
-        console.log("test failed 1", e);
-        this.error = e;
-        throw e;
-      }
-    };
-
-    try {
-      const butThenProxy = new Proxy(pm, {
-        get(target, prop, receiver) {
-          if (prop === "customScreenShot") {
-            return (opts, p) =>
-              target.customScreenShot(
-                {
-                  ...opts,
-                  path: `${filepath}/${opts.path}`,
-                },
-                p
-              );
-          }
-
-          if (prop === "writeFileSync") {
-            return (fp, contents) =>
-              target[prop](`${filepath}/${fp}`, contents);
-          }
-
-          /* @ts-ignore:next-line */
-          return Reflect.get(...arguments);
-        },
-      });
+    return this.butThen(
+      store,
+      async (s: I["iselection"]) => {
+        tLog(" Then!!!:", this.name);
 
-      return this.butThen(
-        store,
-        this.go,
-        testResourceConfiguration,
-        butThenProxy
-      ).catch((e) => {
-        this.error = e;
-        throw e;
-      });
-    } catch (e) {
-      console.log("test failed 2", e);
+        if (typeof this.thenCB === "function") {
+          return await this.thenCB(s);
+        } else {
+          return this.thenCB;
+        }
+      },
+      testResourceConfiguration,
+      butThenProxy(pm, filepath)
+    ).catch((e) => {
+      console.log("test failed 3", e);
       this.error = e;
       throw e;
-    }
+    });
   }
 
   check() {}
@@ -601,7 +462,7 @@ export abstract class BaseCheck<I extends IT = IT> {
     return {
       key: this.key,
       name: this.name,
-      functionAsString: this.checkCB.toString(),
+      // functionAsString: this.checkCB.toString(),
       features: this.features,
     };
   }

package/src/lib/basebuilder.ts

@@ -126,34 +126,31 @@ export abstract class BaseBuilder<
 
           const fails = suiteDone.fails;
 
-          const b = await puppetMaster.writeFileSync(
-            `bdd_errors.txt`,
-            fails.toString()
-          );
-
-          await puppetMaster.writeFileSync(
-            `littleBoard.html`,
-            `
-<!DOCTYPE html>
-<html lang="en">
-
-<head>
-  <meta name="description" content="Webpage description goes here" />
-  <meta charset="utf-8" />
-  <title>kokomoBay - testeranto</title>
-  <meta name="viewport" content="width=device-width, initial-scale=1" />
-  <meta name="author" content="" />
-
-  <link rel="stylesheet" href="/kokomoBay/testeranto/TestReport.css" />
-  <script src="/kokomoBay/testeranto/TestReport.js"></script>
-
-</head>
-
-<body>
-  <div id="root"/>
-</body>
-            `
-          );
+          await puppetMaster.writeFileSync(`bdd_errors.txt`, fails.toString());
+
+          //           await puppetMaster.writeFileSync(
+          //             `index.html`,
+          //             `
+          // <!DOCTYPE html>
+          // <html lang="en">
+
+          // <head>
+          //   <meta name="description" content="Webpage description goes here" />
+          //   <meta charset="utf-8" />
+          //   <title>kokomoBay - testeranto</title>
+          //   <meta name="viewport" content="width=device-width, initial-scale=1" />
+          //   <meta name="author" content="" />
+
+          //   <link rel="stylesheet" href="/kokomoBay/testeranto/TestReport.css" />
+          //   <script src="/kokomoBay/testeranto/TestReport.js"></script>
+
+          // </head>
+
+          // <body>
+          //   <div id="root"/>
+          // </body>
+          //             `
+          //           );
 
           await puppetMaster.writeFileSync(
             `tests.json`,

package/src/lib/classBuilder.ts

@@ -84,10 +84,21 @@ export abstract class ClassBuilder<
     );
 
     const classyThens = Object.entries(testImplementation.thens).reduce(
-      (a, [key, thEn]: [string, (x) => any]) => {
-        a[key] = (expected: any, x) => {
+      (a, [key, thEn]: [string, (s: I["iselection"]) => I["isubject"]]) => {
+        a[key] = (expected, x) => {
           return new thenKlasser.prototype.constructor(
             `${thEn.name}: ${expected && expected.toString()}`,
+            // () => {
+            //   thEn(expected);
+            //   // return new Promise((res), rej) => {
+
+            //   // }
+            //   // try {
+            //   //   thEn(expected);
+            //   // } catch (c) {
+            //   //   console.log("mark99");
+            //   // }
+            // },
             thEn(expected)
           );
         };

package/src/lib/core.ts

@@ -9,6 +9,7 @@ import {
 import {
   DefaultTestInterface,
   IFinalResults,
+  ITTestResourceConfiguration,
   ITTestResourceRequest,
   ITestArtifactory,
   defaultTestResourceRequirement,
@@ -48,15 +49,15 @@ export default abstract class Testeranto<
           return fullTestInterface.afterAll(store, pm);
         }
 
-        assertThat(t): boolean {
+        assertThat(t: Awaited<I["then"]>): boolean {
           return fullTestInterface.assertThis(t);
         }
 
         async setup(
           s: I["iinput"],
           artifactory: ITestArtifactory,
-          tr,
-          pm
+          tr: ITTestResourceConfiguration,
+          pm: IPM
         ): Promise<I["isubject"]> {
           return (
             fullTestInterface.beforeAll ||
@@ -130,17 +131,12 @@ export default abstract class Testeranto<
           testResource: any,
           pm: IPM
         ): Promise<I["iselection"]> {
-          return await fullTestInterface
-            .butThen(store, thenCB, testResource, pm)
-            .then(
-              (v) => {
-                return v;
-              },
-              (e) => {
-                console.log(" ERROR ", e);
-                throw e;
-              }
-            );
+          return await fullTestInterface.butThen(
+            store,
+            thenCB,
+            testResource,
+            pm
+          );
         }
       } as any,
 

package/src/lib/index.ts

@@ -4,7 +4,6 @@ import { PM_Node } from "../PM/node.js";
 import { PM_Web } from "../PM/web.js";
 import {
   Ibdd_in,
-  Ibdd_out,
   ITestInterface,
   ITestconfig,
   IBuiltConfig,
@@ -17,9 +16,7 @@ import {
 import { IGivens, BaseCheck, BaseSuite } from "./abstractBase.js";
 import { IPM } from "./types.js";
 
-export const BaseTestInterface: ITestInterface<
-  Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>
-> = {
+export const BaseTestInterface: ITestInterface<IT> = {
   beforeAll: async (s) => s,
   beforeEach: async function (
     subject: any,
@@ -31,35 +28,15 @@ export const BaseTestInterface: ITestInterface<
     return subject as any;
   },
   afterEach: async (s) => s,
-  afterAll: (
-    store: Ibdd_in<
-      unknown,
-      unknown,
-      unknown,
-      unknown,
-      unknown,
-      unknown,
-      unknown
-    >["istore"]
-  ) => undefined,
+  afterAll: (store: IT["istore"]) => undefined,
   butThen: async (
-    store: Ibdd_in<
-      unknown,
-      unknown,
-      unknown,
-      unknown,
-      unknown,
-      unknown,
-      unknown
-    >["istore"],
-    thenCb: any
+    store: IT["istore"],
+    thenCb: (s: IT["iselection"]) => Promise<IT["isubject"]>
   ) => {
-    try {
-      thenCb(store);
-    } catch (e) {}
+    return thenCb(store);
   },
   andWhen: async (a) => a,
-  assertThis: () => null,
+  assertThis: (x: any) => null,
 };
 
 export const DefaultTestInterface = (