Fix CodeRun

- CodeRun has two module  vars which were global to the module, but they need to be scoped to the instance of the CodeRun class currently running otherwise multiple CodeRuns will complete and use the same vars. This could happen if a work execute 2 or more tests with CodeRuns in the same batch or a single test which has multiple CodeRun steps. This could also happen with multiple calls to child tests with CodeRuns.

- Additionally, the uncaughtException was not fully working because node needs the `unhandled-rejections=strict` param which will trigger this event when an uncaught exception is thrown.

- Move the uncaughtException callback to be inside the CodeRun eval function so it can bind with the scope of the function and have access to `this` so it can call this.resolve() and fail the test with the uncaughtException error message from node.

Author: Kyle Keating

package.json

@@ -5,7 +5,7 @@
   "private": false,
   "license": "MIT",
   "scripts": {
-    "worker:local:interval": "node src/main.js",
+    "worker:local:interval": "node --unhandled-rejections=strict src/main.js",
     "lint": "yarn eslint src/**",
     "format": "yarn prettier -w src/**",
     "check-format": "yarn prettier -c src/**",

src/models/actions/CodeRun.js

@@ -2,37 +2,36 @@ const { BaseAction } = require("./BaseAction");
 const { performance } = require("perf_hooks");
 const { NodeVM } = require("vm2");
 
-let resolve = null;
-let t0 = 0;
-
-process.on("uncaughtException", (e) => {
-  if (resolve) {
-    resolve({
-      actionReports: [
-        {
-          action: "Code.run",
-          success: false,
-          shortSummary: e.message || e,
-          longSummary: null,
-          time: performance.now() - t0,
-        },
-      ],
-    });
+class CodeRun extends BaseAction {
+  constructor(args) {
+    super(args);
+    this.resolve = null;
+    this.t0 = 0;
   }
-  // Do not delete!
-  //
-  // Used to catch asynchronous exceptions from inside of CodeRun that will otherwise
-  // not be caught by try/catch.
-  //
-  // The worker will crash if this event is not defined and an exception occurs in an
-  // asynchronous code run.
-});
 
-class CodeRun extends BaseAction {
   async eval(context) {
+    process.on("uncaughtException", (e) => {
+      // Used to catch asynchronous unhandled exceptions from inside of CodeRun.
+      // https://github.com/patriksimek/vm2#error-handling
+      if (this.resolve) {
+        this.resolve({
+          actionReports: [
+            {
+              action: "Code.run",
+              success: false,
+              shortSummary: e.message || e,
+              longSummary: null,
+              time: performance.now() - this.t0,
+            },
+          ],
+        });
+      }
+    });
+
     return new Promise((_resolve) => {
-      resolve = _resolve;
-      t0 = performance.now();
+      this.resolve = _resolve;
+      this.kyle = 1;
+      this.t0 = performance.now();
       const vm = new NodeVM({
         timeout: 60000,
         eval: false,
@@ -69,7 +68,7 @@ class CodeRun extends BaseAction {
             });
 
             // happy path
-            resolve({
+            this.resolve({
               contextWrites,
               actionReports: [
                 {
@@ -83,35 +82,35 @@ class CodeRun extends BaseAction {
                     null,
                     4
                   ),
-                  time: performance.now() - t0,
+                  time: performance.now() - this.t0,
                 },
               ],
             });
           })
           .catch((e) => {
             // error inside async code run that returns a promise
-            resolve({
+            this.resolve({
               actionReports: [
                 {
                   action: "Code.run",
                   success: false,
                   shortSummary: e.message || e,
                   longSummary: null,
-                  time: performance.now() - t0,
+                  time: performance.now() - this.t0,
                 },
               ],
             });
           });
       } catch (e) {
         // error inside sync code run that returns an object
-        resolve({
+        this.resolve({
           actionReports: [
             {
               action: "Code.run",
               success: false,
               shortSummary: e.message || e,
               longSummary: null,
-              time: performance.now() - t0,
+              time: performance.now() - this.t0,
             },
           ],
         });