Refactor AssertError (#382)

Co-authored-by: devin ivy <[email protected]>

lib/assert.js

@@ -1,12 +1,13 @@
 'use strict';
 
-const AssertError = require('./error');
+const Errors = require('./errors');
+const Stringify = require('./stringify');
 
 
 const internals = {};
 
 
-module.exports = function (condition, ...args) {
+const assert = module.exports = function (condition, ...args) {
 
     if (condition) {
         return;
@@ -18,5 +19,12 @@ module.exports = function (condition, ...args) {
         throw args[0];
     }
 
-    throw new AssertError(args);
+    const msgs = args
+        .filter((arg) => arg !== '')
+        .map((arg) => {
+
+            return typeof arg === 'string' ? arg : arg instanceof Error ? arg.message : Stringify(arg);
+        });
+
+    throw new Errors.AssertError(msgs.join(' '), assert);
 };

lib/errors.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const internals = {};
+
+
+exports.AssertError = class extends Error {
+
+    name = 'AssertError';
+
+    constructor(message, ctor) {
+
+        super(message || 'Unknown error');
+
+        if (typeof Error.captureStackTrace === 'function') {            // $lab:coverage:ignore$
+            Error.captureStackTrace(this, ctor);
+        }
+    }
+};

lib/index.d.ts

@@ -340,6 +340,15 @@ export function assert(condition: any, error: Error): asserts condition;
 export function assert(condition: any, ...args: any): asserts condition;
 
 
+/**
+ * Assertion Error as thrown from Hoek.assert().
+ */
+export class AssertError extends Error {
+
+    name: 'AssertError';
+}
+
+
 /**
  * A benchmarking timer, using the internal node clock for maximum accuracy.
  */

lib/index.js

@@ -4,6 +4,8 @@ exports.applyToDefaults = require('./applyToDefaults');
 
 exports.assert = require('./assert');
 
+exports.AssertError = require('./errors').AssertError;
+
 exports.Bench = require('./bench');
 
 exports.block = require('./block');
@@ -14,8 +16,6 @@ exports.contain = require('./contain');
 
 exports.deepEqual = require('./deepEqual');
 
-exports.Error = require('./error');
-
 exports.escapeHeaderAttribute = require('./escapeHeaderAttribute');
 
 exports.escapeHtml = require('./escapeHtml');

test/esm.js

@@ -20,8 +20,8 @@ describe('import()', () => {
     it('exposes all methods and classes as named imports', () => {
 
         expect(Object.keys(Hoek)).to.equal([
+            'AssertError',
             'Bench',
-            'Error',
             'applyToDefaults',
             'assert',
             'block',

test/index.js

@@ -2102,53 +2102,53 @@ describe('assert()', () => {
         expect(() => {
 
             Hoek.assert(false, 'my error message');
-        }).to.throw('my error message');
+        }).to.throw(Hoek.AssertError, 'my error message');
     });
 
     it('throws an Error when using assert in a test with no message', () => {
 
         expect(() => {
 
             Hoek.assert(false);
-        }).to.throw('Unknown error');
+        }).to.throw(Hoek.AssertError, 'Unknown error');
     });
 
     it('throws an Error when using assert in a test with multipart message', () => {
 
         expect(() => {
 
             Hoek.assert(false, 'This', 'is', 'my message');
-        }).to.throw('This is my message');
+        }).to.throw(Hoek.AssertError, 'This is my message');
     });
 
     it('throws an Error when using assert in a test with multipart message (empty)', () => {
 
         expect(() => {
 
             Hoek.assert(false, 'This', 'is', '', 'my message');
-        }).to.throw('This is my message');
+        }).to.throw(Hoek.AssertError, 'This is my message');
     });
 
     it('throws an Error when using assert in a test with object message', () => {
 
         expect(() => {
 
             Hoek.assert(false, 'This', 'is', { spinal: 'tap' });
-        }).to.throw('This is {"spinal":"tap"}');
+        }).to.throw(Hoek.AssertError, 'This is {"spinal":"tap"}');
     });
 
     it('throws an Error when using assert in a test with multipart string and error messages', () => {
 
         expect(() => {
 
             Hoek.assert(false, new Error('This'), 'is', 'spinal', new Error('tap'));
-        }).to.throw('This is spinal tap');
+        }).to.throw(Hoek.AssertError, 'This is spinal tap');
     });
 
     it('throws an Error when using assert in a test with error object message', () => {
 
-        const err = new Error('This is spinal tap');
-        const got = expect(() => Hoek.assert(false, err)).to.throw('This is spinal tap');
+        const err = new TypeError('This is spinal tap');
+        const got = expect(() => Hoek.assert(false, err)).to.throw(TypeError, 'This is spinal tap');
         expect(got).to.shallow.equal(err);
     });
 
@@ -2172,6 +2172,34 @@ describe('assert()', () => {
     });
 });
 
+describe('AssertError', () => {
+
+    it('takes an optional message', () => {
+
+        expect(new Hoek.AssertError().message).to.equal('Unknown error');
+        expect(new Hoek.AssertError(null).message).to.equal('Unknown error');
+        expect(new Hoek.AssertError('msg').message).to.equal('msg');
+    });
+
+    it('has AssertError name property', () => {
+
+        expect(new Hoek.AssertError().name).to.equal('AssertError');
+        expect(new Hoek.AssertError('msg').name).to.equal('AssertError');
+    });
+
+    it('uses ctor argument to hide stack', { skip: typeof Error.captureStackTrace !== 'function' }, () => {
+
+        const parentFn = () => {
+
+            throw new Hoek.AssertError('msg', parentFn);
+        };
+
+        const err = expect(parentFn).to.throw(Hoek.AssertError);
+
+        expect(err.stack).to.not.contain('parentFn');
+    });
+});
+
 describe('Bench', () => {
 
     it('returns time elapsed', async () => {

test/index.ts

@@ -348,3 +348,13 @@ function xor(input: Hoek.ts.XOR<X, Y>): number {
 xor({ a: 1 });
 xor({ b: 2 });
 expect.error(xor({ a: 1, b: 2 }));
+
+// AssertError
+
+expect.type<Hoek.AssertError>(new Hoek.AssertError());
+expect.type<Hoek.AssertError>(new Hoek.AssertError('fail'));
+expect.type<'AssertError'>(new Hoek.AssertError().name);
+expect.type<string>(new Hoek.AssertError().message);
+
+expect.error(new Hoek.AssertError(new Error()));
+expect.error(new Hoek.AssertError('fail', 'again'));