testeranto 0.200.1 → 0.203.0

package/dist/common/src/lib/BaseSuite.test/test.js

@@ -1,253 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.testAdapter = exports.implementation = exports.specification = void 0;
-const mock_1 = require("./mock");
-// 3. Enhanced Test Specification with more test cases
-const specification = (Suite, Given, When, Then) => [
-    Suite.Default("BaseSuite Core Functionality Tests", {
-        // Test initialization and basic properties
-        initialization: Given.Default(["BaseSuite should initialize with correct name and index"], [], [Then.SuiteNameMatches("testSuite"), Then.SuiteIndexMatches(0)]),
-        // // Test execution flow
-        // execution: Given.Default(
-        //   ["BaseSuite should execute all phases successfully"],
-        //   [When.RunSuite()],
-        //   [Then.StoreValid()]
-        // ),
-        // // Test multiple features
-        // multipleFeatures: Given.Default(
-        //   ["BaseSuite should handle multiple features"],
-        //   [When.AddFeature("additionalFeature")],
-        //   [
-        //     Then.FeaturesIncludes("testFeature"),
-        //     Then.FeaturesIncludes("additionalFeature"),
-        //     Then.FeatureCountMatches(2),
-        //   ]
-        // ),
-        // // Test error handling
-        // errorHandling: Given.Default(
-        //   ["BaseSuite should handle errors gracefully"],
-        //   [When.RunSuiteWithError()],
-        //   [Then.ErrorCountMatches(1), Then.FailedFlagSet()]
-        // ),
-    }),
-    // Suite.Default("Comprehensive Integration", {
-    //   fullStackTest: Given.Default(
-    //     ["All components should work together"],
-    //     [
-    //       When.addArtifact(Promise.resolve("test")),
-    //       When.modifySpecs((specs) => [...specs, "extra"]),
-    //       When.modifyJobs((jobs) => [...jobs, {}]),
-    //     ],
-    //     [
-    //       Then.specsModified(1),
-    //       Then.jobsModified(1),
-    //       Then.artifactsTracked(),
-    //       Then.testRunSuccessful(),
-    //     ]
-    //   ),
-    // }),
-];
-exports.specification = specification;
-// 4. Enhanced Test Implementation with more operations
-exports.implementation = {
-    suites: {
-        Default: "BaseSuite Comprehensive Test Suite",
-    },
-    givens: {
-        Default: () => {
-            return async () => {
-                const suite = new mock_1.MockSuite("testSuite", 0);
-                // Convert MockSuite to TestStore
-                return {
-                    name: suite.name,
-                    index: suite.index,
-                    testStore: true
-                };
-            };
-        },
-    },
-    whens: {
-        addArtifact: (artifact) => (suite) => {
-            suite.artifacts.push(artifact);
-            return suite;
-        },
-        modifySpecs: (modifier) => (suite) => {
-            suite.specs = modifier(suite.specs);
-            return suite;
-        },
-        modifyJobs: (modifier) => (suite) => {
-            suite.testJobs = modifier(suite.testJobs);
-            return suite;
-        },
-        RunSuite: () => async (suite) => {
-            const mockConfig = {
-                name: "test",
-                fs: "/tmp",
-                ports: [3000],
-                environment: {},
-                timeout: 5000,
-                retries: 3,
-            };
-            const mockArtifactory = (key, value) => { };
-            const mockTLog = (...args) => { };
-            const mockPM = {
-                server: null,
-                testResourceConfiguration: mockConfig,
-                start: async () => { },
-                stop: async () => { },
-                testArtiFactoryfileWriter: () => { },
-                $: () => { },
-                click: () => { },
-                closePage: () => { },
-                createWriteStream: async () => "",
-            };
-            return await suite.run(null, mockConfig, mockArtifactory, mockTLog, mockPM);
-        },
-        RunSuiteWithError: () => async (suite) => {
-            // Force an error by passing invalid config
-            try {
-                await suite.run(null, {}, // Invalid config
-                () => { }, () => { }, {});
-            }
-            catch (e) {
-                // Error is caught and counted by BaseSuite
-            }
-            return suite;
-        },
-        AddFeature: (feature) => (suite) => {
-            // Add a feature to the first given
-            const firstGivenKey = Object.keys(suite.givens)[0];
-            if (firstGivenKey) {
-                suite.givens[firstGivenKey].features.push(feature);
-            }
-            return suite;
-        },
-    },
-    thens: {
-        SuiteNameMatches: (expectedName) => (ssel, utils) => (store) => {
-            if (store.name !== expectedName) {
-                throw new Error(`Expected suite name '${expectedName}', got '${store.name}'`);
-            }
-            return Promise.resolve({ testSelection: true });
-        },
-        SuiteIndexMatches: (expectedIndex) => (ssel, utils) => (store) => {
-            if (store.index !== expectedIndex) {
-                throw new Error(`Expected suite index ${expectedIndex}, got ${store.index}`);
-            }
-            return Promise.resolve({ testSelection: true });
-        },
-        FeaturesIncludes: (feature) => (ssel, utils) => (store) => {
-            // This needs to be adjusted to work with the actual implementation
-            // For now, just return a resolved promise
-            return Promise.resolve({ testSelection: true });
-        },
-        FeatureCountMatches: (expectedCount) => (suite) => {
-            const actualCount = suite.features().length;
-            if (actualCount !== expectedCount) {
-                throw new Error(`Expected ${expectedCount} features, got ${actualCount}`);
-            }
-            return suite;
-        },
-        StoreValid: () => (suite) => {
-            var _a;
-            if (!((_a = suite.store) === null || _a === void 0 ? void 0 : _a.testStore)) {
-                throw new Error("Expected valid store after execution");
-            }
-            return suite;
-        },
-        NoErrorsOccurred: () => (suite) => {
-            if (suite.failed || suite.fails > 0) {
-                throw new Error("Expected no errors to occur during execution");
-            }
-            return suite;
-        },
-        ErrorCountMatches: (expectedCount) => (suite) => {
-            if (suite.fails !== expectedCount) {
-                throw new Error(`Expected ${expectedCount} errors, got ${suite.fails}`);
-            }
-            return suite;
-        },
-        FailedFlagSet: () => (suite) => {
-            if (!suite.failed) {
-                throw new Error("Expected failed flag to be set after error");
-            }
-            return suite;
-        },
-        AllTestsCompleted: () => (suite) => {
-            if (!suite.store) {
-                throw new Error("Expected all tests to be completed");
-            }
-            return suite;
-        },
-        CleanExit: () => (suite) => {
-            if (suite.failed && suite.fails === 0) {
-                throw new Error("Expected clean exit state");
-            }
-            return suite;
-        },
-        specsModified: (expectedCount) => (suite) => {
-            if (suite.specs.length !== expectedCount) {
-                throw new Error(`Expected ${expectedCount} modified specs`);
-            }
-            return suite;
-        },
-        jobsModified: (expectedCount) => (suite) => {
-            if (suite.testJobs.length !== expectedCount) {
-                throw new Error(`Expected ${expectedCount} modified jobs`);
-            }
-            return suite;
-        },
-        artifactsTracked: () => (suite) => {
-            if (suite.artifacts.length === 0) {
-                throw new Error("Expected artifacts to be tracked");
-            }
-            return suite;
-        },
-        testRunSuccessful: () => (suite) => {
-            if (suite.failed) {
-                throw new Error("Expected test run to be successful");
-            }
-            return suite;
-        },
-    },
-};
-// 5. Fully typed Test Adapter
-exports.testAdapter = {
-    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-        try {
-            const suite = await initializer();
-            if (!suite) {
-                throw new Error("Initializer returned undefined suite");
-            }
-            return Object.assign({ name: suite.name, index: suite.index, testStore: true, testSelection: false }, (suite.store || {}));
-        }
-        catch (e) {
-            console.error("Given error:", e);
-            throw e;
-        }
-    },
-    andWhen: async (store, whenCB, testResource, pm) => {
-        // The whenCB expects a TestSelection first, then returns a function that takes TestStore
-        // We need to provide a TestSelection
-        const selection = { testSelection: true };
-        const result = await whenCB(selection)(store);
-        // Convert back to TestStore
-        return Object.assign(Object.assign({}, store), result);
-    },
-    butThen: async (store, thenCB, testResource, pm) => {
-        try {
-            // Create a TestSelection from the store
-            const selection = { testSelection: true };
-            await thenCB(selection);
-            return selection;
-        }
-        catch (e) {
-            console.error("Then error:", e.toString());
-            throw e;
-        }
-    },
-    afterEach: (store) => store,
-    afterAll: (store, pm) => { },
-    assertThis: (result) => !!result,
-    beforeAll: async (input, testResource, pm) => input,
-};

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

@@ -1,10 +0,0 @@
-"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 Web_1 = __importDefault(require("../../Web"));
-const BaseSuite_1 = require("../BaseSuite");
-const test_1 = require("./test");
-exports.default = (0, Web_1.default)(BaseSuite_1.BaseSuite, test_1.specification, test_1.implementation, test_1.testAdapter);

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

@@ -1,64 +0,0 @@
-"use strict";
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseThen = void 0;
-const pmProxy_js_1 = require("./pmProxy.js");
-class BaseThen {
-    constructor(name, thenCB) {
-        this.artifacts = [];
-        this.name = name;
-        this.thenCB = thenCB;
-        this.error = false;
-        this.artifacts = [];
-    }
-    addArtifact(path) {
-        const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
-        this.artifacts.push(normalizedPath);
-    }
-    toObj() {
-        const obj = {
-            name: this.name,
-            error: this.error,
-            artifacts: this.artifacts,
-        };
-        return obj;
-    }
-    async test(store, testResourceConfiguration, tLog, pm, filepath) {
-        // Ensure addArtifact is properly bound to 'this'
-        const addArtifact = this.addArtifact.bind(this);
-        const proxiedPm = (0, pmProxy_js_1.butThenProxy)(pm, filepath, addArtifact);
-        return this.butThen(store, async (s) => {
-            try {
-                if (typeof this.thenCB === "function") {
-                    // Add debug logging to see what's being passed to thenCB
-                    // Check if the thenCB is spreading the arguments incorrectly
-                    // Wrap the proxy to see what's happening when writeFileSync is called
-                    const wrappedPm = new Proxy(proxiedPm, {
-                        get: (target, prop, receiver) => {
-                            if (prop === "writeFileSync") {
-                                return (...args) => {
-                                    console.log(`[DEBUG] writeFileSync called with args:`, args);
-                                    return target[prop](...args);
-                                };
-                            }
-                            return target[prop];
-                        },
-                    });
-                    const result = await this.thenCB(s, wrappedPm);
-                    return result;
-                }
-                else {
-                    return this.thenCB;
-                }
-            }
-            catch (e) {
-                console.error(e.stack);
-            }
-        }, testResourceConfiguration, proxiedPm).catch((e) => {
-            this.error = e.stack;
-            // throw e;
-        });
-    }
-}
-exports.BaseThen = BaseThen;

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

@@ -1,45 +0,0 @@
-"use strict";
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.BaseWhen = void 0;
-const pmProxy_js_1 = require("./pmProxy.js");
-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 = (0, pmProxy_js_1.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;
-        }
-    }
-}
-exports.BaseWhen = BaseWhen;

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

@@ -1,7 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Sidecar = void 0;
-// Do not add logging to this file as it is used by the pure runtime.
-class Sidecar {
-}
-exports.Sidecar = Sidecar;

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

@@ -1,149 +0,0 @@
-"use strict";
-/* 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 */
-Object.defineProperty(exports, "__esModule", { value: true });
-const index_js_1 = require("./index.js");
-const BaseGiven_1 = require("./BaseGiven");
-const BaseWhen_js_1 = require("./BaseWhen.js");
-const BaseThen_js_1 = require("./BaseThen.js");
-const BaseSuite_1 = require("./BaseSuite");
-class Tiposkripto {
-    constructor(input, testSpecification, testImplementation, testResourceRequirement = index_js_1.defaultTestResourceRequirement, testAdapter = {}, uberCatcher = (cb) => cb()) {
-        this.artifacts = [];
-        const fullAdapter = (0, index_js_1.DefaultAdapter)(testAdapter);
-        // Create classy implementations
-        const classySuites = Object.entries(testImplementation.suites).reduce((a, [key], index) => {
-            a[key] = (somestring, givens) => {
-                return new (class extends BaseSuite_1.BaseSuite {
-                    afterAll(store, artifactory, pm) {
-                        return fullAdapter.afterAll(store, pm);
-                    }
-                    assertThat(t) {
-                        return fullAdapter.assertThis(t);
-                    }
-                    async setup(s, artifactory, tr, pm) {
-                        var _a, _b;
-                        return ((_b = (_a = fullAdapter.beforeAll) === null || _a === void 0 ? void 0 : _a.call(fullAdapter, s, tr, pm)) !== null && _b !== void 0 ? _b : s);
-                    }
-                })(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_1.BaseGiven {
-                    constructor() {
-                        super(...arguments);
-                        this.uberCatcher = uberCatcher;
-                    }
-                    async givenThat(subject, testResource, artifactory, initializer, initialValues, pm) {
-                        return fullAdapter.beforeEach(subject, initializer, testResource, initialValues, pm);
-                    }
-                    afterEach(store, key, artifactory, pm) {
-                        return Promise.resolve(fullAdapter.afterEach(store, key, pm));
-                    }
-                })(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_js_1.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_js_1.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());
-        // 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(),
-                        };
-                    }
-                    catch (e) {
-                        console.error(e.stack);
-                        return {
-                            failed: true,
-                            fails: -1,
-                            artifacts: this.artifacts || [],
-                            features: [],
-                        };
-                    }
-                },
-            };
-        });
-    }
-    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;
-    }
-}
-exports.default = Tiposkripto;

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

@@ -1,36 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.MockTiposkripto = void 0;
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const Tiposkripto_1 = __importDefault(require("../Tiposkripto"));
-/**
- * Concrete implementation of Tiposkripto for testing purposes
- */
-class MockTiposkripto extends Tiposkripto_1.default {
-    constructor(input, testSpecification, testImplementation, testResourceRequirement = { ports: [] }, testAdapter, uberCatcher = (cb) => cb()) {
-        // Validate required implementation methods
-        const requiredMethods = ["suites", "givens", "whens", "thens"];
-        requiredMethods.forEach((method) => {
-            if (!testImplementation[method]) {
-                throw new Error(`Missing required implementation method: ${method}`);
-            }
-        });
-        super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, uberCatcher);
-        this.specs = [];
-        this.testJobs = [];
-        this.artifacts = [];
-    }
-    async receiveTestResourceConfig(partialTestResource) {
-        return {
-            failed: false,
-            fails: 0,
-            artifacts: [],
-            features: [],
-        };
-    }
-}
-exports.MockTiposkripto = MockTiposkripto;

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

@@ -1,35 +0,0 @@
-"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;
-        try {
-            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;
-        }
-        catch (e) {
-            console.error("[ERROR] BeforeEach failed:", e);
-            throw e;
-        }
-    },
-    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,
-};