@usebruno/js 0.14.0 → 0.16.0

package/src/runtime/test-runtime.js

@@ -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,17 +50,10 @@ class TestRuntime {
     historyLogger,
     secretVariables
   ) {
+    const collectionVariables = request?.collectionVariables || {};
+    const folderVariables = request?.folderVariables || {};
     const requestVariables = request?.requestVariables || {};
-    const bru = new Bru(
-      envVariables,
-      collectionVariables,
-      processEnvVars,
-      collectionPath,
-      historyLogger,
-      undefined, // setHtmlVisualizationString
-      secretVariables,
-      requestVariables
-    );
+    const bru = new Bru(envVariables, runtimeVariables, processEnvVars, collectionPath, historyLogger, undefined, secretVariables, collectionVariables, folderVariables, requestVariables);
     const req = new BrunoRequest(request, historyLogger);
     const res = new BrunoResponse(response);
     const allowScriptFilesystemAccess = get(scriptingConfig, 'filesystemAccess.allow', false);
@@ -86,11 +82,13 @@ class TestRuntime {
       return {
         request,
         envVariables,
-        collectionVariables,
-        results: __brunoTestResults.getResults()
+        runtimeVariables,
+        results: __brunoTestResults.getResults(),
+        nextRequestName: bru.nextRequest
       };
     }
 
+
     const context = {
       test,
       bru,
@@ -111,48 +109,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({
@@ -166,8 +172,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

@@ -1,67 +1,29 @@
 const _ = require('lodash');
 const Bru = require('../bru');
 const BrunoRequest = require('../bruno-request');
-const { evaluateJsTemplateLiteral, evaluateJsExpression, createResponseParser } = require('../utils');
+const { evaluateJsExpression, createResponseParser } = require('../utils');
 
-class VarsRuntime {
-  runPreRequestVars(
-    vars,
-    request,
-    envVariables,
-    collectionVariables,
-    collectionPath,
-    processEnvVars,
-    historyLogger,
-    secretVars = {}
-  ) {
-    if (!request?.requestVariables) {
-      request.requestVariables = {};
-    }
-    const enabledVars = _.filter(vars, (v) => v.enabled);
-    if (!enabledVars.length) {
-      return;
-    }
-
-    const bru = new Bru(
-      envVariables,
-      collectionVariables,
-      processEnvVars,
-      null,
-      historyLogger,
-      undefined, // setHtmlVisualizationString
-      secretVars
-    );
-    const req = new BrunoRequest(request, historyLogger);
+const { executeQuickJsVm } = require('../sandbox/quickjs');
 
-    const bruContext = {
-      bru,
-      req
-    };
+const evaluateJsExpressionBasedOnRuntime = (expr, context, runtime, mode) => {
+  if (runtime === 'quickjs') {
+    return executeQuickJsVm({
+      script: expr,
+      context,
+      scriptType: 'expression'
+    });
+  }
 
-    const context = {
-      ...envVariables,
-      ...collectionVariables,
-      ...secretVars,
-      ...bruContext
-    };
+  return evaluateJsExpression(expr, context);
+};
 
-    _.each(enabledVars, (v) => {
-      const value = evaluateJsTemplateLiteral(v.value, context);
-      request?.requestVariables && (request.requestVariables[v.name] = value);
-    });
+class VarsRuntime {
+  constructor(props) {
+    this.runtime = props?.runtime || 'vm2';
+    this.mode = props?.mode || 'developer';
   }
 
-  runPostResponseVars(
-    vars,
-    request,
-    response,
-    envVariables,
-    collectionVariables,
-    collectionPath,
-    processEnvVars,
-    historyLogger,
-    secretVars = {}
-  ) {
+  runPostResponseVars(vars, request, response, envVariables, runtimeVariables, collectionPath, processEnvVars, historyLogger, secretVars = {}) {
     const requestVariables = request?.requestVariables || {};
     const enabledVars = _.filter(vars, (v) => v.enabled);
     if (!enabledVars.length) {
@@ -70,11 +32,11 @@ class VarsRuntime {
 
     const bru = new Bru(
       envVariables,
-      collectionVariables,
+      runtimeVariables,
       processEnvVars,
       null,
       historyLogger,
-      undefined, // setHtmlVisualizationString
+      undefined, // setVisualizations
       secretVars,
       requestVariables
     );
@@ -89,7 +51,7 @@ class VarsRuntime {
 
     const context = {
       ...envVariables,
-      ...collectionVariables,
+      ...runtimeVariables,
       ...secretVars,
       ...bruContext
     };
@@ -97,7 +59,7 @@ class VarsRuntime {
     const errors = new Map();
     _.each(enabledVars, (v) => {
       try {
-        const value = evaluateJsExpression(v.value, context);
+        const value = evaluateJsExpressionBasedOnRuntime(v.value, context, this.runtime);
         bru.setVar(v.name, value);
       } catch (error) {
         errors.set(v.name, error);
@@ -113,7 +75,7 @@ class VarsRuntime {
 
     return {
       envVariables,
-      collectionVariables,
+      runtimeVariables,
       error
     };
   }