test(evaluate): add test cases for evaluation

Author: char0n

src/errors/JSONPointerIndexError.js

@@ -0,0 +1,9 @@
+import JSONPointerEvaluateError from './JSONPointerEvaluateError.js';
+
+class JSONPointerIndexError extends JSONPointerEvaluateError {
+  constructor(message, options) {
+    super(message, options);
+  }
+}
+
+export default JSONPointerIndexError;

src/errors/JSONPointerKeyError.js

@@ -0,0 +1,9 @@
+import JSONPointerEvaluateError from './JSONPointerEvaluateError.js';
+
+class JSONPointerKeyError extends JSONPointerEvaluateError {
+  constructor(referenceToken, options) {
+    super(`Invalid object key: '${referenceToken}' not found`, options);
+  }
+}
+
+export default JSONPointerKeyError;

src/errors/JSONPointerTypeError.js

@@ -0,0 +1,9 @@
+import JSONPointerEvaluateError from './JSONPointerEvaluateError.js';
+
+class JSONPointerTypeError extends JSONPointerEvaluateError {
+  constructor(referenceToken, options) {
+    super(`Invalid reference token: '${referenceToken}' (not an object/array)`, options);
+  }
+}
+
+export default JSONPointerTypeError;

src/evaluate.js

@@ -1,28 +1,28 @@
 import parse from './parse/index.js';
-import referenceTokenListEvaluator from './parse/evaluators/reference-token-list.js';
 import testArrayDash from './test/array-dash.js';
 import testArrayIndex from './test/array-index.js';
+import JSONPointerEvaluateError from './errors/JSONPointerEvaluateError.js';
+import JSONPointerTypeError from './errors/JSONPointerTypeError.js';
+import JSONPointerIndexError from './errors/JSONPointerIndexError.js';
+import JSONPointerKeyError from './errors/JSONPointerKeyError.js';
 
-const evaluate = (
-  value,
-  jsonPointer,
-  { strictArrays = true, evaluator = referenceTokenListEvaluator } = {},
-) => {
-  const { result, computed: referenceTokens } = parse(jsonPointer, { evaluator });
+const evaluate = (value, jsonPointer, { strictArrays = true, evaluator = null } = {}) => {
+  const parseOptions = typeof evaluator === 'function' ? { evaluator } : undefined;
+  const { result, computed: referenceTokens } = parse(jsonPointer, parseOptions);
 
   if (!result.success) {
-    throw new Error(`Invalid JSON Pointer: ${jsonPointer}`);
+    throw new JSONPointerEvaluateError(`Invalid JSON Pointer: ${jsonPointer}`);
   }
 
   return referenceTokens.reduce((current, referenceToken) => {
     if (typeof current !== 'object' || current === null) {
-      throw new Error(`Invalid reference token: '${referenceToken}' (not an object/array)`);
+      throw new JSONPointerTypeError(referenceToken);
     }
 
     if (Array.isArray(current)) {
       if (testArrayDash(referenceToken)) {
         if (strictArrays) {
-          throw new Error(
+          throw new JSONPointerIndexError(
             'Invalid array index: "-" always refers to a nonexistent element during evaluation',
           );
         } else {
@@ -31,20 +31,20 @@ const evaluate = (
       }
 
       if (!testArrayIndex(referenceToken)) {
-        throw new Error(
+        throw new JSONPointerIndexError(
           `Invalid array index: '${referenceToken}' (MUST be "0", or digits without a leading "0")`,
         );
       }
 
       const index = Number(referenceToken);
       if (index >= current.length && strictArrays) {
-        throw new Error(`Invalid array index: '${index}' out of bounds`);
+        throw new JSONPointerIndexError(`Invalid array index: '${index}' out of bounds`);
       }
       return current[index];
     }
 
     if (!Object.prototype.hasOwnProperty.call(current, referenceToken)) {
-      throw new Error(`Invalid object key: '${referenceToken}' not found`);
+      throw new JSONPointerKeyError(referenceToken);
     }
 
     return current[referenceToken];

src/index.js

@@ -23,3 +23,6 @@ export { default as JSONPointerError } from './errors/JSONPointerError.js';
 export { default as JSONPointerParseError } from './errors/JSONPointerParseError.js';
 export { default as JSONPointerCompileError } from './errors/JSONPointerCompileError.js';
 export { default as JSONPointerEvaluateError } from './errors/JSONPointerEvaluateError.js';
+export { default as JSONPointerTypeError } from './errors/JSONPointerTypeError.js';
+export { default as JSONPointerKeyError } from './errors/JSONPointerKeyError.js';
+export { default as JSONPointerIndexError } from './errors/JSONPointerIndexError.js';

test/evaluate.js

@@ -0,0 +1,151 @@
+import { assert } from 'chai';
+
+import {
+  evaluate,
+  JSONPointerIndexError,
+  JSONPointerTypeError,
+  JSONPointerKeyError,
+  JSONPointerEvaluateError,
+  referenceTokenListEvaluator,
+} from '../src/index.js';
+import unescape from '../src/unescape.js';
+
+describe('evaluate', function () {
+  const data = {
+    foo: ['bar', 'baz'],
+    '': 0,
+    'a/b': 1,
+    'c%d': 2,
+    'e^f': 3,
+    'g|h': 4,
+    'i\\j': 5,
+    'k"l': 6,
+    ' ': 7,
+    'm~n': 8,
+  };
+
+  context('valid JSON Pointers', function () {
+    specify('should return entire document for ""', function () {
+      assert.deepEqual(evaluate(data, ''), data);
+    });
+
+    specify('should return array ["bar", "baz"] for "/foo"', function () {
+      assert.deepEqual(evaluate(data, '/foo'), ['bar', 'baz']);
+    });
+
+    specify('should return "bar" for "/foo/0"', function () {
+      assert.strictEqual(evaluate(data, '/foo/0'), 'bar');
+    });
+
+    specify('should return 0 for "/"', function () {
+      assert.strictEqual(evaluate(data, '/'), 0);
+    });
+
+    specify('should return 1 for "/a~1b"', function () {
+      assert.strictEqual(evaluate(data, '/a~1b'), 1);
+    });
+
+    specify('should return 2 for "/c%d"', function () {
+      assert.strictEqual(evaluate(data, '/c%d'), 2);
+    });
+
+    specify('should return 3 for "/e^f"', function () {
+      assert.strictEqual(evaluate(data, '/e^f'), 3);
+    });
+
+    specify('should return 4 for "/g|h"', function () {
+      assert.strictEqual(evaluate(data, '/g|h'), 4);
+    });
+
+    specify('should return 5 for "/i\\j"', function () {
+      assert.strictEqual(evaluate(data, '/i\\j'), 5);
+    });
+
+    specify('should return 6 for "/k\"l"', function () {
+      assert.strictEqual(evaluate(data, '/k"l'), 6);
+    });
+
+    specify('should return 7 for "/ "', function () {
+      assert.strictEqual(evaluate(data, '/ '), 7);
+    });
+
+    specify('should return 8 for "/m~0n"', function () {
+      assert.strictEqual(evaluate(data, '/m~0n'), 8);
+    });
+  });
+
+  context('custom evaluator option', function () {
+    specify('should correctly use a default evaluator', function () {
+      const result = evaluate(data, '/a~1b', { evaluator: referenceTokenListEvaluator });
+
+      assert.deepEqual(result, 1); // Evaluator should return unescaped reference token list
+    });
+
+    specify('should use a custom evaluator', function () {
+      const evaluator = (ast) => {
+        const parts = [];
+
+        ast.translate(parts);
+
+        return parts.filter(([type]) => type === 'reference-token').map(([, value]) => value);
+      };
+
+      assert.throws(() => evaluate(data, '/a~1b', { evaluator }), JSONPointerKeyError);
+    });
+  });
+
+  context('invalid JSON Pointers (should throw errors)', function () {
+    specify('should throw JSONPointerEvaluateError for invalid JSON Pointer', function () {
+      assert.throws(() => evaluate(data, 'invalid-pointer'), JSONPointerEvaluateError);
+    });
+
+    specify(
+      'should throw JSONPointerTypeError for accessing property on non-object/array',
+      function () {
+        assert.throws(() => evaluate(data, '/foo/0/bad'), JSONPointerTypeError);
+      },
+    );
+
+    specify('should throw JSONPointerKeyError for non-existing key', function () {
+      assert.throws(() => evaluate(data, '/nonexistent'), JSONPointerKeyError);
+    });
+
+    specify('should throw JSONPointerIndexError for non-numeric array index', function () {
+      assert.throws(() => evaluate(data, '/foo/x'), JSONPointerIndexError);
+    });
+
+    specify('should throw JSONPointerIndexError for out-of-bounds array index', function () {
+      assert.throws(() => evaluate(data, '/foo/5'), JSONPointerIndexError);
+    });
+
+    specify('should throw JSONPointerIndexError for leading zero in array index', function () {
+      assert.throws(() => evaluate(data, '/foo/01'), JSONPointerIndexError);
+    });
+
+    specify('should throw JSONPointerIndexError for "-" when strictArrays is true', function () {
+      assert.throws(() => evaluate(data, '/foo/-', { strictArrays: true }), JSONPointerIndexError);
+    });
+
+    specify('should return undefined for "-" when strictArrays is false', function () {
+      assert.strictEqual(evaluate(data, '/foo/-', { strictArrays: false }), undefined);
+    });
+
+    specify(
+      'should throw JSONPointerKeyError for accessing object property that does not exist',
+      function () {
+        assert.throws(() => evaluate(data, '/missing/key'), JSONPointerKeyError);
+      },
+    );
+
+    specify('should throw JSONPointerTypeError when evaluating on primitive', function () {
+      assert.throws(() => evaluate('not-an-object', '/foo'), JSONPointerTypeError);
+    });
+
+    specify(
+      'should throw JSONPointerTypeError when trying to access deep path on primitive',
+      function () {
+        assert.throws(() => evaluate({ foo: 42 }, '/foo/bar'), JSONPointerTypeError);
+      },
+    );
+  });
+});