testeranto 0.114.1 → 0.125.0

package/src/lib/types.ts

@@ -1,4 +1,8 @@
-import { Ibdd_in, Ibdd_out } from "../Types";
+import { PM } from "../PM";
+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,
@@ -9,114 +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[],
-    callbackA: (
-      whens: {
-        [K in keyof O["whens"]]: (...unknown) => BaseWhen<I>;
-      },
-      thens: {
-        [K in keyof O["thens"]]: (...unknown) => BaseThen<I>;
-      }
-    ) => Promise<any>,
+    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

@@ -1,8 +1,9 @@
 import ansiC from "ansi-colors";
 import readline from "readline";
+import path from "path";
 
 import { PM_Main } from "./PM/main";
-import { IBaseConfig, IBuiltConfig } from "./lib";
+import { ITestconfig, IBuiltConfig, IProject } from "./Types";
 
 readline.emitKeypressEvents(process.stdin);
 if (process.stdin.isTTY) process.stdin.setRawMode(true);
@@ -15,15 +16,27 @@ process.stdin.on("keypress", (str, key) => {
   }
 });
 
-import(process.cwd() + "/" + process.argv[2]).then(async (module) => {
-  const rawConfig: IBaseConfig = module.default;
+let testName = process.argv[2];
+
+const mode = process.argv[3] as "once" | "dev";
+if (mode !== "once" && mode !== "dev") {
+  console.error("the 2nd argument should be 'dev' or 'once' ");
+  process.exit(-1);
+}
+
+console.log("testeranto is running", testName, mode);
+
+import(process.cwd() + "/" + "testeranto.config.ts").then(async (module) => {
+  const bigConfig: IProject = module.default;
+
+  const rawConfig: ITestconfig = bigConfig.projects[testName];
 
   const config: IBuiltConfig = {
     ...rawConfig,
-    buildDir: process.cwd() + "/" + rawConfig.outdir,
+    buildDir: process.cwd() + "/" + `testeranto/${testName}.json`,
   };
 
-  const pm = new PM_Main(config);
+  const pm = new PM_Main(config, testName, mode);
   pm.start();
 
   process.stdin.on("keypress", (str, key) => {

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,
@@ -24,74 +25,106 @@ export const destinationOfRuntime = (
     .join(".");
 };
 
-export const tscPather = (entryPoint: string, platform: "web" | "node") => {
+export const tscPather = (
+  entryPoint: string,
+  platform: IRunTime,
+  projectName: string
+) => {
   return path.join(
-    "./docs/",
-    platform,
+    "testeranto",
+    "reports",
+    projectName,
     entryPoint.split(".").slice(0, -1).join("."),
+    platform,
     `type_errors.txt`
   );
 };
 
-export const tscExitCodePather = (
+export const lintPather = (
   entryPoint: string,
-  platform: "web" | "node"
+  platform: IRunTime,
+  projectName: string
 ) => {
   return path.join(
-    "./docs/",
-    platform,
+    "testeranto",
+    "reports",
+    projectName,
     entryPoint.split(".").slice(0, -1).join("."),
-    `type_errors.txt`
-  );
-};
-
-export const lintPather = (entryPoint: string, platform: "web" | "node") => {
-  return path.join(
-    "./docs/",
     platform,
-    entryPoint.split(".").slice(0, -1).join("."),
     `lint_errors.json`
   );
 };
 
-export const lintExitCodePather = (
+export const bddPather = (
   entryPoint: string,
-  platform: "web" | "node"
+  platform: IRunTime,
+  projectName: string
 ) => {
   return path.join(
-    "./docs/",
-    platform,
+    "testeranto",
+    "reports",
+    projectName,
     entryPoint.split(".").slice(0, -1).join("."),
-    `lint_errors.txt`
-  );
-};
-
-export const bddPather = (entryPoint: string, platform: "web" | "node") => {
-  return path.join(
-    "./docs/",
     platform,
-    entryPoint.split(".").slice(0, -1).join("."),
     `tests.json`
   );
 };
 
-export const bddExitCodePather = (
+export const promptPather = (
   entryPoint: string,
-  platform: "web" | "node"
+  platform: IRunTime,
+  projectName: string
 ) => {
   return path.join(
-    "./docs/",
-    platform,
+    "testeranto",
+    "reports",
+    projectName,
     entryPoint.split(".").slice(0, -1).join("."),
-    `bdd_errors.txt`
-  );
-};
-
-export const promptPather = (entryPoint: string, platform: "web" | "node") => {
-  return path.join(
-    "./docs/",
     platform,
-    entryPoint.split(".").slice(0, -1).join("."),
     `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);
+};