testeranto 0.146.1 → 0.146.4

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

@@ -12,6 +12,7 @@ export declare abstract class PM_WithEslintAndTsc extends PM_Base {
     }) => Promise<void>;
     eslintCheck: (entrypoint: string, platform: IRunTime, addableFiles: string[]) => Promise<void>;
     makePrompt: (entryPoint: string, addableFiles: string[], platform: IRunTime) => Promise<void>;
+    private ensureSummaryEntry;
     typeCheckIsRunning: (src: string) => void;
     typeCheckIsNowDone: (src: string, failures: number) => void;
     lintIsRunning: (src: string) => void;
@@ -19,5 +20,5 @@ export declare abstract class PM_WithEslintAndTsc extends PM_Base {
     bddTestIsRunning: (src: string) => void;
     bddTestIsNowDone: (src: string, failures: number) => void;
     writeBigBoard: () => void;
-    checkForShutdown: () => void;
+    abstract checkForShutdown(): any;
 }

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

@@ -6,14 +6,15 @@ import { IBuiltConfig, IRunTime, ITestTypes } from "../Types.js";
 import { Sidecar } from "../lib/Sidecar.js";
 import { PM_WithEslintAndTsc } from "./PM_WithEslintAndTsc.js";
 export declare class PM_Main extends PM_WithEslintAndTsc {
-    ports: Record<number, boolean>;
-    queue: any[];
+    ports: Record<number, string>;
+    queue: string[];
     webMetafileWatcher: fs.FSWatcher;
     nodeMetafileWatcher: fs.FSWatcher;
     importMetafileWatcher: fs.FSWatcher;
     pureSidecars: Record<number, Sidecar>;
     nodeSidecars: Record<number, ChildProcess>;
     webSidecars: Record<number, Page>;
+    launchers: Record<string, () => void>;
     constructor(configs: IBuiltConfig, name: string, mode: "once" | "dev");
     stopSideCar(uid: number): Promise<any>;
     launchSideCar(n: number, name: string): Promise<[number, ITTestResourceConfiguration]>;
@@ -41,4 +42,6 @@ export declare class PM_Main extends PM_WithEslintAndTsc {
     launchPureSideCar: (sidecar: ITestTypes) => Promise<[number, ITTestResourceConfiguration]>;
     launchWeb: (src: string, dest: string) => Promise<void>;
     receiveFeaturesV2: (reportDest: string, srcTest: string, platform: IRunTime) => void;
+    checkQueue(): void;
+    checkForShutdown: () => void;
 }

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

@@ -3,7 +3,7 @@ import Testeranto from "./lib/core.js";
 import { ITTestResourceRequest } from "./lib/index.js";
 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>;
+    receiveTestResourceConfig(partialTestResource: string): Promise<import("./lib/index.js").IFinalResults | -2>;
 }
-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>>;
+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<ITestInterface<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<number | Testeranto<I, O, M>>;
 export default _default;

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

@@ -0,0 +1,36 @@
+import { Ibdd_in, Ibdd_out } from "./CoreTypes";
+import { IPM } from "./lib/types";
+type PureI = Ibdd_in<null, // No initial input needed
+IPM, // Test subject is IPM
+{
+    pm: IPM;
+}, // Store contains PM instance
+{
+    pm: IPM;
+}, // Selection is same as store
+() => IPM, // Given returns IPM
+(store: {
+    pm: IPM;
+}) => {
+    pm: IPM;
+}, // When modifies store
+(store: {
+    pm: IPM;
+}) => {
+    pm: IPM;
+}>;
+type PureO = Ibdd_out<{
+    Default: [string];
+}, {
+    Default: [];
+}, {
+    applyProxy: [string];
+    verifyCall: [string, any];
+}, {
+    verifyProxy: [string];
+    verifyNoProxy: [];
+}, {
+    Default: [];
+}>;
+declare const _default: Promise<number | import("./lib/core").default<PureI, PureO, {}>>;
+export default _default;

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

@@ -1,14 +1,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 { BaseWhen, BaseThen, BaseGiven, BaseCheck, IGivens } from "./lib/abstractBase.js";
 import { Ibdd_in_any, Ibdd_out_any } from "./CoreTypes.js";
+import { BaseSuite } from "./lib/BaseSuite.js";
 export type ISummary = Record<string, {
-    runTimeError: string;
-    typeErrors: number;
-    staticErrors: number;
-    prompt: string;
-    failingFeatures: object;
+    runTimeErrors: number | "?" | undefined;
+    typeErrors: number | "?" | undefined;
+    staticErrors: number | "?" | undefined;
+    prompt: string | "?" | undefined;
+    failingFeatures: object | undefined;
 }>;
 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>;

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

@@ -5,5 +5,5 @@ export declare class WebTesteranto<I extends Ibdd_in_any, O extends Ibdd_out, 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 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>>;
+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<ITestInterface<I>>, testResourceRequirement?: ITTestResourceRequest) => Promise<Testeranto<I, O, M>>;
 export default _default;

package/dist/types/src/esbuildConfigs/consoleDetectorPlugin.d.ts

@@ -1,2 +1,2 @@
-import type { Plugin } from 'esbuild';
+import type { Plugin } from "esbuild";
 export declare const consoleDetectorPlugin: Plugin;

package/dist/types/src/esbuildConfigs/nativeImportDetectorPlugin.d.ts

@@ -0,0 +1,2 @@
+import type { Plugin } from "esbuild";
+export declare const nativeImportDetectorPlugin: Plugin;

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

@@ -0,0 +1,39 @@
+import { ITTestResourceConfiguration, ITestArtifactory } from ".";
+import { Ibdd_in_any, Ibdd_out_any } from "../CoreTypes";
+import { IGivens, BaseCheck } from "./abstractBase";
+import { IPM } from "./types";
+export declare abstract class BaseSuite<I extends Ibdd_in_any, O extends Ibdd_out_any> {
+    name: string;
+    givens: IGivens<I>;
+    checks: BaseCheck<I>[];
+    store: I["istore"];
+    testResourceConfiguration: ITTestResourceConfiguration;
+    index: number;
+    failed: boolean;
+    fails: number;
+    constructor(name: string, index: number, givens?: IGivens<I>, checks?: BaseCheck<I>[]);
+    features(): string[];
+    toObj(): {
+        name: string;
+        givens: {
+            key: string;
+            name: string;
+            whens: {}[];
+            thens: {
+                name: string;
+                error: boolean;
+            }[];
+            error: (string | Error | undefined)[] | null;
+            failed: boolean;
+            features: string[];
+        }[];
+        checks: any[];
+        fails: number;
+        failed: boolean;
+        features: string[];
+    };
+    setup(s: I["iinput"], artifactory: ITestArtifactory, tr: ITTestResourceConfiguration, pm: IPM): Promise<I["isubject"]>;
+    assertThat(t: Awaited<I["then"]> | undefined): boolean;
+    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>>;
+}

package/dist/types/src/lib/BaseSuite.test/node.test.d.ts

@@ -0,0 +1,3 @@
+import { I, O } from "./test";
+declare const _default: Promise<import("../core").default<I, O, {}>>;
+export default _default;

package/dist/types/src/lib/BaseSuite.test/pure.test.d.ts

@@ -0,0 +1,3 @@
+import { I, O } from "./test";
+declare const _default: Promise<number | import("../core").default<I, O, {}>>;
+export default _default;

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

@@ -0,0 +1,42 @@
+import { ITTestResourceConfiguration, ITestArtifactory } from "..";
+import { Ibdd_in, Ibdd_out, ITestSpecification, ITestImplementation, ITestInterface } from "../../CoreTypes";
+import { BaseGiven, BaseWhen, BaseThen } from "../abstractBase";
+import { BaseSuite } from "../BaseSuite";
+import { IPM } from "../types";
+export type TestStore = {
+    testStore: boolean;
+    testSelection?: boolean;
+    error?: Error;
+};
+export type TestSelection = {
+    testSelection: boolean;
+    error?: boolean;
+};
+export type I = Ibdd_in<typeof BaseSuite, BaseSuite<any, any>, // isubject
+TestStore, // istore
+TestSelection, // iselection
+() => Promise<TestStore>, // given
+(store: TestStore) => Promise<TestStore>, // when
+(store: TestStore) => Promise<TestSelection>>;
+export type O = Ibdd_out<{
+    Default: [string];
+}, {
+    Default: [];
+}, {
+    TestWhen: [];
+    RunSuite: [];
+}, {
+    TestThen: [];
+    FeaturesIncludes: [feature: string];
+    StoreValid: [];
+}, {
+    TestCheck: [];
+}>;
+export declare class MockGiven extends BaseGiven<I> {
+    constructor(name: string, features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[]);
+    givenThat(subject: I["isubject"], testResourceConfiguration: ITTestResourceConfiguration, artifactory: ITestArtifactory, givenCB: I["given"], initialValues: any, pm: IPM): Promise<TestStore>;
+    uberCatcher(e: Error): void;
+}
+export declare const specification: ITestSpecification<I, O>;
+export declare const implementation: ITestImplementation<I, O>;
+export declare const testInterface: ITestInterface<I>;

package/dist/types/src/lib/BaseSuite.test/web.test.d.ts

@@ -0,0 +1,3 @@
+import { I, O } from "./test";
+declare const _default: Promise<import("../core").default<I, O, {}>>;
+export default _default;

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

@@ -1,42 +1,7 @@
 import { ITestArtifactory, ITLog, ITTestResourceConfiguration } from ".";
 import { IPM } from "./types.js";
-import type { Ibdd_in_any, Ibdd_out_any } from "../CoreTypes";
+import type { Ibdd_in_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>[];
-    store: I["istore"];
-    testResourceConfiguration: ITTestResourceConfiguration;
-    index: number;
-    failed: boolean;
-    fails: number;
-    constructor(name: string, index: number, givens?: IGivens<I>, checks?: BaseCheck<I>[]);
-    features(): string[];
-    toObj(): {
-        name: string;
-        givens: {
-            key: string;
-            name: string;
-            whens: {}[];
-            thens: {
-                name: string;
-                error: boolean;
-            }[];
-            error: (string | Error | undefined)[] | null;
-            failed: boolean;
-            features: string[];
-        }[];
-        checks: any[];
-        fails: number;
-        failed: boolean;
-        features: string[];
-    };
-    setup(s: I["iinput"], artifactory: ITestArtifactory, tr: ITTestResourceConfiguration, pm: IPM): Promise<I["isubject"]>;
-    assertThat(t: Awaited<I["then"]> | undefined): boolean;
-    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 Ibdd_in_any> {
     name: string;
     features: string[];

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

@@ -0,0 +1,7 @@
+import { BaseGiven } from "../abstractBase";
+import { Ibdd_in_any } from "../../CoreTypes";
+export declare class MockGiven<I extends Ibdd_in_any> extends BaseGiven<I> {
+    constructor(name: string, features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], givenCB: I["given"], initialValues: any);
+    givenThat(subject: I["isubject"], testResourceConfiguration: any, artifactory: any, givenCB: I["given"], initialValues: any, pm: any): Promise<I["istore"]>;
+    uberCatcher(e: Error): void;
+}

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

@@ -0,0 +1,6 @@
+import { BaseThen } from "../abstractBase";
+import { Ibdd_in_any } from "../../CoreTypes";
+export declare class MockThen<I extends Ibdd_in_any> extends BaseThen<I> {
+    constructor(name: string, thenCB: (val: I["iselection"]) => Promise<I["then"]>);
+    butThen(store: I["istore"], thenCB: (s: I["iselection"]) => Promise<I["isubject"]>, testResourceConfiguration: any, pm: any): Promise<I["iselection"]>;
+}

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

@@ -0,0 +1,6 @@
+import { BaseWhen } from "../abstractBase";
+import { Ibdd_in_any } from "../../CoreTypes";
+export declare class MockWhen<I extends Ibdd_in_any> extends BaseWhen<I> {
+    constructor(name: string, whenCB: (x: I["iselection"]) => I["then"]);
+    andWhen(store: I["istore"], whenCB: (x: I["iselection"]) => I["then"], testResource: any, pm: any): Promise<I["istore"]>;
+}

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

@@ -0,0 +1,3 @@
+import { ITestImplementation } from "../../CoreTypes";
+import { I, O } from "./types";
+export declare const implementation: ITestImplementation<I, O>;

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

@@ -0,0 +1,3 @@
+import { I, O } from "./types";
+declare const _default: Promise<import("../core").default<I, O, {}>>;
+export default _default;

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

@@ -0,0 +1,3 @@
+import { ITestInterface } from "../../CoreTypes";
+import { I } from "./types";
+export declare const testInterface: ITestInterface<I>;

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

@@ -0,0 +1,3 @@
+import { ITestSpecification } from "../../CoreTypes";
+import { I, O } from "./types";
+export declare const specification: ITestSpecification<I, O>;

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

@@ -0,0 +1,39 @@
+import { Ibdd_in, Ibdd_out } from "../../CoreTypes";
+export type I = Ibdd_in<{}, // iinput
+{}, // isubject
+{
+    testStore: {
+        value: string;
+    };
+    error?: Error;
+}, // istore
+{
+    testSelection: {
+        selected: boolean;
+    };
+}, // iselection
+() => {
+    testStore: {
+        value: string;
+    };
+}, // given
+(store: any) => any, // when
+(store: any) => any>;
+export type O = Ibdd_out<{
+    Default: [string];
+}, // Suites
+{
+    Default: [];
+    WithError: [];
+}, // Givens
+{
+    modifyStore: [string];
+    throwError: [];
+}, // Whens
+{
+    verifyStore: [string];
+    verifyError: [string];
+}, // Thens
+{
+    Default: [];
+}>;

package/dist/types/src/lib/baseBuilder.test/TestBaseBuilder.d.ts

@@ -0,0 +1,15 @@
+import { BaseBuilder } from "../basebuilder";
+import { Ibdd_in_any, Ibdd_out_any, ITestSpecification } from "../../CoreTypes";
+import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser } from "../types";
+import { ITTestResourceRequest } from "..";
+/**
+ * Concrete implementation of BaseBuilder for testing purposes only
+ */
+export declare class TestBaseBuilder<I extends Ibdd_in_any, O extends Ibdd_out_any, SuiteExtensions = {}, GivenExtensions = {}, WhenExtensions = {}, ThenExtensions = {}, CheckExtensions = {}> extends BaseBuilder<I, O, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions, CheckExtensions> {
+    summary: Record<string, any>;
+    constructor(input: I["iinput"], suitesOverrides?: Record<keyof SuiteExtensions, ISuiteKlasser<I, O>>, givenOverrides?: Record<keyof GivenExtensions, IGivenKlasser<I>>, whenOverrides?: Record<keyof WhenExtensions, IWhenKlasser<I>>, thenOverrides?: Record<keyof ThenExtensions, IThenKlasser<I>>, checkOverrides?: Record<keyof CheckExtensions, ICheckKlasser<I>>, testResourceRequirement?: ITTestResourceRequest, testSpecification?: ITestSpecification<I, O>);
+    /**
+     * Simplified version for testing that doesn't actually run tests
+     */
+    testRun(puppetMaster: any): Promise<any>;
+}

package/dist/types/src/lib/baseBuilder.test/baseBuilder.test.implementation.d.ts

@@ -0,0 +1,3 @@
+import { ITestImplementation } from "../../CoreTypes";
+import { I, O } from "./baseBuilder.test.types";
+export declare const implementation: ITestImplementation<I, O, {}>;

package/dist/types/src/lib/baseBuilder.test/baseBuilder.test.interface.d.ts

@@ -0,0 +1,3 @@
+import { ITestInterface } from "../../CoreTypes";
+import { I } from "./baseBuilder.test.types";
+export declare const testInterface: ITestInterface<I>;

package/dist/types/src/lib/baseBuilder.test/baseBuilder.test.node.d.ts

@@ -0,0 +1,3 @@
+import { I, O } from "./baseBuilder.test.types";
+declare const _default: Promise<number | import("../core").default<I, O, {}>>;
+export default _default;

package/dist/types/src/lib/baseBuilder.test/baseBuilder.test.pure.d.ts

@@ -0,0 +1,3 @@
+import { I, O } from "./baseBuilder.test.types";
+declare const _default: Promise<number | import("../core").default<I, O, {}>>;
+export default _default;

package/dist/types/src/lib/baseBuilder.test/baseBuilder.test.specification.d.ts

@@ -0,0 +1,3 @@
+import { ITestSpecification } from "../../CoreTypes";
+import { I, O } from "./baseBuilder.test.types";
+export declare const specification: ITestSpecification<I, O>;

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

@@ -0,0 +1,20 @@
+import { Ibdd_in, Ibdd_out } from "../../CoreTypes";
+export type I = Ibdd_in<{}, // iinput
+BaseBuilder<any, any, any, any, any, any>, // isubject
+BaseBuilder<any, any, any, any, any, any>, // istore
+BaseBuilder<any, any, any, any, any, any>, // iselection
+() => BaseBuilder<any, any, any, any, any, any>, // given
+(store: any) => any, // when
+(store: any) => any>;
+export type O = Ibdd_out<{
+    Default: [string];
+}, {
+    Default: [];
+}, {}, // No whens in these tests
+{
+    initializedProperly: [];
+    specsGenerated: [];
+    jobsCreated: [];
+}, {
+    Default: [];
+}>;

package/dist/types/src/lib/baseBuilder.test/baseBuilder.test.web.d.ts

@@ -0,0 +1,3 @@
+import { I, O } from "./baseBuilder.test.types";
+declare const _default: Promise<import("../core").default<I, O, {}>>;
+export default _default;

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

@@ -0,0 +1,21 @@
+import { BaseBuilder } from "../basebuilder";
+import { Ibdd_in_any, Ibdd_out_any, ITestImplementation, ITestSpecification } from "../../CoreTypes";
+import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, ICheckKlasser } from "../types";
+import { ITTestResourceRequest } from "..";
+/**
+ * Concrete implementation of BaseBuilder for testing ClassBuilder
+ */
+export declare class TestClassBuilder<I extends Ibdd_in_any, O extends Ibdd_out_any, M = unknown> extends BaseBuilder<I, O, Record<string, unknown>, Record<string, unknown>, Record<string, unknown>, Record<string, unknown>, Record<string, unknown>> {
+    summary: Record<string, any>;
+    constructor(testImplementation: ITestImplementation<I, O, M> & {
+        suites: Record<string, any>;
+        givens: Record<string, any>;
+        whens: Record<string, any>;
+        thens: Record<string, any>;
+        checks: Record<string, any>;
+    }, testSpecification: ITestSpecification<I, O>, input: I["iinput"], suiteKlasser: ISuiteKlasser<I, O>, givenKlasser: IGivenKlasser<I>, whenKlasser: IWhenKlasser<I>, thenKlasser: IThenKlasser<I>, checkKlasser: ICheckKlasser<I>, testResourceRequirement: ITTestResourceRequest);
+    /**
+     * Simplified test run for verification
+     */
+    testRun(puppetMaster: any): Promise<any>;
+}

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

@@ -0,0 +1,3 @@
+import { I, O, M } from "./classBuilder.test.types";
+declare const _default: Promise<import("../core").default<I, O, M>>;
+export default _default;

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

@@ -0,0 +1,3 @@
+import { ITestImplementation } from "../../CoreTypes";
+import { I, O, M } from "./classBuilder.test.types";
+export declare const implementation: ITestImplementation<I, O, M>;

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

@@ -0,0 +1,3 @@
+import { ITestInterface } from "../../CoreTypes";
+import { I } from "../baseBuilder.test/baseBuilder.test.types";
+export declare const testInterface: ITestInterface<I>;

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

@@ -0,0 +1,3 @@
+import { ITestSpecification } from "../../CoreTypes";
+import { I, O } from "./classBuilder.test.types";
+export declare const specification: ITestSpecification<I, O>;

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

@@ -0,0 +1,56 @@
+import { Ibdd_in, Ibdd_out, ITestImplementation, ITestSpecification } from "../../CoreTypes";
+import { ClassBuilder } from "../classBuilder";
+import { ITestJob, ITTestResourceRequest } from "..";
+export type I = Ibdd_in<{}, // iinput
+ClassBuilder<any, any, any>, // isubject
+ClassBuilder<any, any, any>, // istore
+ClassBuilder<any, any, any>, // iselection
+() => ClassBuilder<any, any, any>, // given
+(store: any) => any, // when
+(store: any) => any>;
+export type O = Ibdd_out<{
+    Default: [string];
+    ExtendedSuite: [description: string];
+}, {
+    Default: [];
+    WithCustomInput: [input: any];
+    WithResourceRequirements: [requirements: ITTestResourceRequest];
+    WithCustomImplementation: [impl: ITestImplementation<any, any>];
+    WithCustomSpecification: [spec: ITestSpecification<any, any>];
+}, {
+    addArtifact: [artifact: Promise<any>];
+    setTestJobs: [jobs: ITestJob[]];
+    modifySpecs: [modifier: (specs: any[]) => any[]];
+    modifyJobs: [modifier: (jobs: ITestJob[]) => ITestJob[]];
+    triggerError: [message: string];
+}, {
+    initializedProperly: [];
+    specsGenerated: [];
+    jobsCreated: [];
+    artifactsTracked: [];
+    resourceRequirementsSet: [];
+    suitesOverridesConfigured: [];
+    givensOverridesConfigured: [];
+    whensOverridesConfigured: [];
+    thensOverridesConfigured: [];
+    checksOverridesConfigured: [];
+    specsModified: [expectedCount: number];
+    jobsModified: [expectedCount: number];
+    errorThrown: [expectedMessage: string];
+    testRunSuccessful: [];
+}, {
+    Default: [];
+    ImplementationCheck: [validator: (impl: any) => boolean];
+    SpecificationCheck: [validator: (spec: any) => boolean];
+}>;
+export type M = {
+    givens: {
+        [K in keyof O["givens"]]: (...args: O["givens"][K]) => ClassBuilder<any, any, any>;
+    };
+    whens: {
+        [K in keyof O["whens"]]: (...args: O["whens"][K]) => (builder: ClassBuilder<any, any, any>) => ClassBuilder<any, any, any>;
+    };
+    thens: {
+        [K in keyof O["thens"]]: (...args: O["thens"][K]) => (builder: ClassBuilder<any, any, any>) => ClassBuilder<any, any, 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 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> {
+export default abstract class TesterantoCore<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/core.test/MockCore.d.ts

@@ -0,0 +1,10 @@
+import TesterantoCore from "../core";
+import { Ibdd_in_any, Ibdd_out_any, ITestImplementation, ITestSpecification, ITestInterface } from "../../CoreTypes";
+import { ITTestResourceRequest, IFinalResults } from "..";
+/**
+ * Concrete implementation of Testeranto for testing purposes
+ */
+export declare class MockCore<I extends Ibdd_in_any, O extends Ibdd_out_any, M = unknown> extends TesterantoCore<I, O, M> {
+    constructor(input: I["iinput"], testSpecification: ITestSpecification<I, O>, testImplementation: ITestImplementation<I, O, M>, testResourceRequirement?: ITTestResourceRequest, testInterface?: Partial<ITestInterface<I>>, uberCatcher?: (cb: () => void) => void);
+    receiveTestResourceConfig(partialTestResource: string): Promise<IFinalResults>;
+}

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

@@ -0,0 +1,3 @@
+import { I, O, M } from "./core.test.types";
+declare const _default: Promise<number | import("../core").default<I, O, M>>;
+export default _default;

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

@@ -0,0 +1,3 @@
+import { ITestImplementation } from "../../CoreTypes";
+import { I, O, M } from "./core.test.types";
+export declare const implementation: ITestImplementation<I, O, M>;

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

@@ -0,0 +1,3 @@
+import { ITestInterface } from "../../CoreTypes";
+import { I } from "./core.test.types";
+export declare const testInterface: ITestInterface<I>;

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

@@ -0,0 +1,3 @@
+import { ITestSpecification } from "../../CoreTypes";
+import { I, O } from "./core.test.types";
+export declare const specification: ITestSpecification<I, O>;

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

@@ -0,0 +1,46 @@
+import { Ibdd_in, Ibdd_out, ITestInterface } from "../../CoreTypes";
+import { MockCore } from "./MockCore";
+import { ITTestResourceRequest } from "..";
+export type I = Ibdd_in<{}, // iinput
+MockCore<any, any, any>, // isubject
+MockCore<any, any, any>, // istore
+MockCore<any, any, any>, // iselection
+() => MockCore<any, any, any>, // given
+(store: any) => any, // when
+(store: any) => any>;
+export type O = Ibdd_out<{
+    Default: [string];
+    ExtendedSuite: [description: string];
+}, {
+    Default: [];
+    WithCustomInput: [input: any];
+    WithResourceRequirements: [requirements: ITTestResourceRequest];
+    WithCustomInterface: [interface: Partial<ITestInterface<any>>];
+}, {
+    addArtifact: [artifact: Promise<any>];
+    setTestJobs: [jobs: any[]];
+    modifySpecs: [modifier: (specs: any[]) => any[]];
+    triggerError: [message: string];
+}, {
+    initializedProperly: [];
+    specsGenerated: [];
+    jobsCreated: [];
+    artifactsTracked: [];
+    resourceRequirementsSet: [];
+    interfaceConfigured: [];
+    errorThrown: [expectedMessage: string];
+    testRunSuccessful: [];
+}, {
+    Default: [];
+}>;
+export type M = {
+    givens: {
+        [K in keyof O["givens"]]: (...args: O["givens"][K]) => MockCore<any, any, any>;
+    };
+    whens: {
+        [K in keyof O["whens"]]: (...args: O["whens"][K]) => (builder: MockCore<any, any, any>) => MockCore<any, any, any>;
+    };
+    thens: {
+        [K in keyof O["thens"]]: (...args: O["thens"][K]) => (builder: MockCore<any, any, any>) => MockCore<any, any, any>;
+    };
+};

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

@@ -2,8 +2,9 @@ import { PM_Pure } from "../PM/pure.js";
 import { PM_Node } from "../PM/node.js";
 import { PM_Web } from "../PM/web.js";
 import { ITestconfig, IBuiltConfig, IRunTime, ITestTypes } from "../Types.js";
-import { IGivens, BaseCheck, BaseSuite } from "./abstractBase.js";
+import { IGivens, BaseCheck } from "./abstractBase.js";
 import type { ITestInterface, Ibdd_in_any, Ibdd_out_any } from "../CoreTypes.js";
+import { BaseSuite } from "./BaseSuite.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 = {