npm - testeranto - Versions diffs - 0.121.1 → 0.125.1 - Mend

testeranto 0.121.1 → 0.125.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (381) hide show

package/dist/module/{Init.js → src/Init.js} RENAMED Viewed

@@ -5,6 +5,7 @@ export default async () => {
         `testeranto/bundles/`,
         `testeranto/bundles/node`,
         `testeranto/bundles/web`,
+        `testeranto/bundles/pure`,
         `testeranto/reports`,
         `testeranto/reports/`,
         `testeranto/features/`,
@@ -16,42 +17,10 @@ export default async () => {
             // console.error(e);
         }
     });
-    // fs.writeFileSync(
-    //   `${process.cwd()}/testeranto/index.html`,
-    //   `
-    // <!DOCTYPE html>
-    // <html lang="en">
-    // <head>
-    //   <meta name="description" content="Webpage description goes here" />
-    //   <meta charset="utf-8" />
-    //   <title>kokomoBay - testeranto</title>
-    //   <meta name="viewport" content="width=device-width, initial-scale=1" />
-    //   <meta name="author" content="" />
-    //   <script type="module" src="/kokomoBay/testeranto/Project.js"></script>
-    // </head>
-    // <body>
-    //   <div id="root">
-    //     react is loading
-    //   </div>
-    // </body>
-    // </html>
-    //     `
-    // );
     fs.copyFileSync(`node_modules/testeranto/dist/prebuild/Project.js`, `testeranto/Project.js`);
     fs.copyFileSync(`node_modules/testeranto/dist/prebuild/ReportClient.js`, `testeranto/ReportClient.js`);
     fs.copyFileSync(`node_modules/testeranto/dist/prebuild/Project.css`, `testeranto/Project.css`);
     fs.copyFileSync(`node_modules/testeranto/dist/prebuild/ReportClient.css`, `testeranto/ReportClient.css`);
     fs.copyFileSync(`node_modules/testeranto/dist/prebuild/TestReport.js`, `testeranto/TestReport.js`);
     fs.copyFileSync(`node_modules/testeranto/dist/prebuild/TestReport.css`, `testeranto/TestReport.css`);
-    // fs.writeFileSync(
-    //   `${config.outdir}/testeranto.json`,
-    //   JSON.stringify(
-    //     {
-    //       ...config,
-    //       buildDir: process.cwd() + "/" + config.outdir,
-    //     },
-    //     null,
-    //     2
-    //   )
-    // );
 };

package/dist/module/src/Node.js ADDED Viewed

@@ -0,0 +1,42 @@
+import Testeranto from "./lib/core.js";
+import { defaultTestResourceRequirement, } from "./lib/index.js";
+import { PM_Node } from "./PM/node.js";
+export class NodeTesteranto extends Testeranto {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
+        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface, () => {
+            // no-op
+        });
+    }
+    async receiveTestResourceConfig(partialTestResource) {
+        const t = JSON.parse(partialTestResource);
+        const pm = new PM_Node(t);
+        return await this.testJobs[0].receiveTestResourceConfig(pm);
+        // const { failed, artifacts, logPromise, features } =
+        //   await this.testJobs[0].receiveTestResourceConfig(pm);
+        // // pm.customclose();
+        // return { features, failed };
+    }
+}
+const testeranto = async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {
+    const t = new NodeTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
+    try {
+        const f = await t.receiveTestResourceConfig(process.argv[2]);
+        console.error("goodbye node error", f.fails);
+        process.exit(f.fails);
+    }
+    catch (e) {
+        console.error("goodbye node error", e);
+        process.exit(-1);
+        // fs.writeFileSync(`tests.json`, JSON.stringify(t.,
+        //  null, 2));
+        // process.send({ message: "Hello from child!" });
+        // process.on("message", (message) => {
+        //   const client = net.createConnection(message.path, () => {
+        //     console.error("goodbye node error", e);
+        //     process.exit(-1);
+        //   });
+        // });
+    }
+    return t;
+};
+export default testeranto;

package/dist/module/src/PM/base.js ADDED Viewed

@@ -0,0 +1,223 @@
+import fs from "fs";
+import path from "path";
+const fileStreams3 = [];
+const fPaths = [];
+const files = {};
+const recorders = {};
+const screenshots = {};
+export class PM_Base {
+    constructor(configs) {
+        this.configs = configs;
+    }
+    customclose() {
+        throw new Error("Method not implemented.");
+    }
+    waitForSelector(p, s) {
+        return new Promise((res) => {
+            this.doInPage(p, async (page) => {
+                const x = page.$(s);
+                const y = await x;
+                res(y !== null);
+                // return page.focus(selector);
+            });
+        });
+    }
+    closePage(p) {
+        // throw new Error("Method not implemented.");
+        return new Promise((res) => {
+            this.doInPage(p, async (page) => {
+                page.close();
+                res({});
+                // return page.focus(selector);
+            });
+        });
+    }
+    newPage() {
+        return this.browser.newPage();
+    }
+    goto(p, url) {
+        return new Promise((res) => {
+            this.doInPage(p, async (page) => {
+                await (page === null || page === void 0 ? void 0 : page.goto(url));
+                res({});
+                // return page.focus(selector);
+            });
+        });
+    }
+    $(selector, p) {
+        return new Promise((res) => {
+            this.doInPage(p, async (page) => {
+                const x = page.$(selector);
+                const y = await x;
+                res(y !== null);
+            });
+        });
+    }
+    async pages() {
+        return (await this.browser.pages()).map((p) => {
+            return p.mainFrame()._id;
+        });
+    }
+    async screencast(ssOpts, testName, page) {
+        const p = ssOpts.path;
+        const dir = path.dirname(p);
+        fs.mkdirSync(dir, {
+            recursive: true,
+        });
+        if (!files[testName]) {
+            files[testName] = new Set();
+        }
+        files[testName].add(ssOpts.path);
+        const sPromise = page.screenshot(Object.assign(Object.assign({}, ssOpts), { path: p }));
+        if (!screenshots[testName]) {
+            screenshots[testName] = [];
+        }
+        screenshots[testName].push(sPromise);
+        await sPromise;
+        return sPromise;
+    }
+    async customScreenShot(ssOpts, testName, page) {
+        const p = ssOpts.path;
+        const dir = path.dirname(p);
+        fs.mkdirSync(dir, {
+            recursive: true,
+        });
+        if (!files[testName]) {
+            files[testName] = new Set();
+        }
+        files[testName].add(ssOpts.path);
+        const sPromise = page.screenshot(Object.assign(Object.assign({}, ssOpts), { path: p }));
+        if (!screenshots[testName]) {
+            screenshots[testName] = [];
+        }
+        screenshots[testName].push(sPromise);
+        await sPromise;
+        return sPromise;
+    }
+    async end(uid) {
+        await fileStreams3[uid].end();
+        return true;
+    }
+    existsSync(destFolder) {
+        return fs.existsSync(destFolder);
+    }
+    async mkdirSync(fp) {
+        if (!fs.existsSync(fp)) {
+            return fs.mkdirSync(fp, {
+                recursive: true,
+            });
+        }
+        return false;
+    }
+    async writeFileSync(filepath, contents, testName) {
+        return new Promise(async (res) => {
+            fs.mkdirSync(path.dirname(filepath), {
+                recursive: true,
+            });
+            if (!files[testName]) {
+                files[testName] = new Set();
+            }
+            files[testName].add(filepath);
+            await fs.writeFileSync(filepath, contents);
+            res(true);
+        });
+    }
+    async createWriteStream(filepath, testName) {
+        return new Promise((res) => {
+            const f = fs.createWriteStream(filepath);
+            fileStreams3.push(f);
+            if (!files[testName]) {
+                files[testName] = new Set();
+            }
+            files[testName].add(filepath);
+            res(fileStreams3.length - 1);
+        });
+    }
+    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 {
+                        /* @ts-ignore:next-line */
+                        const pipeStream = value;
+                        const myFile = fs.createWriteStream(fPath);
+                        pipeStream.pipe(myFile);
+                        pipeStream.on("close", () => {
+                            myFile.close();
+                            res();
+                        });
+                    }
+                });
+            }));
+        };
+    }
+    async write(uid, contents) {
+        return new Promise((res) => {
+            const x = fileStreams3[uid].write(contents);
+            res(x);
+        });
+    }
+    page() {
+        throw new Error("Method not implemented.");
+    }
+    click(selector, page) {
+        return page.click(selector);
+    }
+    async focusOn(selector, p) {
+        this.doInPage(p, (page) => {
+            return page.focus(selector);
+        });
+    }
+    async typeInto(value, p) {
+        this.doInPage(p, (page) => {
+            return page.keyboard.type(value);
+        });
+    }
+    getValue(value, p) {
+        this.doInPage(p, (page) => {
+            return page.keyboard.type(value);
+        });
+    }
+    getAttribute(selector, attribute, p) {
+        this.doInPage(p, (page) => {
+            return page.$eval(selector, (input) => input.getAttribute("value"));
+        });
+    }
+    isDisabled(selector, p) {
+        this.doInPage(p, async (page) => {
+            return await page.$eval(selector, (input) => {
+                return input.disabled;
+            });
+        });
+    }
+    screencastStop(s) {
+        return recorders[s].stop();
+    }
+    async doInPage(p, cb) {
+        (await this.browser.pages()).forEach((page) => {
+            if (page.mainFrame()._id === p) {
+                return cb(page);
+            }
+        });
+    }
+}