testeranto 0.134.0 → 0.140.0

package/src/lib/abstractBase.ts

@@ -1,174 +1,19 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import type { IT, OT } from "../Types.js";
 
-import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
+import { ITestArtifactory, ITLog, ITTestResourceConfiguration } from ".";
 import { IPM } from "./types.js";
 import {
-  afterAllProxy,
   afterEachProxy,
   andWhenProxy,
-  beforeAllProxy,
   beforeEachProxy,
   butThenProxy,
 } from "./pmProxy.js";
+import type { Ibdd_in_any } from "../CoreTypes";
 
-export type IGivens<I extends IT> = Record<string, BaseGiven<I>>;
+export type IGivens<I extends Ibdd_in_any> = Record<string, BaseGiven<I>>;
 
-export abstract class BaseSuite<I extends IT = IT, O extends OT = OT> {
-  name: string;
-  givens: IGivens<I>;
-  checks: BaseCheck<I>[];
-  store: I["istore"];
-  testResourceConfiguration: ITTestResourceConfiguration;
-  index: number;
-  failed: boolean;
-  fails: number;
-
-  constructor(
-    name: string,
-    index: number,
-    givens: IGivens<I> = {},
-    checks: BaseCheck<I>[] = []
-  ) {
-    this.name = name;
-    this.index = index;
-    this.givens = givens;
-    this.checks = checks;
-    this.fails = 0;
-  }
-
-  public features() {
-    const features = Object.keys(this.givens)
-      .map((k) => this.givens[k].features)
-      .flat()
-      .filter((value, index, array) => {
-        return array.indexOf(value) === index;
-      });
-    return features || [];
-  }
-
-  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,
-      failed: this.failed,
-      features: this.features(),
-    };
-  }
-
-  setup(
-    s: I["iinput"],
-    artifactory: ITestArtifactory,
-    tr: ITTestResourceConfiguration,
-    pm: IPM
-  ): Promise<I["isubject"]> {
-    return new Promise((res) => res(s as unknown as I["isubject"]));
-  }
-
-  assertThat(t: Awaited<I["then"]> | undefined): boolean {
-    return !!t;
-  }
-
-  afterAll(store: I["istore"], artifactory: ITestArtifactory, pm: IPM) {
-    return store;
-  }
-
-  async run(
-    input: I["iinput"],
-    testResourceConfiguration: ITTestResourceConfiguration,
-    artifactory: (fPath: string, value: unknown) => void,
-    tLog: (...string) => void,
-    pm: IPM
-  ): Promise<BaseSuite<I, O>> {
-    this.testResourceConfiguration = testResourceConfiguration;
-    // tLog("test resources: ", JSON.stringify(testResourceConfiguration));
-
-    const suiteArtifactory = (fPath: string, value: unknown) =>
-      artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
-
-    // console.log("\nSuite:", this.index, this.name);
-    tLog("\nSuite:", this.index, this.name);
-    const sNdx = this.index;
-    // const sName = this.name;
-
-    const subject = await this.setup(
-      input,
-      suiteArtifactory,
-      testResourceConfiguration,
-      beforeAllProxy(pm, sNdx.toString())
-    );
-
-    for (const [gKey, g] of Object.entries(this.givens)) {
-      const giver = this.givens[gKey];
-      try {
-        this.store = await giver.give(
-          subject,
-          gKey,
-          testResourceConfiguration,
-          this.assertThat,
-          suiteArtifactory,
-          tLog,
-          pm,
-          sNdx
-        );
-      } catch (e) {
-        this.failed = true;
-        this.fails = this.fails + 1;
-        console.error(e);
-        // this.fails.push(giver);
-        // return this;
-      }
-    }
-
-    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,
-        artifactory,
-        afterAllProxy(pm, sNdx.toString())
-      );
-    } catch (e) {
-      console.error(e);
-      // this.fails.push(this);
-      // return this;
-    }
-
-    // @TODO fix me
-    // for (const k of Object.keys(this.givens)) {
-    //   const giver = this.givens[k];
-
-    //   try {
-    //     giver.afterAll(this.store, artifactory, pm);
-    //   } catch (e) {
-    //     console.error(e);
-    //     this.fails.push(giver);
-    //     return this;
-    //   }
-    // }
-    ////////////////
-
-    return this;
-  }
-}
-
-export abstract class BaseGiven<I extends IT = IT> {
+export abstract class BaseGiven<I extends Ibdd_in_any> {
   name: string;
   features: string[];
   whens: BaseWhen<I>[];
@@ -206,7 +51,12 @@ export abstract class BaseGiven<I extends IT = IT> {
     return {
       key: this.key,
       name: this.name,
-      whens: this.whens.map((w) => w.toObj()),
+      whens: this.whens.map((w) => {
+        if (w && w.toObj) return w.toObj();
+
+        console.error("w is not as expected!", w);
+        return {};
+      }),
       thens: this.thens.map((t) => t.toObj()),
       error: this.error ? [this.error, this.error.stack] : null,
       failed: this.failed,
@@ -324,7 +174,7 @@ export abstract class BaseGiven<I extends IT = IT> {
   }
 }
 
-export abstract class BaseWhen<I extends IT> {
+export abstract class BaseWhen<I extends Ibdd_in_any> {
   public name: string;
   whenCB: (x: I["iselection"]) => I["then"];
   error: Error;
@@ -371,7 +221,7 @@ export abstract class BaseWhen<I extends IT> {
   }
 }
 
-export abstract class BaseThen<I extends IT> {
+export abstract class BaseThen<I extends Ibdd_in_any> {
   public name: string;
   thenCB: (storeState: I["iselection"]) => Promise<I["then"]>;
   error: boolean;
@@ -430,7 +280,7 @@ export abstract class BaseThen<I extends IT> {
   check() {}
 }
 
-export abstract class BaseCheck<I extends IT = IT> {
+export abstract class BaseCheck<I extends Ibdd_in_any> {
   key: string;
   name: string;
   features: string[];

package/src/lib/basebuilder.ts

@@ -2,11 +2,16 @@
 /* eslint-disable @typescript-eslint/no-empty-object-type */
 /* eslint-disable no-async-promise-executor */
 /* eslint-disable @typescript-eslint/no-explicit-any */
+
 import { PassThrough } from "stream";
 
-import { IT, ITestSpecification, OT } from "../Types.js";
+import type {
+  Ibdd_in_any,
+  Ibdd_out_any,
+  ITestSpecification,
+} from "../CoreTypes";
 
-import { ITTestResourceRequest, ITestJob, ITLog, IFinalResults } from ".";
+import { ITestJob, ITLog, IFinalResults, ITTestResourceRequest } from ".";
 import {
   ISuiteKlasser,
   IGivenKlasser,
@@ -15,17 +20,12 @@ import {
   ICheckKlasser,
   IPM,
 } from "./types.js";
-import {
-  BaseCheck,
-  BaseSuite,
-  BaseWhen,
-  BaseThen,
-  BaseGiven,
-} from "./abstractBase.js";
+import { BaseCheck, BaseWhen, BaseThen, BaseGiven } from "./abstractBase.js";
+import { BaseSuite } from "./BaseSuite";
 
 export abstract class BaseBuilder<
-  I extends IT,
-  O extends OT,
+  I extends Ibdd_in_any,
+  O extends Ibdd_out_any,
   SuiteExtensions,
   GivenExtensions,
   WhenExtensions,

package/src/lib/classBuilder.ts

@@ -1,6 +1,11 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import { IT, ITestImplementation, ITestSpecification, OT } from "../Types.js";
+import type {
+  Ibdd_in_any,
+  Ibdd_out_any,
+  ITestImplementation,
+  ITestSpecification,
+} from "../CoreTypes";
 
 import { BaseBuilder } from "./basebuilder.js";
 import {
@@ -16,8 +21,8 @@ import { BaseCheck } from "./abstractBase.js";
 type IExtenstions = Record<string, unknown>;
 
 export abstract class ClassBuilder<
-  I extends IT = IT,
-  O extends OT = OT,
+  I extends Ibdd_in_any = Ibdd_in_any,
+  O extends Ibdd_out_any = Ibdd_out_any,
   M = unknown
 > extends BaseBuilder<
   I,
@@ -63,7 +68,6 @@ export abstract class ClassBuilder<
     const classyGivens = Object.entries(testImplementation.givens).reduce(
       (a, [key, g]) => {
         a[key] = (features, whens, thens, ...initialValues) => {
-          // console.log("givEn", givEn.toString());
           return new givenKlasser.prototype.constructor(
             key,
             features,
@@ -80,10 +84,10 @@ export abstract class ClassBuilder<
 
     const classyWhens = Object.entries(testImplementation.whens).reduce(
       (a, [key, whEn]: [string, (x) => any]) => {
-        a[key] = (payload?: any) => {
+        a[key] = (...payload: any) => {
           return new whenKlasser.prototype.constructor(
             `${whEn.name}: ${payload && payload.toString()}`,
-            whEn(payload)
+            whEn(...payload)
           );
         };
         return a;
@@ -91,7 +95,9 @@ export abstract class ClassBuilder<
       {}
     );
 
-    const classyThens = Object.entries<(expected: any, ...x: any[]) => any>(testImplementation.thens).reduce(
+    const classyThens = Object.entries<(expected: any, ...x: any[]) => any>(
+      testImplementation.thens
+    ).reduce(
       (a, [key, thEn]: [string, (s: I["iselection"]) => I["isubject"]]) => {
         a[key] = (expected, ...x) => {
           return new thenKlasser.prototype.constructor(

package/src/lib/core.ts

@@ -1,12 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
-import {
-  ITestSpecification,
-  ITestImplementation,
-  ITestInterface,
-  IT,
-  OT,
-} from "../Types.js";
-
 import {
   DefaultTestInterface,
   IFinalResults,
@@ -15,19 +8,22 @@ import {
   ITestArtifactory,
   defaultTestResourceRequirement,
 } from "./index.js";
-import {
-  BaseSuite,
-  BaseGiven,
-  BaseWhen,
-  BaseThen,
-  BaseCheck,
-} from "./abstractBase.js";
+import { BaseGiven, BaseWhen, BaseThen, BaseCheck } from "./abstractBase.js";
 import { ClassBuilder } from "./classBuilder.js";
 import { IPM } from "./types";
 
+import type {
+  Ibdd_in_any,
+  Ibdd_out_any,
+  ITestImplementation,
+  ITestInterface,
+  ITestSpecification,
+} from "../CoreTypes";
+import { BaseSuite } from "./BaseSuite.js";
+
 export default abstract class Testeranto<
-  I extends IT,
-  O extends OT,
+  I extends Ibdd_in_any,
+  O extends Ibdd_out_any,
   M
 > extends ClassBuilder<I, O, M> {
   constructor(

package/src/lib/index.ts

@@ -4,21 +4,20 @@ import { PM_Pure } from "../PM/pure.js";
 
 import { PM_Node } from "../PM/node.js";
 import { PM_Web } from "../PM/web.js";
-import {
-  Ibdd_in,
-  ITestInterface,
-  ITestconfig,
-  IBuiltConfig,
-  IRunTime,
-  ITestTypes,
-  IT,
-  OT,
-} from "../Types.js";
-
-import { IGivens, BaseCheck, BaseSuite } from "./abstractBase.js";
-import { IPM } from "./types.js";
+import { ITestconfig, IBuiltConfig, IRunTime, ITestTypes } from "../Types.js";
 
-export const BaseTestInterface = <T extends IT>(): ITestInterface<T> => ({
+import { IGivens, BaseCheck } from "./abstractBase.js";
+import { IPM } from "./types.js";
+import type {
+  ITestInterface,
+  Ibdd_in_any,
+  Ibdd_out_any,
+} from "../CoreTypes.js";
+import { BaseSuite } from "./BaseSuite.js";
+
+export const BaseTestInterface = <
+  T extends Ibdd_in_any
+>(): ITestInterface<T> => ({
   beforeAll: async (s: T["istore"]) => s,
   beforeEach: async function (
     subject: T["isubject"],
@@ -32,14 +31,14 @@ export const BaseTestInterface = <T extends IT>(): ITestInterface<T> => ({
   afterEach: async (s: T["istore"]) => s,
   afterAll: (store: T["istore"]) => undefined,
   butThen: async (
-    store: IT["istore"],
-    thenCb: (s: IT["iselection"]) => Promise<IT["isubject"]>
+    store: T["istore"],
+    thenCb: (s: T["iselection"]) => Promise<T["isubject"]>
   ) => {
     return thenCb(store);
   },
   andWhen: async (
-    store: IT["istore"],
-    whenCB: IT["when"],
+    store: T["istore"],
+    whenCB: T["when"],
     testResource: ITTestResourceConfiguration,
     pm: IPM
   ) => {
@@ -53,7 +52,7 @@ export const BaseTestInterface = <T extends IT>(): ITestInterface<T> => ({
   assertThis: (x: any) => x,
 });
 
-export const DefaultTestInterface = <T extends IT>(
+export const DefaultTestInterface = <T extends Ibdd_in_any>(
   p: Partial<ITestInterface<T>>
 ): ITestInterface<T> => {
   return {
@@ -99,10 +98,8 @@ export type ITestArtificer = (key: string, data: any) => void;
 type ITest = {
   toObj(): object;
   name: string;
-  givens: IGivens<
-    Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>
-  >;
-  checks: BaseCheck<IT>[];
+  givens: IGivens<Ibdd_in_any>;
+  checks: BaseCheck<Ibdd_in_any>[];
   testResourceConfiguration: ITTestResourceConfiguration;
 };
 
@@ -112,7 +109,7 @@ export type ITestJob = {
   runner: (
     x: ITTestResourceConfiguration,
     t: ITLog
-  ) => Promise<BaseSuite<IT, OT>>;
+  ) => Promise<BaseSuite<Ibdd_in_any, Ibdd_out_any>>;
   testResourceRequirement: ITTestResourceRequirement;
   receiveTestResourceConfig: (pm: PM_Node | PM_Web | PM_Pure) => IFinalResults;
 };

package/src/lib/types.ts

@@ -1,21 +1,26 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
+import type { Ibdd_in_any, Ibdd_out_any } from "../CoreTypes";
 import { PM_Node } from "../PM/node";
 import { PM_Pure } from "../PM/pure";
 import { PM_Web } from "../PM/web";
-import type { IT, OT } from "../Types";
 
 import {
   IGivens,
   BaseCheck,
-  BaseSuite,
   BaseGiven,
   BaseWhen,
   BaseThen,
 } from "./abstractBase";
+import { BaseSuite } from "./BaseSuite";
 
 export type IPM = PM_Node | PM_Web | PM_Pure;
 
-export type TestPhase = 'beforeAll' | 'beforeEach' | 'test' | 'afterEach' | 'afterAll';
+export type TestPhase =
+  | "beforeAll"
+  | "beforeEach"
+  | "test"
+  | "afterEach"
+  | "afterAll";
 
 export type TestError = {
   phase: TestPhase;
@@ -27,7 +32,10 @@ export type TestError = {
   isRetryable?: boolean;
 };
 
-export type ITestCheckCallback<I extends IT, O extends OT> = {
+export type ITestCheckCallback<
+  I extends Ibdd_in_any,
+  O extends Ibdd_out_any
+> = {
   [K in keyof O["checks"]]: (
     name: string,
     features: string[],
@@ -37,14 +45,14 @@ export type ITestCheckCallback<I extends IT, O extends OT> = {
   ) => BaseCheck<I>;
 };
 
-export type ISuiteKlasser<I extends IT, O extends OT> = (
+export type ISuiteKlasser<I extends Ibdd_in_any, O extends Ibdd_out_any> = (
   name: string,
   index: number,
   givens: IGivens<I>,
   checks: BaseCheck<I>[]
 ) => BaseSuite<I, O>;
 
-export type IGivenKlasser<I extends IT> = (
+export type IGivenKlasser<I extends Ibdd_in_any> = (
   name,
   features,
   whens,
@@ -52,8 +60,14 @@ export type IGivenKlasser<I extends IT> = (
   givenCB
 ) => BaseGiven<I>;
 
-export type IWhenKlasser<I extends IT> = (s, o) => BaseWhen<I>;
+export type IWhenKlasser<I extends Ibdd_in_any> = (s, o) => BaseWhen<I>;
 
-export type IThenKlasser<I extends IT> = (s, o) => BaseThen<I>;
+export type IThenKlasser<I extends Ibdd_in_any> = (s, o) => BaseThen<I>;
 
-export type ICheckKlasser<I extends IT> = (n, f, cb, w, t) => BaseCheck<I>;
+export type ICheckKlasser<I extends Ibdd_in_any> = (
+  n,
+  f,
+  cb,
+  w,
+  t
+) => BaseCheck<I>;

package/src/mothership/test.ts

@@ -1,18 +1,16 @@
 /* eslint-disable @typescript-eslint/no-explicit-any */
 /* eslint-disable @typescript-eslint/no-unused-vars */
-import { ITTestResourceConfiguration } from "../lib";
-import { IPM } from "../lib/types";
-import Testeranto from "../Node";
-import { PM } from "../PM";
-
 import {
+  Ibdd_in,
   Ibdd_out,
   ITestSpecification,
-  IT,
   ITestImplementation,
-  Ibdd_in,
-  IPartialNodeInterface,
-} from "../Types";
+  Ibdd_in_any,
+} from "../CoreTypes";
+import { ITTestResourceConfiguration } from "../lib";
+import { IPM } from "../lib/types";
+import Testeranto from "../Node";
+import { PM } from "../PM";
 
 import appFactory from "./index";
 
@@ -49,7 +47,12 @@ type O = Ibdd_out<
   }
 >;
 
-const specification: ITestSpecification<IT, O> = (Suite, Given, When, Then) => {
+const specification: ITestSpecification<Ibdd_in_any, O> = (
+  Suite,
+  Given,
+  When,
+  Then
+) => {
   console.log("Suite", Suite);
   return [
     Suite.TheMothership(

package/src/run.ts

@@ -15,7 +15,7 @@ process.stdin.on("keypress", (str, key) => {
   }
 });
 
-let testName = process.argv[2];
+const testName = process.argv[2];
 
 const mode = process.argv[3] as "once" | "dev";
 if (mode !== "once" && mode !== "dev") {

package/src/style.css

@@ -5,4 +5,4 @@ footer {
   position: fixed;
   bottom: 0;
   right: 0;
-}
+}

package/src/utils/buildTemplates.ts

@@ -0,0 +1,88 @@
+export const testReportPage = (packageName: string, domain: string) => {
+  return `
+    <!DOCTYPE html>
+    <html lang="en">
+  
+    <head>
+      <meta name="description" content="Webpage description goes here" />
+      <meta charset="utf-8" />
+      <title>${packageName} - testeranto</title>
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <meta name="author" content="" />
+      
+      <base href="${domain}" target="_blank">
+  
+      <link rel="stylesheet" href="../ReportClient.css" />
+      <script type="module" src="../ReportClient.js"></script>
+  
+    </head>
+  
+    <body>
+      <div id="root">
+        react is loading
+      </div>
+    </body>
+  
+    </html>
+        `;
+};
+
+export const testsReportPage = (
+  packageName: string,
+  domain: string,
+  projects
+) => {
+  return `
+    <!DOCTYPE html>
+    <html lang="en">
+  
+    <head>
+      <meta name="description" content="Webpage description goes here" />
+      <meta charset="utf-8" />
+      <title>${packageName} - testeranto</title>
+      <meta name="viewport" content="width=device-width, initial-scale=1" />
+      <meta name="author" content="" />
+      <base href="${domain}" target="_blank">
+  
+      <script type="application/json" id="bigConfig">
+        ${JSON.stringify(Object.keys(projects))}
+      </script>
+  
+      <link rel="stylesheet" href="./testeranto/Project.css" />
+      <script type="module" src="./testeranto/Project.js"></script>
+  
+    </head>
+  
+    <body>
+      <div id="root">
+        react is loading
+      </div>
+    </body>
+  
+    </html>
+        `;
+};
+
+export const idkPage = (testName: string, domain: string) => {
+  return `
+<!DOCTYPE html>
+<html lang="en">
+
+<head>
+  <meta name="description" content="Webpage description goes here" />
+  <base href="${domain}" target="_blank">
+  <meta charset="utf-8" />
+  <title>${testName} - testeranto</title>
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <meta name="author" content="" />
+
+  <link rel="stylesheet" href="./testeranto/TestReport.css" />
+  <script src="./testeranto/TestReport.js"></script>
+
+</head>
+
+<body>
+  <div id="root"/>
+</body>
+            `;
+};