testeranto 0.173.0 → 0.189.0

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

@@ -71,10 +71,12 @@ exports.implementation = {
             }
             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) => {

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

@@ -13,23 +13,34 @@ class MockBaseBuilder extends basebuilder_1.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
+            };
+        }
     }
 }
 exports.MockBaseBuilder = MockBaseBuilder;

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

@@ -4,9 +4,9 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 /* eslint-disable @typescript-eslint/no-empty-object-type */
-const Web_1 = __importDefault(require("../../Web"));
+const Pure_1 = __importDefault(require("../../Pure"));
 const baseBuilder_test_specification_1 = require("./baseBuilder.test.specification");
 const baseBuilder_test_implementation_1 = require("./baseBuilder.test.implementation");
 const baseBuilder_test_adapter_1 = require("./baseBuilder.test.adapter");
 const baseBuilder_test_mock_1 = require("./baseBuilder.test.mock");
-exports.default = (0, Web_1.default)(baseBuilder_test_mock_1.MockBaseBuilder.prototype, baseBuilder_test_specification_1.specification, baseBuilder_test_implementation_1.implementation, baseBuilder_test_adapter_1.testAdapter);
+exports.default = (0, Pure_1.default)(baseBuilder_test_mock_1.MockBaseBuilder.prototype, baseBuilder_test_specification_1.specification, baseBuilder_test_implementation_1.implementation, baseBuilder_test_adapter_1.testAdapter);

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

@@ -18,10 +18,15 @@ 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) => {
-                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;
+                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 {
@@ -31,35 +36,37 @@ class BaseBuilder {
                 },
                 runner,
                 receiveTestResourceConfig: async function (puppetMaster) {
-                    // const logFilePath = "logs.txt";
-                    // const access: number = await puppetMaster.createWriteStream(
-                    //   logFilePath
-                    // );
                     // deprecated?
                     const tLog = async (...l) => {
                         //
                     };
-                    const suiteDone = await runner(puppetMaster, tLog);
+                    try {
+                        const suiteDone = await runner(puppetMaster, tLog);
+                        const fails = suiteDone.fails;
+                        await puppetMaster.writeFileSync([
+                            `tests.json`,
+                            JSON.stringify(this.toObj(), null, 2),
+                        ]);
+                        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: [],
+                        };
+                    }
                     // 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),
-                    ]);
-                    return {
-                        failed: fails > 0,
-                        fails,
-                        artifacts: this.artifacts || [],
-                        // logPromise,
-                        features: suiteDone.features(),
-                    };
                 },
             };
         });

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

@@ -1,4 +1,6 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ClassBuilder = void 0;
 const basebuilder_js_1 = require("./basebuilder.js");

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

@@ -12,19 +12,6 @@ const core_1 = __importDefault(require("../core"));
  */
 class MockCore extends core_1.default {
     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) => {
@@ -32,7 +19,6 @@ class MockCore extends core_1.default {
                 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/common/src/lib/core.test/core.test.adapter.js

@@ -5,25 +5,18 @@ const MockCore_1 = require("./MockCore");
 exports.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_1.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/common/src/lib/core.test/core.test.implementation.js

@@ -9,18 +9,14 @@ exports.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_1.MockCore(input, specification, exports.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;
             }
         },
@@ -45,9 +41,9 @@ exports.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/common/src/lib/index.js

@@ -1,4 +1,6 @@
 "use strict";
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultTestResourceRequirement = exports.DefaultAdapter = exports.BaseAdapter = void 0;
 const BaseAdapter = () => ({

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

@@ -17,14 +17,26 @@ const baseProxy = function (pm, mappings) {
         },
     });
 };
-const butThenProxy = (pm, filepath) => {
+const butThenProxy = (pm, filepath, addArtifact) => {
     return baseProxy(pm, [
         [
             "screencast",
             (opts, p) => {
-                var _a, _b;
                 const path = `${filepath}/butThen/${opts.path}`;
-                (_b = (_a = pm.currentStep) === null || _a === void 0 ? void 0 : _a.artifacts) === null || _b === void 0 ? void 0 : _b.push(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,
@@ -34,27 +46,24 @@ const butThenProxy = (pm, filepath) => {
         [
             "createWriteStream",
             (fp) => {
-                var _a, _b;
                 const path = `${filepath}/butThen/${fp}`;
-                (_b = (_a = pm.currentStep) === null || _a === void 0 ? void 0 : _a.artifacts) === null || _b === void 0 ? void 0 : _b.push(path);
+                addArtifact(path);
                 return [path];
             },
         ],
         [
             "writeFileSync",
             (fp, contents) => {
-                var _a, _b;
                 const path = `${filepath}/butThen/${fp}`;
-                (_b = (_a = pm.currentStep) === null || _a === void 0 ? void 0 : _a.artifacts) === null || _b === void 0 ? void 0 : _b.push(path);
+                addArtifact(path);
                 return [path, contents];
             },
         ],
         [
             "customScreenShot",
             (opts, p) => {
-                var _a, _b;
                 const path = `${filepath}/butThen/${opts.path}`;
-                (_b = (_a = pm.currentStep) === null || _a === void 0 ? void 0 : _a.artifacts) === null || _b === void 0 ? void 0 : _b.push(path);
+                addArtifact(path);
                 return [
                     Object.assign(Object.assign({}, opts), { path }),
                     p,
@@ -64,99 +73,198 @@ const butThenProxy = (pm, filepath) => {
     ]);
 };
 exports.butThenProxy = butThenProxy;
-const andWhenProxy = (pm, filepath) => baseProxy(pm, [
-    [
-        "screencast",
-        (opts, p) => [
-            Object.assign(Object.assign({}, opts), { path: `${filepath}/andWhen/${opts.path}` }),
-            p,
-        ],
-    ],
-    ["createWriteStream", (fp) => [`${filepath}/andWhen/${fp}`]],
-    ["writeFileSync", (fp, contents) => [`${filepath}/andWhen${fp}`, contents]],
-    [
-        "customScreenShot",
-        (opts, p) => [
-            Object.assign(Object.assign({}, opts), { path: `${filepath}/andWhen${opts.path}` }),
-            p,
-        ],
-    ],
-]);
+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) => {
+                const path = `${filepath}/andWhen/${fp}`;
+                addArtifact(path);
+                return [path, contents];
+            },
+        ],
+        [
+            "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,
+                ];
+            },
+        ],
+    ]);
+};
 exports.andWhenProxy = andWhenProxy;
-const afterEachProxy = (pm, suite, given) => baseProxy(pm, [
-    [
-        "screencast",
-        (opts, p) => [
-            Object.assign(Object.assign({}, opts), { path: `suite-${suite}/given-${given}/afterEach/${opts.path}` }),
-            p,
-        ],
-    ],
-    ["createWriteStream", (fp) => [`suite-${suite}/afterEach/${fp}`]],
-    [
-        "writeFileSync",
-        (fp, contents) => [
-            `suite-${suite}/given-${given}/afterEach/${fp}`,
-            contents,
-        ],
-    ],
-    [
-        "customScreenShot",
-        (opts, p) => [
-            Object.assign(Object.assign({}, opts), { path: `suite-${suite}/given-${given}/afterEach/${opts.path}` }),
-            p,
-        ],
-    ],
-]);
+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) => {
+                const path = `suite-${suite}/given-${given}/afterEach/${fp}`;
+                addArtifact(path);
+                return [path, contents];
+            },
+        ],
+        [
+            "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,
+                ];
+            },
+        ],
+    ]);
+};
 exports.afterEachProxy = afterEachProxy;
-const beforeEachProxy = (pm, suite) => baseProxy(pm, [
-    [
-        "screencast",
-        (opts, p) => [
-            Object.assign(Object.assign({}, opts), { path: `suite-${suite}/beforeEach/${opts.path}` }),
-            p,
-        ],
-    ],
-    [
-        "writeFileSync",
-        (fp, contents) => [`suite-${suite}/beforeEach/${fp}`, contents],
-    ],
-    [
-        "customScreenShot",
-        (opts, p) => [
-            Object.assign(Object.assign({}, opts), { path: `suite-${suite}/beforeEach/${opts.path}` }),
-            p,
-        ],
-    ],
-    ["createWriteStream", (fp) => [`suite-${suite}/beforeEach/${fp}`]],
-]);
+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) => {
+                const path = `suite-${suite}/beforeEach/${fp}`;
+                addArtifact(path);
+                return [path, contents];
+            },
+        ],
+        [
+            "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];
+            },
+        ],
+    ]);
+};
 exports.beforeEachProxy = beforeEachProxy;
-const beforeAllProxy = (pm, suite) => baseProxy(pm, [
-    [
-        "writeFileSync",
-        (fp, contents) => [`suite-${suite}/beforeAll/${fp}`, contents],
-    ],
-    [
-        "customScreenShot",
-        (opts, p) => [
-            Object.assign(Object.assign({}, opts), { path: `suite-${suite}/beforeAll/${opts.path}` }),
-            p,
-        ],
-    ],
-    ["createWriteStream", (fp) => [`suite-${suite}/beforeAll/${fp}`]],
-]);
+const beforeAllProxy = (pm, suite, addArtifact) => {
+    return baseProxy(pm, [
+        [
+            "writeFileSync",
+            (fp, contents) => {
+                const path = `suite-${suite}/beforeAll/${fp}`;
+                addArtifact(path);
+                return [path, contents];
+            },
+        ],
+        [
+            "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];
+            },
+        ],
+    ]);
+};
 exports.beforeAllProxy = beforeAllProxy;
-const afterAllProxy = (pm, suite) => baseProxy(pm, [
-    ["createWriteStream", (fp) => [`suite-${suite}/afterAll/${fp}`]],
-    [
-        "writeFileSync",
-        (fp, contents) => [`suite-${suite}/afterAll/${fp}`, contents],
-    ],
-    [
-        "customScreenShot",
-        (opts, p) => [
-            Object.assign(Object.assign({}, opts), { path: `suite-${suite}/afterAll/${opts.path}` }),
-            p,
-        ],
-    ],
-]);
+const afterAllProxy = (pm, suite, addArtifact) => {
+    return baseProxy(pm, [
+        [
+            "createWriteStream",
+            (fp) => {
+                const path = `suite-${suite}/afterAll/${fp}`;
+                addArtifact(path);
+                return [path];
+            },
+        ],
+        [
+            "writeFileSync",
+            (fp, contents) => {
+                const path = `suite-${suite}/afterAll/${fp}`;
+                addArtifact(path);
+                return [path, contents];
+            },
+        ],
+        [
+            "customScreenShot",
+            (opts, p) => {
+                const path = `suite-${suite}/afterAll/${opts.path}`;
+                addArtifact(path);
+                return [
+                    Object.assign(Object.assign({}, opts), { path }),
+                    p,
+                ];
+            },
+        ],
+    ]);
+};
 exports.afterAllProxy = afterAllProxy;

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

@@ -18,11 +18,17 @@ exports.testAdapter = {
         // };
     },
     andWhen: async (store, whenCB, testResource, pm) => {
-        const proxiedPM = (0, pmProxy_1.andWhenProxy)(pm, "some/path");
+        const proxiedPM = (0, pmProxy_1.andWhenProxy)(pm, "some/path", (path) => {
+            console.log("Artifact added:", path);
+            return path;
+        });
         return whenCB(store, proxiedPM);
     },
     butThen: async (store, thenCB, testResource, pm) => {
-        const proxiedPM = (0, pmProxy_1.butThenProxy)(pm, "some/path");
+        const proxiedPM = (0, pmProxy_1.butThenProxy)(pm, "some/path", (path) => {
+            console.log("Artifact added:", path);
+            return path;
+        });
         return thenCB(store, proxiedPM);
     },
     afterEach: async (store, key, pm) => store,