testeranto 0.200.1 → 0.203.0

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

@@ -1,284 +0,0 @@
-/* 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) => {
-                        // Add debug logging
-                        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);
-                // 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,
-                ];
-            },
-        ],
-        [
-            "createWriteStream",
-            (fp) => {
-                const path = `${filepath}/butThen/${fp}`;
-                addArtifact(path);
-                return [path];
-            },
-        ],
-        [
-            "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];
-            },
-        ],
-        [
-            "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}`;
-                // console.log("STEP2", JSON.stringify(step));
-                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);
-                // console.log("STEP3", JSON.stringify(step));
-                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

@@ -1,51 +0,0 @@
-/* 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

@@ -1,134 +0,0 @@
-import { MockPMBase } from "./mockPMBase";
-import { butThenProxy } from "../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}`;
-    };
-}
-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);
-            };
-            try {
-                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;
-            }
-            catch (error) {
-                throw error;
-            }
-        },
-        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

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

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

@@ -1,30 +0,0 @@
-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

@@ -1,127 +0,0 @@
-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();
-    }
-}