testeranto 0.202.0 → 0.203.0

package/dist/module/src/PM/metafileOutputs.js

@@ -1,78 +0,0 @@
-"use strict";
-// import { IRunTime } from "../Types";
-// import { IOutputs, filesHash } from "./utils";
-// import ansiC from "ansi-colors";
-// import fs from "fs";
-// export const metafileOutputs = async (platform: IRunTime) => {
-//   let metafilePath: string;
-//   if (platform === "python") {
-//     metafilePath = `./testeranto/metafiles/python/core.json`;
-//   } else {
-//     metafilePath = `./testeranto/metafiles/${platform}/${this.name}.json`;
-//   }
-//   // Check if the file exists
-//   if (!fs.existsSync(metafilePath)) {
-//     if (platform === "python") {
-//       console.log(
-//         ansiC.yellow(
-//           ansiC.inverse(`Pitono metafile not found yet: ${metafilePath}`)
-//         )
-//       );
-//     }
-//     return;
-//   }
-//   let metafile;
-//   try {
-//     const fileContent = fs.readFileSync(metafilePath).toString();
-//     const parsedData = JSON.parse(fileContent);
-//     // Handle different metafile structures
-//     if (platform === "python") {
-//       // Pitono metafile might be the entire content or have a different structure
-//       metafile = parsedData.metafile || parsedData;
-//     } else {
-//       metafile = parsedData.metafile;
-//     }
-//     if (!metafile) {
-//       console.log(
-//         ansiC.yellow(ansiC.inverse(`No metafile found in ${metafilePath}`))
-//       );
-//       return;
-//     }
-//   } catch (error) {
-//     console.error(`Error reading metafile at ${metafilePath}:`, error);
-//     return;
-//   }
-//   const outputs: IOutputs = metafile.outputs;
-//   Object.keys(outputs).forEach(async (k) => {
-//     const pattern = `testeranto/bundles/${platform}/${this.name}/${this.configs.src}`;
-//     if (!k.startsWith(pattern)) {
-//       return false;
-//     }
-//     const addableFiles = Object.keys(outputs[k].inputs).filter((i) => {
-//       if (!fs.existsSync(i)) return false;
-//       if (i.startsWith("node_modules")) return false;
-//       if (i.startsWith("./node_modules")) return false;
-//       return true;
-//     });
-//     const f = `${k.split(".").slice(0, -1).join(".")}/`;
-//     if (!fs.existsSync(f)) {
-//       fs.mkdirSync(f);
-//     }
-//     const entrypoint = outputs[k].entryPoint;
-//     if (entrypoint) {
-//       const changeDigest = await filesHash(addableFiles);
-//       if (changeDigest === changes[entrypoint]) {
-//         // skip
-//       } else {
-//         changes[entrypoint] = changeDigest;
-//         this.tscCheck({
-//           platform,
-//           addableFiles,
-//           entrypoint: entrypoint,
-//         });
-//         this.eslintCheck(entrypoint, platform, addableFiles);
-//         this.makePrompt(entrypoint, addableFiles, platform);
-//       }
-//     }
-//   });
-// };

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

@@ -1,172 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable prefer-rest-params */
-import net from "net";
-import fs from "fs";
-import path from "path";
-import { PM } from ".";
-const fPaths = [];
-export class PM_Node extends PM {
-    constructor(t, ipcFile) {
-        super();
-        this.testResourceConfiguration = t;
-        this.client = net.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.resolve(fPath);
-                fPaths.push(cleanPath.replace(process.cwd(), ``));
-                const targetDir = cleanPath.split("/").slice(0, -1).join("/");
-                fs.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.writeFileSync(fPath, value, "binary");
-                        res();
-                    }
-                    else if (`string` === typeof value) {
-                        fs.writeFileSync(fPath, value.toString(), {
-                            encoding: "utf-8",
-                        });
-                        res();
-                    }
-                    else {
-                        const pipeStream = value;
-                        const myFile = fs.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;
-        // });
-    }
-}

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

@@ -1,58 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable prefer-rest-params */
-import net from "net";
-import { PM_sidecar } from "./sidecar";
-const fPaths = [];
-export class PM_Node_Sidecar extends 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.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]));
-        });
-    }
-}

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

@@ -1,47 +0,0 @@
-import { execSync } from 'child_process';
-import path from 'path';
-import fs from 'fs';
-export class PitonoRunner {
-    constructor(config, testName) {
-        this.config = config;
-        this.testName = testName;
-    }
-    async run() {
-        const coreJsonPath = path.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.existsSync(coreJsonPath) && (Date.now() - startTime) < maxWaitTime) {
-            await new Promise(resolve => setTimeout(resolve, 100));
-        }
-        if (!fs.existsSync(coreJsonPath)) {
-            console.error(`Pitono core.json not found at: ${coreJsonPath} after waiting ${maxWaitTime}ms`);
-            return;
-        }
-        try {
-            const coreData = JSON.parse(fs.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.resolve(entryPoint);
-                    // Check if the file exists
-                    if (!fs.existsSync(absolutePath)) {
-                        console.error(`Pitono test file not found: ${absolutePath}`);
-                        continue;
-                    }
-                    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}`);
-        }
-    }
-}

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

@@ -1,99 +0,0 @@
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable @typescript-eslint/no-explicit-any */
-import { PM } from ".";
-const fPaths = [];
-export class PM_Pure extends 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());
-        };
-    }
-}

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

@@ -1,41 +0,0 @@
-/* eslint-disable @typescript-eslint/no-explicit-any */
-/* eslint-disable @typescript-eslint/no-unused-vars */
-/* eslint-disable prefer-rest-params */
-import net from "net";
-import { PM_sidecar } from "./sidecar";
-const fPaths = [];
-export class PM_Pure_Sidecar extends PM_sidecar {
-    constructor(t) {
-        super();
-        this.testResourceConfiguration = t;
-    }
-    start() {
-        return new Promise((res) => {
-            process.on("message", (message) => {
-                if (message.path) {
-                    this.client = net.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]));
-        });
-    }
-}

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

@@ -1,7 +0,0 @@
-export class PM_sidecar {
-    testArtiFactoryfileWriter(tLog, callback) {
-        return (fPath, value) => {
-            callback(Promise.resolve());
-        };
-    }
-}

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

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