testeranto 0.121.1 → 0.125.1

package/src/TestReport.tsx

@@ -26,8 +26,8 @@ const TestPane = ({ given }: {
   given: {
     key: string,
     name: string,
-    error: string[],
-    features: string[],
+    error?: string[],
+    features?: string[],
     whens: {
       name: string;
       error: string;
@@ -184,8 +184,11 @@ const BddPage = () => {
 document.addEventListener("DOMContentLoaded", function () {
   const elem = document.getElementById("root");
   if (elem) {
-    ReactDom.createRoot(elem).render(React.createElement(BddPage, {}, []));
+    if (elem) {
+      const root = ReactDom.createRoot(elem);
+      root.render(React.createElement(BddPage, {}));
+    }
   }
 });
 
-console.log("hello BddPage!")
+console.log("hello BddPage!")

package/src/Types.ts

@@ -1,4 +1,6 @@
-import { ITTestResourceConfiguration, ITestArtificer } from "./lib/index.js";
+import { Plugin } from "esbuild";
+
+import { ITTestResourceConfiguration } from "./lib/index.js";
 import {
   IGivens,
   BaseCheck,
@@ -7,133 +9,84 @@ import {
   BaseThen,
   BaseGiven,
 } from "./lib/abstractBase.js";
+import { IPM, ITestCheckCallback } from "./lib/types.js";
 import { PM } from "./PM/index.js";
-import { ITestCheckCallback } from "./lib/types.js";
-
-export type ITestInterface<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> = {
-  assertThis: (x: I["then"]) => void;
+
+export type ITestInterface<I extends IT = IT> = {
+  assertThis: (x: I["then"]) => any;
   andWhen: (
     store: I["istore"],
     whenCB: I["when"],
     testResource: ITTestResourceConfiguration,
-    pm: PM
+    pm: IPM
   ) => Promise<I["istore"]>;
   butThen: (
     store: I["istore"],
     thenCB: I["then"],
     testResource: ITTestResourceConfiguration,
-    pm: PM
+    pm: IPM
   ) => Promise<I["iselection"]>;
-  afterAll: (store: I["istore"], pm: PM) => any;
-  afterEach: (store: I["istore"], key: string, pm: PM) => Promise<unknown>;
+  afterAll: (store: I["istore"], pm: IPM) => any;
+  afterEach: (store: I["istore"], key: string, pm: IPM) => Promise<unknown>;
   beforeAll: (
     input: I["iinput"],
     testResource: ITTestResourceConfiguration,
-    pm: PM
+    pm: IPM
   ) => Promise<I["isubject"]>;
   beforeEach: (
     subject: I["isubject"],
     initializer: (c?) => I["given"],
     testResource: ITTestResourceConfiguration,
     initialValues,
-    pm: PM
+    pm: IPM
   ) => Promise<I["istore"]>;
 };
 
-export type IWebTestInterface<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> = 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<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> = Partial<ITestInterface<I>>;
-
-export type IPartialNodeInterface<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> = Partial<INodeTestInterface<I>>;
-export type IPartialWebInterface<
-  I extends Ibdd_in<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown
-  >
-> = Partial<IWebTestInterface<I>>;
+export type IWebTestInterface<I extends IT> = ITestInterface<I>;
+
+export type INodeTestInterface<I extends IT> = ITestInterface<I>;
+
+export type IPartialInterface<I extends IT> = Partial<ITestInterface<I>>;
+
+export type IPartialNodeInterface<I extends IT> = Partial<
+  INodeTestInterface<I>
+>;
+export type IPartialWebInterface<I extends IT> = Partial<IWebTestInterface<I>>;
 
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-export type ITestSpecification<
-  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 IT = Ibdd_in<
+  unknown,
+  unknown,
+  unknown,
+  unknown,
+  unknown,
+  unknown,
+  unknown
+>;
+
+export type OT = Ibdd_out<
+  Record<string, any>,
+  Record<string, any>,
+  Record<string, any>,
+  Record<string, any>,
+  Record<string, any>
+>;
+
+// export type MT<O extends OT> = Partial<{
+//   suites: { [K in keyof O["suites"]]: unknown };
+//   givens: { [K in keyof O["givens"]]: unknown };
+//   whens: { [K in keyof O["whens"]]: unknown };
+//   thens: { [K in keyof O["thens"]]: unknown };
+//   checks: { [K in keyof O["checks"]]: unknown };
+// }>;
+
+export type ITestSpecification<I extends IT, O extends OT> = (
   Suite: {
     [K in keyof O["suites"]]: (
       name: string,
       givens: IGivens<I>,
-      checks: BaseCheck<I, O>[]
+      checks: BaseCheck<I>[]
     ) => BaseSuite<I, O>;
   },
   Given: {
@@ -156,54 +109,44 @@ export type ITestSpecification<
 //////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 export type ITestImplementation<
-  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>
-  >
-> = {
-  suites: {
-    [K in keyof O["suites"]]: string;
-  };
-  givens: {
-    [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
-  };
-  whens: {
-    [K in keyof O["whens"]]: (
-      ...Iw: O["whens"][K]
-    ) => (zel: I["iselection"], utils: PM) => Promise<I["when"]>;
-  };
-  thens: {
-    [K in keyof O["thens"]]: (
-      ...It: O["thens"][K]
-    ) => (ssel: I["iselection"], utils: PM) => I["then"];
-  };
-  checks: {
-    [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
-  };
-};
+  I extends IT,
+  O extends OT,
+  modifier = {}
+> = Modify<
+  {
+    suites: {
+      [K in keyof O["suites"]]: string;
+    };
+    givens: {
+      [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
+    };
+    whens: {
+      [K in keyof O["whens"]]: (
+        ...Iw: O["whens"][K]
+      ) => (zel: I["iselection"], utils: PM) => Promise<I["when"]>;
+    };
+    thens: {
+      [K in keyof O["thens"]]: (
+        ...It: O["thens"][K]
+      ) => (ssel: I["iselection"], utils: PM) => I["then"];
+    };
+    checks: {
+      [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
+    };
+  },
+  modifier
+>;
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
 export type Modify<T, R> = Omit<T, keyof R> & R;
 
 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>
+  ISuites extends Record<string, any> = Record<string, any>,
+  IGivens extends Record<string, any> = Record<string, any>,
+  IWhens extends Record<string, any> = Record<string, any>,
+  IThens extends Record<string, any> = Record<string, any>,
+  IChecks extends Record<string, any> = Record<string, any>
 > = {
   suites: ISuites;
   givens: IGivens;
@@ -229,3 +172,34 @@ export type Ibdd_in<
   when: IWhen;
   then: IThen;
 };
+
+///////////////////////////////////////////////
+
+export type IPluginFactory = (
+  register: (entrypoint: string, sources: string[]) => any,
+  entrypoints: string[]
+) => Plugin;
+
+export type IRunTime = `node` | `web` | "pure";
+
+export type ITestTypes = [string, IRunTime, { ports: number }, ITestTypes[]];
+
+export type ITestconfig = {
+  clearScreen: boolean;
+  debugger: boolean;
+  externals: string[];
+  featureIngestor: (s: string) => Promise<string>;
+  importPlugins: IPluginFactory[];
+  minify: boolean;
+  nodePlugins: IPluginFactory[];
+  ports: string[];
+  src: string;
+  tests: ITestTypes[];
+  webPlugins: IPluginFactory[];
+};
+
+export type IBuiltConfig = { buildDir: string } & ITestconfig;
+
+export type IProject = {
+  projects: Record<string, ITestconfig>;
+};

package/src/Web.ts

@@ -1,15 +1,14 @@
 import { PM_Web } from "./PM/web";
 import type {
-  Ibdd_in,
-  Ibdd_out,
+  IT,
   ITestImplementation,
   ITestInterface,
   ITestSpecification,
   IWebTestInterface,
+  OT,
 } from "./Types";
 import Testeranto from "./lib/core.js";
 import {
-  IFinalResults,
   ITTestResourceConfiguration,
   ITTestResourceRequest,
   defaultTestResourceRequirement,
@@ -22,28 +21,15 @@ let unhandledrejectionCallback = (event: PromiseRejectionEvent) => {
   // throw event;
 };
 
-export class WebTesteranto<
-  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<I, O> {
+export class WebTesteranto<I extends IT, O extends OT, M> extends Testeranto<
+  I,
+  O,
+  M
+> {
   constructor(
     input: I["iinput"],
     testSpecification: ITestSpecification<I, O>,
-    testImplementation: ITestImplementation<I, O>,
+    testImplementation: ITestImplementation<I, O, M>,
     testResourceRequirement: ITTestResourceRequest,
     testInterface: Partial<ITestInterface<I>>
   ) {
@@ -92,39 +78,18 @@ export class WebTesteranto<
   async receiveTestResourceConfig(partialTestResource: any) {
     const t: ITTestResourceConfiguration = partialTestResource; //JSON.parse(partialTestResource);
     const pm = new PM_Web(t);
-    const { failed, artifacts, logPromise, features } =
-      await this.testJobs[0].receiveTestResourceConfig(pm);
-    return new Promise<IFinalResults>((res, rej) => {
-      res({ features, failed });
-    });
+    return await this.testJobs[0].receiveTestResourceConfig(pm);
   }
 }
 
-export default async <
-  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 default async <I extends IT, O extends OT, M>(
   input: I["iinput"],
   testSpecification: ITestSpecification<I, O>,
-  testImplementation: ITestImplementation<I, O>,
+  testImplementation: ITestImplementation<I, O, M>,
   testInterface: Partial<IWebTestInterface<I>>,
   testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement
-): Promise<Testeranto<I, O>> => {
-  return new WebTesteranto<I, O>(
+): Promise<Testeranto<I, O, M>> => {
+  return new WebTesteranto<I, O, M>(
     input,
     testSpecification,
     testImplementation,

package/src/build.ts

@@ -2,20 +2,21 @@ import ansiC from "ansi-colors";
 import fs, { watch } from "fs";
 import path from "path";
 import readline from "readline";
-import { glob } from "glob";
 import esbuild from "esbuild";
 
 import esbuildNodeConfiger from "./esbuildConfigs/node.js";
 import esbuildWebConfiger from "./esbuildConfigs/web.js";
+import esbuildImportConfiger from "./esbuildConfigs/pure.js";
 import webHtmlFrame from "./web.html.js";
+
+import { getRunnables } from "./utils.js";
 import {
-  ITestTypes,
-  IRunnables,
-  IBaseConfig,
-  IRunTime,
+  ITestconfig,
   IBuiltConfig,
-  IConfigV2,
-} from "./lib/index.js";
+  IProject,
+  IRunTime,
+  ITestTypes,
+} from "./Types.js";
 
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY) process.stdin.setRawMode(true);
@@ -31,7 +32,7 @@ if (mode !== "once" && mode !== "dev") {
 console.log("testeranto is building", testName, mode);
 
 import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
-  const bigConfig: IConfigV2 = module.default;
+  const bigConfig: IProject = module.default;
 
   const project = bigConfig.projects[testName];
   if (!project) {
@@ -39,7 +40,7 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     process.exit(-1);
   }
 
-  const rawConfig: IBaseConfig = bigConfig.projects[testName];
+  const rawConfig: ITestconfig = bigConfig.projects[testName];
 
   const getSecondaryEndpointsPoints = (runtime?: IRunTime): string[] => {
     const meta = (ts: ITestTypes[], st: Set<string>): Set<string> => {
@@ -80,10 +81,14 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
   });
   let nodeDone: boolean = false;
   let webDone: boolean = false;
+  let importDone: boolean = false;
 
   let status: "build" | "built" = "build";
 
-  const { nodeEntryPoints, webEntryPoints } = getRunnables(config.tests);
+  const { nodeEntryPoints, webEntryPoints, importEntryPoints } = getRunnables(
+    config.tests,
+    testName
+  );
 
   const onNodeDone = () => {
     nodeDone = true;
@@ -95,11 +100,16 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     onDone();
   };
 
+  const onImportDone = () => {
+    importDone = true;
+    onDone();
+  };
+
   const onDone = async () => {
-    if (nodeDone && webDone) {
+    if (nodeDone && webDone && importDone) {
       status = "built";
     }
-    if (nodeDone && webDone && mode === "once") {
+    if (nodeDone && webDone && importDone && mode === "once") {
       console.log(ansiC.inverse(`${testName} has been built. Goodbye.`));
       process.exit();
     }
@@ -204,73 +214,37 @@ import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
     )
   );
 
-  glob(`${process.cwd()}/testeranto/bundles/${testName}/chunk-*.mjs`, {
-    ignore: "node_modules/**",
-  }).then((chunks) => {
-    chunks.forEach((chunk) => {
-      fs.unlinkSync(chunk);
-    });
-  });
+  // glob(`${process.cwd()}/testeranto/bundles/${testName}/chunk-*.mjs`, {
+  //   ignore: "node_modules/**",
+  // }).then((chunks) => {
+  //   chunks.forEach((chunk) => {
+  //     fs.unlinkSync(chunk);
+  //   });
+  // });
 
   await Promise.all([
-    esbuild
-      .context(
-        esbuildNodeConfiger(config, Object.keys(nodeEntryPoints), testName)
-      )
-      .then(async (nodeContext) => {
-        if (mode === "dev") {
-          await nodeContext.watch().then((v) => {
-            onNodeDone();
-          });
-        } else {
-          nodeContext.rebuild().then((v) => {
-            onNodeDone();
-          });
-        }
-
-        return nodeContext;
-      }),
-    esbuild
-      .context(
-        esbuildWebConfiger(config, Object.keys(webEntryPoints), testName)
-      )
-      .then(async (webContext) => {
-        if (mode === "dev") {
-          await webContext.watch().then((v) => {
-            onWebDone();
-          });
-        } else {
-          webContext.rebuild().then((v) => {
-            onWebDone();
-          });
-        }
-        return webContext;
-      }),
+    ...(
+      [
+        [esbuildImportConfiger, importEntryPoints, onImportDone],
+        [esbuildNodeConfiger, nodeEntryPoints, onNodeDone],
+        [esbuildWebConfiger, webEntryPoints, onWebDone],
+      ] as [(a, b, c) => any, Record<string, string>, () => void][]
+    ).map(([configer, entryPoints, done]) => {
+      esbuild
+        .context(configer(config, Object.keys(entryPoints), testName))
+        .then(async (ctx) => {
+          if (mode === "dev") {
+            await ctx.watch().then((v) => {
+              done();
+            });
+          } else {
+            ctx.rebuild().then((v) => {
+              done();
+            });
+          }
+
+          return ctx;
+        });
+    }),
   ]);
 });
-
-const getRunnables = (
-  tests: ITestTypes[],
-  payload = {
-    nodeEntryPoints: {},
-    webEntryPoints: {},
-  }
-): IRunnables => {
-  return tests.reduce((pt, cv, cndx, cry) => {
-    if (cv[1] === "node") {
-      pt.nodeEntryPoints[cv[0]] = path.resolve(
-        `./docs/node/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
-      );
-    } else if (cv[1] === "web") {
-      pt.webEntryPoints[cv[0]] = path.resolve(
-        `./docs/web/${cv[0].split(".").slice(0, -1).concat("mjs").join(".")}`
-      );
-    }
-
-    if (cv[3].length) {
-      getRunnables(cv[3], payload);
-    }
-
-    return pt;
-  }, payload as IRunnables);
-};

package/src/defaultConfig.ts

@@ -1,18 +1,16 @@
-import { IBaseConfig } from "./lib";
+import { ITestconfig } from "./lib";
 
-const config: IBaseConfig = {
+const config: ITestconfig = {
   src: "src",
-  // outdir: "docs",
   tests: [],
   debugger: true,
   clearScreen: false,
-  devMode: true,
   minify: false,
-  // outbase: ".",
   ports: ["3001"],
   externals: [],
   nodePlugins: [],
   webPlugins: [],
+  importPlugins: [],
   featureIngestor: function (s: string): Promise<string> {
     throw new Error("Function not implemented.");
   },

package/src/esbuildConfigs/index.ts

@@ -1,8 +1,8 @@
 import { BuildOptions } from "esbuild";
 
-import { IBaseConfig } from "../lib";
+import { ITestconfig } from "../lib";
 
-export default (config: IBaseConfig): BuildOptions => {
+export default (config: ITestconfig): BuildOptions => {
   return {
     // packages: "external",
     target: "esnext",

package/src/esbuildConfigs/inputFilesPlugin.ts

@@ -1,5 +1,6 @@
 import fs from "fs";
 import type { Plugin } from "esbuild";
+import { IRunTime } from "../lib";
 
 const otherInputs: Record<string, Set<string>> = {};
 
@@ -11,7 +12,7 @@ const register = (entrypoint: string, sources: string[]): void => {
 };
 
 export default (
-  platform: "web" | "node",
+  platform: IRunTime,
   testName: string
 ): {
   register: (entrypoint: string, sources: string[]) => void;