code review

Author: Thomas Grainger

Diff for: test/ng/qSpec.js

@@ -2165,15 +2165,40 @@ describe('q', function() {
 
 
   describe('when exceptionHandler is called', function() {
-    var exceptionEg = new Error('Fail');
-    var exceptionStr = toDebugString(exceptionEg);
+    function CustomError() { }
+    CustomError.prototype = Object.create(Error.prototype);
+
+    var errorEg = new Error('Fail');
+    var errorStr = toDebugString(errorEg);
+
+    var customError = new CustomError('Custom');
+    var customErrorStr = toDebugString(customError);
+
+    var nonErrorObj = { isATest: 'this is' };
+    var nonErrorObjStr = toDebugString(nonErrorObj);
+
     var fixtures = [
       {
-        type: 'exception',
-        value: exceptionEg,
+        type: 'Error object',
+        value: errorEg,
+        expected: {
+          exception: errorEg,
+          reason: 'Possibly unhandled rejection: ' + errorStr
+        }
+      },
+      {
+        type: 'Custom Error object',
+        value: customError,
         expected: {
-          exception: exceptionEg,
-          reason: 'Possibly unhandled rejection: ' + exceptionStr
+          exception: customError,
+          reason: 'Possibly unhandled rejection: ' + customErrorStr
+        }
+      },
+      {
+        type: 'Non-Error object',
+        value: nonErrorObj,
+        expected: {
+          reason: 'Possibly unhandled rejection: ' + nonErrorObjStr
         }
       },
       {
@@ -2188,45 +2213,48 @@ describe('q', function() {
       var type = fixture.type;
       var value = fixture.value;
       var expected = fixture.expected;
-      it('should log an unhandled' + type + ' rejected promise', function() {
-        var defer = q.defer();
-        defer.reject(value);
-        mockNextTick.flush();
-        expect(exceptionHandlerCalls).toEqual([expected]);
-      });
+      describe(type, function() {
+
+        it('should log an unhandled rejected promise', function() {
+          var defer = q.defer();
+          defer.reject(value);
+          mockNextTick.flush();
+          expect(exceptionHandlerCalls).toEqual([expected]);
+        });
 
 
-      it('should not log an unhandled' + type + ' rejected promise if disabled', function() {
-        var defer = q_no_error.defer();
-        defer.reject(value);
-        expect(exceptionHandlerCalls).toEqual([]);
-      });
+        it('should not log an unhandled rejected promise if disabled', function() {
+          var defer = q_no_error.defer();
+          defer.reject(value);
+          expect(exceptionHandlerCalls).toEqual([]);
+        });
 
 
-      it('should log a handled' + type + ' rejected promise on a promise without rejection callbacks', function() {
-        var defer = q.defer();
-        defer.promise.then(noop);
-        defer.reject(value);
-        mockNextTick.flush();
-        expect(exceptionHandlerCalls).toEqual([expected]);
-      });
+        it('should log a handled rejected promise on a promise without rejection callbacks', function() {
+          var defer = q.defer();
+          defer.promise.then(noop);
+          defer.reject(value);
+          mockNextTick.flush();
+          expect(exceptionHandlerCalls).toEqual([expected]);
+        });
 
 
-      it('should not log a handled' + type + 'rejected promise', function() {
-        var defer = q.defer();
-        defer.promise.catch(noop);
-        defer.reject(value);
-        mockNextTick.flush();
-        expect(exceptionHandlerCalls).toEqual([]);
-      });
+        it('should not log a handled rejected promise', function() {
+          var defer = q.defer();
+          defer.promise.catch(noop);
+          defer.reject(value);
+          mockNextTick.flush();
+          expect(exceptionHandlerCalls).toEqual([]);
+        });
 
 
-      it('should not log a handled' + type + ' rejected promise that is handled in a future tick', function() {
-        var defer = q.defer();
-        defer.promise.catch(noop);
-        defer.resolve(q.reject(value));
-        mockNextTick.flush();
-        expect(exceptionHandlerCalls).toEqual([]);
+        it('should not log a handled rejected promise that is handled in a future tick', function() {
+          var defer = q.defer();
+          defer.promise.catch(noop);
+          defer.resolve(q.reject(value));
+          mockNextTick.flush();
+          expect(exceptionHandlerCalls).toEqual([]);
+        });
       });
     });
   });