test(parse): add tests cases for parsing

Author: char0n

src/compile.js

@@ -1,11 +1,18 @@
 import escape from './escape.js';
+import JSONPointerCompileError from './errors/JSONPointerCompileError.js';
 
 const compile = (tokens) => {
-  if (tokens.length === 0) {
-    return '';
-  }
+  try {
+    if (tokens.length === 0) {
+      return '';
+    }
 
-  return `/${tokens.map(escape).join('/')}`;
+    return `/${tokens.map(escape).join('/')}`;
+  } catch (error) {
+    throw new JSONPointerCompileError('Unknown error during JSON Pointer compilation', {
+      cause: error,
+    });
+  }
 };
 
 export default compile;

src/errors/JSONPointerCompileError.js

@@ -0,0 +1,5 @@
+import JSONPointerError from './JSONPointerError.js';
+
+class JSONPointerCompileError extends JSONPointerError {}
+
+export default JSONPointerCompileError;

src/errors/JSONPointerError.js

@@ -0,0 +1,34 @@
+class JSONPointerError extends Error {
+  constructor(message, options = undefined) {
+    super(message, options);
+
+    this.name = this.constructor.name;
+    if (typeof message === 'string') {
+      this.message = message;
+    }
+    if (typeof Error.captureStackTrace === 'function') {
+      Error.captureStackTrace(this, this.constructor);
+    } else {
+      this.stack = new Error(message).stack;
+    }
+
+    /**
+     * This needs to stay here until our minimum supported version of Node.js is >= 16.9.0.
+     * Node.js is >= 16.9.0 supports error causes natively.
+     */
+    if (
+      options != null &&
+      typeof options === 'object' &&
+      Object.prototype.hasOwnProperty.call(options, 'cause') &&
+      !('cause' in this)
+    ) {
+      const { cause } = options;
+      this.cause = cause;
+      if (cause instanceof Error && 'stack' in cause) {
+        this.stack = `${this.stack}\nCAUSE: ${cause.stack}`;
+      }
+    }
+  }
+}
+
+export default JSONPointerError;

src/errors/JSONPointerEvaluateError.js

@@ -0,0 +1,5 @@
+import JSONPointerError from './JSONPointerError.js';
+
+class JSONPointerEvaluateError extends JSONPointerError {}
+
+export default JSONPointerEvaluateError;

src/errors/JSONPointerParseError.js

@@ -0,0 +1,5 @@
+import JSONPointerError from './JSONPointerError.js';
+
+class JSONPointerParseError extends JSONPointerError {}
+
+export default JSONPointerParseError;

src/index.js

@@ -18,3 +18,8 @@ export { default as escape } from './escape.js';
 export { default as unescape } from './unescape.js';
 
 export { default as evaluate } from './evaluate.js';
+
+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';

src/parse/callbacks/json-pointer.js

@@ -1,9 +1,11 @@
 import { identifiers, utilities } from 'apg-lite';
 
+import JSONPointerParseError from '../../errors/JSONPointerParseError.js';
+
 const jsonPointer = (state, chars, phraseIndex, phraseLength, data) => {
   if (state === identifiers.SEM_PRE) {
     if (Array.isArray(data) === false) {
-      throw new Error("parser's user data must be an array");
+      throw new JSONPointerParseError("parser's user data must be an array");
     }
     data.push(['json-pointer', utilities.charsToString(chars, phraseIndex, phraseLength)]);
   }

src/parse/index.js

@@ -4,26 +4,35 @@ import Grammar from '../grammar.js';
 import jsonPointerCallback from './callbacks/json-pointer.js';
 import referenceTokenCallback from './callbacks/reference-token.js';
 import referenceTokenListEvaluator from './evaluators/reference-token-list.js';
+import JSONPointerParseError from '../errors/JSONPointerParseError.js';
 
 const grammar = new Grammar();
 
 const parse = (jsonPointer, { evaluator = referenceTokenListEvaluator } = {}) => {
-  const parser = new Parser();
+  if (typeof jsonPointer !== 'string') {
+    throw new JSONPointerParseError('JSON Pointer must be a string');
+  }
 
-  parser.ast = new AST();
-  parser.ast.callbacks['json-pointer'] = jsonPointerCallback;
-  parser.ast.callbacks['reference-token'] = referenceTokenCallback;
+  try {
+    const parser = new Parser();
 
-  const { ast } = parser;
-  const result = parser.parse(grammar, 'json-pointer', jsonPointer);
+    parser.ast = new AST();
+    parser.ast.callbacks['json-pointer'] = jsonPointerCallback;
+    parser.ast.callbacks['reference-token'] = referenceTokenCallback;
 
-  if (!result.success) {
-    return { result, ast, computed: null };
-  }
+    const { ast } = parser;
+    const result = parser.parse(grammar, 'json-pointer', jsonPointer);
 
-  const computed = evaluator(ast, { result });
+    if (!result.success) {
+      return { result, ast, computed: null };
+    }
 
-  return { result, ast, computed };
+    const computed = evaluator(ast, { result });
+
+    return { result, ast, computed };
+  } catch (error) {
+    throw new JSONPointerParseError('Unknown error during JSON Pointer parsing', { cause: error });
+  }
 };
 
 export default parse;

test/compile.js

@@ -1,6 +1,6 @@
 import { assert } from 'chai';
 
-import { compile } from '../src/index.js';
+import { compile, JSONPointerCompileError } from '../src/index.js';
 
 describe('compile', function () {
   it('should return an empty string for an empty array', function () {
@@ -38,4 +38,8 @@ describe('compile', function () {
   it('should retain spaces and special symbols without escaping them', function () {
     assert.strictEqual(compile(['foo bar', 'baz@qux']), '/foo bar/baz@qux');
   });
+
+  it('should throw error on invalid input', function () {
+    assert.throws(() => compile(null), JSONPointerCompileError);
+  });
 });