testeranto 0.100.0 → 0.110.0

package/src/Types.ts

@@ -1,8 +1,4 @@
-import {
-  ITTestResourceConfiguration,
-  ITestArtificer,
-  ITestCheckCallback,
-} from "./lib/index.js";
+import { ITTestResourceConfiguration, ITestArtificer } from "./lib/index.js";
 import {
   IGivens,
   BaseCheck,
@@ -12,64 +8,9 @@ import {
   BaseGiven,
 } from "./lib/abstractBase.js";
 import { PM } from "./PM/index.js";
+import { ITestCheckCallback } from "./lib/types.js";
 
-export type IWebTestInterface<
-  ITestShape extends IBaseTest<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
-  >
-> = {
-  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 INodeTestInterface<
+export type ITestInterface<
   I extends Ibdd_in<
     unknown,
     unknown,
@@ -85,38 +26,31 @@ export type INodeTestInterface<
     store: I["istore"],
     whenCB: I["when"],
     testResource: ITTestResourceConfiguration,
-    utils: PM
+    pm: PM
   ) => Promise<I["istore"]>;
   butThen: (
     store: I["istore"],
-    thenCB,
+    thenCB: I["then"],
     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>;
+  ) => Promise<I["iselection"]>;
+  afterAll: (store: I["istore"], pm: PM) => any;
+  afterEach: (store: I["istore"], key: string, 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<
+export type IWebTestInterface<
   I extends Ibdd_in<
     unknown,
     unknown,
@@ -126,42 +60,19 @@ export type ITestInterface<
     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"]>;
-};
+> = ITestInterface<I>;
+
+export type INodeTestInterface<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >
+> = ITestInterface<I>;
 
 export type IPartialInterface<
   I extends Ibdd_in<
@@ -187,24 +98,30 @@ export type IPartialNodeInterface<
   >
 > = Partial<INodeTestInterface<I>>;
 export type IPartialWebInterface<
-  I 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
   >
 > = Partial<IWebTestInterface<I>>;
 
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 export type ITestSpecification<
-  I extends Ibdd_out<
+  I extends Ibdd_in<
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
     Record<string, any>,
     Record<string, any>,
     Record<string, any>,
@@ -213,170 +130,33 @@ export type ITestSpecification<
   >
 > = (
   Suite: {
-    [K in keyof I["suites"]]: (
+    [K in keyof O["suites"]]: (
       name: string,
-      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>
-      >
-    >;
+      givens: IGivens<I>,
+      checks: BaseCheck<I, O>[]
+    ) => BaseSuite<I, O>;
   },
   Given: {
-    [K in keyof I["givens"]]: (
+    [K in keyof O["givens"]]: (
       features: string[],
-      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>
-      >
-    >;
+      whens: BaseWhen<I>[],
+      thens: BaseThen<I>[],
+      ...xtrasB: O["givens"][K]
+    ) => BaseGiven<I>;
   },
   When: {
-    [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>
-      >
-    >;
+    [K in keyof O["whens"]]: (...xtrasC: O["whens"][K]) => BaseWhen<I>;
   },
   Then: {
-    [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>
-      >
-    >;
+    [K in keyof O["thens"]]: (...xtrasD: O["thens"][K]) => BaseThen<I>;
   },
-  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>
-    >
-  >
+  Check: ITestCheckCallback<I, O>
 ) => any[];
 
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 export type ITestImplementation<
-  IN extends Ibdd_in<
+  I extends Ibdd_in<
     unknown,
     unknown,
     unknown,
@@ -385,7 +165,7 @@ export type ITestImplementation<
     unknown,
     unknown
   >,
-  OUT extends Ibdd_out<
+  O extends Ibdd_out<
     Record<string, any>,
     Record<string, any>,
     Record<string, any>,
@@ -394,55 +174,29 @@ export type ITestImplementation<
   >
 > = {
   suites: {
-    [K in keyof OUT["suites"]]: string;
+    [K in keyof O["suites"]]: string;
   };
   givens: {
-    [K in keyof OUT["givens"]]: (...Ig: OUT["givens"][K]) => IN["given"];
+    [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
   };
   whens: {
-    [K in keyof OUT["whens"]]: (
-      ...Iw: OUT["whens"][K]
-    ) => (zel: IN["iselection"], utils: PM) => Promise<IN["when"]>;
+    [K in keyof O["whens"]]: (
+      ...Iw: O["whens"][K]
+    ) => (zel: I["iselection"], utils: PM) => Promise<I["when"]>;
   };
   thens: {
-    [K in keyof OUT["thens"]]: (
-      ...It: OUT["thens"][K]
-    ) => (ssel: IN["iselection"], utils: PM) => IN["then"];
+    [K in keyof O["thens"]]: (
+      ...It: O["thens"][K]
+    ) => (ssel: I["iselection"], utils: PM) => I["then"];
   };
   checks: {
-    [K in keyof OUT["checks"]]: (...Ic: OUT["checks"][K]) => IN["given"];
+    [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
   };
 };
 
-export type Modify<T, R> = Omit<T, keyof R> & R;
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-export type IBaseTest<
-  IInput,
-  ISubject,
-  IStore,
-  ISelection,
-  IGiven,
-  IWhen,
-  IThen,
-  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>
-> = {
-  iinput: IInput;
-  isubject: ISubject;
-  istore: IStore;
-  iselection: ISelection;
-  given: IGiven;
-  when: IWhen;
-  then: IThen;
-  suites: ISuites;
-  givens: IGivens;
-  whens: IWhens;
-  thens: IThens;
-  checks: IChecks;
-};
+export type Modify<T, R> = Omit<T, keyof R> & R;
 
 export type Ibdd_out<
   ISuites extends Record<string, any>,

package/src/Web.ts

@@ -1,17 +1,19 @@
-import { error } from "console";
 import { PM_Web } from "./PM/web";
 import type {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   ITestImplementation,
+  ITestInterface,
   ITestSpecification,
+  IWebTestInterface,
 } from "./Types";
 import Testeranto from "./lib/core.js";
 import {
+  IFinalResults,
   ITTestResourceConfiguration,
   ITTestResourceRequest,
   defaultTestResourceRequirement,
 } from "./lib/index.js";
-import { IFinalResults, ITestInterface, IWebTestInterface } from "./lib/types";
 
 let errorCallback = (e: any) => {};
 let unhandledrejectionCallback = (event: PromiseRejectionEvent) => {
@@ -21,27 +23,29 @@ let unhandledrejectionCallback = (event: PromiseRejectionEvent) => {
 };
 
 export class WebTesteranto<
-  TestShape 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>,
     Record<string, any>,
     Record<string, any>
   >
-> extends Testeranto<TestShape> {
+> extends Testeranto<I, O> {
   constructor(
-    input: TestShape["iinput"],
-    testSpecification: ITestSpecification<TestShape>,
-    testImplementation: ITestImplementation<TestShape>,
+    input: I["iinput"],
+    testSpecification: ITestSpecification<I, O>,
+    testImplementation: ITestImplementation<I, O>,
     testResourceRequirement: ITTestResourceRequest,
-    testInterface: Partial<ITestInterface<TestShape>>
+    testInterface: Partial<ITestInterface<I>>
   ) {
     super(
       input,
@@ -97,14 +101,16 @@ export class WebTesteranto<
 }
 
 export default async <
-  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>,
@@ -112,13 +118,13 @@ export default async <
     Record<string, any>
   >
 >(
-  input: ITestShape["iinput"],
-  testSpecification: ITestSpecification<ITestShape>,
-  testImplementation: ITestImplementation<ITestShape>,
-  testInterface: Partial<IWebTestInterface<ITestShape>>,
+  input: I["iinput"],
+  testSpecification: ITestSpecification<I, O>,
+  testImplementation: ITestImplementation<I, O>,
+  testInterface: Partial<IWebTestInterface<I>>,
   testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement
-): Promise<Testeranto<ITestShape>> => {
-  return new WebTesteranto<ITestShape>(
+): Promise<Testeranto<I, O>> => {
+  return new WebTesteranto<I, O>(
     input,
     testSpecification,
     testImplementation,