@usebruno/js 0.2.0 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@usebruno/js",
-  "version": "0.2.0",
+  "version": "0.4.0",
   "main": "src/index.js",
   "files": [
     "src",
@@ -14,14 +14,16 @@
   },
   "dependencies": {
     "@usebruno/query": "0.1.0",
-    "atob": "^2.1.2",
     "ajv": "^8.12.0",
+    "atob": "^2.1.2",
+    "axios": "^0.26.0",
     "btoa": "^1.2.1",
     "crypto-js": "^4.1.1",
     "json-query": "^2.2.2",
     "lodash": "^4.17.21",
     "moment": "^2.29.4",
     "nanoid": "3.3.4",
+    "node-fetch": "2.*",
     "uuid": "^9.0.0"
   }
-}
+}

package/src/bru.js

@@ -5,6 +5,10 @@ class Bru {
     this._collectionVariables = collectionVariables;
   }
 
+  getProcessEnv(key) {
+    return process.env[key];
+  }
+
   getEnvVar(key) {
     return this._envVariables[key];
   }
@@ -16,7 +20,7 @@ class Bru {
 
     // gracefully ignore if key is not present in environment
     if(!this._envVariables.hasOwnProperty(key)) {
-      return;
+       return;
     }
 
     this._envVariables[key] = value;
@@ -35,4 +39,4 @@ class Bru {
   }
 }
 
-module.exports = Bru;
+module.exports = Bru;

package/src/bruno-response.js

@@ -1,26 +1,26 @@
 class BrunoResponse {
   constructor(res) {
     this.res = res;
-    this.status = res.status;
-    this.statusText = res.statusText;
-    this.headers = res.headers;
-    this.body = res.data;
+    this.status = res ? res.status : null;
+    this.statusText = res ? res.statusText : null;
+    this.headers = res ? res.headers : null;
+    this.body = res ? res.data : null;
   }
 
   getStatus() {
-    return this.res.status;
+    return this.res ? this.res.status : null;
   }
 
   getHeader(name) {
-    return this.res.header[name];
+    return (this.res && this.res.headers) ? this.res.headers[name] : null;
   }
 
   getHeaders() {
-    return this.res.headers;
+    return this.res ? this.res.headers : null;
   }
 
   getBody() {
-    return this.res.data;
+    return this.res ? this.res.data : null;
   }
 }
 

package/src/runtime/assert-runtime.js

@@ -1,17 +1,49 @@
 const _ = require('lodash');
-const chai = require('chai');  
+const chai = require('chai');
+const { nanoid } = require('nanoid');
 const Bru = require('../bru');
 const BrunoRequest = require('../bruno-request');
-const { evaluateJsExpression, createResponseParser } = require('../utils');
+const { evaluateJsTemplateLiteral, evaluateJsExpression, createResponseParser } = require('../utils');
 
 const { expect } = chai;
+chai.use(function (chai, utils) {
+  // Custom assertion for checking if a variable is JSON
+  chai.Assertion.addProperty('json', function () {
+    const obj = this._obj;
+    const isJson = typeof obj === 'object' && obj !== null && !Array.isArray(obj) && obj.constructor === Object;
+
+    this.assert(
+      isJson,
+      `expected ${utils.inspect(obj)} to be JSON`,
+      `expected ${utils.inspect(obj)} not to be JSON`
+    );
+  });
+});
+
+// Custom assertion for matching regex
+chai.use(function (chai, utils) {
+  chai.Assertion.addMethod('match', function (regex) {
+    const obj = this._obj;
+    let match = false;
+    if(obj === undefined) {
+      match = false;
+    } else {
+      match = regex.test(obj);
+    }
+
+    this.assert(
+      match,
+      `expected ${utils.inspect(obj)} to match ${regex}`,
+      `expected ${utils.inspect(obj)} not to match ${regex}`
+    );
+  });
+});
 
 /**
  * Assertion operators
  * 
  * eq          : equal to
  * neq         : not equal to
- * like        : like
  * gt          : greater than
  * gte         : greater than or equal to
  * lt          : less than
@@ -20,7 +52,6 @@ const { expect } = chai;
  * notIn       : not in
  * contains    : contains
  * notContains : not contains
- * count       : count
  * length      : length
  * matches     : matches
  * notMatches  : not matches
@@ -47,15 +78,26 @@ const parseAssertionOperator = (str = '') => {
   }
 
   const operators = [
-    'eq', 'neq', 'like', 'gt', 'gte', 'lt', 'lte', 'in', 'notIn',
-    'contains', 'notContains', 'count', 'length', 'matches', 'notMatches',
+    'eq', 'neq', 'gt', 'gte', 'lt', 'lte', 'in', 'notIn',
+    'contains', 'notContains', 'length', 'matches', 'notMatches',
     'startsWith', 'endsWith', 'between', 'isEmpty', 'isNull', 'isUndefined',
     'isDefined', 'isTruthy', 'isFalsy', 'isJson', 'isNumber', 'isString', 'isBoolean'
   ];
 
+  const unaryOperators = [
+    'isEmpty', 'isNull', 'isUndefined', 'isDefined', 'isTruthy', 'isFalsy', 'isJson', 'isNumber', 'isString', 'isBoolean'
+  ];
+
   const [operator, ...rest] = str.trim().split(' ');
   const value = rest.join(' ');
 
+  if(unaryOperators.includes(operator)) {
+    return {
+      operator,
+      value: ''
+    };
+  }
+
   if(operators.includes(operator)) {
     return {
       operator,
@@ -69,6 +111,45 @@ const parseAssertionOperator = (str = '') => {
   };
 };
 
+const isUnaryOperator = (operator) => {
+  const unaryOperators = [
+    'isEmpty', 'isNull', 'isUndefined', 'isDefined', 'isTruthy', 'isFalsy', 'isJson', 'isNumber', 'isString', 'isBoolean'
+  ];
+
+  return unaryOperators.includes(operator);
+};
+
+const evaluateRhsOperand = (rhsOperand, operator, context) => {
+  if(isUnaryOperator(operator)) {
+    return;
+  }
+
+  // gracefully allow both a,b as well as [a, b]
+  if(operator === 'in' || operator === 'notIn') {
+    if(rhsOperand.startsWith('[') && rhsOperand.endsWith(']')) {
+      rhsOperand = rhsOperand.substring(1, rhsOperand.length - 1);
+    }
+
+    return rhsOperand.split(',').map((v) => evaluateJsTemplateLiteral(v.trim(), context));
+  }
+
+  if(operator === 'between') {
+    const [lhs, rhs] = rhsOperand.split(',').map((v) => evaluateJsTemplateLiteral(v.trim(), context));
+    return [lhs, rhs];
+  }
+
+  // gracefully allow both ^[a-Z] as well as /^[a-Z]/
+  if(operator === 'matches' || operator === 'notMatches') {
+    if(rhsOperand.startsWith('/') && rhsOperand.endsWith('/')) {
+      rhsOperand = rhsOperand.substring(1, rhsOperand.length - 1);
+    }
+
+    return rhsOperand;
+  }
+
+  return evaluateJsTemplateLiteral(rhsOperand, context);
+};
+
 class AssertRuntime {
   runAssertions(assertions, request, response, envVariables, collectionVariables, collectionPath) {
     const enabledAssertions = _.filter(assertions, (a) => a.enabled);
@@ -105,7 +186,7 @@ class AssertRuntime {
 
       try {
         const lhs = evaluateJsExpression(lhsExpr, context);
-        const rhs = evaluateJsExpression(rhsOperand, context);
+        const rhs = evaluateRhsOperand(rhsOperand, operator, context);
 
         switch(operator) {
           case 'eq':
@@ -114,9 +195,6 @@ class AssertRuntime {
           case 'neq':
             expect(lhs).to.not.equal(rhs);
             break;
-          case 'like':
-            expect(lhs).to.match(new RegExp(rhs));
-            break;
           case 'gt':
             expect(lhs).to.be.greaterThan(rhs);
             break;
@@ -141,9 +219,6 @@ class AssertRuntime {
           case 'notContains':
             expect(lhs).to.not.include(rhs);
             break;
-          case 'count':
-            expect(lhs).to.have.lengthOf(rhs);
-            break;
           case 'length':
             expect(lhs).to.have.lengthOf(rhs);
             break;
@@ -160,7 +235,7 @@ class AssertRuntime {
             expect(lhs).to.endWith(rhs);
             break;
           case 'between':
-            const [min, max] = value.split(' ');
+            const [min, max] = value.split(',');
             expect(lhs).to.be.within(min, max);
             break;
           case 'isEmpty':
@@ -199,6 +274,7 @@ class AssertRuntime {
         }
 
         assertionResults.push({
+          uid: nanoid(),
           lhsExpr,
           rhsExpr,
           rhsOperand,
@@ -208,6 +284,7 @@ class AssertRuntime {
       }
       catch (err) {
         assertionResults.push({
+          uid: nanoid(),
           lhsExpr,
           rhsExpr,
           rhsOperand,
@@ -222,4 +299,4 @@ class AssertRuntime {
   }
 }
 
-module.exports = AssertRuntime;
+module.exports = AssertRuntime;

package/src/runtime/script-runtime.js

@@ -1,5 +1,12 @@
 const { NodeVM } = require('vm2');
 const path = require('path');
+const http = require('http');
+const https = require('https');
+const stream = require('stream');
+const util = require('util');
+const zlib = require('zlib');
+const url = require('url');
+const punycode = require('punycode');
 const Bru = require('../bru');
 const BrunoRequest = require('../bruno-request');
 const BrunoResponse = require('../bruno-response');
@@ -11,16 +18,17 @@ const lodash = require('lodash');
 const moment = require('moment');
 const uuid = require('uuid');
 const nanoid = require('nanoid');
+const axios = require('axios');
+const fetch = require('node-fetch');
 const CryptoJS = require('crypto-js');
 
 class ScriptRuntime {
   constructor() {
   }
 
-  runRequestScript(script, request, environment, collectionVariables, collectionPath) {
-    const bru = new Bru(environment, collectionVariables);
+  async runRequestScript(script, request, envVariables, collectionVariables, collectionPath){
+    const bru = new Bru(envVariables, collectionVariables);
     const req = new BrunoRequest(request);
-
     const context = {
       bru,
       req
@@ -32,28 +40,39 @@ class ScriptRuntime {
         external: true,
         root: [collectionPath],
         mock: {
+          // node libs
+          path,
+          stream,
+          util,
+          url,
+          http,
+          https,
+          punycode,
+          zlib,
+          // 3rd party libs
           atob,
           btoa,
           lodash,
           moment,
           uuid,
           nanoid,
+          axios,
+          'node-fetch': fetch,
           'crypto-js': CryptoJS
         }
       }
     });
-
-    vm.run(script, path.join(collectionPath, 'vm.js'));
-
+    const asyncVM = vm.run(`module.exports = async () => { ${script} }`,  path.join(collectionPath, 'vm.js'));
+    await asyncVM();
     return {
       request,
-      environment,
+      envVariables,
       collectionVariables
     };
   }
 
-  runResponseScript(script, request, response, environment, collectionVariables, collectionPath) {
-    const bru = new Bru(environment, collectionVariables);
+  async runResponseScript(script, request, response, envVariables, collectionVariables, collectionPath) {
+    const bru = new Bru(envVariables, collectionVariables);
     const req = new BrunoRequest(request);
     const res = new BrunoResponse(response);
 
@@ -75,16 +94,19 @@ class ScriptRuntime {
           moment,
           uuid,
           nanoid,
+          axios,
+          'node-fetch': fetch,
           'crypto-js': CryptoJS
         }
       }
     });
 
-    vm.run(script, path.join(collectionPath, 'vm.js'));
+    const asyncVM = vm.run(`module.exports = async () => { ${script} }`,  path.join(collectionPath, 'vm.js'));
+    await asyncVM();
 
     return {
       response,
-      environment,
+      envVariables,
       collectionVariables
     };
   }

package/src/runtime/test-runtime.js

@@ -20,14 +20,23 @@ class TestRuntime {
   constructor() {
   }
 
-  runTests(testsFile, request, response, environment, collectionVariables, collectionPath) {
-    const bru = new Bru(environment, collectionVariables);
+  runTests(testsFile, request, response, envVariables, collectionVariables, collectionPath) {
+    const bru = new Bru(envVariables, collectionVariables);
     const req = new BrunoRequest(request);
     const res = new BrunoResponse(response);
 
     const __brunoTestResults = new TestResults();
     const test = Test(__brunoTestResults, chai);
 
+    if(!testsFile || !testsFile.length) {
+      return {
+        request,
+        envVariables,
+        collectionVariables,
+        results: __brunoTestResults.getResults()
+      };
+    }
+
     const context = {
       test,
       bru,
@@ -60,7 +69,7 @@ class TestRuntime {
 
     return {
       request,
-      environment,
+      envVariables,
       collectionVariables,
       results: __brunoTestResults.getResults()
     };

package/src/runtime/vars-runtime.js

@@ -1,7 +1,7 @@
 const _ = require('lodash');
 const Bru = require('../bru');
 const BrunoRequest = require('../bruno-request');
-const { evaluateJsExpression, createResponseParser } = require('../utils');
+const { evaluateJsTemplateLiteral, evaluateJsExpression, createResponseParser } = require('../utils');
 
 class VarsRuntime {
   runPreRequestVars(vars, request, envVariables, collectionVariables, collectionPath) {
@@ -25,9 +25,13 @@ class VarsRuntime {
     }
 
     _.each(enabledVars, (v) => {
-      const value = evaluateJsExpression(v.value, context);
+      const value = evaluateJsTemplateLiteral(v.value, context);
       bru.setVar(v.name, value);
     });
+
+    return {
+      collectionVariables
+    };
   }
 
   runPostResponseVars(vars, request, response, envVariables, collectionVariables, collectionPath) {
@@ -56,6 +60,11 @@ class VarsRuntime {
       const value = evaluateJsExpression(v.value, context);
       bru.setVar(v.name, value);
     });
+
+    return {
+      envVariables,
+      collectionVariables
+    };
   }
 }
 

package/src/utils.js

@@ -60,6 +60,46 @@ const evaluateJsExpression = (expression, context) => {
   return fn(context);
 };
 
+const evaluateJsTemplateLiteral = (templateLiteral, context) => {
+  if(!templateLiteral || !templateLiteral.length || typeof templateLiteral !== 'string') {
+    return templateLiteral;
+  }
+
+  templateLiteral = templateLiteral.trim();
+
+  if(templateLiteral === 'true') {
+    return true;
+  }
+
+  if(templateLiteral === 'false') {
+    return false;
+  }
+
+  if(templateLiteral === 'null') {
+    return null;
+  }
+
+  if(templateLiteral === 'undefined') {
+    return undefined;
+  }
+
+  if(templateLiteral.startsWith('"') && templateLiteral.endsWith('"')) {
+    return templateLiteral.slice(1, -1);
+  }
+
+  if(templateLiteral.startsWith("'") && templateLiteral.endsWith("'")) {
+    return templateLiteral.slice(1, -1);
+  }
+
+  if(!isNaN(templateLiteral)) {
+    return Number(templateLiteral);
+  }
+
+  templateLiteral = "`" + templateLiteral + "`";
+
+  return evaluateJsExpression(templateLiteral, context);
+};
+
 const createResponseParser = (response = {}) => {
   const res = (expr, ...fns) => {
     return get(response.data, expr, ...fns);
@@ -80,6 +120,7 @@ const createResponseParser = (response = {}) => {
 
 module.exports = {
   evaluateJsExpression,
+  evaluateJsTemplateLiteral,
   createResponseParser,
   internalExpressionCache
 };