testeranto 0.202.0 → 0.203.0

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

@@ -1,46 +0,0 @@
-import { implementation } from "./Tiposkripto.implementation";
-export 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()], implementation),
-            customSpecification: Given.WithCustomSpecification(["Custom specification test"], [], [Then.specsGenerated(), Then.jobsCreated()], specification),
-            // 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 }),
-        }),
-    ];
-};

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,20 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { BaseGiven } from "../BaseGiven";
-export class MockGiven extends 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;
-    }
-}

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

@@ -1,12 +0,0 @@
-import { BaseThen } from "../BaseThen";
-export class MockThen extends 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);
-    }
-}

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

@@ -1,16 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { BaseWhen } from "../BaseWhen";
-export class MockWhen extends 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;
-    }
-}

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

@@ -1,21 +0,0 @@
-export const 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/module/src/lib/abstractBase.test/implementation.js

@@ -1,35 +0,0 @@
-export const 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/module/src/lib/abstractBase.test/index.js

@@ -1,13 +0,0 @@
-/* eslint-disable @typescript-eslint/no-empty-object-type */
-import Testeranto from "../../Node";
-import { specification } from "./specification";
-import { implementation } from "./implementation";
-import { testAdapter } from "./adapter";
-import { MockGiven } from "./MockGiven";
-import { MockThen } from "./MockThen";
-import { MockWhen } from "./MockWhen";
-export default Testeranto({
-    MockGiven,
-    MockWhen,
-    MockThen,
-}, specification, implementation, testAdapter);

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

@@ -1,15 +0,0 @@
-export 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
-        ),
-    }),
-];

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,26 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-export 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,
-});
-export const DefaultAdapter = (p) => {
-    const base = BaseAdapter();
-    return Object.assign(Object.assign({}, base), p);
-};
-export const defaultTestResourceRequirement = {
-    ports: 0,
-};

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

@@ -1,284 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-const baseProxy = function (pm, mappings) {
-    return new Proxy(pm, {
-        get: (target, prop, receiver) => {
-            for (const mapping of mappings) {
-                const method = mapping[0];
-                const arger = mapping[1];
-                if (prop === method) {
-                    return (...x) => {
-                        // Add debug logging
-                        const modifiedArgs = arger(...x);
-                        return target[prop](...modifiedArgs);
-                    };
-                }
-            }
-            return (...x) => {
-                return target[prop](...x);
-            };
-        },
-    });
-};
-export const butThenProxy = (pm, filepath, addArtifact) => {
-    return baseProxy(pm, [
-        [
-            "screencast",
-            (opts, p) => {
-                const path = `${filepath}/butThen/${opts.path}`;
-                addArtifact(path);
-                // console.log(
-                //   `[ARTIFACT] Preparing to add to ${step.constructor.name}:`,
-                //   path
-                // );
-                // try {
-                //   console.log(
-                //     `[ARTIFACT] Successfully added to ${step.constructor.name}`
-                //   );
-                //   console.log(`[ARTIFACT] Current artifacts:`, JSON.stringify(step.artifacts));
-                // } catch (e) {
-                //   console.error(`[ARTIFACT] Failed to add ${path}:`, e);
-                //   throw e;
-                // }
-                return [
-                    Object.assign(Object.assign({}, opts), { path }),
-                    p,
-                ];
-            },
-        ],
-        [
-            "createWriteStream",
-            (fp) => {
-                const path = `${filepath}/butThen/${fp}`;
-                addArtifact(path);
-                return [path];
-            },
-        ],
-        [
-            "writeFileSync",
-            (fp, contents, testName) => {
-                console.log(`[DEBUG] butThenProxy writeFileSync: fp="${fp}" (type: ${typeof fp}), contents="${contents}" (type: ${typeof contents}), testName="${testName}" (type: ${typeof testName})`);
-                // Check if fp is being treated as individual characters
-                if (typeof fp !== "string") {
-                    console.log(`[ERROR] fp is not a string:`, fp);
-                    // If fp is not a string, try to handle it
-                    if (Array.isArray(fp)) {
-                        // If it's an array, join it back into a string
-                        fp = fp.join("");
-                        console.log(`[DEBUG] Converted array to string: "${fp}"`);
-                    }
-                    else {
-                        // For other cases, convert to string
-                        fp = String(fp);
-                        console.log(`[DEBUG] Converted to string: "${fp}"`);
-                    }
-                }
-                const path = `${filepath}/butThen/${fp}`;
-                console.log(`[DEBUG] Generated path: "${path}"`);
-                addArtifact(path);
-                return [path, contents, testName];
-            },
-        ],
-        [
-            "customScreenShot",
-            (opts, p) => {
-                const path = `${filepath}/butThen/${opts.path}`;
-                addArtifact(path);
-                return [
-                    Object.assign(Object.assign({}, opts), { path }),
-                    p,
-                ];
-            },
-        ],
-    ]);
-};
-export const andWhenProxy = (pm, filepath, addArtifact) => {
-    return baseProxy(pm, [
-        [
-            "screencast",
-            (opts, p) => {
-                const path = `${filepath}/andWhen/${opts.path}`;
-                addArtifact(path);
-                return [
-                    Object.assign(Object.assign({}, opts), { path }),
-                    p,
-                ];
-            },
-        ],
-        [
-            "createWriteStream",
-            (fp) => {
-                const path = `${filepath}/andWhen/${fp}`;
-                addArtifact(path);
-                return [path];
-            },
-        ],
-        [
-            "writeFileSync",
-            (fp, contents, testName) => {
-                const path = `${filepath}/andWhen/${fp}`;
-                addArtifact(path);
-                return [path, contents, testName];
-            },
-        ],
-        [
-            "customScreenShot",
-            (opts, p) => {
-                const path = `${filepath}/andWhen/${opts.path}`;
-                // console.log("STEP2", JSON.stringify(step));
-                addArtifact(path);
-                return [
-                    Object.assign(Object.assign({}, opts), { path }),
-                    p,
-                ];
-            },
-        ],
-    ]);
-};
-export const afterEachProxy = (pm, suite, given, addArtifact) => {
-    return baseProxy(pm, [
-        [
-            "screencast",
-            (opts, p) => {
-                const path = `suite-${suite}/given-${given}/afterEach/${opts.path}`;
-                addArtifact(path);
-                return [
-                    Object.assign(Object.assign({}, opts), { path }),
-                    p,
-                ];
-            },
-        ],
-        [
-            "createWriteStream",
-            (fp) => {
-                const path = `suite-${suite}/afterEach/${fp}`;
-                addArtifact(path);
-                return [path];
-            },
-        ],
-        [
-            "writeFileSync",
-            (fp, contents, testName) => {
-                const path = `suite-${suite}/given-${given}/afterEach/${fp}`;
-                addArtifact(path);
-                return [path, contents, testName];
-            },
-        ],
-        [
-            "customScreenShot",
-            (opts, p) => {
-                const path = `suite-${suite}/given-${given}/afterEach/${opts.path}`;
-                addArtifact(path);
-                // console.log("STEP3", JSON.stringify(step));
-                return [
-                    Object.assign(Object.assign({}, opts), { path }),
-                    p,
-                ];
-            },
-        ],
-    ]);
-};
-export const beforeEachProxy = (pm, suite, addArtifact) => {
-    return baseProxy(pm, [
-        [
-            "screencast",
-            (opts, p) => {
-                const path = `suite-${suite}/beforeEach/${opts.path}`;
-                addArtifact(path);
-                return [
-                    Object.assign(Object.assign({}, opts), { path }),
-                    p,
-                ];
-            },
-        ],
-        [
-            "writeFileSync",
-            (fp, contents, testName) => {
-                const path = `suite-${suite}/beforeEach/${fp}`;
-                addArtifact(path);
-                return [path, contents, testName];
-            },
-        ],
-        [
-            "customScreenShot",
-            (opts, p) => {
-                const path = `suite-${suite}/beforeEach/${opts.path}`;
-                addArtifact(path);
-                return [
-                    Object.assign(Object.assign({}, opts), { path }),
-                    p,
-                ];
-            },
-        ],
-        [
-            "createWriteStream",
-            (fp) => {
-                const path = `suite-${suite}/beforeEach/${fp}`;
-                addArtifact(path);
-                return [path];
-            },
-        ],
-    ]);
-};
-export const beforeAllProxy = (pm, suite, addArtifact) => {
-    return baseProxy(pm, [
-        [
-            "writeFileSync",
-            (fp, contents, testName) => {
-                const path = `suite-${suite}/beforeAll/${fp}`;
-                addArtifact(path);
-                return [path, contents, testName];
-            },
-        ],
-        [
-            "customScreenShot",
-            (opts, p) => {
-                const path = `suite-${suite}/beforeAll/${opts.path}`;
-                addArtifact(path);
-                return [
-                    Object.assign(Object.assign({}, opts), { path }),
-                    p,
-                ];
-            },
-        ],
-        [
-            "createWriteStream",
-            (fp) => {
-                const path = `suite-${suite}/beforeAll/${fp}`;
-                addArtifact(path);
-                return [path];
-            },
-        ],
-    ]);
-};
-export const afterAllProxy = (pm, suite, addArtifact) => {
-    return baseProxy(pm, [
-        [
-            "createWriteStream",
-            (fp) => {
-                const path = `suite-${suite}/afterAll/${fp}`;
-                addArtifact(path);
-                return [path];
-            },
-        ],
-        [
-            "writeFileSync",
-            (fp, contents, testName) => {
-                const path = `suite-${suite}/afterAll/${fp}`;
-                addArtifact(path);
-                return [path, contents, testName];
-            },
-        ],
-        [
-            "customScreenShot",
-            (opts, p) => {
-                const path = `suite-${suite}/afterAll/${opts.path}`;
-                addArtifact(path);
-                return [
-                    Object.assign(Object.assign({}, opts), { path }),
-                    p,
-                ];
-            },
-        ],
-    ]);
-};

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

@@ -1,51 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-import { assert } from "chai";
-import { andWhenProxy, butThenProxy } from "../pmProxy";
-import { MockPMBase } from "./mockPMBase";
-// import { butThenProxy, andWhenProxy, beforeEachProxy } from "../pmProxy";
-export const testAdapter = {
-    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-        return subject;
-        // const mockPM = MockPMBase();
-        // return {
-        //   beforeEachProxy: subject.butThenProxy(
-        //     new MockPMBase() as unknown as IPM,
-        //     initializer
-        //   ),
-        // };
-    },
-    andWhen: async (store, whenCB, testResource, pm) => {
-        const proxiedPM = andWhenProxy(pm, "some/path", (path) => {
-            console.log("Artifact added:", path);
-            return path;
-        });
-        return whenCB(store, proxiedPM);
-    },
-    butThen: async (store, thenCB, testResource, pm) => {
-        const proxiedPM = butThenProxy(pm, "some/path", (path) => {
-            console.log("Artifact added:", path);
-            return path;
-        });
-        return thenCB(store, proxiedPM);
-    },
-    afterEach: async (store, key, pm) => store,
-    afterAll: async (store, pm) => { },
-    beforeAll: async (input, testResource, pm, theGivenString) => {
-        return {
-            beforeEachProxy: input.butThenProxy(new MockPMBase(), theGivenString),
-        };
-    },
-    assertThis: (actualResult, expectedResult) => {
-        // Handle both path assertions and our new test result
-        if (typeof actualResult === 'string' && actualResult.startsWith('PASS')) {
-            assert.equal(actualResult, 'PASS', 'tests.json should be written with correct path and content');
-        }
-        else if (typeof actualResult === 'string' && actualResult.startsWith('FAIL')) {
-            // For the tests.json write test, we want to see what's actually happening
-            assert.fail(`Test failed: ${actualResult}`);
-        }
-        else {
-            assert.equal(actualResult, expectedResult);
-        }
-    },
-};