testeranto 0.70.0 → 0.74.0

package/README.md

@@ -17,7 +17,6 @@ example repo: [kokomo bay](https://github.com/ChromaPDX/kokomoBay)
 - Do you like TDD/BDD?
 - Do you love Typescript?
 - Do you hate Jira?
-- Do you tolerate electron?
 
 If so, then testeranto might be the testing tool you have been looking for!
 
@@ -40,8 +39,7 @@ Testeranto.ts an Acceptance Test Driven Development ([ATDD](https://en.wikipedia
 
 - esm - Testeranto uses modern js.
 - typescript - tests are functions with type parameters
-- electron - provides both a node and chrome runtime
-- puppeteer - provides node-style tests with a handle to the browser
+- puppeteer - provides access to both node and chrome runtimes
 - esbuild - used to quickly generate test bundles
 - graphology - used to store features within a semantic network
 
@@ -67,7 +65,7 @@ Rather than the traditional method of specifying tests in plain text, Testeranto
 
 ## the bad parts
 
-Testeranto is not designed to maximize performance. In dev mode, it runs multiple esbuild processes, electron, 1 node process for each node test and 1 chromium processes for each web test.
+Testeranto is not designed to maximize performance.
 
 Testeranto does not (yet!) of a means of allowing non-coders to affect changes so, as they say, "get good 💪!"
 
@@ -83,13 +81,9 @@ Testeranto is comprised of 3 parts
 - Build the node-style tests
 - Build the web-style tests
 
-2. The test runner is an electron app which watches the output of those build processes and launches the tests as those files change.
+2. The test runner watches the output of those build processes and launches the tests as those files change.
 3. A Report which links your features, your tests and the results of those tests into a handy website.
 
-## Electron aka Node vs Chromium
-
-At the heart of testeranto is the dual runtime provided by electron. The electron test runner creates an UtilityProcess for each node test and a BrowserWindow for each web test. Each of these processes can communicate to other artifacts over IPC. That is, a node test can invoke a web artifact and send it messages over the IPC channel, and vice-versa. Furthermore, node tests are provided with a puppeteer, providing it access to the web environment, while web tests are provided the electron BrowserWindow, which allows it to similarly bridge the gap between the web runtime and the node runtime.
-
 ## Hybrid tests
 
 Consider the a scenario: You have an http server which serves a frontend react component. You have multiple ways you can test this.
@@ -121,18 +115,15 @@ This is designed so that each piece can be worked upon separately. You can think
 
 ## CLI
 
-There are 4 commands you should add to your `package.json`
+There are 3 commands you should add to your `package.json`
 
 ```
-// build the tests
+// build the tests once
 "testeranto-esbuild": "ts-node-esm testeranto.mts",
 
-// run the tests
-"testeranto-electron": "electron node_modules/testeranto/dist/common/electron.js",
+// build the tests, watching for changes
+"testeranto-esbuild-dev": "ts-node-esm testeranto.mts",
 
-// build and run the tests as src files change
-"testeranto-dev": "yarn testeranto-esbuild -devmode ; yarn testeranto-electron -devmode"
-
-// build the tests, then run the tests
-"testeranto": "yarn testeranto-esbuild && yarn testeranto-electron"
+// run the tests
+"testeranto-puppeteer":"ts-node-esm node_modules/testeranto/dist/module/Puppeteer.js",
 ```

package/dist/common/Node.js

@@ -3,45 +3,18 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
 const core_js_1 = __importDefault(require("./lib/core.js"));
 const index_js_1 = require("./lib/index.js");
-const NodeWriter_js_1 = require("./NodeWriter.js");
-const puppeteerConfiger_js_1 = __importDefault(require("./puppeteerConfiger.js"));
+const node_js_1 = require("./PM/node.js");
 class NodeTesteranto extends core_js_1.default {
     constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
-        super(input, testSpecification, testImplementation, testResourceRequirement, NodeWriter_js_1.NodeWriter, testInterface);
-        if (process.argv[2]) {
-            const testResourceArg = process.argv[2];
-            try {
-                const partialTestResource = JSON.parse(testResourceArg);
-                this.receiveTestResourceConfig(this.testJobs[0], partialTestResource);
-            }
-            catch (e) {
-                console.error(e);
-                // process.exit(-1);
-            }
-        }
-        else {
-            // no-op
-        }
+        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
     }
-    async receiveTestResourceConfig(t, partialTestResource) {
-        const browser = await (0, puppeteerConfiger_js_1.default)("2999").then(async (json) => {
-            const b = await puppeteer_core_1.default.connect({
-                browserWSEndpoint: json.webSocketDebuggerUrl,
-                defaultViewport: null,
-            });
-            console.log("connected!", b.isConnected());
-            return b;
-        });
-        const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(partialTestResource, {
-            browser,
-            ipc: process.parentPort,
-        });
-        Promise.all([...artifacts, logPromise]).then(async () => {
-            process.exit((await failed) ? 1 : 0);
-        });
+    async receiveTestResourceConfig(partialTestResource) {
+        const t = JSON.parse(partialTestResource);
+        const pm = new node_js_1.PM_Node(t);
+        const { failed, artifacts, logPromise } = await this.testJobs[0].receiveTestResourceConfig(pm);
+        pm.customclose();
     }
 }
 exports.default = async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = index_js_1.defaultTestResourceRequirement) => {

package/dist/common/PM/index.js

@@ -0,0 +1,71 @@
+"use strict";
+// import {
+//   Browser,
+//   BrowserContext,
+//   BrowserContextOptions,
+//   DebugInfo,
+//   Page,
+//   PuppeteerNode,
+//   Target,
+// } from "puppeteer-core";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM = void 0;
+const fPaths = [];
+class PM {
+}
+exports.PM = PM;
+// export class PuppetMasterBrowser extends Browser {
+//   process(): ChildProcess | null {
+//     return super.process();
+//   }
+//   createBrowserContext(
+//     options?: BrowserContextOptions
+//   ): Promise<BrowserContext> {
+//     throw new Error("Method not implemented.");
+//   }
+//   browserContexts(): BrowserContext[] {
+//     throw new Error("Method not implemented.");
+//   }
+//   defaultBrowserContext(): BrowserContext {
+//     throw new Error("Method not implemented.");
+//   }
+//   wsEndpoint(): string {
+//     throw new Error("Method not implemented.");
+//   }
+//   newPage(): Promise<Page> {
+//     throw new Error("Method not implemented.");
+//   }
+//   targets(): Target[] {
+//     throw new Error("Method not implemented.");
+//   }
+//   target(): Target {
+//     throw new Error("Method not implemented.");
+//   }
+//   version(): Promise<string> {
+//     throw new Error("Method not implemented.");
+//   }
+//   userAgent(): Promise<string> {
+//     throw new Error("Method not implemented.");
+//   }
+//   close(): Promise<void> {
+//     throw new Error("Method not implemented.");
+//   }
+//   disconnect(): Promise<void> {
+//     throw new Error("Method not implemented.");
+//   }
+//   get connected(): boolean {
+//     throw new Error("Method not implemented.");
+//   }
+//   get debugInfo(): DebugInfo {
+//     throw new Error("Method not implemented.");
+//   }
+//   constructor(...z: []) {
+//     super(...z);
+//   }
+//   // pages(): Promise<Page[]>;
+//   pages(): Promise<Page[]> {
+//     return new Promise<Page[]>((res, rej) => {
+//       res(super.pages());
+//     });
+//   }
+// }

package/dist/common/PM/main.js

@@ -0,0 +1,370 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PM_Main = void 0;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
+const index_js_1 = require("./index.js");
+const fPaths = [];
+const fileStreams3 = [];
+const files = {}; // = new Set<string>();
+const screenshots = {};
+class PM_Main extends index_js_1.PM {
+    constructor(configs) {
+        super();
+        this.launchNode = async (src, dest) => {
+            console.log("launchNode", src);
+            const destFolder = dest.replace(".mjs", "");
+            let argz = "";
+            const testConfig = this.configs.tests.find((t) => {
+                return t[0] === src;
+            });
+            if (!testConfig) {
+                console.error("missing test config");
+                process.exit(-1);
+            }
+            const testConfigResource = testConfig[2];
+            let portsToUse = [];
+            if (testConfigResource.ports === 0) {
+                argz = JSON.stringify({
+                    scheduled: true,
+                    name: src,
+                    ports: portsToUse,
+                    fs: destFolder,
+                    browserWSEndpoint: this.browser.wsEndpoint(),
+                });
+            }
+            else if (testConfigResource.ports > 0) {
+                const openPorts = Object.entries(this.ports).filter(([portnumber, portopen]) => portopen);
+                if (openPorts.length >= testConfigResource.ports) {
+                    for (let i = 0; i < testConfigResource.ports; i++) {
+                        portsToUse.push(openPorts[i][0]);
+                        this.ports[openPorts[i][0]] = false; // port is now closed
+                    }
+                    argz = JSON.stringify({
+                        scheduled: true,
+                        name: src,
+                        // ports: [3333],
+                        ports: portsToUse,
+                        fs: ".",
+                        browserWSEndpoint: this.browser.wsEndpoint(),
+                    });
+                }
+                else {
+                    this.queue.push(src);
+                    return;
+                }
+            }
+            else {
+                console.error("negative port makes no sense", src);
+                process.exit(-1);
+            }
+            const builtfile = dest + ".mjs";
+            this.server[builtfile] = await Promise.resolve().then(() => __importStar(require(`${builtfile}?cacheBust=${Date.now()}`))).then((module) => {
+                return module.default.then((defaultModule) => {
+                    defaultModule
+                        .receiveTestResourceConfig(argz)
+                        .then((x) => {
+                        console.log("then", x);
+                        return x;
+                    })
+                        .catch((e) => {
+                        console.log("catch", e);
+                    });
+                });
+            });
+            for (let i = 0; i <= portsToUse.length; i++) {
+                this.ports[i] = true; //port is open again
+            }
+        };
+        this.launchWeb = (t, dest) => {
+            console.log("launchWeb", t, dest);
+            const destFolder = dest.replace(".mjs", "");
+            const webArgz = JSON.stringify({
+                name: dest,
+                ports: [].toString(),
+                fs: destFolder,
+                browserWSEndpoint: this.browser.wsEndpoint(),
+            });
+            const evaluation = `import('${dest}.mjs').then(async (x) => {
+      console.log("imported", x, (x.default));
+      try {
+        await (await x.default).receiveTestResourceConfig(${webArgz})
+      } catch (e) {
+        console.log("fail", e)
+      }
+    })`;
+            const fileStreams2 = [];
+            // const screenshots2: Promise<any>[] = [];
+            const doneFileStream2 = [];
+            this.browser
+                .newPage()
+                .then((page) => {
+                page.exposeFunction("custom-screenshot", async (ssOpts, testName) => {
+                    console.log("main.ts browser custom-screenshot", testName);
+                    const p = ssOpts.path;
+                    const dir = path_1.default.dirname(p);
+                    fs_1.default.mkdirSync(dir, {
+                        recursive: true,
+                    });
+                    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);
+                    // sPromise.then(())
+                    await sPromise;
+                    return sPromise;
+                    // page.evaluate(`window["screenshot done"]`);
+                });
+                page.exposeFunction("writeFileSync", (fp, contents, testName) => {
+                    const dir = path_1.default.dirname(fp);
+                    fs_1.default.mkdirSync(dir, {
+                        recursive: true,
+                    });
+                    const p = new Promise(async (res, rej) => {
+                        fs_1.default.writeFileSync(fp, contents);
+                        res(fp);
+                    });
+                    doneFileStream2.push(p);
+                    if (!files[testName]) {
+                        files[testName] = new Set();
+                    }
+                    files[testName].add(fp);
+                    return p;
+                });
+                page.exposeFunction("existsSync", (fp, contents) => {
+                    return fs_1.default.existsSync(fp);
+                });
+                page.exposeFunction("mkdirSync", (fp) => {
+                    if (!fs_1.default.existsSync(fp)) {
+                        return fs_1.default.mkdirSync(fp, {
+                            recursive: true,
+                        });
+                    }
+                    return false;
+                });
+                page.exposeFunction("createWriteStream", (fp, testName) => {
+                    const f = fs_1.default.createWriteStream(fp);
+                    if (!files[testName]) {
+                        files[testName] = new Set();
+                    }
+                    files[testName].add(fp);
+                    const p = new Promise((res, rej) => {
+                        res(fp);
+                    });
+                    doneFileStream2.push(p);
+                    f.on("close", async () => {
+                        await p;
+                    });
+                    fileStreams2.push(f);
+                    return Object.assign(Object.assign({}, JSON.parse(JSON.stringify(f))), { uid: fileStreams2.length - 1 });
+                });
+                page.exposeFunction("write", async (uid, contents) => {
+                    return fileStreams2[uid].write(contents);
+                });
+                page.exposeFunction("end", async (uid) => {
+                    return fileStreams2[uid].end();
+                });
+                page.exposeFunction("customclose", (p, testName) => {
+                    fs_1.default.writeFileSync(p + "/manifest.json", JSON.stringify(Array.from(files[testName])));
+                    delete files[testName];
+                    Promise.all(screenshots[testName] || []).then(() => {
+                        delete screenshots[testName];
+                        page.close();
+                    });
+                    // globalThis["writeFileSync"](
+                    //   p + "/manifest.json",
+                    //   // files.entries()
+                    //   JSON.stringify(Array.from(files[testName]))
+                    // );
+                    // console.log("closing doneFileStream2", doneFileStream2);
+                    // console.log("closing doneFileStream2", doneFileStream2);
+                    // Promise.all([...doneFileStream2, ...screenshots2]).then(() => {
+                    //   page.close();
+                    // });
+                    // Promise.all(screenshots).then(() => {
+                    //   page.close();
+                    // });
+                    // setTimeout(() => {
+                    //   console.log("Delayed for 1 second.");
+                    //   page.close();
+                    // }, 5000);
+                    // return page.close();
+                });
+                return page;
+            })
+                .then(async (page) => {
+                await page.goto(`file://${`${dest}.html`}`, {});
+                page.evaluate(evaluation).finally(() => {
+                    console.log("evaluation failed.", dest);
+                });
+                return page;
+            });
+        };
+        this.server = {};
+        this.configs = configs;
+        this.ports = {};
+        this.configs.ports.forEach((element) => {
+            this.ports[element] = "true"; // set ports as open
+        });
+        globalThis["mkdirSync"] = (fp) => {
+            if (!fs_1.default.existsSync(fp)) {
+                return fs_1.default.mkdirSync(fp, {
+                    recursive: true,
+                });
+            }
+            return false;
+        };
+        globalThis["writeFileSync"] = (filepath, contents, testName) => {
+            // Create directories if they don't exist
+            const dir = path_1.default.dirname(filepath.split("/").slice(0, -1).join("/"));
+            fs_1.default.mkdirSync(dir, {
+                recursive: true,
+            });
+            if (!files[testName]) {
+                files[testName] = new Set();
+            }
+            files[testName].add(filepath);
+            return fs_1.default.writeFileSync(filepath, contents);
+        };
+        globalThis["createWriteStream"] = (filepath, testName) => {
+            const f = fs_1.default.createWriteStream(filepath);
+            fileStreams3.push(f);
+            // files.add(filepath);
+            if (!files[testName]) {
+                files[testName] = new Set();
+            }
+            files[testName].add(filepath);
+            return Object.assign(Object.assign({}, JSON.parse(JSON.stringify(f))), { uid: fileStreams3.length - 1 });
+        };
+        globalThis["write"] = (uid, contents) => {
+            fileStreams3[uid].write(contents);
+        };
+        globalThis["end"] = (uid) => {
+            fileStreams3[uid].end();
+        };
+        globalThis["customclose"] = (p, testName) => {
+            if (!files[testName]) {
+                files[testName] = new Set();
+            }
+            fs_1.default.writeFileSync(p + "/manifest.json", JSON.stringify(Array.from(files[testName])));
+            delete files[testName];
+            // globalThis["writeFileSync"](
+            //   p + "/manifest.json",
+            //   // files.entries()
+            //   JSON.stringify(Array.from(files[testName]))
+            // );
+            // fileStreams3[uid].end();
+        };
+        // page.exposeFunction("customclose", () => {
+        //   console.log("closing doneFileStream2", doneFileStream2);
+        //   // console.log("closing doneFileStream2", doneFileStream2);
+        //   Promise.all([...doneFileStream2, ...screenshots2]).then(() => {
+        //     page.close();
+        //   });
+        //   // page.close();
+        //   // Promise.all(screenshots).then(() => {
+        //   //   page.close();
+        //   // });
+        //   // setTimeout(() => {
+        //   //   console.log("Delayed for 1 second.");
+        //   //   page.close();
+        //   // }, 5000);
+        //   // return page.close();
+        // });
+    }
+    async startPuppeteer(options, destfolder) {
+        this.browser = await puppeteer_core_1.default.launch(options);
+        return this.browser;
+    }
+    end(accessObject) {
+        throw new Error("Method not implemented.");
+    }
+    existsSync(destFolder) {
+        return fs_1.default.existsSync(destFolder);
+    }
+    async mkdirSync(fp) {
+        if (!fs_1.default.existsSync(fp)) {
+            return fs_1.default.mkdirSync(fp, {
+                recursive: true,
+            });
+        }
+        return false;
+    }
+    writeFileSync(fp, contents) {
+        fs_1.default.writeFileSync(fp, contents);
+    }
+    createWriteStream(filepath) {
+        return fs_1.default.createWriteStream(filepath);
+    }
+    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_1.default.writeFileSync(path_1.default.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 {
+                        /* @ts-ignore:next-line */
+                        const pipeStream = value;
+                        const myFile = fs_1.default.createWriteStream(fPath);
+                        pipeStream.pipe(myFile);
+                        pipeStream.on("close", () => {
+                            myFile.close();
+                            res();
+                        });
+                    }
+                });
+            }));
+        };
+    }
+    write(accessObject, contents) {
+        throw new Error("Method not implemented.");
+    }
+}
+exports.PM_Main = PM_Main;

package/dist/common/PM/node.js

@@ -0,0 +1,84 @@
+"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;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const puppeteer_core_1 = __importDefault(require("puppeteer-core"));
+const index_js_1 = require("./index.js");
+const fPaths = [];
+class PM_Node extends index_js_1.PM {
+    constructor(t) {
+        super();
+        this.server = {};
+        this.testResourceConfiguration = t;
+    }
+    existsSync(destFolder) {
+        return globalThis["existsSync"](this.testResourceConfiguration.fs + "/" + destFolder);
+    }
+    mkdirSync() {
+        return globalThis["mkdirSync"](this.testResourceConfiguration.fs + "/");
+    }
+    write(writeObject, contents) {
+        return globalThis["write"](writeObject.uid, contents);
+    }
+    writeFileSync(filepath, contents) {
+        return globalThis["writeFileSync"](this.testResourceConfiguration.fs + "/" + filepath, contents, this.testResourceConfiguration.name);
+    }
+    createWriteStream(filepath) {
+        return globalThis["createWriteStream"](this.testResourceConfiguration.fs + "/" + filepath, this.testResourceConfiguration.name);
+    }
+    end(writeObject) {
+        return globalThis["end"](writeObject.uid);
+    }
+    customclose() {
+        globalThis["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_1.default.writeFileSync(path_1.default.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 {
+                        /* @ts-ignore:next-line */
+                        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_core_1.default.connect(options).then((b) => {
+            this.browser = b;
+        });
+    }
+}
+exports.PM_Node = PM_Node;