testeranto 0.129.0 → 0.135.0

package/dist/common/src/PM/PM_WithEslintAndTsc.js

@@ -0,0 +1,189 @@
+"use strict";
+/* eslint-disable @typescript-eslint/ban-ts-comment */
+/* eslint-disable no-async-promise-executor */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM_WithEslintAndTsc = void 0;
+const typescript_1 = __importDefault(require("typescript"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const ansi_colors_1 = __importDefault(require("ansi-colors"));
+const eslint_1 = require("eslint");
+const tsc_prog_1 = __importDefault(require("tsc-prog"));
+const utils_1 = require("../utils");
+const base_js_1 = require("./base.js");
+const eslint = new eslint_1.ESLint();
+const formatter = await eslint.loadFormatter("./node_modules/testeranto/dist/prebuild/esbuildConfigs/eslint-formatter-testeranto.mjs");
+class PM_WithEslintAndTsc extends base_js_1.PM_Base {
+    constructor(configs, name, mode) {
+        super(configs);
+        this.summary = {};
+        this.tscCheck = async ({ entrypoint, addableFiles, platform, }) => {
+            console.log(ansi_colors_1.default.green(ansi_colors_1.default.inverse(`tsc < ${entrypoint}`)));
+            this.typeCheckIsRunning(entrypoint);
+            const program = tsc_prog_1.default.createProgramFromConfig({
+                basePath: process.cwd(), // always required, used for relative paths
+                configFilePath: "tsconfig.json", // config to inherit from (optional)
+                compilerOptions: {
+                    outDir: (0, utils_1.tscPather)(entrypoint, platform, this.name),
+                    // declaration: true,
+                    // skipLibCheck: true,
+                    noEmit: true,
+                },
+                include: addableFiles, //["src/**/*"],
+                // exclude: ["node_modules", "../testeranto"],
+                // exclude: ["**/*.test.ts", "**/*.spec.ts"],
+            });
+            const tscPath = (0, utils_1.tscPather)(entrypoint, platform, this.name);
+            const allDiagnostics = program.getSemanticDiagnostics();
+            const results = [];
+            allDiagnostics.forEach((diagnostic) => {
+                if (diagnostic.file) {
+                    const { line, character } = typescript_1.default.getLineAndCharacterOfPosition(diagnostic.file, diagnostic.start);
+                    const message = typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+                    results.push(`${diagnostic.file.fileName} (${line + 1},${character + 1}): ${message}`);
+                }
+                else {
+                    results.push(typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, "\n"));
+                }
+            });
+            fs_1.default.writeFileSync(tscPath, results.join("\n"));
+            this.typeCheckIsNowDone(entrypoint, results.length);
+        };
+        this.eslintCheck = async (entrypoint, platform, addableFiles) => {
+            console.log(ansi_colors_1.default.green(ansi_colors_1.default.inverse(`eslint < ${entrypoint}`)));
+            this.lintIsRunning(entrypoint);
+            const results = (await eslint.lintFiles(addableFiles))
+                .filter((r) => r.messages.length)
+                .filter((r) => {
+                return r.messages[0].ruleId !== null;
+            })
+                .map((r) => {
+                delete r.source;
+                return r;
+            });
+            fs_1.default.writeFileSync((0, utils_1.lintPather)(entrypoint, platform, this.name), await formatter.format(results));
+            this.lintIsNowDone(entrypoint, results.length);
+        };
+        this.makePrompt = async (entryPoint, addableFiles, platform) => {
+            this.summary[entryPoint].prompt = "?";
+            const promptPath = (0, utils_1.promptPather)(entryPoint, platform, this.name);
+            const testPaths = path_1.default.join("testeranto", "reports", this.name, entryPoint.split(".").slice(0, -1).join("."), platform, `tests.json`);
+            const featuresPath = path_1.default.join("testeranto", "reports", this.name, platform, entryPoint.split(".").slice(0, -1).join("."), `featurePrompt.txt`);
+            const logPath = path_1.default.join("testeranto", "reports", this.name, entryPoint.split(".").slice(0, -1).join("."), platform, `console_log.txt`);
+            const lintPath = path_1.default.join("testeranto", "reports", this.name, entryPoint.split(".").slice(0, -1).join("."), platform, `lint_errors.json`);
+            const typePath = path_1.default.join("testeranto", "reports", this.name, entryPoint.split(".").slice(0, -1).join("."), platform, `type_errors.txt`);
+            const messagePath = path_1.default.join("testeranto", "reports", this.name, entryPoint.split(".").slice(0, -1).join("."), platform, `message`);
+            fs_1.default.writeFileSync(promptPath, `
+${addableFiles
+                .map((x) => {
+                return `/add ${x}`;
+            })
+                .join("\n")}
+
+/read ${testPaths}
+/read ${logPath}
+/read ${typePath}
+/read ${lintPath}
+`);
+            fs_1.default.writeFileSync(messagePath, `Fix the failing tests described in ${testPaths} and ${logPath}. DO NOT refactor beyond what is necessary. Always prefer minimal changes, focusing mostly on keeping the BDD tests passing`);
+            this.summary[entryPoint].prompt = `aider --model deepseek/deepseek-chat --load testeranto/${this.name}/reports/${platform}/${entryPoint
+                .split(".")
+                .slice(0, -1)
+                .join(".")}/prompt.txt`;
+            this.checkForShutdown();
+        };
+        this.typeCheckIsRunning = (src) => {
+            this.summary[src].typeErrors = "?";
+        };
+        this.typeCheckIsNowDone = (src, failures) => {
+            this.summary[src].typeErrors = failures;
+            this.writeBigBoard();
+            this.checkForShutdown();
+        };
+        this.lintIsRunning = (src) => {
+            this.summary[src].staticErrors = "?";
+            this.writeBigBoard();
+        };
+        this.lintIsNowDone = (src, failures) => {
+            this.summary[src].staticErrors = failures;
+            this.writeBigBoard();
+            this.checkForShutdown();
+        };
+        this.bddTestIsRunning = (src) => {
+            this.summary[src].runTimeError = "?";
+            this.writeBigBoard();
+        };
+        this.bddTestIsNowDone = (src, failures) => {
+            this.summary[src].runTimeError = failures;
+            this.writeBigBoard();
+            this.checkForShutdown();
+        };
+        this.writeBigBoard = () => {
+            fs_1.default.writeFileSync(`./testeranto/reports/${this.name}/summary.json`, JSON.stringify(this.summary, null, 2));
+        };
+        this.checkForShutdown = () => {
+            console.log(ansi_colors_1.default.inverse(`checkForShutdown`));
+            this.writeBigBoard();
+            if (this.mode === "dev")
+                return;
+            let inflight = false;
+            Object.keys(this.summary).forEach((k) => {
+                if (this.summary[k].prompt === "?") {
+                    console.log(ansi_colors_1.default.blue(ansi_colors_1.default.inverse(`🕕 prompt ${k}`)));
+                    inflight = true;
+                }
+            });
+            Object.keys(this.summary).forEach((k) => {
+                if (this.summary[k].runTimeError === "?") {
+                    console.log(ansi_colors_1.default.blue(ansi_colors_1.default.inverse(`🕕 runTimeError ${k}`)));
+                    inflight = true;
+                }
+            });
+            Object.keys(this.summary).forEach((k) => {
+                if (this.summary[k].staticErrors === "?") {
+                    console.log(ansi_colors_1.default.blue(ansi_colors_1.default.inverse(`🕕 staticErrors ${k}`)));
+                    inflight = true;
+                }
+            });
+            Object.keys(this.summary).forEach((k) => {
+                if (this.summary[k].typeErrors === "?") {
+                    console.log(ansi_colors_1.default.blue(ansi_colors_1.default.inverse(`🕕 typeErrors ${k}`)));
+                    inflight = true;
+                }
+            });
+            this.writeBigBoard();
+            if (!inflight) {
+                this.browser.disconnect().then(() => {
+                    console.log(ansi_colors_1.default.inverse(`${this.name} has been tested. Goodbye.`));
+                    process.exit();
+                });
+            }
+        };
+        this.name = name;
+        this.mode = mode;
+        this.configs.tests.forEach(([t, rt, tr, sidecars]) => {
+            this.summary[t] = {
+                runTimeError: "?",
+                typeErrors: "?",
+                staticErrors: "?",
+                prompt: "?",
+                failingFeatures: {},
+            };
+            sidecars.forEach(([t]) => {
+                this.summary[t] = {
+                    // runTimeError: "?",
+                    typeErrors: "?",
+                    staticErrors: "?",
+                    // prompt: "?",
+                    // failingFeatures: {},
+                };
+            });
+        });
+    }
+}
+exports.PM_WithEslintAndTsc = PM_WithEslintAndTsc;

package/dist/common/src/PM/__tests__/nodeSidecar.testeranto.js

@@ -0,0 +1,109 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const nodeSidecar_1 = require("../nodeSidecar");
+const Node_1 = __importDefault(require("../../Node"));
+const specification = (Suite, Given, When, Then) => {
+    return [
+        Suite.SidecarInitialized("Sidecar message passing works correctly", {
+            basicSend: Given.SidecarReady(["can send and receive messages"], [When.SendTestMessage("test-message")], [Then.MessageReceived("test-message")]),
+            cleanup: Given.SidecarReady(["cleans up listeners after message"], [When.VerifyCleanup()], [Then.ListenersCleaned()]),
+        }, []),
+    ];
+};
+const implementation = {
+    suites: { SidecarInitialized: (x) => x },
+    givens: {
+        SidecarReady: () => {
+            const config = {
+                name: "test-sidecar",
+                fs: "/tmp",
+                ports: [3001],
+                browserWSEndpoint: "",
+            };
+            return new nodeSidecar_1.PM_Node_Sidecar(config);
+        },
+    },
+    whens: {
+        SendTestMessage: (message) => async (sidecar) => {
+            let callbackFn;
+            const mockProcess = {
+                on: (event, callback) => {
+                    if (event === "message") {
+                        callbackFn = callback;
+                        callback(JSON.stringify({
+                            key: "mock-key",
+                            payload: message,
+                        }));
+                    }
+                    return mockProcess;
+                },
+                addListener: () => mockProcess,
+                removeListener: () => mockProcess
+            };
+            process = mockProcess;
+            let writeCalled = false;
+            sidecar.client.write = (data) => {
+                writeCalled = true;
+                return true;
+            };
+            await sidecar.send("test-command", message);
+            return { writeCalled, callbackFn };
+        },
+        VerifyCleanup: () => async (sidecar) => {
+            let addListenerCalled = false;
+            let removeListenerCalled = false;
+            const mockProcess = {
+                addListener: () => {
+                    addListenerCalled = true;
+                    return mockProcess;
+                },
+                removeListener: () => {
+                    removeListenerCalled = true;
+                    return mockProcess;
+                }
+            };
+            process = mockProcess;
+            await sidecar.send("test-command", "test");
+            return { addListenerCalled, removeListenerCalled };
+        },
+    },
+    thens: {
+        MessageReceived: (expected) => (actual) => {
+            if (actual !== expected) {
+                throw new Error(`Expected "${expected}" but got "${actual}"`);
+            }
+            return actual;
+        },
+        ListenersCleaned: () => (result, { removeListenerCalled }) => {
+            if (!removeListenerCalled) {
+                throw new Error("Expected removeListener to be called");
+            }
+            return result;
+        },
+    },
+    checks: { SidecarState: () => "unknown" },
+};
+const testInterface = {
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        const sidecar = initializer();
+        sidecar.client = {
+            write: () => true,
+            end: () => { },
+            on: () => { },
+        };
+        return sidecar;
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        try {
+            await whenCB(store, testResource, pm);
+        }
+        catch (e) {
+            console.error("Error in andWhen:", e);
+            throw e;
+        }
+    },
+};
+exports.default = (0, Node_1.default)(() => new nodeSidecar_1.PM_Node_Sidecar({}), specification, implementation, testInterface);

package/dist/common/src/PM/__tests__/pureSidecar.testeranto.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const pureSidecar_1 = require("../pureSidecar");
+const Node_1 = __importDefault(require("../../Node"));
+const specification = (Suite, Given, When, Then) => {
+    return [
+        Suite.SidecarInitialized("Pure Sidecar message passing works correctly", {
+            basicSend: Given.SidecarReady(["can send and receive messages"], [When.SendTestMessage("test-message")], [Then.MessageReceived("test-message")]),
+            cleanup: Given.SidecarReady(["cleans up listeners after message"], [When.VerifyCleanup()], [Then.ListenersCleaned()]),
+        }, []),
+    ];
+};
+const implementation = {
+    suites: { SidecarInitialized: (x) => x },
+    givens: {
+        SidecarReady: () => {
+            const config = {
+                name: "test-pure-sidecar",
+                fs: "/tmp",
+                ports: [3001],
+                browserWSEndpoint: "",
+            };
+            return new pureSidecar_1.PM_Pure_Sidecar(config);
+        },
+    },
+    whens: {
+        SendTestMessage: (message) => async (sidecar) => {
+            let callbackFn;
+            process.on = (event, callback) => {
+                if (event === "message") {
+                    callbackFn = callback;
+                    callback(JSON.stringify({
+                        key: "mock-key",
+                        payload: message,
+                    }));
+                }
+            };
+            let writeCalled = false;
+            sidecar.client.write = (data) => {
+                writeCalled = true;
+                return true;
+            };
+            await sidecar.send("test-command", message);
+            return { writeCalled, callbackFn };
+        },
+        VerifyCleanup: () => async (sidecar) => {
+            let addListenerCalled = false;
+            let removeListenerCalled = false;
+            process.addListener = () => (addListenerCalled = true);
+            process.removeListener = () => (removeListenerCalled = true);
+            await sidecar.send("test-command", "test");
+            return { addListenerCalled, removeListenerCalled };
+        },
+    },
+    thens: {
+        MessageReceived: (expected) => (actual) => {
+            if (actual !== expected) {
+                throw new Error(`Expected "${expected}" but got "${actual}"`);
+            }
+            return actual;
+        },
+        ListenersCleaned: () => (result, { removeListenerCalled }) => {
+            if (!removeListenerCalled) {
+                throw new Error("Expected removeListener to be called");
+            }
+            return result;
+        },
+    },
+    checks: { SidecarState: () => "unknown" },
+};
+const testInterface = {
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        const sidecar = initializer();
+        sidecar.client = {
+            write: () => true,
+            end: () => { },
+            on: () => { },
+        };
+        return sidecar;
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        try {
+            await whenCB(store, testResource, pm);
+        }
+        catch (e) {
+            console.error("Error in andWhen:", e);
+            throw e;
+        }
+    },
+};
+exports.default = (0, Node_1.default)(() => new pureSidecar_1.PM_Pure_Sidecar({}), specification, implementation, testInterface);

package/dist/common/src/PM/__tests__/webSidecar.testeranto.js

@@ -0,0 +1,94 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const webSidecar_1 = require("../webSidecar");
+const Node_1 = __importDefault(require("../../Node"));
+const specification = (Suite, Given, When, Then) => {
+    return [
+        Suite.SidecarInitialized("Web Sidecar message passing works correctly", {
+            basicSend: Given.SidecarReady(["can send and receive messages"], [When.SendTestMessage("test-message")], [Then.MessageReceived("test-message")]),
+            cleanup: Given.SidecarReady(["cleans up listeners after message"], [When.VerifyCleanup()], [Then.ListenersCleaned()]),
+        }, []),
+    ];
+};
+const implementation = {
+    suites: { SidecarInitialized: (x) => x },
+    givens: {
+        SidecarReady: () => {
+            const config = {
+                name: "test-web-sidecar",
+                fs: "/tmp",
+                ports: [3001],
+                browserWSEndpoint: "",
+            };
+            return new webSidecar_1.PM_Web_Sidecar(config);
+        },
+    },
+    whens: {
+        SendTestMessage: (message) => async (sidecar) => {
+            let callbackFn;
+            process.on = (event, callback) => {
+                if (event === "message") {
+                    callbackFn = callback;
+                    callback(JSON.stringify({
+                        key: "mock-key",
+                        payload: message,
+                    }));
+                }
+            };
+            let writeCalled = false;
+            sidecar.client.write = (data) => {
+                writeCalled = true;
+                return true;
+            };
+            await sidecar.send("test-command", message);
+            return { writeCalled, callbackFn };
+        },
+        VerifyCleanup: () => async (sidecar) => {
+            let addListenerCalled = false;
+            let removeListenerCalled = false;
+            process.addListener = () => (addListenerCalled = true);
+            process.removeListener = () => (removeListenerCalled = true);
+            await sidecar.send("test-command", "test");
+            return { addListenerCalled, removeListenerCalled };
+        },
+    },
+    thens: {
+        MessageReceived: (expected) => (actual) => {
+            if (actual !== expected) {
+                throw new Error(`Expected "${expected}" but got "${actual}"`);
+            }
+            return actual;
+        },
+        ListenersCleaned: () => (result, { removeListenerCalled }) => {
+            if (!removeListenerCalled) {
+                throw new Error("Expected removeListener to be called");
+            }
+            return result;
+        },
+    },
+    checks: { SidecarState: () => "unknown" },
+};
+const testInterface = {
+    beforeEach: async (subject, initializer, testResource, initialValues, pm) => {
+        const sidecar = initializer();
+        sidecar.client = {
+            write: () => true,
+            end: () => { },
+            on: () => { },
+        };
+        return sidecar;
+    },
+    andWhen: async (store, whenCB, testResource, pm) => {
+        try {
+            await whenCB(store, testResource, pm);
+        }
+        catch (e) {
+            console.error("Error in andWhen:", e);
+            throw e;
+        }
+    },
+};
+exports.default = (0, Node_1.default)(() => new webSidecar_1.PM_Web_Sidecar({}), specification, implementation, testInterface);

package/dist/common/src/PM/base.js

@@ -4,6 +4,8 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PM_Base = void 0;
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
 const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const fileStreams3 = [];
@@ -16,7 +18,7 @@ class PM_Base {
         this.configs = configs;
     }
     customclose() {
-        throw new Error("Method not implemented.");
+        throw new Error("customclose not implemented.");
     }
     waitForSelector(p, s) {
         return new Promise((res) => {
@@ -38,8 +40,8 @@ class PM_Base {
             });
         });
     }
-    newPage() {
-        return this.browser.newPage();
+    async newPage() {
+        return (await this.browser.newPage()).mainFrame()._id;
     }
     goto(p, url) {
         return new Promise((res) => {
@@ -53,9 +55,9 @@ class PM_Base {
     $(selector, p) {
         return new Promise((res) => {
             this.doInPage(p, async (page) => {
-                const x = page.$(selector);
-                const y = await x;
-                res(y !== null);
+                const x = await page.$(selector);
+                const y = await (x === null || x === void 0 ? void 0 : x.jsonValue());
+                res(y);
             });
         });
     }
@@ -82,7 +84,7 @@ class PM_Base {
         await sPromise;
         return sPromise;
     }
-    async customScreenShot(ssOpts, testName, page) {
+    async customScreenShot(ssOpts, testName, pageUid) {
         const p = ssOpts.path;
         const dir = path_1.default.dirname(p);
         fs_1.default.mkdirSync(dir, {
@@ -92,6 +94,7 @@ class PM_Base {
             files[testName] = new Set();
         }
         files[testName].add(ssOpts.path);
+        const page = (await this.browser.pages()).find((p) => p.mainFrame()._id === pageUid);
         const sPromise = page.screenshot(Object.assign(Object.assign({}, ssOpts), { path: p }));
         if (!screenshots[testName]) {
             screenshots[testName] = [];
@@ -170,7 +173,6 @@ class PM_Base {
                         res();
                     }
                     else {
-                        /* @ts-ignore:next-line */
                         const pipeStream = value;
                         const myFile = fs_1.default.createWriteStream(fPath);
                         pipeStream.pipe(myFile);
@@ -189,8 +191,8 @@ class PM_Base {
             res(x);
         });
     }
-    page() {
-        throw new Error("Method not implemented.");
+    page(p) {
+        return p;
     }
     click(selector, page) {
         return page.click(selector);
@@ -205,14 +207,28 @@ class PM_Base {
             return page.keyboard.type(value);
         });
     }
-    getValue(value, p) {
+    // setValue(value: string, p: string) {
+    //   this.doInPage(p, (page) => {
+    //     return page.keyboard.type(value);
+    //   });
+    // }
+    getAttribute(selector, attribute, p) {
         this.doInPage(p, (page) => {
-            return page.keyboard.type(value);
+            return page.$eval(selector, (input) => input.getAttribute(attribute));
         });
     }
-    getAttribute(selector, attribute, p) {
-        this.doInPage(p, (page) => {
-            return page.$eval(selector, (input) => input.getAttribute("value"));
+    async getInnerHtml(selector, p) {
+        return new Promise((res, rej) => {
+            this.doInPage(p, async (page) => {
+                const e = await page.$(selector);
+                if (!e) {
+                    rej();
+                }
+                else {
+                    const text = await (await e.getProperty("textContent")).jsonValue();
+                    res(text);
+                }
+            });
         });
     }
     isDisabled(selector, p) {
@@ -227,7 +243,8 @@ class PM_Base {
     }
     async doInPage(p, cb) {
         (await this.browser.pages()).forEach((page) => {
-            if (page.mainFrame()._id === p) {
+            const frame = page.mainFrame();
+            if (frame._id === p) {
                 return cb(page);
             }
         });