testeranto 0.129.0 → 0.135.0

package/src/lib/classBuilder.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { IT, ITestImplementation, ITestSpecification, OT } from "../Types.js";
 
 import { BaseBuilder } from "./basebuilder.js";
@@ -27,7 +29,13 @@ export abstract class ClassBuilder<
   IExtenstions
 > {
   constructor(
-    testImplementation: ITestImplementation<I, O, M>,
+    testImplementation: ITestImplementation<I, O, M> & {
+      suites: Record<string, any>;
+      givens: Record<string, any>;
+      whens: Record<string, any>;
+      thens: Record<string, any>;
+      checks: Record<string, any>;
+    },
     testSpecification: ITestSpecification<I, O>,
     input: I["iinput"],
     suiteKlasser: ISuiteKlasser<I, O>,
@@ -54,15 +62,14 @@ export abstract class ClassBuilder<
 
     const classyGivens = Object.entries(testImplementation.givens).reduce(
       (a, [key, g]) => {
-        a[key] = (features, whens, thens) => {
-          // console.log("givEn", givEn.toString());
+        a[key] = (features, whens, thens, ...initialValues) => {
           return new givenKlasser.prototype.constructor(
             key,
             features,
             whens,
             thens,
-            testImplementation.givens[key]
-            // givEn
+            testImplementation.givens[key],
+            initialValues
           );
         };
         return a;
@@ -72,10 +79,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;
@@ -83,23 +90,14 @@ export abstract class ClassBuilder<
       {}
     );
 
-    const classyThens = Object.entries(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) => {
+        a[key] = (expected, ...x) => {
           return new thenKlasser.prototype.constructor(
             `${thEn.name}: ${expected && expected.toString()}`,
-            // () => {
-            //   thEn(expected);
-            //   // return new Promise((res), rej) => {
-
-            //   // }
-            //   // try {
-            //   //   thEn(expected);
-            //   // } catch (c) {
-            //   //   console.log("mark99");
-            //   // }
-            // },
-            thEn(expected)
+            thEn(expected, ...x)
           );
         };
         return a;

package/src/lib/core.ts

@@ -1,11 +1,3 @@
-import {
-  ITestSpecification,
-  ITestImplementation,
-  ITestInterface,
-  IT,
-  OT,
-} from "../Types.js";
-
 import {
   DefaultTestInterface,
   IFinalResults,
@@ -23,6 +15,11 @@ import {
 } from "./abstractBase.js";
 import { ClassBuilder } from "./classBuilder.js";
 import { IPM } from "./types";
+import {
+  ITestSpecification,
+  ITestImplementation,
+  ITestInterface,
+} from "../CoreTypes.js";
 
 export default abstract class Testeranto<
   I extends IT,
@@ -32,7 +29,13 @@ export default abstract class Testeranto<
   constructor(
     input: I["iinput"],
     testSpecification: ITestSpecification<I, O>,
-    testImplementation: ITestImplementation<I, O, M>,
+    testImplementation: ITestImplementation<I, O, M> & {
+      suites: Record<string, any>;
+      givens: Record<string, any>;
+      whens: Record<string, any>;
+      thens: Record<string, any>;
+      checks: Record<string, any>;
+    },
     testResourceRequirement: ITTestResourceRequest = defaultTestResourceRequirement,
     testInterface: Partial<ITestInterface<I>>,
     uberCatcher: (cb: () => void) => void
@@ -111,16 +114,22 @@ export default abstract class Testeranto<
 
       class When extends BaseWhen<I> {
         async andWhen(store, whenCB, testResource, pm) {
-          try {
-            return await fullTestInterface.andWhen(
-              store,
-              whenCB,
-              testResource,
-              pm
-            );
-          } catch (e) {
-            throw e;
-          }
+          return await fullTestInterface.andWhen(
+            store,
+            whenCB,
+            testResource,
+            pm
+          );
+          // try {
+          //   return await fullTestInterface.andWhen(
+          //     store,
+          //     whenCB,
+          //     testResource,
+          //     pm
+          //   );
+          // } catch (e) {
+          //   console.log("mark22", e);
+          // }
         }
       } as any,
 

package/src/lib/index.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import { PM_Pure } from "../PM/pure.js";
 
 import { PM_Node } from "../PM/node.js";
@@ -16,32 +18,44 @@ import {
 import { IGivens, BaseCheck, BaseSuite } from "./abstractBase.js";
 import { IPM } from "./types.js";
 
-export const BaseTestInterface: ITestInterface<IT> = {
-  beforeAll: async (s) => s,
+export const BaseTestInterface = <T extends IT>(): ITestInterface<T> => ({
+  beforeAll: async (s: T["istore"]) => s,
   beforeEach: async function (
-    subject: any,
-    initialValues: any,
-    x: any,
-    testResource: any,
+    subject: T["isubject"],
+    initialValues: T["iinitialValues"],
+    x: unknown,
+    testResource: ITTestResourceConfiguration,
     pm: IPM
-  ) {
-    return subject as any;
+  ): Promise<T["isubject"]> {
+    return subject;
   },
-  afterEach: async (s) => s,
-  afterAll: (store: IT["istore"]) => undefined,
+  afterEach: async (s: T["istore"]) => s,
+  afterAll: (store: T["istore"]) => undefined,
   butThen: async (
     store: IT["istore"],
     thenCb: (s: IT["iselection"]) => Promise<IT["isubject"]>
   ) => {
     return thenCb(store);
   },
-  andWhen: async (a) => a,
-  assertThis: (x: any) => null,
-};
+  andWhen: async (
+    store: IT["istore"],
+    whenCB: IT["when"],
+    testResource: ITTestResourceConfiguration,
+    pm: IPM
+  ) => {
+    try {
+      await whenCB(store, testResource, pm);
+    } catch (error) {
+      console.error("Error in andWhen:", error);
+      throw error; // Re-throw to maintain test failure
+    }
+  },
+  assertThis: (x: any) => x,
+});
 
-export const DefaultTestInterface = (
-  p: Partial<ITestInterface<any>>
-): ITestInterface<any> => {
+export const DefaultTestInterface = <T extends IT>(
+  p: Partial<ITestInterface<T>>
+): ITestInterface<T> => {
   return {
     ...BaseTestInterface,
     ...p,
@@ -52,7 +66,10 @@ export type ITTestResourceConfiguration = {
   name: string;
   fs: string;
   ports: number[];
-  browserWSEndpoint: string;
+  browserWSEndpoint?: string;
+  timeout?: number;
+  retries?: number;
+  environment?: Record<string, string>;
 };
 
 export type ITTestResourceRequirement = {
@@ -112,8 +129,11 @@ export type { ITestconfig, IBuiltConfig, IRunTime, ITestTypes };
 
 export type IRunnables = {
   nodeEntryPoints: Record<string, string>;
+  nodeEntryPointSidecars: Record<string, string>;
   webEntryPoints: Record<string, string>;
-  importEntryPoints: Record<string, string>;
+  webEntryPointSidecars: Record<string, string>;
+  pureEntryPoints: Record<string, string>;
+  pureEntryPointSidecars: Record<string, string>;
 };
 
 export type IFinalResults = {

package/src/lib/pmProxy.ts

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { IPM } from "./types";
 
 const prxy = function (pm: IPM, mappings: [string, (...x) => any][]) {
@@ -8,7 +10,7 @@ const prxy = function (pm: IPM, mappings: [string, (...x) => any][]) {
         const arger = mapping[1];
 
         if (prop === method) {
-          return (x) => target[prop](arger(x));
+          return (...x) => target[prop](arger(...x));
         }
       }
 

package/src/lib/types.ts

@@ -1,7 +1,8 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { PM_Node } from "../PM/node";
 import { PM_Pure } from "../PM/pure";
 import { PM_Web } from "../PM/web";
-import { IT, OT } from "../Types";
+import type { IT, OT } from "../Types";
 
 import {
   IGivens,
@@ -14,11 +15,23 @@ import {
 
 export type IPM = PM_Node | PM_Web | PM_Pure;
 
+export type TestPhase = 'beforeAll' | 'beforeEach' | 'test' | 'afterEach' | 'afterAll';
+
+export type TestError = {
+  phase: TestPhase;
+  error: Error;
+  testName: string;
+  timestamp: number;
+  stackTrace?: string;
+  additionalInfo?: Record<string, unknown>;
+  isRetryable?: boolean;
+};
+
 export type ITestCheckCallback<I extends IT, O extends OT> = {
   [K in keyof O["checks"]]: (
     name: string,
     features: string[],
-    checkCallback: (store: I["istore"], pm: IPM) => Promise<any>,
+    checkCallback: (store: I["istore"], pm: IPM) => Promise<O["checks"][K]>,
 
     ...xtrasA: O["checks"][K]
   ) => BaseCheck<I>;

package/src/mothership/index.ts

@@ -0,0 +1,15 @@
+import express from "express";
+
+const app = express();
+
+app.get("/", (req, res) => {
+  res.send("Hello World!");
+});
+
+export default (port: number) => {
+  app.listen(port, () => {
+    console.log(`Example app listening on port ${port}`);
+  });
+
+  return app;
+};

package/src/mothership/test.ts

@@ -0,0 +1,137 @@
+/* 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_out,
+  ITestSpecification,
+  IT,
+  ITestImplementation,
+  Ibdd_in,
+  IPartialNodeInterface,
+} from "../Types";
+
+import appFactory from "./index";
+
+import type { Express } from "express";
+
+type I = Ibdd_in<
+  (port: number) => Express,
+  (port: number) => Express,
+  any,
+  any,
+  any,
+  any,
+  any
+>;
+
+type O = Ibdd_out<
+  {
+    TheMothership: [null];
+  },
+  {
+    ItIsRunning: [];
+  },
+  {
+    IClaimTheResource: [string];
+    IReleaseTheResource: [string];
+    IResetTheResource: [string];
+  },
+  {
+    TheResourceIsClaimed: [string];
+    TheResourceIsUnClaimed: [string];
+  },
+  {
+    AnEmptyState;
+  }
+>;
+
+const specification: ITestSpecification<IT, O> = (Suite, Given, When, Then) => {
+  console.log("Suite", Suite);
+  return [
+    Suite.TheMothership(
+      "the mothership allows the coordination of test resources",
+      {
+        test0: Given.ItIsRunning(
+          [`a resource can be claimed`],
+          [When.IClaimTheResource("test")],
+          [
+            // Then.TheResourceIsClaimed("test")
+          ]
+        ),
+      },
+      []
+    ),
+  ];
+};
+
+const implementation: ITestImplementation<I, O> = {
+  suites: { TheMothership: (x) => x },
+  givens: { ItIsRunning: () => undefined },
+  whens: {
+    IClaimTheResource: (resource) => async (i, tr, p) => {
+      fetch(`http://localhost:${tr.ports[0]}/claim?${resource}`);
+    },
+    IReleaseTheResource: function (
+      resource: string
+    ): (zel, tr, utils) => Promise<any> {
+      throw new Error("Function not implemented.");
+    },
+    IResetTheResource: function (
+      Iw_0: string
+    ): (zel: any, tr, utils: PM) => Promise<any> {
+      throw new Error("Function not implemented.");
+    },
+  },
+  thens: {
+    TheResourceIsClaimed: (resource) => async (z, u) => {
+      throw new Error("Function not implemented.");
+    },
+    TheResourceIsUnClaimed: function (
+      It_0: string
+    ): (ssel: any, utils: PM) => any {
+      throw new Error("Function not implemented.");
+    },
+  },
+  checks: { AnEmptyState: () => "any" },
+};
+
+const testInterface: IPartialNodeInterface<I> = {
+  // assertThis: function (x: any) {
+  //   throw new Error("Function not implemented.");
+  // },
+  // andWhen: function (store: any, whenCB: any, testResource: ITTestResourceConfiguration, pm: IPM): Promise<any> {
+  //   throw new Error("Function not implemented.");
+  // },
+  // butThen: function (store: any, thenCB: any, testResource: ITTestResourceConfiguration, pm: IPM): Promise<any> {
+  //   throw new Error("Function not implemented.");
+  // },
+  // afterAll: function (store: any, pm: IPM) {
+  //   throw new Error("Function not implemented.");
+  // },
+  // afterEach: function (store: any, key: string, pm: IPM): Promise<unknown> {
+  //   throw new Error("Function not implemented.");
+  // },
+  // beforeAll: function (input: Express, testResource: ITTestResourceConfiguration, pm: IPM): Promise<any> {
+  //   throw new Error("Function not implemented.");
+  // },
+  beforeEach: async (
+    subject,
+    initializer: (c?: any) => any,
+    testResource: ITTestResourceConfiguration,
+    initialValues: any,
+    pm: IPM
+  ) => {
+    return subject(testResource.ports[0]);
+  },
+};
+
+export default Testeranto(
+  appFactory,
+  specification,
+  implementation,
+  testInterface
+);

package/src/run.ts

@@ -1,6 +1,5 @@
 import ansiC from "ansi-colors";
 import readline from "readline";
-import path from "path";
 
 import { PM_Main } from "./PM/main";
 import { ITestconfig, IBuiltConfig, IProject } from "./Types";

package/src/utils/queue.ts

@@ -0,0 +1,41 @@
+export class Queue<I> {
+  items: I[];
+
+  constructor() {
+    this.items = [];
+  }
+
+  enqueue(element) {
+    this.items.push(element);
+  }
+
+  dequeue() {
+    if (this.isEmpty()) {
+      return "Queue is empty";
+    }
+    return this.items.shift();
+  }
+
+  peek() {
+    if (this.isEmpty()) {
+      return "Queue is empty";
+    }
+    return this.items[0];
+  }
+
+  isEmpty() {
+    return this.items.length === 0;
+  }
+
+  size() {
+    return this.items.length;
+  }
+
+  clear() {
+    this.items = [];
+  }
+
+  print() {
+    console.log(this.items.join(" -> "));
+  }
+}

package/src/utils.ts

@@ -1,18 +1,9 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
 import path from "path";
 
 import { IBuiltConfig, IRunTime, ITestTypes } from "./Types";
 import { IRunnables } from "./lib";
 
-export type ISummary = Record<
-  string,
-  {
-    runTimeError?: number | "?";
-    typeErrors?: number | "?";
-    staticErrors?: number | "?";
-    prompt?: string | "?";
-  }
->;
-
 export const destinationOfRuntime = (
   f: string,
   r: IRunTime,
@@ -90,8 +81,11 @@ export const getRunnables = (
   projectName: string,
   payload = {
     nodeEntryPoints: {},
+    nodeEntryPointSidecars: {},
     webEntryPoints: {},
-    importEntryPoints: {},
+    webEntryPointSidecars: {},
+    pureEntryPoints: {},
+    pureEntryPointSidecars: {},
   }
 ): IRunnables => {
   return tests.reduce((pt, cv, cndx, cry) => {
@@ -112,7 +106,7 @@ export const getRunnables = (
           .join(".")}`
       );
     } else if (cv[1] === "pure") {
-      pt.importEntryPoints[cv[0]] = path.resolve(
+      pt.pureEntryPoints[cv[0]] = path.resolve(
         `./testeranto/bundles/pure/${projectName}/${cv[0]
           .split(".")
           .slice(0, -1)
@@ -121,9 +115,41 @@ export const getRunnables = (
       );
     }
 
-    // if (cv[3].length) {
-    //   getRunnables(cv[3], testName, payload);
-    // }
+    //////////////////////////////////////////////////////////
+
+    cv[3]
+      .filter((t) => t[1] === "node")
+      .forEach((t) => {
+        pt.nodeEntryPointSidecars[`${t[0]}`] = path.resolve(
+          `./testeranto/bundles/node/${projectName}/${cv[0]
+            .split(".")
+            .slice(0, -1)
+            .concat("mjs")
+            .join(".")}`
+        );
+      });
+    cv[3]
+      .filter((t) => t[1] === "web")
+      .forEach((t) => {
+        pt.webEntryPointSidecars[`${t[0]}`] = path.resolve(
+          `./testeranto/bundles/web/${projectName}/${cv[0]
+            .split(".")
+            .slice(0, -1)
+            .concat("mjs")
+            .join(".")}`
+        );
+      });
+    cv[3]
+      .filter((t) => t[1] === "pure")
+      .forEach((t) => {
+        pt.pureEntryPointSidecars[`${t[0]}`] = path.resolve(
+          `./testeranto/bundles/pure/${projectName}/${cv[0]
+            .split(".")
+            .slice(0, -1)
+            .concat("mjs")
+            .join(".")}`
+        );
+      });
 
     return pt;
   }, payload as IRunnables);

package/testeranto/bundles/node/mothership/chunk-PG6KUKNP.mjs

@@ -0,0 +1,44 @@
+import { createRequire } from 'module';const require = createRequire(import.meta.url);
+
+// src/PM/sidecar.ts
+var PM_sidecar = class {
+  testArtiFactoryfileWriter(tLog, callback) {
+    return (fPath, value) => {
+      callback(Promise.resolve());
+    };
+  }
+  // abstract $(selector: string): any;
+  // abstract click(selector: string): any;
+  // abstract closePage(p): any;
+  // abstract createWriteStream(
+  //   filepath: string,
+  //   testName: string
+  // ): Promise<string>;
+  // abstract customclose();
+  // abstract customScreenShot(opts: object, page?: string): any;
+  // abstract end(uid: number): Promise<boolean>;
+  // abstract existsSync(fp: string): Promise<boolean>;
+  // abstract focusOn(selector: string): any;
+  // abstract getAttribute(selector: string, attribute: string): any;
+  // abstract getValue(value: string): any;
+  // abstract goto(p, url: string): any;
+  // abstract isDisabled(selector: string): Promise<boolean>;
+  // abstract mkdirSync(a: string);
+  // abstract newPage(): Promise<string>;
+  // abstract page(): Promise<string | undefined>;
+  // abstract pages(): Promise<string[]>;
+  // abstract screencast(o: ScreenRecorderOptions, p: Page | string): any;
+  // abstract screencastStop(s: string): any;
+  // abstract typeInto(selector: string, value: string): any;
+  // abstract waitForSelector(p, sel: string);
+  // abstract write(uid: number, contents: string): Promise<boolean>;
+  // abstract writeFileSync(f: string, c: string, t: string): Promise<boolean>;
+  // abstract launchSideCar(
+  //   n: number
+  // ): Promise<[number, ITTestResourceConfiguration]>;
+  // abstract stopSideCar(n: number): Promise<any>;
+};
+
+export {
+  PM_sidecar
+};