testeranto 0.146.2 → 0.146.4

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

@@ -2,95 +2,8 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseCheck = exports.BaseThen = exports.BaseWhen = exports.BaseGiven = exports.BaseSuite = void 0;
+exports.BaseCheck = exports.BaseThen = exports.BaseWhen = exports.BaseGiven = void 0;
 const pmProxy_js_1 = require("./pmProxy.js");
-class BaseSuite {
-    constructor(name, index, givens = {}, checks = []) {
-        this.name = name;
-        this.index = index;
-        this.givens = givens;
-        this.checks = checks;
-        this.fails = 0;
-    }
-    features() {
-        const features = Object.keys(this.givens)
-            .map((k) => this.givens[k].features)
-            .flat()
-            .filter((value, index, array) => {
-            return array.indexOf(value) === index;
-        });
-        return features || [];
-    }
-    toObj() {
-        const givens = Object.keys(this.givens).map((k) => this.givens[k].toObj());
-        const checks = Object.keys(this.checks).map((k) => this.checks[k].toObj());
-        return {
-            name: this.name,
-            givens,
-            checks,
-            fails: this.fails,
-            failed: this.failed,
-            features: this.features(),
-        };
-    }
-    setup(s, artifactory, tr, pm) {
-        return new Promise((res) => res(s));
-    }
-    assertThat(t) {
-        return !!t;
-    }
-    afterAll(store, artifactory, pm) {
-        return store;
-    }
-    async run(input, testResourceConfiguration, artifactory, tLog, pm) {
-        this.testResourceConfiguration = testResourceConfiguration;
-        // tLog("test resources: ", JSON.stringify(testResourceConfiguration));
-        const suiteArtifactory = (fPath, value) => artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
-        // console.log("\nSuite:", this.index, this.name);
-        tLog("\nSuite:", this.index, this.name);
-        const sNdx = this.index;
-        // const sName = this.name;
-        const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, (0, pmProxy_js_1.beforeAllProxy)(pm, sNdx.toString()));
-        for (const [gKey, g] of Object.entries(this.givens)) {
-            const giver = this.givens[gKey];
-            try {
-                this.store = await giver.give(subject, gKey, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, pm, sNdx);
-            }
-            catch (e) {
-                this.failed = true;
-                this.fails = this.fails + 1;
-                console.error(e);
-                // this.fails.push(giver);
-                // return this;
-            }
-        }
-        for (const [ndx, thater] of this.checks.entries()) {
-            await thater.check(subject, thater.name, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, pm);
-        }
-        try {
-            this.afterAll(this.store, artifactory, (0, pmProxy_js_1.afterAllProxy)(pm, sNdx.toString()));
-        }
-        catch (e) {
-            console.error(e);
-            // this.fails.push(this);
-            // return this;
-        }
-        // @TODO fix me
-        // for (const k of Object.keys(this.givens)) {
-        //   const giver = this.givens[k];
-        //   try {
-        //     giver.afterAll(this.store, artifactory, pm);
-        //   } catch (e) {
-        //     console.error(e);
-        //     this.fails.push(giver);
-        //     return this;
-        //   }
-        // }
-        ////////////////
-        return this;
-    }
-}
-exports.BaseSuite = BaseSuite;
 class BaseGiven {
     constructor(name, features, whens, thens, givenCB, initialValues) {
         this.name = name;
@@ -188,7 +101,6 @@ class BaseWhen {
     async test(store, testResourceConfiguration, tLog, pm, filepath) {
         tLog(" When:", this.name);
         return await this.andWhen(store, this.whenCB, testResourceConfiguration, (0, pmProxy_js_1.andWhenProxy)(pm, filepath)).catch((e) => {
-            console.log("MARK9", e);
             this.error = e;
             throw e;
         });
@@ -217,7 +129,6 @@ class BaseThen {
                 return this.thenCB;
             }
         }, testResourceConfiguration, (0, pmProxy_js_1.butThenProxy)(pm, filepath)).catch((e) => {
-            console.log("test failed 3", e);
             this.error = e;
             throw e;
         });

package/dist/common/src/lib/abstractBase.test/MockGiven.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockGiven = void 0;
+const abstractBase_1 = require("../abstractBase");
+class MockGiven extends abstractBase_1.BaseGiven {
+    constructor(name, features, whens, thens, givenCB, initialValues) {
+        super(name, features, whens, thens, givenCB, initialValues);
+    }
+    async givenThat(subject, testResourceConfiguration, artifactory, givenCB, initialValues, pm) {
+        return givenCB();
+    }
+    uberCatcher(e) {
+        console.error("MockGiven error:", e);
+        this.error = e;
+    }
+}
+exports.MockGiven = MockGiven;

package/dist/common/src/lib/abstractBase.test/MockThen.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockThen = void 0;
+const abstractBase_1 = require("../abstractBase");
+class MockThen extends abstractBase_1.BaseThen {
+    constructor(name, thenCB) {
+        super(name, thenCB);
+    }
+    async butThen(store, thenCB, testResourceConfiguration, pm) {
+        return thenCB(store);
+    }
+}
+exports.MockThen = MockThen;

package/dist/common/src/lib/abstractBase.test/MockWhen.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockWhen = void 0;
+const abstractBase_1 = require("../abstractBase");
+class MockWhen extends abstractBase_1.BaseWhen {
+    constructor(name, whenCB) {
+        super(name, whenCB);
+    }
+    async andWhen(store, whenCB, testResource, pm) {
+        return whenCB(store);
+    }
+}
+exports.MockWhen = MockWhen;

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

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.implementation = void 0;
+const stream_1 = require("stream");
+exports.implementation = {
+    suites: {
+        Default: "Abstract Base Test Suite",
+    },
+    givens: {
+        Default: () => ({
+            testStore: { value: "initial" },
+            testSelection: { selected: true },
+        }),
+        WithError: () => ({
+            testStore: { value: "error" },
+            testSelection: { selected: false },
+        }),
+    },
+    whens: {
+        modifyStore: (newValue) => (store) => (Object.assign(Object.assign({}, store), { testStore: { value: newValue } })),
+        throwError: () => () => {
+            throw new Error("Test error");
+        },
+    },
+    thens: {
+        verifyStore: (expected) => (store) => {
+            if (store.testStore.value !== expected) {
+                throw new Error(`Expected ${expected}, got ${store.testStore.value}`);
+            }
+            return store;
+        },
+        verifyError: (expected) => (store) => {
+            if (!store.error || !store.error.message.includes(expected)) {
+                throw new Error(`Expected error "${expected}" not found`);
+            }
+            return store;
+        },
+    },
+    checks: {
+        Default: () => new stream_1.PassThrough(),
+    },
+};

package/dist/common/src/lib/abstractBase.test/index.js

@@ -0,0 +1,17 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Node_1 = __importDefault(require("../../Node"));
+const specification_1 = require("./specification");
+const implementation_1 = require("./implementation");
+const interface_1 = require("./interface");
+const MockGiven_1 = require("./MockGiven");
+const MockThen_1 = require("./MockThen");
+const MockWhen_1 = require("./MockWhen");
+exports.default = (0, Node_1.default)({
+    MockGiven: MockGiven_1.MockGiven,
+    MockWhen: MockWhen_1.MockWhen,
+    MockThen: MockThen_1.MockThen,
+}, specification_1.specification, implementation_1.implementation, interface_1.testInterface);

package/dist/common/src/lib/abstractBase.test/interface.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testInterface = void 0;
+exports.testInterface = {
+    beforeEach: async (subject, initializer) => initializer(),
+    andWhen: async (store, whenCB) => whenCB(store),
+    butThen: async (store, thenCB) => thenCB(store),
+    afterEach: (store) => store,
+    afterAll: () => { },
+    assertThis: (result) => !!result,
+    beforeAll: async (input) => input
+};

package/dist/common/src/lib/abstractBase.test/specification.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.specification = void 0;
+const specification = (Suite, Given, When, Then, Check) => [
+    Suite.Default("BaseGiven Tests", {
+        initialization: Given.Default(["Should initialize with default values"], [], [Then.verifyStore("initial")]),
+        errorHandling: Given.WithError(["Should handle errors properly"], [When.throwError()], [Then.verifyError("Test error")])
+    }),
+    Suite.Default("BaseWhen Tests", {
+        stateModification: Given.Default(["Should modify state correctly"], [When.modifyStore("modified")], [Then.verifyStore("modified")]),
+        errorPropagation: Given.Default(["Should propagate errors"], [When.throwError()], [Then.verifyError("Test error")])
+    }),
+    Suite.Default("BaseThen Tests", {
+        assertionPassing: Given.Default(["Should pass valid assertions"], [When.modifyStore("asserted")], [Then.verifyStore("asserted")]),
+        assertionFailing: Given.Default(["Should fail invalid assertions"], [When.modifyStore("wrong")], [Then.verifyStore("right")] // This should fail
+        )
+    })
+];
+exports.specification = specification;

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

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

package/dist/common/src/lib/baseBuilder.test/TestBaseBuilder.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestBaseBuilder = void 0;
+const basebuilder_1 = require("../basebuilder");
+/**
+ * Concrete implementation of BaseBuilder for testing purposes only
+ */
+class TestBaseBuilder extends basebuilder_1.BaseBuilder {
+    constructor(input, suitesOverrides = {}, givenOverrides = {}, whenOverrides = {}, thenOverrides = {}, checkOverrides = {}, testResourceRequirement = { ports: [] }, testSpecification = () => []) {
+        super(input, suitesOverrides, givenOverrides, whenOverrides, thenOverrides, checkOverrides, testResourceRequirement, testSpecification);
+        this.summary = {};
+        this.summary = {};
+    }
+    /**
+     * Simplified version for testing that doesn't actually run tests
+     */
+    testRun(puppetMaster) {
+        this.summary = {
+            [puppetMaster.testResourceConfiguration.name]: {
+                typeErrors: 0,
+                staticErrors: 0,
+                runTimeError: "",
+                prompt: "",
+                failingFeatures: {},
+            },
+        };
+        return Promise.resolve({
+            failed: false,
+            fails: 0,
+            artifacts: [],
+            logPromise: Promise.resolve(),
+            features: [],
+        });
+    }
+}
+exports.TestBaseBuilder = TestBaseBuilder;

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

@@ -0,0 +1,97 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.implementation = void 0;
+const stream_1 = require("stream");
+const TestBaseBuilder_1 = require("./TestBaseBuilder");
+const basebuilder_1 = require("../basebuilder");
+exports.implementation = {
+    suites: {
+        Default: "BaseBuilder test suite",
+    },
+    givens: {
+        Default: () => {
+            return new TestBaseBuilder_1.TestBaseBuilder({}, {}, {}, {}, {}, {}, { ports: [] }, () => []);
+        },
+        WithCustomInput: (input) => {
+            return new TestBaseBuilder_1.TestBaseBuilder(input, {}, {}, {}, {}, {}, { ports: [] }, () => []);
+        },
+        WithResourceRequirements: (requirements) => {
+            return new TestBaseBuilder_1.TestBaseBuilder({}, {}, {}, {}, {}, {}, requirements, () => []);
+        },
+    },
+    whens: {
+        addArtifact: (artifact) => (builder) => {
+            builder.artifacts.push(artifact);
+            return builder;
+        },
+        setTestJobs: (jobs) => (builder) => {
+            builder.testJobs = jobs;
+            return builder;
+        },
+    },
+    thens: {
+        initializedProperly: () => (builder) => {
+            if (!(builder instanceof basebuilder_1.BaseBuilder)) {
+                throw new Error("Builder was not properly initialized");
+            }
+            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;
+        },
+        suitesOverridesConfigured: () => (builder) => {
+            if (!builder.suitesOverrides) {
+                throw new Error("Suites overrides not configured");
+            }
+            return builder;
+        },
+        givensOverridesConfigured: () => (builder) => {
+            if (!builder.givenOverides) {
+                throw new Error("Givens overrides not configured");
+            }
+            return builder;
+        },
+        whensOverridesConfigured: () => (builder) => {
+            if (!builder.whenOverides) {
+                throw new Error("Whens overrides not configured");
+            }
+            return builder;
+        },
+        thensOverridesConfigured: () => (builder) => {
+            if (!builder.thenOverides) {
+                throw new Error("Thens overrides not configured");
+            }
+            return builder;
+        },
+        checksOverridesConfigured: () => (builder) => {
+            if (!builder.checkOverides) {
+                throw new Error("Checks overrides not configured");
+            }
+            return builder;
+        },
+    },
+    checks: {
+        Default: () => new stream_1.PassThrough(), // Not used in these tests
+    },
+};

package/dist/common/src/lib/baseBuilder.test/baseBuilder.test.interface.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testInterface = void 0;
+exports.testInterface = {
+    beforeEach: async (subject, initializer) => {
+        return initializer();
+    },
+    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/common/src/lib/baseBuilder.test/baseBuilder.test.node.js

@@ -0,0 +1,11 @@
+"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 baseBuilder_test_specification_1 = require("./baseBuilder.test.specification");
+const baseBuilder_test_implementation_1 = require("./baseBuilder.test.implementation");
+const baseBuilder_test_interface_1 = require("./baseBuilder.test.interface");
+const basebuilder_1 = require("../basebuilder");
+exports.default = (0, Pure_1.default)(basebuilder_1.BaseBuilder.prototype, baseBuilder_test_specification_1.specification, baseBuilder_test_implementation_1.implementation, baseBuilder_test_interface_1.testInterface);

package/dist/common/src/lib/baseBuilder.test/baseBuilder.test.pure.js

@@ -0,0 +1,11 @@
+"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 baseBuilder_test_specification_1 = require("./baseBuilder.test.specification");
+const baseBuilder_test_implementation_1 = require("./baseBuilder.test.implementation");
+const baseBuilder_test_interface_1 = require("./baseBuilder.test.interface");
+const basebuilder_1 = require("../basebuilder");
+exports.default = (0, Pure_1.default)(basebuilder_1.BaseBuilder.prototype, baseBuilder_test_specification_1.specification, baseBuilder_test_implementation_1.implementation, baseBuilder_test_interface_1.testInterface);

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.specification = void 0;
+const specification = (Suite, Given, When, Then, Check) => {
+    return [
+        Suite.Default("Testing BaseBuilder functionality", {
+            testInitialization: Given.Default(["BaseBuilder should initialize correctly"], [], [Then.initializedProperly()]),
+            testSpecsGeneration: Given.Default(["BaseBuilder should generate specs from test specification"], [], [Then.specsGenerated()]),
+            testJobsCreation: Given.Default(["BaseBuilder should create test jobs"], [], [Then.jobsCreated()]),
+        }, []),
+    ];
+};
+exports.specification = specification;

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

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

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

@@ -0,0 +1,11 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const Web_1 = __importDefault(require("../../Web"));
+const baseBuilder_test_specification_1 = require("./baseBuilder.test.specification");
+const baseBuilder_test_implementation_1 = require("./baseBuilder.test.implementation");
+const baseBuilder_test_interface_1 = require("./baseBuilder.test.interface");
+const basebuilder_1 = require("../basebuilder");
+exports.default = (0, Web_1.default)(basebuilder_1.BaseBuilder.prototype, baseBuilder_test_specification_1.specification, baseBuilder_test_implementation_1.implementation, baseBuilder_test_interface_1.testInterface);

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

@@ -34,8 +34,9 @@ class BaseBuilder {
                 receiveTestResourceConfig: async function (puppetMaster) {
                     const logFilePath = "log.txt";
                     const access = await puppetMaster.createWriteStream(logFilePath);
+                    // deprecated?
                     const tLog = async (...l) => {
-                        // console.log("x", x);
+                        //
                     };
                     const suiteDone = await runner(puppetMaster, tLog);
                     const logPromise = new Promise(async (res) => {

package/dist/common/src/lib/classBuilder.test/TestClassBuilder.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TestClassBuilder = void 0;
+const basebuilder_1 = require("../basebuilder");
+/**
+ * Concrete implementation of BaseBuilder for testing ClassBuilder
+ */
+class TestClassBuilder extends basebuilder_1.BaseBuilder {
+    constructor(testImplementation, testSpecification, input, suiteKlasser, givenKlasser, whenKlasser, thenKlasser, checkKlasser, testResourceRequirement) {
+        super(input, {}, // suitesOverrides
+        {}, // givenOverides
+        {}, // whenOverides
+        {}, // thenOverides
+        {}, // checkOverides
+        testResourceRequirement, testSpecification);
+        this.summary = {};
+        this.summary = {};
+    }
+    /**
+     * Simplified test run for verification
+     */
+    testRun(puppetMaster) {
+        this.summary = {
+            [puppetMaster.testResourceConfiguration.name]: {
+                typeErrors: 0,
+                staticErrors: 0,
+                runTimeError: "",
+                prompt: "",
+                failingFeatures: {},
+            },
+        };
+        return Promise.resolve({
+            failed: false,
+            fails: 0,
+            artifacts: [],
+            logPromise: Promise.resolve(),
+            features: [],
+        });
+    }
+}
+exports.TestClassBuilder = TestClassBuilder;