Add tests

Author: rekmarks

src/utils.ts

@@ -39,15 +39,15 @@ interface JsonRpcValidatorOptions {
 
 /**
  * Gets a function for validating JSON-RPC request / response `id` values.
- * 
+ *
  * By manipulating the options of this factory, you can control the behavior
  * of the resulting validator for some edge cases. This is useful because e.g.
  * `null` should sometimes but not always be permitted.
- * 
+ *
  * Note that the empty string (`''`) is always permitted by the JSON-RPC
  * specification, but that kind of sucks and you may want to forbid it in some
  * instances anyway.
- * 
+ *
  * For more details, see the
  * [JSON-RPC Specification](https://www.jsonrpc.org/specification).
  *

test/utils.test.js

@@ -0,0 +1,108 @@
+/* eslint-env mocha */
+'use strict';
+
+const { strict: assert } = require('assert');
+const {
+  isJsonRpcFailure,
+  isJsonRpcSuccess,
+  getJsonRpcIdValidator,
+} = require('../dist');
+
+describe('isJsonRpcSuccess', function () {
+  it('correctly identifies JSON-RPC response objects', function () {
+    assert.equal(isJsonRpcSuccess({ result: 'success' }), true);
+    assert.equal(isJsonRpcSuccess({ result: undefined }), true);
+    assert.equal(isJsonRpcSuccess({ error: new Error('foo') }), false);
+    assert.equal(isJsonRpcSuccess({}), false);
+  });
+});
+
+describe('isJsonRpcFailure', function () {
+  it('correctly identifies JSON-RPC response objects', function () {
+    assert.equal(isJsonRpcFailure({ error: 'failure' }), true);
+    assert.equal(isJsonRpcFailure({ error: undefined }), true);
+    assert.equal(isJsonRpcFailure({ result: 'success' }), false);
+    assert.equal(isJsonRpcFailure({}), false);
+  });
+});
+
+describe('getJsonRpcIdValidator', function () {
+  const getInputs = () => {
+    return {
+      // invariant with respect to options
+      fractionString: { value: '1.2', expected: true },
+      negativeInteger: { value: -1, expected: true },
+      object: { value: {}, expected: false },
+      positiveInteger: { value: 1, expected: true },
+      string: { value: 'foo', expected: true },
+      undefined: { value: undefined, expected: false },
+      zero: { value: 0, expected: true },
+      // variant with respect to options
+      emptyString: { value: '', expected: true },
+      fraction: { value: 1.2, expected: false },
+      null: { value: null, expected: true },
+    };
+  };
+
+  const validateAll = (validate, inputs) => {
+    for (const input of Object.values(inputs)) {
+      assert.equal(
+        validate(input.value),
+        input.expected,
+        `should output "${input.expected}" for "${input.value}"`,
+      );
+    }
+  };
+
+  it('performs as expected with default options', function () {
+    const inputs = getInputs();
+
+    // The default options are:
+    // permitEmptyString: true,
+    // permitFractions: false,
+    // permitNull: true,
+    validateAll(getJsonRpcIdValidator(), inputs);
+  });
+
+  it('performs as expected with "permitEmptyString: false"', function () {
+    const inputs = getInputs();
+    inputs.emptyString.expected = false;
+
+    validateAll(
+      getJsonRpcIdValidator({
+        permitEmptyString: false,
+        permitFractions: false,
+        permitNull: true,
+      }),
+      inputs,
+    );
+  });
+
+  it('performs as expected with "permitFractions: true"', function () {
+    const inputs = getInputs();
+    inputs.fraction.expected = true;
+
+    validateAll(
+      getJsonRpcIdValidator({
+        permitEmptyString: true,
+        permitFractions: true,
+        permitNull: true,
+      }),
+      inputs,
+    );
+  });
+
+  it('performs as expected with "permitNull: false"', function () {
+    const inputs = getInputs();
+    inputs.null.expected = false;
+
+    validateAll(
+      getJsonRpcIdValidator({
+        permitEmptyString: true,
+        permitFractions: false,
+        permitNull: false,
+      }),
+      inputs,
+    );
+  });
+});