testeranto 0.177.0 → 0.197.0

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

@@ -3,7 +3,6 @@
 import { afterEachProxy, andWhenProxy, beforeEachProxy, butThenProxy, } from "./pmProxy.js";
 export class BaseGiven {
     addArtifact(path) {
-        console.log("Given addArtifact", path);
         const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
         this.artifacts.push(normalizedPath);
     }
@@ -50,11 +49,14 @@ export class BaseGiven {
             tLog(e.stack);
         });
         try {
-            const proxiedPm = beforeEachProxy(pm, suiteNdx.toString(), this.addArtifact.bind(this));
+            // Ensure addArtifact is properly bound to 'this'
+            const addArtifact = this.addArtifact.bind(this);
+            const proxiedPm = beforeEachProxy(pm, suiteNdx.toString(), addArtifact);
             this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, this.initialValues, proxiedPm);
         }
         catch (e) {
             // console.error("Given failure: ", e.stack);
+            this.failed = true;
             this.error = e.stack;
             // throw e;
         }
@@ -69,13 +71,16 @@ export class BaseGiven {
             }
         }
         catch (e) {
+            this.error = e.stack;
             this.failed = true;
-            tLog(e.stack);
-            throw e;
+            // tLog(e.stack);
+            // throw e;
         }
         finally {
             try {
-                const proxiedPm = afterEachProxy(pm, suiteNdx.toString(), key, this.addArtifact.bind(this));
+                // Ensure addArtifact is properly bound to 'this'
+                const addArtifact = this.addArtifact.bind(this);
+                const proxiedPm = afterEachProxy(pm, suiteNdx.toString(), key, addArtifact);
                 // (proxiedPm as any).currentStep = this;
                 await this.afterEach(this.store, this.key, givenArtifactory, proxiedPm);
             }
@@ -90,7 +95,6 @@ export class BaseGiven {
 }
 export class BaseWhen {
     addArtifact(path) {
-        console.log("When addArtifact", path);
         const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
         this.artifacts.push(normalizedPath);
     }
@@ -113,7 +117,9 @@ export class BaseWhen {
     async test(store, testResourceConfiguration, tLog, pm, filepath) {
         try {
             // tLog(" When:", this.name);
-            const proxiedPm = andWhenProxy(pm, filepath, this.addArtifact.bind(this));
+            // 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;
@@ -134,7 +140,6 @@ export class BaseThen {
         this.artifacts = [];
     }
     addArtifact(path) {
-        console.log("Then addArtifact", path);
         const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
         this.artifacts.push(normalizedPath);
     }
@@ -147,13 +152,35 @@ export class BaseThen {
         return obj;
     }
     async test(store, testResourceConfiguration, tLog, pm, filepath) {
-        const proxiedPm = butThenProxy(pm, filepath, this.addArtifact.bind(this));
+        // Ensure addArtifact is properly bound to 'this'
+        const addArtifact = this.addArtifact.bind(this);
+        const proxiedPm = butThenProxy(pm, filepath, addArtifact);
         return this.butThen(store, async (s) => {
-            if (typeof this.thenCB === "function") {
-                return await this.thenCB(s, proxiedPm);
+            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;
+                }
             }
-            else {
-                return this.thenCB;
+            catch (e) {
+                console.error(e.stack);
             }
         }, testResourceConfiguration, proxiedPm).catch((e) => {
             this.error = e.stack;

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

@@ -1,22 +1,22 @@
 export const testAdapter = {
-    beforeAll: async (input, testResource, pm) => input,
+    beforeAll: async (input, testResource, pm) => {
+        return input;
+    },
     beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-        console.log("Initializing test with:", {
-            subject,
-            initializer,
-            initialValues,
-        });
-        const result = initializer();
-        console.log("Initialization result:", result.toString());
+        const result = initializer()();
         return result;
     },
     andWhen: async (store, whenCB, testResource, utils) => {
-        return whenCB(store, utils);
+        const result = whenCB(store, utils);
+        return result;
     },
     butThen: async (store, thenCB, testResource, pm) => {
-        return thenCB(store, pm);
+        const result = thenCB(store, pm);
+        return result;
+    },
+    afterEach: async (store, key, pm) => {
+        return store;
     },
-    afterEach: (store) => store,
-    afterAll: () => { },
+    afterAll: (store, pm) => { },
     assertThis: (x) => x,
 };

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.implementation.js

@@ -5,7 +5,7 @@ export const implementation = {
         Default: "BaseBuilder test suite",
     },
     givens: {
-        "the default BaseBuilder": () => {
+        "the default BaseBuilder": () => () => {
             return new MockBaseBuilder({}, // input
             {}, // suitesOverrides
             {}, // givenOverrides
@@ -15,19 +15,19 @@ export const implementation = {
             () => [] // testSpecification
             );
         },
-        "a BaseBuilder with TestInput": (input) => {
+        "a BaseBuilder with TestInput": (input) => () => {
             return new MockBaseBuilder(input, {}, {}, {}, {}, { ports: [] }, () => []);
         },
-        "a BaseBuilder with Test Resource Requirements": (requirements) => {
+        "a BaseBuilder with Test Resource Requirements": (requirements) => () => {
             return new MockBaseBuilder({}, {}, {}, {}, {}, requirements, () => []);
         },
     },
     whens: {
-        addArtifact: (artifact) => (builder) => {
+        addArtifact: (artifact) => (builder, utils) => {
             builder.artifacts.push(artifact);
             return builder;
         },
-        setTestJobs: (jobs) => (builder) => {
+        setTestJobs: (jobs) => (builder, utils) => {
             builder.testJobs = jobs;
             return builder;
         },
@@ -56,49 +56,51 @@ export const implementation = {
             });
             return builder;
         },
-        "it generates TestSpecifications": () => (builder) => {
+        "it generates TestSpecifications": () => (builder, utils) => {
             if (!Array.isArray(builder.specs)) {
                 throw new Error("Specs were not generated");
             }
             return builder;
         },
-        "it creates jobs": () => (builder) => {
+        "it creates jobs": () => (builder, utils) => {
             if (!Array.isArray(builder.testJobs)) {
                 throw new Error("Test jobs were not created");
             }
             return builder;
         },
-        "it tracks artifacts": () => (builder) => {
+        "it tracks artifacts": () => (builder, utils) => {
             if (!Array.isArray(builder.artifacts)) {
                 throw new Error("Artifacts array not initialized");
             }
+            // Verify we can write artifacts
+            utils.writeFileSync("artifact_test.txt", "test");
             return builder;
         },
-        resourceRequirementsSet: () => (builder) => {
+        resourceRequirementsSet: () => (builder, utils) => {
             if (!builder.testResourceRequirement) {
                 throw new Error("Resource requirements not set");
             }
             return builder;
         },
-        suitesOverridesConfigured: () => (builder) => {
+        suitesOverridesConfigured: () => (builder, utils) => {
             if (!builder.suitesOverrides) {
                 throw new Error("Suites overrides not configured");
             }
             return builder;
         },
-        givensOverridesConfigured: () => (builder) => {
+        givensOverridesConfigured: () => (builder, utils) => {
             if (!builder.givenOverides) {
                 throw new Error("Givens overrides not configured");
             }
             return builder;
         },
-        whensOverridesConfigured: () => (builder) => {
+        whensOverridesConfigured: () => (builder, utils) => {
             if (!builder.whenOverides) {
                 throw new Error("Whens overrides not configured");
             }
             return builder;
         },
-        thensOverridesConfigured: () => (builder) => {
+        thensOverridesConfigured: () => (builder, utils) => {
             if (!builder.thenOverides) {
                 throw new Error("Thens overrides not configured");
             }

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.mock.js

@@ -10,22 +10,33 @@ export class MockBaseBuilder extends BaseBuilder {
     /**
      * Simplified version for testing that doesn't actually run tests
      */
-    testRun(puppetMaster) {
-        this.summary = {
-            [puppetMaster.testResourceConfiguration.name]: {
-                typeErrors: 0,
-                staticErrors: 0,
-                runTimeError: "",
-                prompt: "",
-                failingFeatures: {},
-            },
-        };
-        return Promise.resolve({
-            failed: false,
-            fails: 0,
-            artifacts: [],
-            // logPromise: Promise.resolve(),
-            features: [],
-        });
+    async testRun(puppetMaster) {
+        try {
+            this.summary = {
+                [puppetMaster.testResourceConfiguration.name]: {
+                    typeErrors: 0,
+                    staticErrors: 0,
+                    runTimeError: "",
+                    prompt: "",
+                    failingFeatures: {},
+                },
+            };
+            return {
+                failed: false,
+                fails: 0,
+                artifacts: this.artifacts,
+                features: [],
+            };
+        }
+        catch (error) {
+            console.error("Test run failed:", error);
+            return {
+                failed: true,
+                fails: 1,
+                artifacts: this.artifacts,
+                features: [],
+                error: error.message
+            };
+        }
     }
 }

package/dist/module/src/lib/baseBuilder.test/baseBuilder.test.pure.js

@@ -1,5 +1,5 @@
 /* eslint-disable @typescript-eslint/no-empty-object-type */
-import Testeranto from "../../Web";
+import Testeranto from "../../Pure";
 import { specification } from "./baseBuilder.test.specification";
 import { implementation } from "./baseBuilder.test.implementation";
 import { testAdapter } from "./baseBuilder.test.adapter";

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

@@ -15,12 +15,15 @@ export class BaseBuilder {
         this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then());
         this.testJobs = this.specs.map((suite) => {
             const suiteRunner = (suite) => async (puppetMaster, tLog) => {
-                console.log("mark17");
-                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);
-                console.log("mark18");
-                return x;
+                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);
+                }
             };
             const runner = suiteRunner(suite);
             return {
@@ -30,38 +33,29 @@ export class BaseBuilder {
                 },
                 runner,
                 receiveTestResourceConfig: async function (puppetMaster) {
-                    // const logFilePath = "logs.txt";
-                    // const access: number = await puppetMaster.createWriteStream(
-                    //   logFilePath
-                    // );
-                    // deprecated?
                     const tLog = async (...l) => {
                         //
                     };
-                    console.log("mark14");
-                    const suiteDone = await runner(puppetMaster, tLog);
-                    console.log("mark15");
-                    // const logPromise = new Promise(async (res) => {
-                    //   await puppetMaster.end(access);
-                    //   res(true);
-                    // });
-                    const fails = suiteDone.fails;
-                    await puppetMaster.writeFileSync([
-                        `bdd_errors.txt`,
-                        fails.toString(),
-                    ]);
-                    await puppetMaster.writeFileSync([
-                        `tests.json`,
-                        JSON.stringify(this.toObj(), null, 2),
-                    ]);
-                    console.log("mark13");
-                    return {
-                        failed: fails > 0,
-                        fails,
-                        artifacts: this.artifacts || [],
-                        // logPromise,
-                        features: suiteDone.features(),
-                    };
+                    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: [],
+                        };
+                    }
                 },
             };
         });

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

@@ -1,3 +1,5 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 import { BaseBuilder } from "./basebuilder.js";
 export class ClassBuilder extends BaseBuilder {
     constructor(testImplementation, testSpecification, input, suiteKlasser, givenKlasser, whenKlasser, thenKlasser, testResourceRequirement) {
@@ -15,13 +17,13 @@ export class ClassBuilder extends BaseBuilder {
         }, {});
         const classyWhens = Object.entries(testImplementation.whens).reduce((a, [key, whEn]) => {
             a[key] = (...payload) => {
-                return new whenKlasser.prototype.constructor(`${whEn.name}: ${payload && payload.toString()}`, whEn(...payload));
+                return new whenKlasser.prototype.constructor(`${key}: ${payload && payload.toString()}`, whEn(...payload));
             };
             return a;
         }, {});
         const classyThens = Object.entries(testImplementation.thens).reduce((a, [key, thEn]) => {
-            a[key] = (expected, ...x) => {
-                return new thenKlasser.prototype.constructor(`${thEn.name}: ${expected && expected.toString()}`, thEn(expected, ...x));
+            a[key] = (...args) => {
+                return new thenKlasser.prototype.constructor(`${key}: ${args && args.toString()}`, thEn(...args));
             };
             return a;
         }, {});

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

@@ -15,10 +15,8 @@ export default class TesterantoCore extends ClassBuilder {
                 return fullAdapter.assertThis(t);
             }
             async setup(s, artifactory, tr, pm) {
-                return (fullAdapter.beforeAll ||
-                    (async (input, artifactory, tr, pm) => input))(s, this.testResourceConfiguration, 
-                // artifactory,
-                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;
             }
         }, class Given extends BaseGiven {
             constructor() {
@@ -26,11 +24,10 @@ export default class TesterantoCore extends ClassBuilder {
                 this.uberCatcher = uberCatcher;
             }
             async givenThat(subject, testResource, artifactory, initializer, initialValues, pm) {
-                console.log("mark800");
                 return fullAdapter.beforeEach(subject, initializer, testResource, initialValues, pm);
             }
             afterEach(store, key, artifactory, pm) {
-                return new Promise((res) => res(fullAdapter.afterEach(store, key, pm)));
+                return Promise.resolve(fullAdapter.afterEach(store, key, pm));
             }
         }, class When extends BaseWhen {
             async andWhen(store, whenCB, testResource, pm) {

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

@@ -6,19 +6,6 @@ import TesterantoCore from "../core";
  */
 export class MockCore extends TesterantoCore {
     constructor(input, testSpecification, testImplementation, testResourceRequirement = { ports: [] }, testAdapter, uberCatcher = (cb) => cb()) {
-        console.log("[DEBUG] MockCore constructor starting...");
-        if (!testImplementation) {
-            throw new Error("testImplementation is required");
-        }
-        if (!testSpecification) {
-            console.warn("[WARN] testSpecification is null/undefined - tests may fail");
-        }
-        console.log("[DEBUG] MockCore constructor called with:");
-        console.log("- input:", JSON.stringify(input, null, 2));
-        console.log("- testSpecification keys:", Object.keys(testSpecification));
-        console.log("- testImplementation keys:", Object.keys(testImplementation));
-        console.log("- testResourceRequirement:", JSON.stringify(testResourceRequirement));
-        console.log("- testAdapter keys:", Object.keys(testAdapter));
         // Validate required implementation methods
         const requiredMethods = ["suites", "givens", "whens", "thens"];
         requiredMethods.forEach((method) => {
@@ -26,7 +13,6 @@ export class MockCore extends TesterantoCore {
                 throw new Error(`Missing required implementation method: ${method}`);
             }
         });
-        console.log("[DEBUG] Validation passed, calling super...");
         // this.testResourceRequirement = testResourceRequirement;
         // this.testAdapter = testAdapter;
         super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, uberCatcher);

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

@@ -2,25 +2,18 @@ import { MockCore } from "./MockCore";
 export const testAdapter = {
     beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
         var _a;
-        console.log('[DEBUG] BeforeEach - subject:', subject);
-        console.log('[DEBUG] BeforeEach - initialValues:', initialValues);
-        console.log('[DEBUG] BeforeEach called with:');
-        console.log('- subject type:', typeof subject);
-        console.log('- testResource:', JSON.stringify(testResource, null, 2));
-        console.log('- initialValues:', initialValues);
         try {
             const result = await initializer();
             if (!result) {
-                throw new Error('Initializer returned undefined');
+                throw new Error("Initializer returned undefined");
             }
             if (!(result instanceof MockCore)) {
                 throw new Error(`Initializer returned ${(_a = result === null || result === void 0 ? void 0 : result.constructor) === null || _a === void 0 ? void 0 : _a.name}, expected MockCore`);
             }
-            console.log('[DEBUG] BeforeEach initialized MockCore successfully');
             return result;
         }
         catch (e) {
-            console.error('[ERROR] BeforeEach failed:', e);
+            console.error("[ERROR] BeforeEach failed:", e);
             throw e;
         }
     },

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

@@ -6,18 +6,14 @@ export const implementation = {
     },
     givens: {
         Default: () => {
-            console.log('[DEBUG] Creating Default MockCore instance');
             const input = { debug: true };
             const resourceReq = { ports: [3000] };
-            console.log('[DEBUG] Default Given - input:', input);
-            console.log('[DEBUG] Default Given - resourceReq:', resourceReq);
             try {
                 const instance = new MockCore(input, specification, implementation, resourceReq, testAdapter, (cb) => cb());
-                console.log('[DEBUG] MockCore instance created successfully:', instance);
                 return instance;
             }
             catch (e) {
-                console.error('[ERROR] Failed to create MockCore:', e);
+                console.error("[ERROR] Failed to create MockCore:", e);
                 throw e;
             }
         },
@@ -42,9 +38,9 @@ export const implementation = {
         },
         modifySpecs: (modifier) => (builder) => {
             var _a;
-            console.log('Modifying specs - current count:', (_a = builder.specs) === null || _a === void 0 ? void 0 : _a.length);
+            console.log("Modifying specs - current count:", (_a = builder.specs) === null || _a === void 0 ? void 0 : _a.length);
             const newSpecs = modifier(builder.specs || []);
-            console.log('Modifying specs - new count:', newSpecs.length);
+            console.log("Modifying specs - new count:", newSpecs.length);
             builder.specs = newSpecs;
             return builder;
         },

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

@@ -1,26 +1,25 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 export const BaseAdapter = () => ({
-    beforeAll: async (s) => s,
-    beforeEach: async function (subject, initialValues, x, testResource, pm) {
+    beforeAll: async (input, testResource, pm) => {
+        return input;
+    },
+    beforeEach: async function (subject, initializer, testResource, initialValues, pm) {
         return subject;
     },
-    afterEach: async (s) => s,
-    afterAll: (store) => undefined,
-    butThen: async (store, thenCb) => {
-        return thenCb(store);
+    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) => {
-        try {
-            await whenCB(store, testResource, pm);
-        }
-        catch (error) {
-            console.error("Error in andWhen:", error);
-            throw error; // Re-throw to maintain test failure
-        }
+        return whenCB(store, pm);
     },
     assertThis: (x) => x,
 });
 export const DefaultAdapter = (p) => {
-    return Object.assign(Object.assign({}, BaseAdapter), p);
+    const base = BaseAdapter();
+    return Object.assign(Object.assign({}, base), p);
 };
 export const defaultTestResourceRequirement = {
     ports: 0,