testeranto 0.128.0 → 0.134.0

package/dist/types/src/lib/abstractBase.d.ts

@@ -1,4 +1,4 @@
-import { IT, OT } from "../Types.js";
+import type { IT, OT } from "../Types.js";
 import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
 import { IPM } from "./types.js";
 export type IGivens<I extends IT> = Record<string, BaseGiven<I>>;
@@ -20,7 +20,7 @@ export declare abstract class BaseSuite<I extends IT = IT, O extends OT = OT> {
             name: string;
             whens: {
                 name: string;
-                error: boolean;
+                error: string;
             }[];
             thens: {
                 name: string;
@@ -60,7 +60,7 @@ export declare abstract class BaseGiven<I extends IT = IT> {
         name: string;
         whens: {
             name: string;
-            error: boolean;
+            error: string;
         }[];
         thens: {
             name: string;
@@ -73,17 +73,17 @@ export declare abstract class BaseGiven<I extends IT = IT> {
     abstract givenThat(subject: I["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, givenCB: I["given"], initialValues: any, pm: IPM): Promise<I["istore"]>;
     afterEach(store: I["istore"], key: string, artifactory: ITestArtifactory, pm: IPM): Promise<unknown>;
     abstract uberCatcher(e: any): any;
-    give(subject: I["isubject"], key: string, testResourceConfiguration: ITTestResourceConfiguration, tester: (t: Awaited<I["then"]> | undefined) => boolean, artifactory: ITestArtifactory, tLog: ITLog, pm: IPM, suiteNdx: number): Promise<boolean | I["istore"]>;
+    give(subject: I["isubject"], key: string, testResourceConfiguration: ITTestResourceConfiguration, tester: (t: Awaited<I["then"]> | undefined) => boolean, artifactory: ITestArtifactory, tLog: ITLog, pm: IPM, suiteNdx: number): Promise<I["istore"]>;
 }
 export declare abstract class BaseWhen<I extends IT> {
     name: string;
     whenCB: (x: I["iselection"]) => I["then"];
-    error: boolean;
+    error: Error;
     constructor(name: string, whenCB: (xyz: I["iselection"]) => I["then"]);
     abstract andWhen(store: I["istore"], whenCB: (x: I["iselection"]) => I["then"], testResource: any, pm: IPM): Promise<any>;
     toObj(): {
         name: string;
-        error: boolean;
+        error: string;
     };
     test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: IPM, filepath: string): Promise<any>;
 }

package/dist/types/src/lib/classBuilder.d.ts

@@ -4,6 +4,12 @@ import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser
 import { ITTestResourceRequest } from "./index.js";
 type IExtenstions = Record<string, unknown>;
 export declare abstract class ClassBuilder<I extends IT = IT, O extends OT = OT, M = unknown> extends BaseBuilder<I, O, IExtenstions, IExtenstions, IExtenstions, IExtenstions, IExtenstions> {
-    constructor(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>, testResourceRequirement: ITTestResourceRequest);
+    constructor(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>, givenKlasser: IGivenKlasser<I>, whenKlasser: IWhenKlasser<I>, thenKlasser: IThenKlasser<I>, checkKlasser: ICheckKlasser<I>, testResourceRequirement: ITTestResourceRequest);
 }
 export {};

package/dist/types/src/lib/core.d.ts

@@ -2,6 +2,12 @@ import { ITestSpecification, ITestImplementation, ITestInterface, IT, OT } from
 import { IFinalResults, ITTestResourceRequest } from "./index.js";
 import { ClassBuilder } from "./classBuilder.js";
 export default abstract class Testeranto<I extends IT, O extends OT, M> extends ClassBuilder<I, O, M> {
-    constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testResourceRequirement: ITTestResourceRequest | undefined, testInterface: Partial<ITestInterface<I>>, uberCatcher: (cb: () => void) => void);
+    constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, 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 | undefined, testInterface: Partial<ITestInterface<I>>, uberCatcher: (cb: () => void) => void);
     abstract receiveTestResourceConfig(partialTestResource: string): Promise<IFinalResults>;
 }

package/dist/types/src/lib/index.d.ts

@@ -3,13 +3,16 @@ 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";
-export declare const BaseTestInterface: ITestInterface<IT>;
-export declare const DefaultTestInterface: (p: Partial<ITestInterface<any>>) => ITestInterface<any>;
+export declare const BaseTestInterface: <T extends IT>() => ITestInterface<T>;
+export declare const DefaultTestInterface: <T extends IT>(p: Partial<ITestInterface<T>>) => ITestInterface<T>;
 export type ITTestResourceConfiguration = {
     name: string;
     fs: string;
     ports: number[];
-    browserWSEndpoint: string;
+    browserWSEndpoint?: string;
+    timeout?: number;
+    retries?: number;
+    environment?: Record<string, string>;
 };
 export type ITTestResourceRequirement = {
     name: string;
@@ -49,8 +52,11 @@ export type ITestArtifactory = (key: string, value: unknown) => unknown;
 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 = {
     features: string[];

package/dist/types/src/lib/types.d.ts

@@ -1,11 +1,21 @@
 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, BaseCheck, BaseSuite, BaseGiven, BaseWhen, BaseThen } from "./abstractBase";
 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>, ...xtrasA: O["checks"][K]) => BaseCheck<I>;
+    [K in keyof O["checks"]]: (name: string, features: string[], checkCallback: (store: I["istore"], pm: IPM) => Promise<O["checks"][K]>, ...xtrasA: O["checks"][K]) => BaseCheck<I>;
 };
 export type ISuiteKlasser<I extends IT, O extends OT> = (name: string, index: number, givens: IGivens<I>, checks: BaseCheck<I>[]) => BaseSuite<I, O>;
 export type IGivenKlasser<I extends IT> = (name: any, features: any, whens: any, thens: any, givenCB: any) => BaseGiven<I>;

package/dist/types/src/mothership/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (port: number) => import("express-serve-static-core").Express;
+export default _default;

package/dist/types/src/mothership/test.d.ts

@@ -0,0 +1,21 @@
+import { Ibdd_out, Ibdd_in } from "../Types";
+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: any;
+}>;
+declare const _default: Promise<import("../lib/core").default<IT, O, {
+    whens: import("../Types").TestWhenImplementation<I, O>;
+}>>;
+export default _default;

package/dist/types/src/utils/queue.d.ts

@@ -0,0 +1,11 @@
+export declare class Queue<I> {
+    items: I[];
+    constructor();
+    enqueue(element: any): void;
+    dequeue(): I | "Queue is empty" | undefined;
+    peek(): I | "Queue is empty";
+    isEmpty(): boolean;
+    size(): number;
+    clear(): void;
+    print(): void;
+}

package/dist/types/src/utils.d.ts

@@ -1,11 +1,5 @@
 import { IBuiltConfig, IRunTime, ITestTypes } from "./Types";
 import { IRunnables } from "./lib";
-export type ISummary = Record<string, {
-    runTimeError?: number | "?";
-    typeErrors?: number | "?";
-    staticErrors?: number | "?";
-    prompt?: string | "?";
-}>;
 export declare const destinationOfRuntime: (f: string, r: IRunTime, configs: IBuiltConfig) => string;
 export declare const tscPather: (entryPoint: string, platform: IRunTime, projectName: string) => string;
 export declare const lintPather: (entryPoint: string, platform: IRunTime, projectName: string) => string;
@@ -13,6 +7,9 @@ export declare const bddPather: (entryPoint: string, platform: IRunTime, project
 export declare const promptPather: (entryPoint: string, platform: IRunTime, projectName: string) => string;
 export declare const getRunnables: (tests: ITestTypes[], projectName: string, payload?: {
     nodeEntryPoints: {};
+    nodeEntryPointSidecars: {};
     webEntryPoints: {};
-    importEntryPoints: {};
+    webEntryPointSidecars: {};
+    pureEntryPoints: {};
+    pureEntryPointSidecars: {};
 }) => IRunnables;