testeranto 0.203.0 → 0.205.0

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

@@ -0,0 +1,179 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM_Node = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable prefer-rest-params */
+const net_1 = __importDefault(require("net"));
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const _1 = require(".");
+const fPaths = [];
+class PM_Node extends _1.PM {
+    constructor(t, ipcFile) {
+        super();
+        this.testResourceConfiguration = t;
+        this.client = net_1.default.createConnection(ipcFile, () => {
+            return;
+        });
+    }
+    start() {
+        throw new Error("DEPRECATED");
+    }
+    stop() {
+        throw new Error("stop not implemented.");
+    }
+    send(command, ...argz) {
+        const key = Math.random().toString();
+        if (!this.client) {
+            console.error(`Tried to send "${command} (${argz})" but the test has not been started and the IPC client is not established. Exiting as failure!`);
+            process.exit(-1);
+        }
+        return new Promise((res) => {
+            const myListener = (event) => {
+                const x = JSON.parse(event);
+                if (x.key === key) {
+                    process.removeListener("message", myListener);
+                    res(x.payload);
+                }
+            };
+            process.addListener("message", myListener);
+            this.client.write(JSON.stringify([command, ...argz, key]));
+        });
+    }
+    async pages() {
+        return this.send("pages", ...arguments);
+    }
+    waitForSelector(p, s) {
+        return this.send("waitForSelector", ...arguments);
+    }
+    closePage(p) {
+        return this.send("closePage", ...arguments);
+        // return globalThis["closePage"](p);
+    }
+    goto(page, url) {
+        return this.send("goto", ...arguments);
+        // return globalThis["goto"](cdpPage.mainFrame()._id, url);
+    }
+    async newPage() {
+        return this.send("newPage");
+    }
+    $(selector, page) {
+        return this.send("$", ...arguments);
+    }
+    isDisabled(selector) {
+        return this.send("isDisabled", ...arguments);
+    }
+    getAttribute(selector, attribute, p) {
+        return this.send("getAttribute", ...arguments);
+    }
+    getInnerHtml(selector, p) {
+        return this.send("getInnerHtml", ...arguments);
+    }
+    // setValue(selector: string) {
+    //   return this.send("getValue", ...arguments);
+    // }
+    focusOn(selector) {
+        return this.send("focusOn", ...arguments);
+    }
+    typeInto(selector) {
+        return this.send("typeInto", ...arguments);
+    }
+    page() {
+        return this.send("page");
+    }
+    click(selector) {
+        return this.send("click", ...arguments);
+    }
+    screencast(opts, page) {
+        return this.send("screencast", Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page, this.testResourceConfiguration.name);
+    }
+    screencastStop(p) {
+        return this.send("screencastStop", ...arguments);
+    }
+    customScreenShot(x, y) {
+        const opts = x[0];
+        const page = x[1];
+        return this.send("customScreenShot", Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), this.testResourceConfiguration.name, page);
+    }
+    async existsSync(destFolder) {
+        return await this.send("existsSync", this.testResourceConfiguration.fs + "/" + destFolder);
+    }
+    mkdirSync() {
+        return this.send("mkdirSync", this.testResourceConfiguration.fs + "/");
+    }
+    async write(uid, contents) {
+        return await this.send("write", ...arguments);
+    }
+    async writeFileSync(x) {
+        const z = arguments["0"];
+        // const filepath = z[0];
+        // const contents = z[1];
+        const filepath = arguments[0];
+        const contents = arguments[1];
+        return await this.send("writeFileSync", this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
+    }
+    async createWriteStream(filepath) {
+        return await this.send("createWriteStream", this.testResourceConfiguration.fs + "/" + filepath, this.testResourceConfiguration.name);
+    }
+    async end(uid) {
+        return await this.send("end", ...arguments);
+    }
+    async customclose() {
+        return await this.send("customclose", this.testResourceConfiguration.fs, this.testResourceConfiguration.name);
+    }
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            callback(new Promise((res, rej) => {
+                tLog("testArtiFactory =>", fPath);
+                const cleanPath = path_1.default.resolve(fPath);
+                fPaths.push(cleanPath.replace(process.cwd(), ``));
+                const targetDir = cleanPath.split("/").slice(0, -1).join("/");
+                fs_1.default.mkdir(targetDir, { recursive: true }, async (error) => {
+                    if (error) {
+                        console.error(`❗️testArtiFactory failed`, targetDir, error);
+                    }
+                    // fs.writeFileSync(
+                    //   path.resolve(
+                    //     targetDir.split("/").slice(0, -1).join("/"),
+                    //     "manifest"
+                    //   ),
+                    //   fPaths.join(`\n`),
+                    //   {
+                    //     encoding: "utf-8",
+                    //   }
+                    // );
+                    if (Buffer.isBuffer(value)) {
+                        fs_1.default.writeFileSync(fPath, value, "binary");
+                        res();
+                    }
+                    else if (`string` === typeof value) {
+                        fs_1.default.writeFileSync(fPath, value.toString(), {
+                            encoding: "utf-8",
+                        });
+                        res();
+                    }
+                    else {
+                        const pipeStream = value;
+                        const myFile = fs_1.default.createWriteStream(fPath);
+                        pipeStream.pipe(myFile);
+                        pipeStream.on("close", () => {
+                            myFile.close();
+                            res();
+                        });
+                    }
+                });
+            }));
+        };
+    }
+    // launch(options?: PuppeteerLaunchOptions): Promise<Browser>;
+    startPuppeteer(options) {
+        // return puppeteer.connect(options).then((b) => {
+        //   this.browser = b;
+        // });
+    }
+}
+exports.PM_Node = PM_Node;

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

@@ -0,0 +1,65 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM_Node_Sidecar = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable prefer-rest-params */
+const net_1 = __importDefault(require("net"));
+const sidecar_1 = require("./sidecar");
+const fPaths = [];
+class PM_Node_Sidecar extends sidecar_1.PM_sidecar {
+    constructor(t) {
+        super();
+        this.testResourceConfiguration = t;
+        this.client = {};
+    }
+    start(stopper) {
+        return new Promise((res) => {
+            process.on("message", async (message) => {
+                if (message === "stop") {
+                    await stopper();
+                    process.exit();
+                }
+                else if (message.path) {
+                    this.client = net_1.default.createConnection(message.path, () => {
+                        res();
+                    });
+                }
+            });
+        });
+    }
+    stop() {
+        return new Promise((resolve) => {
+            if (this.client) {
+                this.client.end(() => resolve());
+            }
+            else {
+                resolve();
+            }
+        });
+    }
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            tLog(`Pure runtime skipping file write to ${fPath}`);
+            callback(Promise.resolve());
+        };
+    }
+    send(command, ...argz) {
+        return new Promise((res) => {
+            const key = Math.random().toString();
+            const myListener = (event) => {
+                const x = JSON.parse(event);
+                if (x.key === key) {
+                    process.removeListener("message", myListener);
+                    res(x.payload);
+                }
+            };
+            process.addListener("message", myListener);
+            this.client.write(JSON.stringify([command, ...argz, key]));
+        });
+    }
+}
+exports.PM_Node_Sidecar = PM_Node_Sidecar;

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

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PitonoBuild = void 0;
+const pitonoMetafile_1 = require("../utils/pitonoMetafile");
+const pitonoWatcher_1 = require("../utils/pitonoWatcher");
+class PitonoBuild {
+    constructor(config, testName) {
+        this.watcher = null;
+        this.config = config;
+        this.testName = testName;
+    }
+    async build() {
+        // Filter python tests
+        const pythonTests = this.config.tests.filter((test) => test[1] === "python");
+        const hasPythonTests = pythonTests.length > 0;
+        if (hasPythonTests) {
+            // Get the entry points
+            const pythonEntryPoints = pythonTests.map((test) => test[0]);
+            // Generate and write metafile
+            const metafile = await (0, pitonoMetafile_1.generatePitonoMetafile)(this.testName, pythonEntryPoints);
+            (0, pitonoMetafile_1.writePitonoMetafile)(this.testName, metafile);
+            // Start watching for changes
+            this.watcher = new pitonoWatcher_1.PitonoWatcher(this.testName, pythonEntryPoints);
+            await this.watcher.start();
+            return pythonEntryPoints;
+        }
+        return [];
+    }
+    async rebuild() {
+        if (this.watcher) {
+            await this.watcher.regenerateMetafile();
+        }
+    }
+    stop() {
+        if (this.watcher) {
+            this.watcher.stop();
+            this.watcher = null;
+        }
+    }
+    onBundleChange(callback) {
+        if (this.watcher) {
+            this.watcher.onMetafileChange(callback);
+        }
+    }
+}
+exports.PitonoBuild = PitonoBuild;

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

@@ -0,0 +1,54 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PitonoRunner = void 0;
+const child_process_1 = require("child_process");
+const path_1 = __importDefault(require("path"));
+const fs_1 = __importDefault(require("fs"));
+class PitonoRunner {
+    constructor(config, testName) {
+        this.config = config;
+        this.testName = testName;
+    }
+    async run() {
+        const coreJsonPath = path_1.default.join(process.cwd(), 'testeranto', 'pitono', this.testName, 'core.json');
+        // Wait for the core.json file to be created with a timeout
+        const maxWaitTime = 10000; // 10 seconds
+        const startTime = Date.now();
+        while (!fs_1.default.existsSync(coreJsonPath) && (Date.now() - startTime) < maxWaitTime) {
+            await new Promise(resolve => setTimeout(resolve, 100));
+        }
+        if (!fs_1.default.existsSync(coreJsonPath)) {
+            console.error(`Pitono core.json not found at: ${coreJsonPath} after waiting ${maxWaitTime}ms`);
+            return;
+        }
+        try {
+            const coreData = JSON.parse(fs_1.default.readFileSync(coreJsonPath, 'utf-8'));
+            const entryPoints = coreData.entryPoints;
+            for (const entryPoint of entryPoints) {
+                try {
+                    console.log(`Running pitono test: ${entryPoint}`);
+                    // Use python to execute the test file
+                    const absolutePath = path_1.default.resolve(entryPoint);
+                    // Check if the file exists
+                    if (!fs_1.default.existsSync(absolutePath)) {
+                        console.error(`Pitono test file not found: ${absolutePath}`);
+                        continue;
+                    }
+                    (0, child_process_1.execSync)(`python "${absolutePath}"`, { stdio: 'inherit' });
+                    console.log(`Pitono test completed: ${entryPoint}`);
+                }
+                catch (error) {
+                    console.error(`Pitono test failed: ${entryPoint}`, error);
+                    throw error;
+                }
+            }
+        }
+        catch (error) {
+            console.error(`Error reading or parsing core.json: ${error}`);
+        }
+    }
+}
+exports.PitonoRunner = PitonoRunner;

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

@@ -0,0 +1,103 @@
+"use strict";
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM_Pure = void 0;
+const _1 = require(".");
+const fPaths = [];
+class PM_Pure extends _1.PM {
+    getInnerHtml(selector, page) {
+        throw new Error("pure.ts getInnerHtml not implemented");
+    }
+    constructor(t) {
+        super();
+        this.server = {};
+        this.testResourceConfiguration = t;
+    }
+    trackCall(method, args) {
+        // Track calls if needed
+    }
+    start() {
+        return new Promise((r) => r());
+    }
+    stop() {
+        return new Promise((r) => r());
+    }
+    async createWriteStream(filepath, testName) {
+        throw new Error("pure.ts createWriteStream not implemented");
+    }
+    pages() {
+        return globalThis["pages"]();
+    }
+    waitForSelector(p, s) {
+        return globalThis["waitForSelector"](p, s);
+    }
+    closePage(p) {
+        return globalThis["closePage"](p);
+    }
+    goto(cdpPage, url) {
+        return globalThis["goto"](cdpPage.mainFrame()._id, url);
+    }
+    newPage() {
+        return globalThis["newPage"]();
+    }
+    $(selector) {
+        return globalThis["$"](selector);
+    }
+    isDisabled(selector) {
+        return globalThis["isDisabled"](selector);
+    }
+    getAttribute(selector, attribute) {
+        return globalThis["getAttribute"](selector, attribute);
+    }
+    getValue(selector) {
+        return globalThis["getValue"](selector);
+    }
+    focusOn(selector) {
+        return globalThis["focusOn"](selector);
+    }
+    typeInto(selector, value) {
+        return globalThis["typeInto"](selector, value);
+    }
+    page() {
+        return globalThis["page"]();
+    }
+    click(selector) {
+        return globalThis["click"](selector);
+    }
+    screencast(opts, page) {
+        return globalThis["screencast"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page, this.testResourceConfiguration.name);
+    }
+    screencastStop(p) {
+        return globalThis["screencastStop"](p);
+    }
+    customScreenShot(opts, page) {
+        return globalThis["customScreenShot"](Object.assign(Object.assign({}, opts), { path: this.testResourceConfiguration.fs + "/" + opts.path }), page, this.testResourceConfiguration.name);
+    }
+    // TODO: fix these
+    existsSync(destFolder) {
+        return Promise.resolve(true);
+    }
+    mkdirSync() {
+        return true;
+    }
+    write(uid, contents) {
+        return Promise.resolve(true);
+    }
+    writeFileSync() {
+        return Promise.resolve(true);
+    }
+    end(uid) {
+        return globalThis["end"](uid);
+    }
+    customclose() {
+        globalThis["customclose"](this.testResourceConfiguration.fs, this.testResourceConfiguration.name);
+    }
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            this.trackCall("testArtiFactoryfileWriter", { fPath, value });
+            callback(Promise.resolve());
+        };
+    }
+}
+exports.PM_Pure = PM_Pure;

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

@@ -0,0 +1,48 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM_Pure_Sidecar = void 0;
+/* eslint-disable @typescript-eslint/no-explicit-any */
+/* eslint-disable @typescript-eslint/no-unused-vars */
+/* eslint-disable prefer-rest-params */
+const net_1 = __importDefault(require("net"));
+const sidecar_1 = require("./sidecar");
+const fPaths = [];
+class PM_Pure_Sidecar extends sidecar_1.PM_sidecar {
+    constructor(t) {
+        super();
+        this.testResourceConfiguration = t;
+    }
+    start() {
+        return new Promise((res) => {
+            process.on("message", (message) => {
+                if (message.path) {
+                    this.client = net_1.default.createConnection(message.path, () => {
+                        // No stdout/stderr logging for pure sidecars
+                        res();
+                    });
+                }
+            });
+        });
+    }
+    stop() {
+        throw new Error("stop not implemented.");
+    }
+    send(command, ...argz) {
+        return new Promise((res) => {
+            const key = Math.random().toString();
+            const myListener = (event) => {
+                const x = JSON.parse(event);
+                if (x.key === key) {
+                    process.removeListener("message", myListener);
+                    res(x.payload);
+                }
+            };
+            process.addListener("message", myListener);
+            this.client.write(JSON.stringify([command, ...argz, key]));
+        });
+    }
+}
+exports.PM_Pure_Sidecar = PM_Pure_Sidecar;

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

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM_sidecar = void 0;
+class PM_sidecar {
+    testArtiFactoryfileWriter(tLog, callback) {
+        return (fPath, value) => {
+            callback(Promise.resolve());
+        };
+    }
+}
+exports.PM_sidecar = PM_sidecar;

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

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });