testeranto 0.49.10 → 0.62.0

package/dist/module/electron.js

@@ -1,47 +1,191 @@
-import { app, BrowserWindow, ipcMain } from "electron";
+import { app, BrowserWindow, utilityProcess } from "electron";
+import pie from "puppeteer-in-electron";
+import puppeteer from "puppeteer-core";
+import fs from "fs";
 import path from "path";
-import url from "url";
-let win;
-function createWindow() {
-    win = new BrowserWindow({
-        webPreferences: {
-            devTools: true,
-            nodeIntegration: true,
-            nodeIntegrationInWorker: true,
-            contextIsolation: false,
-            preload: path.join(app.getAppPath(), 'preload.js'),
-            sandbox: false
-        },
-        width: 800,
-        height: 600,
-        show: true,
+import { jsonc } from 'jsonc';
+const remoteMain = require("@electron/remote/main");
+remoteMain.initialize();
+const main = async () => {
+    const configs = jsonc.parse((await fs.readFileSync("./docs/testeranto.json")).toString());
+    const loadReport = (configs) => {
+        const win = new BrowserWindow({
+            show: true,
+            webPreferences: {
+                offscreen: false,
+                devTools: true,
+            }
+        });
+        win.loadFile(`/${configs.buildDir}/report.html`).then(async (x) => {
+            // pie.connect(app, puppeteer).then(async (browser) => {
+            //   pie.getPage(browser, win).then(async (page) => {
+            //     await page.screenshot({
+            //       path: 'electron-puppeteer-screenshot1.jpg'
+            //     });
+            //   })
+            // })
+        });
+    };
+    const launchNode = (t, x) => {
+        var _a;
+        const f = x.replace(".ts", ".mjs");
+        const a = JSON.stringify({
+            scheduled: true,
+            name: x,
+            ports: [],
+            fs: path.resolve(configs.buildDir, "node", t),
+        });
+        console.log("launchNode", f, a);
+        const child = utilityProcess.fork(f, [a], {});
+        child.postMessage({ message: 'hello' });
+        child.on('message', (data) => {
+            console.log("from child", data);
+            launchWebSecondary(process.cwd() + data);
+        });
+        child.on('exit', (data) => {
+            console.log("node process ended with: ", data);
+            fileStream.close();
+        });
+        // child.stdout
+        // child..on("", (data) => {
+        //   console.log("from child", data) // hello world!
+        //   launchWebSecondary(process.cwd() + data);
+        // })
+        // Create a write stream for the file
+        const fileStream = fs.createWriteStream('errors.txt');
+        // Pipe the child process's stdout to the file
+        (_a = child.stdout) === null || _a === void 0 ? void 0 : _a.pipe(fileStream);
+        // // Handle errors
+        // child.on('error', (err) => {
+        //   console.error('Error spawning child process:', err);
+        // });
+        // fileStream.on('error', (err) => {
+        //   console.error('Error writing to file:', err);
+        // });
+        // // Log a message when the child process exits
+        // child.on('close', (code) => {
+        //   console.log(`Child process exited with code ${code}`);
+        // });
+        // console.log("child", child);
+        // child.stdout?.on("data", (x) => {
+        //   console.log("x", x)
+        // })
+    };
+    const launchWebSecondary = (htmlFile) => {
+        console.log("launchWebSecondary", htmlFile);
+        const subWin = new BrowserWindow({
+            show: true,
+            webPreferences: {
+                nodeIntegration: true,
+                nodeIntegrationInWorker: true,
+                contextIsolation: false,
+                preload: path.join(app.getAppPath(), 'preload.js'),
+                offscreen: false,
+                devTools: false,
+            }
+        });
+        remoteMain.enable(subWin.webContents);
+        subWin.webContents.openDevTools();
+        subWin.loadFile(htmlFile);
+    };
+    const launchWeb = (t, changedFile) => {
+        console.log("launchWeb", changedFile);
+        const subWin = new BrowserWindow({
+            show: true,
+            webPreferences: {
+                nodeIntegration: true,
+                nodeIntegrationInWorker: true,
+                contextIsolation: false,
+                preload: path.join(app.getAppPath(), 'preload.js'),
+                offscreen: false,
+                devTools: true,
+            }
+        });
+        remoteMain.enable(subWin.webContents);
+        // subWin.webContents.openDevTools()
+        const htmlFile = changedFile.split(".").slice(0, -1).concat("html").join(".");
+        subWin.loadFile(htmlFile, {
+            query: {
+                requesting: encodeURIComponent(JSON.stringify({
+                    name: changedFile,
+                    ports: [].toString(),
+                    fs: path.resolve(configs.buildDir, "web", t),
+                }))
+            }
+        });
+    };
+    const watcher = (test, runtime) => {
+        return path.normalize(`${configs.buildDir}/${runtime}/${test.split('.').slice(0, -1).concat('mjs').join('.')}`);
+    };
+    const changer = (f) => {
+        return path.normalize(`${configs.buildDir}/${f}`);
+    };
+    const changer2 = (f, r) => {
+        return path.normalize(`${configs.buildDir}/${r}/${f}`);
+    };
+    pie.initialize(app, 2999).then(async () => {
+        app.on("ready", () => {
+            loadReport(configs);
+            console.log("running all the tests once initially");
+            ;
+            configs.modules.forEach((t) => {
+                if (t.runtime === "node") {
+                    launchNode(t.test, changer2(t.test, "node"));
+                }
+                else if (t.runtime === "web") {
+                    launchWeb(t.test, changer2(t.test, "web"));
+                }
+                else {
+                    console.error("runtime makes no sense", t.runtime);
+                }
+            });
+            console.log("ready and watching for changes...", configs.buildDir);
+            fs.watch(configs.buildDir, {
+                recursive: true,
+            }, (eventType, changedFile) => {
+                console.log(eventType, changedFile);
+                if (changedFile) {
+                    configs.modules.forEach((t) => {
+                        if (watcher(t.test, t.runtime) === changer(changedFile)) {
+                            if (t.runtime === "node") {
+                                launchNode(t.test, changer(changedFile));
+                            }
+                            else if (t.runtime === "web") {
+                                launchWeb(t.test, changer(changedFile));
+                            }
+                            else {
+                                console.error("runtime makes no sense", t.runtime);
+                            }
+                        }
+                    });
+                }
+            });
+        });
     });
-    const u = url.format({
-        pathname: path.join(process.cwd(), process.argv[2]),
-        protocol: "file:",
-        slashes: true,
-        query: {
-            requesting: encodeURIComponent(process.argv[3]),
-        }
-    });
-    console.log("loading", u);
-    win.loadURL(u);
-    win.webContents.openDevTools();
-}
-app.on("ready", createWindow);
-ipcMain.handle('web-log', (x, message) => {
-    console.log("web-log)", message);
-});
-ipcMain.handle('web-error', (x, message) => {
-    console.log("web-error)", message);
-});
-ipcMain.handle('web-warn', (x, message) => {
-    console.log("web-warn)", message);
-});
-ipcMain.handle('web-info', (x, message) => {
-    console.log("web-info)", message);
-});
-ipcMain.handle('quit-app', (x, failed) => {
-    console.log("quit-app", failed);
-    // app.exit(failed);
-});
+    await pie.connect(app, puppeteer);
+};
+main();
+// ipcMain.handle('web-log', (x, message: string) => {
+//   console.log("web-log)", message);
+// });
+// ipcMain.handle('web-error', (x, message: string) => {
+//   console.log("web-error)", message);
+// });
+// ipcMain.handle('web-warn', (x, message: string) => {
+//   console.log("web-warn)", message);
+// });
+// ipcMain.handle('web-info', (x, message: string) => {
+//   console.log("web-info)", message);
+// });
+// ipcMain.handle('quit-app', (x, failed: number) => {
+//   console.log("quit-app", failed);
+//   app.exit(failed);
+// });
+// process.stdin.on("data", (configTests) => {
+//   main(JSON.parse(configTests.toString()) as ITestTypes[]);
+// });
+// const watchables = (tests: ITestTypes[]) => {
+//   return tests.map((t) => {
+//     return [t[1], `dist/${t[1]}/${t[0].replace(".mts", ".mjs")}`]
+//   })
+// }

package/dist/module/esbuildConfigs/features.js

@@ -0,0 +1,12 @@
+export default (config) => {
+    return {
+        bundle: true,
+        entryPoints: [config.features],
+        minify: config.minify === true,
+        outbase: config.outbase,
+        write: true,
+        outfile: `${config.outdir}/features.test.js`,
+        // external: ["graphology"],
+        format: "esm",
+    };
+};

package/dist/module/esbuildConfigs/index.js

@@ -0,0 +1,18 @@
+export default (config) => {
+    return {
+        target: "esnext",
+        format: "esm",
+        splitting: true,
+        outExtension: { '.js': '.mjs' },
+        outbase: config.outbase,
+        jsx: 'transform',
+        bundle: true,
+        minify: config.minify === true,
+        write: true,
+        loader: {
+            '.js': 'jsx',
+            '.png': 'binary',
+            '.jpg': 'binary',
+        },
+    };
+};

package/dist/module/esbuildConfigs/node.js

@@ -0,0 +1,30 @@
+import baseEsBuildConfig from "./index.js";
+// const jsonConfig = jsonc.parse((await fs.readFileSync("./testeranto.json")).toString()) as IJsonConfig;
+export default (config, entryPoints) => {
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { outdir: config.outdir + "/node", inject: [`./node_modules/testeranto/dist/cjs-shim.js`], supported: {
+            "dynamic-import": true
+        }, define: {
+            "process.env.FLUENTFFMPEG_COV": "0"
+        }, absWorkingDir: process.cwd(), banner: {
+            js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+        }, platform: "node", external: [
+            "testeranto.json",
+            "features.test.js",
+            "react",
+            "events",
+            // "ganache"
+            ...config.externals
+        ], entryPoints: [...entryPoints], plugins: [
+            ...(config.nodePlugins || []),
+            {
+                name: 'rebuild-notify',
+                setup(build) {
+                    build.onEnd(result => {
+                        console.log(`node build ended with ${result.errors.length} errors`);
+                        console.log(result);
+                        result.errors.length !== 0 && process.exit(-1);
+                    });
+                }
+            },
+        ] });
+};

package/dist/module/esbuildConfigs/report.js

@@ -0,0 +1,48 @@
+"use strict";
+// import { jsonc } from "jsonc";
+// import { IBaseConfig, IJsonConfig } from "../Types";
+// import baseEsBuildConfig from "./index.js";
+// import fs from "fs"
+// import { BuildOptions } from "esbuild";
+// // import { CssModulesPlugin } from 'esbuild-css-modules-plugin';
+// const jsonConfig = jsonc.parse((await fs.readFileSync("./testeranto.json")).toString()) as IJsonConfig;
+// export default (config: IBaseConfig): BuildOptions => {
+//   return {
+//     bundle: true,
+//     entryPoints: ["./node_modules/testeranto/dist/module/report.js"],
+//     minify: config.minify === true,
+//     outbase: config.outbase,
+//     write: true,
+//     outfile: `${jsonConfig.outdir}/report.js`,
+//     external: [
+//       "tests.json",
+//       "features.test.js"
+//     ],
+//     // plugins: [
+//     //   CssModulesPlugin({
+//     //     // @see https://github.com/indooorsman/esbuild-css-modules-plugin/blob/main/index.d.ts for more details
+//     //     force: true,
+//     //     emitDeclarationFile: true,
+//     //     localsConvention: 'camelCaseOnly',
+//     //     namedExports: true,
+//     //     inject: false
+//     //   })
+//     // ]
+//   }
+//   // return {
+//   //   bundle: true,
+//   //   entryPoints: [
+//   //     "./node_modules/testeranto/dist/module/Report.js",
+//   //     jsonConfig.features
+//   //   ],
+//   //   minify: config.minify === true,
+//   //   outbase: ".",
+//   //   outdir: 'docs',
+//   //   write: true,
+//   //   // outfile: `${jsonConfig.outdir}/Report.js`,
+//   //   external: [
+//   //     "features.test.js",
+//   //     "testeranto.json"
+//   //   ]
+//   // }
+// }

package/dist/module/esbuildConfigs/tests.js

@@ -0,0 +1,12 @@
+// const jsonConfig = jsonc.parse((await fs.readFileSync("./testeranto.json")).toString()) as IJsonConfig;
+export default (config) => {
+    return {
+        bundle: true,
+        entryPoints: [config.features],
+        minify: config.minify === true,
+        outbase: config.outbase,
+        write: true,
+        outfile: `${config.outdir}/tests.test.js`,
+        // external: ["graphology"]
+    };
+};

package/dist/module/esbuildConfigs/web.js

@@ -0,0 +1,45 @@
+import path from "path";
+import baseEsBuildConfig from "./index.js";
+// const jsonConfig = jsonc.parse((await fs.readFileSync("./testeranto.json")).toString()) as IJsonConfig;
+export default (config, entryPoints) => {
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { 
+        // inject: ['./node_modules/testeranto/dist/cjs-shim.js'],
+        // banner: {
+        //   js: `import { createRequire } from 'module';const require = createRequire(import.meta.url);`
+        // },
+        outdir: config.outdir + "/web", alias: {
+            react: path.resolve("./node_modules/react")
+        }, external: [
+            "testeranto.json",
+            "features.test.ts",
+            // "url", 
+            "react",
+            "electron",
+            "path",
+            "fs",
+            "stream",
+            "http",
+            "constants",
+            "net",
+            "assert",
+            "tls",
+            "os",
+            "child_process",
+            "readline",
+            "zlib",
+            "crypto",
+            "https"
+        ], platform: "browser", entryPoints: [...entryPoints], plugins: [
+            ...(config.webPlugins || []),
+            {
+                name: 'rebuild-notify',
+                setup(build) {
+                    build.onEnd(result => {
+                        console.log(`web build ended with ${result.errors.length} errors`);
+                        console.log(result);
+                        result.errors.length !== 0 && process.exit(-1);
+                    });
+                }
+            },
+        ] });
+};

package/dist/module/lib/abstractBase.js

@@ -0,0 +1,185 @@
+export class BaseSuite {
+    constructor(name, index, givens = {}, checks = []) {
+        this.name = name;
+        this.index = index;
+        this.givens = givens;
+        this.checks = checks;
+        this.fails = [];
+    }
+    toObj() {
+        return {
+            name: this.name,
+            givens: Object.keys(this.givens).map((k) => this.givens[k].toObj()),
+            fails: this.fails,
+        };
+    }
+    setup(s, artifactory, tr, utils) {
+        return new Promise((res) => res(s));
+    }
+    assertThat(t) {
+        // console.log("base assertThat")
+        return t;
+    }
+    async run(input, testResourceConfiguration, artifactory, tLog, utils) {
+        this.testResourceConfiguration = testResourceConfiguration;
+        tLog("test resources: ", testResourceConfiguration);
+        const suiteArtifactory = (fPath, value) => artifactory(`suite-${this.index}-${this.name}/${fPath}`, value);
+        const subject = await this.setup(input, suiteArtifactory, testResourceConfiguration, utils);
+        tLog("\nSuite:", this.index, this.name);
+        for (const k of Object.keys(this.givens)) {
+            const giver = this.givens[k];
+            try {
+                this.store = await giver.give(subject, k, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, utils);
+            }
+            catch (e) {
+                console.error(e);
+                this.fails.push(giver);
+                return this;
+            }
+        }
+        for (const [ndx, thater] of this.checks.entries()) {
+            await thater.check(subject, thater.name, testResourceConfiguration, this.assertThat, suiteArtifactory, tLog, utils);
+        }
+        // @TODO fix me
+        for (const k of Object.keys(this.givens)) {
+            const giver = this.givens[k];
+            giver.afterAll(this.store, artifactory, utils);
+        }
+        ////////////////
+        return this;
+    }
+}
+export class BaseGiven {
+    constructor(name, features, whens, thens, givenCB, initialValues) {
+        this.name = name;
+        this.features = features;
+        this.whens = whens;
+        this.thens = thens;
+        this.givenCB = givenCB;
+        this.initialValues = initialValues;
+    }
+    beforeAll(store, artifactory) {
+        return store;
+    }
+    afterAll(store, artifactory, utils) {
+        return store;
+    }
+    toObj() {
+        return {
+            name: this.name,
+            whens: this.whens.map((w) => w.toObj()),
+            thens: this.thens.map((t) => t.toObj()),
+            error: this.error ? [this.error, this.error.stack] : null,
+            features: this.features,
+        };
+    }
+    async afterEach(store, key, artifactory) {
+        return store;
+    }
+    async give(subject, key, testResourceConfiguration, tester, artifactory, tLog, utils) {
+        tLog(`\n Given: ${this.name}`);
+        const givenArtifactory = (fPath, value) => artifactory(`given-${key}/${fPath}`, value);
+        try {
+            this.store = await this.givenThat(subject, testResourceConfiguration, givenArtifactory, this.givenCB);
+            // tLog(`\n Given this.store`, this.store);
+            for (const whenStep of this.whens) {
+                await whenStep.test(this.store, testResourceConfiguration, tLog, utils);
+            }
+            for (const thenStep of this.thens) {
+                const t = await thenStep.test(this.store, testResourceConfiguration, tLog, utils);
+                tester(t);
+            }
+        }
+        catch (e) {
+            this.error = e;
+            tLog(e);
+            tLog("\u0007"); // bell
+            // throw e;
+        }
+        finally {
+            try {
+                await this.afterEach(this.store, key, givenArtifactory);
+            }
+            catch (e) {
+                console.error("afterEach failed! no error will be recorded!", e);
+            }
+        }
+        return this.store;
+    }
+}
+export class BaseWhen {
+    constructor(name, whenCB) {
+        this.name = name;
+        this.whenCB = whenCB;
+    }
+    toObj() {
+        return {
+            name: this.name,
+            error: this.error,
+        };
+    }
+    async test(store, testResourceConfiguration, tLog, utils) {
+        tLog(" When:", this.name);
+        try {
+            return await this.andWhen(store, this.whenCB, testResourceConfiguration);
+        }
+        catch (e) {
+            this.error = true;
+            throw e;
+        }
+    }
+}
+export class BaseThen {
+    constructor(name, thenCB) {
+        this.name = name;
+        this.thenCB = thenCB;
+    }
+    toObj() {
+        return {
+            name: this.name,
+            error: this.error,
+        };
+    }
+    async test(store, testResourceConfiguration, tLog, utils) {
+        tLog(" Then:", this.name);
+        try {
+            const x = (await this.butThen(store, this.thenCB, testResourceConfiguration));
+            return x;
+        }
+        catch (e) {
+            console.log("test failed", e);
+            this.error = true;
+            throw e;
+        }
+    }
+}
+export class BaseCheck {
+    constructor(name, features, checkCB, whens, thens) {
+        this.name = name;
+        this.features = features;
+        this.checkCB = checkCB;
+        this.whens = whens;
+        this.thens = thens;
+    }
+    async afterEach(store, key, cb) {
+        return;
+    }
+    async check(subject, key, testResourceConfiguration, tester, artifactory, tLog, utils) {
+        tLog(`\n Check: ${this.name}`);
+        const store = await this.checkThat(subject, testResourceConfiguration, artifactory);
+        await this.checkCB(Object.entries(this.whens).reduce((a, [key, when]) => {
+            a[key] = async (payload) => {
+                return await when(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, utils);
+            };
+            return a;
+        }, {}), Object.entries(this.thens).reduce((a, [key, then]) => {
+            a[key] = async (payload) => {
+                const t = await then(payload, testResourceConfiguration).test(store, testResourceConfiguration, tLog, utils);
+                tester(t);
+            };
+            return a;
+        }, {}));
+        await this.afterEach(store, key);
+        return;
+    }
+}

package/dist/module/lib/basebuilder.js

@@ -0,0 +1,82 @@
+export class BaseBuilder {
+    constructor(input, suitesOverrides, givenOverides, whenOverides, thenOverides, checkOverides, logWriter, testResourceRequirement, testSpecification) {
+        this.input = input;
+        this.artifacts = [];
+        this.artifacts = [];
+        this.testResourceRequirement = testResourceRequirement;
+        this.suitesOverrides = suitesOverrides;
+        this.givenOverides = givenOverides;
+        this.whenOverides = whenOverides;
+        this.thenOverides = thenOverides;
+        this.checkOverides = checkOverides;
+        this.testSpecification = testSpecification;
+        this.specs = testSpecification(this.Suites(), this.Given(), this.When(), this.Then(), this.Check());
+        const suiteRunner = (suite, utils) => async (testResourceConfiguration, tLog, utils) => {
+            return await suite.run(input, testResourceConfiguration, (fPath, value) => logWriter.testArtiFactoryfileWriter(tLog, (p) => {
+                this.artifacts.push(p);
+            })(testResourceConfiguration.fs + "/" + fPath, value), tLog, utils);
+        };
+        this.testJobs = this.specs.map((suite, utils) => {
+            const runner = suiteRunner(suite, utils);
+            return {
+                test: suite,
+                testResourceRequirement,
+                toObj: () => {
+                    return suite.toObj();
+                },
+                runner,
+                receiveTestResourceConfig: async function (testResourceConfiguration = {
+                    name: "",
+                    fs: ".",
+                    ports: [],
+                    scheduled: false
+                }, y) {
+                    console.log(`testResourceConfiguration ${JSON.stringify(testResourceConfiguration, null, 2)}`);
+                    await logWriter.mkdirSync(testResourceConfiguration.fs);
+                    logWriter.writeFileSync(`${testResourceConfiguration.fs}/tests.json`, JSON.stringify(this.toObj(), null, 2));
+                    const logFilePath = `${testResourceConfiguration.fs}/log.txt`;
+                    const access = await logWriter.createWriteStream(logFilePath);
+                    const tLog = (...l) => {
+                        // console.log(...l);
+                        access.write(`${l.toString()}\n`);
+                    };
+                    const suiteDone = await runner(testResourceConfiguration, tLog, y);
+                    const resultsFilePath = (`${testResourceConfiguration.fs}/results.json`);
+                    logWriter.writeFileSync(resultsFilePath, JSON.stringify(suiteDone.toObj(), null, 2));
+                    const logPromise = new Promise((res, rej) => {
+                        access.on("finish", () => { res(true); });
+                    });
+                    access.end();
+                    const numberOfFailures = Object.keys(suiteDone.givens).filter((k) => {
+                        // console.log(`suiteDone.givens[k].error`, suiteDone.givens[k].error);
+                        return suiteDone.givens[k].error;
+                    }).length;
+                    console.log(`exiting gracefully with ${numberOfFailures} failures.`);
+                    return {
+                        failed: numberOfFailures,
+                        artifacts: this.artifacts || [],
+                        logPromise
+                    };
+                },
+            };
+        });
+    }
+    Specs() {
+        return this.specs;
+    }
+    Suites() {
+        return this.suitesOverrides;
+    }
+    Given() {
+        return this.givenOverides;
+    }
+    When() {
+        return this.whenOverides;
+    }
+    Then() {
+        return this.thenOverides;
+    }
+    Check() {
+        return this.checkOverides;
+    }
+}