testeranto 0.121.1 → 0.125.0

package/src/lib/classBuilder.ts

@@ -1,9 +1,4 @@
-import {
-  Ibdd_in,
-  Ibdd_out,
-  ITestImplementation,
-  ITestSpecification,
-} from "../Types.js";
+import { IT, ITestImplementation, ITestSpecification, OT } from "../Types.js";
 
 import { BaseBuilder } from "./basebuilder.js";
 import {
@@ -16,33 +11,30 @@ import {
 import { ITTestResourceRequest } from "./index.js";
 import { BaseCheck } from "./abstractBase.js";
 
+type IExtenstions = Record<string, unknown>;
+
 export abstract class ClassBuilder<
-  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 BaseBuilder<I, O, any, any, any, any, any> {
+  I extends IT = IT,
+  O extends OT = OT,
+  M = unknown
+> extends BaseBuilder<
+  I,
+  O,
+  IExtenstions,
+  IExtenstions,
+  IExtenstions,
+  IExtenstions,
+  IExtenstions
+> {
   constructor(
-    testImplementation: ITestImplementation<I, O>,
+    testImplementation: ITestImplementation<I, O, M>,
     testSpecification: ITestSpecification<I, O>,
     input: I["iinput"],
     suiteKlasser: ISuiteKlasser<I, O>,
     givenKlasser: IGivenKlasser<I>,
     whenKlasser: IWhenKlasser<I>,
     thenKlasser: IThenKlasser<I>,
-    checkKlasser: ICheckKlasser<I, O>,
+    checkKlasser: ICheckKlasser<I>,
     testResourceRequirement: ITTestResourceRequest
   ) {
     const classySuites = Object.entries(testImplementation.suites).reduce(
@@ -116,7 +108,7 @@ export abstract class ClassBuilder<
         };
         return a;
       },
-      {} as Record<string, (n, f, c) => BaseCheck<I, O>>
+      {} as Record<string, (n, f, c) => BaseCheck<I>>
     );
 
     super(

package/src/lib/core.ts

@@ -1,12 +1,10 @@
-import { IStore } from "../SubPackages/react/jsx";
 import {
   ITestSpecification,
   ITestImplementation,
   ITestInterface,
-  Ibdd_in,
-  Ibdd_out,
+  IT,
+  OT,
 } from "../Types.js";
-import { PM } from "../PM/index";
 
 import {
   DefaultTestInterface,
@@ -23,32 +21,20 @@ import {
   BaseCheck,
 } from "./abstractBase.js";
 import { ClassBuilder } from "./classBuilder.js";
+import { IPM } from "./types";
 
 export default abstract class Testeranto<
-  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 ClassBuilder<I, O> {
+  I extends IT,
+  O extends OT,
+  M
+> extends ClassBuilder<I, O, M> {
   constructor(
     input: I["iinput"],
     testSpecification: ITestSpecification<I, O>,
-    testImplementation: ITestImplementation<I, O>,
+    testImplementation: ITestImplementation<I, O, M>,
     testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement,
     testInterface: Partial<ITestInterface<I>>,
-    uberCatcher: (cb) => void
+    uberCatcher: (cb: () => void) => void
   ) {
     const fullTestInterface = DefaultTestInterface(testInterface);
 
@@ -58,20 +44,12 @@ export default abstract class Testeranto<
       input,
 
       class extends BaseSuite<I, O> {
-        afterAll(store: IStore, artifactory: ITestArtifactory, pm: PM) {
-          return fullTestInterface.afterAll(
-            store,
-            // (fPath: string, value: unknown) =>
-            //   // TODO does not work?
-            //   {
-            //     artifactory(`afterAll4-${this.name}/${fPath}`, value);
-            //   },
-            pm
-          );
+        afterAll(store: I["istore"], artifactory: ITestArtifactory, pm: IPM) {
+          return fullTestInterface.afterAll(store, pm);
         }
 
-        assertThat(t) {
-          fullTestInterface.assertThis(t);
+        assertThat(t): boolean {
+          return fullTestInterface.assertThis(t);
         }
 
         async setup(
@@ -86,7 +64,7 @@ export default abstract class Testeranto<
               input: I["iinput"],
               artifactory: ITestArtifactory,
               tr,
-              pm: PM
+              pm: IPM
             ) => input as any)
           )(
             s,
@@ -142,20 +120,6 @@ export default abstract class Testeranto<
           } catch (e) {
             throw e;
           }
-          // return fullTestInterface
-          //   .andWhen(store, whenCB, testResource, pm)
-          //   .catch((e) => {
-          //     throw e;
-          //   });
-          // return new Promise((res, rej) => {
-          //   fullTestInterface.andWhen(store, whenCB, testResource, pm);
-          // });
-          // return await fullTestInterface.andWhen(
-          //   store,
-          //   whenCB,
-          //   testResource,
-          //   pm
-          // );
         }
       } as any,
 
@@ -164,7 +128,7 @@ export default abstract class Testeranto<
           store: any,
           thenCB,
           testResource: any,
-          pm: PM
+          pm: IPM
         ): Promise<I["iselection"]> {
           return await fullTestInterface
             .butThen(store, thenCB, testResource, pm)
@@ -177,41 +141,22 @@ export default abstract class Testeranto<
                 throw e;
               }
             );
-          // try {
-          //   console.log("mark 4");
-          //   return await fullTestInterface.butThen(
-          //     store,
-          //     thenCB,
-          //     testResource,
-          //     pm
-          //   );
-          // } catch (e) {
-          //   console.log("mar123");
-          //   throw e;
-          // }
-
-          // return await fullTestInterface.butThen(
-          //   store,
-          //   thenCB,
-          //   testResourceConfiguration,
-          //   pm
-          // );
         }
       } as any,
 
-      class Check extends BaseCheck<I, O> {
+      class Check extends BaseCheck<I> {
         initialValues: any;
 
         constructor(
           name: string,
           features: string[],
-          checkCallback: (s: I["istore"], pm: PM) => any,
-          whens,
-          thens,
-          initialValues: any
+          checkCallback: (s: I["istore"], pm: IPM) => any,
+          x,
+          i,
+          c
         ) {
-          super(name, features, whens, thens, checkCallback, initialValues);
-          this.initialValues = initialValues;
+          super(name, features, checkCallback, x, c);
+          this.initialValues = i;
         }
 
         async checkThat(

package/src/lib/index.ts

@@ -1,7 +1,21 @@
-import { PM } from "../PM/index.js";
-import { Ibdd_in, Ibdd_out, ITestInterface } from "../Types.js";
+import { PM_Pure } from "../PM/pure.js";
+
+import { PM_Node } from "../PM/node.js";
+import { PM_Web } from "../PM/web.js";
+import {
+  Ibdd_in,
+  Ibdd_out,
+  ITestInterface,
+  ITestconfig,
+  IBuiltConfig,
+  IRunTime,
+  ITestTypes,
+  IT,
+  OT,
+} from "../Types.js";
 
 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>
@@ -12,7 +26,7 @@ export const BaseTestInterface: ITestInterface<
     initialValues: any,
     x: any,
     testResource: any,
-    pm: PM
+    pm: IPM
   ) {
     return subject as any;
   },
@@ -44,7 +58,7 @@ export const BaseTestInterface: ITestInterface<
       thenCb(store);
     } catch (e) {}
   },
-  andWhen: (a) => a,
+  andWhen: async (a) => a,
   assertThis: () => null,
 };
 
@@ -94,44 +108,19 @@ type ITest = {
   givens: IGivens<
     Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>
   >;
-  checks: BaseCheck<
-    Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>,
-    Ibdd_out<
-      Record<string, any>,
-      Record<string, any>,
-      Record<string, any>,
-      Record<string, any>,
-      Record<string, any>
-    >
-  >[];
+  checks: BaseCheck<IT>[];
   testResourceConfiguration: ITTestResourceConfiguration;
 };
 
-export type ITestJob<T = PM> = {
+export type ITestJob = {
   toObj(): object;
   test: ITest;
   runner: (
     x: ITTestResourceConfiguration,
     t: ITLog
-  ) => Promise<
-    BaseSuite<
-      Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>,
-      Ibdd_out<
-        Record<string, any>,
-        Record<string, any>,
-        Record<string, any>,
-        Record<string, any>,
-        Record<string, any>
-      >
-    >
-  >;
+  ) => Promise<BaseSuite<IT, OT>>;
   testResourceRequirement: ITTestResourceRequirement;
-  receiveTestResourceConfig: (pm: PM) => Promise<{
-    failed: number;
-    artifacts: Promise<unknown>[];
-    logPromise: Promise<unknown>;
-    features: string[];
-  }>;
+  receiveTestResourceConfig: (pm: PM_Node | PM_Web | PM_Pure) => IFinalResults;
 };
 
 export type ITestResults = Promise<{ test: ITest }>[];
@@ -142,42 +131,18 @@ export const defaultTestResourceRequirement: ITTestResourceRequest = {
 
 export type ITestArtifactory = (key: string, value: unknown) => unknown;
 
+export type { ITestconfig, IBuiltConfig, IRunTime, ITestTypes };
+
 export type IRunnables = {
   nodeEntryPoints: Record<string, string>;
   webEntryPoints: Record<string, string>;
+  importEntryPoints: Record<string, string>;
 };
 
-export type IFinalResults = { features: string[]; failed: number };
-
-export type IRunTime = `node` | `web`;
-
-export type ITestTypes = [string, IRunTime, { ports: number }, ITestTypes[]];
-
-export type IPluginFactory = (
-  register: (entrypoint, sources) => any,
-  entrypoints
-) => Plugin;
-
-export type IBaseConfig = {
-  src: string;
-  clearScreen: boolean;
-  debugger: boolean;
-  // devMode: boolean;
-  externals: string[];
-  minify: boolean;
-  // outbase: string;
-  // outdir: string;
-  ports: string[];
-  tests: ITestTypes[];
-
-  nodePlugins: IPluginFactory[];
-  webPlugins: IPluginFactory[];
-
-  featureIngestor: (s: string) => Promise<string>;
-};
-
-export type IBuiltConfig = { buildDir: string } & IBaseConfig;
-
-export type IConfigV2 = {
-  projects: Record<string, IBaseConfig>;
+export type IFinalResults = {
+  features: string[];
+  failed: boolean;
+  fails: number;
+  artifacts: Promise<unknown>[];
+  logPromise: Promise<unknown>;
 };

package/src/lib/types.ts

@@ -1,5 +1,8 @@
 import { PM } from "../PM";
-import { Ibdd_in, Ibdd_out } from "../Types";
+import { PM_Node } from "../PM/node";
+import { PM_Pure } from "../PM/pure";
+import { PM_Web } from "../PM/web";
+import { IT, OT } from "../Types";
 
 import {
   IGivens,
@@ -10,108 +13,35 @@ import {
   BaseThen,
 } from "./abstractBase";
 
-export type ITestCheckCallback<
-  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 type IPM = PM_Node | PM_Web | PM_Pure;
+
+export type ITestCheckCallback<I extends IT, O extends OT> = {
   [K in keyof O["checks"]]: (
     name: string,
     features: string[],
     checkCallback: (store: I["istore"], pm: PM) => Promise<any>,
 
     ...xtrasA: O["checks"][K]
-  ) => BaseCheck<I, O>;
+  ) => BaseCheck<I>;
 };
 
-export type ISuiteKlasser<
-  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 type ISuiteKlasser<I extends IT, O extends OT> = (
   name: string,
   index: number,
   givens: IGivens<I>,
-  checks: BaseCheck<I, O>[]
+  checks: BaseCheck<I>[]
 ) => BaseSuite<I, O>;
 
-export type IGivenKlasser<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> = (name, features, whens, thens, givenCB) => BaseGiven<I>;
+export type IGivenKlasser<I extends IT> = (
+  name,
+  features,
+  whens,
+  thens,
+  givenCB
+) => BaseGiven<I>;
 
-export type IWhenKlasser<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> = (s, o) => BaseWhen<I>;
+export type IWhenKlasser<I extends IT> = (s, o) => BaseWhen<I>;
 
-export type IThenKlasser<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> = (s, o) => BaseThen<I>;
+export type IThenKlasser<I extends IT> = (s, o) => BaseThen<I>;
 
-export type ICheckKlasser<
-  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>
-  >
-> = (n, f, cb, w, t) => BaseCheck<I, O>;
+export type ICheckKlasser<I extends IT> = (n, f, cb, w, t) => BaseCheck<I>;

package/src/run.ts

@@ -3,7 +3,7 @@ import readline from "readline";
 import path from "path";
 
 import { PM_Main } from "./PM/main";
-import { IBaseConfig, IBuiltConfig, IConfigV2 } from "./lib";
+import { ITestconfig, IBuiltConfig, IProject } from "./Types";
 
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY) process.stdin.setRawMode(true);
@@ -27,12 +27,9 @@ if (mode !== "once" && mode !== "dev") {
 console.log("testeranto is running", testName, mode);
 
 import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
-  // const testName = path.basename(process.argv[2]).split(".")[0];
-  const bigConfig: IConfigV2 = module.default;
+  const bigConfig: IProject = module.default;
 
-  const rawConfig: IBaseConfig = bigConfig.projects[testName];
-
-  // const rawConfig: IBaseConfig = module.default;
+  const rawConfig: ITestconfig = bigConfig.projects[testName];
 
   const config: IBuiltConfig = {
     ...rawConfig,

package/src/utils.ts

@@ -1,6 +1,7 @@
 import path from "path";
 
-import { IRunTime, IBuiltConfig } from "./lib";
+import { IBuiltConfig, IRunTime, ITestTypes } from "./Types";
+import { IRunnables } from "./lib";
 
 export type ISummary = Record<
   string,
@@ -26,7 +27,7 @@ export const destinationOfRuntime = (
 
 export const tscPather = (
   entryPoint: string,
-  platform: "web" | "node",
+  platform: IRunTime,
   projectName: string
 ) => {
   return path.join(
@@ -41,7 +42,7 @@ export const tscPather = (
 
 export const lintPather = (
   entryPoint: string,
-  platform: "web" | "node",
+  platform: IRunTime,
   projectName: string
 ) => {
   return path.join(
@@ -56,7 +57,7 @@ export const lintPather = (
 
 export const bddPather = (
   entryPoint: string,
-  platform: "web" | "node",
+  platform: IRunTime,
   projectName: string
 ) => {
   return path.join(
@@ -71,7 +72,7 @@ export const bddPather = (
 
 export const promptPather = (
   entryPoint: string,
-  platform: "web" | "node",
+  platform: IRunTime,
   projectName: string
 ) => {
   return path.join(
@@ -83,3 +84,47 @@ export const promptPather = (
     `prompt.txt`
   );
 };
+
+export const getRunnables = (
+  tests: ITestTypes[],
+  projectName: string,
+  payload = {
+    nodeEntryPoints: {},
+    webEntryPoints: {},
+    importEntryPoints: {},
+  }
+): IRunnables => {
+  return tests.reduce((pt, cv, cndx, cry) => {
+    if (cv[1] === "node") {
+      pt.nodeEntryPoints[cv[0]] = path.resolve(
+        `./testeranto/bundles/node/${projectName}/${cv[0]
+          .split(".")
+          .slice(0, -1)
+          .concat("mjs")
+          .join(".")}`
+      );
+    } else if (cv[1] === "web") {
+      pt.webEntryPoints[cv[0]] = path.resolve(
+        `./testeranto/bundles/web/${projectName}/${cv[0]
+          .split(".")
+          .slice(0, -1)
+          .concat("mjs")
+          .join(".")}`
+      );
+    } else if (cv[1] === "pure") {
+      pt.importEntryPoints[cv[0]] = path.resolve(
+        `./testeranto/bundles/pure/${projectName}/${cv[0]
+          .split(".")
+          .slice(0, -1)
+          .concat("mjs")
+          .join(".")}`
+      );
+    }
+
+    // if (cv[3].length) {
+    //   getRunnables(cv[3], testName, payload);
+    // }
+
+    return pt;
+  }, payload as IRunnables);
+};