@usebruno/js 0.13.0 → 0.15.0

package/src/runtime/test-runtime.js

@@ -1,4 +1,4 @@
-const { NodeVM } = require('vm2');
+const { NodeVM } = require('@usebruno/vm2');
 const chai = require('chai');
 const path = require('path');
 const http = require('http');
@@ -15,7 +15,7 @@ const BrunoRequest = require('../bruno-request');
 const BrunoResponse = require('../bruno-response');
 const Test = require('../test');
 const TestResults = require('../test-results');
-const { cleanJson } = require('../utils');
+const { cleanJson, appendAwaitToTestFunc } = require('../utils');
 
 // Inbuilt Library Support
 const ajv = require('ajv');
@@ -29,17 +29,20 @@ const nanoid = require('nanoid');
 const axios = require('axios');
 const fetch = require('node-fetch');
 const CryptoJS = require('crypto-js');
-const NodeSecrets = require('node-vault');
+const NodeVault = require('node-vault');
+const { executeQuickJsVmAsync } = require('../sandbox/quickjs');
 
 class TestRuntime {
-  constructor() {}
+  constructor(props) {
+    this.runtime = props?.runtime || 'vm2';
+  }
 
   async runTests(
     testsFile,
     request,
     response,
     envVariables,
-    collectionVariables,
+    runtimeVariables,
     collectionPath,
     onConsoleLog,
     processEnvVars,
@@ -47,14 +50,16 @@ class TestRuntime {
     historyLogger,
     secretVariables
   ) {
+    const requestVariables = request?.requestVariables || {};
     const bru = new Bru(
       envVariables,
-      collectionVariables,
+      runtimeVariables,
       processEnvVars,
       collectionPath,
       historyLogger,
-      undefined, // setHtmlVisualizationString
-      secretVariables
+      undefined, // setVisualizations
+      secretVariables,
+      requestVariables
     );
     const req = new BrunoRequest(request, historyLogger);
     const res = new BrunoResponse(response);
@@ -84,11 +89,15 @@ class TestRuntime {
       return {
         request,
         envVariables,
-        collectionVariables,
-        results: __brunoTestResults.getResults()
+        runtimeVariables,
+        results: __brunoTestResults.getResults(),
+        nextRequestName: bru.nextRequest
       };
     }
 
+    // add 'await' prefix to the test function calls
+    testsFile = appendAwaitToTestFunc(testsFile);
+
     const context = {
       test,
       bru,
@@ -109,48 +118,56 @@ class TestRuntime {
         log: customLogger('log'),
         info: customLogger('info'),
         warn: customLogger('warn'),
+        debug: customLogger('debug'),
         error: customLogger('error')
       };
     }
 
-    const vm = new NodeVM({
-      sandbox: context,
-      require: {
-        context: 'sandbox',
-        external: true,
-        root: [collectionPath, ...additionalContextRootsAbsolute],
-        mock: {
-          // node libs
-          path,
-          stream,
-          util,
-          url,
-          http,
-          https,
-          punycode,
-          zlib,
-          // 3rd party libs
-          ajv,
-          'ajv-formats': addFormats,
-          btoa,
-          atob,
-          lodash,
-          moment,
-          uuid,
-          nanoid,
-          axios,
-          chai,
-          'node-fetch': fetch,
-          'crypto-js': CryptoJS,
-          ...whitelistedModules,
-          fs: allowScriptFilesystemAccess ? fs : undefined,
-          'node-vault': NodeSecrets
+    if (this.runtime === 'quickjs') {
+      await executeQuickJsVmAsync({
+        script: testsFile,
+        context: context
+      });
+    } else {
+      // default runtime is vm2
+      const vm = new NodeVM({
+        sandbox: context,
+        require: {
+          context: 'sandbox',
+          external: true,
+          root: [collectionPath, ...additionalContextRootsAbsolute],
+          mock: {
+            // node libs
+            path,
+            stream,
+            util,
+            url,
+            http,
+            https,
+            punycode,
+            zlib,
+            // 3rd party libs
+            ajv,
+            'ajv-formats': addFormats,
+            btoa,
+            atob,
+            lodash,
+            moment,
+            uuid,
+            nanoid,
+            axios,
+            chai,
+            'node-fetch': fetch,
+            'crypto-js': CryptoJS,
+            ...whitelistedModules,
+            fs: allowScriptFilesystemAccess ? fs : undefined,
+            'node-vault': NodeVault
+          }
         }
-      }
-    });
-
-    const asyncVM = vm.run(`module.exports = async () => { ${testsFile}}`, path.join(collectionPath, 'vm.js'));
-    await asyncVM();
+      });
+      const asyncVM = vm.run(`module.exports = async () => { ${testsFile}}`, path.join(collectionPath, 'vm.js'));
+      await asyncVM();
+    }
 
     if (historyLogger) {
       historyLogger({
@@ -164,8 +181,9 @@ class TestRuntime {
     return {
       request,
       envVariables: cleanJson(envVariables),
-      collectionVariables: cleanJson(collectionVariables),
-      results: cleanJson(__brunoTestResults.getResults())
+      runtimeVariables: cleanJson(runtimeVariables),
+      results: cleanJson(__brunoTestResults.getResults()),
+      nextRequestName: bru.nextRequest
     };
   }
 }

package/src/runtime/vars-runtime.js

@@ -3,17 +3,42 @@ const Bru = require('../bru');
 const BrunoRequest = require('../bruno-request');
 const { evaluateJsTemplateLiteral, evaluateJsExpression, createResponseParser } = require('../utils');
 
+const { executeQuickJsVm } = require('../sandbox/quickjs');
+
+const evaluateJsTemplateLiteralBasedOnRuntime = (literal, context, runtime) => {
+  if (runtime === 'quickjs') {
+    return executeQuickJsVm({
+      script: literal,
+      context,
+      scriptType: 'template-literal'
+    });
+  }
+
+  return evaluateJsTemplateLiteral(literal, context);
+};
+
+const evaluateJsExpressionBasedOnRuntime = (expr, context, runtime, mode) => {
+  if (runtime === 'quickjs') {
+    return executeQuickJsVm({
+      script: expr,
+      context,
+      scriptType: 'expression'
+    });
+  }
+
+  return evaluateJsExpression(expr, context);
+};
+
 class VarsRuntime {
-  runPreRequestVars(
-    vars,
-    request,
-    envVariables,
-    collectionVariables,
-    collectionPath,
-    processEnvVars,
-    historyLogger,
-    secretVars = {}
-  ) {
+  constructor(props) {
+    this.runtime = props?.runtime || 'vm2';
+    this.mode = props?.mode || 'developer';
+  }
+
+  runPreRequestVars(vars, request, envVariables, runtimeVariables, collectionPath, processEnvVars, historyLogger, secretVars = {}) {
+    if (!request?.requestVariables) {
+      request.requestVariables = {};
+    }
     const enabledVars = _.filter(vars, (v) => v.enabled);
     if (!enabledVars.length) {
       return;
@@ -21,12 +46,13 @@ class VarsRuntime {
 
     const bru = new Bru(
       envVariables,
-      collectionVariables,
+      runtimeVariables,
       processEnvVars,
       null,
       historyLogger,
-      undefined, // setHtmlVisualizationString
-      secretVars
+      undefined, // setVisualizations
+      secretVars,
+      undefined, // requestVariables
     );
     const req = new BrunoRequest(request, historyLogger);
 
@@ -37,19 +63,15 @@ class VarsRuntime {
 
     const context = {
       ...envVariables,
-      ...collectionVariables,
+      ...runtimeVariables,
       ...secretVars,
       ...bruContext
     };
 
     _.each(enabledVars, (v) => {
-      const value = evaluateJsTemplateLiteral(v.value, context);
-      bru.setVar(v.name, value);
+      const value = evaluateJsTemplateLiteralBasedOnRuntime(v.value, context, this.runtime);
+      request?.requestVariables && (request.requestVariables[v.name] = value);
     });
-
-    return {
-      collectionVariables
-    };
   }
 
   runPostResponseVars(
@@ -57,12 +79,13 @@ class VarsRuntime {
     request,
     response,
     envVariables,
-    collectionVariables,
+    runtimeVariables,
     collectionPath,
     processEnvVars,
     historyLogger,
     secretVars = {}
   ) {
+    const requestVariables = request?.requestVariables || {};
     const enabledVars = _.filter(vars, (v) => v.enabled);
     if (!enabledVars.length) {
       return;
@@ -70,12 +93,13 @@ class VarsRuntime {
 
     const bru = new Bru(
       envVariables,
-      collectionVariables,
+      runtimeVariables,
       processEnvVars,
       null,
       historyLogger,
-      undefined, // setHtmlVisualizationString
-      secretVars
+      undefined, // setVisualizations
+      secretVars,
+      requestVariables
     );
     const req = new BrunoRequest(request, historyLogger);
     const res = createResponseParser(response);
@@ -88,19 +112,32 @@ class VarsRuntime {
 
     const context = {
       ...envVariables,
-      ...collectionVariables,
+      ...runtimeVariables,
       ...secretVars,
       ...bruContext
     };
 
+    const errors = new Map();
     _.each(enabledVars, (v) => {
-      const value = evaluateJsExpression(v.value, context);
-      bru.setVar(v.name, value);
+      try {
+        const value = evaluateJsExpressionBasedOnRuntime(v.value, context, this.runtime);
+        bru.setVar(v.name, value);
+      } catch (error) {
+        errors.set(v.name, error);
+      }
     });
 
+    let error = null;
+    if (errors.size > 0) {
+      // Format all errors as a single string to be displayed in a toast
+      const errorMessage = [...errors.entries()].map(([name, err]) => `${name}: ${err.message ?? err}`).join('\n');
+      error = `${errors.size} error${errors.size === 1 ? '' : 's'} in post response variables: \n${errorMessage}`;
+    }
+
     return {
       envVariables,
-      collectionVariables
+      runtimeVariables,
+      error
     };
   }
 }