testeranto 0.47.33 → 0.47.52

package/dist/module/Web.js

@@ -1,111 +1,34 @@
-import { defaultTestResourceRequirement, } from "./core";
-import TesterantoLevelTwo from "./core";
-const webSocket = new WebSocket("ws://localhost:8080");
-const receiveTestResourceConfigUnscheduled = async (t, testresource) => {
-    const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(testresource);
-    Promise.all([...artifacts, logPromise]).then(async () => {
-        // ipcRenderer.invoke('quit-app', failed);
-        window.exit(failed);
-    });
-};
-const receiveTestResourceConfigScheduled = async (t, testresource) => {
-    const { failed, artifacts, logPromise } = await t.receiveTestResourceConfig(testresource);
-    webSocket.send(JSON.stringify({
-        type: "testeranto:adios",
-        data: {
-            failed,
-            testResourceConfiguration: t.test.testResourceConfiguration,
-            results: t.toObj(),
-        },
-    }));
-    Promise.all([...artifacts, logPromise]).then(async () => {
-        // ipcRenderer.invoke('quit-app', failed);
-        window.exit(failed);
-    });
-};
-export default async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {
-    const mrt = new TesterantoLevelTwo(input, testSpecification, testImplementation, testInterface, testResourceRequirement, testInterface.assertioner || (async (t) => t), testInterface.beforeEach ||
-        async function (subject, initialValues, testResource) {
-            return subject;
-        }, testInterface.afterEach || (async (s) => s), testInterface.afterAll || ((store) => undefined), testInterface.butThen || (async (a) => a), testInterface.andWhen, testInterface.actionHandler ||
-        function (b) {
-            return b;
-        }, window.NodeWriter);
-    const tl2 = mrt;
-    const t = tl2.testJobs[0];
-    const testResourceArg = decodeURIComponent(new URLSearchParams(location.search).get('requesting') || '');
-    try {
-        const partialTestResource = JSON.parse(testResourceArg);
-        console.log("initial test resource", partialTestResource);
-        if (partialTestResource.scheduled) {
-            console.log("test is scheduled");
-            console.log("awaiting test resources via WS...");
-            webSocket.addEventListener("open", (event) => {
-                webSocket.addEventListener("message", (event) => {
-                    console.log("Message from server ", event.data);
-                });
-                const r = JSON.stringify({
-                    type: "testeranto:hola",
-                    data: {
-                        requirement: Object.assign(Object.assign({}, testResourceRequirement), { name: partialTestResource.name })
-                    },
-                });
-                webSocket.send(r);
-                console.log("awaiting test resources via websocket...", r);
-                webSocket.onmessage = (async (msg) => {
-                    console.log("message: ", msg);
-                    const resourcesFromWs = JSON.parse(msg.data);
-                    console.log("secondary test resource", resourcesFromWs);
-                    const secondTestResource = Object.assign(Object.assign({ fs: "." }, JSON.parse(JSON.stringify(partialTestResource))), JSON.parse(JSON.stringify(resourcesFromWs)));
-                    console.log("final test resource", secondTestResource);
-                    receiveTestResourceConfigScheduled(t, secondTestResource);
-                });
-            });
-        }
-        else {
-            receiveTestResourceConfigUnscheduled(t, partialTestResource);
-        }
-        // const partialTestResource = JSON.parse(
-        //   testResourceArg
-        // ) as ITTestResourceConfiguration;
-        // if (partialTestResource.fs && partialTestResource.ports) {
-        //   receiveTestResourceConfig(t, partialTestResource);
-        // } else {
-        //   console.log("test configuration is incomplete", partialTestResource);
-        //   console.log(
-        //     "requesting test resources via ws",
-        //     testResourceRequirement
-        //   );
-        //   webSocket.addEventListener("open", (event) => {
-        //     webSocket.addEventListener("message", (event) => {
-        //       console.log("Message from server ", event.data);
-        //     });
-        //     const r = JSON.stringify({
-        //       type: "testeranto:hola",
-        //       data: {
-        //         testResourceRequirement,
-        //       },
-        //     });
-        //     webSocket.send(r);
-        //     console.log("awaiting test resources via websocket...", r);
-        //     webSocket.onmessage = (
-        //       async (msg: MessageEvent<any>) => {
-        //         console.log("message: ", msg);
-        //         const resourcesFromPm2 = msg.data.testResourceConfiguration;
-        //         const secondTestResource = {
-        //           fs: ".",
-        //           ...JSON.parse(JSON.stringify(partialTestResource)),
-        //           ...JSON.parse(JSON.stringify(resourcesFromPm2)),
-        //         } as ITTestResourceConfiguration;
-        //         console.log("secondTestResource", secondTestResource);
-        //         receiveTestResourceConfig(t, secondTestResource);
-        //       }
-        //     );
-        //   });
-        // }
+import { PM_Web } from "./PM/web";
+import Testeranto from "./lib/core.js";
+import { defaultTestResourceRequirement, } from "./lib/index.js";
+class WebTesteranto extends Testeranto {
+    constructor(input, testSpecification, testImplementation, testResourceRequirement, testInterface) {
+        super(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
     }
-    catch (e) {
-        console.error(e);
-        // process.exit(-1);
+    async receiveTestResourceConfig(partialTestResource) {
+        const t = partialTestResource; //JSON.parse(partialTestResource);
+        const pm = new PM_Web(t);
+        const { failed, artifacts, logPromise } = await this.testJobs[0].receiveTestResourceConfig(pm);
+        pm.customclose();
+        // Promise.all([...artifacts, logPromise]).then(async () => {
+        //   console.log("hello world");
+        //   pm.customclose();
+        //   // we can't close the window becuase we might be taking a screenshot
+        //   // window.close();
+        //   // console.log(
+        //   //   "(window as any).browser",
+        //   //   JSON.stringify(await (window as any).browser)
+        //   // );
+        //   // var currentWindow = (await (window as any).browser).getCurrentWindow();
+        //   // window.close();
+        //   // var customWindow = window.open("", "_blank", "");
+        //   // customWindow.close();
+        //   // this.puppetMaster.browser.page
+        //   // window["customclose"]();
+        //   // console.log("goodbye", window["customclose"]());
+        // });
     }
+}
+export default async (input, testSpecification, testImplementation, testInterface, testResourceRequirement = defaultTestResourceRequirement) => {
+    return new WebTesteranto(input, testSpecification, testImplementation, testResourceRequirement, testInterface);
 };

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,19 @@
+export default (config) => {
+    return {
+        // packages: "external",
+        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/inputFilesPlugin.js

@@ -0,0 +1,44 @@
+import fs from "fs";
+import path from "path";
+export default (platform, entryPoints) => {
+    return {
+        name: "metafileWriter",
+        setup(build) {
+            build.onEnd((result) => {
+                if (result.errors.length === 0) {
+                    entryPoints.forEach((entryPoint) => {
+                        const filePath = path.join("./docs/", platform, entryPoint.split(".").slice(0, -1).join("."), `inputFiles.json`);
+                        const dirName = path.dirname(filePath);
+                        if (!fs.existsSync(dirName)) {
+                            fs.mkdirSync(dirName, { recursive: true });
+                        }
+                        fs.writeFileSync(filePath, JSON.stringify(Object.keys(Object.keys(result.metafile.outputs)
+                            .filter((s) => {
+                            if (!result.metafile.outputs[s].entryPoint) {
+                                return false;
+                            }
+                            return (path.resolve(result.metafile.outputs[s].entryPoint) ===
+                                path.resolve(entryPoint));
+                        })
+                            .reduce((mm, el) => {
+                            mm.push(result.metafile.outputs[el].inputs);
+                            return mm;
+                        }, [])[0])
+                            .filter((f) => {
+                            const regex = /^src\/.*/g;
+                            const matches = f.match(regex);
+                            const passes = (matches === null || matches === void 0 ? void 0 : matches.length) === 1;
+                            return passes;
+                        })
+                            .filter((f) => {
+                            const regex = /.*\.test\..*/g;
+                            const matches = f.match(regex);
+                            const passes = (matches === null || matches === void 0 ? void 0 : matches.length) === 1;
+                            return !passes;
+                        })));
+                    });
+                }
+            });
+        },
+    };
+};

package/dist/module/esbuildConfigs/node.js

@@ -0,0 +1,34 @@
+import baseEsBuildConfig from "./index.js";
+import inputFilesPlugin from "./inputFilesPlugin";
+export default (config, entryPoints) => {
+    return Object.assign(Object.assign({}, baseEsBuildConfig(config)), { splitting: true, outdir: config.outdir + "/node", inject: [`./node_modules/testeranto/dist/cjs-shim.js`], metafile: true, 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 || []),
+            inputFilesPlugin("node", entryPoints),
+            {
+                name: "rebuild-notify",
+                setup(build) {
+                    build.onEnd((result) => {
+                        console.log(`node build ended with ${result.errors.length} errors`);
+                        if (result.errors.length > 0) {
+                            console.log(result);
+                        }
+                        // console.log(result);
+                        // result.errors.length !== 0 && process.exit(-1);
+                    });
+                },
+            },
+        ] });
+};

package/dist/module/esbuildConfigs/report.js

@@ -0,0 +1,14 @@
+"use strict";
+// import { BuildOptions } from "esbuild";
+// import { IBaseConfig } from "../lib/types";
+// 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: `${config.outdir}/report.js`,
+//     external: ["tests.json", "features.test.js"],
+//   };
+// };

package/dist/module/esbuildConfigs/tests.js

@@ -0,0 +1,11 @@
+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,52 @@
+import path from "path";
+import baseEsBuildConfig from "./index.js";
+import inputFilesPlugin from "./inputFilesPlugin.js";
+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);`,
+        // },
+        // splitting: true,
+        outdir: config.outdir + "/web", alias: {
+            react: path.resolve("./node_modules/react"),
+        }, metafile: true, external: [
+            "testeranto.json",
+            "features.test.ts",
+            // "url",
+            "react",
+            "path",
+            "fs",
+            "stream",
+            "http",
+            "constants",
+            "net",
+            "assert",
+            "tls",
+            "os",
+            "child_process",
+            "readline",
+            "zlib",
+            "crypto",
+            "https",
+            "util",
+            "process",
+            "dns",
+        ], platform: "browser", entryPoints: [...entryPoints], plugins: [
+            ...(config.webPlugins || []),
+            inputFilesPlugin("node", entryPoints),
+            {
+                name: "rebuild-notify",
+                setup(build) {
+                    build.onEnd((result) => {
+                        console.log(`web build ended with ${result.errors.length} errors`);
+                        if (result.errors.length > 0) {
+                            console.log(result);
+                        }
+                        // console.log(result);
+                        // result.errors.length !== 0 && process.exit(-1);
+                    });
+                },
+            },
+        ] });
+};