testeranto 0.90.0 → 0.100.0

package/src/Types.ts

@@ -1,4 +1,8 @@
-import { ITTestResourceRequest, ITestCheckCallback } from "./lib/index.js";
+import {
+  ITTestResourceConfiguration,
+  ITestArtificer,
+  ITestCheckCallback,
+} from "./lib/index.js";
 import {
   IGivens,
   BaseCheck,
@@ -7,16 +11,10 @@ import {
   BaseThen,
   BaseGiven,
 } from "./lib/abstractBase.js";
-import Testeranto from "./lib/core.js";
-import {
-  INodeTestInterface,
-  ITestInterface,
-  IWebTestInterface,
-} from "./lib/types.js";
 import { PM } from "./PM/index.js";
 
-export type IPartialInterface<
-  I extends IBaseTest<
+export type IWebTestInterface<
+  ITestShape extends IBaseTest<
     unknown,
     unknown,
     unknown,
@@ -30,43 +28,166 @@ export type IPartialInterface<
     Record<string, any>,
     Record<string, any>
   >
-> = Partial<ITestInterface<I>>;
+> = {
+  assertThis: (x: ITestShape["then"]) => void;
+  andWhen: (
+    store: ITestShape["istore"],
+    whenCB: ITestShape["when"],
+    testResource: ITTestResourceConfiguration,
+    utils: PM
+  ) => Promise<ITestShape["istore"]>;
+  butThen: (
+    store: ITestShape["istore"],
+    thenCB,
+    testResource: ITTestResourceConfiguration,
+    utils: PM
+  ) => Promise<ITestShape["iselection"]>;
+  afterAll: (
+    store: ITestShape["istore"],
+    artificer: ITestArtificer,
+    utils: PM
+  ) => any;
+  afterEach: (
+    store: ITestShape["istore"],
+    key: string,
+    artificer: ITestArtificer,
+    utils: PM
+  ) => Promise<unknown>;
+  beforeAll: (
+    input: ITestShape["iinput"],
+    testResource: ITTestResourceConfiguration,
+    artificer: ITestArtificer,
+    utils: PM
+  ) => Promise<ITestShape["isubject"]>;
+  beforeEach: (
+    subject: ITestShape["isubject"],
+    initializer: (c?) => ITestShape["given"],
+    artificer: ITestArtificer,
+    testResource: ITTestResourceConfiguration,
+    initialValues,
+    utils: PM
+  ) => Promise<ITestShape["istore"]>;
+};
 
-export type IPartialNodeInterface<
-  I extends IBaseTest<
+export type INodeTestInterface<
+  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
   >
-> = Partial<INodeTestInterface<I>>;
-export type IPartialWebInterface<
-  I extends IBaseTest<
+> = {
+  assertThis: (x: I["then"]) => void;
+  andWhen: (
+    store: I["istore"],
+    whenCB: I["when"],
+    testResource: ITTestResourceConfiguration,
+    utils: PM
+  ) => Promise<I["istore"]>;
+  butThen: (
+    store: I["istore"],
+    thenCB,
+    testResource: ITTestResourceConfiguration,
+    utils: PM
+  ) => Promise<I["iselection"]>;
+  afterAll: (store: I["istore"], artificer: ITestArtificer, pm: PM) => any;
+  afterEach: (
+    store: I["istore"],
+    key: string,
+    artificer: ITestArtificer,
+    pm: PM
+  ) => Promise<unknown>;
+  beforeAll: (
+    input: I["iinput"],
+    testResource: ITTestResourceConfiguration,
+    artificer: ITestArtificer,
+    pm: PM
+  ) => Promise<I["isubject"]>;
+  beforeEach: (
+    subject: I["isubject"],
+    initializer: (c?) => I["given"],
+    artificer: ITestArtificer,
+    testResource: ITTestResourceConfiguration,
+    initialValues,
+    pm: PM
+  ) => Promise<I["istore"]>;
+};
+
+export type ITestInterface<
+  I extends Ibdd_in<
     unknown,
     unknown,
     unknown,
     unknown,
     unknown,
     unknown,
+    unknown
+  >
+> = {
+  assertThis: (x: I["then"]) => void;
+  andWhen: (
+    store: I["istore"],
+    whenCB: I["when"],
+    testResource: ITTestResourceConfiguration,
+    pm: PM
+  ) => Promise<I["istore"]>;
+  butThen: (
+    store: I["istore"],
+    thenCB: I["then"],
+    testResource: ITTestResourceConfiguration,
+    pm: PM
+  ) => Promise<I["iselection"]>;
+  afterAll: (store: I["istore"], artificer: ITestArtificer, pm: PM) => any;
+  afterEach: (
+    store: I["istore"],
+    key: string,
+    artificer: ITestArtificer,
+    pm: PM
+  ) => Promise<unknown>;
+  beforeAll: (
+    input: I["iinput"],
+    testResource: ITTestResourceConfiguration,
+    artificer: ITestArtificer,
+    pm: PM
+  ) => Promise<I["isubject"]>;
+  beforeEach: (
+    subject: I["isubject"],
+    initializer: (c?) => I["given"],
+    artificer: ITestArtificer,
+    testResource: ITTestResourceConfiguration,
+    initialValues,
+    pm: PM
+  ) => Promise<I["istore"]>;
+};
+
+export type IPartialInterface<
+  I extends Ibdd_in<
     unknown,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
   >
-> = Partial<IWebTestInterface<I>>;
+> = Partial<ITestInterface<I>>;
 
-export type IEntry<
-  ITestShape extends IBaseTest<
+export type IPartialNodeInterface<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >
+> = Partial<INodeTestInterface<I>>;
+export type IPartialWebInterface<
+  I extends IBaseTest<
     unknown,
     unknown,
     unknown,
@@ -80,23 +201,10 @@ export type IEntry<
     Record<string, any>,
     Record<string, any>
   >
-> = (
-  input: ITestShape["iinput"],
-  testSpecification: ITestSpecification<ITestShape>,
-  testImplementation: ITestImplementation<ITestShape, object>,
-  testInterface: IPartialInterface<ITestShape>,
-  testResourceRequirement: ITTestResourceRequest
-) => Promise<Testeranto<ITestShape>>;
+> = Partial<IWebTestInterface<I>>;
 
 export type ITestSpecification<
-  ITestShape extends IBaseTest<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
+  I extends Ibdd_out<
     Record<string, any>,
     Record<string, any>,
     Record<string, any>,
@@ -105,100 +213,208 @@ export type ITestSpecification<
   >
 > = (
   Suite: {
-    [K in keyof ITestShape["suites"]]: (
+    [K in keyof I["suites"]]: (
       name: string,
-      givens: IGivens<ITestShape>,
-      checks: BaseCheck<ITestShape>[]
-    ) => BaseSuite<ITestShape>;
+      givens: IGivens<
+        IBaseTest<
+          unknown,
+          unknown,
+          unknown,
+          unknown,
+          unknown,
+          unknown,
+          unknown,
+          Record<string, any>,
+          Record<string, any>,
+          Record<string, any>,
+          Record<string, any>,
+          Record<string, any>
+        >
+      >,
+      checks: BaseCheck<
+        IBaseTest<
+          unknown,
+          unknown,
+          unknown,
+          unknown,
+          unknown,
+          unknown,
+          unknown,
+          Record<string, any>,
+          Record<string, any>,
+          Record<string, any>,
+          Record<string, any>,
+          Record<string, any>
+        >
+      >[]
+    ) => BaseSuite<
+      IBaseTest<
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        Record<string, any>,
+        Record<string, any>,
+        Record<string, any>,
+        Record<string, any>,
+        Record<string, any>
+      >
+    >;
   },
   Given: {
-    [K in keyof ITestShape["givens"]]: (
+    [K in keyof I["givens"]]: (
       features: string[],
-      whens: BaseWhen<ITestShape>[],
-      thens: BaseThen<ITestShape>[],
-      ...xtrasB: ITestShape["givens"][K]
-    ) => BaseGiven<ITestShape>;
+      whens: BaseWhen<
+        IBaseTest<
+          unknown,
+          unknown,
+          unknown,
+          unknown,
+          unknown,
+          unknown,
+          unknown,
+          Record<string, any>,
+          Record<string, any>,
+          Record<string, any>,
+          Record<string, any>,
+          Record<string, any>
+        >
+      >[],
+      thens: BaseThen<
+        IBaseTest<
+          unknown,
+          unknown,
+          unknown,
+          unknown,
+          unknown,
+          unknown,
+          unknown,
+          Record<string, any>,
+          Record<string, any>,
+          Record<string, any>,
+          Record<string, any>,
+          Record<string, any>
+        >
+      >[],
+      ...xtrasB: I["givens"][K]
+    ) => BaseGiven<
+      IBaseTest<
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        Record<string, any>,
+        Record<string, any>,
+        Record<string, any>,
+        Record<string, any>,
+        Record<string, any>
+      >
+    >;
   },
   When: {
-    [K in keyof ITestShape["whens"]]: (
-      ...xtrasC: ITestShape["whens"][K]
-    ) => BaseWhen<ITestShape>;
+    [K in keyof I["whens"]]: (
+      ...xtrasC: I["whens"][K]
+    ) => BaseWhen<
+      IBaseTest<
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        Record<string, any>,
+        Record<string, any>,
+        Record<string, any>,
+        Record<string, any>,
+        Record<string, any>
+      >
+    >;
   },
   Then: {
-    [K in keyof ITestShape["thens"]]: (
-      ...xtrasD: ITestShape["thens"][K]
-    ) => BaseThen<ITestShape>;
+    [K in keyof I["thens"]]: (
+      ...xtrasD: I["thens"][K]
+    ) => BaseThen<
+      IBaseTest<
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        unknown,
+        Record<string, any>,
+        Record<string, any>,
+        Record<string, any>,
+        Record<string, any>,
+        Record<string, any>
+      >
+    >;
   },
-  Check: ITestCheckCallback<ITestShape>
+  Check: ITestCheckCallback<
+    IBaseTest<
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      unknown,
+      Record<string, any>,
+      Record<string, any>,
+      Record<string, any>,
+      Record<string, any>,
+      Record<string, any>
+    >
+  >
 ) => any[];
 
 export type ITestImplementation<
-  ITestShape extends IBaseTest<
-    unknown,
+  IN extends Ibdd_in<
     unknown,
     unknown,
     unknown,
     unknown,
     unknown,
     unknown,
+    unknown
+  >,
+  OUT extends Ibdd_out<
     Record<string, any>,
     Record<string, any>,
     Record<string, any>,
     Record<string, any>,
     Record<string, any>
-  >,
-  IMod = object
-> = Modify<
-  {
-    suites: {
-      [K in keyof ITestShape["suites"]]: string;
-    };
-    givens: {
-      [K in keyof ITestShape["givens"]]: (
-        ...Ig: ITestShape["givens"][K]
-      ) => ITestShape["given"];
-    };
-    whens: {
-      [K in keyof ITestShape["whens"]]: (
-        ...Iw: ITestShape["whens"][K]
-      ) => (
-        zel: ITestShape["iselection"],
-        utils: PM
-      ) => Promise<ITestShape["when"]>;
-    };
-    thens: {
-      [K in keyof ITestShape["thens"]]: (
-        ...It: ITestShape["thens"][K]
-      ) => (ssel: ITestShape["iselection"], utils: PM) => ITestShape["then"];
-    };
-    checks: {
-      [K in keyof ITestShape["checks"]]: (
-        ...Ic: ITestShape["checks"][K]
-      ) => ITestShape["given"];
-    };
-  },
-  IMod
->;
-
-type Modify<T, R> = Omit<T, keyof R> & R;
-
-// export type IBaseTest<Shape = any, II = Shape> = {
-//   iinput: II;
-//   isubject: Shape;
-//   istore: Shape;
-//   iselection: Shape;
-//   // iinitial;
-
-//   given;
-//   when;
-//   then;
+  >
+> = {
+  suites: {
+    [K in keyof OUT["suites"]]: string;
+  };
+  givens: {
+    [K in keyof OUT["givens"]]: (...Ig: OUT["givens"][K]) => IN["given"];
+  };
+  whens: {
+    [K in keyof OUT["whens"]]: (
+      ...Iw: OUT["whens"][K]
+    ) => (zel: IN["iselection"], utils: PM) => Promise<IN["when"]>;
+  };
+  thens: {
+    [K in keyof OUT["thens"]]: (
+      ...It: OUT["thens"][K]
+    ) => (ssel: IN["iselection"], utils: PM) => IN["then"];
+  };
+  checks: {
+    [K in keyof OUT["checks"]]: (...Ic: OUT["checks"][K]) => IN["given"];
+  };
+};
 
-//   suites: Record<string, any>;
-//   givens: Record<string, any>;
-//   whens: Record<string, any>;
-//   thens: Record<string, any>;
-//   checks: Record<string, any>;
-// };
+export type Modify<T, R> = Omit<T, keyof R> & R;
 
 export type IBaseTest<
   IInput,
@@ -227,3 +443,35 @@ export type IBaseTest<
   thens: IThens;
   checks: IChecks;
 };
+
+export type Ibdd_out<
+  ISuites extends Record<string, any>,
+  IGivens extends Record<string, any>,
+  IWhens extends Record<string, any>,
+  IThens extends Record<string, any>,
+  IChecks extends Record<string, any>
+> = {
+  suites: ISuites;
+  givens: IGivens;
+  whens: IWhens;
+  thens: IThens;
+  checks: IChecks;
+};
+
+export type Ibdd_in<
+  IInput,
+  ISubject,
+  IStore,
+  ISelection,
+  IGiven,
+  IWhen,
+  IThen
+> = {
+  iinput: IInput;
+  isubject: ISubject;
+  istore: IStore;
+  iselection: ISelection;
+  given: IGiven;
+  when: IWhen;
+  then: IThen;
+};

package/src/Web.ts

@@ -1,3 +1,4 @@
+import { error } from "console";
 import { PM_Web } from "./PM/web";
 import type {
   IBaseTest,
@@ -10,7 +11,14 @@ import {
   ITTestResourceRequest,
   defaultTestResourceRequirement,
 } from "./lib/index.js";
-import { ITestInterface, IWebTestInterface } from "./lib/types";
+import { IFinalResults, ITestInterface, IWebTestInterface } from "./lib/types";
+
+let errorCallback = (e: any) => {};
+let unhandledrejectionCallback = (event: PromiseRejectionEvent) => {
+  console.log("window.addEventListener unhandledrejection", event);
+  // cb({ error: event.reason.message });
+  // throw event;
+};
 
 export class WebTesteranto<
   TestShape extends IBaseTest<
@@ -40,7 +48,40 @@ export class WebTesteranto<
       testSpecification,
       testImplementation,
       testResourceRequirement,
-      testInterface
+      testInterface,
+      (cb) => {
+        window.removeEventListener("error", errorCallback);
+
+        errorCallback = (e) => {
+          console.log("window.addEventListener error", e);
+          cb(e);
+          // throw e;
+        };
+
+        window.addEventListener("error", errorCallback);
+
+        window.removeEventListener(
+          "unhandledrejection",
+          unhandledrejectionCallback
+        );
+        /////////////////////
+
+        window.removeEventListener(
+          "unhandledrejection",
+          unhandledrejectionCallback
+        );
+
+        unhandledrejectionCallback = (event: PromiseRejectionEvent) => {
+          console.log("window.addEventListener unhandledrejection", event);
+          cb({ error: event.reason.message });
+          // throw event;
+        };
+
+        window.addEventListener(
+          "unhandledrejection",
+          unhandledrejectionCallback
+        );
+      }
     );
   }
 
@@ -49,28 +90,9 @@ export class WebTesteranto<
     const pm = new PM_Web(t);
     const { failed, artifacts, logPromise, features } =
       await this.testJobs[0].receiveTestResourceConfig(pm);
-    pm.customclose();
-    return new Promise<string[]>((res, rej) => {
-      res(features);
+    return new Promise<IFinalResults>((res, rej) => {
+      res({ features, failed });
     });
-    // return features;
-    // Promise.all([...artifacts, logPromise]).then(async () => {
-    //   console.log("hello world");
-    //   pm.customclose();
-    //   // we can't close the window becuase we might be taking a screenshot
-    //   // window.close();
-    //   // console.log(
-    //   //   "(window as any).browser",
-    //   //   JSON.stringify(await (window as any).browser)
-    //   // );
-    //   // var currentWindow = (await (window as any).browser).getCurrentWindow();
-    //   // window.close();
-    //   // var customWindow = window.open("", "_blank", "");
-    //   // customWindow.close();
-    //   // this.puppetMaster.browser.page
-    //   // window["customclose"]();
-    //   // console.log("goodbye", window["customclose"]());
-    // });
   }
 }