testeranto 0.135.0 → 0.140.0

package/dist/types/src/PM/nodeSidecar.d.ts

@@ -1,10 +1,10 @@
 import net from "net";
-import { ITTestResourceConfiguration } from "../lib";
+import { ITLog, ITTestResourceConfiguration } from "../lib";
 import { PM_sidecar } from "./sidecar";
+import { PassThrough } from "stream";
 export declare class PM_Node_Sidecar extends PM_sidecar {
     testResourceConfiguration: ITTestResourceConfiguration;
     client: net.Socket;
-    mockListener?: jest.Mock;
     constructor(t: ITTestResourceConfiguration);
     start(stopper: () => any): Promise<void>;
     stop(): Promise<void>;

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

@@ -1,9 +1,9 @@
+import { Ibdd_in_any, Ibdd_out, ITestImplementation, ITestInterface, ITestSpecification } from "./CoreTypes.js";
 import Testeranto from "./lib/core.js";
 import { ITTestResourceRequest } from "./lib/index.js";
-import type { INodeTestInterface, IT, ITestImplementation, ITestInterface, ITestSpecification, OT } from "./Types.js";
-export declare class PureTesteranto<I extends IT, O extends OT, M> extends Testeranto<I, O, M> {
+export declare class PureTesteranto<I extends Ibdd_in_any, O extends Ibdd_out, M> extends Testeranto<I, O, M> {
     constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testResourceRequirement: ITTestResourceRequest, testInterface: Partial<ITestInterface<I>>);
     receiveTestResourceConfig(partialTestResource: string): Promise<import("./lib/index.js").IFinalResults>;
 }
-declare const _default: <I extends IT, O extends OT, M>(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testInterface: Partial<INodeTestInterface<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<I, O, M>>;
+declare const _default: <I extends Ibdd_in_any, O extends Ibdd_out, M>(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testInterface: Partial<INodeTestInterface<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<I, O, M>>;
 export default _default;

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

@@ -2,8 +2,15 @@ import { Plugin } from "esbuild";
 import { ITTestResourceConfiguration } from "./lib/index.js";
 import { PM } from "./PM/index.js";
 import { BaseWhen, BaseThen, BaseGiven, BaseCheck, BaseSuite, IGivens } from "./lib/abstractBase.js";
-import { Ibdd_in, Ibdd_out } from "./CoreTypes.js";
-export type SuiteSpecification<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
+import { Ibdd_in_any, Ibdd_out_any } from "./CoreTypes.js";
+export type ISummary = Record<string, {
+    runTimeError: string;
+    typeErrors: number;
+    staticErrors: number;
+    prompt: string;
+    failingFeatures: object;
+}>;
+export type SuiteSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["suites"]]: (name: string, givens: IGivens<I>, checks: BaseCheck<I>[]) => BaseSuite<I, O>;
 };
 export type TestSummary = {
@@ -51,28 +58,28 @@ export type ProjectConfig = {
     minify?: boolean;
     debug?: boolean;
 };
-export type GivenSpecification<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
+export type GivenSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["givens"]]: (features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], ...xtrasB: O["givens"][K]) => BaseGiven<I>;
 };
-export type WhenSpecification<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
+export type WhenSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["whens"]]: (...xtrasC: O["whens"][K]) => BaseWhen<I>;
 };
-export type ThenSpecification<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
+export type ThenSpecification<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["thens"]]: (...xtrasD: O["thens"][K]) => BaseThen<I>;
 };
-export type TestSuiteImplementation<O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
+export type TestSuiteImplementation<O extends Ibdd_out_any> = {
     [K in keyof O["suites"]]: string;
 };
-export type TestGivenImplementation<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
+export type TestGivenImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["givens"]]: (...Ig: O["givens"][K]) => I["given"];
 };
-export type TestWhenImplementation<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
+export type TestWhenImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["whens"]]: (...Iw: O["whens"][K]) => (zel: I["iselection"], tr: ITTestResourceConfiguration, utils: PM) => Promise<I["when"]>;
 };
-export type TestThenImplementation<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
+export type TestThenImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["thens"]]: (...It: O["thens"][K]) => (ssel: I["iselection"], utils: PM) => I["then"];
 };
-export type TestCheckImplementation<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, O extends Ibdd_out<TestSuiteShape, TestGivenShape, TestWhenShape, TestThenShape, TestCheckShape>> = {
+export type TestCheckImplementation<I extends Ibdd_in_any, O extends Ibdd_out_any> = {
     [K in keyof O["checks"]]: (...Ic: O["checks"][K]) => I["given"];
 };
 export type Modify<T, R> = Omit<T, keyof R> & R;
@@ -90,10 +97,6 @@ export type ITestconfig = {
     clearScreen: boolean;
     debugger: boolean;
     externals: string[];
-    externalTests: Record<string, {
-        watch: string[];
-        exec: string;
-    }>;
     featureIngestor: (s: string) => Promise<string>;
     importPlugins: IPluginFactory[];
     minify: boolean;
@@ -108,4 +111,5 @@ export type IBuiltConfig = {
 } & ITestconfig;
 export type IProject = {
     projects: Record<string, ITestconfig>;
+    reportDomain: string;
 };

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

@@ -1,9 +1,9 @@
-import type { ITestImplementation, ITestInterface, ITestSpecification } from "./Types";
+import { ITestSpecification, ITestImplementation, ITestInterface, Ibdd_in_any, Ibdd_out } from "./CoreTypes";
 import Testeranto from "./lib/core.js";
 import { ITTestResourceRequest } from "./lib/index.js";
-export declare class WebTesteranto<I extends IT, O extends OT, M> extends Testeranto<I, O, M> {
+export declare class WebTesteranto<I extends Ibdd_in_any, O extends Ibdd_out, M> extends Testeranto<I, O, M> {
     constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testResourceRequirement: ITTestResourceRequest, testInterface: Partial<ITestInterface<I>>);
     receiveTestResourceConfig(partialTestResource: any): Promise<import("./lib/index.js").IFinalResults>;
 }
-declare const _default: <I extends IT, O extends OT, M>(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testInterface: Partial<IWebTestInterface<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<I, O, M>>;
+declare const _default: <I extends Ibdd_in_any, O extends Ibdd_out, M>(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testInterface: Partial<IWebTestInterface<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<I, O, M>>;
 export default _default;

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

@@ -1,8 +1,8 @@
-import type { IT, OT } from "../Types.js";
-import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
+import { ITestArtifactory, ITLog, ITTestResourceConfiguration } from ".";
 import { IPM } from "./types.js";
-export type IGivens<I extends IT> = Record<string, BaseGiven<I>>;
-export declare abstract class BaseSuite<I extends IT = IT, O extends OT = OT> {
+import type { Ibdd_in_any, Ibdd_out_any } from "../CoreTypes";
+export type IGivens<I extends Ibdd_in_any> = Record<string, BaseGiven<I>>;
+export declare abstract class BaseSuite<I extends Ibdd_in_any, O extends Ibdd_out_any> {
     name: string;
     givens: IGivens<I>;
     checks: BaseCheck<I>[];
@@ -37,7 +37,7 @@ export declare abstract class BaseSuite<I extends IT = IT, O extends OT = OT> {
     afterAll(store: I["istore"], artifactory: ITestArtifactory, pm: IPM): I["istore"];
     run(input: I["iinput"], testResourceConfiguration: ITTestResourceConfiguration, artifactory: (fPath: string, value: unknown) => void, tLog: (...string: any[]) => void, pm: IPM): Promise<BaseSuite<I, O>>;
 }
-export declare abstract class BaseGiven<I extends IT = IT> {
+export declare abstract class BaseGiven<I extends Ibdd_in_any> {
     name: string;
     features: string[];
     whens: BaseWhen<I>[];
@@ -69,7 +69,7 @@ export declare abstract class BaseGiven<I extends IT = IT> {
     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<I["istore"]>;
 }
-export declare abstract class BaseWhen<I extends IT> {
+export declare abstract class BaseWhen<I extends Ibdd_in_any> {
     name: string;
     whenCB: (x: I["iselection"]) => I["then"];
     error: Error;
@@ -81,7 +81,7 @@ export declare abstract class BaseWhen<I extends IT> {
     };
     test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: IPM, filepath: string): Promise<any>;
 }
-export declare abstract class BaseThen<I extends IT> {
+export declare abstract class BaseThen<I extends Ibdd_in_any> {
     name: string;
     thenCB: (storeState: I["iselection"]) => Promise<I["then"]>;
     error: boolean;
@@ -94,7 +94,7 @@ export declare abstract class BaseThen<I extends IT> {
     test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: IPM, filepath: string): Promise<I["then"] | undefined>;
     check(): void;
 }
-export declare abstract class BaseCheck<I extends IT = IT> {
+export declare abstract class BaseCheck<I extends Ibdd_in_any> {
     key: string;
     name: string;
     features: string[];

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

@@ -1,8 +1,8 @@
-import { IT, ITestSpecification, OT } from "../Types.js";
-import { ITTestResourceRequest, ITestJob } from ".";
+import type { Ibdd_in_any, Ibdd_out_any, ITestSpecification } from "../CoreTypes";
+import { ITestJob, ITTestResourceRequest } from ".";
 import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser, IPM } from "./types.js";
 import { BaseCheck, BaseWhen, BaseThen, BaseGiven } from "./abstractBase.js";
-export declare abstract class BaseBuilder<I extends IT, O extends OT, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions, CheckExtensions> {
+export declare abstract class BaseBuilder<I extends Ibdd_in_any, O extends Ibdd_out_any, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions, CheckExtensions> {
     specs: any;
     assertThis: (t: I["then"]) => {};
     testResourceRequirement: ITTestResourceRequest;

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

@@ -1,9 +1,9 @@
-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 { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser } from "./types.js";
 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> {
+export declare abstract class ClassBuilder<I extends Ibdd_in_any = Ibdd_in_any, O extends Ibdd_out_any = Ibdd_out_any, M = unknown> extends BaseBuilder<I, O, IExtenstions, IExtenstions, IExtenstions, IExtenstions, IExtenstions> {
     constructor(testImplementation: ITestImplementation<I, O, M> & {
         suites: Record<string, any>;
         givens: Record<string, any>;

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

@@ -1,7 +1,7 @@
 import { IFinalResults, ITTestResourceRequest } from "./index.js";
 import { ClassBuilder } from "./classBuilder.js";
-import { ITestSpecification, ITestImplementation, ITestInterface } from "../CoreTypes.js";
-export default abstract class Testeranto<I extends IT, O extends OT, M> extends ClassBuilder<I, O, M> {
+import type { Ibdd_in_any, Ibdd_out_any, ITestImplementation, ITestInterface, ITestSpecification } from "../CoreTypes";
+export default abstract class Testeranto<I extends Ibdd_in_any, O extends Ibdd_out_any, M> extends ClassBuilder<I, O, M> {
     constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M> & {
         suites: Record<string, any>;
         givens: Record<string, any>;

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

@@ -1,10 +1,11 @@
 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 { ITestconfig, IBuiltConfig, IRunTime, ITestTypes } from "../Types.js";
 import { IGivens, BaseCheck, BaseSuite } from "./abstractBase.js";
-export declare const BaseTestInterface: <T extends IT>() => ITestInterface<T>;
-export declare const DefaultTestInterface: <T extends IT>(p: Partial<ITestInterface<T>>) => ITestInterface<T>;
+import type { ITestInterface, Ibdd_in_any, Ibdd_out_any } from "../CoreTypes.js";
+export declare const BaseTestInterface: <T extends Ibdd_in_any>() => ITestInterface<T>;
+export declare const DefaultTestInterface: <T extends Ibdd_in_any>(p: Partial<ITestInterface<T>>) => ITestInterface<T>;
 export type ITTestResourceConfiguration = {
     name: string;
     fs: string;
@@ -33,14 +34,14 @@ 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;
 };
 export type ITestJob = {
     toObj(): object;
     test: ITest;
-    runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<BaseSuite<IT, OT>>;
+    runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<BaseSuite<Ibdd_in_any, Ibdd_out_any>>;
     testResourceRequirement: ITTestResourceRequirement;
     receiveTestResourceConfig: (pm: PM_Node | PM_Web | PM_Pure) => IFinalResults;
 };

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

@@ -1,10 +1,10 @@
+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";
 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;
     error: Error;
@@ -14,11 +14,11 @@ export type TestError = {
     additionalInfo?: Record<string, unknown>;
     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[], 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>;
-export type IWhenKlasser<I extends IT> = (s: any, o: any) => BaseWhen<I>;
-export type IThenKlasser<I extends IT> = (s: any, o: any) => BaseThen<I>;
-export type ICheckKlasser<I extends IT> = (n: any, f: any, cb: any, w: any, t: any) => BaseCheck<I>;
+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 Ibdd_in_any> = (name: any, features: any, whens: any, thens: any, givenCB: any) => BaseGiven<I>;
+export type IWhenKlasser<I extends Ibdd_in_any> = (s: any, o: any) => BaseWhen<I>;
+export type IThenKlasser<I extends Ibdd_in_any> = (s: any, o: any) => BaseThen<I>;
+export type ICheckKlasser<I extends Ibdd_in_any> = (n: any, f: any, cb: any, w: any, t: any) => BaseCheck<I>;

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

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

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

@@ -0,0 +1,3 @@
+export declare const testReportPage: (packageName: string, domain: string) => string;
+export declare const testsReportPage: (packageName: string, domain: string, projects: any) => string;
+export declare const idkPage: (testName: string, domain: string) => string;