testeranto 0.111.0 → 0.112.0

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

@@ -0,0 +1,110 @@
+import { PM } from "../PM/index.js";
+import { ITTestResourceConfiguration, ITestArtifactory, ITLog } from ".";
+import { Ibdd_in, Ibdd_out } from "../Types.js";
+export type IGivens<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = Record<string, BaseGiven<I>>;
+export declare abstract class BaseSuite<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>>> {
+    name: string;
+    givens: IGivens<I>;
+    checks: BaseCheck<I, O>[];
+    store: I["istore"];
+    fails: BaseGiven<I>[];
+    testResourceConfiguration: ITTestResourceConfiguration;
+    index: number;
+    constructor(name: string, index: number, givens?: IGivens<I>, checks?: BaseCheck<I, O>[]);
+    features(): string[];
+    toObj(): {
+        name: string;
+        givens: {
+            key: string;
+            name: string;
+            whens: {
+                name: string;
+                error: boolean;
+            }[];
+            thens: {
+                name: string;
+                error: boolean;
+            }[];
+            error: (string | Error | undefined)[] | null;
+            features: string[];
+        }[];
+        fails: BaseGiven<I>[];
+        features: string[];
+    };
+    setup(s: I["iinput"], artifactory: ITestArtifactory, tr: ITTestResourceConfiguration, pm: PM): Promise<I["isubject"]>;
+    assertThat(t: I["then"]): unknown;
+    afterAll(store: I["istore"], artifactory: ITestArtifactory, pm: PM): I["istore"];
+    run(input: I["iinput"], testResourceConfiguration: ITTestResourceConfiguration, artifactory: (fPath: string, value: unknown) => void, tLog: (...string: any[]) => void, pm: PM): Promise<BaseSuite<I, O>>;
+}
+export declare abstract class BaseGiven<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> {
+    name: string;
+    features: string[];
+    whens: BaseWhen<I>[];
+    thens: BaseThen<I>[];
+    error: Error;
+    fail: any;
+    store: I["istore"];
+    recommendedFsPath: string;
+    givenCB: I["given"];
+    initialValues: any;
+    key: string;
+    constructor(name: string, features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], givenCB: I["given"], initialValues: any);
+    beforeAll(store: I["istore"], initializer: any, artifactory: any, testResource: any, initialValues: any, pm: any): I["istore"];
+    toObj(): {
+        key: string;
+        name: string;
+        whens: {
+            name: string;
+            error: boolean;
+        }[];
+        thens: {
+            name: string;
+            error: boolean;
+        }[];
+        error: (string | Error | undefined)[] | null;
+        features: string[];
+    };
+    abstract givenThat(subject: I["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, givenCB: I["given"], initialValues: any, pm: PM): Promise<I["istore"]>;
+    afterEach(store: I["istore"], key: string, artifactory: ITestArtifactory, pm: PM): 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: PM, suiteNdx: number): Promise<I["istore"]>;
+}
+export declare abstract class BaseWhen<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> {
+    name: string;
+    whenCB: (x: I["iselection"]) => I["then"];
+    error: boolean;
+    constructor(name: string, whenCB: (xyz: I["iselection"]) => I["then"]);
+    abstract andWhen(store: I["istore"], whenCB: (x: I["iselection"]) => I["then"], testResource: any, pm: PM): Promise<any>;
+    toObj(): {
+        name: string;
+        error: boolean;
+    };
+    test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: PM, filepath: string): Promise<any>;
+}
+export declare abstract class BaseThen<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> {
+    name: string;
+    thenCB: (storeState: I["iselection"]) => I["then"];
+    error: boolean;
+    constructor(name: string, thenCB: (val: I["iselection"]) => I["then"]);
+    toObj(): {
+        name: string;
+        error: boolean;
+    };
+    abstract butThen(store: I["istore"], thenCB: any, testResourceConfiguration: ITTestResourceConfiguration, pm: PM): Promise<I["iselection"]>;
+    test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: PM, filepath: string): Promise<I["then"] | undefined>;
+}
+export declare abstract class BaseCheck<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>>> {
+    name: string;
+    features: string[];
+    checkCB: (whens: any, thens: any) => any;
+    whens: {
+        [K in keyof O["whens"]]: (p: any, tc: any) => BaseWhen<I>;
+    };
+    thens: {
+        [K in keyof O["thens"]]: (p: any, tc: any) => BaseThen<I>;
+    };
+    constructor(name: string, features: string[], checkCB: (whens: any, thens: any) => any, whens: any, thens: any);
+    abstract checkThat(subject: I["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, pm: PM): Promise<I["istore"]>;
+    afterEach(store: I["istore"], key: string, cb: any, pm: PM): Promise<unknown>;
+    check(subject: I["isubject"], key: string, testResourceConfiguration: any, tester: any, artifactory: ITestArtifactory, tLog: ITLog, pm: PM): Promise<void>;
+}

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

@@ -0,0 +1,27 @@
+import { ITTestResourceRequest, ITestJob } from ".";
+import { Ibdd_in, Ibdd_out, ITestSpecification } from "../Types.js";
+import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser } from "./types.js";
+import { BaseCheck, BaseWhen, BaseThen, BaseGiven } from "./abstractBase.js";
+import { PM } from "../PM/index.js";
+export declare abstract class BaseBuilder<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>>, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions, CheckExtensions> {
+    readonly input: I["iinput"];
+    specs: any;
+    assertThis: (t: I["then"]) => {};
+    testResourceRequirement: ITTestResourceRequest;
+    artifacts: Promise<unknown>[];
+    testJobs: ITestJob[];
+    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(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);
+    Specs(): any;
+    Suites(): Record<keyof SuiteExtensions, ISuiteKlasser<I, O>>;
+    Given(): Record<keyof GivenExtensions, (name: string, features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], gcb: any) => BaseGiven<I>>;
+    When(): Record<keyof WhenExtensions, (arg0: I["istore"], ...arg1: any) => BaseWhen<I>>;
+    Then(): Record<keyof ThenExtensions, (selection: I["iselection"], expectation: any) => BaseThen<I>>;
+    Check(): Record<keyof CheckExtensions, (feature: string, callback: (whens: any, thens: any) => any, whens: any, thens: any, x: any) => BaseCheck<I, O>>;
+}

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

@@ -0,0 +1,7 @@
+import { Ibdd_in, Ibdd_out, ITestImplementation, ITestSpecification } from "../Types.js";
+import { BaseBuilder } from "./basebuilder.js";
+import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser } from "./types.js";
+import { ITTestResourceRequest } from "./index.js";
+export declare abstract class ClassBuilder<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<I, O, any, any, any, any, any> {
+    constructor(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);
+}

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

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

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

@@ -0,0 +1,83 @@
+import { PM } from "../PM/index.js";
+import { Ibdd_in, Ibdd_out, ITestInterface } from "../Types.js";
+import { IGivens, BaseCheck, BaseSuite } from "./abstractBase.js";
+export declare const BaseTestInterface: ITestInterface<Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>>;
+export declare const DefaultTestInterface: (p: Partial<ITestInterface<any>>) => ITestInterface<any>;
+export type ITTestResourceConfiguration = {
+    name: string;
+    fs: string;
+    ports: number[];
+    browserWSEndpoint: string;
+};
+export type ITTestResourceRequirement = {
+    name: string;
+    ports: number;
+    fs: string;
+};
+export type ITTestResourceRequest = {
+    ports: number;
+};
+export type ITLog = (...string: any[]) => void;
+export type ILogWriter = {
+    createWriteStream: (line: string) => any | any;
+    writeFileSync: (fp: string, contents: string) => any;
+    mkdirSync: () => any;
+    testArtiFactoryfileWriter: (tLog: ITLog, n: (Promise: any) => void) => (fPath: string, value: unknown) => void;
+};
+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<Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>[];
+    testResourceConfiguration: ITTestResourceConfiguration;
+};
+export type ITestJob<T = PM> = {
+    toObj(): object;
+    test: ITest;
+    runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<BaseSuite<Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>, Ibdd_out<Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>, Record<string, any>>>>;
+    testResourceRequirement: ITTestResourceRequirement;
+    receiveTestResourceConfig: (pm: PM) => Promise<{
+        failed: number;
+        artifacts: Promise<unknown>[];
+        logPromise: Promise<unknown>;
+        features: string[];
+    }>;
+};
+export type ITestResults = Promise<{
+    test: ITest;
+}>[];
+export declare const defaultTestResourceRequirement: ITTestResourceRequest;
+export type ITestArtifactory = (key: string, value: unknown) => unknown;
+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: any, sources: any) => any, entrypoints: any) => 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;
+export {};

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

@@ -0,0 +1,14 @@
+import { Ibdd_in, Ibdd_out } from "../Types";
+import { IGivens, BaseCheck, BaseSuite, BaseGiven, BaseWhen, BaseThen } from "./abstractBase";
+export type ITestCheckCallback<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>>> = {
+    [K in keyof O["checks"]]: (name: string, features: string[], callbackA: (whens: {
+        [K in keyof O["whens"]]: (...unknown: any[]) => BaseWhen<I>;
+    }, thens: {
+        [K in keyof O["thens"]]: (...unknown: any[]) => BaseThen<I>;
+    }) => Promise<any>, ...xtrasA: O["checks"][K]) => BaseCheck<I, O>;
+};
+export type ISuiteKlasser<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>>> = (name: string, index: number, givens: IGivens<I>, checks: BaseCheck<I, O>[]) => BaseSuite<I, O>;
+export type IGivenKlasser<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = (name: any, features: any, whens: any, thens: any, givenCB: any) => BaseGiven<I>;
+export type IWhenKlasser<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = (s: any, o: any) => BaseWhen<I>;
+export type IThenKlasser<I extends Ibdd_in<unknown, unknown, unknown, unknown, unknown, unknown, unknown>> = (s: any, o: any) => BaseThen<I>;
+export type ICheckKlasser<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>>> = (n: any, f: any, cb: any, w: any, t: any) => BaseCheck<I, O>;

package/dist/types/puppeteerConfiger.d.ts

@@ -0,0 +1,4 @@
+declare const _default: (port: string) => Promise<{
+    webSocketDebuggerUrl: string;
+}>;
+export default _default;

package/dist/types/run.d.ts

@@ -0,0 +1 @@
+export {};