Add error type (fixes hapijs#61)

Marsup · Apr 5, 2016 · 2b8ab77 · 2b8ab77
1 parent b456673
commit 2b8ab77
Show file tree

Hide file tree

Showing 2 changed files with 183 additions and 0 deletions.
diff --git a/lib/index.js b/lib/index.js
@@ -169,6 +169,21 @@ internals.addMethod = function (names, fn) {
     internals.addMethod(word, method);
 });
 
+internals.addMethod('error', function (/*type, message*/) {
+
+    const type = arguments.length && typeof arguments[0] !== 'string' && !(arguments[0] instanceof RegExp) ? arguments[0] : Error;
+    const lastArg = arguments[1] || arguments[0];
+    const message = typeof lastArg === 'string' || lastArg instanceof RegExp ? lastArg : null;
+    const err = this._ref;
+
+    this.assert(err instanceof type, 'be an error with ' + (type.name || 'provided') + ' type');
+
+    if (message !== null) {
+        const error = err.message || '';
+        this.assert(typeof message === 'string' ? error === message : error.match(message), 'be an error with specified message', error, message);
+    }
+});
+
 
 [true, false, null, undefined].forEach((value) => {
 

diff --git a/test/index.js b/test/index.js
@@ -496,6 +496,174 @@ describe('expect()', () => {
             });
         });
 
+        describe('error()', () => {
+
+            const error = new Error('kaboom');
+
+            it('validates assertion', (done) => {
+
+                let exception = false;
+                try {
+                    Code.expect(error).to.be.an.error();
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(!exception, exception);
+                done();
+            });
+
+            it('invalidates assertion', (done) => {
+
+                let exception = false;
+                try {
+                    Code.expect(false).to.be.an.error();
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(exception.message === 'Expected false to be an error with Error type', exception);
+                done();
+            });
+
+            it('validates assertion (message)', (done) => {
+
+                let exception = false;
+                try {
+                    Code.expect(error).to.be.an.error('kaboom');
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(!exception, exception);
+                done();
+            });
+
+            it('validates assertion (empty message)', (done) => {
+
+                let exception = false;
+                try {
+                    Code.expect(new Error('')).to.be.an.error('');
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(!exception, exception);
+                done();
+            });
+
+            it('validates assertion (message regex)', (done) => {
+
+                let exception = false;
+                try {
+                    Code.expect(error).to.be.an.error(/boom/);
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(!exception, exception);
+                done();
+            });
+
+            it('validates assertion (missing message)', (done) => {
+
+                const Custom = function () { };
+                Hoek.inherits(Custom, Error);
+
+                let exception = false;
+                try {
+                    Code.expect(new Custom()).to.be.an.error('kaboom');
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(exception.message === 'Expected [Error] to be an error with specified message', exception);
+                done();
+            });
+
+
+            it('invalidates assertion (empty message)', (done) => {
+
+                let exception = false;
+                try {
+                    Code.expect(new Error('kaboom')).to.be.an.error('');
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(exception.message === 'Expected [Error: kaboom] to be an error with specified message', exception);
+                done();
+            });
+
+            it('validates assertion (type)', (done) => {
+
+                let exception = false;
+                try {
+                    Code.expect(error).to.be.an.error(Error);
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(!exception, exception);
+                done();
+            });
+
+            it('invalidates assertion (known type)', (done) => {
+
+                const Custom = function () { };
+
+                let exception = false;
+                try {
+                    Code.expect(new Custom()).to.be.an.error(Error);
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(exception.message === 'Expected {} to be an error with Error type', exception);
+                done();
+            });
+
+            it('invalidates assertion (anonymous type)', (done) => {
+
+                const Custom = function () { };
+                Hoek.inherits(Custom, Error);
+
+                let exception = false;
+                try {
+                    Code.expect(error).to.be.an.error(Custom);
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(exception.message === 'Expected [Error: kaboom] to be an error with provided type', exception);
+                done();
+            });
+
+            it('validates assertion (type and message)', (done) => {
+
+                let exception = false;
+                try {
+                    Code.expect(error).to.be.an.error(Error, 'kaboom');
+                }
+                catch (err) {
+                    exception = err;
+                }
+
+                Hoek.assert(!exception, exception);
+                done();
+            });
+        });
+
         describe('function()', () => {
 
             it('validates correct type', (done) => {