feat(core): improve error handling for config manager and add tests

Ovidiu Barabula · Ovidiu Barabula · commit c859efe37332 · 2018-03-25T17:00:34.000+03:00
diff --git a/src/config-manager/index.spec.ts b/src/config-manager/index.spec.ts
@@ -1,20 +1,29 @@
 import { assert, expect } from 'chai';
 import 'mocha';
 import * as path from 'path';
-import ConfigManager, { IConfigManager } from './index';
+import { stdout } from 'test-console';
+import Logger from '../util/logger';
+import ConfigManager, { ERRORS, IConfigManager } from './index';
 import { Config, ConfigReader } from './package-json-config-reader';
 
 describe('ConfigManager', () => {
-  const testDir = '/tmp/tests/';
-  const configFile = 'package.json';
   let configManager: IConfigManager;
 
-
-  beforeEach(async () => configManager = await ConfigManager('frontvue'));
+  beforeEach(async function () {
+    this.timeout(12000);
+    configManager = await ConfigManager('frontvue');
+  });
 
 
   it('instantiates', async () => {
-    expect(configManager).to.be.an('object').to.have.all.keys('get', 'has', 'remove', 'set');
+    expect(configManager).to.be.an('object')
+      .to.contain.keys('get', 'has', 'remove', 'set');
+  });
+
+
+  it('instantiates with default namespace', async () => {
+    expect(await ConfigManager()).to.be.an('object')
+      .to.contain.keys('get', 'has', 'remove', 'set');
   });
 
 
@@ -36,9 +45,15 @@ describe('ConfigManager', () => {
         },
       };
     };
-
     const customConfigManager = await ConfigManager('frontvue', customReader);
-    expect(customConfigManager).to.be.an('object').to.have.all.keys('get', 'has', 'remove', 'set');
+    expect(customConfigManager).to.be.an('object')
+      .to.contain.keys('get', 'has', 'remove', 'set');
+  });
+
+
+  it('instantiates with custom logger', async () => {
+    const customLogger = Logger('frontvue')('customConfigManager');
+    const configManagerWithLogger = await ConfigManager('frontvue', undefined, customLogger);
   });
 
 
@@ -89,4 +104,89 @@ describe('ConfigManager', () => {
     const removed = await configManager.remove('key2', 'key3');
     expect(await configManager.get()).to.eql({});
   });
+
+
+  it('console logs even if errorHandler did not receive an error', () => {
+    const inspect = stdout.inspect();
+    configManager.errorHandler();
+    inspect.restore();
+    expect(inspect.output.length).to.gt(0);
+  });
+
+
+  describe('Inaccessible configuration', () => {
+    // Stub for customReader with errors
+    const badCustomReaderFactory = (
+      options: {
+        badDestroy?: boolean,
+        badFetch?: boolean,
+        badUpdate?: boolean,
+      } = {},
+    ) => {
+      const {
+        badDestroy = false,
+        badFetch = false,
+        badUpdate = false,
+      } = options;
+
+      // Custom reader with very nasty errors
+      return function (namespace: string): ConfigReader {
+        return {
+          destroy(): Promise<Config|Error> {
+            if (badDestroy) {
+              return Promise.reject(new Error('customReader> Some nasty destroy() error here'));
+            }
+            return Promise.resolve({});
+          },
+          fetch(): Promise<Config|Error> {
+            if (badFetch) {
+              return Promise.reject(new Error('customReader> Some nasty fetch() error here'));
+            }
+            return Promise.resolve({});
+          },
+          update(object: object): Promise<boolean|Error> {
+            if (badUpdate) {
+              return Promise.reject(new Error('customReader> Some nasty update() error here'));
+            }
+            return Promise.resolve(true);
+          },
+        };
+      };
+    };
+
+
+    it('returns rejected promise when configReader fails to instantiate', async () => {
+      const customReader = () => {
+        return new Promise((resolve, reject) => {
+          reject(new Error('customReader> Some nasty init error here'));
+        });
+      };
+
+      return expect(ConfigManager('frontvue', customReader))
+        .to.be.rejectedWith(Error);
+    });
+
+
+    it('returns a rejected promise when configuration cannot be fetched', async () => {
+      const customReader = badCustomReaderFactory({ badFetch: true });
+      return expect(ConfigManager('frontvue', customReader))
+        .to.be.rejectedWith(Error);
+    });
+
+
+    it('returns a rejected promise when .set() fails', async () => {
+      const customReader = badCustomReaderFactory({ badUpdate: true });
+      const badConfigManager = await ConfigManager('frontvue', customReader);
+      return expect(badConfigManager.set('key', 'value'))
+        .to.be.rejectedWith(Error);
+    });
+
+
+    it('returns a rejected promise when .remove() fails', async () => {
+      const customReader = badCustomReaderFactory({ badUpdate: true });
+      const badConfigManager = await ConfigManager('frontvue', customReader);
+      return expect(badConfigManager.remove('key'))
+        .to.be.rejectedWith(Error);
+    });
+  });
 });
diff --git a/src/config-manager/index.ts b/src/config-manager/index.ts
@@ -5,6 +5,7 @@
  * @since 0.1.0
  */
 
+import Logger, { ILogger } from '../util/logger';
 import PackageJsonConfigReader, {
   Config,
   ConfigReader,
@@ -15,10 +16,14 @@ import PackageJsonConfigReader, {
 export interface IConfigManager {
   has(key: string): Promise<boolean>;
   get(key?: string): Promise<Config | any>;
-  set(option: Config | string, value?: any): Promise<boolean>;
-  remove(...options: string[]): Promise<boolean>;
+  set(option: Config | string, value?: any): Promise<boolean|Error>;
+  remove(...options: string[]): Promise<boolean|Error>;
+  errorHandler?(error?: Error): Error;
 }
 
+export const ERRORS = {
+  CONFIG_FETCH_FAILED: 'There was an error while accessing the configuration:',
+};
 
 /**
  * Configuration manager constructor
@@ -27,22 +32,47 @@ export interface IConfigManager {
  * @param customReader Custom ConfigReader
  */
 async function ConfigManager(
-  namespace: string,
+  namespace: string = 'frontvue',
   customReader?: ConfigReaderConstructor,
+  logger: ILogger = Logger('frontvue')('ConfigManager'),
 ): Promise<IConfigManager> {
   let configReader: ConfigReader;
 
-  // Check for custom config reader
-  if (customReader && typeof customReader === 'function') {
-    // Initialize custom config reader
-    configReader = customReader(namespace);
-  } else {
-    // If not, stick with the default config reader
-    configReader = await PackageJsonConfigReader(namespace);
+  // Instantiate configReader
+  try {
+    // Check for custom config reader
+    if (customReader && typeof customReader === 'function') {
+      // Initialize custom config reader
+      // Wrap customReader with a promise to handle this asynchronous
+      configReader = await Promise.resolve(customReader(namespace));
+    } else {
+      // If not, stick with the default config reader
+      configReader = await PackageJsonConfigReader(namespace);
+    }
+  } catch (error) {
+    return Promise.reject(errorHandler(error));
+  }
+
+
+  // Catch any errors when fetching configuration object
+  let config: Config;
+  try {
+    // Get the configuration contents
+    config = await configReader.fetch();
+  } catch (error) {
+    return Promise.reject(errorHandler(error));
   }
 
-  // Get the configuration contents
-  let config: Config = await configReader.fetch();
+
+  /**
+   * Error handler function
+   * @param error Caught error
+   */
+  function errorHandler(error?: Error): Error {
+    const errorMessage = error ? `\n  ${error.message}` : '';
+    logger.fatal(`${ERRORS.CONFIG_FETCH_FAILED} ${errorMessage}`);
+    return new Error(ERRORS.CONFIG_FETCH_FAILED);
+  }
 
 
   /**
@@ -75,7 +105,7 @@ async function ConfigManager(
    * @param option Configuration object or object key
    * @param value New value to be set if option is an object key ("string")
    */
-  async function set(option: Config | string, value?: any): Promise<boolean> {
+  async function set(option: Config | string, value?: any): Promise<boolean|Error> {
     // If we're passing in a "key" and a "value"
     if (typeof option === 'string' && typeof value !== 'undefined') {
       config[option] = value;
@@ -86,29 +116,48 @@ async function ConfigManager(
       return false;
     }
 
-    const saved: boolean = await configReader.update(config);
-    return saved;
+    try {
+      const saved: boolean | Error = await configReader.update(config);
+      return saved;
+    } catch (error) {
+      return Promise.reject(errorHandler(error));
+    }
+
   }
 
 
   /**
    * Removes one or more options from config
    * @param option Option name or array of option names
    */
-  async function remove(...options: string[]): Promise<boolean> {
+  async function remove(...options: string[]): Promise<boolean|Error> {
     options.forEach(item => delete config[item]);
-    const saved: boolean = await configReader.update(config);
-    return saved;
+    try {
+      const saved: boolean | Error = await configReader.update(config);
+      return saved;
+    } catch (error) {
+      return Promise.reject(errorHandler(error));
+    }
   }
 
-
-  // Returning config manager public API
-  return Object.freeze({
+  // Creating the public API object
+  let publicApi: IConfigManager = {
     get,
     has,
     remove,
     set,
-  });
+  };
+
+  // Adding private methods to public API in test environment
+  /* test:start */
+  publicApi = {...publicApi,
+    errorHandler,
+  };
+  /* test:end */
+
+
+  // Returning config manager public API
+  return Object.freeze(publicApi);
 }
 
 export default ConfigManager;
