testeranto 0.49.10 → 0.70.0

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

@@ -0,0 +1,8 @@
+import { IBaseTest, ITestSpecification, ITestImplementation } from "../Types.js";
+import { ITestInterface, IUtils } from "./types.js";
+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>, 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,58 @@
+import { IBaseTest } from "../Types.js";
+import { IGivens, BaseCheck, BaseSuite, BaseWhen, BaseThen } from "./abstractBase.js";
+import { INodeUtils, ITestInterface, IWebUtils } from "./types.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<T = INodeUtils | IWebUtils> = {
+    toObj(): object;
+    test: ITest;
+    runner: (x: ITTestResourceConfiguration, t: ITLog) => Promise<BaseSuite<IBaseTest>>;
+    testResourceRequirement: ITTestResourceRequirement;
+    receiveTestResourceConfig: (testResource: any, utils: T) => 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/lib/types.d.ts

@@ -0,0 +1,70 @@
+/// <reference types="electron" />
+import { IBaseTest } from "../Types";
+import puppeteer from "puppeteer-core";
+import { IGivens, BaseCheck, BaseSuite, BaseGiven, BaseWhen, BaseThen } from "./abstractBase";
+import { ITTestResourceConfiguration, ITestArtificer } from ".";
+export declare type IRunTime = `node` | `web`;
+export declare type ITestTypes = [string, IRunTime, ITestTypes[]];
+export declare type IJsonConfig = {
+    outdir: string;
+    tests: ITestTypes[];
+    features: string;
+};
+export declare type IBaseConfig = {
+    clearScreen: boolean;
+    debugger: boolean;
+    devMode: boolean;
+    externals: string[];
+    features: string;
+    minify: boolean;
+    nodePlugins: any[];
+    outbase: string;
+    outdir: string;
+    ports: string[];
+    tests: ITestTypes[];
+    webPlugins: any[];
+};
+export declare type IBuiltConfig = {
+    buildDir: string;
+} & IBaseConfig;
+export declare type INodeUtils = {
+    browser: puppeteer.Browser;
+    ipc: Electron.ParentPort;
+};
+export declare type IWebUtils = {
+    browser: puppeteer.Browser;
+    ipc: Electron.IpcRenderer;
+};
+export declare type IUtils = INodeUtils | IWebUtils;
+export declare type IWebTestInterface<ITestShape extends IBaseTest> = {
+    assertThis: (x: ITestShape["then"]) => void;
+    andWhen: (store: ITestShape["istore"], whenCB: ITestShape["when"], testResource: ITTestResourceConfiguration) => Promise<ITestShape["istore"]>;
+    butThen: (store: ITestShape["istore"], thenCB: any, testResource: ITTestResourceConfiguration) => Promise<ITestShape["iselection"]>;
+    afterAll: (store: ITestShape["istore"], artificer: ITestArtificer, browser: IWebUtils) => any;
+    afterEach: (store: ITestShape["istore"], key: string, artificer: ITestArtificer, utils: IWebUtils) => Promise<unknown>;
+    beforeAll: (input: ITestShape["iinput"], testResource: ITTestResourceConfiguration, artificer: ITestArtificer, utils: IWebUtils) => Promise<ITestShape["isubject"]>;
+    beforeEach: (subject: ITestShape["isubject"], initializer: (c?: any) => ITestShape["given"], artificer: ITestArtificer, testResource: ITTestResourceConfiguration, initialValues: any) => Promise<ITestShape["istore"]>;
+};
+export declare type INodeTestInterface<ITestShape extends IBaseTest> = {
+    assertThis: (x: ITestShape["then"]) => void;
+    andWhen: (store: ITestShape["istore"], whenCB: ITestShape["when"], testResource: ITTestResourceConfiguration) => Promise<ITestShape["istore"]>;
+    butThen: (store: ITestShape["istore"], thenCB: any, testResource: ITTestResourceConfiguration) => Promise<ITestShape["iselection"]>;
+    afterAll: (store: ITestShape["istore"], artificer: ITestArtificer, utils: INodeUtils) => any;
+    afterEach: (store: ITestShape["istore"], key: string, artificer: ITestArtificer, utils: INodeUtils) => Promise<unknown>;
+    beforeAll: (input: ITestShape["iinput"], testResource: ITTestResourceConfiguration, artificer: ITestArtificer, utils: INodeUtils) => Promise<ITestShape["isubject"]>;
+    beforeEach: (subject: ITestShape["isubject"], initializer: (c?: any) => ITestShape["given"], artificer: ITestArtificer, testResource: ITTestResourceConfiguration, initialValues: any) => Promise<ITestShape["istore"]>;
+};
+export declare type ITestInterface<ITestShape extends IBaseTest> = {
+    assertThis: (x: ITestShape["then"]) => void;
+    andWhen: (store: ITestShape["istore"], whenCB: ITestShape["when"], testResource: ITTestResourceConfiguration) => Promise<ITestShape["istore"]>;
+    butThen: (store: ITestShape["istore"], thenCB: any, testResource: ITTestResourceConfiguration) => Promise<ITestShape["iselection"]>;
+    afterAll: (store: ITestShape["istore"], artificer: ITestArtificer, utils: IUtils) => any;
+    afterEach: (store: ITestShape["istore"], key: string, artificer: ITestArtificer, utils: IUtils) => Promise<unknown>;
+    beforeAll: (input: ITestShape["iinput"], testResource: ITTestResourceConfiguration, artificer: ITestArtificer, utils: IUtils) => Promise<ITestShape["isubject"]>;
+    beforeEach: (subject: ITestShape["isubject"], initializer: (c?: any) => ITestShape["given"], artificer: ITestArtificer, testResource: ITTestResourceConfiguration, initialValues: any) => Promise<ITestShape["istore"]>;
+};
+export declare type ISuiteKlasser<ITestShape extends IBaseTest> = (name: string, index: number, givens: IGivens<ITestShape>, checks: BaseCheck<ITestShape>[]) => BaseSuite<ITestShape>;
+export declare type IGivenKlasser<ITestShape extends IBaseTest> = (name: any, features: any, whens: any, thens: any, givenCB: any) => BaseGiven<ITestShape>;
+export declare type IWhenKlasser<ITestShape extends IBaseTest> = (s: any, o: any) => BaseWhen<ITestShape>;
+export declare type IThenKlasser<ITestShape extends IBaseTest> = (s: any, o: any) => BaseThen<ITestShape>;
+export declare type ICheckKlasser<ITestShape extends IBaseTest> = (n: any, f: any, cb: any, w: any, t: any) => BaseCheck<ITestShape>;

package/dist/types/puppeteerConfiger.d.ts

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

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

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