testeranto 0.47.30 → 0.47.32

package/dist/module/Project.js

@@ -53,19 +53,19 @@ export class ITProject {
                 });
                 console.table(procsTable);
                 console.table(this.resourceQueue);
-                // console.log("webSocketServer.clients", webSocketServer.clients.size);
-                // console.log("resourceQueue", this.resourceQueue);
+                console.log("webSocketServer.clients", Object.keys(this.websockets));
                 const resourceRequest = this.resourceQueue.pop();
                 if (!resourceRequest) {
                     if (!this.devMode && this.mode === "up") {
                         this.initiateShutdown("resource request queue is empty");
                     }
-                    if (this.mode === "down" && procsTable.every((p) => p.pid === 0 || p.pid === undefined)) {
+                    if (this.mode === "down" &&
+                        (procsTable.every((p) => p.pid === 0 || p.pid === undefined) ||
+                            procsTable.length === 0)) {
                         this.shutdown();
                     }
                 }
                 else {
-                    console.log("handling", resourceRequest);
                     if (resourceRequest.protocol === "ipc") {
                         this.allocateViaIpc(resourceRequest);
                     }
@@ -89,13 +89,6 @@ export class ITProject {
                         console.log(this.spinner(), "Shutdown is in progress. Please wait.");
                     }
                 }
-                // console.log(this.spinner());
-                // console.log(
-                //   this.spinner(),
-                //   this.mode === `up`
-                //     ? `press "q" to initiate graceful shutdown`
-                //     : `please wait while testeranto shuts down gracefully...`
-                // );
             });
         };
         this.clearScreen = config.clearScreen;
@@ -113,6 +106,12 @@ export class ITProject {
                 this.initiateShutdown("'q' command");
             }
         });
+        process.stdin.on('keypress', (str, key) => {
+            if (key.name === 'x') {
+                console.log("Shutting down hard!");
+                process.exit(-1);
+            }
+        });
         import(testPath).then((tests) => {
             this.tests = tests.default;
             import(featurePath).then((features) => {
@@ -181,6 +180,7 @@ export class ITProject {
                             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);
                                     // HERE: somehow restart the server from here, e.g., by sending a signal that you trap and react to inside the server.
                                 });
@@ -230,6 +230,7 @@ export class ITProject {
                             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);
                                     // HERE: somehow restart the server from here, e.g., by sending a signal that you trap and react to inside the server.
                                 });
@@ -286,141 +287,159 @@ export class ITProject {
                     esbuild.context(esbuildConfigWeb).then(async (esbuildWeb) => {
                         await esbuildWeb.watch();
                     })
-                ]);
-                pm2.connect(async (err) => {
-                    if (err) {
-                        console.error(err);
-                        process.exit(-1);
+                ]).then(() => {
+                    if (config.devMode === false) {
+                        console.log("Your tests were built but not run because devMode was false. Exiting gracefully");
+                        process.exit(0);
                     }
                     else {
-                        console.log(`pm2 is connected`);
-                    }
-                    // run a websocket as an alternative to node IPC
-                    webSocketServer = new WebSocketServer({
-                        port: 8080,
-                        host: "localhost",
-                    });
-                    webSocketServer.on('open', () => {
-                        console.log('open');
-                        // process.exit()
-                    });
-                    webSocketServer.on('close', (data) => {
-                        console.log('webSocketServer close: %s', data);
-                        // process.exit()
-                    });
-                    webSocketServer.on('listening', () => {
-                        console.log("webSocketServer listening", webSocketServer.address());
-                        // process.exit()
-                    });
-                    webSocketServer.on('connection', (webSocket) => {
-                        console.log('webSocketServer connection');
-                        webSocket.on('message', (webSocketData) => {
-                            console.log('webSocket message: %s', webSocketData);
-                            const payload = webSocketData.valueOf();
-                            const name = payload.data.name;
-                            const messageType = payload.type;
-                            const requestedResources = payload.data;
-                            this.websockets[name] = webSocket;
-                            console.log('connected: ' + name + ' in ' + Object.getOwnPropertyNames(this.websockets));
-                            if (messageType === "testeranto:hola") {
-                                console.log("hola WS", requestedResources);
-                                this.requestResource(requestedResources, 'ws');
+                        pm2.connect(async (err) => {
+                            if (err) {
+                                console.error(err);
+                                process.exit(-1);
                             }
-                            else if (messageType === "testeranto:adios") {
-                                console.log("adios WS", name);
-                                this.releaseTestResources(payload);
+                            else {
+                                console.log(`pm2 is connected`);
                             }
-                        });
-                    });
-                    const makePath = (fPath, rt) => {
-                        return path.resolve("./" + config.outdir + "/" + fPath.replace(path.extname(fPath), "") + ".mjs");
-                    };
-                    const bootInterval = setInterval(async () => {
-                        const filesToLookup = this.tests
-                            .map(([p, rt]) => {
-                            const filepath = makePath(p, rt);
-                            return {
-                                filepath,
-                                exists: fsExists(filepath),
-                            };
-                        });
-                        const allFilesExist = (await Promise.all(filesToLookup.map((f) => f.exists))).every((b) => b);
-                        if (!allFilesExist) {
-                            console.log(this.spinner(), "waiting for files to build...");
-                            filesToLookup.forEach((f) => {
-                                console.log(f.exists, "\t", f.filepath);
+                            // run a websocket as an alternative to node IPC
+                            webSocketServer = new WebSocketServer({
+                                port: 8080,
+                                host: "localhost",
                             });
-                        }
-                        else {
-                            clearInterval(bootInterval);
-                            pm2.launchBus((err, pm2_bus) => {
-                                pm2_bus.on("testeranto:hola", (packet) => {
-                                    console.log("hola IPC", packet);
-                                    this.requestResource(packet.data.requirement, 'ipc');
-                                });
-                                pm2_bus.on("testeranto:adios", (payload) => {
-                                    console.log("adios IPC", payload);
-                                    this.releaseTestResources(payload.data);
+                            webSocketServer.on('open', () => {
+                                console.log('open');
+                                // process.exit()
+                            });
+                            webSocketServer.on('close', (data) => {
+                                console.log('webSocketServer close: %s', data);
+                                // process.exit()
+                            });
+                            webSocketServer.on('listening', () => {
+                                console.log("webSocketServer listening", webSocketServer.address());
+                                // process.exit()
+                            });
+                            webSocketServer.on('connection', (webSocket) => {
+                                console.log('webSocketServer connection');
+                                webSocket.on('message', (webSocketData) => {
+                                    // console.log('webSocket message: %s', webSocketData);
+                                    const payload = JSON.parse(webSocketData.valueOf().toString());
+                                    // console.log('webSocket payload', JSON.stringify(payload.data.testResourceConfiguration.name, null, 2));
+                                    //  as {
+                                    //   type: string,
+                                    //   data: ITTestResourceRequirement & {
+                                    //     testResourceConfiguration: {
+                                    //       name: string;
+                                    //     }
+                                    //   }
+                                    // };
+                                    const messageType = payload.type;
+                                    if (messageType === "testeranto:hola") {
+                                        const name = payload.data.requirement.name;
+                                        const requestedResources = payload.data;
+                                        this.websockets[name] = webSocket;
+                                        console.log('hola WS! connected: ' + name + ' in ' + Object.getOwnPropertyNames(this.websockets));
+                                        this.requestResource(requestedResources.requirement, 'ws');
+                                    }
+                                    else if (messageType === "testeranto:adios") {
+                                        console.log("adios WS", payload.data.testResourceConfiguration.name);
+                                        this.releaseTestResourceWs(payload);
+                                    }
                                 });
                             });
-                            this
-                                .tests
-                                .reduce((m, [inputFilePath, runtime]) => {
-                                const script = makePath(inputFilePath, runtime);
-                                const partialTestResourceByCommandLineArg = `${script} '${JSON.stringify({
-                                    name: inputFilePath,
-                                    ports: [],
-                                    fs: path.resolve(process.cwd(), config.outdir, inputFilePath),
-                                })}'`;
-                                if (runtime === "web") {
-                                    const fileAsList = inputFilePath.split("/");
-                                    const fileListHead = fileAsList.slice(0, -1);
-                                    const fname = fileAsList[fileAsList.length - 1];
-                                    const fnameOnly = fname.split(".").slice(0, -1).join(".");
-                                    const htmlFile = [config.outdir, ...fileListHead, `${fnameOnly}.html`].join("/");
-                                    const jsFile = htmlFile.split(".html")[0] + ".mjs";
-                                    console.log("watching", jsFile);
-                                    pm2.start({
-                                        script: `yarn electron node_modules/testeranto/dist/common/electron.js ${htmlFile} '${JSON.stringify({
-                                            name: inputFilePath,
-                                            ports: [],
-                                            fs: path.resolve(process.cwd(), config.outdir, inputFilePath),
-                                        })}'`,
-                                        name: inputFilePath,
-                                        autorestart: false,
-                                        args: partialTestResourceByCommandLineArg,
-                                        watch: [jsFile],
-                                    }, (err, proc) => {
-                                        if (err) {
-                                            console.error(err);
-                                            return pm2.disconnect();
-                                        }
+                            const makePath = (fPath, rt) => {
+                                return path.resolve("./" + config.outdir + "/" + fPath.replace(path.extname(fPath), "") + ".mjs");
+                            };
+                            const bootInterval = setInterval(async () => {
+                                const filesToLookup = this.tests
+                                    .map(([p, rt]) => {
+                                    const filepath = makePath(p, rt);
+                                    return {
+                                        filepath,
+                                        exists: fsExists(filepath),
+                                    };
+                                });
+                                const allFilesExist = (await Promise.all(filesToLookup.map((f) => f.exists))).every((b) => b);
+                                if (!allFilesExist) {
+                                    console.log(this.spinner(), "waiting for files to build...");
+                                    filesToLookup.forEach((f) => {
+                                        console.log(f.exists, "\t", f.filepath);
                                     });
                                 }
-                                else if (runtime === "node") {
-                                    pm2.start({
-                                        name: inputFilePath,
-                                        script: `node ${script} '${JSON.stringify({
+                                else {
+                                    clearInterval(bootInterval);
+                                    pm2.launchBus((err, pm2_bus) => {
+                                        pm2_bus.on("testeranto:hola", (packet) => {
+                                            console.log("hola IPC", packet);
+                                            this.requestResource(packet.data.requirement, 'ipc');
+                                        });
+                                        pm2_bus.on("testeranto:adios", (payload) => {
+                                            this.releaseTestResourcePm2(payload.data);
+                                        });
+                                    });
+                                    this
+                                        .tests
+                                        .reduce((m, [inputFilePath, runtime]) => {
+                                        const script = makePath(inputFilePath, runtime);
+                                        const partialTestResourceByCommandLineArg = `${script} '${JSON.stringify({
                                             name: inputFilePath,
                                             ports: [],
                                             fs: path.resolve(process.cwd(), config.outdir, inputFilePath),
-                                        })}'`,
-                                        autorestart: false,
-                                        watch: [script],
-                                        args: partialTestResourceByCommandLineArg
-                                    }, (err, proc) => {
-                                        if (err) {
-                                            console.error(err);
-                                            return pm2.disconnect();
+                                        })}'`;
+                                        if (runtime === "web") {
+                                            const fileAsList = inputFilePath.split("/");
+                                            const fileListHead = fileAsList.slice(0, -1);
+                                            const fname = fileAsList[fileAsList.length - 1];
+                                            const fnameOnly = fname.split(".").slice(0, -1).join(".");
+                                            const htmlFile = [config.outdir, ...fileListHead, `${fnameOnly}.html`].join("/");
+                                            const jsFile = path.resolve(htmlFile.split(".html")[0] + ".mjs");
+                                            console.log("watching", jsFile);
+                                            pm2.start({
+                                                script: `yarn electron node_modules/testeranto/dist/common/electron.js ${htmlFile} '${JSON.stringify({
+                                                    scheduled: true,
+                                                    name: inputFilePath,
+                                                    ports: [],
+                                                    fs: path.resolve(process.cwd(), config.outdir, inputFilePath),
+                                                })}'`,
+                                                name: inputFilePath,
+                                                autorestart: false,
+                                                args: partialTestResourceByCommandLineArg,
+                                                watch: [jsFile],
+                                            }, (err, proc) => {
+                                                if (err) {
+                                                    console.error(err);
+                                                    return pm2.disconnect();
+                                                }
+                                            });
                                         }
-                                    });
+                                        else if (runtime === "node") {
+                                            const resolvedPath = path.resolve(script);
+                                            console.log("watching", resolvedPath);
+                                            pm2.start({
+                                                name: inputFilePath,
+                                                script: `node ${resolvedPath} '${JSON.stringify({
+                                                    scheduled: true,
+                                                    name: inputFilePath,
+                                                    ports: [],
+                                                    fs: path.resolve(process.cwd(), config.outdir, inputFilePath),
+                                                })}'`,
+                                                autorestart: false,
+                                                watch: [resolvedPath],
+                                                args: partialTestResourceByCommandLineArg
+                                            }, (err, proc) => {
+                                                if (err) {
+                                                    console.error(err);
+                                                    return pm2.disconnect();
+                                                }
+                                            });
+                                        }
+                                        this.exitCodes[inputFilePath] = null;
+                                        return [inputFilePath, ...m];
+                                    }, []);
+                                    setInterval(this.mainLoop, TIMEOUT).unref();
                                 }
-                                this.exitCodes[inputFilePath] = null;
-                                return [inputFilePath, ...m];
-                            }, []);
-                            setInterval(this.mainLoop, TIMEOUT).unref();
-                        }
-                    }, TIMEOUT).unref();
+                            }, TIMEOUT).unref();
+                        });
+                    }
                 });
             });
         });
@@ -444,21 +463,54 @@ export class ITProject {
         this.mode = "down";
     }
     shutdown() {
-        console.log("Stopping PM2");
-        pm2.stop("all", (e) => console.error(e));
-        pm2.killDaemon((e) => console.error(e));
-        pm2.disconnect();
-        process.exit();
+        let i = 0;
+        new Promise((res, reh) => {
+            console.log("final results: ");
+            const procsTable = [];
+            pm2.list((err, procs) => {
+                procs.forEach((proc, ndx) => {
+                    const exitCode = this.exitCodes[proc.name];
+                    if (exitCode !== 0) {
+                        i++;
+                    }
+                    procsTable.push({
+                        name: proc.name,
+                        pm_id: proc.pm_id,
+                        exitCode
+                    });
+                    if (ndx === procs.length - 1) {
+                        console.table(procsTable);
+                        res(i);
+                    }
+                });
+            });
+        }).then((failures) => {
+            console.log("Stopping PM2");
+            pm2.stop("all", (e) => console.error(e));
+            // pm2.killDaemon((e) => console.error(e));
+            pm2.disconnect();
+            console.log(`gracefully exiting with ${failures} failures`);
+            process.exit(failures);
+        });
     }
     spinner() {
         this.spinCycle = (this.spinCycle + 1) % this.spinAnimation.length;
         return this.spinAnimation[this.spinCycle];
     }
-    async releaseTestResources(payload) {
+    async releaseTestResourceWs(payload) {
+        const name = payload.data.testResourceConfiguration.name;
+        const failed = payload.data.failed;
+        this.exitCodes[name] = failed;
+        Object.keys(this.ports).forEach((port) => {
+            if (this.ports[port] === name) {
+                this.ports[port] = OPEN_PORT;
+            }
+        });
+    }
+    async releaseTestResourcePm2(payload) {
         const name = payload.testResourceConfiguration.name;
         const failed = payload.failed;
-        console.log("releaseTestResources", name, failed);
-        // reset ports
+        this.exitCodes[name] = failed;
         pm2.list((err, processes) => {
             processes.forEach((proc) => {
                 if (proc.name === name) {
@@ -470,86 +522,55 @@ export class ITProject {
                 }
             });
         });
-        this.exitCodes[name] = failed;
     }
     allocateViaWs(resourceRequest) {
-        const pName = resourceRequest.requirement.name;
+        const name = resourceRequest.requirement.name;
         const testResourceRequirement = resourceRequest.requirement;
-        pm2.list((err, processes) => {
-            console.error(err);
-            processes.forEach((p) => {
-                if (p.name === pName && p.pid) {
-                    const message = {
-                        // these fields must be present
-                        id: p.pid,
-                        topic: "some topic",
-                        type: "process:msg",
-                        // Data to be sent
-                        data: {
-                            testResourceConfiguration: {
-                                ports: [],
-                                // fs: fPath,
-                            },
-                            id: p.pm_id,
+        const websocket = this.websockets[name];
+        if ((testResourceRequirement === null || testResourceRequirement === void 0 ? void 0 : testResourceRequirement.ports) === 0) {
+            websocket.send(JSON.stringify({
+                data: {
+                    testResourceConfiguration: {
+                        ports: [],
+                    },
+                }
+            }));
+        }
+        else if (((testResourceRequirement === null || testResourceRequirement === void 0 ? void 0 : testResourceRequirement.ports) || 0) > 0) {
+            // clear any port-slots associated with this job
+            Object.values(this.ports).forEach((jobMaybe, portNumber) => {
+                if (jobMaybe && jobMaybe === name) {
+                    this.ports[portNumber] = OPEN_PORT;
+                }
+            });
+            // find a list of open ports
+            const foundOpenPorts = Object.keys(this.ports).filter((p) => this.ports[p] === OPEN_PORT);
+            if (foundOpenPorts.length >= testResourceRequirement.ports) {
+                const selectionOfPorts = foundOpenPorts.slice(0, testResourceRequirement.ports);
+                websocket.send(JSON.stringify({
+                    data: {
+                        testResourceConfiguration: {
+                            ports: selectionOfPorts,
                         },
-                    };
-                    if ((testResourceRequirement === null || testResourceRequirement === void 0 ? void 0 : testResourceRequirement.ports) === 0) {
-                        pm2.sendDataToProcessId(p.pid, message, function (err, res) {
-                            // console.log("sendDataToProcessId", err, res, message);
-                        });
-                    }
-                    if (((testResourceRequirement === null || testResourceRequirement === void 0 ? void 0 : testResourceRequirement.ports) || 0) > 0) {
-                        // clear any port-slots associated with this job
-                        Object.values(this.ports).forEach((jobMaybe, portNumber) => {
-                            if (jobMaybe && jobMaybe === pName) {
-                                this.ports[portNumber] = OPEN_PORT;
-                            }
-                        });
-                        // find a list of open ports
-                        const foundOpenPorts = Object.keys(this.ports).filter((p) => this.ports[p] === OPEN_PORT);
-                        // if there are enough open port-slots...
-                        if (foundOpenPorts.length >= testResourceRequirement.ports) {
-                            const selectionOfPorts = foundOpenPorts.slice(0, testResourceRequirement.ports);
-                            const message = {
-                                // these fields must be present
-                                id: p.pid,
-                                topic: "some topic",
-                                // process:msg will be send as 'message' on target process
-                                type: "process:msg",
-                                // Data to be sent
-                                data: {
-                                    testResourceConfiguration: {
-                                        // fs: fPath,
-                                        ports: selectionOfPorts,
-                                    },
-                                    id: p.pid,
-                                },
-                            };
-                            pm2.sendDataToProcessId(p.pid, message, function (err, res) {
-                                // no-op
-                            });
-                            // mark the selected ports as occupied
-                            for (const foundOpenPort of selectionOfPorts) {
-                                this.ports[foundOpenPort] = p.pid.toString();
-                            }
-                        }
-                        else {
-                            console.log(`no port was open so send the ${p.pid} job to the back of the resourceQueue`);
-                            this.resourceQueue.push(resourceRequest);
-                        }
                     }
+                }));
+                // mark the selected ports as occupied
+                for (const foundOpenPort of selectionOfPorts) {
+                    this.ports[foundOpenPort] = name;
                 }
-            });
-        });
+            }
+            else {
+                console.log(`no port was open so send the ${name} job to the back of the resourceQueue`);
+                this.resourceQueue.push(resourceRequest);
+            }
+        }
     }
     allocateViaIpc(resourceRequest) {
-        console.log("allocateViaIpc", resourceRequest);
         const pName = resourceRequest.requirement.name;
         const testResourceRequirement = resourceRequest.requirement;
         pm2.list((err, processes) => {
             console.error(err);
             processes.forEach((p) => {
-                console.log("p.pid, p.name, p.pm_id", p.pid, p.name, p.pm_id);
                 if (p.name === pName && p.pid) {
                     const message = {
                         // these fields must be present
@@ -565,7 +586,6 @@ export class ITProject {
                             id: p.pm_id,
                         },
                     };
-                    console.log("message", message);
                     if ((testResourceRequirement === null || testResourceRequirement === void 0 ? void 0 : testResourceRequirement.ports) === 0) {
                         pm2.sendDataToProcessId(p.pm_id, message, function (err, res) {
                             // console.log("sendDataToProcessId", err, res, message);

package/dist/module/Web.js

@@ -1,8 +1,14 @@
 import { defaultTestResourceRequirement, } from "./core";
 import TesterantoLevelTwo from "./core";
-// import { ipcRenderer } from "electron";
 const webSocket = new WebSocket("ws://localhost:8080");
-const receiveTestResourceConfig = async (t, testresource) => {
+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",
@@ -30,12 +36,10 @@ export default async (input, testSpecification, testImplementation, testInterfac
     const testResourceArg = decodeURIComponent(new URLSearchParams(location.search).get('requesting') || '');
     try {
         const partialTestResource = JSON.parse(testResourceArg);
-        if (partialTestResource.fs && partialTestResource.ports) {
-            receiveTestResourceConfig(t, partialTestResource);
-        }
-        else {
-            console.log("test configuration is incomplete", partialTestResource);
-            console.log("requesting test resources via ws", testResourceRequirement);
+        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);
@@ -43,20 +47,62 @@ export default async (input, testSpecification, testImplementation, testInterfac
                 const r = JSON.stringify({
                     type: "testeranto:hola",
                     data: {
-                        testResourceRequirement,
+                        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 resourcesFromPm2 = msg.data.testResourceConfiguration;
-                    const secondTestResource = Object.assign(Object.assign({ fs: "." }, JSON.parse(JSON.stringify(partialTestResource))), JSON.parse(JSON.stringify(resourcesFromPm2)));
-                    console.log("secondTestResource", secondTestResource);
-                    receiveTestResourceConfig(t, secondTestResource);
+                    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);
+        //       }
+        //     );
+        //   });
+        // }
     }
     catch (e) {
         console.error(e);