testeranto 0.202.0 → 0.203.0

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();
-    }
-}

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

@@ -1,175 +0,0 @@
-console.log("wtf");
-export const specification = (Suite, Given, When, Then) => [
-    Suite.Default("PM Proxy Functionality", {
-        // Basic path rewriting tests
-        writeFileProxyTest: Given.SomeBaseString(["butThenProxy should rewrite writeFileSync paths"], [], [
-            Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/test.txt"),
-        ], "writeFileSync test"),
-        // createWriteStreamProxyTest: Given.SomeBaseString(
-        //   ["butThenProxy should rewrite createWriteStream paths"],
-        //   [],
-        //   [
-        //     Then.theButTheProxyReturns(
-        //       "createWriteStream",
-        //       "test/path/butThen/stream.txt"
-        //     ),
-        //   ],
-        //   "createWriteStream test"
-        // ),
-        // screencastProxyTest: Given.SomeBaseString(
-        //   ["butThenProxy should rewrite screencast paths"],
-        //   [],
-        //   [
-        //     Then.theButTheProxyReturns(
-        //       "screencast",
-        //       "test/path/butThen/screen.png"
-        //     ),
-        //   ],
-        //   "screencast test"
-        // ),
-        // customScreenShotProxyTest: Given.SomeBaseString(
-        //   ["butThenProxy should rewrite customScreenShot paths"],
-        //   [],
-        //   [
-        //     Then.theButTheProxyReturns(
-        //       "customScreenShot",
-        //       "test/path/butThen/shot.png"
-        //     ),
-        //   ],
-        //   "customScreenShot test"
-        // ),
-        // // Edge cases
-        // emptyPathTest: Given.SomeBaseString(
-        //   ["butThenProxy should handle empty paths"],
-        //   [],
-        //   [Then.theButTheProxyReturns("writeFileSync", "test/path/butThen/")],
-        //   "empty path test"
-        // ),
-        // nestedPathTest: Given.SomeBaseString(
-        //   ["butThenProxy should handle nested paths"],
-        //   [],
-        //   [
-        //     Then.theButTheProxyReturns(
-        //       "writeFileSync",
-        //       "test/path/butThen/nested/folder/test.txt"
-        //     ),
-        //   ],
-        //   "nested path test"
-        // ),
-        // specialCharsTest: Given.SomeBaseString(
-        //   ["butThenProxy should handle special characters in paths"],
-        //   [],
-        //   [
-        //     Then.theButTheProxyReturns(
-        //       "writeFileSync",
-        //       "test/path/butThen/file with spaces.txt"
-        //     ),
-        //   ],
-        //   "special chars test"
-        // ),
-        // testsJsonTest: Given.SomeBaseString(
-        //   ["butThenProxy should handle tests.json correctly"],
-        //   [],
-        //   [
-        //     Then.theButTheProxyReturns(
-        //       "writeFileSync",
-        //       "test/path/butThen/tests.json"
-        //     ),
-        //   ],
-        //   "tests.json test"
-        // ),
-    }),
-    // Suite.Default("Proxy Type Coverage", {
-    //   // Test all proxy types
-    //   butThenProxyTest: Given.SomeBaseString(
-    //     ["butThenProxy should work correctly"],
-    //     [],
-    //     [
-    //       Then.theButTheProxyReturns(
-    //         "writeFileSync",
-    //         "test/path/butThen/test.txt"
-    //       ),
-    //     ],
-    //     "butThenProxy test"
-    //   ),
-    //   andWhenProxyTest: Given.SomeBaseString(
-    //     ["andWhenProxy should work correctly"],
-    //     [],
-    //     [
-    //       Then.theButTheProxyReturns(
-    //         "writeFileSync",
-    //         "test/path/andWhen/test.txt"
-    //       ),
-    //     ],
-    //     "andWhenProxy test"
-    //   ),
-    //   beforeEachProxyTest: Given.SomeBaseString(
-    //     ["beforeEachProxy should work correctly"],
-    //     [],
-    //     [
-    //       Then.theButTheProxyReturns(
-    //         "writeFileSync",
-    //         "suite-1/beforeEach/test.txt"
-    //       ),
-    //     ],
-    //     "beforeEachProxy test"
-    //   ),
-    //   afterEachProxyTest: Given.SomeBaseString(
-    //     ["afterEachProxy should work correctly"],
-    //     [],
-    //     [
-    //       Then.theButTheProxyReturns(
-    //         "writeFileSync",
-    //         "suite-1/given-1/afterEach/test.txt"
-    //       ),
-    //     ],
-    //     "afterEachProxy test"
-    //   ),
-    // }),
-    // Suite.Default("Content Preservation", {
-    //   // Verify content is preserved
-    //   contentPreservationTest: Given.SomeBaseString(
-    //     ["Proxies should preserve file content"],
-    //     [],
-    //     [
-    //       Then.theButTheProxyReturns(
-    //         "writeFileSync",
-    //         "test/path/butThen/test.txt"
-    //       ),
-    //       Then.verifyContent("test content"),
-    //     ],
-    //     "content preservation test"
-    //   ),
-    //   objectContentTest: Given.SomeBaseString(
-    //     ["Proxies should preserve object content"],
-    //     [],
-    //     [
-    //       Then.theButTheProxyReturns(
-    //         "screencast",
-    //         "test/path/butThen/screen.png"
-    //       ),
-    //       Then.verifyContent({ quality: 80, fullPage: true }),
-    //     ],
-    //     "object content test"
-    //   ),
-    // }),
-    // Suite.Default("Error Cases", {
-    //   invalidPathTest: Given.SomeBaseString(
-    //     ["Proxies should handle invalid paths"],
-    //     [],
-    //     [
-    //       Then.theButTheProxyReturns(
-    //         "writeFileSync",
-    //         "test/path/butThen/../invalid.txt"
-    //       ),
-    //     ],
-    //     "invalid path test"
-    //   ),
-    //   undefinedInputTest: Given.SomeBaseString(
-    //     ["Proxies should handle undefined inputs"],
-    //     [],
-    //     [Then.theButTheProxyReturns("writeFileSync", undefined)],
-    //     "undefined input test"
-    //   ),
-    // }),
-];

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

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

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

@@ -1,2 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-export {};

package/dist/module/src/mothership/index.js

@@ -1,16 +0,0 @@
-import express from "express";
-const app = express();
-app.get("/", (req, res) => {
-    res.send("Hello World!");
-});
-app.get("/claim", (req, res) => {
-    const { resource } = req.query;
-    console.log(`Resource claimed: ${resource}`);
-    res.status(200).json({ status: 'claimed', resource });
-});
-export default (port) => {
-    app.listen(port, () => {
-        console.log(`Example app listening on port ${port}`);
-    });
-    return app;
-};

package/dist/module/src/mothership/test.js

@@ -1,78 +0,0 @@
-import Testeranto from "../Node";
-import appFactory from "./index";
-const specification = (Suite, Given, When, Then) => {
-    console.log("Suite", Suite);
-    return [
-        Suite.TheMothership("the mothership allows the coordination of test resources", {
-            test0: Given.ItIsRunning([`a resource can be claimed`], [When.IClaimTheResource("test")], [Then.TheResourceIsClaimed("test")]),
-        }, []),
-    ];
-};
-const implementation = {
-    suites: { TheMothership: (x) => x },
-    givens: { ItIsRunning: () => undefined },
-    whens: {
-        IClaimTheResource: (resource) => async (app, tr, pm) => {
-            try {
-                const response = await fetch(`http://localhost:${tr.ports[0]}/claim?resource=${resource}`);
-                if (!response.ok) {
-                    const errorText = await response.text();
-                    console.error(`[ERROR] Failed to claim resource: ${errorText}`);
-                    throw new Error(`Failed to claim resource: ${errorText}`);
-                }
-                const result = await response.json();
-                return app;
-            }
-            catch (error) {
-                console.error("[ERROR] Resource claim failed:", error);
-                throw error;
-            }
-        },
-        IReleaseTheResource: function (resource) {
-            throw new Error("Function not implemented.");
-        },
-        IResetTheResource: function (Iw_0) {
-            throw new Error("Function not implemented.");
-        },
-    },
-    thens: {
-        TheResourceIsClaimed: (expectedResource) => async (app, pm) => {
-            // In a real implementation, we'd check the server state
-            // For now just log and return success
-            return app;
-        },
-        TheResourceIsUnClaimed: function (It_0) {
-            throw new Error("Function not implemented.");
-        },
-    },
-};
-const testAdapter = {
-    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
-        console.log("beforeEach - starting app on port", testResource.ports[0]);
-        return subject(testResource.ports[0]);
-    },
-    andWhen: async (store, whenCB, testResource, pm) => {
-        console.log("andWhen - executing action");
-        return whenCB(store, testResource, pm);
-    },
-    butThen: async (store, thenCB, testResource, pm) => {
-        console.log("butThen - making assertions");
-        return thenCB(store, pm);
-    },
-    afterEach: async (store, key, pm) => {
-        console.log("afterEach - cleaning up");
-        return store;
-    },
-    afterAll: async (store, pm) => {
-        console.log("afterAll - final cleanup");
-    },
-    beforeAll: async (input, testResource, pm) => {
-        console.log("beforeAll - initial setup");
-        return input;
-    },
-    assertThis: (x) => {
-        console.log("assertThis - validating result");
-        return x;
-    },
-};
-export default Testeranto(appFactory, specification, implementation, testAdapter);

package/dist/module/src/run.js

@@ -1,49 +0,0 @@
-"use strict";
-// import ansiC from "ansi-colors";
-// import readline from "readline";
-// import { PM_Main } from "./PM/main";
-// import { ITestconfig, IBuiltConfig, IProject } from "./Types";
-// readline.emitKeypressEvents(process.stdin);
-// if (process.stdin.isTTY) process.stdin.setRawMode(true);
-// console.log(ansiC.inverse("Press 'q' to initiate a graceful shutdown."));
-// console.log(ansiC.inverse("Press 'x' to quit forcefully."));
-// process.stdin.on("keypress", (str, key) => {
-//   if (key.name === "x") {
-//     console.log(ansiC.inverse("Shutting down forcefully..."));
-//     process.exit(-1);
-//   }
-// });
-// const projectName = process.argv[2];
-// const mode = process.argv[3] as "once" | "dev";
-// if (mode !== "once" && mode !== "dev") {
-//   console.error("the 2nd argument should be 'dev' or 'once' ");
-//   process.exit(-1);
-// }
-// const f = process.cwd() + "/" + "testeranto.config.ts";
-// console.log("config file:", f);
-// import(f).then(async (module) => {
-//   const bigConfig: IProject = module.default || module;
-//   const rawConfig: ITestconfig = bigConfig.projects[projectName];
-//   if (!rawConfig) {
-//     console.error(`Project "${projectName}" does not exist in the configuration.`);
-//     console.error("Available projects:", Object.keys(bigConfig.projects));
-//     process.exit(-1);
-//   }
-//   if (!rawConfig.tests) {
-//     console.error(projectName, "appears to have no tests: ", f);
-//     console.error(`here is the config:`);
-//     console.log(JSON.stringify(rawConfig));
-//     process.exit(-1);
-//   }
-//   const config: IBuiltConfig = {
-//     ...rawConfig,
-//     buildDir: process.cwd() + "/" + `testeranto/${projectName}.json`,
-//   };
-//   const pm = new PM_Main(config, projectName, mode);
-//   pm.start();
-//   process.stdin.on("keypress", (str, key) => {
-//     if (key.name === "q") {
-//       pm.stop();
-//     }
-//   });
-// });