testeranto 0.146.2 → 0.146.4

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

@@ -0,0 +1,37 @@
+export const specification = (Suite, Given, When, Then, Check) => {
+    return [
+        Suite.Default("Basic ClassBuilder Functionality", {
+            // Basic initialization tests
+            initialization: Given.Default(["ClassBuilder should initialize with default values"], [], [Then.initializedProperly()]),
+            customInput: Given.WithCustomInput({ custom: "input" }, [], [Then.initializedProperly()]),
+            resourceRequirements: Given.WithResourceRequirements({ ports: [3000, 3001] }, [], [Then.resourceRequirementsSet()]),
+            // Core functionality tests
+            specGeneration: Given.Default(["Should generate specs from test specification"], [], [Then.specsGenerated()]),
+            jobCreation: Given.Default(["Should create test jobs from specs"], [], [Then.jobsCreated()]),
+            artifactTracking: Given.Default(["Should track artifacts"], [When.addArtifact(Promise.resolve("test"))], [Then.artifactsTracked()]),
+            // Configuration tests
+            overridesConfiguration: Given.Default(["Should properly configure all overrides"], [], [
+                Then.suitesOverridesConfigured(),
+                Then.givensOverridesConfigured(),
+                Then.whensOverridesConfigured(),
+                Then.thensOverridesConfigured(),
+                Then.checksOverridesConfigured(),
+            ]),
+        }, []),
+        Suite.ExtendedSuite("Advanced ClassBuilder Functionality", {
+            // Custom implementations
+            customImplementation: Given.WithCustomImplementation(implementation, [], [Then.specsGenerated(), Then.jobsCreated()]),
+            customSpecification: Given.WithCustomSpecification(specification, [], [Then.specsGenerated(), Then.jobsCreated()]),
+            // Dynamic modification tests
+            modifySpecs: Given.Default(["Should allow modifying specs"], [When.modifySpecs((specs) => [...specs, "extra"])], [Then.specsModified(1)]),
+            modifyJobs: Given.Default(["Should allow modifying jobs"], [When.modifyJobs((jobs) => [...jobs, {}])], [Then.jobsModified(1)]),
+            // Error handling
+            errorHandling: Given.Default(["Should properly handle errors"], [When.triggerError("test error")], [Then.errorThrown("test error")]),
+            // Full test run
+            testRun: Given.Default(["Should complete a full test run successfully"], [], [Then.testRunSuccessful()]),
+        }, [
+            Check.ImplementationCheck((impl) => impl !== null),
+            Check.SpecificationCheck((spec) => spec !== null),
+        ]),
+    ];
+};

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

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

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

@@ -1,9 +1,10 @@
 /* eslint-disable @typescript-eslint/no-unused-vars */
 /* eslint-disable @typescript-eslint/no-explicit-any */
 import { DefaultTestInterface, defaultTestResourceRequirement, } from "./index.js";
-import { BaseSuite, BaseGiven, BaseWhen, BaseThen, BaseCheck, } from "./abstractBase.js";
+import { BaseGiven, BaseWhen, BaseThen, BaseCheck } from "./abstractBase.js";
 import { ClassBuilder } from "./classBuilder.js";
-export default class Testeranto extends ClassBuilder {
+import { BaseSuite } from "./BaseSuite.js";
+export default class TesterantoCore extends ClassBuilder {
     constructor(input, testSpecification, testImplementation, testResourceRequirement = defaultTestResourceRequirement, testInterface, uberCatcher) {
         const fullTestInterface = DefaultTestInterface(testInterface);
         super(testImplementation, testSpecification, input, class extends BaseSuite {
@@ -33,16 +34,6 @@ export default class Testeranto extends ClassBuilder {
         }, class When extends BaseWhen {
             async andWhen(store, whenCB, testResource, pm) {
                 return await fullTestInterface.andWhen(store, whenCB, testResource, pm);
-                // try {
-                //   return await fullTestInterface.andWhen(
-                //     store,
-                //     whenCB,
-                //     testResource,
-                //     pm
-                //   );
-                // } catch (e) {
-                //   console.log("mark22", e);
-                // }
             }
         }, class Then extends BaseThen {
             async butThen(store, thenCB, testResource, pm) {

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

@@ -0,0 +1,18 @@
+import TesterantoCore from "../core";
+/**
+ * Concrete implementation of Testeranto for testing purposes
+ */
+export class MockCore extends TesterantoCore {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement = { ports: [] }, testInterface = {}, uberCatcher = (cb) => cb()) {
+        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface, uberCatcher);
+    }
+    async receiveTestResourceConfig(partialTestResource) {
+        return {
+            failed: false,
+            fails: 0,
+            artifacts: [],
+            logPromise: Promise.resolve(),
+            features: [],
+        };
+    }
+}

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

@@ -0,0 +1,99 @@
+import { MockCore } from "./MockCore";
+import { PassThrough } from "stream";
+export const implementation = {
+    suites: {
+        Default: "Testeranto test suite",
+        ExtendedSuite: "Extended Testeranto test suite",
+    },
+    givens: {
+        Default: () => {
+            return new MockCore({}, // input
+            specification, // testSpecification 
+            implementation, // testImplementation
+            { ports: [] }, // testResourceRequirement
+            testInterface, // testInterface
+            (cb) => cb() // uberCatcher
+            );
+        },
+        WithCustomInput: (input) => {
+            return new MockCore(input, specification, implementation, { ports: [] }, testInterface, (cb) => cb());
+        },
+        WithResourceRequirements: (requirements) => {
+            return new MockCore({}, specification, implementation, requirements, testInterface, (cb) => cb());
+        },
+        WithCustomInterface: (customInterface) => {
+            return new MockCore({}, specification, implementation, { ports: [] }, Object.assign(Object.assign({}, testInterface), customInterface), (cb) => cb());
+        }
+    },
+    whens: {
+        addArtifact: (artifact) => (builder) => {
+            builder.artifacts.push(artifact);
+            return builder;
+        },
+        setTestJobs: (jobs) => (builder) => {
+            builder.testJobs = jobs;
+            return builder;
+        },
+        modifySpecs: (modifier) => (builder) => {
+            builder.specs = modifier(builder.specs || []);
+            return builder;
+        },
+        triggerError: (message) => (builder) => {
+            throw new Error(message);
+        },
+    },
+    thens: {
+        initializedProperly: () => (builder) => {
+            if (!(builder instanceof MockCore)) {
+                throw new Error("Builder was not properly initialized");
+            }
+            return builder;
+        },
+        specsGenerated: () => (builder) => {
+            if (!Array.isArray(builder.specs)) {
+                throw new Error("Specs were not generated");
+            }
+            return builder;
+        },
+        jobsCreated: () => (builder) => {
+            if (!Array.isArray(builder.testJobs)) {
+                throw new Error("Test jobs were not created");
+            }
+            return builder;
+        },
+        artifactsTracked: () => (builder) => {
+            if (!Array.isArray(builder.artifacts)) {
+                throw new Error("Artifacts array not initialized");
+            }
+            return builder;
+        },
+        resourceRequirementsSet: () => (builder) => {
+            if (!builder.testResourceRequirement) {
+                throw new Error("Resource requirements not set");
+            }
+            return builder;
+        },
+        interfaceConfigured: () => (builder) => {
+            if (!builder.testInterface) {
+                throw new Error("Test interface not configured");
+            }
+            return builder;
+        },
+        errorThrown: (expectedMessage) => (builder) => {
+            // Handled by test runner
+            return builder;
+        },
+        testRunSuccessful: () => async (builder) => {
+            try {
+                await builder.receiveTestResourceConfig("");
+                return builder;
+            }
+            catch (e) {
+                throw new Error(`Test run failed: ${e.message}`);
+            }
+        },
+    },
+    checks: {
+        Default: () => new PassThrough(),
+    },
+};

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

@@ -0,0 +1,15 @@
+export const testInterface = {
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        return initializer();
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        return whenCB(store, pm);
+    },
+    butThen: async (store, thenCB, testResource, pm) => {
+        return thenCB(store, pm);
+    },
+    afterEach: (store) => store,
+    afterAll: (store, pm) => { },
+    assertThis: (result) => !!result,
+    beforeAll: async (input, testResource, pm) => input
+};

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

@@ -0,0 +1,12 @@
+import Testeranto from "../../Pure";
+import { specification } from "./core.test.specification";
+import { implementation } from "./core.test.implementation";
+import { testInterface } from "./core.test.interface";
+import { MockCore } from "./MockCore";
+export default Testeranto(MockCore.prototype, // test subject
+specification, // test scenarios
+implementation, // test operations
+testInterface, // test lifecycle hooks
+{ ports: [] }, // resource requirements
+(cb) => cb() // error handler
+);

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

@@ -0,0 +1,29 @@
+export const specification = (Suite, Given, When, Then, Check) => {
+    return [
+        Suite.Default("Testeranto Core Functionality", {
+            // Initialization tests
+            defaultInitialization: Given.Default(["Should initialize with default values"], [], [Then.initializedProperly()]),
+            customInputInitialization: Given.WithCustomInput({ test: "input" }, [], [Then.initializedProperly()]),
+            // Configuration tests  
+            resourceConfig: Given.WithResourceRequirements({ ports: [3000, 3001] }, [], [Then.resourceRequirementsSet()]),
+            interfaceConfig: Given.WithCustomInterface({
+                assertThis: (x) => !!x,
+                beforeEach: async (s, i) => i()
+            }, [], [Then.interfaceConfigured()]),
+            // Core operations
+            specGeneration: Given.Default(["Should generate test specs"], [], [Then.specsGenerated()]),
+            jobCreation: Given.Default(["Should create test jobs"], [], [Then.jobsCreated()]),
+            artifactHandling: Given.Default(["Should track artifacts"], [When.addArtifact(Promise.resolve("test"))], [Then.artifactsTracked()])
+        }, []),
+        Suite.ExtendedSuite("Testeranto Advanced Features", {
+            // Error handling
+            errorPropagation: Given.Default(["Should propagate errors properly"], [When.triggerError("test error")], [Then.errorThrown("test error")]),
+            // Dynamic behavior
+            specModification: Given.Default(["Should allow spec modification"], [When.modifySpecs((specs) => [...specs, { name: "extra" }])], [Then.specsModified(1)]),
+            // Full lifecycle
+            testExecution: Given.Default(["Should execute full test lifecycle"], [], [Then.testRunSuccessful()]),
+            // Custom implementations
+            customImpl: Given.WithCustomImplementation(Object.assign(Object.assign({}, implementation), { suites: { Default: "Custom suite" } }), [], [Then.specsGenerated()])
+        }, [])
+    ];
+};

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

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

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

@@ -1,4 +1,6 @@
-const prxy = function (pm, mappings) {
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+const baseProxy = function (pm, mappings) {
     return new Proxy(pm, {
         get: (target, prop, receiver) => {
             for (const mapping of mappings) {
@@ -12,7 +14,7 @@ const prxy = function (pm, mappings) {
         },
     });
 };
-export const butThenProxy = (pm, filepath) => prxy(pm, [
+export const butThenProxy = (pm, filepath) => baseProxy(pm, [
     [
         "screencast",
         (opts, p) => [
@@ -33,7 +35,7 @@ export const butThenProxy = (pm, filepath) => prxy(pm, [
         ],
     ],
 ]);
-export const andWhenProxy = (pm, filepath) => prxy(pm, [
+export const andWhenProxy = (pm, filepath) => baseProxy(pm, [
     [
         "screencast",
         (opts, p) => [
@@ -51,7 +53,7 @@ export const andWhenProxy = (pm, filepath) => prxy(pm, [
         ],
     ],
 ]);
-export const afterEachProxy = (pm, suite, given) => prxy(pm, [
+export const afterEachProxy = (pm, suite, given) => baseProxy(pm, [
     [
         "screencast",
         (opts, p) => [
@@ -75,7 +77,7 @@ export const afterEachProxy = (pm, suite, given) => prxy(pm, [
         ],
     ],
 ]);
-export const beforeEachProxy = (pm, suite) => prxy(pm, [
+export const beforeEachProxy = (pm, suite) => baseProxy(pm, [
     [
         "screencast",
         (opts, p) => [
@@ -96,7 +98,7 @@ export const beforeEachProxy = (pm, suite) => prxy(pm, [
     ],
     ["createWriteStream", (fp) => [`suite-${suite}/beforeEach/${fp}`]],
 ]);
-export const beforeAllProxy = (pm, suite) => prxy(pm, [
+export const beforeAllProxy = (pm, suite) => baseProxy(pm, [
     [
         "writeFileSync",
         (fp, contents) => [`suite-${suite}/beforeAll/${fp}`, contents],
@@ -110,7 +112,7 @@ export const beforeAllProxy = (pm, suite) => prxy(pm, [
     ],
     ["createWriteStream", (fp) => [`suite-${suite}/beforeAll/${fp}`]],
 ]);
-export const afterAllProxy = (pm, suite) => prxy(pm, [
+export const afterAllProxy = (pm, suite) => baseProxy(pm, [
     ["createWriteStream", (fp) => [`suite-${suite}/afterAll/${fp}`]],
     [
         "writeFileSync",
@@ -124,162 +126,3 @@ export const afterAllProxy = (pm, suite) => prxy(pm, [
         ],
     ],
 ]);
-/////////////////////////////////////////////////
-// export const butThenProxy = (pm: IPM, filepath: string) => {
-//   return new Proxy(pm, {
-//     get: (target, prop, receiver) => {
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               path: `${filepath}/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) => target[prop](`${filepath}/${fp}`, contents);
-//       }
-//     },
-//   });
-// };
-// export const andWhenProxy = (pm: IPM, filepath: string) => {
-//   return new Proxy(pm, {
-//     get(target, prop, receiver) {
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               path: `${filepath}/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) =>
-//           target[prop](`${filepath}/andWhen/${fp}`, contents);
-//       }
-//       /* @ts-ignore:next-line */
-//       return Reflect.get(...arguments);
-//     },
-//   });
-// };
-// export const afterEachProxy = (pm: IPM, suite: string, given: string): IPM => {
-//   return new Proxy(pm, {
-//     get(target, prop, receiver) {
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               path: `suite-${suite}/given-${given}/afterEach/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) =>
-//           target[prop](
-//             `suite-${suite}/given-${given}/afterEach/${fp}`,
-//             contents
-//           );
-//       }
-//       /* @ts-ignore:next-line */
-//       return Reflect.get(...arguments);
-//     },
-//   });
-// };
-// export const beforeAllProxy = (pm: IPM, suite: string): IPM => {
-//   return new Proxy(pm, {
-//     get(target, prop, receiver) {
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               // path: `${filepath}/${opts.path}`,
-//               path: `suite-${suite}/beforeAll/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) =>
-//           target[prop](`suite-${suite}/beforeAll/${fp}`, contents);
-//       }
-//       /* @ts-ignore:next-line */
-//       return Reflect.get(...arguments);
-//     },
-//   });
-// };
-// export const beforeEachProxy = (pm: IPM, suite: string, given: string): IPM => {
-//   return new Proxy(pm, {
-//     get(target, prop, receiver) {
-//       // if (prop === "write") {
-//       //   return (handle, contents) =>
-//       //     target[prop](
-//       //       `suite-${suiteNdx}/given-${key}/when/beforeEach/${fp}`,
-//       //       contents
-//       //     );
-//       // }
-//       if (prop === "createWriteStream") {
-//         return (fp) =>
-//           target[prop](`suite-${suite}/given-${given}/when/beforeEach/${fp}`);
-//       }
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) =>
-//           target[prop](
-//             `suite-${suite}/given-${given}/when/beforeEach/${fp}`,
-//             contents
-//           );
-//       }
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               path: `suite-${suite}/given-${given}/when/beforeEach/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-//       if (prop === "screencast") {
-//         return (opts, p) =>
-//           target.screencast(
-//             {
-//               ...opts,
-//               path: `suite-${suite}/given-${given}/when/beforeEach/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-//       /* @ts-ignore:next-line */
-//       return Reflect.get(...arguments);
-//     },
-//   });
-// };
-// export const afterAllProxy = (pm: IPM, suite: string): IPM => {
-//   return new Proxy(pm, {
-//     get(target, prop, receiver) {
-//       if (prop === "customScreenShot") {
-//         return (opts, p) =>
-//           target.customScreenShot(
-//             {
-//               ...opts,
-//               // path: `${filepath}/${opts.path}`,
-//               path: `suite-${suite}/afterAll/${opts.path}`,
-//             },
-//             p
-//           );
-//       }
-//       if (prop === "writeFileSync") {
-//         return (fp, contents) =>
-//           target[prop](`suite-${suite}/afterAll/${fp}`, contents);
-//       }
-//       /* @ts-ignore:next-line */
-//       return Reflect.get(...arguments);
-//     },
-//   });
-// };

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

@@ -0,0 +1,73 @@
+import { MockPMBase } from "./mockPMBase";
+export const implementation = {
+    suites: {
+        Default: "PM Proxy Tests",
+    },
+    givens: {
+        SomeBaseString: (s) => s,
+    },
+    whens: {
+    // functions have no mutations
+    },
+    thens: {
+        theButTheProxyReturns: (method, expectedPath) => (store) => {
+            var _a, _b, _c, _d, _e, _f, _g, _h;
+            const mockPm = new MockPMBase();
+            const filepath = "test/path";
+            const proxiedPm = store.butThenProxy(mockPm, filepath);
+            let actualPath;
+            let actualContent;
+            try {
+                switch (method) {
+                    case "writeFileSync":
+                        const content = expectedPath.includes('content') ?
+                            "test content" : "default content";
+                        proxiedPm.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;
+                        break;
+                    case "createWriteStream":
+                        proxiedPm.createWriteStream(expectedPath.includes('empty') ? "" : "stream.txt");
+                        actualPath = (_c = mockPm.getLastCall("createWriteStream")) === null || _c === void 0 ? void 0 : _c.path;
+                        break;
+                    case "screencast":
+                        proxiedPm.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;
+                        break;
+                    case "customScreenShot":
+                        proxiedPm.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;
+                        break;
+                    default:
+                        throw new Error(`Unknown method: ${method}`);
+                }
+                if (expectedPath === undefined) {
+                    return [undefined, undefined];
+                }
+                return [actualPath, expectedPath, actualContent];
+            }
+            catch (error) {
+                return [error.message, expectedPath];
+            }
+        },
+        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;
+        },
+    },
+    checks: {
+        Default: (s) => s,
+    },
+};

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

@@ -0,0 +1,10 @@
+import Testeranto from "../../Node";
+import { implementation } from "./implementation";
+import { specification } from "./specification";
+import { testInterface } from "./interface";
+import { butThenProxy } from "../pmProxy";
+export default Testeranto(
+// because of the nature of testeranto, we must add all the testable items here
+{
+    butThenProxy,
+}, specification, implementation, testInterface);

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

@@ -0,0 +1,34 @@
+import { assert } from "chai";
+import { andWhenProxy, butThenProxy } from "../pmProxy";
+import { MockPMBase } from "./mockPMBase";
+// import { butThenProxy, andWhenProxy, beforeEachProxy } from "../pmProxy";
+export const testInterface = {
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        return subject;
+        // const mockPM = MockPMBase();
+        // return {
+        //   beforeEachProxy: subject.butThenProxy(
+        //     new MockPMBase() as unknown as IPM,
+        //     initializer
+        //   ),
+        // };
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        const proxiedPM = andWhenProxy(pm, "some/path");
+        return whenCB(store, proxiedPM);
+    },
+    butThen: async (store, thenCB, testResource, pm) => {
+        const proxiedPM = butThenProxy(pm, "some/path");
+        return thenCB(store, proxiedPM);
+    },
+    afterEach: async (store, key, pm) => store,
+    afterAll: async (store, pm) => { },
+    beforeAll: async (input, testResource, pm, theGivenString) => {
+        return {
+            beforeEachProxy: input.butThenProxy(new MockPMBase(), theGivenString),
+        };
+    },
+    assertThis: (returnedFilePath, expectation) => {
+        assert.equal(returnedFilePath, expectation);
+    },
+};

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

@@ -0,0 +1,30 @@
+import { MockPMBase } from "./mockPMBase";
+export class MockPM extends MockPMBase {
+    constructor(configs) {
+        super(configs);
+        this.server = {};
+        this.testResourceConfiguration = {};
+    }
+    // PM-specific methods
+    start() {
+        this.trackCall("start", {});
+        return Promise.resolve();
+    }
+    stop() {
+        this.trackCall("stop", {});
+        return Promise.resolve();
+    }
+    launchSideCar(n) {
+        this.trackCall("launchSideCar", { n });
+        return Promise.resolve([n, this.testResourceConfiguration]);
+    }
+    stopSideCar(n) {
+        this.trackCall("stopSideCar", { n });
+        return Promise.resolve();
+    }
+    // Override any methods that need different behavior from MockPMBase
+    // For example:
+    writeFileSync(path, content) {
+        return super.writeFileSync(path, content, "default-test-name");
+    }
+}