testeranto 0.49.10 → 0.62.0

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

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

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

@@ -0,0 +1,24 @@
+import { IBaseTest, ICheckKlasser, IGivenKlasser, ISuiteKlasser, ITestSpecification, IThenKlasser, IWhenKlasser } from "../Types";
+import { BaseCheck, BaseWhen, BaseThen, BaseGiven } from "./abstractBase.js";
+import { ITTestResourceRequest, ITestJob, ILogWriter } from ".";
+export declare abstract class BaseBuilder<ITestShape extends IBaseTest, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions, CheckExtensions> {
+    readonly input: ITestShape['iinput'];
+    specs: any;
+    assertThis: (t: any) => {};
+    testResourceRequirement: ITTestResourceRequest;
+    artifacts: Promise<unknown>[];
+    testJobs: ITestJob[];
+    testSpecification: ITestSpecification<ITestShape>;
+    suitesOverrides: Record<keyof SuiteExtensions, ISuiteKlasser<ITestShape>>;
+    givenOverides: Record<keyof GivenExtensions, IGivenKlasser<ITestShape>>;
+    whenOverides: Record<keyof WhenExtensions, IWhenKlasser<ITestShape>>;
+    thenOverides: Record<keyof ThenExtensions, IThenKlasser<ITestShape>>;
+    checkOverides: Record<keyof CheckExtensions, ICheckKlasser<ITestShape>>;
+    constructor(input: ITestShape['iinput'], suitesOverrides: Record<keyof SuiteExtensions, ISuiteKlasser<ITestShape>>, givenOverides: Record<keyof GivenExtensions, IGivenKlasser<ITestShape>>, whenOverides: Record<keyof WhenExtensions, IWhenKlasser<ITestShape>>, thenOverides: Record<keyof ThenExtensions, IThenKlasser<ITestShape>>, checkOverides: Record<keyof CheckExtensions, ICheckKlasser<ITestShape>>, logWriter: ILogWriter, testResourceRequirement: ITTestResourceRequest, testSpecification: any);
+    Specs(): any;
+    Suites(): Record<keyof SuiteExtensions, ISuiteKlasser<ITestShape>>;
+    Given(): Record<keyof GivenExtensions, (name: string, features: string[], whens: BaseWhen<ITestShape>[], thens: BaseThen<ITestShape>[], gcb: any) => BaseGiven<ITestShape>>;
+    When(): Record<keyof WhenExtensions, (arg0: ITestShape['istore'], ...arg1: any) => BaseWhen<ITestShape>>;
+    Then(): Record<keyof ThenExtensions, (selection: ITestShape['iselection'], expectation: any) => BaseThen<ITestShape>>;
+    Check(): Record<keyof CheckExtensions, (feature: string, callback: (whens: any, thens: any) => any, whens: any, thens: any, x: any) => BaseCheck<ITestShape>>;
+}

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

@@ -0,0 +1,6 @@
+import { Browser, Page } from "puppeteer-core";
+export declare class TBrowser {
+    browser: Browser;
+    constructor(browser: Browser);
+    pages(): Promise<Page[]>;
+}

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

@@ -0,0 +1,6 @@
+import type { IBaseTest, ICheckKlasser, IGivenKlasser, ISuiteKlasser, ITestImplementation, ITestSpecification, IThenKlasser, IWhenKlasser } from "../Types";
+import { BaseBuilder } from "./basebuilder.js";
+import { ILogWriter, ITTestResourceRequest } from ".";
+export declare abstract class ClassBuilder<ITestShape extends IBaseTest> extends BaseBuilder<ITestShape, any, any, any, any, any> {
+    constructor(testImplementation: ITestImplementation<ITestShape, any>, testSpecification: ITestSpecification<ITestShape>, input: ITestShape['iinput'], suiteKlasser: ISuiteKlasser<ITestShape>, givenKlasser: IGivenKlasser<ITestShape>, whenKlasser: IWhenKlasser<ITestShape>, thenKlasser: IThenKlasser<ITestShape>, checkKlasser: ICheckKlasser<ITestShape>, testResourceRequirement: ITTestResourceRequest, logWriter: ILogWriter);
+}

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

@@ -0,0 +1,7 @@
+import type { IBaseTest, ITestImplementation, ITestInterface, ITestSpecification, IUtils } from "../Types";
+import { ILogWriter, ITTestResourceConfiguration, ITTestResourceRequest, ITestJob } from "./index.js";
+import { ClassBuilder } from "./classBuilder.js";
+export default abstract class Testeranto<ITestShape extends IBaseTest> extends ClassBuilder<ITestShape> {
+    constructor(input: ITestShape['iinput'], testSpecification: ITestSpecification<ITestShape>, testImplementation: ITestImplementation<ITestShape, object>, testResourceRequirement: ITTestResourceRequest | undefined, logWriter: ILogWriter, testInterface: Partial<ITestInterface<ITestShape>>);
+    abstract receiveTestResourceConfig(t: ITestJob, partialTestResource: ITTestResourceConfiguration, utils: IUtils): any;
+}

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

@@ -0,0 +1,57 @@
+import { IBaseTest, ITestInterface, IUtils } from "../Types.js";
+import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen } from "./abstractBase.js";
+export declare const BaseTestInterface: ITestInterface<IBaseTest>;
+export declare const DefaultTestInterface: (p: Partial<ITestInterface<any>>) => ITestInterface<any>;
+export declare type ITTestResourceConfiguration = {
+    name: string;
+    fs: string;
+    ports: number[];
+    scheduled: boolean;
+};
+export declare type ITTestResourceRequirement = {
+    name: string;
+    ports: number;
+    fs: string;
+};
+export declare type ITTestResourceRequest = {
+    ports: number;
+};
+export declare type ITLog = (...string: any[]) => void;
+export declare type ILogWriter = {
+    createWriteStream: (line: string) => any | any;
+    writeFileSync: (fp: string, contents: string) => any;
+    mkdirSync: (fp: string) => any;
+    testArtiFactoryfileWriter: (tLog: ITLog, n: (Promise: any) => void) => (fPath: string, value: unknown) => void;
+};
+export declare type ITestArtificer = (key: string, data: any) => void;
+declare type ITest = {
+    toObj(): object;
+    name: string;
+    givens: IGivens<IBaseTest>;
+    checks: BaseCheck<IBaseTest>[];
+    testResourceConfiguration: ITTestResourceConfiguration;
+};
+export declare type ITestJob = {
+    toObj(): object;
+    test: ITest;
+    runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<BaseSuite<IBaseTest>>;
+    testResourceRequirement: ITTestResourceRequirement;
+    receiveTestResourceConfig: (testResource: any, utils: IUtils) => Promise<{
+        failed: number;
+        artifacts: Promise<unknown>[];
+        logPromise: Promise<unknown>;
+    }>;
+};
+export declare type ITestResults = Promise<{
+    test: ITest;
+}>[];
+export declare const defaultTestResourceRequirement: ITTestResourceRequest;
+export declare type ITestArtifactory = (key: string, value: unknown) => unknown;
+export declare type ITestCheckCallback<ITestShape extends IBaseTest> = {
+    [K in keyof ITestShape["checks"]]: (name: string, features: string[], callbackA: (whens: {
+        [K in keyof ITestShape["whens"]]: (...unknown: any[]) => BaseWhen<ITestShape>;
+    }, thens: {
+        [K in keyof ITestShape["thens"]]: (...unknown: any[]) => BaseThen<ITestShape>;
+    }) => Promise<any>, ...xtrasA: ITestShape["checks"][K]) => BaseCheck<ITestShape>;
+};
+export {};

package/dist/types/nodeWriterElectron.d.ts

@@ -0,0 +1,2 @@
+import { ILogWriter } from "./lib/index.js";
+export declare const NodeWriterElectron: ILogWriter;

package/dist/types/report.html.d.ts

@@ -0,0 +1,2 @@
+declare const _default: () => string;
+export default _default;