testeranto 0.189.0 → 0.197.0

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

@@ -6,7 +6,6 @@ exports.BaseThen = exports.BaseWhen = exports.BaseGiven = void 0;
 const pmProxy_js_1 = require("./pmProxy.js");
 class BaseGiven {
     addArtifact(path) {
-        console.log("Given addArtifact", path);
         const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
         this.artifacts.push(normalizedPath);
     }
@@ -53,7 +52,9 @@ class BaseGiven {
             tLog(e.stack);
         });
         try {
-            const proxiedPm = (0, pmProxy_js_1.beforeEachProxy)(pm, suiteNdx.toString(), this.addArtifact.bind(this));
+            // Ensure addArtifact is properly bound to 'this'
+            const addArtifact = this.addArtifact.bind(this);
+            const proxiedPm = (0, pmProxy_js_1.beforeEachProxy)(pm, suiteNdx.toString(), addArtifact);
             this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB, this.initialValues, proxiedPm);
         }
         catch (e) {
@@ -80,7 +81,9 @@ class BaseGiven {
         }
         finally {
             try {
-                const proxiedPm = (0, pmProxy_js_1.afterEachProxy)(pm, suiteNdx.toString(), key, this.addArtifact.bind(this));
+                // Ensure addArtifact is properly bound to 'this'
+                const addArtifact = this.addArtifact.bind(this);
+                const proxiedPm = (0, pmProxy_js_1.afterEachProxy)(pm, suiteNdx.toString(), key, addArtifact);
                 // (proxiedPm as any).currentStep = this;
                 await this.afterEach(this.store, this.key, givenArtifactory, proxiedPm);
             }
@@ -96,7 +99,6 @@ class BaseGiven {
 exports.BaseGiven = BaseGiven;
 class BaseWhen {
     addArtifact(path) {
-        console.log("When addArtifact", path);
         const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
         this.artifacts.push(normalizedPath);
     }
@@ -119,7 +121,9 @@ class BaseWhen {
     async test(store, testResourceConfiguration, tLog, pm, filepath) {
         try {
             // tLog(" When:", this.name);
-            const proxiedPm = (0, pmProxy_js_1.andWhenProxy)(pm, filepath, this.addArtifact.bind(this));
+            // 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;
@@ -141,7 +145,6 @@ class BaseThen {
         this.artifacts = [];
     }
     addArtifact(path) {
-        console.log("Then addArtifact", path);
         const normalizedPath = path.replace(/\\/g, "/"); // Normalize path separators
         this.artifacts.push(normalizedPath);
     }
@@ -154,11 +157,28 @@ class BaseThen {
         return obj;
     }
     async test(store, testResourceConfiguration, tLog, pm, filepath) {
-        const proxiedPm = (0, pmProxy_js_1.butThenProxy)(pm, filepath, this.addArtifact.bind(this));
+        // 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") {
-                    return await this.thenCB(s, proxiedPm);
+                    // 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;

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

@@ -2,18 +2,24 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.testAdapter = void 0;
 exports.testAdapter = {
-    beforeAll: async (input, testResource, pm) => input,
+    beforeAll: async (input, testResource, pm) => {
+        return input;
+    },
     beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-        const result = initializer();
+        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/common/src/lib/baseBuilder.test/baseBuilder.test.implementation.js

@@ -8,7 +8,7 @@ exports.implementation = {
         Default: "BaseBuilder test suite",
     },
     givens: {
-        "the default BaseBuilder": () => {
+        "the default BaseBuilder": () => () => {
             return new baseBuilder_test_mock_1.MockBaseBuilder({}, // input
             {}, // suitesOverrides
             {}, // givenOverrides
@@ -18,19 +18,19 @@ exports.implementation = {
             () => [] // testSpecification
             );
         },
-        "a BaseBuilder with TestInput": (input) => {
+        "a BaseBuilder with TestInput": (input) => () => {
             return new baseBuilder_test_mock_1.MockBaseBuilder(input, {}, {}, {}, {}, { ports: [] }, () => []);
         },
-        "a BaseBuilder with Test Resource Requirements": (requirements) => {
+        "a BaseBuilder with Test Resource Requirements": (requirements) => () => {
             return new baseBuilder_test_mock_1.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;
         },
@@ -59,13 +59,13 @@ exports.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");
             }
@@ -79,31 +79,31 @@ exports.implementation = {
             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/common/src/lib/basebuilder.js

@@ -36,17 +36,13 @@ class BaseBuilder {
                 },
                 runner,
                 receiveTestResourceConfig: async function (puppetMaster) {
-                    // deprecated?
                     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),
-                        ]);
+                        await puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2), "test");
                         return {
                             failed: fails > 0,
                             fails,
@@ -63,10 +59,6 @@ class BaseBuilder {
                             features: [],
                         };
                     }
-                    // const logPromise = new Promise(async (res) => {
-                    //   await puppetMaster.end(access);
-                    //   res(true);
-                    // });
                 },
             };
         });

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

@@ -20,13 +20,13 @@ class ClassBuilder extends basebuilder_js_1.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/common/src/lib/core.js

@@ -17,10 +17,8 @@ class TesterantoCore extends classBuilder_js_1.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 abstractBase_js_1.BaseGiven {
             constructor() {
@@ -31,7 +29,7 @@ class TesterantoCore extends classBuilder_js_1.ClassBuilder {
                 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 abstractBase_js_1.BaseWhen {
             async andWhen(store, whenCB, testResource, pm) {

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

@@ -4,29 +4,26 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.defaultTestResourceRequirement = exports.DefaultAdapter = exports.BaseAdapter = void 0;
 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,
 });
 exports.BaseAdapter = BaseAdapter;
 const DefaultAdapter = (p) => {
-    return Object.assign(Object.assign({}, exports.BaseAdapter), p);
+    const base = (0, exports.BaseAdapter)();
+    return Object.assign(Object.assign({}, base), p);
 };
 exports.DefaultAdapter = DefaultAdapter;
 exports.defaultTestResourceRequirement = {

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

@@ -10,10 +10,16 @@ const baseProxy = function (pm, mappings) {
                 const method = mapping[0];
                 const arger = mapping[1];
                 if (prop === method) {
-                    return (...x) => target[prop](arger(...x));
+                    return (...x) => {
+                        // Add debug logging
+                        const modifiedArgs = arger(...x);
+                        return target[prop](...modifiedArgs);
+                    };
                 }
             }
-            return (...x) => target[prop](...x);
+            return (...x) => {
+                return target[prop](...x);
+            };
         },
     });
 };
@@ -53,10 +59,27 @@ const butThenProxy = (pm, filepath, addArtifact) => {
         ],
         [
             "writeFileSync",
-            (fp, contents) => {
+            (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];
+                return [path, contents, testName];
             },
         ],
         [
@@ -96,10 +119,10 @@ const andWhenProxy = (pm, filepath, addArtifact) => {
         ],
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
                 const path = `${filepath}/andWhen/${fp}`;
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [
@@ -140,10 +163,10 @@ const afterEachProxy = (pm, suite, given, addArtifact) => {
         ],
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
                 const path = `suite-${suite}/given-${given}/afterEach/${fp}`;
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [
@@ -176,10 +199,10 @@ const beforeEachProxy = (pm, suite, addArtifact) => {
         ],
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
                 const path = `suite-${suite}/beforeEach/${fp}`;
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [
@@ -208,10 +231,10 @@ const beforeAllProxy = (pm, suite, addArtifact) => {
     return baseProxy(pm, [
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
                 const path = `suite-${suite}/beforeAll/${fp}`;
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [
@@ -248,10 +271,10 @@ const afterAllProxy = (pm, suite, addArtifact) => {
         ],
         [
             "writeFileSync",
-            (fp, contents) => {
+            (fp, contents, testName) => {
                 const path = `suite-${suite}/afterAll/${fp}`;
                 addArtifact(path);
-                return [path, contents];
+                return [path, contents, testName];
             },
         ],
         [

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

@@ -38,7 +38,17 @@ exports.testAdapter = {
             beforeEachProxy: input.butThenProxy(new mockPMBase_1.MockPMBase(), theGivenString),
         };
     },
-    assertThis: (returnedFilePath, expectation) => {
-        chai_1.assert.equal(returnedFilePath, expectation);
+    assertThis: (actualResult, expectedResult) => {
+        // Handle both path assertions and our new test result
+        if (typeof actualResult === 'string' && actualResult.startsWith('PASS')) {
+            chai_1.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
+            chai_1.assert.fail(`Test failed: ${actualResult}`);
+        }
+        else {
+            chai_1.assert.equal(actualResult, expectedResult);
+        }
     },
 };

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

@@ -8,25 +8,25 @@ function createPathRewriter(basePath) {
         if (!path)
             return path;
         // Normalize paths and handle edge cases
-        const normalizedPath = path.replace(/\\/g, '/');
-        const normalizedBase = basePath.replace(/\\/g, '/');
+        const normalizedPath = path.replace(/\\/g, "/");
+        const normalizedBase = basePath.replace(/\\/g, "/");
         // Handle absolute paths
-        if (normalizedPath.startsWith('/')) {
+        if (normalizedPath.startsWith("/")) {
             return `${normalizedBase}${normalizedPath}`;
         }
         // Handle parent directory references
-        if (normalizedPath.includes('../')) {
-            const parts = normalizedPath.split('/');
-            const baseParts = normalizedBase.split('/');
+        if (normalizedPath.includes("../")) {
+            const parts = normalizedPath.split("/");
+            const baseParts = normalizedBase.split("/");
             for (const part of parts) {
-                if (part === '..') {
+                if (part === "..") {
                     baseParts.pop();
                 }
-                else if (part !== '.') {
+                else if (part !== ".") {
                     baseParts.push(part);
                 }
             }
-            return baseParts.join('/');
+            return baseParts.join("/");
         }
         return `${normalizedBase}/${normalizedPath}`;
     };
@@ -42,58 +42,55 @@ exports.implementation = {
     // functions have no mutations
     },
     thens: {
-        theButTheProxyReturns: (method, expectedPath) => (store) => {
-            var _a, _b, _c, _d, _e, _f, _g, _h;
+        theButTheProxyReturns: (method, expectedPath) => async (store) => {
             const mockPm = new mockPMBase_1.MockPMBase();
             const filepath = "test/path";
-            const rewritePath = createPathRewriter(`${filepath}/butThen`);
+            // Track the actual path that was used
             let actualPath;
-            let actualContent;
+            // Monkey patch to track the path
+            const originalWriteFileSync = mockPm.writeFileSync;
+            mockPm.writeFileSync = async (path, content, testName) => {
+                actualPath = path;
+                return originalWriteFileSync.call(mockPm, path, content, testName);
+            };
+            const originalCreateWriteStream = mockPm.createWriteStream;
+            mockPm.createWriteStream = async (path, testName) => {
+                actualPath = path;
+                return originalCreateWriteStream.call(mockPm, path, testName);
+            };
+            const originalScreencast = mockPm.screencast;
+            mockPm.screencast = async (opts, testName, page) => {
+                actualPath = opts.path;
+                return originalScreencast.call(mockPm, opts, testName, page);
+            };
+            const originalCustomScreenShot = mockPm.customScreenShot;
+            mockPm.customScreenShot = async (opts, testName, pageUid) => {
+                actualPath = opts.path;
+                return originalCustomScreenShot.call(mockPm, opts, testName, pageUid);
+            };
             try {
                 switch (method) {
                     case "writeFileSync":
-                        const content = expectedPath.includes("content")
-                            ? "test content"
-                            : "default content";
-                        (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).writeFileSync(expectedPath.includes("empty")
-                            ? ""
-                            : expectedPath.includes("nested")
-                                ? "nested/folder/test.txt"
-                                : expectedPath.includes("spaces")
-                                    ? "file with spaces.txt"
-                                    : expectedPath.includes("invalid")
-                                        ? "../invalid.txt"
-                                        : "test.txt", content);
-                        actualPath = (_a = mockPm.getLastCall("writeFileSync")) === null || _a === void 0 ? void 0 : _a.path;
-                        actualContent = (_b = mockPm.getLastCall("writeFileSync")) === null || _b === void 0 ? void 0 : _b.content;
+                        await (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).writeFileSync("test.txt", "content", "test");
                         break;
                     case "createWriteStream":
-                        (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).createWriteStream(expectedPath.includes("empty") ? "" : "stream.txt");
-                        actualPath = (_c = mockPm.getLastCall("createWriteStream")) === null || _c === void 0 ? void 0 : _c.path;
+                        await (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).createWriteStream("stream.txt", "test");
                         break;
                     case "screencast":
-                        (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).screencast({
-                            path: "screen.png",
-                            quality: 80,
-                            fullPage: true,
-                        }, "test");
-                        actualPath = (_e = (_d = mockPm.getLastCall("screencast")) === null || _d === void 0 ? void 0 : _d.opts) === null || _e === void 0 ? void 0 : _e.path;
-                        actualContent = (_f = mockPm.getLastCall("screencast")) === null || _f === void 0 ? void 0 : _f.opts;
+                        await (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).screencast({ path: "screen.png" }, "test");
                         break;
                     case "customScreenShot":
-                        (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).customScreenShot({ path: "shot.png" }, "test");
-                        actualPath = (_h = (_g = mockPm.getLastCall("customScreenShot")) === null || _g === void 0 ? void 0 : _g.opts) === null || _h === void 0 ? void 0 : _h.path;
+                        await (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).customScreenShot({ path: "shot.png" }, "test");
                         break;
                     default:
                         throw new Error(`Unknown method: ${method}`);
                 }
-                if (expectedPath === undefined) {
-                    return [undefined, undefined];
-                }
-                return [actualPath, expectedPath, actualContent];
+                // For now, just return the actual path to be asserted against expectedPath
+                // The testAdapter.assertThis will handle the comparison
+                return actualPath;
             }
             catch (error) {
-                return [error.message, expectedPath];
+                throw error;
             }
         },
         verifyContent: (expectedContent) => (result) => {
@@ -103,5 +100,38 @@ exports.implementation = {
             }
             return result;
         },
+        // Test to verify tests.json is written correctly
+        verifyTestsJsonWrite: () => async (store) => {
+            const mockPm = new mockPMBase_1.MockPMBase();
+            // Track the actual parameters passed to writeFileSync
+            let actualArgs;
+            const originalWriteFileSync = mockPm.writeFileSync;
+            mockPm.writeFileSync = async (...args) => {
+                actualArgs = args;
+                // Check if the first argument is being split
+                if (args[0] && typeof args[0] === "string") {
+                    console.log(`[TESTS.JSON DEBUG] First argument length: ${args[0].length}, value: "${args[0]}"`);
+                }
+                return originalWriteFileSync.apply(mockPm, args);
+            };
+            // Simulate writing tests.json through the proxy
+            // This should mimic the call in BaseBuilder: puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2))
+            const testData = { test: "data" };
+            // const result = await butThenProxy(mockPm, "test/path", {}).writeFileSync(
+            //   "tests.json",
+            //   JSON.stringify(testData, null, 2),
+            //   "test"
+            // );
+            // Check if both path and content are correct
+            if (actualArgs &&
+                actualArgs[0] === "test/path/butThen/tests.json" &&
+                actualArgs[1] === JSON.stringify(testData, null, 2) &&
+                actualArgs[2] === "test") {
+                return "PASS";
+            }
+            else {
+                return `FAIL: args=${JSON.stringify(actualArgs)}`;
+            }
+        },
     },
 };

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

@@ -24,6 +24,9 @@ const specification = (Suite, Given, When, Then) => [
         specialCharsTest: Given.SomeBaseString(["butThenProxy should handle special characters in paths"], [], [
             Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/file with spaces.txt"),
         ], "special chars test"),
+        testsJsonTest: Given.SomeBaseString(["butThenProxy should handle tests.json correctly"], [], [
+            Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/tests.json"),
+        ], "tests.json test"),
     }),
     Suite.Default("Proxy Type Coverage", {
         // Test all proxy types