testeranto 0.128.0 → 0.134.0

package/dist/common/src/Init.js

@@ -3,6 +3,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+/* eslint-disable @typescript-eslint/no-unused-vars */
 const fs_1 = __importDefault(require("fs"));
 exports.default = async () => {
     [
@@ -14,6 +15,7 @@ exports.default = async () => {
         `testeranto/reports`,
         `testeranto/reports/`,
         `testeranto/features/`,
+        `testeranto/externalTests/`,
     ].forEach((f) => {
         try {
             fs_1.default.mkdirSync(`${process.cwd()}/${f}`);
@@ -25,7 +27,10 @@ exports.default = async () => {
     fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/Project.js`, `testeranto/Project.js`);
     fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/ReportClient.js`, `testeranto/ReportClient.js`);
     fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/Project.css`, `testeranto/Project.css`);
-    fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/ReportClient.css`, `testeranto/ReportClient.css`);
+    // fs.copyFileSync(
+    //   `node_modules/testeranto/dist/prebuild/ReportClient.css`,
+    //   `testeranto/ReportClient.css`
+    // );
     fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/TestReport.js`, `testeranto/TestReport.js`);
     fs_1.default.copyFileSync(`node_modules/testeranto/dist/prebuild/TestReport.css`, `testeranto/TestReport.css`);
 };

package/dist/common/src/Node.js

@@ -7,6 +7,7 @@ exports.NodeTesteranto = void 0;
 const core_js_1 = __importDefault(require("./lib/core.js"));
 const index_js_1 = require("./lib/index.js");
 const node_js_1 = require("./PM/node.js");
+let ipcfile;
 class NodeTesteranto extends core_js_1.default {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
         super(input, testSpecification, testImplementation, testResourceRequirement, testInterface, () => {
@@ -15,7 +16,7 @@ class NodeTesteranto extends core_js_1.default {
     }
     async receiveTestResourceConfig(partialTestResource) {
         const t = JSON.parse(partialTestResource);
-        const pm = new node_js_1.PM_Node(t);
+        const pm = new node_js_1.PM_Node(t, ipcfile);
         return await this.testJobs[0].receiveTestResourceConfig(pm);
         // const { failed, artifacts, logPromise, features } =
         //   await this.testJobs[0].receiveTestResourceConfig(pm);
@@ -29,15 +30,16 @@ const testeranto = async (input, testSpecification, testImplementation, testInte
     process.on("unhandledRejection", (reason, promise) => {
         console.error("Unhandled Rejection at:", promise, "reason:", reason);
         // Optionally, terminate the process or perform cleanup
+        // t.registerUncaughtPromise(reason, promise);
     });
     try {
-        console.log(process.argv);
+        ipcfile = process.argv[3];
         const f = await t.receiveTestResourceConfig(process.argv[2]);
-        console.error("goodbye node error", f.fails);
+        console.error("goodbye node with failures", f.fails);
         process.exit(f.fails);
     }
     catch (e) {
-        console.error("goodbye node error", e);
+        console.error("goodbye node with caught error", e);
         process.exit(-1);
         // fs.writeFileSync(`tests.json`, JSON.stringify(t.,
         //  null, 2));

package/dist/common/src/NodeSidecar.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NodeSidecar = void 0;
+const Sidecar_1 = require("./lib/Sidecar");
+const nodeSidecar_1 = require("./PM/nodeSidecar");
+class NodeSidecar extends Sidecar_1.Sidecar {
+    constructor(t) {
+        super();
+        this.pm = new nodeSidecar_1.PM_Node_Sidecar(t);
+        this.pm.start(this.stop).then(() => {
+            this.start(JSON.parse(process.argv[2]));
+        });
+    }
+}
+exports.NodeSidecar = NodeSidecar;

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

@@ -0,0 +1,187 @@
+"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, platform, entryPoint.split(".").slice(0, -1).join("."), `tests.json`);
+            const featuresPath = path_1.default.join("testeranto", "reports", this.name, platform, entryPoint.split(".").slice(0, -1).join("."), `featurePrompt.txt`);
+            fs_1.default.writeFileSync(promptPath, `
+${addableFiles
+                .map((x) => {
+                return `/add ${x}`;
+            })
+                .join("\n")}
+
+/read ${(0, utils_1.lintPather)(entryPoint, platform, this.name)}
+/read ${(0, utils_1.tscPather)(entryPoint, platform, this.name)}
+/read ${testPaths}
+
+/load ${featuresPath}
+
+/code Fix the failing tests described in ${testPaths}. Correct any type signature errors described in the files ${(0, utils_1.tscPather)(entryPoint, platform, this.name)}. Implement any method which throws "Function not implemented. Resolve the lint errors described in ${(0, utils_1.lintPather)(entryPoint, platform, this.name)}"
+          `);
+            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);