testeranto 0.114.1 → 0.125.0

package/src/lib/basebuilder.ts

@@ -1,14 +1,15 @@
 import { PassThrough } from "stream";
 
-import { ITTestResourceRequest, ITestJob, ITLog } from ".";
-import { Ibdd_in, Ibdd_out, ITestSpecification } from "../Types.js";
+import { IT, ITestSpecification, OT } from "../Types.js";
 
+import { ITTestResourceRequest, ITestJob, ITLog, IFinalResults } from ".";
 import {
   ISuiteKlasser,
   IGivenKlasser,
   IWhenKlasser,
   IThenKlasser,
   ICheckKlasser,
+  IPM,
 } from "./types.js";
 import {
   BaseCheck,
@@ -17,25 +18,10 @@ import {
   BaseThen,
   BaseGiven,
 } from "./abstractBase.js";
-import { PM } from "../PM/index.js";
 
 export abstract class BaseBuilder<
-  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>
-  >,
+  I extends IT,
+  O extends OT,
   SuiteExtensions,
   GivenExtensions,
   WhenExtensions,
@@ -54,16 +40,16 @@ export abstract class BaseBuilder<
   givenOverides: Record<keyof GivenExtensions, IGivenKlasser<I>>;
   whenOverides: Record<keyof WhenExtensions, IWhenKlasser<I>>;
   thenOverides: Record<keyof ThenExtensions, IThenKlasser<I>>;
-  checkOverides: Record<keyof CheckExtensions, ICheckKlasser<I, O>>;
-  puppetMaster: PM;
+  checkOverides: Record<keyof CheckExtensions, ICheckKlasser<I>>;
+  puppetMaster: IPM;
 
   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>>,
     thenOverides: Record<keyof ThenExtensions, IThenKlasser<I>>,
-    checkOverides: Record<keyof CheckExtensions, ICheckKlasser<I, O>>,
+    checkOverides: Record<keyof CheckExtensions, ICheckKlasser<I>>,
     testResourceRequirement: ITTestResourceRequest,
     testSpecification: any
   ) {
@@ -87,7 +73,7 @@ export abstract class BaseBuilder<
     this.testJobs = this.specs.map((suite: BaseSuite<I, O>) => {
       const suiteRunner =
         (suite: BaseSuite<I, O>) =>
-        async (puppetMaster: PM, tLog: ITLog): Promise<BaseSuite<I, O>> => {
+        async (puppetMaster: IPM, tLog: ITLog): Promise<BaseSuite<I, O>> => {
           const x = await suite.run(
             input,
             puppetMaster.testResourceConfiguration,
@@ -116,33 +102,39 @@ export abstract class BaseBuilder<
 
         runner,
 
-        receiveTestResourceConfig: async function (puppetMaster: PM) {
+        receiveTestResourceConfig: async function (
+          puppetMaster: IPM
+        ): Promise<IFinalResults> {
+          const start = await puppetMaster.start();
+
           const logFilePath = "log.txt";
-          const access = await puppetMaster.createWriteStream(logFilePath);
-          const tLog = (...l: string[]) => {
-            puppetMaster.write(access, `${l.toString()}\n`);
+          const access: number = await puppetMaster.createWriteStream(
+            logFilePath
+          );
+
+          const tLog = async (...l: string[]) => {
+            const x = await puppetMaster.write(access, `${l.toString()}\n`);
+            // console.log("x", x);
           };
 
           const suiteDone: BaseSuite<I, O> = await runner(puppetMaster, tLog);
 
-          const logPromise = new Promise((res, rej) => {
-            puppetMaster.end(access);
+          const logPromise = new Promise(async (res, rej) => {
+            await puppetMaster.end(access);
             res(true);
           });
 
-          const numberOfFailures = Object.keys(suiteDone.givens).filter((k) => {
-            return suiteDone.givens[k].error;
-          }).length;
-          puppetMaster.writeFileSync(
+          const fails = suiteDone.fails;
+
+          const b = await puppetMaster.writeFileSync(
             `bdd_errors.txt`,
-            numberOfFailures.toString()
+            fails.toString()
           );
 
-          const o = this.toObj();
-          puppetMaster.writeFileSync(
+          await puppetMaster.writeFileSync(
             `littleBoard.html`,
             `
-            <!DOCTYPE html>
+<!DOCTYPE html>
 <html lang="en">
 
 <head>
@@ -152,25 +144,25 @@ 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>
             `
           );
 
-          puppetMaster.writeFileSync(
+          await puppetMaster.writeFileSync(
             `tests.json`,
             JSON.stringify(this.toObj(), null, 2)
           );
 
           return {
-            failed: numberOfFailures,
+            failed: fails > 0,
+            fails,
             artifacts: this.artifacts || [],
             logPromise,
             features: suiteDone.features(),
@@ -180,6 +172,13 @@ export abstract class BaseBuilder<
     });
   }
 
+  // testsJson() {
+  //   puppetMaster.writeFileSync(
+  //     `tests.json`,
+  //     JSON.stringify({ features: suiteDone.features() }, null, 2)
+  //   );
+  // }
+
   Specs() {
     return this.specs;
   }
@@ -218,11 +217,11 @@ export abstract class BaseBuilder<
     keyof CheckExtensions,
     (
       feature: string,
-      callback: (whens, thens) => any,
+      callback: (whens, thens, pm: IPM) => any,
       whens,
       thens,
       x
-    ) => BaseCheck<I, O>
+    ) => BaseCheck<I>
   > {
     return this.checkOverides;
   }

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 {
@@ -14,34 +9,32 @@ import {
   ICheckKlasser,
 } from "./types.js";
 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(
@@ -61,14 +54,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 +97,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>>
     );
 
     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,
@@ -111,7 +89,6 @@ export default abstract class Testeranto<
           return fullTestInterface.beforeEach(
             subject,
             initializer,
-            // artifactory,
             testResource,
             initialValues,
             pm
@@ -125,17 +102,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> {
@@ -150,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,
 
@@ -172,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)
@@ -185,51 +141,37 @@ 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: (a, b) => any,
-          whens,
-          thens,
-          initialValues: any
+          checkCallback: (s: I["istore"], pm: IPM) => any,
+          x,
+          i,
+          c
         ) {
-          super(name, features, checkCallback, whens, thens);
-          this.initialValues = initialValues;
+          super(name, features, checkCallback, x, c);
+          this.initialValues = i;
         }
 
-        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 +183,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,8 +1,21 @@
-import { IBaseTest } from "../../dist/types/src/Types.js";
-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>
@@ -13,7 +26,7 @@ export const BaseTestInterface: ITestInterface<
     initialValues: any,
     x: any,
     testResource: any,
-    pm: PM
+    pm: IPM
   ) {
     return subject as any;
   },
@@ -39,9 +52,13 @@ export const BaseTestInterface: ITestInterface<
       unknown,
       unknown
     >["istore"],
-    thenCb
-  ) => thenCb(store),
-  andWhen: (a) => a,
+    thenCb: any
+  ) => {
+    try {
+      thenCb(store);
+    } catch (e) {}
+  },
+  andWhen: async (a) => a,
   assertThis: () => null,
 };
 
@@ -91,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 }>[];
@@ -139,38 +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 IFinalResults = {
+  features: string[];
+  failed: boolean;
+  fails: number;
+  artifacts: Promise<unknown>[];
+  logPromise: Promise<unknown>;
 };
-
-export type IBuiltConfig = { buildDir: string } & IBaseConfig;