@usebruno/js 0.1.0

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@usebruno/js",
+  "version": "0.1.0",
+  "main": "src/index.js",
+  "files": [
+    "src",
+    "package.json"
+  ],
+  "peerDependencies": {
+    "vm2": "^3.9.13"
+  },
+  "dependencies": {
+    "atob": "^2.1.2",
+    "ajv": "^8.12.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",
+    "uuid": "^9.0.0"
+  }
+}

package/readme.md

@@ -0,0 +1,8 @@
+# bruno-js
+
+Provides the script, test, vars and assert runtimes.
+
+### Publish to Npm Registry
+```bash
+npm publish --access=public
+```

package/src/bru.js

@@ -0,0 +1,38 @@
+
+class Bru {
+  constructor(envVariables, collectionVariables) {
+    this._envVariables = envVariables;
+    this._collectionVariables = collectionVariables;
+  }
+
+  getEnvVar(key) {
+    return this._envVariables[key];
+  }
+
+  setEnvVar(key, value) {
+    if(!key) {
+      throw new Error('Key is required');
+    }
+
+    // gracefully ignore if key is not present in environment
+    if(!this._envVariables.hasOwnProperty(key)) {
+      return;
+    }
+
+    this._envVariables[key] = value;
+  }
+
+  setVar(key, value) {
+    if(!key) {
+      throw new Error('Key is required');
+    }
+
+    this._collectionVariables[key] = value;
+  }
+
+  getVar(key) {
+    return this._collectionVariables[key];
+  }
+}
+
+module.exports = Bru;

package/src/bruno-request.js

@@ -0,0 +1,51 @@
+class BrunoRequest {
+  constructor(req) {
+    this.req = req;
+    this.url = req.url;
+    this.method = req.method;
+    this.headers = req.headers;
+    this.body = req.data;
+  }
+
+  getUrl() {
+    return this.req.url;
+  }
+
+  setUrl(url) {
+    this.req.url = url;
+  }
+
+  getMethod() {
+    return this.req.method;
+  }
+
+  setMethod(method) {
+    this.req.method = method;
+  }
+
+  getHeaders() {
+    return this.req.headers;
+  }
+
+  setHeaders(headers) {
+    this.req.headers = headers;
+  }
+
+  getHeader(name) {
+    return this.req.headers[name];
+  }
+
+  setHeader(name, value) {
+    this.req.headers[name] = value;
+  }
+
+  getBody() {
+    return this.req.data;
+  }
+
+  setBody(data) {
+    this.req.data = data;
+  }
+}
+
+module.exports = BrunoRequest;

package/src/bruno-response.js

@@ -0,0 +1,27 @@
+class BrunoResponse {
+  constructor(res) {
+    this.res = res;
+    this.status = res.status;
+    this.statusText = res.statusText;
+    this.headers = res.headers;
+    this.body = res.data;
+  }
+
+  getStatus() {
+    return this.res.status;
+  }
+
+  getHeader(name) {
+    return this.res.header[name];
+  }
+
+  getHeaders() {
+    return this.res.headers;
+  }
+
+  getBody() {
+    return this.res.data;
+  }
+}
+
+module.exports = BrunoResponse;

package/src/index.js

@@ -0,0 +1,11 @@
+const ScriptRuntime = require('./runtime/script-runtime');
+const TestRuntime = require('./runtime/test-runtime');
+const VarsRuntime = require('./runtime/vars-runtime');
+const AssertRuntime = require('./runtime/assert-runtime');
+
+module.exports = {
+  ScriptRuntime,
+  TestRuntime,
+  VarsRuntime,
+  AssertRuntime
+};

package/src/runtime/assert-runtime.js

@@ -0,0 +1,226 @@
+const _ = require('lodash');
+const chai = require('chai');  
+const { nanoid } = require('nanoid');
+const Bru = require('../bru');
+const BrunoRequest = require('../bruno-request');
+const { evaluateJsExpression, createResponseParser } = require('../utils');
+
+const { expect } = chai;
+
+/**
+ * Assertion operators
+ * 
+ * eq          : equal to
+ * neq         : not equal to
+ * like        : like
+ * gt          : greater than
+ * gte         : greater than or equal to
+ * lt          : less than
+ * lte         : less than or equal to
+ * in          : in
+ * notIn       : not in
+ * contains    : contains
+ * notContains : not contains
+ * count       : count
+ * length      : length
+ * matches     : matches
+ * notMatches  : not matches
+ * startsWith  : starts with
+ * endsWith    : ends with
+ * between     : between
+ * isEmpty     : is empty
+ * isNull      : is null
+ * isUndefined : is undefined
+ * isDefined   : is defined
+ * isTruthy    : is truthy
+ * isFalsy     : is falsy
+ * isJson      : is json
+ * isNumber    : is number
+ * isString    : is string
+ * isBoolean   : is boolean
+ */
+const parseAssertionOperator = (str = '') => {
+  if(!str || typeof str !== 'string' || str.length) {
+    return {
+      operator: 'eq',
+      value: str
+    };
+  }
+
+  const operators = [
+    'eq', 'neq', 'like', 'gt', 'gte', 'lt', 'lte', 'in', 'notIn',
+    'contains', 'notContains', 'count', 'length', 'matches', 'notMatches',
+    'startsWith', 'endsWith', 'between', 'isEmpty', 'isNull', 'isUndefined',
+    'isDefined', 'isTruthy', 'isFalsy', 'isJson', 'isNumber', 'isString', 'isBoolean'
+  ];
+
+  const [operator, ...rest] = str.trim().split(' ');
+  const value = rest.join(' ');
+
+  if(operators.includes(operator)) {
+    return {
+      operator,
+      value
+    };
+  }
+
+  return {
+    operator: 'eq',
+    value: str
+  };
+};
+
+class AssertRuntime {
+  runAssertions(assertions, request, response, envVariables, collectionVariables, collectionPath) {
+    const enabledAssertions = _.filter(assertions, (a) => a.enabled);
+    if(!enabledAssertions.length) {
+      return [];
+    }
+
+    const bru = new Bru(envVariables, collectionVariables);
+    const req = new BrunoRequest(request);
+    const res = createResponseParser(response);
+
+    const bruContext = {
+      bru,
+      req,
+      res
+    };
+
+    const context = {
+      ...envVariables,
+      ...collectionVariables,
+      ...bruContext
+    }
+
+    const assertionResults = [];
+
+    // parse assertion operators
+    for (const v of enabledAssertions) {
+      const lhsExpr = v.name;
+      const rhsExpr = v.value;
+      const {
+        operator,
+        value: rhsOperand
+      } = parseAssertionOperator(rhsExpr);
+
+      try {
+        const lhs = evaluateJsExpression(lhsExpr, context);
+        const rhs = evaluateJsExpression(rhsOperand, context);
+
+        switch(operator) {
+          case 'eq':
+            expect(lhs).to.equal(rhs);
+            break;
+          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;
+          case 'gte':
+            expect(lhs).to.be.greaterThanOrEqual(rhs);
+            break;
+          case 'lt':
+            expect(lhs).to.be.lessThan(rhs);
+            break;
+          case 'lte':
+            expect(lhs).to.be.lessThanOrEqual(rhs);
+            break;
+          case 'in':
+            expect(lhs).to.be.oneOf(rhs);
+            break;
+          case 'notIn':
+            expect(lhs).to.not.be.oneOf(rhs);
+            break;
+          case 'contains':
+            expect(lhs).to.include(rhs);
+            break;
+          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;
+          case 'matches':
+            expect(lhs).to.match(new RegExp(rhs));
+            break;
+          case 'notMatches':
+            expect(lhs).to.not.match(new RegExp(rhs));
+            break;
+          case 'startsWith':
+            expect(lhs).to.startWith(rhs);
+            break;
+          case 'endsWith':
+            expect(lhs).to.endWith(rhs);
+            break;
+          case 'between':
+            const [min, max] = value.split(' ');
+            expect(lhs).to.be.within(min, max);
+            break;
+          case 'isEmpty':
+            expect(lhs).to.be.empty;
+            break;
+          case 'isNull':
+            expect(lhs).to.be.null;
+            break;
+          case 'isUndefined':
+            expect(lhs).to.be.undefined;
+            break;
+          case 'isDefined':
+            expect(lhs).to.not.be.undefined;
+            break;
+          case 'isTruthy':
+            expect(lhs).to.be.true;
+            break;
+          case 'isFalsy':
+            expect(lhs).to.be.false;
+            break;
+          case 'isJson':
+            expect(lhs).to.be.json;
+            break;
+          case 'isNumber':
+            expect(lhs).to.be.a('number');
+            break;
+          case 'isString':
+            expect(lhs).to.be.a('string');
+            break;
+          case 'isBoolean':
+            expect(lhs).to.be.a('boolean');
+            break;
+          default:
+            expect(lhs).to.equal(rhs);
+            break;
+        }
+
+        assertionResults.push({
+          lhsExpr,
+          rhsExpr,
+          rhsOperand,
+          operator,
+          status: 'pass'
+        });
+      }
+      catch (err) {
+        assertionResults.push({
+          lhsExpr,
+          rhsExpr,
+          rhsOperand,
+          operator,
+          status: 'fail',
+          error: err.message
+        });
+      }
+    }
+
+    return assertionResults;
+  }
+}
+
+module.exports = AssertRuntime;

package/src/runtime/script-runtime.js

@@ -0,0 +1,93 @@
+const { NodeVM } = require('vm2');
+const path = require('path');
+const Bru = require('../bru');
+const BrunoRequest = require('../bruno-request');
+const BrunoResponse = require('../bruno-response');
+
+// Inbuilt Library Support
+const atob = require('atob');
+const btoa = require('btoa');
+const lodash = require('lodash');
+const moment = require('moment');
+const uuid = require('uuid');
+const nanoid = require('nanoid');
+const CryptoJS = require('crypto-js');
+
+class ScriptRuntime {
+  constructor() {
+  }
+
+  runRequestScript(script, request, environment, collectionVariables, collectionPath) {
+    const bru = new Bru(environment, collectionVariables);
+    const req = new BrunoRequest(request);
+
+    const context = {
+      bru,
+      req
+    };
+    const vm = new NodeVM({
+      sandbox: context,
+      require: {
+        context: 'sandbox',
+        external: true,
+        root: [collectionPath],
+        mock: {
+          atob,
+          btoa,
+          lodash,
+          moment,
+          uuid,
+          nanoid,
+          'crypto-js': CryptoJS
+        }
+      }
+    });
+
+    vm.run(script, path.join(collectionPath, 'vm.js'));
+
+    return {
+      request,
+      environment,
+      collectionVariables
+    };
+  }
+
+  runResponseScript(script, request, response, environment, collectionVariables, collectionPath) {
+    const bru = new Bru(environment, collectionVariables);
+    const req = new BrunoRequest(request);
+    const res = new BrunoResponse(response);
+
+    const context = {
+      bru,
+      req,
+      res
+    };
+    const vm = new NodeVM({
+      sandbox: context,
+      require: {
+        context: 'sandbox',
+        external: true,
+        root: [collectionPath],
+        mock: {
+          atob,
+          btoa,
+          lodash,
+          moment,
+          uuid,
+          nanoid,
+          'crypto-js': CryptoJS
+        }
+      }
+    });
+
+    vm.run(script, path.join(collectionPath, 'vm.js'));
+
+    return {
+      response,
+      environment,
+      collectionVariables
+    };
+  }
+}
+
+module.exports = ScriptRuntime;

package/src/runtime/test-runtime.js

@@ -0,0 +1,70 @@
+const { NodeVM } = require('vm2');
+const chai = require('chai');  
+const path = require('path');
+const Bru = require('../bru');
+const BrunoRequest = require('../bruno-request');
+const BrunoResponse = require('../bruno-response');
+const Test = require('../test');
+const TestResults = require('../test-results');
+
+// Inbuilt Library Support
+const atob = require('atob');
+const btoa = require('btoa');
+const lodash = require('lodash');
+const moment = require('moment');
+const uuid = require('uuid');
+const nanoid = require('nanoid');
+const CryptoJS = require('crypto-js');
+
+class TestRuntime {
+  constructor() {
+  }
+
+  runTests(testsFile, request, response, environment, collectionVariables, collectionPath) {
+    const bru = new Bru(environment, collectionVariables);
+    const req = new BrunoRequest(request);
+    const res = new BrunoResponse(response);
+
+    const __brunoTestResults = new TestResults();
+    const test = Test(__brunoTestResults, chai);
+
+    const context = {
+      test,
+      bru,
+      req,
+      res,
+      expect: chai.expect,
+      assert: chai.assert,
+      __brunoTestResults: __brunoTestResults
+    };
+
+    const vm = new NodeVM({
+      sandbox: context,
+      require: {
+        context: 'sandbox',
+        external: true,
+        root: [collectionPath],
+        mock: {
+          atob,
+          btoa,
+          lodash,
+          moment,
+          uuid,
+          nanoid,
+          'crypto-js': CryptoJS
+        }
+      }
+    });
+
+    vm.run(testsFile, path.join(collectionPath, 'vm.js'));
+
+    return {
+      request,
+      environment,
+      collectionVariables,
+      results: __brunoTestResults.getResults()
+    };
+  }
+}
+
+module.exports = TestRuntime;

package/src/runtime/vars-runtime.js

@@ -0,0 +1,62 @@
+const _ = require('lodash');
+const Bru = require('../bru');
+const BrunoRequest = require('../bruno-request');
+const { evaluateJsExpression, createResponseParser } = require('../utils');
+
+class VarsRuntime {
+  runPreRequestVars(vars, request, envVariables, collectionVariables, collectionPath) {
+    const enabledVars = _.filter(vars, (v) => v.enabled);
+    if(!enabledVars.length) {
+      return;
+    }
+
+    const bru = new Bru(envVariables, collectionVariables);
+    const req = new BrunoRequest(request);
+
+    const bruContext = {
+      bru,
+      req
+    };
+
+    const context = {
+      ...envVariables,
+      ...collectionVariables,
+      ...bruContext
+    }
+
+    _.each(enabledVars, (v) => {
+      const value = evaluateJsExpression(v.value, context);
+      bru.setVar(v.name, value);
+    });
+  }
+
+  runPostResponseVars(vars, request, response, envVariables, collectionVariables, collectionPath) {
+    const enabledVars = _.filter(vars, (v) => v.enabled);
+    if(!enabledVars.length) {
+      return;
+    }
+
+    const bru = new Bru(envVariables, collectionVariables);
+    const req = new BrunoRequest(request);
+    const res = createResponseParser(response);
+
+    const bruContext = {
+      bru,
+      req,
+      res
+    };
+
+    const context = {
+      ...envVariables,
+      ...collectionVariables,
+      ...bruContext
+    }
+
+    _.each(enabledVars, (v) => {
+      const value = evaluateJsExpression(v.value, context);
+      bru.setVar(v.name, value);
+    });
+  }
+}
+
+module.exports = VarsRuntime;

package/src/test-results.js

@@ -0,0 +1,18 @@
+const { nanoid } = require('nanoid');
+
+class TestResults {
+  constructor() {
+    this.results = [];
+  }
+
+  addResult(result) {
+    result.uid = nanoid();
+    this.results.push(result);
+  }
+
+  getResults() {
+    return this.results;
+  }
+}
+
+module.exports = TestResults;

package/src/test.js

@@ -0,0 +1,27 @@
+const Test = (__brunoTestResults, chai) => (description, callback) => {
+  try {
+    callback();
+    __brunoTestResults.addResult({ description, status: "pass" });
+  } catch (error) {
+    console.log(chai.AssertionError);
+    if (error instanceof chai.AssertionError) {
+      const { message, actual, expected } = error;
+      __brunoTestResults.addResult({
+        description,
+        status: "fail",
+        error: message,
+        actual,
+        expected
+      });
+    } else {
+      __brunoTestResults.addResult({
+        description,
+        status: "fail",
+        error: error.message || 'An unexpected error occurred.'
+      });
+    }
+    console.log(error);
+  }
+}
+
+module.exports = Test;

package/src/utils.js

@@ -0,0 +1,25 @@
+const jsonQuery = require('json-query');
+
+const evaluateJsExpression = (expression, context) => {
+  const fn = new Function(...Object.keys(context), `return ${expression}`);
+  return fn(...Object.values(context));
+};
+
+const createResponseParser = (response = {}) => {
+  const res = (expr)  => {
+    const output = jsonQuery(expr, { data: response.data });
+    return output ? output.value : null;
+  }
+
+  res.status = response.status;
+  res.statusText = response.statusText;
+  res.headers = response.headers;
+  res.body = response.data;
+
+  return res;
+};
+
+module.exports = {
+  evaluateJsExpression,
+  createResponseParser
+};