testeranto 0.94.0 → 0.110.0

package/src/Types.ts

@@ -1,4 +1,4 @@
-import { ITTestResourceRequest, ITestCheckCallback } from "./lib/index.js";
+import { ITTestResourceConfiguration, ITestArtificer } from "./lib/index.js";
 import {
   IGivens,
   BaseCheck,
@@ -7,96 +7,121 @@ 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";
+import { ITestCheckCallback } from "./lib/types.js";
 
-export type IPartialInterface<
-  I extends IBaseTest<
-    unknown,
+export type ITestInterface<
+  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<ITestInterface<I>>;
+> = {
+  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"], pm: PM) => any;
+  afterEach: (store: I["istore"], key: string, pm: PM) => Promise<unknown>;
+  beforeAll: (
+    input: I["iinput"],
+    testResource: ITTestResourceConfiguration,
+    pm: PM
+  ) => Promise<I["isubject"]>;
+  beforeEach: (
+    subject: I["isubject"],
+    initializer: (c?) => I["given"],
+    testResource: ITTestResourceConfiguration,
+    initialValues,
+    pm: PM
+  ) => Promise<I["istore"]>;
+};
 
-export type IPartialNodeInterface<
-  I extends IBaseTest<
-    unknown,
+export type IWebTestInterface<
+  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<INodeTestInterface<I>>;
-export type IPartialWebInterface<
-  I extends IBaseTest<
+> = 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,
-    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 Ibdd_in<
     unknown,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown,
+    unknown
   >
-> = (
-  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,
+  I extends Ibdd_in<
     unknown,
     unknown,
     unknown,
     unknown,
     unknown,
     unknown,
+    unknown
+  >,
+  O extends Ibdd_out<
     Record<string, any>,
     Record<string, any>,
     Record<string, any>,
@@ -105,114 +130,96 @@ export type ITestSpecification<
   >
 > = (
   Suite: {
-    [K in keyof ITestShape["suites"]]: (
+    [K in keyof O["suites"]]: (
       name: string,
-      givens: IGivens<ITestShape>,
-      checks: BaseCheck<ITestShape>[]
-    ) => BaseSuite<ITestShape>;
+      givens: IGivens<I>,
+      checks: BaseCheck<I, O>[]
+    ) => BaseSuite<I, O>;
   },
   Given: {
-    [K in keyof ITestShape["givens"]]: (
+    [K in keyof O["givens"]]: (
       features: string[],
-      whens: BaseWhen<ITestShape>[],
-      thens: BaseThen<ITestShape>[],
-      ...xtrasB: ITestShape["givens"][K]
-    ) => BaseGiven<ITestShape>;
+      whens: BaseWhen<I>[],
+      thens: BaseThen<I>[],
+      ...xtrasB: O["givens"][K]
+    ) => BaseGiven<I>;
   },
   When: {
-    [K in keyof ITestShape["whens"]]: (
-      ...xtrasC: ITestShape["whens"][K]
-    ) => BaseWhen<ITestShape>;
+    [K in keyof O["whens"]]: (...xtrasC: O["whens"][K]) => BaseWhen<I>;
   },
   Then: {
-    [K in keyof ITestShape["thens"]]: (
-      ...xtrasD: ITestShape["thens"][K]
-    ) => BaseThen<ITestShape>;
+    [K in keyof O["thens"]]: (...xtrasD: O["thens"][K]) => BaseThen<I>;
   },
-  Check: ITestCheckCallback<ITestShape>
+  Check: ITestCheckCallback<I, O>
 ) => any[];
 
+//////////////////////////////////////////////////////////////////////////////////////////////////////////////
+
 export type ITestImplementation<
-  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>,
     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;
+  >
+> = {
+  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"];
+  };
+};
 
-// export type IBaseTest<Shape = any, II = Shape> = {
-//   iinput: II;
-//   isubject: Shape;
-//   istore: Shape;
-//   iselection: Shape;
-//   // iinitial;
+////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
 
-//   given;
-//   when;
-//   then;
+export type Modify<T, R> = Omit<T, keyof R> & R;
 
-//   suites: Record<string, any>;
-//   givens: Record<string, any>;
-//   whens: Record<string, any>;
-//   thens: Record<string, any>;
-//   checks: Record<string, any>;
-// };
+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 IBaseTest<
+export type Ibdd_in<
   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>
+  IThen
 > = {
   iinput: IInput;
   isubject: ISubject;
@@ -221,9 +228,4 @@ export type IBaseTest<
   given: IGiven;
   when: IWhen;
   then: IThen;
-  suites: ISuites;
-  givens: IGivens;
-  whens: IWhens;
-  thens: IThens;
-  checks: IChecks;
 };

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,

package/src/build.ts

@@ -0,0 +1,240 @@
+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 webHtmlFrame from "./web.html.js";
+import {
+  ITestTypes,
+  IRunnables,
+  IBaseConfig,
+  IRunTime,
+  IBuiltConfig,
+} from "./lib/index.js";
+
+readline.emitKeypressEvents(process.stdin);
+if (process.stdin.isTTY) process.stdin.setRawMode(true);
+
+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);
+};
+
+import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
+  const rawConfig: IBaseConfig = module.default;
+
+  const getSecondaryEndpointsPoints = (runtime?: IRunTime): string[] => {
+    const meta = (ts: ITestTypes[], st: Set<string>): Set<string> => {
+      ts.forEach((t) => {
+        if (t[1] === runtime) {
+          st.add(t[0]);
+        }
+        if (Array.isArray(t[3])) {
+          meta(t[3], st);
+        }
+      });
+      return st;
+    };
+    return Array.from(meta(config.tests, new Set()));
+  };
+
+  const config: IBuiltConfig = {
+    ...rawConfig,
+    buildDir: process.cwd() + "/" + rawConfig.outdir,
+  };
+
+  let nodeDone: boolean = false;
+  let webDone: boolean = false;
+  let mode = config.devMode ? "DEV" : "PROD";
+  let status: "build" | "built" = "build";
+  // let pm: PM_Main | undefined = new PM_Main(config);
+  // const fileHashes = {};
+  const { nodeEntryPoints, webEntryPoints } = getRunnables(config.tests);
+
+  const onNodeDone = () => {
+    nodeDone = true;
+    onDone();
+  };
+
+  const onWebDone = () => {
+    webDone = true;
+    onDone();
+  };
+
+  const onDone = async () => {
+    if (nodeDone && webDone) {
+      status = "built";
+    }
+    if (nodeDone && webDone && status === "built") {
+      // Object.entries(nodeEntryPoints).forEach(([k, outputFile]) => {
+      //   console.log("watching", outputFile);
+      //   try {
+      //     watch(outputFile, async (filename) => {
+      //       const hash = await fileHash(outputFile);
+      //       if (fileHashes[k] !== hash) {
+      //         fileHashes[k] = hash;
+      //         console.log(`< ${filename} `);
+      //         pm.launchNode(k, outputFile);
+      //       }
+      //     });
+      //   } catch (e) {
+      //     console.error(e);
+      //   }
+      // });
+      // Object.entries(webEntryPoints).forEach(([k, outputFile]) => {
+      //   console.log("watching", outputFile);
+      //   watch(outputFile, async (filename) => {
+      //     const hash = await fileHash(outputFile);
+      //     console.log(`< ${filename} ${hash}`);
+      //     if (fileHashes[k] !== hash) {
+      //       fileHashes[k] = hash;
+      //       pm.launchWeb(k, outputFile);
+      //     }
+      //   });
+      // });
+    }
+
+    if (nodeDone && webDone && mode === "PROD") {
+      console.log("Testeranto-EsBuild is all done. Goodbye!");
+      process.exit();
+    } else {
+      if (mode === "PROD") {
+        console.log("waiting for tests to finish");
+        console.log(
+          JSON.stringify(
+            {
+              nodeDone: nodeDone,
+              webDone: webDone,
+              mode: mode,
+            },
+            null,
+            2
+          )
+        );
+      } else {
+        console.log("waiting for tests to change");
+      }
+
+      if (config.devMode) {
+        console.log("ready and watching for changes...");
+      } else {
+        // pm.shutDown();
+      }
+      ////////////////////////////////////////////////////////////////////////////////
+    }
+  };
+
+  console.log(
+    `Press 'q' to shutdown gracefully. Press 'x' to shutdown forcefully.`
+  );
+  process.stdin.on("keypress", (str, key) => {
+    if (key.name === "q") {
+      console.log("Testeranto-Build is shutting down...");
+      mode = "PROD";
+      onDone();
+    }
+    if (key.name === "x") {
+      console.log("Testeranto-Build is shutting down forcefully...");
+      process.exit(-1);
+    }
+  });
+
+  fs.writeFileSync(
+    `${config.outdir}/testeranto.json`,
+    JSON.stringify(config, null, 2)
+  );
+
+  Promise.resolve(
+    Promise.all(
+      [...getSecondaryEndpointsPoints("web")].map(async (sourceFilePath) => {
+        const sourceFileSplit = sourceFilePath.split("/");
+        const sourceDir = sourceFileSplit.slice(0, -1);
+        const sourceFileName = sourceFileSplit[sourceFileSplit.length - 1];
+        const sourceFileNameMinusJs = sourceFileName
+          .split(".")
+          .slice(0, -1)
+          .join(".");
+
+        const htmlFilePath = path.normalize(
+          `${process.cwd()}/${config.outdir}/web/${sourceDir.join(
+            "/"
+          )}/${sourceFileNameMinusJs}.html`
+        );
+        const jsfilePath = `./${sourceFileNameMinusJs}.mjs`;
+
+        return fs.promises
+          .mkdir(path.dirname(htmlFilePath), { recursive: true })
+          .then((x) =>
+            fs.writeFileSync(
+              htmlFilePath,
+              webHtmlFrame(jsfilePath, htmlFilePath)
+            )
+          );
+      })
+    )
+  );
+
+  glob(`./${config.outdir}/chunk-*.mjs`, {
+    ignore: "node_modules/**",
+  }).then((chunks) => {
+    chunks.forEach((chunk) => {
+      fs.unlinkSync(chunk);
+    });
+  });
+
+  await Promise.all([
+    esbuild
+      .context(esbuildNodeConfiger(config, Object.keys(nodeEntryPoints)))
+      .then(async (nodeContext) => {
+        if (config.devMode) {
+          await nodeContext.watch().then((v) => {
+            onNodeDone();
+          });
+        } else {
+          nodeContext.rebuild().then((v) => {
+            onNodeDone();
+          });
+        }
+
+        return nodeContext;
+      }),
+    esbuild
+      .context(esbuildWebConfiger(config, Object.keys(webEntryPoints)))
+      .then(async (webContext) => {
+        if (config.devMode) {
+          await webContext.watch().then((v) => {
+            onWebDone();
+          });
+        } else {
+          webContext.rebuild().then((v) => {
+            onWebDone();
+          });
+        }
+        return webContext;
+      }),
+  ]);
+});