@usebruno/js 0.47.0 → 0.48.0

package/src/runtime/assert-runtime.js

@@ -7,6 +7,8 @@ const { evaluateJsTemplateLiteral, evaluateJsExpression, createResponseParser, u
 const { interpolateString } = require('../interpolate-string');
 const { executeQuickJsVm } = require('../sandbox/quickjs');
 
+const Ajv = require('ajv');
+const addFormats = require('ajv-formats');
 const { expect } = chai;
 chai.use(require('chai-string'));
 chai.use(function (chai, utils) {
@@ -24,6 +26,48 @@ chai.use(function (chai, utils) {
   });
 });
 
+// Custom assertion for JSON Schema validation
+const defaultAjv = new Ajv({ allErrors: true });
+addFormats(defaultAjv);
+
+const SUPPORTED_SCHEMA_VERSIONS = [
+  'http://json-schema.org/draft-07/schema#',
+  'http://json-schema.org/draft-07/schema'
+];
+
+chai.use(function (chai) {
+  chai.Assertion.addMethod('jsonSchema', function (schema, ajvOptions) {
+    if (schema && schema.$schema && !SUPPORTED_SCHEMA_VERSIONS.includes(schema.$schema)) {
+      this.assert(
+        false,
+        `Unsupported JSON Schema version: "${schema.$schema}". Bruno currently only supports Draft-07 (http://json-schema.org/draft-07/schema#). Please update your schema to be Draft-07 compatible and remove the $schema property.`,
+        `Unsupported JSON Schema version: "${schema.$schema}".`
+      );
+    }
+    let ajv;
+    if (ajvOptions) {
+      ajv = new Ajv({ allErrors: true, ...ajvOptions });
+      addFormats(ajv);
+    } else {
+      ajv = defaultAjv;
+    }
+    let validate;
+    try {
+      validate = ajv.compile(schema);
+    } catch (e) {
+      this.assert(false, 'JSON schema compile error: ' + e.message, 'JSON schema compile error: ' + e.message);
+    }
+    const data = this._obj;
+    const isValid = validate(data);
+
+    this.assert(
+      isValid,
+      'expected #{this} to match JSON schema, validation errors: ' + (validate.errors ? JSON.stringify(validate.errors) : 'none'),
+      'expected #{this} to not match JSON schema'
+    );
+  });
+});
+
 // Custom assertion for matching regex
 chai.use(function (chai, utils) {
   chai.Assertion.addMethod('match', function (regex) {
@@ -43,6 +87,118 @@ chai.use(function (chai, utils) {
   });
 });
 
+// Custom assertion for jsonBody (Postman parity)
+chai.use(function (chai, utils) {
+  // Parse a property path into an array of keys.
+  // Handles: dot notation (a.b), numeric brackets (a[0]), quoted brackets (a["b.c"], a['key']),
+  // and combinations like data[0]["a.b"].name
+  //
+  // Examples:
+  //   "a.b.c"              -> ["a", "b", "c"]
+  //   "items[0].name"      -> ["items", "0", "name"]
+  //   'data["a.b"]'        -> ["data", "a.b"]
+  //   "matrix[0][1]"       -> ["matrix", "0", "1"]
+  //   'nested["x.y"].z'    -> ["nested", "x.y", "z"]
+  //   '["say \\"hi\\""]'   -> ["say \"hi\""]
+  function parsePath(path) {
+    const keys = [];
+    let i = 0;
+    while (i < path.length) {
+      if (path[i] === '.') {
+        // Skip dot separator
+        i++;
+      } else if (path[i] === '[') {
+        i++; // skip '['
+        if (i < path.length && (path[i] === '\'' || path[i] === '"')) {
+          // Quoted key — collect until matching unescaped quote + ']'
+          const quote = path[i];
+          i++; // skip opening quote
+          let key = '';
+          while (i < path.length && path[i] !== quote) {
+            if (path[i] === '\\' && i + 1 < path.length && path[i + 1] === quote) {
+              key += quote;
+              i += 2; // skip backslash + escaped quote
+            } else {
+              key += path[i];
+              i++;
+            }
+          }
+          i++; // skip closing quote
+          i++; // skip ']'
+          keys.push(key);
+        } else {
+          // Unquoted (numeric) key — collect until ']'
+          let key = '';
+          while (i < path.length && path[i] !== ']') {
+            key += path[i];
+            i++;
+          }
+          i++; // skip ']'
+          keys.push(key);
+        }
+      } else {
+        // Bare key — collect until '.', '[', or end
+        let key = '';
+        while (i < path.length && path[i] !== '.' && path[i] !== '[') {
+          key += path[i];
+          i++;
+        }
+        keys.push(key);
+      }
+    }
+    return keys;
+  }
+
+  function getNestedValue(obj, path) {
+    const keys = parsePath(path);
+    let current = obj;
+    for (const key of keys) {
+      if (current === null || current === undefined || !Object.prototype.hasOwnProperty.call(Object(current), key)) {
+        return { found: false };
+      }
+      current = current[key];
+    }
+    return { found: true, value: current };
+  }
+
+  chai.Assertion.addMethod('jsonBody', function () {
+    const obj = this._obj;
+    const args = Array.prototype.slice.call(arguments);
+
+    if (args.length === 0) {
+      // No args: check body is valid JSON (object or array)
+      this.assert(
+        typeof obj === 'object' && obj !== null,
+        `expected ${utils.inspect(obj)} to be a JSON body (object or array)`,
+        `expected ${utils.inspect(obj)} not to be a JSON body`
+      );
+    } else if (args.length === 1 && typeof args[0] === 'object' && args[0] !== null) {
+      // Object arg: deep equality
+      this.assert(
+        utils.eql(obj, args[0]),
+        `expected body to deeply equal ${utils.inspect(args[0])}`,
+        `expected body to not deeply equal ${utils.inspect(args[0])}`
+      );
+    } else if (args.length === 1) {
+      // String path: check nested property exists
+      const result = getNestedValue(obj, String(args[0]));
+      this.assert(
+        result.found,
+        `expected body to have nested property '${args[0]}'`,
+        `expected body to not have nested property '${args[0]}'`
+      );
+    } else {
+      // Path + value: check nested property equals value
+      const result = getNestedValue(obj, String(args[0]));
+      this.assert(
+        result.found && utils.eql(result.value, args[1]),
+        `expected body to have nested property '${args[0]}' equal to ${utils.inspect(args[1])}`,
+        `expected body to not have nested property '${args[0]}' equal to ${utils.inspect(args[1])}`
+      );
+    }
+  });
+});
+
 /**
  * Assertion operators
  *