testeranto 0.94.0 → 0.110.0

package/src/lib/basebuilder.ts

@@ -1,7 +1,7 @@
 import { PassThrough } from "stream";
 
 import { ITTestResourceRequest, ITestJob, ITLog } from ".";
-import { IBaseTest, ITestSpecification } from "../Types.js";
+import { Ibdd_in, Ibdd_out, ITestSpecification } from "../Types.js";
 
 import {
   ISuiteKlasser,
@@ -20,14 +20,16 @@ import {
 import { PM } from "../PM/index.js";
 
 export abstract class BaseBuilder<
-  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>,
@@ -42,26 +44,26 @@ export abstract class BaseBuilder<
 > {
   specs: any;
 
-  assertThis: (t: ITestShape["then"]) => {};
+  assertThis: (t: I["then"]) => {};
 
   testResourceRequirement: ITTestResourceRequest;
   artifacts: Promise<unknown>[] = [];
   testJobs: ITestJob[];
-  testSpecification: ITestSpecification<ITestShape>;
-  suitesOverrides: Record<keyof SuiteExtensions, ISuiteKlasser<ITestShape>>;
-  givenOverides: Record<keyof GivenExtensions, IGivenKlasser<ITestShape>>;
-  whenOverides: Record<keyof WhenExtensions, IWhenKlasser<ITestShape>>;
-  thenOverides: Record<keyof ThenExtensions, IThenKlasser<ITestShape>>;
-  checkOverides: Record<keyof CheckExtensions, ICheckKlasser<ITestShape>>;
+  testSpecification: ITestSpecification<I, O>;
+  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>>;
   puppetMaster: PM;
 
   constructor(
-    public readonly input: ITestShape["iinput"],
-    suitesOverrides: Record<keyof SuiteExtensions, ISuiteKlasser<ITestShape>>,
-    givenOverides: Record<keyof GivenExtensions, IGivenKlasser<ITestShape>>,
-    whenOverides: Record<keyof WhenExtensions, IWhenKlasser<ITestShape>>,
-    thenOverides: Record<keyof ThenExtensions, IThenKlasser<ITestShape>>,
-    checkOverides: Record<keyof CheckExtensions, ICheckKlasser<ITestShape>>,
+    public readonly 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>>,
     testResourceRequirement: ITTestResourceRequest,
     testSpecification: any
   ) {
@@ -82,13 +84,10 @@ export abstract class BaseBuilder<
       this.Check()
     );
 
-    this.testJobs = this.specs.map((suite: BaseSuite<ITestShape>) => {
+    this.testJobs = this.specs.map((suite: BaseSuite<I, O>) => {
       const suiteRunner =
-        (suite: BaseSuite<ITestShape>) =>
-        async (
-          puppetMaster: PM,
-          tLog: ITLog
-        ): Promise<BaseSuite<ITestShape>> => {
+        (suite: BaseSuite<I, O>) =>
+        async (puppetMaster: PM, tLog: ITLog): Promise<BaseSuite<I, O>> => {
           const x = await suite.run(
             input,
             puppetMaster.testResourceConfiguration,
@@ -124,10 +123,7 @@ export abstract class BaseBuilder<
             puppetMaster.write(access, `${l.toString()}\n`);
           };
 
-          const suiteDone: BaseSuite<ITestShape> = await runner(
-            puppetMaster,
-            tLog
-          );
+          const suiteDone: BaseSuite<I, O> = await runner(puppetMaster, tLog);
 
           const logPromise = new Promise((res, rej) => {
             puppetMaster.end(access);
@@ -137,22 +133,41 @@ export abstract class BaseBuilder<
           const numberOfFailures = Object.keys(suiteDone.givens).filter((k) => {
             return suiteDone.givens[k].error;
           }).length;
-          puppetMaster.writeFileSync(`exitcode`, numberOfFailures.toString());
+          puppetMaster.writeFileSync(
+            `bdd_errors.txt`,
+            numberOfFailures.toString()
+          );
 
-          // if (numberOfFailures > 0) {
-          //   puppetMaster.writeFileSync(
-          //     `prompt`,
-          //     `
-          //     aider --message "make a script that prints hello" hello.js
-          //     `
-          //   );
-          // }
+          const o = this.toObj();
+          puppetMaster.writeFileSync(
+            `littleBoard.html`,
+            `
+            <!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta name="description" content="Webpage description goes here" />
+  <meta charset="utf-8" />
+  <title>kokomoBay - testeranto</title>
+  <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>
+
+</head>
+
+  <body>
+    <h1>Test report</h1>
+            <div id="root"/>
+  </body>
+            `
+          );
 
           puppetMaster.writeFileSync(
             `tests.json`,
             JSON.stringify(this.toObj(), null, 2)
           );
-          // console.log(`exiting gracefully with ${numberOfFailures} failures.`);
 
           return {
             failed: numberOfFailures,
@@ -177,27 +192,24 @@ export abstract class BaseBuilder<
     (
       name: string,
       features: string[],
-      whens: BaseWhen<ITestShape>[],
-      thens: BaseThen<ITestShape>[],
+      whens: BaseWhen<I>[],
+      thens: BaseThen<I>[],
       gcb
-    ) => BaseGiven<ITestShape>
+    ) => BaseGiven<I>
   > {
     return this.givenOverides;
   }
 
   When(): Record<
     keyof WhenExtensions,
-    (arg0: ITestShape["istore"], ...arg1: any) => BaseWhen<ITestShape>
+    (arg0: I["istore"], ...arg1: any) => BaseWhen<I>
   > {
     return this.whenOverides;
   }
 
   Then(): Record<
     keyof ThenExtensions,
-    (
-      selection: ITestShape["iselection"],
-      expectation: any
-    ) => BaseThen<ITestShape>
+    (selection: I["iselection"], expectation: any) => BaseThen<I>
   > {
     return this.thenOverides;
   }
@@ -210,7 +222,7 @@ export abstract class BaseBuilder<
       whens,
       thens,
       x
-    ) => BaseCheck<ITestShape>
+    ) => BaseCheck<I, O>
   > {
     return this.checkOverides;
   }

package/src/lib/classBuilder.ts

@@ -1,11 +1,11 @@
 import {
-  IBaseTest,
+  Ibdd_in,
+  Ibdd_out,
   ITestImplementation,
   ITestSpecification,
 } from "../Types.js";
 
 import { BaseBuilder } from "./basebuilder.js";
-
 import {
   ISuiteKlasser,
   IGivenKlasser,
@@ -13,34 +13,35 @@ import {
   IThenKlasser,
   ICheckKlasser,
 } from "./types.js";
-import { PM } from "../PM/index.js";
 import { ITTestResourceRequest } from "./index.js";
 
 export abstract class ClassBuilder<
-  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>
   >
-> extends BaseBuilder<ITestShape, any, any, any, any, any> {
+> extends BaseBuilder<I, O, any, any, any, any, any> {
   constructor(
-    testImplementation: ITestImplementation<ITestShape, any>,
-    testSpecification: ITestSpecification<ITestShape>,
-    input: ITestShape["iinput"],
-    suiteKlasser: ISuiteKlasser<ITestShape>,
-    givenKlasser: IGivenKlasser<ITestShape>,
-    whenKlasser: IWhenKlasser<ITestShape>,
-    thenKlasser: IThenKlasser<ITestShape>,
-    checkKlasser: ICheckKlasser<ITestShape>,
+    testImplementation: ITestImplementation<I, O>,
+    testSpecification: ITestSpecification<I, O>,
+    input: I["iinput"],
+    suiteKlasser: ISuiteKlasser<I, O>,
+    givenKlasser: IGivenKlasser<I>,
+    whenKlasser: IWhenKlasser<I>,
+    thenKlasser: IThenKlasser<I>,
+    checkKlasser: ICheckKlasser<I, O>,
     testResourceRequirement: ITTestResourceRequest
   ) {
     const classySuites = Object.entries(testImplementation.suites).reduce(
@@ -126,7 +127,6 @@ export abstract class ClassBuilder<
       classyChecks,
       testResourceRequirement,
       testSpecification
-      // puppetMaster
     );
   }
 }

package/src/lib/core.ts

@@ -1,13 +1,16 @@
 import { IStore } from "../SubPackages/react/jsx";
 import {
-  IBaseTest,
   ITestSpecification,
   ITestImplementation,
+  ITestInterface,
+  Ibdd_in,
+  Ibdd_out,
 } from "../Types.js";
+import { PM } from "../PM/index";
 
-import { IFinalResults, ITestInterface } from "./types.js";
 import {
   DefaultTestInterface,
+  IFinalResults,
   ITTestResourceRequest,
   ITestArtifactory,
   defaultTestResourceRequirement,
@@ -20,30 +23,31 @@ import {
   BaseCheck,
 } from "./abstractBase.js";
 import { ClassBuilder } from "./classBuilder.js";
-import { PM } from "../PM/index";
 
 export default abstract class Testeranto<
-  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>
   >
-> extends ClassBuilder<ITestShape> {
+> extends ClassBuilder<I, O> {
   constructor(
-    input: ITestShape["iinput"],
-    testSpecification: ITestSpecification<ITestShape>,
-    testImplementation: ITestImplementation<ITestShape>,
+    input: I["iinput"],
+    testSpecification: ITestSpecification<I, O>,
+    testImplementation: ITestImplementation<I, O>,
     testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement,
-    testInterface: Partial<ITestInterface<ITestShape>>,
+    testInterface: Partial<ITestInterface<I>>,
     uberCatcher: (cb) => void
   ) {
     const fullTestInterface = DefaultTestInterface(testInterface);
@@ -53,15 +57,15 @@ export default abstract class Testeranto<
       testSpecification,
       input,
 
-      class extends BaseSuite<ITestShape> {
+      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);
-              },
+            // (fPath: string, value: unknown) =>
+            //   // TODO does not work?
+            //   {
+            //     artifactory(`afterAll4-${this.name}/${fPath}`, value);
+            //   },
             pm
           );
         }
@@ -71,24 +75,29 @@ export default abstract class Testeranto<
         }
 
         async setup(
-          s: ITestShape["iinput"],
+          s: I["iinput"],
           artifactory: ITestArtifactory,
           tr,
           pm
-        ): Promise<ITestShape["isubject"]> {
+        ): Promise<I["isubject"]> {
           return (
             fullTestInterface.beforeAll ||
             (async (
-              input: ITestShape["iinput"],
+              input: I["iinput"],
               artifactory: ITestArtifactory,
               tr,
               pm: PM
             ) => input as any)
-          )(s, this.testResourceConfiguration, artifactory, pm);
+          )(
+            s,
+            this.testResourceConfiguration,
+            // artifactory,
+            pm
+          );
         }
       } as any,
 
-      class Given extends BaseGiven<ITestShape> {
+      class Given extends BaseGiven<I> {
         uberCatcher = uberCatcher;
 
         async givenThat(
@@ -102,7 +111,7 @@ export default abstract class Testeranto<
           return fullTestInterface.beforeEach(
             subject,
             initializer,
-            artifactory,
+            // artifactory,
             testResource,
             initialValues,
             pm
@@ -110,7 +119,7 @@ export default abstract class Testeranto<
         }
 
         afterEach(
-          store: ITestShape["istore"],
+          store: I["istore"],
           key: string,
           artifactory,
           pm
@@ -120,8 +129,8 @@ export default abstract class Testeranto<
               fullTestInterface.afterEach(
                 store,
                 key,
-                (fPath: string, value: unknown) =>
-                  artifactory(`after/${fPath}`, value),
+                // (fPath: string, value: unknown) =>
+                //   artifactory(`after/${fPath}`, value),
                 pm
               )
             )
@@ -129,7 +138,7 @@ export default abstract class Testeranto<
         }
       } as any,
 
-      class When extends BaseWhen<ITestShape> {
+      class When extends BaseWhen<I> {
         async andWhen(store, whenCB, testResource, pm) {
           try {
             return await fullTestInterface.andWhen(
@@ -158,13 +167,13 @@ export default abstract class Testeranto<
         }
       } as any,
 
-      class Then extends BaseThen<ITestShape> {
+      class Then extends BaseThen<I> {
         async butThen(
           store: any,
           thenCB,
           testResource: any,
           pm: PM
-        ): Promise<ITestShape["iselection"]> {
+        ): Promise<I["iselection"]> {
           return await fullTestInterface
             .butThen(store, thenCB, testResource, pm)
             .then(
@@ -198,7 +207,7 @@ export default abstract class Testeranto<
         }
       } as any,
 
-      class Check extends BaseCheck<ITestShape> {
+      class Check extends BaseCheck<I, O> {
         initialValues: any;
 
         constructor(
@@ -217,8 +226,8 @@ export default abstract class Testeranto<
           return fullTestInterface.beforeEach(
             subject,
             this.initialValues,
-            (fPath: string, value: unknown) =>
-              artifactory(`before/${fPath}`, value),
+            // (fPath: string, value: unknown) =>
+            //   artifactory(`before/${fPath}`, value),
             testResourceConfiguration,
             this.initialValues,
             pm
@@ -226,7 +235,7 @@ export default abstract class Testeranto<
         }
 
         afterEach(
-          store: ITestShape["istore"],
+          store: I["istore"],
           key: string,
           artifactory,
           pm
@@ -236,9 +245,9 @@ export default abstract class Testeranto<
               fullTestInterface.afterEach(
                 store,
                 key,
-                (fPath: string, value: unknown) =>
-                  // TODO does not work?
-                  artifactory(`afterEach2-${this.name}/${fPath}`, value),
+                // (fPath: string, value: unknown) =>
+                //   // TODO does not work?
+                //   artifactory(`afterEach2-${this.name}/${fPath}`, value),
                 pm
               )
             )

package/src/lib/index.ts

@@ -1,32 +1,11 @@
+import { IBaseTest } from "../../dist/types/src/Types.js";
 import { PM } from "../PM/index.js";
-import { IBaseTest } from "../Types.js";
+import { Ibdd_in, Ibdd_out, ITestInterface } from "../Types.js";
 
-import {
-  IGivens,
-  BaseCheck,
-  BaseSuite,
-  BaseWhen,
-  BaseThen,
-} from "./abstractBase.js";
-import { ITestInterface } from "./types.js";
-
-// import { INodeUtils, ITestInterface, IUtils, IWebUtils } from "./types.js";
+import { IGivens, BaseCheck, BaseSuite } from "./abstractBase.js";
 
 export const BaseTestInterface: ITestInterface<
-  IBaseTest<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
-  >
+  Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>
 > = {
   beforeAll: async (s) => s,
   beforeEach: async function (
@@ -40,35 +19,25 @@ export const BaseTestInterface: ITestInterface<
   },
   afterEach: async (s) => s,
   afterAll: (
-    store: IBaseTest<
-      unknown,
+    store: Ibdd_in<
       unknown,
       unknown,
       unknown,
       unknown,
       unknown,
       unknown,
-      Record<string, any>,
-      Record<string, any>,
-      Record<string, any>,
-      Record<string, any>,
-      Record<string, any>
+      unknown
     >["istore"]
   ) => undefined,
   butThen: async (
-    store: IBaseTest<
-      unknown,
+    store: Ibdd_in<
       unknown,
       unknown,
       unknown,
       unknown,
       unknown,
       unknown,
-      Record<string, any>,
-      Record<string, any>,
-      Record<string, any>,
-      Record<string, any>,
-      Record<string, any>
+      unknown
     >["istore"],
     thenCb
   ) => thenCb(store),
@@ -120,30 +89,11 @@ type ITest = {
   toObj(): object;
   name: string;
   givens: IGivens<
-    IBaseTest<
-      unknown,
-      unknown,
-      unknown,
-      unknown,
-      unknown,
-      unknown,
-      unknown,
-      Record<string, any>,
-      Record<string, any>,
-      Record<string, any>,
-      Record<string, any>,
-      Record<string, any>
-    >
+    Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>
   >;
   checks: BaseCheck<
-    IBaseTest<
-      unknown,
-      unknown,
-      unknown,
-      unknown,
-      unknown,
-      unknown,
-      unknown,
+    Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>,
+    Ibdd_out<
       Record<string, any>,
       Record<string, any>,
       Record<string, any>,
@@ -162,14 +112,8 @@ export type ITestJob<T = PM> = {
     t: ITLog
   ) => Promise<
     BaseSuite<
-      IBaseTest<
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
-        unknown,
+      Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>,
+      Ibdd_out<
         Record<string, any>,
         Record<string, any>,
         Record<string, any>,
@@ -195,33 +139,38 @@ export const defaultTestResourceRequirement: ITTestResourceRequest = {
 
 export type ITestArtifactory = (key: string, value: unknown) => unknown;
 
-export type ITestCheckCallback<
-  ITestShape extends IBaseTest<
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    unknown,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>,
-    Record<string, any>
-  >
-> = {
-  [K in keyof ITestShape["checks"]]: (
-    name: string,
-    features: string[],
-    callbackA: (
-      whens: {
-        [K in keyof ITestShape["whens"]]: (...unknown) => BaseWhen<ITestShape>;
-      },
-      thens: {
-        [K in keyof ITestShape["thens"]]: (...unknown) => BaseThen<ITestShape>;
-      }
-    ) => Promise<any>,
-    ...xtrasA: ITestShape["checks"][K]
-  ) => BaseCheck<ITestShape>;
+export type IRunnables = {
+  nodeEntryPoints: Record<string, string>;
+  webEntryPoints: 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 IBuiltConfig = { buildDir: string } & IBaseConfig;

package/src/lib/readme.md

@@ -0,0 +1,12 @@
+# lib
+
+This folder represents testeranto internals.
+
+## layers
+
+Testeranto's core architecture is built in layers.
+
+0. abstractBase.ts - The lowest layer is composed of abstract BDD classes
+1. baseBuilder.ts - this layer extends the classes in `abstractBase` with the capacity to run and log tests.
+2. classBuilder.ts - this layer extends the classes in `baseBuilder` with the capacity to accept custom implementations of of abstract BDD classes in `abstractBase`
+3. core.ts - this layer extends the classes in `classBuilder` with the capacity to accept an input, a specification, a implementation a test resource requirement and an interface, and to map those entities to custom implementations of of abstract BDD classes in `abstractBase`.