testeranto 0.202.0 → 0.205.0

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

@@ -32,7 +32,19 @@ class Tiposkripto {
             return a;
         }, {});
         const classyGivens = Object.entries(testImplementation.givens).reduce((a, [key, g]) => {
-            a[key] = (name, features, whens, thens, gcb, initialValues) => {
+            a[key] = (
+            // name: string,
+            features, whens, thens, gcb, initialValues) => {
+                // Debug the parameters being passed - check if features contains when-like objects
+                // console.log(`[Tiposkripto] Creating Given ${key} with:`);
+                // console.log(`  name: ${name}`);
+                // console.log(`  features:`, features);
+                // console.log(`  whens:`, whens);
+                // console.log(`  thens:`, thens);
+                // Ensure parameters are arrays and create copies to avoid reference issues
+                const safeFeatures = Array.isArray(features) ? [...features] : [];
+                const safeWhens = Array.isArray(whens) ? [...whens] : [];
+                const safeThens = Array.isArray(thens) ? [...thens] : [];
                 return new (class extends BaseGiven_1.BaseGiven {
                     constructor() {
                         super(...arguments);
@@ -44,27 +56,33 @@ class Tiposkripto {
                     afterEach(store, key, artifactory, pm) {
                         return Promise.resolve(fullAdapter.afterEach(store, key, pm));
                     }
-                })(name, features, whens, thens, testImplementation.givens[key], initialValues);
+                })(
+                // name,
+                safeFeatures, safeWhens, safeThens, testImplementation.givens[key], initialValues);
             };
             return a;
         }, {});
         const classyWhens = Object.entries(testImplementation.whens).reduce((a, [key, whEn]) => {
             a[key] = (...payload) => {
-                return new (class extends BaseWhen_js_1.BaseWhen {
+                const whenInstance = new (class extends BaseWhen_js_1.BaseWhen {
                     async andWhen(store, whenCB, testResource, pm) {
                         return await fullAdapter.andWhen(store, whenCB, testResource, pm);
                     }
                 })(`${key}: ${payload && payload.toString()}`, whEn(...payload));
+                // console.log(`[Tiposkripto] Created When ${key}:`, whenInstance.name);
+                return whenInstance;
             };
             return a;
         }, {});
         const classyThens = Object.entries(testImplementation.thens).reduce((a, [key, thEn]) => {
             a[key] = (...args) => {
-                return new (class extends BaseThen_js_1.BaseThen {
+                const thenInstance = new (class extends BaseThen_js_1.BaseThen {
                     async butThen(store, thenCB, testResource, pm) {
                         return await fullAdapter.butThen(store, thenCB, testResource, pm);
                     }
                 })(`${key}: ${args && args.toString()}`, thEn(...args));
+                // console.log(`[Tiposkripto] Created Then ${key}:`, thenInstance.name);
+                return thenInstance;
             };
             return a;
         }, {});
@@ -77,11 +95,7 @@ class Tiposkripto {
         this.testSpecification = testSpecification;
         // Generate specs
         this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then());
-        // Calculate total number of tests (sum of all Givens across all Suites)
-        // Each suite should have a 'givens' property that's a record of test names to BaseGiven instances
         this.totalTests = this.calculateTotalTests();
-        console.log(`Total tests calculated: ${this.totalTests}`);
-        // Create test jobs
         this.testJobs = this.specs.map((suite) => {
             const suiteRunner = (suite) => async (puppetMaster, tLog) => {
                 try {
@@ -109,6 +123,7 @@ class Tiposkripto {
                     try {
                         const suiteDone = await runner(puppetMaster, tLog);
                         const fails = suiteDone.fails;
+                        // Always use PM.writeFileSync to write tests.json, not direct filesystem access
                         await puppetMaster.writeFileSync(`tests.json`, JSON.stringify(this.toObj(), null, 2), "test");
                         return {
                             failed: fails > 0,
@@ -156,12 +171,12 @@ class Tiposkripto {
     calculateTotalTests() {
         let total = 0;
         for (const suite of this.specs) {
-            if (suite && typeof suite === 'object') {
+            if (suite && typeof suite === "object") {
                 // Access the givens property which should be a record of test names to BaseGiven instances
                 // The givens property is typically on the suite instance
-                if ('givens' in suite) {
+                if ("givens" in suite) {
                     const givens = suite.givens;
-                    if (givens && typeof givens === 'object') {
+                    if (givens && typeof givens === "object") {
                         total += Object.keys(givens).length;
                     }
                 }

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

@@ -11,24 +11,13 @@ const Tiposkripto_1 = __importDefault(require("../Tiposkripto"));
  * Concrete implementation of Tiposkripto for testing purposes
  */
 class MockTiposkripto extends Tiposkripto_1.default {
-    constructor(input, testSpecification, testImplementation, testResourceRequirement = { ports: [] }, testAdapter, uberCatcher = (cb) => cb()) {
-        // Call super first
+    constructor(input, testSpecification, testImplementation, testResourceRequirement = { ports: 0 }, testAdapter, uberCatcher = (cb) => cb()) {
         super(input, testSpecification, testImplementation, testResourceRequirement, testAdapter, uberCatcher);
         this.specs = [];
         this.testJobs = [];
         this.artifacts = [];
         this.features = [];
         this.testImplementation = testImplementation;
-        // Add debug logging for features
-        console.log('MockTiposkripto constructor called with input:', JSON.stringify(input));
-        // Validate required implementation methods
-        const requiredMethods = ["suites", "givens", "whens", "thens"];
-        requiredMethods.forEach((method) => {
-            if (!testImplementation[method]) {
-                throw new Error(`Missing required implementation method: ${method}`);
-            }
-        });
-        // Store the test adapter
         this.testAdapter = testAdapter;
         // Store implementation methods as overrides
         this.suitesOverrides = testImplementation.suites;
@@ -40,9 +29,9 @@ class MockTiposkripto extends Tiposkripto_1.default {
         // Each Given corresponds to one test
         let totalTests = Object.keys(testImplementation.givens).length;
         // Override with specific values for test cases
-        if (input && typeof input === 'object') {
+        if (input && typeof input === "object") {
             const inputObj = input;
-            if ('testCount' in inputObj) {
+            if ("testCount" in inputObj) {
                 totalTests = Number(inputObj.testCount);
             }
         }
@@ -51,27 +40,27 @@ class MockTiposkripto extends Tiposkripto_1.default {
             this.features = this.extractFeaturesFromSpecification(testSpecification);
         }
         catch (error) {
-            console.error('Failed to extract features, using fallback:', error);
+            console.error("Failed to extract features, using fallback:", error);
             // Fallback to basic features
             this.features = [
-                'Tiposkripto should initialize with default values',
-                'Custom input test',
-                'Resource requirements test',
-                'Should generate specs from test specification',
-                'Should create test jobs from specs',
-                'Should track artifacts',
-                'Should properly configure all overrides',
-                'Interface configuration test',
-                'Custom implementation test',
-                'Custom specification test',
-                'Should allow modifying specs',
-                'Should allow modifying jobs',
-                'Should properly handle errors',
-                'Should complete a full test run successfully',
-                'Should correctly count the number of tests',
-                'Should set runTimeTests to -1 on hard errors',
-                'Given a config that has 1 suite containing 5 GivenWhenThens',
-                'Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens'
+                "Tiposkripto should initialize with default values",
+                "Custom input test",
+                "Resource requirements test",
+                "Should generate specs from test specification",
+                "Should create test jobs from specs",
+                "Should track artifacts",
+                "Should properly configure all overrides",
+                "Interface configuration test",
+                "Custom implementation test",
+                "Custom specification test",
+                "Should allow modifying specs",
+                "Should allow modifying jobs",
+                "Should properly handle errors",
+                "Should complete a full test run successfully",
+                "Should correctly count the number of tests",
+                "Should set runTimeTests to -1 on hard errors",
+                "Given a config that has 1 suite containing 5 GivenWhenThens",
+                "Given a config that has 1 suite containing 3 GivenWhenThens and 1 suite containing 3 GivenWhenThens",
             ];
         }
     }
@@ -82,14 +71,16 @@ class MockTiposkripto extends Tiposkripto_1.default {
             const mockSuite = (name, tests, features) => ({
                 name,
                 tests,
-                features
+                features,
             });
             // The Given function should take features, whens, thens
             const mockGiven = (features, whens, thens) => {
                 return {
-                    features: Array.isArray(features) ? features.filter(f => typeof f === 'string') : [],
+                    features: Array.isArray(features)
+                        ? features.filter((f) => typeof f === "string")
+                        : [],
                     whens,
-                    thens
+                    thens,
                 };
             };
             // Create mock When and Then objects that have all the methods from the implementation
@@ -98,13 +89,13 @@ class MockTiposkripto extends Tiposkripto_1.default {
             const mockThen = {};
             // Add all when methods
             if (this.testImplementation.whens) {
-                Object.keys(this.testImplementation.whens).forEach(key => {
+                Object.keys(this.testImplementation.whens).forEach((key) => {
                     mockWhen[key] = (...args) => ({ name: key, args });
                 });
             }
             // Add all then methods
             if (this.testImplementation.thens) {
-                Object.keys(this.testImplementation.thens).forEach(key => {
+                Object.keys(this.testImplementation.thens).forEach((key) => {
                     mockThen[key] = (...args) => ({ name: key, args });
                 });
             }
@@ -113,13 +104,13 @@ class MockTiposkripto extends Tiposkripto_1.default {
             // Extract all features from all tests in all suites
             const features = [];
             for (const suite of suites) {
-                if (suite && suite.tests && typeof suite.tests === 'object') {
+                if (suite && suite.tests && typeof suite.tests === "object") {
                     for (const testKey of Object.keys(suite.tests)) {
                         const test = suite.tests[testKey];
                         if (test && test.features && Array.isArray(test.features)) {
                             // Ensure all features are strings
                             for (const feature of test.features) {
-                                if (typeof feature === 'string') {
+                                if (typeof feature === "string") {
                                     features.push(feature);
                                 }
                             }
@@ -129,11 +120,10 @@ class MockTiposkripto extends Tiposkripto_1.default {
             }
             // Remove duplicates
             const uniqueFeatures = [...new Set(features)];
-            console.log('Extracted features:', JSON.stringify(uniqueFeatures));
             return uniqueFeatures;
         }
         catch (error) {
-            console.error('Error extracting features from specification:', error);
+            console.error("Error extracting features from specification:", error);
             return [];
         }
     }
@@ -144,13 +134,13 @@ class MockTiposkripto extends Tiposkripto_1.default {
                 throw new Error("Test adapter not configured");
             }
             // Ensure features are always strings
-            const stringFeatures = this.features.filter(f => typeof f === 'string');
+            const stringFeatures = this.features.filter((f) => typeof f === "string");
             // Calculate totalTests based on input
             let totalTests = Object.keys(this.givenOverides).length;
             const input = this.input;
             // Override with specific values for test cases
-            if (input && typeof input === 'object') {
-                if ('testCount' in input) {
+            if (input && typeof input === "object") {
+                if ("testCount" in input) {
                     totalTests = input.testCount;
                 }
             }

package/dist/common/src/lib/Tiposkripto.test/Tiposkripto.implementation.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.implementation = void 0;
 const MockTiposkripto_1 = require("./MockTiposkripto");
@@ -15,7 +17,7 @@ exports.implementation = {
             const builder = new MockTiposkripto_1.MockTiposkripto({}, // input
             Tiposkripto_specification_1.specification, // Use the current specification
             exports.implementation, // Use the current implementation
-            { ports: [] }, // Default resource requirements
+            { ports: 0 }, // Default resource requirements
             Tiposkripto_adapter_1.testAdapter, // Default adapter
             (cb) => cb() // Default uberCatcher
             );
@@ -27,19 +29,19 @@ exports.implementation = {
             return builder;
         },
         WithCustomInput: (input = {}) => {
-            return new MockTiposkripto_1.MockTiposkripto(input, Tiposkripto_specification_1.specification, exports.implementation, { ports: [] }, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
+            return new MockTiposkripto_1.MockTiposkripto(input, Tiposkripto_specification_1.specification, exports.implementation, { ports: 0 }, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
         },
         WithResourceRequirements: (requirements = { ports: 0 }) => {
             return new MockTiposkripto_1.MockTiposkripto({}, Tiposkripto_specification_1.specification, exports.implementation, requirements, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
         },
         WithCustomImplementation: (impl = exports.implementation) => {
-            return new MockTiposkripto_1.MockTiposkripto({}, Tiposkripto_specification_1.specification, impl, { ports: [] }, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
+            return new MockTiposkripto_1.MockTiposkripto({}, Tiposkripto_specification_1.specification, impl, { ports: 0 }, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
         },
         WithCustomSpecification: (spec = Tiposkripto_specification_1.specification) => {
-            return new MockTiposkripto_1.MockTiposkripto({}, spec, exports.implementation, { ports: [] }, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
+            return new MockTiposkripto_1.MockTiposkripto({}, spec, exports.implementation, { ports: 0 }, Tiposkripto_adapter_1.testAdapter, (cb) => cb());
         },
         WithCustomAdapter: (customAdapter = {}) => {
-            return new MockTiposkripto_1.MockTiposkripto({}, Tiposkripto_specification_1.specification, exports.implementation, { ports: [] }, Object.assign(Object.assign({}, Tiposkripto_adapter_1.testAdapter), customAdapter), (cb) => cb());
+            return new MockTiposkripto_1.MockTiposkripto({}, Tiposkripto_specification_1.specification, exports.implementation, { ports: 0 }, Object.assign(Object.assign({}, Tiposkripto_adapter_1.testAdapter), customAdapter), (cb) => cb());
         },
     },
     whens: {
@@ -147,16 +149,16 @@ exports.implementation = {
             }
             // Check if the test adapter has the required methods
             const requiredMethods = [
-                'beforeAll',
-                'beforeEach',
-                'andWhen',
-                'butThen',
-                'afterEach',
-                'afterAll',
-                'assertThis'
+                "beforeAll",
+                "beforeEach",
+                "andWhen",
+                "butThen",
+                "afterEach",
+                "afterAll",
+                "assertThis",
             ];
             for (const method of requiredMethods) {
-                if (typeof builder.testAdapter[method] !== 'function') {
+                if (typeof builder.testAdapter[method] !== "function") {
                     throw new Error(`Test adapter missing required method: ${method}`);
                 }
             }

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

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.specification = void 0;
-const Tiposkripto_implementation_1 = require("./Tiposkripto.implementation");
 const specification = (Suite, Given, When, Then) => {
     return [
         Suite.Default("Tiposkripto Core Functionality", {
@@ -27,8 +26,8 @@ const specification = (Suite, Given, When, Then) => {
         }),
         Suite.ExtendedSuite("Tiposkripto Advanced Features", {
             // Custom implementations
-            customImplementation: Given.WithCustomImplementation(["Custom implementation test"], [], [Then.specsGenerated(), Then.jobsCreated()], Tiposkripto_implementation_1.implementation),
-            customSpecification: Given.WithCustomSpecification(["Custom specification test"], [], [Then.specsGenerated(), Then.jobsCreated()], exports.specification),
+            customImplementation: Given.WithCustomImplementation(["Custom implementation test"], [], [Then.specsGenerated(), Then.jobsCreated()]),
+            customSpecification: Given.WithCustomSpecification(["Custom specification test"], [], [Then.specsGenerated(), Then.jobsCreated()]),
             // 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)]),
@@ -42,8 +41,12 @@ const specification = (Suite, Given, When, Then) => {
             // 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 }),
+            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/common/src/lib/pmProxy.js

@@ -11,7 +11,6 @@ const baseProxy = function (pm, mappings) {
                 const arger = mapping[1];
                 if (prop === method) {
                     return (...x) => {
-                        // Add debug logging
                         const modifiedArgs = arger(...x);
                         return target[prop](...modifiedArgs);
                     };
@@ -30,19 +29,6 @@ const butThenProxy = (pm, filepath, addArtifact) => {
             (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,
@@ -60,24 +46,7 @@ const butThenProxy = (pm, filepath, addArtifact) => {
         [
             "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];
             },
@@ -129,7 +98,6 @@ const andWhenProxy = (pm, filepath, addArtifact) => {
             "customScreenShot",
             (opts, p) => {
                 const path = `${filepath}/andWhen/${opts.path}`;
-                // console.log("STEP2", JSON.stringify(step));
                 addArtifact(path);
                 return [
                     Object.assign(Object.assign({}, opts), { path }),
@@ -174,7 +142,6 @@ const afterEachProxy = (pm, suite, given, addArtifact) => {
             (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,

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

@@ -3,34 +3,32 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.implementation = void 0;
 const mockPMBase_1 = require("./mockPMBase");
 const pmProxy_1 = require("../pmProxy");
-function createPathRewriter(basePath) {
-    return (path) => {
-        if (!path)
-            return path;
-        // Normalize paths and handle edge cases
-        const normalizedPath = path.replace(/\\/g, "/");
-        const normalizedBase = basePath.replace(/\\/g, "/");
-        // Handle absolute paths
-        if (normalizedPath.startsWith("/")) {
-            return `${normalizedBase}${normalizedPath}`;
-        }
-        // Handle parent directory references
-        if (normalizedPath.includes("../")) {
-            const parts = normalizedPath.split("/");
-            const baseParts = normalizedBase.split("/");
-            for (const part of parts) {
-                if (part === "..") {
-                    baseParts.pop();
-                }
-                else if (part !== ".") {
-                    baseParts.push(part);
-                }
-            }
-            return baseParts.join("/");
-        }
-        return `${normalizedBase}/${normalizedPath}`;
-    };
-}
+// function createPathRewriter(basePath: string): PathRewriter {
+//   return (path: string) => {
+//     if (!path) return path;
+//     // Normalize paths and handle edge cases
+//     const normalizedPath = path.replace(/\\/g, "/");
+//     const normalizedBase = basePath.replace(/\\/g, "/");
+//     // Handle absolute paths
+//     if (normalizedPath.startsWith("/")) {
+//       return `${normalizedBase}${normalizedPath}`;
+//     }
+//     // Handle parent directory references
+//     if (normalizedPath.includes("../")) {
+//       const parts = normalizedPath.split("/");
+//       const baseParts = normalizedBase.split("/");
+//       for (const part of parts) {
+//         if (part === "..") {
+//           baseParts.pop();
+//         } else if (part !== ".") {
+//           baseParts.push(part);
+//         }
+//       }
+//       return baseParts.join("/");
+//     }
+//     return `${normalizedBase}/${normalizedPath}`;
+//   };
+// }
 exports.implementation = {
     suites: {
         Default: "PM Proxy Tests",
@@ -68,70 +66,65 @@ exports.implementation = {
                 actualPath = opts.path;
                 return originalCustomScreenShot.call(mockPm, opts, testName, pageUid);
             };
-            try {
-                switch (method) {
-                    case "writeFileSync":
-                        await (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).writeFileSync("test.txt", "content", "test");
-                        break;
-                    case "createWriteStream":
-                        await (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).createWriteStream("stream.txt", "test");
-                        break;
-                    case "screencast":
-                        await (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).screencast({ path: "screen.png" }, "test");
-                        break;
-                    case "customScreenShot":
-                        await (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).customScreenShot({ path: "shot.png" }, "test");
-                        break;
-                    default:
-                        throw new Error(`Unknown method: ${method}`);
-                }
-                // For now, just return the actual path to be asserted against expectedPath
-                // The testAdapter.assertThis will handle the comparison
-                return actualPath;
-            }
-            catch (error) {
-                throw error;
+            switch (method) {
+                case "writeFileSync":
+                    await (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).writeFileSync("test.txt", "content", "test");
+                    break;
+                case "createWriteStream":
+                    await (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).createWriteStream("stream.txt", "test");
+                    break;
+                case "screencast":
+                    await (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).screencast({ path: "screen.png" }, "test");
+                    break;
+                case "customScreenShot":
+                    await (0, pmProxy_1.butThenProxy)(mockPm, filepath, {}).customScreenShot({ path: "shot.png" }, "test");
+                    break;
+                default:
+                    throw new Error(`Unknown method: ${method}`);
             }
+            // For now, just return the actual path to be asserted against expectedPath
+            // The testAdapter.assertThis will handle the comparison
+            return actualPath;
         },
-        verifyContent: (expectedContent) => (result) => {
-            const actualContent = result[2];
-            if (JSON.stringify(actualContent) !== JSON.stringify(expectedContent)) {
-                throw new Error(`Content mismatch. Expected: ${JSON.stringify(expectedContent)}, Got: ${JSON.stringify(actualContent)}`);
-            }
-            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)}`;
+    },
+    verifyContent: (expectedContent) => (result) => {
+        const actualContent = result[2];
+        if (JSON.stringify(actualContent) !== JSON.stringify(expectedContent)) {
+            throw new Error(`Content mismatch. Expected: ${JSON.stringify(expectedContent)}, Got: ${JSON.stringify(actualContent)}`);
+        }
+        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/index.js

@@ -8,8 +8,6 @@ const implementation_1 = require("./implementation");
 const specification_1 = require("./specification");
 const adapter_1 = require("./adapter");
 const pmProxy_1 = require("../pmProxy");
-exports.default = (0, Node_1.default)(
-// because of the nature of testeranto, we must add all the testable items here
-{
+exports.default = (0, Node_1.default)({
     butThenProxy: pmProxy_1.butThenProxy,
 }, specification_1.specification, implementation_1.implementation, adapter_1.testAdapter);

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

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.MockPM = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
 const mockPMBase_1 = require("./mockPMBase");
 class MockPM extends mockPMBase_1.MockPMBase {
     constructor(configs) {