testeranto 0.113.1 → 0.121.1

package/src/esbuildConfigs/node.ts

@@ -8,18 +8,20 @@ import featuresPlugin from "./featuresPlugin";
 
 export default (
   config: IBaseConfig,
-  entryPoints: Set<string> | string[]
+  entryPoints: Set<string> | string[],
+  testName: string
 ): BuildOptions => {
   const { inputFilesPluginFactory, register } = inputFilesPlugin(
     "node",
-    entryPoints
+    // entryPoints,
+    testName
   );
   return {
     ...baseEsBuildConfig(config),
 
     splitting: true,
 
-    outdir: config.outdir + "/node",
+    outdir: `testeranto/bundles/node/${testName}/`,
 
     // inject: [`./node_modules/testeranto/dist/cjs-shim.js`],
     metafile: true,

package/src/esbuildConfigs/web.ts

@@ -9,17 +9,18 @@ import featuresPlugin from "./featuresPlugin.js";
 
 export default (
   config: IBaseConfig,
-  entryPoints: Set<string> | string[]
+  entryPoints: Set<string> | string[],
+  testName: string
 ): BuildOptions => {
   const { inputFilesPluginFactory, register } = inputFilesPlugin(
     "web",
-    entryPoints
+    testName
   );
 
   return {
     ...baseEsBuildConfig(config),
 
-    outdir: config.outdir + "/web",
+    outdir: `testeranto/bundles/web/${testName}`,
 
     alias: {
       react: path.resolve("./node_modules/react"),

package/src/init-docs.ts

@@ -1,20 +1,7 @@
-import fs from "fs";
 import Init from "./Init";
 
 console.log("Initializing a testeranto project");
 
-if (!process.argv[2]) {
-  console.log("You didn't pass a config file, so I will create one for you.");
+Init();
 
-  fs.writeFileSync(
-    "testeranto.mts",
-    fs.readFileSync("node_modules/testeranto/src/defaultConfig.ts")
-  );
-  import(process.cwd() + "/" + "testeranto.mts").then((module) => {
-    Init(module.default);
-  });
-} else {
-  import(process.cwd() + "/" + process.argv[2]).then((module) => {
-    Init(module.default);
-  });
-}
+console.log("testeranto project initialized");

package/src/lib/abstractBase.ts

@@ -1,9 +1,7 @@
-// import { IBaseTest } from "../Types";
 import { PM } from "../PM/index.js";
+import { Ibdd_in, Ibdd_out } from "../Types.js";
 
 import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
-import { IBaseTest } from "../../dist/types/src/Types.js";
-import { Ibdd_in, Ibdd_out } from "../Types.js";
 
 export type IGivens<
   I extends Ibdd_in<
@@ -72,10 +70,12 @@ export abstract class BaseSuite<
 
   public toObj() {
     const givens = Object.keys(this.givens).map((k) => this.givens[k].toObj());
+    const checks = Object.keys(this.checks).map((k) => this.checks[k].toObj());
 
     return {
       name: this.name,
       givens,
+      checks,
       fails: this.fails,
       features: this.features(),
     };
@@ -106,7 +106,7 @@ export abstract class BaseSuite<
     pm: PM
   ): Promise<BaseSuite<I, O>> {
     this.testResourceConfiguration = testResourceConfiguration;
-    tLog("test resources: ", JSON.stringify(testResourceConfiguration));
+    // tLog("test resources: ", JSON.stringify(testResourceConfiguration));
 
     const suiteArtifactory = (fPath: string, value: unknown) =>
       artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
@@ -116,39 +116,38 @@ export abstract class BaseSuite<
     const sNdx = this.index;
     const sName = this.name;
 
-    for (const [gKey, g] of Object.entries(this.givens)) {
-      // console.log("gKey", gKey);
-      const beforeAllProxy = new Proxy(pm, {
-        get(target, prop, receiver) {
-          if (prop === "customScreenShot") {
-            return (opts, p) =>
-              target.customScreenShot(
-                {
-                  ...opts,
-                  // path: `${filepath}/${opts.path}`,
-                  path: `suite-${sNdx}/beforeAll/${opts.path}`,
-                },
-                p
-              );
-          }
+    const beforeAllProxy = new Proxy(pm, {
+      get(target, prop, receiver) {
+        if (prop === "customScreenShot") {
+          return (opts, p) =>
+            target.customScreenShot(
+              {
+                ...opts,
+                // path: `${filepath}/${opts.path}`,
+                path: `suite-${sNdx}/beforeAll/${opts.path}`,
+              },
+              p
+            );
+        }
 
-          if (prop === "writeFileSync") {
-            return (fp, contents) =>
-              target[prop](`suite-${sNdx}/beforeAll/${fp}`, contents);
-          }
+        if (prop === "writeFileSync") {
+          return (fp, contents) =>
+            target[prop](`suite-${sNdx}/beforeAll/${fp}`, contents);
+        }
 
-          /* @ts-ignore:next-line */
-          return Reflect.get(...arguments);
-        },
-      });
+        /* @ts-ignore:next-line */
+        return Reflect.get(...arguments);
+      },
+    });
 
-      const subject = await this.setup(
-        input,
-        suiteArtifactory,
-        testResourceConfiguration,
-        beforeAllProxy
-      );
+    const subject = await this.setup(
+      input,
+      suiteArtifactory,
+      testResourceConfiguration,
+      beforeAllProxy
+    );
 
+    for (const [gKey, g] of Object.entries(this.givens)) {
       const giver = this.givens[gKey];
       try {
         this.store = await giver.give(
@@ -168,6 +167,18 @@ export abstract class BaseSuite<
       }
     }
 
+    for (const [ndx, thater] of this.checks.entries()) {
+      await thater.check(
+        subject,
+        thater.name,
+        testResourceConfiguration,
+        this.assertThat,
+        suiteArtifactory,
+        tLog,
+        pm
+      );
+    }
+
     try {
       this.afterAll(
         this.store,
@@ -181,18 +192,6 @@ export abstract class BaseSuite<
       // return this;
     }
 
-    // for (const [ndx, thater] of this.checks.entries()) {
-    //   await thater.check(
-    //     subject,
-    //     thater.name,
-    //     testResourceConfiguration,
-    //     this.assertThat,
-    //     suiteArtifactory,
-    //     tLog,
-    //     pm
-    //   );
-    // }
-
     // @TODO fix me
     // for (const k of Object.keys(this.givens)) {
     //   const giver = this.givens[k];
@@ -241,7 +240,6 @@ export abstract class BaseGiven<
     thens: BaseThen<I>[],
     givenCB: I["given"],
     initialValues: any
-    // key: string
   ) {
     this.name = name;
     this.features = features;
@@ -431,7 +429,8 @@ export abstract class BaseGiven<
           afterEachProxy
         );
       } catch (e) {
-        console.error("afterEach failed! no error will be recorded!", e);
+        console.error("afterEach failed!", e);
+        this.error = e.message;
       }
     }
     return this.store;
@@ -481,7 +480,6 @@ export abstract class BaseWhen<
   ) {
     tLog(" When:", this.name);
 
-    const name = this.name;
     const andWhenProxy = new Proxy(pm, {
       get(target, prop, receiver) {
         if (prop === "customScreenShot") {
@@ -540,11 +538,13 @@ export abstract class BaseThen<
 > {
   public name: string;
   thenCB: (storeState: I["iselection"]) => I["then"];
+  go: (storeState: I["iselection"]) => I["then"];
   error: boolean;
 
   constructor(name: string, thenCB: (val: I["iselection"]) => I["then"]) {
     this.name = name;
     this.thenCB = thenCB;
+
     this.error = false;
   }
 
@@ -557,7 +557,7 @@ export abstract class BaseThen<
 
   abstract butThen(
     store: I["istore"],
-    thenCB,
+    thenCB: (s: I["iselection"]) => I["isubject"],
     testResourceConfiguration: ITTestResourceConfiguration,
     pm: PM
   ): Promise<I["iselection"]>;
@@ -569,7 +569,17 @@ export abstract class BaseThen<
     pm: PM,
     filepath: string
   ): Promise<I["then"] | undefined> {
-    tLog(" Then:", this.name);
+    this.go = async (s: I["iselection"]) => {
+      tLog(" Then!!!:", this.name);
+
+      try {
+        await this.thenCB(s);
+      } catch (e) {
+        console.log("test failed", e);
+        this.error = e.message;
+      }
+    };
+
     try {
       const butThenProxy = new Proxy(pm, {
         get(target, prop, receiver) {
@@ -596,7 +606,7 @@ export abstract class BaseThen<
 
       return this.butThen(
         store,
-        this.thenCB,
+        this.go,
         testResourceConfiguration,
         butThenProxy
       ).catch((e) => {
@@ -609,6 +619,8 @@ export abstract class BaseThen<
       throw e;
     }
   }
+
+  check() {}
 }
 
 export abstract class BaseCheck<
@@ -629,44 +641,74 @@ export abstract class BaseCheck<
     Record<string, any>
   >
 > {
+  key: string;
   name: string;
   features: string[];
-  checkCB: (whens, thens) => any;
-  whens: {
-    [K in keyof O["whens"]]: (p, tc) => BaseWhen<I>;
-  };
-  thens: {
-    [K in keyof O["thens"]]: (p, tc) => BaseThen<I>;
-  };
+  checkCB: (store: I["istore"], pm: PM) => any;
+  initialValues: any;
+  store: I["istore"];
+  // whens: {
+  //   [K in keyof O["whens"]]: (p, tc) => BaseWhen<I>;
+  // };
+  // thens: {
+  //   [K in keyof O["thens"]]: (p, tc) => BaseThen<I>;
+  // };
+  checker: any;
 
   constructor(
     name: string,
     features: string[],
-    checkCB: (whens, thens) => any,
-    whens,
-    thens
+    checker: (store: I["istore"], pm: PM) => any,
+    x: any,
+    checkCB: any
   ) {
     this.name = name;
     this.features = features;
     this.checkCB = checkCB;
-    this.whens = whens;
-    this.thens = thens;
+    this.checker = checker;
   }
 
   abstract checkThat(
     subject: I["isubject"],
     testResourceConfiguration,
     artifactory: ITestArtifactory,
+    initializer,
+    initialValues,
     pm: PM
   ): Promise<I["istore"]>;
 
+  toObj() {
+    return {
+      key: this.key,
+      name: this.name,
+      functionAsString: this.checkCB.toString(),
+      // thens: this.thens.map((t) => t.toObj()),
+      // error: this.error ? [this.error, this.error.stack] : null,
+      // fail: this.fail ? [this.fail] : false,
+      features: this.features,
+    };
+  }
+
   async afterEach(
     store: I["istore"],
     key: string,
-    cb,
+    artifactory: ITestArtifactory,
     pm: PM
   ): Promise<unknown> {
-    return;
+    return store;
+  }
+
+  beforeAll(
+    store: I["istore"],
+    // artifactory: ITestArtifactory
+    // subject,
+    initializer,
+    artifactory,
+    testResource,
+    initialValues,
+    pm
+  ) {
+    return store;
   }
 
   async check(
@@ -678,41 +720,19 @@ export abstract class BaseCheck<
     tLog: ITLog,
     pm: PM
   ) {
+    this.key = key;
     tLog(`\n Check: ${this.name}`);
-    const store = await this.checkThat(
+    this.store = await this.checkThat(
       subject,
       testResourceConfiguration,
       artifactory,
+      this.checkCB,
+      this.initialValues,
       pm
     );
-    await this.checkCB(
-      Object.entries(this.whens).reduce((a, [key, when]) => {
-        a[key] = async (payload) => {
-          return await when(payload, testResourceConfiguration).test(
-            store,
-            testResourceConfiguration,
-            tLog,
-            pm,
-            "x"
-          );
-        };
-        return a;
-      }, {}),
-      Object.entries(this.thens).reduce((a, [key, then]) => {
-        a[key] = async (payload) => {
-          const t = await then(payload, testResourceConfiguration).test(
-            store,
-            testResourceConfiguration,
-            tLog,
-            pm
-          );
-          tester(t);
-        };
-        return a;
-      }, {})
-    );
 
-    await this.afterEach(store, key, () => {}, pm);
+    await this.checker(this.store, pm);
+
     return;
   }
 }

package/src/lib/basebuilder.ts

@@ -58,7 +58,7 @@ export abstract class BaseBuilder<
   puppetMaster: PM;
 
   constructor(
-    public readonly input: I["iinput"],
+    input: I["iinput"],
     suitesOverrides: Record<keyof SuiteExtensions, ISuiteKlasser<I, O>>,
     givenOverides: Record<keyof GivenExtensions, IGivenKlasser<I>>,
     whenOverides: Record<keyof WhenExtensions, IWhenKlasser<I>>,
@@ -142,7 +142,7 @@ export abstract class BaseBuilder<
           puppetMaster.writeFileSync(
             `littleBoard.html`,
             `
-            <!DOCTYPE html>
+<!DOCTYPE html>
 <html lang="en">
 
 <head>
@@ -152,15 +152,14 @@ export abstract class BaseBuilder<
   <meta name="viewport" content="width=device-width, initial-scale=1" />
   <meta name="author" content="" />
 
-  <link rel="stylesheet" href="/kokomoBay/docs/TestReport.css" />
-  <script src="/kokomoBay/docs/TestReport.js"></script>
+  <link rel="stylesheet" href="/kokomoBay/testeranto/TestReport.css" />
+  <script src="/kokomoBay/testeranto/TestReport.js"></script>
 
 </head>
 
-  <body>
-    <h1>Test report</h1>
-            <div id="root"/>
-  </body>
+<body>
+  <div id="root"/>
+</body>
             `
           );
 
@@ -218,7 +217,7 @@ export abstract class BaseBuilder<
     keyof CheckExtensions,
     (
       feature: string,
-      callback: (whens, thens) => any,
+      callback: (whens, thens, pm: PM) => any,
       whens,
       thens,
       x

package/src/lib/classBuilder.ts

@@ -14,6 +14,7 @@ import {
   ICheckKlasser,
 } from "./types.js";
 import { ITTestResourceRequest } from "./index.js";
+import { BaseCheck } from "./abstractBase.js";
 
 export abstract class ClassBuilder<
   I extends Ibdd_in<
@@ -61,14 +62,15 @@ export abstract class ClassBuilder<
 
     const classyGivens = Object.entries(testImplementation.givens).reduce(
       (a, [key, g]) => {
-        a[key] = (features, whens, thens, givEn) => {
+        a[key] = (features, whens, thens) => {
+          // console.log("givEn", givEn.toString());
           return new givenKlasser.prototype.constructor(
             key,
             features,
             whens,
             thens,
-            testImplementation.givens[key],
-            givEn
+            testImplementation.givens[key]
+            // givEn
           );
         };
         return a;
@@ -103,19 +105,18 @@ export abstract class ClassBuilder<
     );
 
     const classyChecks = Object.entries(testImplementation.checks).reduce(
-      (a, [key, z]) => {
-        a[key] = (somestring, features, callback) => {
+      (a, [key, chEck]) => {
+        a[key] = (name, features, checker) => {
           return new checkKlasser.prototype.constructor(
-            somestring,
+            key,
             features,
-            callback,
-            classyWhens,
-            classyThens
+            chEck,
+            checker
           );
         };
         return a;
       },
-      {}
+      {} as Record<string, (n, f, c) => BaseCheck<I, O>>
     );
 
     super(

package/src/lib/core.ts

@@ -111,7 +111,6 @@ export default abstract class Testeranto<
           return fullTestInterface.beforeEach(
             subject,
             initializer,
-            // artifactory,
             testResource,
             initialValues,
             pm
@@ -125,17 +124,10 @@ export default abstract class Testeranto<
           pm
         ): Promise<unknown> {
           return new Promise((res) =>
-            res(
-              fullTestInterface.afterEach(
-                store,
-                key,
-                // (fPath: string, value: unknown) =>
-                //   artifactory(`after/${fPath}`, value),
-                pm
-              )
-            )
+            res(fullTestInterface.afterEach(store, key, pm))
           );
         }
+        s;
       } as any,
 
       class When extends BaseWhen<I> {
@@ -213,23 +205,28 @@ export default abstract class Testeranto<
         constructor(
           name: string,
           features: string[],
-          checkCallback: (a, b) => any,
+          checkCallback: (s: I["istore"], pm: PM) => any,
           whens,
           thens,
           initialValues: any
         ) {
-          super(name, features, checkCallback, whens, thens);
+          super(name, features, whens, thens, checkCallback, initialValues);
           this.initialValues = initialValues;
         }
 
-        async checkThat(subject, testResourceConfiguration, artifactory, pm) {
+        async checkThat(
+          subject,
+          testResourceConfiguration,
+          artifactory,
+          initializer,
+          initialValues,
+          pm
+        ) {
           return fullTestInterface.beforeEach(
             subject,
-            this.initialValues,
-            // (fPath: string, value: unknown) =>
-            //   artifactory(`before/${fPath}`, value),
+            initializer,
             testResourceConfiguration,
-            this.initialValues,
+            initialValues,
             pm
           );
         }
@@ -241,16 +238,7 @@ export default abstract class Testeranto<
           pm
         ): Promise<unknown> {
           return new Promise((res) =>
-            res(
-              fullTestInterface.afterEach(
-                store,
-                key,
-                // (fPath: string, value: unknown) =>
-                //   // TODO does not work?
-                //   artifactory(`afterEach2-${this.name}/${fPath}`, value),
-                pm
-              )
-            )
+            res(fullTestInterface.afterEach(store, key, pm))
           );
         }
       } as any,

package/src/lib/index.ts

@@ -1,4 +1,3 @@
-import { IBaseTest } from "../../dist/types/src/Types.js";
 import { PM } from "../PM/index.js";
 import { Ibdd_in, Ibdd_out, ITestInterface } from "../Types.js";
 
@@ -39,8 +38,12 @@ export const BaseTestInterface: ITestInterface<
       unknown,
       unknown
     >["istore"],
-    thenCb
-  ) => thenCb(store),
+    thenCb: any
+  ) => {
+    try {
+      thenCb(store);
+    } catch (e) {}
+  },
   andWhen: (a) => a,
   assertThis: () => null,
 };
@@ -159,11 +162,11 @@ export type IBaseConfig = {
   src: string;
   clearScreen: boolean;
   debugger: boolean;
-  devMode: boolean;
+  // devMode: boolean;
   externals: string[];
   minify: boolean;
-  outbase: string;
-  outdir: string;
+  // outbase: string;
+  // outdir: string;
   ports: string[];
   tests: ITestTypes[];
 
@@ -174,3 +177,7 @@ export type IBaseConfig = {
 };
 
 export type IBuiltConfig = { buildDir: string } & IBaseConfig;
+
+export type IConfigV2 = {
+  projects: Record<string, IBaseConfig>;
+};

package/src/lib/types.ts

@@ -1,3 +1,4 @@
+import { PM } from "../PM";
 import { Ibdd_in, Ibdd_out } from "../Types";
 
 import {
@@ -30,14 +31,8 @@ export type ITestCheckCallback<
   [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>;
 };