testeranto 0.38.0 → 0.38.1

package/dist/index.d.mts

@@ -0,0 +1,205 @@
+import { BaseFeature } from './Features';
+import { IBaseConfig } from "./IBaseConfig";
+export type { IBaseConfig };
+declare type ITTestResourceConfiguration = {
+    "fs": string;
+    "ports": number[];
+};
+export declare type ITTestResourceRequirement = {
+    "ports": number;
+    "fs": string;
+};
+declare type IRunner = (x: ITTestResourceConfiguration, t: ITLog) => Promise<boolean>;
+export declare type IT = {
+    toObj(): object;
+    name: string;
+    givens: BaseGiven<unknown, unknown, unknown, unknown, Record<string, BaseFeature>>[];
+    checks: BaseCheck<unknown, unknown, unknown, unknown, ITTestShape, unknown>[];
+    testResourceConfiguration: ITTestResourceConfiguration;
+};
+export declare type ITestJob = {
+    toObj(): object;
+    test: IT;
+    runner: IRunner;
+    testResourceRequirement: ITTestResourceRequirement;
+    receiveTestResourceConfig: (testResource?: any) => boolean;
+};
+export declare type ITestResults = Promise<{
+    test: IT;
+}>[];
+export declare type ITTestShape = {
+    suites: any;
+    givens: any;
+    whens: any;
+    thens: any;
+    checks: any;
+};
+export declare type ITestSpecification<ITestShape extends ITTestShape, IFeatureShape> = (Suite: {
+    [K in keyof ITestShape["suites"]]: (name: string, givens: BaseGiven<unknown, unknown, unknown, unknown, Record<string, BaseFeature>>[], checks: BaseCheck<unknown, unknown, unknown, unknown, ITestShape, IFeatureShape>[]) => BaseSuite<unknown, unknown, unknown, unknown, unknown, ITestShape, IFeatureShape>;
+}, Given: {
+    [K in keyof ITestShape["givens"]]: (features: (keyof IFeatureShape)[], whens: BaseWhen<unknown, unknown, unknown>[], thens: BaseThen<unknown, unknown, unknown>[], ...xtras: ITestShape["givens"][K]) => BaseGiven<unknown, unknown, unknown, unknown, unknown>;
+}, When: {
+    [K in keyof ITestShape["whens"]]: (...xtras: ITestShape["whens"][K]) => BaseWhen<unknown, unknown, unknown>;
+}, Then: {
+    [K in keyof ITestShape["thens"]]: (...xtras: ITestShape["thens"][K]) => BaseThen<unknown, unknown, unknown>;
+}, Check: {
+    [K in keyof ITestShape["checks"]]: (name: string, features: (keyof IFeatureShape)[], callbackA: (whens: {
+        [K in keyof ITestShape["whens"]]: (...unknown: any[]) => BaseWhen<unknown, unknown, unknown>;
+    }, thens: {
+        [K in keyof ITestShape["thens"]]: (...unknown: any[]) => BaseThen<unknown, unknown, unknown>;
+    }) => unknown, ...xtras: ITestShape["checks"][K]) => BaseCheck<unknown, unknown, unknown, unknown, ITestShape, IFeatureShape>;
+}) => any[];
+export declare type ITestImplementation<IState, ISelection, IWhenShape, IThenShape, ITestShape extends ITTestShape> = {
+    Suites: {
+        [K in keyof ITestShape["suites"]]: string;
+    };
+    Givens: {
+        [K in keyof ITestShape["givens"]]: (...Ig: ITestShape["givens"][K]) => IState;
+    };
+    Whens: {
+        [K in keyof ITestShape["whens"]]: (...Iw: ITestShape["whens"][K]) => (zel: ISelection) => IWhenShape;
+    };
+    Thens: {
+        [K in keyof ITestShape["thens"]]: (...It: ITestShape["thens"][K]) => (ssel: ISelection) => IThenShape;
+    };
+    Checks: {
+        [K in keyof ITestShape["checks"]]: (...Ic: ITestShape["checks"][K]) => IState;
+    };
+};
+declare type ITestArtifactory = (key: string, value: string) => unknown;
+declare type ITLog = (...string: any[]) => void;
+export declare abstract class BaseSuite<IInput, ISubject, IStore, ISelection, IThenShape, ITestShape extends ITTestShape, IFeatureShape> {
+    name: string;
+    givens: BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>[];
+    checks: BaseCheck<ISubject, IStore, ISelection, IThenShape, ITestShape, IFeatureShape>[];
+    store: IStore;
+    fails: BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>[];
+    testResourceConfiguration: ITTestResourceConfiguration;
+    constructor(name: string, givens?: BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>[], checks?: BaseCheck<ISubject, IStore, ISelection, IThenShape, ITestShape, IFeatureShape>[]);
+    toObj(): {
+        name: string;
+        givens: {
+            name: string;
+            whens: {
+                name: string;
+                error: boolean;
+            }[];
+            thens: {
+                name: string;
+                error: boolean;
+            }[];
+            errors: Error;
+            features: (keyof IFeatureShape)[];
+        }[];
+        fails: BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>[];
+    };
+    setup(s: IInput, artifactory: ITestArtifactory): Promise<ISubject>;
+    test(t: IThenShape): unknown;
+    run(input: any, testResourceConfiguration: ITTestResourceConfiguration, artifactory: (gndex: string) => (a: string, b: string) => void, tLog: (...string: any[]) => void): Promise<BaseSuite<IInput, ISubject, IStore, ISelection, IThenShape, ITestShape, IFeatureShape>>;
+}
+export declare abstract class BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape> {
+    name: string;
+    features: (keyof IFeatureShape)[];
+    whens: BaseWhen<IStore, ISelection, IThenShape>[];
+    thens: BaseThen<ISelection, IStore, IThenShape>[];
+    error: Error;
+    store: IStore;
+    recommendedFsPath: string;
+    constructor(name: string, features: (keyof IFeatureShape)[], whens: BaseWhen<IStore, ISelection, IThenShape>[], thens: BaseThen<ISelection, IStore, IThenShape>[]);
+    afterAll(store: IStore, artifactory: ITestArtifactory): void;
+    toObj(): {
+        name: string;
+        whens: {
+            name: string;
+            error: boolean;
+        }[];
+        thens: {
+            name: string;
+            error: boolean;
+        }[];
+        errors: Error;
+        features: (keyof IFeatureShape)[];
+    };
+    abstract givenThat(subject: ISubject, testResourceConfiguration: any, artifactory: ITestArtifactory): Promise<IStore>;
+    afterEach(store: IStore, ndx: number, artifactory: ITestArtifactory): Promise<unknown>;
+    give(subject: ISubject, index: number, testResourceConfiguration: any, tester: any, artifactory: ITestArtifactory, tLog: ITLog): Promise<IStore>;
+}
+export declare abstract class BaseWhen<IStore, ISelection, IThenShape> {
+    name: string;
+    actioner: (x: ISelection) => IThenShape;
+    error: boolean;
+    constructor(name: string, actioner: (xyz: ISelection) => IThenShape);
+    abstract andWhen(store: IStore, actioner: (x: ISelection) => IThenShape, testResource: any): any;
+    toObj(): {
+        name: string;
+        error: boolean;
+    };
+    test(store: IStore, testResourceConfiguration: any, tLog: ITLog): Promise<any>;
+}
+export declare abstract class BaseThen<ISelection, IStore, IThenShape> {
+    name: string;
+    thenCB: (storeState: ISelection) => IThenShape;
+    error: boolean;
+    constructor(name: string, thenCB: (val: ISelection) => IThenShape);
+    toObj(): {
+        name: string;
+        error: boolean;
+    };
+    abstract butThen(store: any, testResourceConfiguration?: any): Promise<ISelection>;
+    test(store: IStore, testResourceConfiguration: any, tLog: ITLog): Promise<IThenShape | undefined>;
+}
+export declare abstract class BaseCheck<ISubject, IStore, ISelection, IThenShape, ITestShape extends ITTestShape, IFeatureShape> {
+    name: string;
+    features: (keyof IFeatureShape)[];
+    checkCB: (whens: any, thens: any) => any;
+    whens: {
+        [K in keyof ITestShape["whens"]]: (p: any, tc: any) => BaseWhen<IStore, ISelection, IThenShape>;
+    };
+    thens: {
+        [K in keyof ITestShape["thens"]]: (p: any, tc: any) => BaseThen<ISelection, IStore, IThenShape>;
+    };
+    constructor(name: string, features: (keyof IFeatureShape)[], checkCB: (whens: any, thens: any) => any, whens: any, thens: any);
+    abstract checkThat(subject: ISubject, testResourceConfiguration: any, artifactory: ITestArtifactory): Promise<IStore>;
+    afterEach(store: IStore, ndx: number, cb?: any): Promise<unknown>;
+    check(subject: ISubject, ndx: number, testResourceConfiguration: any, tester: any, artifactory: ITestArtifactory, tLog: ITLog): Promise<void>;
+}
+export declare abstract class TesterantoLevelZero<IInput, ISubject, IStore, ISelection, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions, CheckExtensions, IThenShape, IFeatureShape> {
+    readonly cc: IStore;
+    constructorator: IStore;
+    suitesOverrides: Record<keyof SuiteExtensions, (name: string, givens: BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>[], checks: BaseCheck<ISubject, IStore, ISelection, IThenShape, ITTestShape, IFeatureShape>[]) => BaseSuite<IInput, ISubject, IStore, ISelection, IThenShape, ITTestShape, IFeatureShape>>;
+    givenOverides: Record<keyof GivenExtensions, (name: string, features: (keyof IFeatureShape)[], whens: BaseWhen<IStore, ISelection, IThenShape>[], thens: BaseThen<ISelection, IStore, IThenShape>[], ...xtraArgs: any[]) => BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>>;
+    whenOverides: Record<keyof WhenExtensions, (any: any) => BaseWhen<IStore, ISelection, IThenShape>>;
+    thenOverides: Record<keyof ThenExtensions, (selection: ISelection, expectation: any) => BaseThen<ISelection, IStore, IThenShape>>;
+    checkOverides: Record<keyof CheckExtensions, (feature: string, callback: (whens: any, thens: any) => any, ...xtraArgs: any[]) => BaseCheck<ISubject, IStore, ISelection, IThenShape, ITTestShape, IFeatureShape>>;
+    constructor(cc: IStore, suitesOverrides: Record<keyof SuiteExtensions, (name: string, givens: BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>[], checks: BaseCheck<ISubject, IStore, ISelection, IThenShape, ITTestShape, IFeatureShape>[]) => BaseSuite<IInput, ISubject, IStore, ISelection, IThenShape, ITTestShape, IFeatureShape>>, givenOverides: Record<keyof GivenExtensions, (name: string, features: (keyof IFeatureShape)[], whens: BaseWhen<IStore, ISelection, IThenShape>[], thens: BaseThen<ISelection, IStore, IThenShape>[], ...xtraArgs: any[]) => BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>>, whenOverides: Record<keyof WhenExtensions, (c: any) => BaseWhen<IStore, ISelection, IThenShape>>, thenOverides: Record<keyof ThenExtensions, (selection: ISelection, expectation: any) => BaseThen<ISelection, IStore, IThenShape>>, checkOverides: Record<keyof CheckExtensions, (feature: string, callback: (whens: any, thens: any) => any, ...xtraArgs: any[]) => BaseCheck<ISubject, IStore, ISelection, IThenShape, ITTestShape, IFeatureShape>>);
+    Suites(): Record<keyof SuiteExtensions, (name: string, givens: BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>[], checks: BaseCheck<ISubject, IStore, ISelection, IThenShape, ITTestShape, IFeatureShape>[]) => BaseSuite<IInput, ISubject, IStore, ISelection, IThenShape, ITTestShape, IFeatureShape>>;
+    Given(): Record<keyof GivenExtensions, (name: string, features: (keyof IFeatureShape)[], whens: BaseWhen<IStore, ISelection, IThenShape>[], thens: BaseThen<ISelection, IStore, IThenShape>[], ...xtraArgs: any[]) => BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>>;
+    When(): Record<keyof WhenExtensions, (arg0: IStore, ...arg1: any) => BaseWhen<IStore, ISelection, IThenShape>>;
+    Then(): Record<keyof ThenExtensions, (selection: ISelection, expectation: any) => BaseThen<ISelection, IStore, IThenShape>>;
+    Check(): Record<keyof CheckExtensions, (feature: string, callback: (whens: any, thens: any) => any, whens: any, thens: any) => BaseCheck<ISubject, IStore, ISelection, IThenShape, ITTestShape, IFeatureShape>>;
+}
+export declare abstract class TesterantoLevelOne<ITestShape extends ITTestShape, IInitialState, ISelection, IStore, ISubject, IWhenShape, IThenShape, IInput, IFeatureShape extends Record<string, BaseFeature>> {
+    constructor(testImplementation: ITestImplementation<IInitialState, ISelection, IWhenShape, IThenShape, ITestShape>, testSpecification: (Suite: {
+        [K in keyof ITestShape["suites"]]: (feature: string, givens: BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>[], checks: BaseCheck<ISubject, IStore, ISelection, IThenShape, ITestShape, IFeatureShape>[]) => BaseSuite<IInput, ISubject, IStore, ISelection, IThenShape, ITestShape, IFeatureShape>;
+    }, Given: {
+        [K in keyof ITestShape["givens"]]: (name: string, features: (keyof IFeatureShape)[], whens: BaseWhen<IStore, ISelection, IThenShape>[], thens: BaseThen<ISelection, IStore, IThenShape>[], ...a: ITestShape["givens"][K]) => BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>;
+    }, When: {
+        [K in keyof ITestShape["whens"]]: (...a: ITestShape["whens"][K]) => BaseWhen<IStore, ISelection, IThenShape>;
+    }, Then: {
+        [K in keyof ITestShape["thens"]]: (...a: ITestShape["thens"][K]) => BaseThen<ISelection, IStore, IThenShape>;
+    }, Check: {
+        [K in keyof ITestShape["checks"]]: (name: string, features: (keyof IFeatureShape)[], cbz: (...any: any[]) => Promise<void>) => any;
+    }) => BaseSuite<IInput, ISubject, IStore, ISelection, IThenShape, ITestShape, IFeatureShape>[], input: IInput, suiteKlasser: (name: string, givens: BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>[], checks: BaseCheck<ISubject, IStore, ISelection, IThenShape, ITestShape, IFeatureShape>[]) => BaseSuite<IInput, ISubject, IStore, ISelection, IThenShape, ITestShape, IFeatureShape>, givenKlasser: (n: any, f: any, w: any, t: any, z?: any) => BaseGiven<ISubject, IStore, ISelection, IThenShape, IFeatureShape>, whenKlasser: (s: any, o: any) => BaseWhen<IStore, ISelection, IThenShape>, thenKlasser: (s: any, o: any) => BaseThen<IStore, ISelection, IThenShape>, checkKlasser: (n: any, f: any, cb: any, w: any, t: any) => BaseCheck<ISubject, IStore, ISelection, IThenShape, ITestShape, IFeatureShape>, testResourceRequirement: any, nameKey: string);
+}
+declare type ITestArtificer = (key: string, data: any) => void;
+declare const _default: <TestShape extends ITTestShape, Input, Subject, Store, Selection_1, WhenShape, ThenShape, InitialStateShape, IFeatureShape extends Record<string, BaseFeature>>(input: Input, testSpecification: ITestSpecification<TestShape, IFeatureShape>, testImplementation: any, testInterface: {
+    actionHandler?: ((b: (...any: any[]) => any) => any) | undefined;
+    andWhen: (store: Store, actioner: any, testResource: ITTestResourceConfiguration) => Promise<Selection_1>;
+    butThen?: ((store: Store, callback: any, testResource: ITTestResourceConfiguration) => Promise<Selection_1>) | undefined;
+    assertioner?: ((t: ThenShape) => any) | undefined;
+    afterAll?: ((store: Store, artificer: ITestArtificer) => any) | undefined;
+    afterEach?: ((store: Store, ndx: number, artificer: ITestArtificer) => Promise<unknown>) | undefined;
+    beforeAll?: ((input: Input, artificer: ITestArtificer) => Promise<Subject>) | undefined;
+    beforeEach?: ((subject: Subject, initialValues: any, testResource: ITTestResourceConfiguration, artificer: ITestArtificer) => Promise<Store>) | undefined;
+}, nameKey: string, testResourceRequirement?: ITTestResourceRequirement) => Promise<void>;
+export default _default;

package/dist/index.mjs

@@ -0,0 +1,468 @@
+import fs from 'fs';
+import path from 'path';
+const defaultTestResource = { "fs": ".", ports: [] };
+const defaultTestResourceRequirement = { "fs": ".", ports: 0 };
+const fPaths = [];
+const testArtiFactoryfileWriter = (tLog) => (fp) => (givenNdx) => (key, value) => {
+    tLog("testArtiFactory =>", key);
+    const fPath = `${fp}/${givenNdx}/${key}`;
+    const cleanPath = path.resolve(fPath);
+    fPaths.push(cleanPath.replace(process.cwd(), ``));
+    const targetDir = cleanPath.split('/').slice(0, -1).join('/');
+    fs.mkdir(targetDir, { recursive: true }, async (error) => {
+        if (error) {
+            console.error(`❗️testArtiFactory failed`, targetDir, error);
+        }
+        fs.writeFileSync(path.resolve(targetDir.split('/').slice(0, -1).join('/'), "manifest"), fPaths.join(`\n`), {
+            encoding: 'utf-8'
+        });
+        if (Buffer.isBuffer(value)) {
+            fs.writeFileSync(fPath, value, "binary");
+        }
+        else if (`string` === (typeof value)) {
+            fs.writeFileSync(fPath, value.toString(), {
+                encoding: 'utf-8'
+            });
+        }
+        else {
+            /* @ts-ignore:next-line */
+            const pipeStream = value;
+            var myFile = fs.createWriteStream(fPath);
+            pipeStream.pipe(myFile);
+            pipeStream.on("close", () => {
+                myFile.close();
+            });
+        }
+    });
+};
+export class BaseSuite {
+    constructor(name, givens = [], checks = []) {
+        this.name = name;
+        this.givens = givens;
+        this.checks = checks;
+        this.fails = [];
+    }
+    toObj() {
+        return {
+            name: this.name,
+            givens: this.givens.map((g) => g.toObj()),
+            fails: this.fails
+        };
+    }
+    setup(s, artifactory) {
+        return new Promise((res) => res(s));
+    }
+    test(t) {
+        return t;
+    }
+    async run(input, testResourceConfiguration, artifactory, tLog) {
+        this.testResourceConfiguration = testResourceConfiguration;
+        const subject = await this.setup(input, artifactory("-1"));
+        tLog("\nSuite:", this.name, testResourceConfiguration);
+        for (const [ndx, giver] of this.givens.entries()) {
+            try {
+                this.store = await giver.give(subject, ndx, testResourceConfiguration, this.test, artifactory(ndx.toString()), tLog);
+            }
+            catch (e) {
+                console.error(e);
+                this.fails.push(giver);
+                return this;
+            }
+        }
+        for (const [ndx, thater] of this.checks.entries()) {
+            await thater.check(subject, ndx, testResourceConfiguration, this.test, artifactory, tLog);
+        }
+        // @TODO fix me
+        for (const [ndx, giver] of this.givens.entries()) {
+            giver.afterAll(this.store, artifactory);
+        }
+        ////////////////
+        return this;
+    }
+}
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+export class BaseGiven {
+    constructor(name, features, whens, thens) {
+        this.name = name;
+        this.features = features;
+        this.whens = whens;
+        this.thens = thens;
+    }
+    afterAll(store, artifactory) {
+        return;
+    }
+    ;
+    toObj() {
+        return {
+            name: this.name,
+            whens: this.whens.map((w) => w.toObj()),
+            thens: this.thens.map((t) => t.toObj()),
+            errors: this.error,
+            features: this.features,
+        };
+    }
+    async afterEach(store, ndx, artifactory) {
+        return;
+    }
+    async give(subject, index, testResourceConfiguration, tester, artifactory, tLog) {
+        tLog(`\n Given: ${this.name}`);
+        try {
+            this.store = await this.givenThat(subject, testResourceConfiguration, artifactory);
+            for (const whenStep of this.whens) {
+                await whenStep.test(this.store, testResourceConfiguration, tLog);
+            }
+            for (const thenStep of this.thens) {
+                const t = await thenStep.test(this.store, testResourceConfiguration, tLog);
+                tester(t);
+            }
+        }
+        catch (e) {
+            this.error = e;
+            tLog('\u0007'); // bell
+            // throw e;
+        }
+        finally {
+            try {
+                await this.afterEach(this.store, index, artifactory);
+            }
+            catch (_a) {
+                console.error("afterEach failed! no error will be recorded!");
+            }
+        }
+        return this.store;
+    }
+}
+export class BaseWhen {
+    constructor(name, actioner) {
+        this.name = name;
+        this.actioner = actioner;
+    }
+    toObj() {
+        return {
+            name: this.name,
+            error: this.error,
+        };
+    }
+    async test(store, testResourceConfiguration, tLog) {
+        tLog(" When:", this.name);
+        try {
+            return await this.andWhen(store, this.actioner, testResourceConfiguration);
+        }
+        catch (e) {
+            this.error = true;
+            throw e;
+        }
+    }
+}
+export class BaseThen {
+    constructor(name, thenCB) {
+        this.name = name;
+        this.thenCB = thenCB;
+    }
+    toObj() {
+        return {
+            name: this.name,
+            error: this.error,
+        };
+    }
+    async test(store, testResourceConfiguration, tLog) {
+        tLog(" Then:", this.name);
+        try {
+            return this.thenCB(await this.butThen(store, testResourceConfiguration));
+        }
+        catch (e) {
+            console.log("wtf");
+            this.error = true;
+            throw e;
+        }
+        // try {
+        //   return await (this.thenCB(
+        //     await (async () => {
+        //       try {
+        //         return await (
+        //           (() => {
+        //             try {
+        //               return this.butThen(store, testResourceConfiguration)
+        //             } catch (e) {
+        //               this.error = true;
+        //               throw e
+        //             }
+        //           })()
+        //         );
+        //       } catch (e) {
+        //         this.error = true;
+        //         throw e
+        //       }
+        //     })()
+        //   ));
+        // } catch (e) {
+        //   this.error = true;
+        //   throw e
+        // }
+    }
+}
+export class BaseCheck {
+    constructor(name, features, checkCB, whens, thens) {
+        this.name = name;
+        this.features = features;
+        this.checkCB = checkCB;
+        this.whens = whens;
+        this.thens = thens;
+    }
+    async afterEach(store, ndx, cb) {
+        return;
+    }
+    async check(subject, ndx, testResourceConfiguration, tester, artifactory, tLog) {
+        tLog(`\n Check: ${this.name}`);
+        const store = await this.checkThat(subject, testResourceConfiguration, artifactory);
+        await this.checkCB((Object.entries(this.whens)
+            .reduce((a, [key, when]) => {
+            a[key] = async (payload) => {
+                return await when(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog);
+            };
+            return a;
+        }, {})), (Object.entries(this.thens)
+            .reduce((a, [key, then]) => {
+            a[key] = async (payload) => {
+                const t = await then(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog);
+                tester(t);
+            };
+            return a;
+        }, {})));
+        await this.afterEach(store, ndx);
+        return;
+    }
+}
+///////////////////////////////////////////////////////////////////////////////////////////////////////////
+export class TesterantoLevelZero {
+    constructor(cc, suitesOverrides, givenOverides, whenOverides, thenOverides, checkOverides) {
+        this.cc = cc;
+        this.constructorator = cc;
+        this.suitesOverrides = suitesOverrides;
+        this.givenOverides = givenOverides;
+        this.whenOverides = whenOverides;
+        this.thenOverides = thenOverides;
+        this.checkOverides = checkOverides;
+    }
+    Suites() {
+        return this.suitesOverrides;
+    }
+    Given() {
+        return this.givenOverides;
+    }
+    When() {
+        return this.whenOverides;
+    }
+    Then() {
+        return this.thenOverides;
+    }
+    Check() {
+        return this.checkOverides;
+    }
+}
+export class TesterantoLevelOne {
+    constructor(testImplementation, testSpecification, input, suiteKlasser, givenKlasser, whenKlasser, thenKlasser, checkKlasser, testResourceRequirement, nameKey) {
+        const classySuites = Object.entries(testImplementation.Suites)
+            .reduce((a, [key]) => {
+            a[key] = (somestring, givens, checks) => {
+                return new suiteKlasser.prototype.constructor(somestring, givens, checks);
+            };
+            return a;
+        }, {});
+        const classyGivens = Object.entries(testImplementation.Givens)
+            .reduce((a, [key, z]) => {
+            a[key] = (features, whens, thens, ...xtrasW) => {
+                return new givenKlasser.prototype.constructor(z.name, features, whens, thens, z(...xtrasW));
+            };
+            return a;
+        }, {});
+        const classyWhens = Object.entries(testImplementation.Whens)
+            .reduce((a, [key, whEn]) => {
+            a[key] = (payload) => {
+                return new whenKlasser.prototype.constructor(`${whEn.name}: ${payload && payload.toString()}`, whEn(payload));
+            };
+            return a;
+        }, {});
+        const classyThens = Object.entries(testImplementation.Thens)
+            .reduce((a, [key, thEn]) => {
+            a[key] = (expected, x) => {
+                return new thenKlasser.prototype.constructor(`${thEn.name}: ${expected && expected.toString()}`, thEn(expected));
+            };
+            return a;
+        }, {});
+        const classyChecks = Object.entries(testImplementation.Checks)
+            .reduce((a, [key, z]) => {
+            a[key] = (somestring, features, callback) => {
+                return new checkKlasser.prototype.constructor(somestring, features, callback, classyWhens, classyThens);
+            };
+            return a;
+        }, {});
+        const classyTesteranto = new (class extends TesterantoLevelZero {
+        })(input, classySuites, classyGivens, classyWhens, classyThens, classyChecks);
+        const suites = testSpecification(
+        /* @ts-ignore:next-line */
+        classyTesteranto.Suites(), classyTesteranto.Given(), classyTesteranto.When(), classyTesteranto.Then(), classyTesteranto.Check());
+        const suiteRunner = (suite) => (testResourceConfiguration, tLog) => {
+            return suite.run(input, testResourceConfiguration, testArtiFactoryfileWriter(tLog)(testResourceConfiguration.fs + "/"), tLog);
+        };
+        /* @ts-ignore:next-line */
+        const toReturn = suites.map((suite) => {
+            const runner = suiteRunner(suite);
+            return {
+                test: suite,
+                testResourceRequirement,
+                toObj: () => {
+                    return suite.toObj();
+                },
+                runner,
+                receiveTestResourceConfig: async function (testResourceConfiguration = defaultTestResource) {
+                    console.log(`testResourceConfiguration ${JSON.stringify(testResourceConfiguration, null, 2)}`);
+                    await fs.mkdirSync(testResourceConfiguration.fs, { recursive: true });
+                    const logFilePath = path.resolve(`${testResourceConfiguration.fs}/log.txt`);
+                    var access = fs.createWriteStream(logFilePath);
+                    const tLog = (...l) => {
+                        console.log(...l);
+                        access.write(`${l.toString()}\n`);
+                    };
+                    const suiteDone = await runner(testResourceConfiguration, tLog);
+                    const resultsFilePath = path.resolve(`${testResourceConfiguration.fs}/results.json`);
+                    fs.writeFileSync(resultsFilePath, JSON.stringify(suiteDone.toObj(), null, 2));
+                    access.close();
+                    const numberOfFailures = suiteDone.givens.filter((g) => g.error).length;
+                    console.log(`exiting gracefully with ${numberOfFailures} failures.`);
+                    process.exitCode = numberOfFailures;
+                }
+            };
+        });
+        return toReturn;
+    }
+}
+export default async (input, testSpecification, testImplementation, testInterface, nameKey, testResourceRequirement = defaultTestResourceRequirement) => {
+    const butThen = testInterface.butThen || (async (a) => a);
+    const { andWhen } = testInterface;
+    const actionHandler = testInterface.actionHandler || function (b) {
+        return b;
+    };
+    const assertioner = testInterface.assertioner || (async (t) => t);
+    const beforeAll = testInterface.beforeAll || (async (input) => input);
+    const beforeEach = testInterface.beforeEach || async function (subject, initialValues, testResource) {
+        return subject;
+    };
+    const afterEach = testInterface.afterEach || (async (s) => s);
+    const afterAll = testInterface.afterAll || ((store) => undefined);
+    class MrT extends TesterantoLevelOne {
+        constructor() {
+            super(testImplementation, 
+            /* @ts-ignore:next-line */
+            testSpecification, input, (class extends BaseSuite {
+                async setup(s, artifactory) {
+                    return beforeAll(s, artifactory);
+                }
+                test(t) {
+                    return assertioner(t);
+                }
+            }), class Given extends BaseGiven {
+                constructor(name, features, whens, thens, initialValues) {
+                    super(name, features, whens, thens);
+                    this.initialValues = initialValues;
+                }
+                async givenThat(subject, testResource, artifactory) {
+                    return beforeEach(subject, this.initialValues, testResource, artifactory);
+                }
+                afterEach(store, ndx, artifactory) {
+                    return new Promise((res) => res(afterEach(store, ndx, artifactory)));
+                }
+                afterAll(store, artifactory) {
+                    return afterAll(store, artifactory);
+                }
+            }, class When extends BaseWhen {
+                constructor(name, actioner, payload) {
+                    super(name, (store) => {
+                        return actionHandler(actioner);
+                    });
+                    this.payload = payload;
+                }
+                async andWhen(store, actioner, testResource) {
+                    return await andWhen(store, actioner, testResource);
+                }
+            }, class Then extends BaseThen {
+                constructor(name, callback) {
+                    super(name, callback);
+                }
+                async butThen(store, testResourceConfiguration) {
+                    return await butThen(store, this.thenCB, testResourceConfiguration);
+                }
+            }, class Check extends BaseCheck {
+                constructor(name, features, checkCallback, whens, thens, initialValues) {
+                    super(name, features, checkCallback, whens, thens);
+                    this.initialValues = initialValues;
+                }
+                async checkThat(subject, testResourceConfiguration, artifactory) {
+                    return beforeEach(subject, this.initialValues, testResourceConfiguration, artifactory);
+                }
+                afterEach(store, ndx, artifactory) {
+                    return new Promise((res) => res(afterEach(store, ndx, artifactory)));
+                }
+            }, testResourceRequirement, nameKey);
+        }
+    }
+    const mrt = new MrT();
+    const t = mrt[0];
+    const testResourceArg = process.argv[2] || `{}`;
+    try {
+        const partialTestResource = JSON.parse(testResourceArg);
+        if (partialTestResource.fs && partialTestResource.ports) {
+            await t.receiveTestResourceConfig(partialTestResource);
+            // process.exit(0); // :-)
+        }
+        else {
+            console.log("test configuration is incomplete");
+            if (process.send) {
+                console.log("requesting test resources from pm2 ...", testResourceRequirement);
+                /* @ts-ignore:next-line */
+                process.send({
+                    type: 'testeranto:hola',
+                    data: {
+                        testResourceRequirement
+                    }
+                });
+                console.log("awaiting test resources from pm2...");
+                process.on('message', async function (packet) {
+                    const resourcesFromPm2 = packet.data.testResourceConfiguration;
+                    const secondTestResource = (Object.assign(Object.assign({}, JSON.parse(JSON.stringify(resourcesFromPm2))), JSON.parse(JSON.stringify(partialTestResource))));
+                    if (await t.receiveTestResourceConfig(secondTestResource)) {
+                        /* @ts-ignore:next-line */
+                        process.send({
+                            type: 'testeranto:adios',
+                            data: {
+                                testResourceConfiguration: mrt[0].test.testResourceConfiguration,
+                                results: mrt[0].toObj()
+                            }
+                        }, (err) => {
+                            if (!err) {
+                                console.log(`✅`);
+                            }
+                            else {
+                                console.error(`❗️`, err);
+                            }
+                            // process.exit(0); // :-)
+                        });
+                    }
+                });
+            }
+            else {
+                console.log("Pass run-time test resources by STDIN");
+                process.stdin.on('data', async (data) => {
+                    const resourcesFromStdin = JSON.parse(data.toString());
+                    const secondTestResource = (Object.assign(Object.assign({}, JSON.parse(JSON.stringify(resourcesFromStdin))), JSON.parse(JSON.stringify(partialTestResource))));
+                    await t.receiveTestResourceConfig(secondTestResource);
+                    // process.exit(0); // :-)
+                });
+            }
+        }
+    }
+    catch (e) {
+        console.error(`the test resource passed by command-line arugument "${process.argv[2]}" was malformed.`);
+        process.exit(-1);
+    }
+};