testeranto 0.146.2 → 0.146.5

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

@@ -0,0 +1,182 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.implementation = void 0;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+const stream_1 = require("stream");
+const TestClassBuilder_1 = require("./TestClassBuilder");
+const classBuilder_test_specification_1 = require("./classBuilder.test.specification");
+exports.implementation = {
+    suites: {
+        Default: "ClassBuilder test suite",
+    },
+    givens: {
+        Default: () => {
+            return new TestClassBuilder_1.TestClassBuilder(exports.implementation, // Use the current implementation
+            classBuilder_test_specification_1.specification, // Use the current specification
+            {}, // Default input
+            class {
+            }, // suiteKlasser
+            class {
+            }, // givenKlasser
+            class {
+            }, // whenKlasser
+            class {
+            }, // thenKlasser
+            class {
+            }, // checkKlasser
+            { ports: [] } // Default resource requirements
+            );
+        },
+        WithCustomInput: (input) => {
+            return new TestClassBuilder_1.TestClassBuilder(exports.implementation, classBuilder_test_specification_1.specification, input, class {
+            }, class {
+            }, class {
+            }, class {
+            }, class {
+            }, { ports: [] });
+        },
+        WithResourceRequirements: (requirements) => {
+            return new TestClassBuilder_1.TestClassBuilder(exports.implementation, classBuilder_test_specification_1.specification, {}, class {
+            }, class {
+            }, class {
+            }, class {
+            }, class {
+            }, requirements);
+        },
+        WithCustomImplementation: (impl) => {
+            return new TestClassBuilder_1.TestClassBuilder(impl, classBuilder_test_specification_1.specification, {}, class {
+            }, class {
+            }, class {
+            }, class {
+            }, class {
+            }, { ports: [] });
+        },
+        WithCustomSpecification: (spec) => {
+            return new TestClassBuilder_1.TestClassBuilder(exports.implementation, spec, {}, class {
+            }, class {
+            }, class {
+            }, class {
+            }, class {
+            }, { ports: [] });
+        },
+    },
+    whens: {
+        addArtifact: (artifact) => (builder) => {
+            builder.artifacts.push(artifact);
+            return builder;
+        },
+        setTestJobs: (jobs) => (builder) => {
+            builder.testJobs = jobs;
+            return builder;
+        },
+        modifySpecs: (modifier) => (builder) => {
+            builder.specs = modifier(builder.specs || []);
+            return builder;
+        },
+        modifyJobs: (modifier) => (builder) => {
+            builder.testJobs = modifier(builder.testJobs || []);
+            return builder;
+        },
+        triggerError: (message) => (builder) => {
+            throw new Error(message);
+        },
+    },
+    thens: {
+        initializedProperly: () => (builder) => {
+            if (!(builder instanceof TestClassBuilder_1.TestClassBuilder)) {
+                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;
+        },
+        specsModified: (expectedCount) => (builder) => {
+            if (builder.specs.length <= expectedCount) {
+                throw new Error(`Expected at least ${expectedCount} modified specs`);
+            }
+            return builder;
+        },
+        jobsModified: (expectedCount) => (builder) => {
+            if (builder.testJobs.length <= expectedCount) {
+                throw new Error(`Expected at least ${expectedCount} modified jobs`);
+            }
+            return builder;
+        },
+        errorThrown: (expectedMessage) => (builder) => {
+            // This is handled by the test runner
+            return builder;
+        },
+        testRunSuccessful: () => async (builder) => {
+            try {
+                await builder.testRun({
+                    testResourceConfiguration: {
+                        name: "test",
+                        fs: "/tmp",
+                        ports: [],
+                    },
+                });
+                return builder;
+            }
+            catch (e) {
+                throw new Error(`Test run failed: ${e.message}`);
+            }
+        },
+    },
+    checks: {
+        Default: () => new stream_1.PassThrough(),
+        ImplementationCheck: (validator) => validator(exports.implementation),
+        SpecificationCheck: (validator) => validator(classBuilder_test_specification_1.specification),
+    },
+};

package/dist/common/src/lib/classBuilder.test/classBuilder.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/classBuilder.test/classBuilder.test.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 Node_1 = __importDefault(require("../../Node"));
+const classBuilder_1 = require("../classBuilder");
+const classBuilder_test_specification_1 = require("./classBuilder.test.specification");
+const classBuilder_test_implementation_1 = require("./classBuilder.test.implementation");
+const classBuilder_test_interface_1 = require("./classBuilder.test.interface");
+exports.default = (0, Node_1.default)(classBuilder_1.ClassBuilder.prototype, classBuilder_test_specification_1.specification, classBuilder_test_implementation_1.implementation, classBuilder_test_interface_1.testInterface);

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

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.specification = void 0;
+const specification = (Suite, Given, When, Then, Check) => {
+    return [
+        Suite.Default("Basic ClassBuilder Functionality", {
+            // Basic initialization tests
+            initialization: Given.Default(["ClassBuilder should initialize with default values"], [], [Then.initializedProperly()]),
+            customInput: Given.WithCustomInput({ custom: "input" }, [], [Then.initializedProperly()]),
+            resourceRequirements: Given.WithResourceRequirements({ ports: [3000, 3001] }, [], [Then.resourceRequirementsSet()]),
+            // Core functionality tests
+            specGeneration: Given.Default(["Should generate specs from test specification"], [], [Then.specsGenerated()]),
+            jobCreation: Given.Default(["Should create test jobs from specs"], [], [Then.jobsCreated()]),
+            artifactTracking: Given.Default(["Should track artifacts"], [When.addArtifact(Promise.resolve("test"))], [Then.artifactsTracked()]),
+            // Configuration tests
+            overridesConfiguration: Given.Default(["Should properly configure all overrides"], [], [
+                Then.suitesOverridesConfigured(),
+                Then.givensOverridesConfigured(),
+                Then.whensOverridesConfigured(),
+                Then.thensOverridesConfigured(),
+                Then.checksOverridesConfigured(),
+            ]),
+        }, []),
+        Suite.ExtendedSuite("Advanced ClassBuilder Functionality", {
+            // Custom implementations
+            customImplementation: Given.WithCustomImplementation(implementation, [], [Then.specsGenerated(), Then.jobsCreated()]),
+            customSpecification: Given.WithCustomSpecification(exports.specification, [], [Then.specsGenerated(), Then.jobsCreated()]),
+            // Dynamic modification tests
+            modifySpecs: Given.Default(["Should allow modifying specs"], [When.modifySpecs((specs) => [...specs, "extra"])], [Then.specsModified(1)]),
+            modifyJobs: Given.Default(["Should allow modifying jobs"], [When.modifyJobs((jobs) => [...jobs, {}])], [Then.jobsModified(1)]),
+            // Error handling
+            errorHandling: Given.Default(["Should properly handle errors"], [When.triggerError("test error")], [Then.errorThrown("test error")]),
+            // Full test run
+            testRun: Given.Default(["Should complete a full test run successfully"], [], [Then.testRunSuccessful()]),
+        }, [
+            Check.ImplementationCheck((impl) => impl !== null),
+            Check.SpecificationCheck((spec) => spec !== null),
+        ]),
+    ];
+};
+exports.specification = specification;

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

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

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

@@ -5,10 +5,11 @@ 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");
-class Testeranto extends classBuilder_js_1.ClassBuilder {
+const BaseSuite_js_1 = require("./BaseSuite.js");
+class TesterantoCore extends classBuilder_js_1.ClassBuilder {
     constructor(input, testSpecification, testImplementation, testResourceRequirement = index_js_1.defaultTestResourceRequirement, testInterface, uberCatcher) {
         const fullTestInterface = (0, index_js_1.DefaultTestInterface)(testInterface);
-        super(testImplementation, testSpecification, input, class extends abstractBase_js_1.BaseSuite {
+        super(testImplementation, testSpecification, input, class extends BaseSuite_js_1.BaseSuite {
             afterAll(store, artifactory, pm) {
                 return fullTestInterface.afterAll(store, pm);
             }
@@ -35,16 +36,6 @@ class Testeranto extends classBuilder_js_1.ClassBuilder {
         }, class When extends abstractBase_js_1.BaseWhen {
             async andWhen(store, whenCB, testResource, pm) {
                 return await fullTestInterface.andWhen(store, whenCB, testResource, pm);
-                // try {
-                //   return await fullTestInterface.andWhen(
-                //     store,
-                //     whenCB,
-                //     testResource,
-                //     pm
-                //   );
-                // } catch (e) {
-                //   console.log("mark22", e);
-                // }
             }
         }, class Then extends abstractBase_js_1.BaseThen {
             async butThen(store, thenCB, testResource, pm) {
@@ -64,4 +55,4 @@ class Testeranto extends classBuilder_js_1.ClassBuilder {
         }, testResourceRequirement);
     }
 }
-exports.default = Testeranto;
+exports.default = TesterantoCore;

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

@@ -0,0 +1,25 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockCore = void 0;
+const core_1 = __importDefault(require("../core"));
+/**
+ * Concrete implementation of Testeranto for testing purposes
+ */
+class MockCore extends core_1.default {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement = { ports: [] }, testInterface = {}, uberCatcher = (cb) => cb()) {
+        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface, uberCatcher);
+    }
+    async receiveTestResourceConfig(partialTestResource) {
+        return {
+            failed: false,
+            fails: 0,
+            artifacts: [],
+            logPromise: Promise.resolve(),
+            features: [],
+        };
+    }
+}
+exports.MockCore = MockCore;

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

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.implementation = void 0;
+const MockCore_1 = require("./MockCore");
+const stream_1 = require("stream");
+exports.implementation = {
+    suites: {
+        Default: "Testeranto test suite",
+        ExtendedSuite: "Extended Testeranto test suite",
+    },
+    givens: {
+        Default: () => {
+            return new MockCore_1.MockCore({}, // input
+            specification, // testSpecification 
+            exports.implementation, // testImplementation
+            { ports: [] }, // testResourceRequirement
+            testInterface, // testInterface
+            (cb) => cb() // uberCatcher
+            );
+        },
+        WithCustomInput: (input) => {
+            return new MockCore_1.MockCore(input, specification, exports.implementation, { ports: [] }, testInterface, (cb) => cb());
+        },
+        WithResourceRequirements: (requirements) => {
+            return new MockCore_1.MockCore({}, specification, exports.implementation, requirements, testInterface, (cb) => cb());
+        },
+        WithCustomInterface: (customInterface) => {
+            return new MockCore_1.MockCore({}, specification, exports.implementation, { ports: [] }, Object.assign(Object.assign({}, testInterface), customInterface), (cb) => cb());
+        }
+    },
+    whens: {
+        addArtifact: (artifact) => (builder) => {
+            builder.artifacts.push(artifact);
+            return builder;
+        },
+        setTestJobs: (jobs) => (builder) => {
+            builder.testJobs = jobs;
+            return builder;
+        },
+        modifySpecs: (modifier) => (builder) => {
+            builder.specs = modifier(builder.specs || []);
+            return builder;
+        },
+        triggerError: (message) => (builder) => {
+            throw new Error(message);
+        },
+    },
+    thens: {
+        initializedProperly: () => (builder) => {
+            if (!(builder instanceof MockCore_1.MockCore)) {
+                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;
+        },
+        interfaceConfigured: () => (builder) => {
+            if (!builder.testInterface) {
+                throw new Error("Test interface 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}`);
+            }
+        },
+    },
+    checks: {
+        Default: () => new stream_1.PassThrough(),
+    },
+};

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

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

package/dist/common/src/lib/core.test/core.test.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 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_interface_1 = require("./core.test.interface");
+const MockCore_1 = require("./MockCore");
+exports.default = (0, Pure_1.default)(MockCore_1.MockCore.prototype, // test subject
+core_test_specification_1.specification, // test scenarios
+core_test_implementation_1.implementation, // test operations
+core_test_interface_1.testInterface, // test lifecycle hooks
+{ ports: [] }, // resource requirements
+(cb) => cb() // error handler
+);

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

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.specification = void 0;
+const specification = (Suite, Given, When, Then, Check) => {
+    return [
+        Suite.Default("Testeranto Core Functionality", {
+            // Initialization tests
+            defaultInitialization: Given.Default(["Should initialize with default values"], [], [Then.initializedProperly()]),
+            customInputInitialization: Given.WithCustomInput({ test: "input" }, [], [Then.initializedProperly()]),
+            // Configuration tests  
+            resourceConfig: Given.WithResourceRequirements({ ports: [3000, 3001] }, [], [Then.resourceRequirementsSet()]),
+            interfaceConfig: Given.WithCustomInterface({
+                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", {
+            // 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
+            customImpl: Given.WithCustomImplementation(Object.assign(Object.assign({}, implementation), { suites: { Default: "Custom suite" } }), [], [Then.specsGenerated()])
+        }, [])
+    ];
+};
+exports.specification = specification;

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

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