testeranto 0.197.0 → 0.199.0

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

@@ -1,45 +0,0 @@
-"use strict";
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_js_1 = require("./index.js");
-const abstractBase_js_1 = require("./abstractBase.js");
-const classBuilder_js_1 = require("./classBuilder.js");
-const BaseSuite_js_1 = require("./BaseSuite.js");
-class TesterantoCore extends classBuilder_js_1.ClassBuilder {
-    constructor(input, testSpecification, testImplementation, testResourceRequirement = index_js_1.defaultTestResourceRequirement, testAdapter, uberCatcher) {
-        const fullAdapter = (0, index_js_1.DefaultAdapter)(testAdapter);
-        super(testImplementation, testSpecification, input, class extends BaseSuite_js_1.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 abstractBase_js_1.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 abstractBase_js_1.BaseWhen {
-            async andWhen(store, whenCB, testResource, pm) {
-                return await fullAdapter.andWhen(store, whenCB, testResource, pm);
-            }
-        }, class Then extends abstractBase_js_1.BaseThen {
-            async butThen(store, thenCB, testResource, pm) {
-                return await fullAdapter.butThen(store, thenCB, testResource, pm);
-            }
-        }, testResourceRequirement);
-    }
-}
-exports.default = TesterantoCore;

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

@@ -1,121 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.implementation = void 0;
-const MockCore_1 = require("./MockCore");
-exports.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_1.MockCore(input, specification, exports.implementation, resourceReq, testAdapter, (cb) => cb());
-                return instance;
-            }
-            catch (e) {
-                console.error("[ERROR] Failed to create MockCore:", e);
-                throw e;
-            }
-        },
-        WithCustomInput: (input) => {
-            return new MockCore_1.MockCore(input, specification, exports.implementation, { ports: [] }, testAdapter, (cb) => cb());
-        },
-        WithResourceRequirements: (requirements) => {
-            return new MockCore_1.MockCore({}, specification, exports.implementation, requirements, testAdapter, (cb) => cb());
-        },
-        WithCustomAdapter: (customAdapter) => {
-            return new MockCore_1.MockCore({}, specification, exports.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_1.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/common/src/lib/core.test/core.test.js

@@ -1,63 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const Pure_1 = __importDefault(require("../../Pure"));
-const core_test_specification_1 = require("./core.test.specification");
-const core_test_implementation_1 = require("./core.test.implementation");
-const core_test_adapter_1 = require("./core.test.adapter");
-const MockCore_1 = require("./MockCore");
-exports.default = (0, Pure_1.default)(MockCore_1.MockCore.prototype, core_test_specification_1.specification, core_test_implementation_1.implementation, core_test_adapter_1.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/common/src/lib/core.test/core.test.specification.js

@@ -1,53 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.specification = void 0;
-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()]),
-        }),
-    ];
-};
-exports.specification = specification;

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

@@ -1,2 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -1,190 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { afterEachProxy, andWhenProxy, beforeEachProxy, butThenProxy, } from "./pmProxy.js";
-export class BaseGiven {
-    addArtifact(path) {
-        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
-        this.artifacts.push(normalizedPath);
-    }
-    constructor(name, features, whens, thens, givenCB, initialValues) {
-        this.artifacts = [];
-        this.name = name;
-        this.features = features;
-        this.whens = whens;
-        this.thens = thens;
-        this.givenCB = givenCB;
-        this.initialValues = initialValues;
-    }
-    beforeAll(store) {
-        return store;
-    }
-    toObj() {
-        return {
-            key: this.key,
-            name: this.name,
-            whens: this.whens.map((w) => {
-                if (w && w.toObj)
-                    return w.toObj();
-                console.error("w is not as expected!", JSON.stringify(w));
-                return {};
-            }),
-            thens: this.thens.map((t) => t.toObj()),
-            error: this.error ? [this.error, this.error.stack] : null,
-            failed: this.failed,
-            features: this.features,
-            artifacts: this.artifacts,
-        };
-    }
-    async afterEach(store, key, artifactory, pm) {
-        return store;
-    }
-    async give(subject, key, testResourceConfiguration, tester, artifactory, tLog, pm, suiteNdx) {
-        this.key = key;
-        tLog(`\n ${this.key}`);
-        tLog(`\n Given: ${this.name}`);
-        const givenArtifactory = (fPath, value) => artifactory(`given-${key}/${fPath}`, value);
-        this.uberCatcher((e) => {
-            console.error(e.toString());
-            this.error = e.error;
-            tLog(e.stack);
-        });
-        try {
-            // Ensure addArtifact is properly bound to 'this'
-            const addArtifact = this.addArtifact.bind(this);
-            const proxiedPm = beforeEachProxy(pm, suiteNdx.toString(), addArtifact);
-            this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, this.initialValues, proxiedPm);
-        }
-        catch (e) {
-            // console.error("Given failure: ", e.stack);
-            this.failed = true;
-            this.error = e.stack;
-            // throw e;
-        }
-        try {
-            // tLog(`\n Given this.store`, this.store);
-            for (const [whenNdx, whenStep] of this.whens.entries()) {
-                await whenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/when/${whenNdx}`);
-            }
-            for (const [thenNdx, thenStep] of this.thens.entries()) {
-                const t = await thenStep.test(this.store, testResourceConfiguration, tLog, pm, `suite-${suiteNdx}/given-${key}/then-${thenNdx}`);
-                tester(t);
-            }
-        }
-        catch (e) {
-            this.error = e.stack;
-            this.failed = true;
-            // tLog(e.stack);
-            // throw e;
-        }
-        finally {
-            try {
-                // Ensure addArtifact is properly bound to 'this'
-                const addArtifact = this.addArtifact.bind(this);
-                const proxiedPm = afterEachProxy(pm, suiteNdx.toString(), key, addArtifact);
-                // (proxiedPm as any).currentStep = this;
-                await this.afterEach(this.store, this.key, givenArtifactory, proxiedPm);
-            }
-            catch (e) {
-                this.failed = e;
-                throw e;
-                // this.error = e.message;
-            }
-        }
-        return this.store;
-    }
-}
-export class BaseWhen {
-    addArtifact(path) {
-        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
-        this.artifacts.push(normalizedPath);
-    }
-    constructor(name, whenCB) {
-        this.artifacts = [];
-        this.name = name;
-        this.whenCB = whenCB;
-    }
-    toObj() {
-        const obj = {
-            name: this.name,
-            error: this.error
-                ? `${this.error.name}: ${this.error.message}\n${this.error.stack}`
-                : null,
-            artifacts: this.artifacts || [],
-        };
-        console.log(`[TOOBJ] Serializing ${this.constructor.name} with artifacts:`, obj.artifacts);
-        return obj;
-    }
-    async test(store, testResourceConfiguration, tLog, pm, filepath) {
-        try {
-            // tLog(" When:", this.name);
-            // Ensure addArtifact is properly bound to 'this'
-            const addArtifact = this.addArtifact.bind(this);
-            const proxiedPm = andWhenProxy(pm, filepath, addArtifact);
-            // (proxiedPm as any).currentStep = this;
-            const result = await this.andWhen(store, this.whenCB, testResourceConfiguration, proxiedPm);
-            return result;
-        }
-        catch (e) {
-            console.error("[ERROR] When step failed:", this.name.toString(), e.toString());
-            this.error = e;
-            throw e;
-        }
-    }
-}
-export class BaseThen {
-    constructor(name, thenCB) {
-        this.artifacts = [];
-        this.name = name;
-        this.thenCB = thenCB;
-        this.error = false;
-        this.artifacts = [];
-    }
-    addArtifact(path) {
-        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
-        this.artifacts.push(normalizedPath);
-    }
-    toObj() {
-        const obj = {
-            name: this.name,
-            error: this.error,
-            artifacts: this.artifacts,
-        };
-        return obj;
-    }
-    async test(store, testResourceConfiguration, tLog, pm, filepath) {
-        // Ensure addArtifact is properly bound to 'this'
-        const addArtifact = this.addArtifact.bind(this);
-        const proxiedPm = butThenProxy(pm, filepath, addArtifact);
-        return this.butThen(store, async (s) => {
-            try {
-                if (typeof this.thenCB === "function") {
-                    // Add debug logging to see what's being passed to thenCB
-                    // Check if the thenCB is spreading the arguments incorrectly
-                    // Wrap the proxy to see what's happening when writeFileSync is called
-                    const wrappedPm = new Proxy(proxiedPm, {
-                        get: (target, prop, receiver) => {
-                            if (prop === "writeFileSync") {
-                                return (...args) => {
-                                    console.log(`[DEBUG] writeFileSync called with args:`, args);
-                                    return target[prop](...args);
-                                };
-                            }
-                            return target[prop];
-                        },
-                    });
-                    const result = await this.thenCB(s, wrappedPm);
-                    return result;
-                }
-                else {
-                    return this.thenCB;
-                }
-            }
-            catch (e) {
-                console.error(e.stack);
-            }
-        }, testResourceConfiguration, proxiedPm).catch((e) => {
-            this.error = e.stack;
-            // throw e;
-        });
-    }
-}

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

@@ -1,22 +0,0 @@
-export const testAdapter = {
-    beforeAll: async (input, testResource, pm) => {
-        return input;
-    },
-    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-        const result = initializer()();
-        return result;
-    },
-    andWhen: async (store, whenCB, testResource, utils) => {
-        const result = whenCB(store, utils);
-        return result;
-    },
-    butThen: async (store, thenCB, testResource, pm) => {
-        const result = thenCB(store, pm);
-        return result;
-    },
-    afterEach: async (store, key, pm) => {
-        return store;
-    },
-    afterAll: (store, pm) => { },
-    assertThis: (x) => x,
-};

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

@@ -1,110 +0,0 @@
-import { MockBaseBuilder } from "./baseBuilder.test.mock";
-import { BaseBuilder } from "../basebuilder";
-export const implementation = {
-    suites: {
-        Default: "BaseBuilder test suite",
-    },
-    givens: {
-        "the default BaseBuilder": () => () => {
-            return new MockBaseBuilder({}, // input
-            {}, // suitesOverrides
-            {}, // givenOverrides
-            {}, // whenOverrides
-            {}, // thenOverrides
-            { ports: 0 }, // testResourceRequirement
-            () => [] // testSpecification
-            );
-        },
-        "a BaseBuilder with TestInput": (input) => () => {
-            return new MockBaseBuilder(input, {}, {}, {}, {}, { ports: [] }, () => []);
-        },
-        "a BaseBuilder with Test Resource Requirements": (requirements) => () => {
-            return new MockBaseBuilder({}, {}, {}, {}, {}, requirements, () => []);
-        },
-    },
-    whens: {
-        addArtifact: (artifact) => (builder, utils) => {
-            builder.artifacts.push(artifact);
-            return builder;
-        },
-        setTestJobs: (jobs) => (builder, utils) => {
-            builder.testJobs = jobs;
-            return builder;
-        },
-    },
-    thens: {
-        "it is initialized": () => (builder, utils) => {
-            var _a;
-            utils.writeFileSync("hello.txt", "world");
-            if (!(builder instanceof BaseBuilder)) {
-                console.error("Builder instance:", builder);
-                throw new Error(`Builder was not properly initialized - expected BaseBuilder instance but got ${(_a = builder === null || builder === void 0 ? void 0 : builder.constructor) === null || _a === void 0 ? void 0 : _a.name}`);
-            }
-            // Verify required properties exist
-            [
-                "artifacts",
-                "testJobs",
-                "specs",
-                "suitesOverrides",
-                "givenOverides",
-                "whenOverides",
-                "thenOverides",
-            ].forEach((prop) => {
-                if (!(prop in builder)) {
-                    throw new Error(`Builder missing required property: ${prop}`);
-                }
-            });
-            return builder;
-        },
-        "it generates TestSpecifications": () => (builder, utils) => {
-            if (!Array.isArray(builder.specs)) {
-                throw new Error("Specs were not generated");
-            }
-            return builder;
-        },
-        "it creates jobs": () => (builder, utils) => {
-            if (!Array.isArray(builder.testJobs)) {
-                throw new Error("Test jobs were not created");
-            }
-            return builder;
-        },
-        "it tracks artifacts": () => (builder, utils) => {
-            if (!Array.isArray(builder.artifacts)) {
-                throw new Error("Artifacts array not initialized");
-            }
-            // Verify we can write artifacts
-            utils.writeFileSync("artifact_test.txt", "test");
-            return builder;
-        },
-        resourceRequirementsSet: () => (builder, utils) => {
-            if (!builder.testResourceRequirement) {
-                throw new Error("Resource requirements not set");
-            }
-            return builder;
-        },
-        suitesOverridesConfigured: () => (builder, utils) => {
-            if (!builder.suitesOverrides) {
-                throw new Error("Suites overrides not configured");
-            }
-            return builder;
-        },
-        givensOverridesConfigured: () => (builder, utils) => {
-            if (!builder.givenOverides) {
-                throw new Error("Givens overrides not configured");
-            }
-            return builder;
-        },
-        whensOverridesConfigured: () => (builder, utils) => {
-            if (!builder.whenOverides) {
-                throw new Error("Whens overrides not configured");
-            }
-            return builder;
-        },
-        thensOverridesConfigured: () => (builder, utils) => {
-            if (!builder.thenOverides) {
-                throw new Error("Thens overrides not configured");
-            }
-            return builder;
-        },
-    },
-};

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

@@ -1,42 +0,0 @@
-import { BaseBuilder } from "../basebuilder";
-/**
- * Concrete implementation of BaseBuilder for testing purposes only
- */
-export class MockBaseBuilder extends BaseBuilder {
-    constructor(input, suitesOverrides = {}, givenOverrides = {}, whenOverrides = {}, thenOverrides = {}, testResourceRequirement = { ports: 0 }, testSpecification = () => []) {
-        super(input, suitesOverrides, givenOverrides, whenOverrides, thenOverrides, testResourceRequirement, testSpecification);
-        this.summary = {};
-    }
-    /**
-     * Simplified version for testing that doesn't actually run tests
-     */
-    async testRun(puppetMaster) {
-        try {
-            this.summary = {
-                [puppetMaster.testResourceConfiguration.name]: {
-                    typeErrors: 0,
-                    staticErrors: 0,
-                    runTimeError: "",
-                    prompt: "",
-                    failingFeatures: {},
-                },
-            };
-            return {
-                failed: false,
-                fails: 0,
-                artifacts: this.artifacts,
-                features: [],
-            };
-        }
-        catch (error) {
-            console.error("Test run failed:", error);
-            return {
-                failed: true,
-                fails: 1,
-                artifacts: this.artifacts,
-                features: [],
-                error: error.message
-            };
-        }
-    }
-}

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

@@ -1,7 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import Testeranto from "../../Node";
-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.test/baseBuilder.test.pure.js

@@ -1,7 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import Testeranto from "../../Pure";
-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);