[cdnjs gem] make exception classes more consistent

lib/error-helper.js

@@ -26,10 +26,10 @@ const checkErrorResponse = function(badgeData, err, res, notFoundMessage = 'not
 checkErrorResponse.asPromise = function ({ notFoundMessage } = {}) {
   return async function ({ buffer, res }) {
     if (res.statusCode === 404) {
-      throw new NotFound(notFoundMessage);
+      throw new NotFound({ prettyMessage: notFoundMessage });
     } else if (res.statusCode !== 200) {
       const underlying = Error(`Got status code ${res.statusCode} (expected 200)`);
-      throw new InvalidResponse(undefined, underlying);
+      throw new InvalidResponse({ underlyingError: underlying});
     }
     return { buffer, res };
   };
@@ -39,7 +39,7 @@ async function asJson({ buffer, res }) {
   try {
     return JSON.parse(buffer);
   } catch (err) {
-    throw new InvalidResponse(undefined, err);
+    throw new InvalidResponse({ underlyingError: err });
   }
 };
 

lib/request-handler.js

@@ -176,7 +176,7 @@ function handleRequest (makeBadge, handlerOptions) {
         if (err) {
           // Wrap the error in an Inaccessible so it can be identified
           // by the BaseService handler.
-          reject(new Inaccessible(err));
+          reject(new Inaccessible({ underlyingError: err }));
         } else {
           resolve({ res, buffer });
         }

services/errors.js

@@ -1,34 +1,60 @@
 'use strict';
 
-class NotFound extends Error {
-  constructor(prettyMessage = 'not found') {
+class ShieldsRuntimeError extends Error {
+
+  get name() { return 'ShieldsRuntimeError'; }
+  get defaultPrettyMessage() { throw new Error('Must implement abstract method'); }
+
+  constructor(props, message) {
+    props = props || {};
+    super(message);
+    this.prettyMessage = props.prettyMessage || this.defaultPrettyMessage;
+    if (props.underlyingError) {
+      this.stack = props.underlyingError.stack;
+    }
+  }
+}
+
+class NotFound extends ShieldsRuntimeError {
+
+  get name() { return 'NotFound'; }
+  get defaultPrettyMessage() { return 'not found'; }
+
+  constructor(props) {
+    props = props || {};
+    const prettyMessage = props.prettyMessage || 'not found';
     const message = prettyMessage === 'not found'
       ? 'Not Found'
       : `Not Found: ${prettyMessage}`;
-    super(message);
-    this.prettyMessage = prettyMessage;
-    this.name = 'NotFound';
+    super(props, message);
   }
 }
 
-class InvalidResponse extends Error {
-  constructor(prettyMessage = 'invalid', underlyingError) {
-    const message = underlyingError
-      ? `Invalid Response: ${underlyingError.message}`
+class InvalidResponse extends ShieldsRuntimeError {
+
+  get name() { return 'InvalidResponse'; }
+  get defaultPrettyMessage() { return 'invalid'; }
+
+  constructor(props) {
+    props = props || {};
+    const message = props.underlyingError
+      ? `Invalid Response: ${props.underlyingError.message}`
       : 'Invalid Response';
-    super(message);
-    this.stack = underlyingError.stack;
-    this.prettyMessage = prettyMessage;
-    this.name = 'InvalidResponse';
+    super(props, message);
   }
 }
 
-class Inaccessible extends Error {
-  constructor(underlyingError, prettyMessage = 'inaccessible') {
-    super(`Inaccessible: ${underlyingError.message}`);
-    this.stack = underlyingError.stack;
-    this.prettyMessage = prettyMessage;
-    this.name = 'Inaccessible';
+class Inaccessible extends ShieldsRuntimeError {
+
+  get name() { return 'Inaccessible'; }
+  get defaultPrettyMessage() { return 'inaccessible'; }
+
+  constructor(props) {
+    props = props || {};
+    const message = props.underlyingError
+      ? `Inaccessible: ${props.underlyingError.message}`
+      : 'Inaccessible';
+    super(props, message);
   }
 }
 

services/gem/gem.js

@@ -129,11 +129,11 @@ class GemDownloads extends BaseService {
 
         downloads = metric(versionData.downloads_count);
       } else {
-        throw new InvalidResponse('invalid', new Error('version is null'));
+        throw new InvalidResponse({ underlyingError: new Error('version is null') });
       }
 
     } else {
-      throw new InvalidResponse('invalid', new Error('info is invalid'));
+      throw new InvalidResponse({ underlyingError: new Error('info is invalid') });
     }
 
     return {