testeranto 0.197.0 → 0.198.0

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.specification.js

@@ -1,14 +0,0 @@
-export const specification = (Suite, Given, When, Then) => {
-    return [
-        Suite.Default("Testing BaseBuilder functionality", {
-            testInitialization: Given["the default BaseBuilder"](["BaseBuilder should initialize correctly"], [], [
-                Then["it is initialized"](),
-                Then["it tracks artifacts"](),
-                // Then["it creates jobs"](),
-                // Then["it generates TestSpecifications"](),
-            ]),
-            testSpecsGeneration: Given["the default BaseBuilder"](["BaseBuilder should generate specs from test specification"], [], [Then["it generates TestSpecifications"]()]),
-            testJobsCreation: Given["the default BaseBuilder"](["BaseBuilder should create test jobs"], [], [Then["it creates jobs"]()]),
-        }),
-    ];
-};

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.web.js

@@ -1,7 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import Testeranto from "../../Web";
-import { specification } from "./baseBuilder.test.specification";
-import { implementation } from "./baseBuilder.test.implementation";
-import { testAdapter } from "./baseBuilder.test.adapter";
-import { MockBaseBuilder } from "./baseBuilder.test.mock";
-export default Testeranto(MockBaseBuilder.prototype, specification, implementation, testAdapter);

package/dist/module/src/lib/basebuilder.js

@@ -1,84 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-/* eslint-disable no-async-promise-executor */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export class BaseBuilder {
-    constructor(input, suitesOverrides, givenOverides, whenOverides, thenOverides, testResourceRequirement, testSpecification) {
-        this.artifacts = [];
-        this.artifacts = [];
-        this.testResourceRequirement = testResourceRequirement;
-        this.suitesOverrides = suitesOverrides;
-        this.givenOverides = givenOverides;
-        this.whenOverides = whenOverides;
-        this.thenOverides = thenOverides;
-        this.testSpecification = testSpecification;
-        this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then());
-        this.testJobs = this.specs.map((suite) => {
-            const suiteRunner = (suite) => async (puppetMaster, tLog) => {
-                try {
-                    const x = await suite.run(input, puppetMaster.testResourceConfiguration, (fPath, value) => puppetMaster.testArtiFactoryfileWriter(tLog, (p) => {
-                        this.artifacts.push(p);
-                    })(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value), tLog, puppetMaster);
-                    return x;
-                }
-                catch (e) {
-                    console.error(e.stack);
-                }
-            };
-            const runner = suiteRunner(suite);
-            return {
-                test: suite,
-                toObj: () => {
-                    return suite.toObj();
-                },
-                runner,
-                receiveTestResourceConfig: async function (puppetMaster) {
-                    const tLog = async (...l) => {
-                        //
-                    };
-                    try {
-                        const suiteDone = await runner(puppetMaster, tLog);
-                        const fails = suiteDone.fails;
-                        await puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2), "test");
-                        return {
-                            failed: fails > 0,
-                            fails,
-                            artifacts: this.artifacts || [],
-                            features: suiteDone.features(),
-                        };
-                    }
-                    catch (e) {
-                        console.error(e.stack);
-                        return {
-                            failed: true,
-                            fails: -1,
-                            artifacts: this.artifacts || [],
-                            features: [],
-                        };
-                    }
-                },
-            };
-        });
-    }
-    // testsJson() {
-    //   puppetMaster.writeFileSync(
-    //     `tests.json`,
-    //     JSON.stringify({ features: suiteDone.features() }, null, 2)
-    //   );
-    // }
-    Specs() {
-        return this.specs;
-    }
-    Suites() {
-        return this.suitesOverrides;
-    }
-    Given() {
-        return this.givenOverides;
-    }
-    When() {
-        return this.whenOverides;
-    }
-    Then() {
-        return this.thenOverides;
-    }
-}

package/dist/module/src/lib/classBuilder.js

@@ -1,32 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { BaseBuilder } from "./basebuilder.js";
-export class ClassBuilder extends BaseBuilder {
-    constructor(testImplementation, testSpecification, input, suiteKlasser, givenKlasser, whenKlasser, thenKlasser, testResourceRequirement) {
-        const classySuites = Object.entries(testImplementation.suites).reduce((a, [key], index) => {
-            a[key] = (somestring, givens) => {
-                return new suiteKlasser.prototype.constructor(somestring, index, givens);
-            };
-            return a;
-        }, {});
-        const classyGivens = Object.entries(testImplementation.givens).reduce((a, [key, g]) => {
-            a[key] = (features, whens, thens, ...initialValues) => {
-                return new givenKlasser.prototype.constructor(key, features, whens, thens, testImplementation.givens[key], initialValues);
-            };
-            return a;
-        }, {});
-        const classyWhens = Object.entries(testImplementation.whens).reduce((a, [key, whEn]) => {
-            a[key] = (...payload) => {
-                return new whenKlasser.prototype.constructor(`${key}: ${payload && payload.toString()}`, whEn(...payload));
-            };
-            return a;
-        }, {});
-        const classyThens = Object.entries(testImplementation.thens).reduce((a, [key, thEn]) => {
-            a[key] = (...args) => {
-                return new thenKlasser.prototype.constructor(`${key}: ${args && args.toString()}`, thEn(...args));
-            };
-            return a;
-        }, {});
-        super(input, classySuites, classyGivens, classyWhens, classyThens, testResourceRequirement, testSpecification);
-    }
-}

package/dist/module/src/lib/classBuilder.test/classBuilder.test.adapter.js

@@ -1,20 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export const testAdapter = {
-    beforeAll: async () => { },
-    beforeEach: async (subject, initializer) => {
-        console.log("Running beforeEach with initializer:", initializer);
-        const result = await initializer();
-        console.log("Initializer returned:", result);
-        return result;
-    },
-    andWhen: async (store, whenCB, testResource, utils) => {
-        return whenCB(store, utils);
-    },
-    butThen: async (store, thenCB, testResource, pm) => {
-        return thenCB(store, pm);
-    },
-    afterEach: (store) => store,
-    afterAll: () => { },
-    assertThis: (x) => { },
-};

package/dist/module/src/lib/classBuilder.test/classBuilder.test.js

@@ -1,7 +0,0 @@
-import Testeranto from "../../Node";
-import { ClassBuilder } from "../classBuilder";
-import { specification } from "./classBuilder.test.specification";
-import { implementation } from "./classBuilder.test.implementation";
-import { testAdapter } from "./classBuilder.test.adapter";
-export default Testeranto(ClassBuilder.prototype, specification, implementation, testAdapter, { ports: 1 } // Add resource requirements
-);

package/dist/module/src/lib/classBuilder.test/classBuilder.test.types.js

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

package/dist/module/src/lib/classBuilder.test/mock.js

@@ -1,14 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { ClassBuilder } from "../classBuilder";
-/**
- * Concrete testable implementation of ClassBuilder for testing
- */
-export default class TestClassBuilderMock extends ClassBuilder {
-    constructor(testImplementation, testSpecification, input, suiteKlasser, givenKlasser, whenKlasser, thenKlasser, testResourceRequirement) {
-        super(testImplementation, testSpecification, input, suiteKlasser, givenKlasser, whenKlasser, thenKlasser, testResourceRequirement);
-        this.testJobs = [];
-        this.specs = [];
-        this.artifacts = [];
-        this.summary = {};
-    }
-}

package/dist/module/src/lib/core.js

@@ -1,42 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { DefaultAdapter, defaultTestResourceRequirement, } from "./index.js";
-import { BaseGiven, BaseWhen, BaseThen } from "./abstractBase.js";
-import { ClassBuilder } from "./classBuilder.js";
-import { BaseSuite } from "./BaseSuite.js";
-export default class TesterantoCore extends ClassBuilder {
-    constructor(input, testSpecification, testImplementation, testResourceRequirement = defaultTestResourceRequirement, testAdapter, uberCatcher) {
-        const fullAdapter = DefaultAdapter(testAdapter);
-        super(testImplementation, testSpecification, input, class extends BaseSuite {
-            afterAll(store, artifactory, pm) {
-                return fullAdapter.afterAll(store, pm);
-            }
-            assertThat(t) {
-                return fullAdapter.assertThis(t);
-            }
-            async setup(s, artifactory, tr, pm) {
-                var _a, _b;
-                return (_b = (_a = fullAdapter.beforeAll) === null || _a === void 0 ? void 0 : _a.call(fullAdapter, s, tr, pm)) !== null && _b !== void 0 ? _b : s;
-            }
-        }, class Given extends BaseGiven {
-            constructor() {
-                super(...arguments);
-                this.uberCatcher = uberCatcher;
-            }
-            async givenThat(subject, testResource, artifactory, initializer, initialValues, pm) {
-                return fullAdapter.beforeEach(subject, initializer, testResource, initialValues, pm);
-            }
-            afterEach(store, key, artifactory, pm) {
-                return Promise.resolve(fullAdapter.afterEach(store, key, pm));
-            }
-        }, class When extends BaseWhen {
-            async andWhen(store, whenCB, testResource, pm) {
-                return await fullAdapter.andWhen(store, whenCB, testResource, pm);
-            }
-        }, class Then extends BaseThen {
-            async butThen(store, thenCB, testResource, pm) {
-                return await fullAdapter.butThen(store, thenCB, testResource, pm);
-            }
-        }, testResourceRequirement);
-    }
-}

package/dist/module/src/lib/core.test/core.test.implementation.js

@@ -1,118 +0,0 @@
-import { MockCore } from "./MockCore";
-export const implementation = {
-    suites: {
-        Default: "Testeranto test suite",
-        ExtendedSuite: "Extended Testeranto test suite",
-    },
-    givens: {
-        Default: () => {
-            const input = { debug: true };
-            const resourceReq = { ports: [3000] };
-            try {
-                const instance = new MockCore(input, specification, implementation, resourceReq, testAdapter, (cb) => cb());
-                return instance;
-            }
-            catch (e) {
-                console.error("[ERROR] Failed to create MockCore:", e);
-                throw e;
-            }
-        },
-        WithCustomInput: (input) => {
-            return new MockCore(input, specification, implementation, { ports: [] }, testAdapter, (cb) => cb());
-        },
-        WithResourceRequirements: (requirements) => {
-            return new MockCore({}, specification, implementation, requirements, testAdapter, (cb) => cb());
-        },
-        WithCustomAdapter: (customAdapter) => {
-            return new MockCore({}, specification, implementation, { ports: [] }, Object.assign(Object.assign({}, testAdapter), customAdapter), (cb) => cb());
-        },
-    },
-    whens: {
-        addArtifact: (artifact) => (builder) => {
-            builder.artifacts.push(artifact);
-            return builder;
-        },
-        setTestJobs: (jobs) => (builder) => {
-            builder.testJobs = jobs;
-            return builder;
-        },
-        modifySpecs: (modifier) => (builder) => {
-            var _a;
-            console.log("Modifying specs - current count:", (_a = builder.specs) === null || _a === void 0 ? void 0 : _a.length);
-            const newSpecs = modifier(builder.specs || []);
-            console.log("Modifying specs - new count:", newSpecs.length);
-            builder.specs = newSpecs;
-            return builder;
-        },
-        triggerError: (message) => (builder) => {
-            throw new Error(message);
-        },
-    },
-    thens: {
-        initializedProperly: () => (builder) => {
-            if (!builder) {
-                throw new Error("Builder is undefined");
-            }
-            if (!(builder instanceof MockCore)) {
-                throw new Error(`Builder is not MockCore (got ${builder.constructor.name})`);
-            }
-            if (!builder.testResourceRequirement) {
-                throw new Error("testResourceRequirement not set");
-            }
-            if (!builder.testAdapter) {
-                throw new Error("testAdapter not set");
-            }
-            return builder;
-        },
-        specsGenerated: () => (builder) => {
-            if (!Array.isArray(builder.specs)) {
-                throw new Error("Specs were not generated");
-            }
-            return builder;
-        },
-        jobsCreated: () => (builder) => {
-            if (!Array.isArray(builder.testJobs)) {
-                throw new Error("Test jobs were not created");
-            }
-            return builder;
-        },
-        artifactsTracked: () => (builder) => {
-            if (!Array.isArray(builder.artifacts)) {
-                throw new Error("Artifacts array not initialized");
-            }
-            return builder;
-        },
-        resourceRequirementsSet: () => (builder) => {
-            if (!builder.testResourceRequirement) {
-                throw new Error("Resource requirements not set");
-            }
-            return builder;
-        },
-        interfaceConfigured: () => (builder) => {
-            if (!builder.testAdapter) {
-                throw new Error("Test adapter not configured");
-            }
-            return builder;
-        },
-        errorThrown: (expectedMessage) => (builder) => {
-            // Handled by test runner
-            return builder;
-        },
-        testRunSuccessful: () => async (builder) => {
-            try {
-                await builder.receiveTestResourceConfig("");
-                return builder;
-            }
-            catch (e) {
-                throw new Error(`Test run failed: ${e.message}`);
-            }
-        },
-        specsModified: (expectedCount) => (builder) => {
-            var _a;
-            if (!builder.specs || builder.specs.length !== expectedCount) {
-                throw new Error(`Expected ${expectedCount} specs, got ${(_a = builder.specs) === null || _a === void 0 ? void 0 : _a.length}`);
-            }
-            return builder;
-        },
-    },
-};

package/dist/module/src/lib/core.test/core.test.js

@@ -1,58 +0,0 @@
-import Testeranto from "../../Pure";
-import { specification } from "./core.test.specification";
-import { implementation } from "./core.test.implementation";
-import { testAdapter } from "./core.test.adapter";
-import { MockCore } from "./MockCore";
-export default Testeranto(MockCore.prototype, specification, implementation, testAdapter);
-// console.log("[DEBUG] Starting core.test.ts");
-// console.log("[DEBUG] MockCore:", MockCore?.name);
-// console.log("[DEBUG] specification:", specification?.name);
-// console.log("[DEBUG] implementation keys:", Object.keys(implementation));
-// console.log("[DEBUG] testAdapter keys:", Object.keys(testAdapter));
-// console.log("[DEBUG] Starting test runner with:");
-// console.log("- Specification:", specification?.name);
-// console.log("- Implementation keys:", Object.keys(implementation));
-// console.log("- Test adapter keys:", Object.keys(testAdapter));
-// console.log("[DEBUG] Creating test runner instance...");
-// try {
-//   const testRunner = new Testeranto<I, O, M>(
-//     MockCore.prototype,
-//     specification,
-//     implementation,
-//     { ports: [3000, 3001] },
-//     testAdapter
-//   );
-//   console.log("[DEBUG] Starting test execution...");
-//   const runTests = async () => {
-//     try {
-//       const result = await testRunner.receiveTestResourceConfig(
-//         JSON.stringify({
-//           name: "core.test",
-//           fs: "/tmp/core.test",
-//           ports: [3000, 3001],
-//         })
-//       );
-//       console.log("[DEBUG] Test run completed with:");
-//       console.log("- Status:", result.failed ? "FAILED" : "PASSED");
-//       console.log("- Failures:", result.fails);
-//       console.log("- Features tested:", result.features?.length);
-//       console.log("- Artifacts:", result.artifacts?.length);
-//       if (result.failed) {
-//         throw new Error(`Tests failed with ${result.fails} failures`);
-//       }
-//       return result;
-//     } catch (e) {
-//       console.error("[ERROR] Test runner failed:", e.message);
-//       console.error("- Full error:", e);
-//       process.exit(1);
-//     }
-//   };
-//   // Run tests immediately when imported
-//   runTests().catch(e => {
-//     console.error("[ERROR] Test runner failed:", e);
-//     process.exit(1);
-//   });
-// } catch (e) {
-//   console.error("[ERROR] Failed to initialize test runner:", e);
-//   process.exit(1);
-// }

package/dist/module/src/lib/core.test/core.test.specification.js

@@ -1,49 +0,0 @@
-export const specification = (Suite, Given, When, Then) => {
-    const summary = {
-        suites: {
-            'Testeranto Core Functionality': {
-                features: {},
-                artifacts: []
-            },
-            'Testeranto Advanced Features': {
-                features: {},
-                artifacts: []
-            }
-        },
-        features: {},
-        artifacts: []
-    };
-    return [
-        Suite.Default("Testeranto Core Functionality", summary.suites['Testeranto Core Functionality'], {
-            // Initialization tests
-            defaultInitialization: Given.Default(["Should initialize with default values"], [], [
-                Then.initializedProperly(),
-                Then.specsGenerated(),
-                Then.jobsCreated(),
-                Then.artifactsTracked()
-            ]),
-            customInputInitialization: Given.WithCustomInput({ test: "input" }, [], [Then.initializedProperly()]),
-            // Configuration tests
-            resourceConfig: Given.WithResourceRequirements({ ports: [3000, 3001] }, [], [Then.resourceRequirementsSet()]),
-            interfaceConfig: Given.WithCustomAdapter({
-                assertThis: (x) => !!x,
-                beforeEach: async (s, i) => i(),
-            }, [], [Then.interfaceConfigured()]),
-            // Core operations
-            specGeneration: Given.Default(["Should generate test specs"], [], [Then.specsGenerated()]),
-            jobCreation: Given.Default(["Should create test jobs"], [], [Then.jobsCreated()]),
-            artifactHandling: Given.Default(["Should track artifacts"], [When.addArtifact(Promise.resolve("test"))], [Then.artifactsTracked()]),
-        }, []),
-        Suite.ExtendedSuite("Testeranto Advanced Features", summary.suites['Testeranto Advanced Features'], {
-            // Error handling
-            errorPropagation: Given.Default(["Should propagate errors properly"], [When.triggerError("test error")], [Then.errorThrown("test error")]),
-            // Dynamic behavior
-            specModification: Given.Default(["Should allow spec modification"], [When.modifySpecs((specs) => [...specs, { name: "extra" }])], [Then.specsModified(1)]),
-            // Full lifecycle
-            testExecution: Given.Default(["Should execute full test lifecycle"], [], [Then.testRunSuccessful()]),
-            // Custom implementations
-            // Removed customImpl test since WithCustomImplementation isn't defined
-            dynamicSpecs: Given.Default(["Should handle dynamic spec changes"], [When.modifySpecs((specs) => specs)], [Then.specsGenerated()]),
-        }),
-    ];
-};

package/dist/module/src/lib/core.test/core.test.types.js

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

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

@@ -1,70 +0,0 @@
-import type { Ibdd_in_any } from "../CoreTypes";
-import { ITestArtifactory, ITLog, ITTestResourceConfiguration } from ".";
-import { IPM } from "./types.js";
-export type IGivens<I extends Ibdd_in_any> = Record<string, BaseGiven<I>>;
-export declare abstract class BaseGiven<I extends Ibdd_in_any> {
-    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;
-    failed: boolean;
-    artifacts: string[];
-    addArtifact(path: string): void;
-    constructor(name: string, features: string[], whens: BaseWhen<I>[], thens: BaseThen<I>[], givenCB: I["given"], initialValues: any);
-    beforeAll(store: I["istore"]): I["istore"];
-    toObj(): {
-        key: string;
-        name: string;
-        whens: {}[];
-        thens: {
-            name: string;
-            error: boolean;
-            artifacts: string[];
-        }[];
-        error: (string | Error | undefined)[] | null;
-        failed: boolean;
-        features: string[];
-        artifacts: string[];
-    };
-    abstract givenThat(subject: I["isubject"], testResourceConfiguration: any, artifactory: ITestArtifactory, givenCB: I["given"], initialValues: any, pm: IPM): Promise<I["istore"]>;
-    afterEach(store: I["istore"], key: string, artifactory: ITestArtifactory, pm: IPM): 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: IPM, suiteNdx: number): Promise<I["istore"]>;
-}
-export declare abstract class BaseWhen<I extends Ibdd_in_any> {
-    name: string;
-    whenCB: (x: I["iselection"]) => I["then"];
-    error: Error;
-    artifacts: string[];
-    addArtifact(path: string): void;
-    constructor(name: string, whenCB: (xyz: I["iselection"]) => I["then"]);
-    abstract andWhen(store: I["istore"], whenCB: (x: I["iselection"]) => I["then"], testResource: any, pm: IPM): Promise<any>;
-    toObj(): {
-        name: string;
-        error: string | null;
-        artifacts: string[];
-    };
-    test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: IPM, filepath: string): Promise<any>;
-}
-export declare abstract class BaseThen<I extends Ibdd_in_any> {
-    name: string;
-    thenCB: (storeState: I["iselection"], pm: IPM) => Promise<I["then"]>;
-    error: boolean;
-    artifacts: string[];
-    constructor(name: string, thenCB: (val: I["iselection"]) => Promise<I["then"]>);
-    addArtifact(path: string): void;
-    toObj(): {
-        name: string;
-        error: boolean;
-        artifacts: string[];
-    };
-    abstract butThen(store: I["istore"], thenCB: (s: I["iselection"]) => Promise<I["isubject"]>, testResourceConfiguration: ITTestResourceConfiguration, pm: IPM, ...args: any[]): Promise<I["iselection"]>;
-    test(store: I["istore"], testResourceConfiguration: any, tLog: ITLog, pm: IPM, filepath: string): Promise<I["then"] | undefined>;
-}

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

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

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

@@ -1,3 +0,0 @@
-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.mock.d.ts

@@ -1,15 +0,0 @@
-import { Ibdd_in_any, Ibdd_out_any, ITestSpecification } from "../../CoreTypes";
-import { BaseBuilder } from "../basebuilder";
-import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser } from "../types";
-import { ITTestResourceRequest } from "..";
-/**
- * Concrete implementation of BaseBuilder for testing purposes only
- */
-export declare class MockBaseBuilder<I extends Ibdd_in_any, O extends Ibdd_out_any, SuiteExtensions = {}, GivenExtensions = {}, WhenExtensions = {}, ThenExtensions = {}> extends BaseBuilder<I, O, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions> {
-    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>>, 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.node.d.ts

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

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

@@ -1,3 +0,0 @@
-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

@@ -1,3 +0,0 @@
-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

@@ -1,22 +0,0 @@
-import { Ibdd_in, Ibdd_out } from "../../CoreTypes";
-import { BaseBuilder } from "../basebuilder";
-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];
-}, {
-    "the default BaseBuilder": [];
-    "a BaseBuilder with TestInput": [];
-    "a BaseBuilder with Test Resource Requirements": [];
-}, {}, // No whens in these tests
-{
-    "it is initialized": [];
-    "it generates TestSpecifications": [];
-    "it creates jobs": [];
-    "it tracks artifacts": [];
-}>;

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

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

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

@@ -1,23 +0,0 @@
-import type { Ibdd_in_any, Ibdd_out_any, ITestSpecification } from "../CoreTypes";
-import { ITestJob, ITTestResourceRequest } from ".";
-import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser, IPM } from "./types.js";
-import { BaseWhen, BaseThen, BaseGiven } from "./abstractBase.js";
-export declare abstract class BaseBuilder<I extends Ibdd_in_any, O extends Ibdd_out_any, SuiteExtensions, GivenExtensions, WhenExtensions, ThenExtensions> {
-    specs: any;
-    assertThis: (t: I["then"]) => any;
-    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>>;
-    puppetMaster: IPM;
-    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>>, 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>>;
-}

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

@@ -1,15 +0,0 @@
-import { NonEmptyObject } from "type-fest";
-import type { Ibdd_in_any, Ibdd_out_any, ITestImplementation, ITestSpecification } from "../CoreTypes";
-import { BaseBuilder } from "./basebuilder.js";
-import { ISuiteKlasser, IGivenKlasser, IWhenKlasser, IThenKlasser } from "./types.js";
-import { ITTestResourceRequest } from "./index.js";
-type IExtenstions = Record<string, unknown>;
-export declare abstract class ClassBuilder<I extends Ibdd_in_any = Ibdd_in_any, O extends Ibdd_out_any = Ibdd_out_any, M = unknown> extends BaseBuilder<I, O, IExtenstions, IExtenstions, IExtenstions, IExtenstions> {
-    constructor(testImplementation: ITestImplementation<I, O, M> & {
-        suites: Record<string, NonEmptyObject<object>>;
-        givens: Record<string, any>;
-        whens: Record<string, any>;
-        thens: Record<string, any>;
-    }, testSpecification: ITestSpecification<I, O>, input: I["iinput"], suiteKlasser: ISuiteKlasser<I, O>, givenKlasser: IGivenKlasser<I>, whenKlasser: IWhenKlasser<I>, thenKlasser: IThenKlasser<I>, testResourceRequirement: ITTestResourceRequest);
-}
-export {};

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

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