testeranto 0.203.0 → 0.206.0

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

@@ -0,0 +1,251 @@
+/* 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) {
+                const method = mapping[0];
+                const arger = mapping[1];
+                if (prop === method) {
+                    return (...x) => {
+                        const modifiedArgs = arger(...x);
+                        return target[prop](...modifiedArgs);
+                    };
+                }
+            }
+            return (...x) => {
+                return target[prop](...x);
+            };
+        },
+    });
+};
+export const butThenProxy = (pm, filepath, addArtifact) => {
+    return baseProxy(pm, [
+        [
+            "screencast",
+            (opts, p) => {
+                const path = `${filepath}/butThen/${opts.path}`;
+                addArtifact(path);
+                return [
+                    Object.assign(Object.assign({}, opts), { path }),
+                    p,
+                ];
+            },
+        ],
+        [
+            "createWriteStream",
+            (fp) => {
+                const path = `${filepath}/butThen/${fp}`;
+                addArtifact(path);
+                return [path];
+            },
+        ],
+        [
+            "writeFileSync",
+            (fp, contents, testName) => {
+                const path = `${filepath}/butThen/${fp}`;
+                addArtifact(path);
+                return [path, contents, testName];
+            },
+        ],
+        [
+            "customScreenShot",
+            (opts, p) => {
+                const path = `${filepath}/butThen/${opts.path}`;
+                addArtifact(path);
+                return [
+                    Object.assign(Object.assign({}, opts), { path }),
+                    p,
+                ];
+            },
+        ],
+    ]);
+};
+export 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, testName) => {
+                const path = `${filepath}/andWhen/${fp}`;
+                addArtifact(path);
+                return [path, contents, testName];
+            },
+        ],
+        [
+            "customScreenShot",
+            (opts, p) => {
+                const path = `${filepath}/andWhen/${opts.path}`;
+                addArtifact(path);
+                return [
+                    Object.assign(Object.assign({}, opts), { path }),
+                    p,
+                ];
+            },
+        ],
+    ]);
+};
+export 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, testName) => {
+                const path = `suite-${suite}/given-${given}/afterEach/${fp}`;
+                addArtifact(path);
+                return [path, contents, testName];
+            },
+        ],
+        [
+            "customScreenShot",
+            (opts, p) => {
+                const path = `suite-${suite}/given-${given}/afterEach/${opts.path}`;
+                addArtifact(path);
+                return [
+                    Object.assign(Object.assign({}, opts), { path }),
+                    p,
+                ];
+            },
+        ],
+    ]);
+};
+export 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, testName) => {
+                const path = `suite-${suite}/beforeEach/${fp}`;
+                addArtifact(path);
+                return [path, contents, testName];
+            },
+        ],
+        [
+            "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];
+            },
+        ],
+    ]);
+};
+export const beforeAllProxy = (pm, suite, addArtifact) => {
+    return baseProxy(pm, [
+        [
+            "writeFileSync",
+            (fp, contents, testName) => {
+                const path = `suite-${suite}/beforeAll/${fp}`;
+                addArtifact(path);
+                return [path, contents, testName];
+            },
+        ],
+        [
+            "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];
+            },
+        ],
+    ]);
+};
+export const afterAllProxy = (pm, suite, addArtifact) => {
+    return baseProxy(pm, [
+        [
+            "createWriteStream",
+            (fp) => {
+                const path = `suite-${suite}/afterAll/${fp}`;
+                addArtifact(path);
+                return [path];
+            },
+        ],
+        [
+            "writeFileSync",
+            (fp, contents, testName) => {
+                const path = `suite-${suite}/afterAll/${fp}`;
+                addArtifact(path);
+                return [path, contents, testName];
+            },
+        ],
+        [
+            "customScreenShot",
+            (opts, p) => {
+                const path = `suite-${suite}/afterAll/${opts.path}`;
+                addArtifact(path);
+                return [
+                    Object.assign(Object.assign({}, opts), { path }),
+                    p,
+                ];
+            },
+        ],
+    ]);
+};

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

@@ -0,0 +1,51 @@
+/* eslint-disable @typescript-eslint/no-unused-vars */
+import { assert } from "chai";
+import { andWhenProxy, butThenProxy } from "../pmProxy";
+import { MockPMBase } from "./mockPMBase";
+// import { butThenProxy, andWhenProxy, beforeEachProxy } from "../pmProxy";
+export const testAdapter = {
+    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", (path) => {
+            console.log("Artifact added:", path);
+            return path;
+        });
+        return whenCB(store, proxiedPM);
+    },
+    butThen: async (store, thenCB, testResource, pm) => {
+        const proxiedPM = butThenProxy(pm, "some/path", (path) => {
+            console.log("Artifact added:", path);
+            return 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: (actualResult, expectedResult) => {
+        // Handle both path assertions and our new test result
+        if (typeof actualResult === 'string' && actualResult.startsWith('PASS')) {
+            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
+            assert.fail(`Test failed: ${actualResult}`);
+        }
+        else {
+            assert.equal(actualResult, expectedResult);
+        }
+    },
+};

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

@@ -0,0 +1,127 @@
+import { MockPMBase } from "./mockPMBase";
+import { butThenProxy } from "../pmProxy";
+// 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}`;
+//   };
+// }
+export const implementation = {
+    suites: {
+        Default: "PM Proxy Tests",
+    },
+    givens: {
+        SomeBaseString: (s) => s,
+    },
+    whens: {
+    // functions have no mutations
+    },
+    thens: {
+        theButTheProxyReturns: (method, expectedPath) => async (store) => {
+            const mockPm = new MockPMBase();
+            const filepath = "test/path";
+            // Track the actual path that was used
+            let actualPath;
+            // 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);
+            };
+            switch (method) {
+                case "writeFileSync":
+                    await butThenProxy(mockPm, filepath, {}).writeFileSync("test.txt", "content", "test");
+                    break;
+                case "createWriteStream":
+                    await butThenProxy(mockPm, filepath, {}).createWriteStream("stream.txt", "test");
+                    break;
+                case "screencast":
+                    await butThenProxy(mockPm, filepath, {}).screencast({ path: "screen.png" }, "test");
+                    break;
+                case "customScreenShot":
+                    await 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();
+        // 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/module/src/lib/pmProxy.test/index.js

@@ -0,0 +1,8 @@
+import Testeranto from "../../Node";
+import { implementation } from "./implementation";
+import { specification } from "./specification";
+import { testAdapter } from "./adapter";
+import { butThenProxy } from "../pmProxy";
+export default Testeranto({
+    butThenProxy,
+}, specification, implementation, testAdapter);

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

@@ -0,0 +1,31 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+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");
+    }
+}

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

@@ -0,0 +1,127 @@
+export class MockPMBase {
+    constructor(configs) {
+        this.calls = {};
+        this.testResourceConfiguration = {};
+        this.configs = configs || {};
+    }
+    // Common tracking functionality
+    trackCall(method, args) {
+        if (!this.calls[method]) {
+            this.calls[method] = [];
+        }
+        this.calls[method].push(args);
+    }
+    getCallCount(method) {
+        var _a;
+        return ((_a = this.calls[method]) === null || _a === void 0 ? void 0 : _a.length) || 0;
+    }
+    getLastCall(method) {
+        const calls = this.calls[method];
+        return calls ? calls[calls.length - 1] : null;
+    }
+    // Add missing methods used in tests
+    // writeFileSync(path: string, content: string): Promise<boolean> {
+    //   this.trackCall('writeFileSync', { path, content });
+    //   return Promise.resolve(true);
+    // }
+    // end(uid: number): Promise<boolean> {
+    //   this.trackCall('end', { uid });
+    //   return Promise.resolve(true);
+    // }
+    // Minimal implementations of required methods
+    launchSideCar(n, testName, projectName) {
+        this.trackCall("launchSideCar", { n, testName, projectName });
+        return Promise.resolve();
+    }
+    end(uid) {
+        this.trackCall("end", { uid });
+        // Add debug logging
+        console.debug(`Ending test with uid ${uid}`);
+        return Promise.resolve(true);
+    }
+    // Add debug method
+    debug(message) {
+        console.debug(`[MockPMBase] ${message}`);
+        this.trackCall("debug", { message });
+    }
+    writeFileSync(path, content, testName) {
+        this.trackCall("writeFileSync", { path, content, testName });
+        return Promise.resolve(true);
+    }
+    createWriteStream(path, testName) {
+        this.trackCall("createWriteStream", { path, testName });
+        return Promise.resolve(0);
+    }
+    screencast(opts, testName, page) {
+        this.trackCall("screencast", { opts, testName, page });
+        return Promise.resolve({});
+    }
+    customScreenShot(opts, testName, pageUid) {
+        this.trackCall("customScreenShot", { opts, testName, pageUid });
+        return Promise.resolve({});
+    }
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            this.trackCall("testArtiFactoryfileWriter", { fPath, value });
+            callback(Promise.resolve());
+        };
+    }
+    // Other required PM_Base methods with minimal implementations
+    closePage(p) {
+        return Promise.resolve();
+    }
+    $(selector, p) {
+        return Promise.resolve();
+    }
+    click(selector, page) {
+        return Promise.resolve();
+    }
+    goto(p, url) {
+        return Promise.resolve();
+    }
+    newPage() {
+        return Promise.resolve("mock-page");
+    }
+    pages() {
+        return Promise.resolve(["mock-page"]);
+    }
+    waitForSelector(p, s) {
+        return Promise.resolve(true);
+    }
+    focusOn(selector, p) {
+        return Promise.resolve();
+    }
+    typeInto(value, p) {
+        return Promise.resolve();
+    }
+    getAttribute(selector, attribute, p) {
+        return Promise.resolve();
+    }
+    getInnerHtml(selector, p) {
+        return Promise.resolve();
+    }
+    isDisabled(selector, p) {
+        return Promise.resolve(false);
+    }
+    screencastStop(s) {
+        return Promise.resolve();
+    }
+    existsSync(destFolder) {
+        return false;
+    }
+    mkdirSync(fp) {
+        return Promise.resolve();
+    }
+    write(uid, contents) {
+        return Promise.resolve(true);
+    }
+    page(p) {
+        return "mock-page";
+    }
+    doInPage(p, cb) {
+        return Promise.resolve();
+    }
+    customclose() {
+        return Promise.resolve();
+    }
+}