testeranto 0.94.0 → 0.100.0

package/src/SubPackages/react/jsx/node.ts

@@ -8,7 +8,22 @@ import {
   testInterface as baseInterface,
 } from "./index.js";
 
-export default <ITestShape extends IBaseTest>(
+export default <
+  ITestShape extends IBaseTest<
+    IInput,
+    number,
+    number,
+    number,
+    unknown,
+    unknown,
+    unknown,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>,
+    Record<string, any>
+  >
+>(
   testImplementations: ITestImpl<ITestShape>,
   testSpecifications: ITestSpec<ITestShape>,
   testInput: IInput,
@@ -19,9 +34,5 @@ export default <ITestShape extends IBaseTest>(
     testSpecifications,
     testImplementations,
     testInterface
-    // {
-    //   ...baseInterface,
-    //   ...testInterface,
-    // }
   );
 };

package/src/SubPackages/react-test-renderer/jsx/node.ts

@@ -5,7 +5,22 @@ import type { ITestImpl, ITestSpec } from "../jsx-promised";
 
 import { IInput, testInterface } from "./index.js";
 
-export default <ITestShape extends IBaseTest>(
+export default <
+  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>
+  >
+>(
   testImplementations: ITestImpl<ITestShape>,
   testSpecifications: ITestSpec<ITestShape>,
   testInput: IInput,

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;
+};