testeranto 0.114.1 → 0.125.0

package/src/lib/abstractBase.ts

@@ -1,59 +1,31 @@
-// import { IBaseTest } from "../Types";
-import { PM } from "../PM/index.js";
+import { IT, OT } from "../Types.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<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> = Record<string, BaseGiven<I>>;
-
-export abstract class BaseSuite<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >,
-  O extends Ibdd_out<
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
-  >
-> {
+import { IPM } from "./types.js";
+
+export type IGivens<I extends IT> = Record<string, BaseGiven<I>>;
+
+export abstract class BaseSuite<I extends IT = IT, O extends OT = OT> {
   name: string;
   givens: IGivens<I>;
-  checks: BaseCheck<I, O>[];
+  checks: BaseCheck<I>[];
   store: I["istore"];
-  fails: BaseGiven<I>[];
   testResourceConfiguration: ITTestResourceConfiguration;
   index: number;
+  failed: boolean;
+  fails: number;
 
   constructor(
     name: string,
     index: number,
     givens: IGivens<I> = {},
-    checks: BaseCheck<I, O>[] = []
+    checks: BaseCheck<I>[] = []
   ) {
     this.name = name;
     this.index = index;
     this.givens = givens;
     this.checks = checks;
-    this.fails = [];
+    this.fails = 0;
   }
 
   public features() {
@@ -63,20 +35,19 @@ export abstract class BaseSuite<
       .filter((value, index, array) => {
         return array.indexOf(value) === index;
       });
-    // .reduce((mm, lm) => {
-    //   mm[lm] = lm;
-    //   return mm;
-    // }, {});
     return features || [];
   }
 
   public toObj() {
     const givens = Object.keys(this.givens).map((k) => this.givens[k].toObj());
+    const checks = Object.keys(this.checks).map((k) => this.checks[k].toObj());
 
     return {
       name: this.name,
       givens,
+      checks,
       fails: this.fails,
+      failed: this.failed,
       features: this.features(),
     };
   }
@@ -85,16 +56,16 @@ export abstract class BaseSuite<
     s: I["iinput"],
     artifactory: ITestArtifactory,
     tr: ITTestResourceConfiguration,
-    pm: PM
+    pm: IPM
   ): Promise<I["isubject"]> {
     return new Promise((res) => res(s as unknown as I["isubject"]));
   }
 
-  assertThat(t: I["then"]): unknown {
-    return t;
+  assertThat(t: Awaited<I["then"]> | undefined): boolean {
+    return !!t;
   }
 
-  afterAll(store: I["istore"], artifactory: ITestArtifactory, pm: PM) {
+  afterAll(store: I["istore"], artifactory: ITestArtifactory, pm: IPM) {
     return store;
   }
 
@@ -103,10 +74,10 @@ export abstract class BaseSuite<
     testResourceConfiguration: ITTestResourceConfiguration,
     artifactory: (fPath: string, value: unknown) => void,
     tLog: (...string) => void,
-    pm: PM
+    pm: IPM
   ): Promise<BaseSuite<I, O>> {
     this.testResourceConfiguration = testResourceConfiguration;
-    tLog("test resources: ", JSON.stringify(testResourceConfiguration));
+    // tLog("test resources: ", JSON.stringify(testResourceConfiguration));
 
     const suiteArtifactory = (fPath: string, value: unknown) =>
       artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
@@ -116,39 +87,38 @@ export abstract class BaseSuite<
     const sNdx = this.index;
     const sName = this.name;
 
-    for (const [gKey, g] of Object.entries(this.givens)) {
-      // console.log("gKey", gKey);
-      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
-              );
-          }
+    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);
-          }
+        if (prop === "writeFileSync") {
+          return (fp, contents) =>
+            target[prop](`suite-${sNdx}/beforeAll/${fp}`, contents);
+        }
 
-          /* @ts-ignore:next-line */
-          return Reflect.get(...arguments);
-        },
-      });
+        /* @ts-ignore:next-line */
+        return Reflect.get(...arguments);
+      },
+    });
 
-      const subject = await this.setup(
-        input,
-        suiteArtifactory,
-        testResourceConfiguration,
-        beforeAllProxy
-      );
+    const subject = await this.setup(
+      input,
+      suiteArtifactory,
+      testResourceConfiguration,
+      beforeAllProxy
+    );
 
+    for (const [gKey, g] of Object.entries(this.givens)) {
       const giver = this.givens[gKey];
       try {
         this.store = await giver.give(
@@ -162,12 +132,26 @@ export abstract class BaseSuite<
           sNdx
         );
       } catch (e) {
-        console.error(e);
-        this.fails.push(giver);
+        this.failed = true;
+        this.fails = this.fails + 1;
+        // console.error(e);
+        // this.fails.push(giver);
         // return this;
       }
     }
 
+    for (const [ndx, thater] of this.checks.entries()) {
+      await thater.check(
+        subject,
+        thater.name,
+        testResourceConfiguration,
+        this.assertThat,
+        suiteArtifactory,
+        tLog,
+        pm
+      );
+    }
+
     try {
       this.afterAll(
         this.store,
@@ -181,18 +165,6 @@ export abstract class BaseSuite<
       // 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];
@@ -211,17 +183,7 @@ export abstract class BaseSuite<
   }
 }
 
-export abstract class BaseGiven<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> {
+export abstract class BaseGiven<I extends IT = IT> {
   name: string;
   features: string[];
   whens: BaseWhen<I>[];
@@ -233,6 +195,7 @@ export abstract class BaseGiven<
   givenCB: I["given"];
   initialValues: any;
   key: string;
+  failed: boolean;
 
   constructor(
     name: string,
@@ -241,7 +204,6 @@ export abstract class BaseGiven<
     thens: BaseThen<I>[],
     givenCB: I["given"],
     initialValues: any
-    // key: string
   ) {
     this.name = name;
     this.features = features;
@@ -251,16 +213,7 @@ export abstract class BaseGiven<
     this.initialValues = initialValues;
   }
 
-  beforeAll(
-    store: I["istore"],
-    // artifactory: ITestArtifactory
-    // subject,
-    initializer,
-    artifactory,
-    testResource,
-    initialValues,
-    pm
-  ) {
+  beforeAll(store: I["istore"]) {
     return store;
   }
 
@@ -271,7 +224,7 @@ 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,
+      failed: this.failed,
       features: this.features,
     };
   }
@@ -282,14 +235,14 @@ export abstract class BaseGiven<
     artifactory: ITestArtifactory,
     givenCB: I["given"],
     initialValues: any,
-    pm: PM
+    pm: IPM
   ): Promise<I["istore"]>;
 
   async afterEach(
     store: I["istore"],
     key: string,
     artifactory: ITestArtifactory,
-    pm: PM
+    pm: IPM
   ): Promise<unknown> {
     return store;
   }
@@ -303,7 +256,7 @@ export abstract class BaseGiven<
     tester: (t: Awaited<I["then"]> | undefined) => boolean,
     artifactory: ITestArtifactory,
     tLog: ITLog,
-    pm: PM,
+    pm: IPM,
     suiteNdx: number
   ) {
     this.key = key;
@@ -313,52 +266,51 @@ export abstract class BaseGiven<
 
     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") {
-            return (fp, contents) =>
-              target[prop](
-                `suite-${suiteNdx}/given-${key}/when/beforeEach/${fp}`,
-                contents
-              );
-          }
+    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 === "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
-              );
-          }
+        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);
-        },
-      });
+        /* @ts-ignore:next-line */
+        return Reflect.get(...arguments);
+      },
+    });
 
-      this.uberCatcher((e) => {
-        console.error(e);
-        this.error = e.error;
-        tLog(e.stack);
-      });
+    this.uberCatcher((e) => {
+      console.error(e);
+      this.error = e.error;
+      tLog(e.stack);
+    });
 
+    try {
       this.store = await this.givenThat(
         subject,
         testResourceConfiguration,
@@ -367,6 +319,13 @@ export abstract class BaseGiven<
         this.initialValues,
         beforeEachProxy
       );
+    } catch (e) {
+      this.error = e;
+      throw e;
+    }
+
+    try {
+      // tLog(`\n Given this.store`, this.store);
 
       for (const [whenNdx, whenStep] of this.whens.entries()) {
         await whenStep.test(
@@ -389,12 +348,10 @@ export abstract class BaseGiven<
         tester(t);
       }
     } catch (e) {
-      console.error(e);
-      this.error = e;
+      // this.error = e;
+      this.failed = true;
       tLog(e.stack);
-      // tLog("\u0007"); // bell
-
-      // throw e;
+      throw e;
     } finally {
       try {
         const afterEachProxy = new Proxy(pm, {
@@ -431,24 +388,17 @@ export abstract class BaseGiven<
           afterEachProxy
         );
       } catch (e) {
-        console.error("afterEach failed! no error will be recorded!", e);
+        this.failed = e;
+        throw e;
+        // console.error("afterEach failed!", e);
+        // this.error = e.message;
       }
     }
     return this.store;
   }
 }
 
-export abstract class BaseWhen<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> {
+export abstract class BaseWhen<I extends IT> {
   public name: string;
   whenCB: (x: I["iselection"]) => I["then"];
   error: boolean;
@@ -462,7 +412,7 @@ export abstract class BaseWhen<
     store: I["istore"],
     whenCB: (x: I["iselection"]) => I["then"],
     testResource,
-    pm: PM
+    pm: IPM
   ): Promise<any>;
 
   toObj() {
@@ -476,12 +426,11 @@ export abstract class BaseWhen<
     store: I["istore"],
     testResourceConfiguration,
     tLog: ITLog,
-    pm: PM,
+    pm: IPM,
     filepath: string
   ) {
     tLog(" When:", this.name);
 
-    const name = this.name;
     const andWhenProxy = new Proxy(pm, {
       get(target, prop, receiver) {
         if (prop === "customScreenShot") {
@@ -527,24 +476,16 @@ export abstract class BaseWhen<
   }
 }
 
-export abstract class BaseThen<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> {
+export abstract class BaseThen<I extends IT> {
   public name: string;
   thenCB: (storeState: I["iselection"]) => I["then"];
+  go: (storeState: I["iselection"]) => I["then"];
   error: boolean;
 
   constructor(name: string, thenCB: (val: I["iselection"]) => I["then"]) {
     this.name = name;
     this.thenCB = thenCB;
+
     this.error = false;
   }
 
@@ -557,19 +498,31 @@ export abstract class BaseThen<
 
   abstract butThen(
     store: I["istore"],
-    thenCB,
+    thenCB: (s: I["iselection"]) => I["isubject"],
     testResourceConfiguration: ITTestResourceConfiguration,
-    pm: PM
+    pm: IPM,
+    ...args: any[]
   ): Promise<I["iselection"]>;
 
   async test(
     store: I["istore"],
     testResourceConfiguration,
     tLog: ITLog,
-    pm: PM,
+    pm: IPM,
     filepath: string
   ): Promise<I["then"] | undefined> {
-    tLog(" Then:", this.name);
+    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) {
@@ -596,77 +549,74 @@ export abstract class BaseThen<
 
       return this.butThen(
         store,
-        this.thenCB,
+        this.go,
         testResourceConfiguration,
         butThenProxy
       ).catch((e) => {
-        this.error = true;
+        this.error = e;
         throw e;
       });
     } catch (e) {
-      console.log("test failed", e);
-      this.error = e.message;
+      console.log("test failed 2", e);
+      this.error = e;
       throw e;
     }
   }
+
+  check() {}
 }
 
-export abstract class BaseCheck<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >,
-  O extends Ibdd_out<
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
-  >
-> {
+export abstract class BaseCheck<I extends IT = IT> {
+  key: string;
   name: string;
   features: string[];
-  checkCB: (whens, thens) => any;
-  whens: {
-    [K in keyof O["whens"]]: (p, tc) => BaseWhen<I>;
-  };
-  thens: {
-    [K in keyof O["thens"]]: (p, tc) => BaseThen<I>;
-  };
+  checkCB: (store: I["istore"], pm: IPM) => any;
+  initialValues: any;
+  store: I["istore"];
+  checker: any;
 
   constructor(
     name: string,
     features: string[],
-    checkCB: (whens, thens) => any,
-    whens,
-    thens
+    checker: (store: I["istore"], pm: IPM) => any,
+    x: any,
+    checkCB: any
   ) {
     this.name = name;
     this.features = features;
     this.checkCB = checkCB;
-    this.whens = whens;
-    this.thens = thens;
+    this.checker = checker;
   }
 
   abstract checkThat(
     subject: I["isubject"],
     testResourceConfiguration,
     artifactory: ITestArtifactory,
-    pm: PM
+    initializer,
+    initialValues,
+    pm: IPM
   ): Promise<I["istore"]>;
 
+  toObj() {
+    return {
+      key: this.key,
+      name: this.name,
+      functionAsString: this.checkCB.toString(),
+      features: this.features,
+    };
+  }
+
   async afterEach(
     store: I["istore"],
     key: string,
-    cb,
-    pm: PM
+    artifactory: ITestArtifactory,
+    pm: IPM
   ): Promise<unknown> {
-    return;
+    return store;
+  }
+
+  beforeAll(store: I["istore"]) {
+    return store;
   }
 
   async check(
@@ -676,43 +626,21 @@ export abstract class BaseCheck<
     tester,
     artifactory: ITestArtifactory,
     tLog: ITLog,
-    pm: PM
+    pm: IPM
   ) {
+    this.key = key;
     tLog(`\n Check: ${this.name}`);
-    const store = await this.checkThat(
+    this.store = await this.checkThat(
       subject,
       testResourceConfiguration,
       artifactory,
+      this.checkCB,
+      this.initialValues,
       pm
     );
-    await this.checkCB(
-      Object.entries(this.whens).reduce((a, [key, when]) => {
-        a[key] = async (payload) => {
-          return await when(payload, testResourceConfiguration).test(
-            store,
-            testResourceConfiguration,
-            tLog,
-            pm,
-            "x"
-          );
-        };
-        return a;
-      }, {}),
-      Object.entries(this.thens).reduce((a, [key, then]) => {
-        a[key] = async (payload) => {
-          const t = await then(payload, testResourceConfiguration).test(
-            store,
-            testResourceConfiguration,
-            tLog,
-            pm
-          );
-          tester(t);
-        };
-        return a;
-      }, {})
-    );
 
-    await this.afterEach(store, key, () => {}, pm);
+    await this.checker(this.store, pm);
+
     return;
   }
 }