testeranto 0.202.0 → 0.203.0

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

@@ -1,41 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { andWhenProxy } from "./pmProxy.js";
-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;
-        }
-    }
-}

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

@@ -1,3 +0,0 @@
-// Do not add logging to this file as it is used by the pure runtime.
-export class Sidecar {
-}

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

@@ -1,170 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-/* eslint-disable no-async-promise-executor */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { defaultTestResourceRequirement, DefaultAdapter, } from "./index.js";
-import { BaseGiven } from "./BaseGiven";
-import { BaseWhen } from "./BaseWhen.js";
-import { BaseThen } from "./BaseThen.js";
-import { BaseSuite } from "./BaseSuite";
-export default class Tiposkripto {
-    constructor(input, testSpecification, testImplementation, testResourceRequirement = defaultTestResourceRequirement, testAdapter = {}, uberCatcher = (cb) => cb()) {
-        this.artifacts = [];
-        const fullAdapter = DefaultAdapter(testAdapter);
-        // Create classy implementations
-        const classySuites = Object.entries(testImplementation.suites).reduce((a, [key], index) => {
-            a[key] = (somestring, givens) => {
-                return new (class extends BaseSuite {
-                    afterAll(store, artifactory, pm) {
-                        return fullAdapter.afterAll(store, pm);
-                    }
-                    assertThat(t) {
-                        return fullAdapter.assertThis(t);
-                    }
-                    async setup(s, artifactory, tr, pm) {
-                        var _a, _b;
-                        return ((_b = (_a = fullAdapter.beforeAll) === null || _a === void 0 ? void 0 : _a.call(fullAdapter, s, tr, pm)) !== null && _b !== void 0 ? _b : s);
-                    }
-                })(somestring, index, givens);
-            };
-            return a;
-        }, {});
-        const classyGivens = Object.entries(testImplementation.givens).reduce((a, [key, g]) => {
-            a[key] = (name, features, whens, thens, gcb, initialValues) => {
-                return new (class extends BaseGiven {
-                    constructor() {
-                        super(...arguments);
-                        this.uberCatcher = uberCatcher;
-                    }
-                    async givenThat(subject, testResource, artifactory, initializer, initialValues, pm) {
-                        return fullAdapter.beforeEach(subject, initializer, testResource, initialValues, pm);
-                    }
-                    afterEach(store, key, artifactory, pm) {
-                        return Promise.resolve(fullAdapter.afterEach(store, key, pm));
-                    }
-                })(name, features, whens, thens, testImplementation.givens[key], initialValues);
-            };
-            return a;
-        }, {});
-        const classyWhens = Object.entries(testImplementation.whens).reduce((a, [key, whEn]) => {
-            a[key] = (...payload) => {
-                return new (class extends BaseWhen {
-                    async andWhen(store, whenCB, testResource, pm) {
-                        return await fullAdapter.andWhen(store, whenCB, testResource, pm);
-                    }
-                })(`${key}: ${payload && payload.toString()}`, whEn(...payload));
-            };
-            return a;
-        }, {});
-        const classyThens = Object.entries(testImplementation.thens).reduce((a, [key, thEn]) => {
-            a[key] = (...args) => {
-                return new (class extends BaseThen {
-                    async butThen(store, thenCB, testResource, pm) {
-                        return await fullAdapter.butThen(store, thenCB, testResource, pm);
-                    }
-                })(`${key}: ${args && args.toString()}`, thEn(...args));
-            };
-            return a;
-        }, {});
-        // Set up the overrides
-        this.suitesOverrides = classySuites;
-        this.givenOverides = classyGivens;
-        this.whenOverides = classyWhens;
-        this.thenOverides = classyThens;
-        this.testResourceRequirement = testResourceRequirement;
-        this.testSpecification = testSpecification;
-        // Generate specs
-        this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then());
-        // Calculate total number of tests (sum of all Givens across all Suites)
-        // Each suite should have a 'givens' property that's a record of test names to BaseGiven instances
-        this.totalTests = this.calculateTotalTests();
-        console.log(`Total tests calculated: ${this.totalTests}`);
-        // Create test jobs
-        this.testJobs = this.specs.map((suite) => {
-            const suiteRunner = (suite) => async (puppetMaster, tLog) => {
-                try {
-                    const x = await suite.run(input, puppetMaster.testResourceConfiguration, (fPath, value) => puppetMaster.testArtiFactoryfileWriter(tLog, (p) => {
-                        this.artifacts.push(p);
-                    })(puppetMaster.testResourceConfiguration.fs + "/" + fPath, value), tLog, puppetMaster);
-                    return x;
-                }
-                catch (e) {
-                    console.error(e.stack);
-                    throw e;
-                }
-            };
-            const runner = suiteRunner(suite);
-            return {
-                test: suite,
-                toObj: () => {
-                    return suite.toObj();
-                },
-                runner,
-                receiveTestResourceConfig: async function (puppetMaster) {
-                    const tLog = async (...l) => {
-                        //
-                    };
-                    try {
-                        const suiteDone = await runner(puppetMaster, tLog);
-                        const fails = suiteDone.fails;
-                        await puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2), "test");
-                        return {
-                            failed: fails > 0,
-                            fails,
-                            artifacts: this.artifacts || [],
-                            features: suiteDone.features(),
-                            tests: 0, // Keep existing field
-                            runTimeTests: this.totalTests, // Add the total number of tests
-                        };
-                    }
-                    catch (e) {
-                        console.error(e.stack);
-                        return {
-                            failed: true,
-                            fails: -1,
-                            artifacts: this.artifacts || [],
-                            features: [],
-                            tests: 0, // Keep existing field
-                            runTimeTests: -1, // Set to -1 on hard error
-                        };
-                    }
-                },
-            };
-        });
-    }
-    Specs() {
-        return this.specs;
-    }
-    Suites() {
-        return this.suitesOverrides;
-    }
-    Given() {
-        return this.givenOverides;
-    }
-    When() {
-        return this.whenOverides;
-    }
-    Then() {
-        return this.thenOverides;
-    }
-    // Add a method to access test jobs which can be used by receiveTestResourceConfig
-    getTestJobs() {
-        return this.testJobs;
-    }
-    calculateTotalTests() {
-        let total = 0;
-        for (const suite of this.specs) {
-            if (suite && typeof suite === 'object') {
-                // Access the givens property which should be a record of test names to BaseGiven instances
-                // The givens property is typically on the suite instance
-                if ('givens' in suite) {
-                    const givens = suite.givens;
-                    if (givens && typeof givens === 'object') {
-                        total += Object.keys(givens).length;
-                    }
-                }
-            }
-        }
-        return total;
-    }
-}

package/dist/module/src/lib/Tiposkripto.test/MockTiposkripto.js

@@ -1,173 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import Tiposkripto from "../Tiposkripto";
-/**
- * Concrete implementation of Tiposkripto for testing purposes
- */
-export class MockTiposkripto extends Tiposkripto {
-    constructor(input, testSpecification, testImplementation, testResourceRequirement = { ports: [] }, testAdapter, uberCatcher = (cb) => cb()) {
-        // Call super first
-        super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, uberCatcher);
-        this.specs = [];
-        this.testJobs = [];
-        this.artifacts = [];
-        this.features = [];
-        this.testImplementation = testImplementation;
-        // Add debug logging for features
-        console.log('MockTiposkripto constructor called with input:', JSON.stringify(input));
-        // Validate required implementation methods
-        const requiredMethods = ["suites", "givens", "whens", "thens"];
-        requiredMethods.forEach((method) => {
-            if (!testImplementation[method]) {
-                throw new Error(`Missing required implementation method: ${method}`);
-            }
-        });
-        // Store the test adapter
-        this.testAdapter = testAdapter;
-        // Store implementation methods as overrides
-        this.suitesOverrides = testImplementation.suites;
-        this.givenOverides = testImplementation.givens;
-        this.whenOverides = testImplementation.whens;
-        this.thenOverides = testImplementation.thens;
-        // Calculate total number of tests (sum of all Givens across all Suites)
-        // For testing purposes, we'll use the number of Givens in the implementation
-        // Each Given corresponds to one test
-        let totalTests = Object.keys(testImplementation.givens).length;
-        // Override with specific values for test cases
-        if (input && typeof input === 'object') {
-            const inputObj = input;
-            if ('testCount' in inputObj) {
-                totalTests = Number(inputObj.testCount);
-            }
-        }
-        // Extract features from the test specification
-        try {
-            this.features = this.extractFeaturesFromSpecification(testSpecification);
-        }
-        catch (error) {
-            console.error('Failed to extract features, using fallback:', error);
-            // Fallback to basic features
-            this.features = [
-                'Tiposkripto should initialize with default values',
-                'Custom input test',
-                'Resource requirements test',
-                'Should generate specs from test specification',
-                'Should create test jobs from specs',
-                'Should track artifacts',
-                'Should properly configure all overrides',
-                'Interface configuration test',
-                'Custom implementation test',
-                'Custom specification test',
-                'Should allow modifying specs',
-                'Should allow modifying jobs',
-                'Should properly handle errors',
-                'Should complete a full test run successfully',
-                'Should correctly count the number of tests',
-                'Should set runTimeTests to -1 on hard errors',
-                'Given a config that has 1 suite containing 5 GivenWhenThens',
-                'Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens'
-            ];
-        }
-    }
-    extractFeaturesFromSpecification(specification) {
-        try {
-            // Create proper mock functions that match the expected signatures
-            // The Suite function should take name, tests, and features
-            const mockSuite = (name, tests, features) => ({
-                name,
-                tests,
-                features
-            });
-            // The Given function should take features, whens, thens
-            const mockGiven = (features, whens, thens) => {
-                return {
-                    features: Array.isArray(features) ? features.filter(f => typeof f === 'string') : [],
-                    whens,
-                    thens
-                };
-            };
-            // Create mock When and Then objects that have all the methods from the implementation
-            // We need to dynamically create objects with all the method names from this.testImplementation.whens and this.testImplementation.thens
-            const mockWhen = {};
-            const mockThen = {};
-            // Add all when methods
-            if (this.testImplementation.whens) {
-                Object.keys(this.testImplementation.whens).forEach(key => {
-                    mockWhen[key] = (...args) => ({ name: key, args });
-                });
-            }
-            // Add all then methods
-            if (this.testImplementation.thens) {
-                Object.keys(this.testImplementation.thens).forEach(key => {
-                    mockThen[key] = (...args) => ({ name: key, args });
-                });
-            }
-            // Execute the specification to get the test suites
-            const suites = specification(mockSuite, mockGiven, mockWhen, mockThen);
-            // Extract all features from all tests in all suites
-            const features = [];
-            for (const suite of suites) {
-                if (suite && suite.tests && typeof suite.tests === 'object') {
-                    for (const testKey of Object.keys(suite.tests)) {
-                        const test = suite.tests[testKey];
-                        if (test && test.features && Array.isArray(test.features)) {
-                            // Ensure all features are strings
-                            for (const feature of test.features) {
-                                if (typeof feature === 'string') {
-                                    features.push(feature);
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            // Remove duplicates
-            const uniqueFeatures = [...new Set(features)];
-            console.log('Extracted features:', JSON.stringify(uniqueFeatures));
-            return uniqueFeatures;
-        }
-        catch (error) {
-            console.error('Error extracting features from specification:', error);
-            return [];
-        }
-    }
-    async receiveTestResourceConfig(partialTestResource) {
-        try {
-            // Ensure test adapter is properly configured
-            if (!this.testAdapter) {
-                throw new Error("Test adapter not configured");
-            }
-            // Ensure features are always strings
-            const stringFeatures = this.features.filter(f => typeof f === 'string');
-            // Calculate totalTests based on input
-            let totalTests = Object.keys(this.givenOverides).length;
-            const input = this.input;
-            // Override with specific values for test cases
-            if (input && typeof input === 'object') {
-                if ('testCount' in input) {
-                    totalTests = input.testCount;
-                }
-            }
-            // Simulate running tests
-            return {
-                failed: false,
-                fails: 0,
-                artifacts: [],
-                features: stringFeatures,
-                tests: 0,
-                runTimeTests: totalTests,
-            };
-        }
-        catch (error) {
-            // On hard error, set runTimeTests to -1
-            return {
-                failed: true,
-                fails: 1,
-                artifacts: [],
-                features: [], // Ensure this is always an array of strings
-                tests: 0,
-                runTimeTests: -1,
-            };
-        }
-    }
-}

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

@@ -1,26 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { MockTiposkripto } from "./MockTiposkripto";
-export const 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)) {
-            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/module/src/lib/Tiposkripto.test/Tiposkripto.implementation.js

@@ -1,210 +0,0 @@
-import { MockTiposkripto } from "./MockTiposkripto";
-import { specification } from "./Tiposkripto.specification";
-import { testAdapter } from "./Tiposkripto.adapter";
-export const implementation = {
-    suites: {
-        Default: "Tiposkripto test suite",
-        ExtendedSuite: "Extended Tiposkripto test suite",
-    },
-    givens: {
-        Default: () => {
-            console.log("Creating default test builder instance");
-            const builder = new MockTiposkripto({}, // input
-            specification, // Use the current specification
-            implementation, // Use the current implementation
-            { ports: [] }, // Default resource requirements
-            testAdapter, // Default adapter
-            (cb) => cb() // Default uberCatcher
-            );
-            console.log("Builder created:", builder);
-            // Ensure the test adapter is properly set
-            if (!builder.testAdapter) {
-                builder.testAdapter = testAdapter;
-            }
-            return builder;
-        },
-        WithCustomInput: (input = {}) => {
-            return new MockTiposkripto(input, specification, implementation, { ports: [] }, testAdapter, (cb) => cb());
-        },
-        WithResourceRequirements: (requirements = { ports: 0 }) => {
-            return new MockTiposkripto({}, specification, implementation, requirements, testAdapter, (cb) => cb());
-        },
-        WithCustomImplementation: (impl = implementation) => {
-            return new MockTiposkripto({}, specification, impl, { ports: [] }, testAdapter, (cb) => cb());
-        },
-        WithCustomSpecification: (spec = specification) => {
-            return new MockTiposkripto({}, spec, implementation, { ports: [] }, testAdapter, (cb) => cb());
-        },
-        WithCustomAdapter: (customAdapter = {}) => {
-            return new MockTiposkripto({}, specification, implementation, { ports: [] }, Object.assign(Object.assign({}, testAdapter), customAdapter), (cb) => cb());
-        },
-    },
-    whens: {
-        addArtifact: (artifact) => (builder) => {
-            builder.artifacts.push(artifact);
-            return builder;
-        },
-        setTestJobs: (jobs) => (builder) => {
-            builder.testJobs = jobs;
-            return builder;
-        },
-        modifySpecs: (modifier) => (builder) => {
-            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)) {
-                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/module/src/lib/Tiposkripto.test/Tiposkripto.js

@@ -1,6 +0,0 @@
-import Testeranto from "../../Node";
-import { testAdapter } from "./Tiposkripto.adapter";
-import { MockTiposkripto } from "./MockTiposkripto";
-import { specification } from "./Tiposkripto.specification";
-import { implementation } from "./Tiposkripto.implementation";
-export default Testeranto(MockTiposkripto.prototype, specification, implementation, testAdapter, { ports: 1 });