feat(core): improve error handling for package.json config reader and add more tests

Ovidiu Barabula · Ovidiu Barabula · commit fa445ca92c68 · 2018-03-25T16:59:43.000+03:00
diff --git a/src/config-manager/package-json-config-reader.spec.ts b/src/config-manager/package-json-config-reader.spec.ts
@@ -1,67 +1,80 @@
+import * as chai from 'chai';
+import * as chaiAspromised from 'chai-as-promised';
+chai.use(chaiAspromised);
+
 import { assert, expect } from 'chai';
 import * as fs from 'fs';
 import 'mocha';
 import * as mockfs from 'mock-fs';
 import * as path from 'path';
+import Logger from '../util/logger';
 import PackageJsonConfigReader, { ERRORS } from './package-json-config-reader';
 
 describe('PackageJsonConfigReader', () => {
   const testDir = '/tmp/tests/';
   const priorConfiguredFile = 'priorConfiguredFile.json';
   const noConfigFile = 'noConfigFile.json';
   const noFrontvueConfigFile = 'noFrontVueConfigFile.json';
+  const nonExistingFile = 'nonExistingConfigFile.json';
+  const readonlyConfigFile = 'readonlyConfigFile.json';
 
+  // Restore FileSystem
+  before(mockfs.restore);
+  // Mock FileSystem with dummy files
   beforeEach(() => {
+    mockfs.restore();
+    const noConfigContent = '{}';
+    const noFrontvueConfigContent = `{ "config": { "somePlugin": {} } }`;
+    const withConfigContent = `{ "config": { "frontvue": { "key": "value" } } }`;
     mockfs({
       [testDir]: {
-        [noConfigFile]: `{}`,
-        [noFrontvueConfigFile]: `{
-          "config": {
-            "somePlugin": {}
-          }
-        }`,
-        [priorConfiguredFile]: `{
-          "config": {
-            "frontvue": {
-              "key": "value"
-            }
-          }
-        }`,
+        [noConfigFile]: noConfigContent,
+        [noFrontvueConfigFile]: noFrontvueConfigContent,
+        [priorConfiguredFile]: withConfigContent,
+        [readonlyConfigFile]: mockfs.file({ content: withConfigContent, mode: 0o440 }),
       },
     });
   });
+  // Clean up
+  afterEach(mockfs.restore);
+  after(async () => {
+    return PackageJsonConfigReader('frontvue')
+      .then(configReader => configReader.destroy());
+  });
 
-
-  it('throws if no namespace is passed', async () => {
-    await PackageJsonConfigReader(undefined).catch((error: Error) => {
-      expect(error.message, ERRORS.NO_NAMESPACE);
-    });
+  it('instantiates with no namespace', () => {
+    // Reading actual package.json from current folder
+    mockfs.restore();
+    return expect(PackageJsonConfigReader())
+      .to.eventually.have.all.keys('destroy', 'fetch', 'update');
   });
 
 
-  it('throws if namespace is not a string', async () => {
-    await PackageJsonConfigReader(1).catch((error: Error) => {
-      expect(error.message, ERRORS.NO_NAMESPACE);
-    });
+  it('throws if namespace is not a string', () => {
+    // Reading actual package.json from current folder
+    mockfs.restore();
+    return expect(PackageJsonConfigReader(1))
+      .to.be.rejectedWith(ERRORS.INVALID_NAMESPACE);
   });
 
 
-  it('instantiates with no custom filepath', async () => {
+  it('instantiates with no custom filepath', () => {
+    // Reading actual package.json from current folder
     mockfs.restore();
-    expect(await PackageJsonConfigReader('frontvue'))
-      .to.be.an('object')
-      .to.have.all.keys('destroy', 'fetch', 'update');
+    return expect(PackageJsonConfigReader('frontvue'))
+      .to.eventually.be.an('object')
+      .to.eventually.have.all.keys('destroy', 'fetch', 'update');
   });
 
 
   it('instantiates without any config object', async () => {
     const filepath = path.join(testDir, noConfigFile);
     const configReader = await PackageJsonConfigReader('frontvue', filepath);
     const config = await configReader.fetch();
-    const fileContents = await fs.readFile(filepath, { encoding: 'utf-8' }, (error, data) => {
+    const fileContents = fs.readFile(filepath, { encoding: 'utf-8' }, (error, data) => {
       expect(JSON.parse(data)).to.eql({config: { frontvue: {} }});
     });
-  });
+  }).timeout(12000);
 
 
   it('instantiates without Frontvue config object', async () => {
@@ -71,21 +84,21 @@ describe('PackageJsonConfigReader', () => {
     const fileContents = await fs.readFile(filepath, { encoding: 'utf-8' }, (error, data) => {
       expect(JSON.parse(data)).to.eql({config: { somePlugin: {}, frontvue: {} }});
     });
-  });
+  }).timeout(12000);
 
 
   it('instantiates with prior Frontvue config object', async () => {
     const filepath = path.join(testDir, priorConfiguredFile);
     const configReader = await PackageJsonConfigReader('frontvue', filepath);
-    expect(await configReader.fetch()).to.eql({ key: 'value' });
+    return expect(configReader.fetch()).to.eventually.eql({ key: 'value' });
   });
 
 
   it('updates config object', async () => {
     const filepath = path.join(testDir, noConfigFile);
     const configReader = await PackageJsonConfigReader('frontvue', filepath);
     const updated = await configReader.update({ key: 'value' });
-    expect(await configReader.fetch()).to.eql({ key: 'value' });
+    return expect(configReader.fetch()).to.eventually.eql({ key: 'value' });
   });
 
 
@@ -97,5 +110,55 @@ describe('PackageJsonConfigReader', () => {
   });
 
 
-  afterEach(mockfs.restore);
+  it('accepts custom logger', () => {
+    const filepath = path.join(testDir, priorConfiguredFile);
+    return expect(
+      PackageJsonConfigReader('frontvue', filepath, Logger('frontvue')('customLogger')),
+    ).to.eventually.not.throw;
+  }).timeout(12000);
+
+
+  it('rejects promise if filepath config file can\'t be read', () => {
+    return expect(PackageJsonConfigReader('frontvue', path.join(testDir, nonExistingFile)))
+      .to.be.rejectedWith(RegExp(ERRORS.RW_ERROR));
+  }).timeout(12000);
+
+
+  it('rejects promise if refetching config from file fails', async () => {
+    const filepath = path.join(testDir, priorConfiguredFile);
+    const configReader = await PackageJsonConfigReader('frontvue', filepath);
+    // We destroy the mocked fs and replace the file with something that can't be read
+    mockfs.restore();
+    mockfs({
+      [testDir]: {
+        [priorConfiguredFile]: '',
+      },
+    });
+    return expect(configReader.fetch()).to.be.rejectedWith(RegExp(ERRORS.RW_ERROR));
+  }).timeout(12000);
+
+
+  it('rejects promise if destroy fails after initial config file fetch', async () => {
+    const filepath = path.join(testDir, priorConfiguredFile);
+    const configReader = await PackageJsonConfigReader('frontvue', filepath);
+    // We destroy the mocked fs and recreate the file with something that can't be read
+    mockfs.restore();
+    mockfs({
+      [testDir]: {
+        [priorConfiguredFile]: mockfs.file({
+          content: 'File content',
+          mode: 0o330,
+        }),
+      },
+    });
+
+    return expect(configReader.destroy()).to.be.rejectedWith(RegExp(ERRORS.RW_ERROR));
+  });
+
+
+  it('rejects promise if trying to destroy from readonly file', async () => {
+    const filepath = path.join(testDir, readonlyConfigFile);
+    const configReader = await PackageJsonConfigReader('frontvue', filepath);
+    return expect(configReader.destroy()).to.be.rejectedWith(Error);
+  }).timeout(12000);
 });
diff --git a/src/config-manager/package-json-config-reader.ts b/src/config-manager/package-json-config-reader.ts
@@ -6,46 +6,110 @@
  */
 
 import FileReader from '../util/file-reader';
-import { hasNested } from '../util/utility-functions';
+import Logger, { ILogger } from '../util/logger';
+import { hasNested, retry } from '../util/utility-functions';
 
 export interface Config {
   [key: string]: any;
 }
 
 export interface ConfigReader {
-  destroy(): Promise<Config>;
-  fetch(): Promise<Config>;
-  update(config: Config): Promise<boolean>;
+  destroy(): Promise<Config|Error>;
+  fetch(): Promise<Config|Error>;
+  update(config: Config): Promise<boolean|Error>;
 }
 
 export type ConfigReaderConstructor = (namespace: string, filepath?: string) => ConfigReader;
 
 export const ERRORS = {
-  NO_NAMESPACE: 'PackageJsonConfigReader requires parameter 1 to be string',
+  INVALID_NAMESPACE: 'PackageJsonConfigReader() requires parameter 1 to be string',
+  RW_ERROR: 'PackageJsonConfigReader> An error occured while reading/writing the file',
 };
 
 
 /**
  * Factory function for package.json configuration reader
  * @param namespace Configuration key in package.json 'config' object
+ * @param filepath Custom file path to store/get configuration
+ * @param logger Instance of a logger that implements ILogger interface
  */
-async function PackageJsonConfigReader(namespace: string, filepath?: string): Promise<ConfigReader> {
-  if (typeof namespace === 'undefined') {
-    throw new Error(ERRORS.NO_NAMESPACE);
+async function PackageJsonConfigReader(
+  namespace: string = 'frontvue',
+  filepath: string = './package.json',
+  logger: ILogger = Logger('frontvue')('packageJsonConfigReader'),
+): Promise<ConfigReader> {
+  if (typeof namespace !== 'string') {
+    throw new Error(ERRORS.INVALID_NAMESPACE);
   }
 
-  if (typeof namespace !== 'string') {
-    throw new Error(ERRORS.NO_NAMESPACE);
+  // Get config file contents and catch any errors
+  const configFile = FileReader(filepath);
+  let packageJson: Config;
+  try {
+    packageJson = await readConfigFile();
+  } catch (error) {
+    return Promise.reject(errorHandler(error));
   }
 
-  const configFile = FileReader(filepath || './package.json');
-  const packageJson = await configFile.read();
+
+  /**
+   * Read configuration file
+   */
+  async function readConfigFile(): Promise<Config|Error> {
+    // Catch any errors when retrieving file contents
+    try {
+      return await retry(configFile.read, { logChannel: 'packageJsonConfigReader' });
+    } catch (error) {
+      return Promise.reject(errorHandler(error));
+    }
+  }
+
+
+  /**
+   * Refetch config file contents
+   */
+  async function refetchConfigFileContents(): Promise<void|Error> {
+    try {
+      packageJson = await readConfigFile();
+      return undefined;
+    } catch (error) {
+      return Promise.reject(errorHandler());
+    }
+  }
+
+
+  /**
+   * Write config object to configuration file
+   * @param config Config object
+   */
+  async function writeConfigFile(config: Config): Promise<boolean|Error> {
+    // retry() requires a function and we can't pass configFile.write without the config object
+    const writeConfigToFile = async () => await configFile.write(config);
+
+    // Update the file
+    try {
+      return await retry(writeConfigToFile, { logChannel: 'packageJsonConfigReader' });
+    } catch (error) {
+      return Promise.reject(errorHandler());
+    }
+  }
+
+
+  /**
+   * Handler for failed promise
+   * @param error Error object
+   */
+  function errorHandler(error?: Error): Error {
+    const errorMessage = error ? `\n  ${error.message}` : '';
+    logger.fatal(`${ERRORS.RW_ERROR} ${errorMessage}`);
+    return new Error(ERRORS.RW_ERROR);
+  }
 
 
   /**
    * Initialize empty configuration if not found
    */
-  async function initializeEmptyConfig(): Promise<boolean> {
+  async function initializeEmptyConfig(): Promise<boolean|Error> {
     if (hasNested(packageJson, 'config')) {
       packageJson.config[namespace] = {};
     } else {
@@ -54,43 +118,58 @@ async function PackageJsonConfigReader(namespace: string, filepath?: string): Pr
       };
     }
 
-    const written = await configFile.write(packageJson);
-    return written;
+    return await writeConfigFile(packageJson);
+  }
+
+
+  /**
+   * Delete namespace from config file
+   */
+  function removeNamespaceFromConfig(): void {
+    // Delete config object
+    packageJson.config[namespace] = undefined;
+    packageJson = JSON.parse(JSON.stringify(packageJson));
   }
 
 
   /**
    * Fetch configuration object
    */
   async function fetch(): Promise<Config> {
-    return new Promise((resolve, reject) => {
-      return resolve(packageJson.config[namespace]);
-    });
+    await refetchConfigFileContents();
+    return Promise.resolve(packageJson.config[namespace]);
   }
 
 
   /**
    * Update configuration object
    * @param config New configuration object
    */
-  async function update(config: Config) {
+  async function update(config: Config): Promise<boolean|Error> {
     packageJson.config[namespace] = {...packageJson.config[namespace], ...config};
-    const updated = await configFile.write(packageJson);
-    return updated;
+
+    // Update the file
+    return await writeConfigFile(packageJson);
   }
 
 
   /**
    * Remove configuration from file and return the removed config object
    */
-  async function destroy(): Promise<Config> {
-    // Save existing config
-    const fileContent = await configFile.read();
-    // Delete config object
-    delete packageJson.config[namespace];
-    // Update the file
-    await configFile.write(packageJson);
-    return fileContent.config[namespace];
+  async function destroy(): Promise<Config|Error> {
+    await refetchConfigFileContents();
+
+    try {
+      // Store it to be returned later
+      const config: Config = packageJson.config[namespace];
+      // Delete config object
+      removeNamespaceFromConfig();
+      // If the file was saved, return the removed config object
+      await writeConfigFile(packageJson);
+      return config;
+    } catch (error) {
+      return Promise.reject(error);
+    }
   }
 
 
