testeranto 0.203.0 → 0.205.0

package/dist/common/src/lib/Tiposkripto.test/Tiposkripto.adapter.js

@@ -0,0 +1,29 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testAdapter = void 0;
+const MockTiposkripto_1 = require("./MockTiposkripto");
+exports.testAdapter = {
+    beforeAll: async (input, testResource, pm) => input,
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        var _a;
+        const result = await initializer();
+        if (!result) {
+            throw new Error("Initializer returned undefined");
+        }
+        if (!(result instanceof MockTiposkripto_1.MockTiposkripto)) {
+            throw new Error(`Initializer returned ${(_a = result === null || result === void 0 ? void 0 : result.constructor) === null || _a === void 0 ? void 0 : _a.name}, expected MockTiposkripto`);
+        }
+        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) => !!x,
+};

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

@@ -0,0 +1,215 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.implementation = void 0;
+const MockTiposkripto_1 = require("./MockTiposkripto");
+const Tiposkripto_specification_1 = require("./Tiposkripto.specification");
+const Tiposkripto_adapter_1 = require("./Tiposkripto.adapter");
+exports.implementation = {
+    suites: {
+        Default: "Tiposkripto test suite",
+        ExtendedSuite: "Extended Tiposkripto test suite",
+    },
+    givens: {
+        Default: () => {
+            console.log("Creating default test builder instance");
+            const builder = new MockTiposkripto_1.MockTiposkripto({}, // input
+            Tiposkripto_specification_1.specification, // Use the current specification
+            exports.implementation, // Use the current implementation
+            { ports: 0 }, // Default resource requirements
+            Tiposkripto_adapter_1.testAdapter, // Default adapter
+            (cb) => cb() // Default uberCatcher
+            );
+            console.log("Builder created:", builder);
+            // Ensure the test adapter is properly set
+            if (!builder.testAdapter) {
+                builder.testAdapter = Tiposkripto_adapter_1.testAdapter;
+            }
+            return builder;
+        },
+        WithCustomInput: (input = {}) => {
+            return new MockTiposkripto_1.MockTiposkripto(input, Tiposkripto_specification_1.specification, exports.implementation, { ports: 0 }, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
+        },
+        WithResourceRequirements: (requirements = { ports: 0 }) => {
+            return new MockTiposkripto_1.MockTiposkripto({}, Tiposkripto_specification_1.specification, exports.implementation, requirements, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
+        },
+        WithCustomImplementation: (impl = exports.implementation) => {
+            return new MockTiposkripto_1.MockTiposkripto({}, Tiposkripto_specification_1.specification, impl, { ports: 0 }, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
+        },
+        WithCustomSpecification: (spec = Tiposkripto_specification_1.specification) => {
+            return new MockTiposkripto_1.MockTiposkripto({}, spec, exports.implementation, { ports: 0 }, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
+        },
+        WithCustomAdapter: (customAdapter = {}) => {
+            return new MockTiposkripto_1.MockTiposkripto({}, Tiposkripto_specification_1.specification, exports.implementation, { ports: 0 }, Object.assign(Object.assign({}, Tiposkripto_adapter_1.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) => {
+            builder.specs = modifier(builder.specs || []);
+            return builder;
+        },
+        modifyJobs: (modifier) => (builder) => {
+            builder.testJobs = modifier(builder.testJobs || []);
+            return builder;
+        },
+        triggerError: (message) => (builder) => {
+            throw new Error(message);
+        },
+        // Add a when to simulate receiving test resource config
+        receiveTestResourceConfig: (config) => async (builder) => {
+            return await builder.receiveTestResourceConfig(config);
+        },
+    },
+    thens: {
+        initializedProperly: () => (builder, utils) => {
+            var _a;
+            if (!builder) {
+                throw new Error("Builder is undefined");
+            }
+            if (!(builder instanceof MockTiposkripto_1.MockTiposkripto)) {
+                throw new Error(`Builder was not properly initialized. Expected MockTiposkripto 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
+            const requiredProps = [
+                "specs",
+                "testJobs",
+                "artifacts",
+                "suitesOverrides",
+                "givenOverides",
+                "whenOverides",
+                "thenOverides",
+            ];
+            for (const prop of requiredProps) {
+                if (!(prop in builder)) {
+                    throw new Error(`Missing required property: ${prop}`);
+                }
+            }
+            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;
+        },
+        interfaceConfigured: () => (builder) => {
+            if (!builder.testAdapter) {
+                throw new Error("Test adapter not configured");
+            }
+            // Check if the test adapter has the required methods
+            const requiredMethods = [
+                "beforeAll",
+                "beforeEach",
+                "andWhen",
+                "butThen",
+                "afterEach",
+                "afterAll",
+                "assertThis",
+            ];
+            for (const method of requiredMethods) {
+                if (typeof builder.testAdapter[method] !== "function") {
+                    throw new Error(`Test adapter missing required method: ${method}`);
+                }
+            }
+            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) => {
+            await builder.receiveTestResourceConfig("");
+            return builder;
+        },
+        runTimeTestsCounted: () => async (builder) => {
+            const result = await builder.receiveTestResourceConfig("");
+            // The total number of tests should be greater than 0
+            if (result.runTimeTests <= 0) {
+                throw new Error(`Expected runTimeTests > 0, got ${result.runTimeTests}`);
+            }
+            return builder;
+        },
+        runTimeTestsSetToNegativeOne: () => async (builder) => {
+            await builder.receiveTestResourceConfig("");
+            // If we reach here, no error was thrown, which is unexpected
+            // But we'll let the test fail naturally
+            return builder;
+        },
+        runTimeTestsCountIs: (expectedCount) => async (builder) => {
+            const result = await builder.receiveTestResourceConfig("");
+            if (result.runTimeTests !== expectedCount) {
+                throw new Error(`Expected runTimeTests to be ${expectedCount}, got ${result.runTimeTests}`);
+            }
+            return builder;
+        },
+        runTimeTestsIsNegativeOne: () => async (builder) => {
+            await builder.receiveTestResourceConfig("");
+            // If we reach here, no error was thrown, which is unexpected
+            // But we'll let the test fail naturally
+            return builder;
+        },
+    },
+};

package/dist/common/src/lib/Tiposkripto.test/Tiposkripto.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 Tiposkripto_adapter_1 = require("./Tiposkripto.adapter");
+const MockTiposkripto_1 = require("./MockTiposkripto");
+const Tiposkripto_specification_1 = require("./Tiposkripto.specification");
+const Tiposkripto_implementation_1 = require("./Tiposkripto.implementation");
+exports.default = (0, Node_1.default)(MockTiposkripto_1.MockTiposkripto.prototype, Tiposkripto_specification_1.specification, Tiposkripto_implementation_1.implementation, Tiposkripto_adapter_1.testAdapter, { ports: 1 });

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.specification = void 0;
+const specification = (Suite, Given, When, Then) => {
+    return [
+        Suite.Default("Tiposkripto Core Functionality", {
+            // Basic initialization tests
+            initialization: Given.Default(["Tiposkripto should initialize with default values"], [], [Then.initializedProperly()]),
+            customInput: Given.WithCustomInput(["Custom input test"], [], [Then.initializedProperly()]),
+            resourceRequirements: Given.WithResourceRequirements(["Resource requirements test"], [], [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(),
+            ]),
+            interfaceConfiguration: Given.WithCustomAdapter(["Interface configuration test"], [], [Then.interfaceConfigured()], {
+                assertThis: (x) => !!x,
+                beforeEach: async (s, i) => i(),
+            }),
+        }),
+        Suite.ExtendedSuite("Tiposkripto Advanced Features", {
+            // Custom implementations
+            customImplementation: Given.WithCustomImplementation(["Custom implementation test"], [], [Then.specsGenerated(), Then.jobsCreated()]),
+            customSpecification: Given.WithCustomSpecification(["Custom specification test"], [], [Then.specsGenerated(), Then.jobsCreated()]),
+            // Dynamic modification tests
+            specModification: Given.Default(["Should allow modifying specs"], [When.modifySpecs((specs) => [...specs, "extra"])], [Then.specsModified(1)]),
+            jobModification: 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
+            fullTestRun: Given.Default(["Should complete a full test run successfully"], [], [Then.testRunSuccessful()]),
+            // runTimeTests behavior
+            runTimeTestsCount: Given.Default(["Should correctly count the number of tests"], [], [Then.runTimeTestsCounted()]),
+            runTimeTestsOnError: Given.Default(["Should set runTimeTests to -1 on hard errors"], [When.triggerError("test error")], [Then.runTimeTestsSetToNegativeOne()]),
+            // Specific test cases for runTimeTests behavior
+            runTimeTestsSingleSuiteFiveTests: Given.WithCustomInput(["Given a config that has 1 suite containing 5 GivenWhenThens"], [], [Then.runTimeTestsCountIs(5)], { testCount: 5 }),
+            runTimeTestsSingleSuiteFiveTestsError: Given.WithCustomInput(["Given a config that has 1 suite containing 5 GivenWhenThens"], [When.triggerError("hard error")], [Then.runTimeTestsIsNegativeOne()], { testCount: 5 }),
+            runTimeTestsTwoSuitesThreeTestsEach: Given.WithCustomInput([
+                "Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens",
+            ], [], [Then.runTimeTestsCountIs(6)], { testCount: 6 }),
+            runTimeTestsTwoSuitesThreeTestsEachError: Given.WithCustomInput([
+                "Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens",
+            ], [When.triggerError("hard error")], [Then.runTimeTestsIsNegativeOne()], { testCount: 6 }),
+        }),
+    ];
+};
+exports.specification = specification;

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

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

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

@@ -0,0 +1,24 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockGiven = void 0;
+const BaseGiven_1 = require("../BaseGiven");
+class MockGiven extends BaseGiven_1.BaseGiven {
+    constructor(name, features, whens, thens, givenCB, initialValues) {
+        super(name, features, whens, thens, givenCB, initialValues);
+    }
+    async givenThat(subject, testResourceConfiguration, artifactory, givenCB, initialValues, pm) {
+        // Call the givenCB which is a function that returns the store
+        const result = givenCB();
+        if (typeof result === 'function') {
+            return result();
+        }
+        return result;
+    }
+    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,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockThen = void 0;
+const BaseThen_1 = require("../BaseThen");
+class MockThen extends BaseThen_1.BaseThen {
+    constructor(name, thenCB) {
+        super(name, thenCB);
+    }
+    async butThen(store, thenCB, testResourceConfiguration, pm) {
+        // The thenCB expects a selection, not the store directly
+        // We need to extract the selection from the store
+        const selection = { testSelection: store.testSelection };
+        return thenCB(selection);
+    }
+}
+exports.MockThen = MockThen;

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

@@ -0,0 +1,20 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MockWhen = void 0;
+const BaseWhen_1 = require("../BaseWhen");
+class MockWhen extends BaseWhen_1.BaseWhen {
+    constructor(name, whenCB) {
+        super(name, whenCB);
+    }
+    async andWhen(store, whenCB, testResource, pm) {
+        // The whenCB returns a function that takes the store
+        const result = whenCB(store);
+        if (typeof result === 'function') {
+            return result(store);
+        }
+        return result;
+    }
+}
+exports.MockWhen = MockWhen;

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

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.testAdapter = void 0;
+exports.testAdapter = {
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        const result = await initializer();
+        // Ensure the result matches the expected type
+        if (typeof result === "function") {
+            // If it's a function, call it to get the actual store
+            return result();
+        }
+        return result;
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        return whenCB(store);
+    },
+    butThen: async (store, thenCB, testResource, pm) => {
+        return thenCB(store);
+    },
+    afterEach: async (store, key, pm) => Promise.resolve(store),
+    afterAll: async (store, pm) => { },
+    assertThis: (result) => !!result,
+    beforeAll: async (input, testResource, pm) => input,
+};

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

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

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

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-empty-object-type */
+const Node_1 = __importDefault(require("../../Node"));
+const specification_1 = require("./specification");
+const implementation_1 = require("./implementation");
+const adapter_1 = require("./adapter");
+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, adapter_1.testAdapter);

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) => [
+    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/index.js

@@ -0,0 +1,31 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultTestResourceRequirement = exports.DefaultAdapter = exports.BaseAdapter = void 0;
+const BaseAdapter = () => ({
+    beforeAll: async (input, testResource, pm) => {
+        return input;
+    },
+    beforeEach: async function (subject, initializer, testResource, initialValues, pm) {
+        return subject;
+    },
+    afterEach: async (store, key, pm) => Promise.resolve(store),
+    afterAll: (store, pm) => undefined,
+    butThen: async (store, thenCb, testResource, pm) => {
+        return thenCb(store, pm);
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        return whenCB(store, pm);
+    },
+    assertThis: (x) => x,
+});
+exports.BaseAdapter = BaseAdapter;
+const DefaultAdapter = (p) => {
+    const base = (0, exports.BaseAdapter)();
+    return Object.assign(Object.assign({}, base), p);
+};
+exports.DefaultAdapter = DefaultAdapter;
+exports.defaultTestResourceRequirement = {
+    ports: 0,
+};