feat: basic implementation of command line config option

src/config.js

@@ -6,7 +6,7 @@ import camelCase from 'camelcase';
 import decamelize from 'decamelize';
 
 import {createLogger} from './util/logger';
-import {UsageError, WebExtError} from './errors';
+import {UsageError} from './errors';
 
 const log = createLogger(__filename);
 
@@ -50,7 +50,7 @@ export function applyConfigToArgv({
         `an unknown option: "${option}"`);
     }
     if (options[decamelizedOptName].type === undefined) {
-      throw new WebExtError(
+      throw new UsageError(
         `Option: ${option} was defined without a type.`);
     }
 
@@ -109,4 +109,4 @@ export function loadJSConfigFile(filePath: string): Object {
       'Did you set module.exports = {...}?');
   }
   return configObject;
-}
+}

src/program.js

@@ -11,6 +11,10 @@ import {UsageError} from './errors';
 import {createLogger, consoleStream as defaultLogStream} from './util/logger';
 import {coerceCLICustomPreference} from './firefox/preferences';
 import {checkForUpdates as defaultUpdateChecker} from './util/updates';
+import {
+  loadJSConfigFile as defaultLoadJSConfigFile,
+  applyConfigToArgv as defaultApplyConfigToArgv,
+} from './config';
 
 const log = createLogger(__filename);
 const envPrefix = 'WEB_EXT';
@@ -20,13 +24,17 @@ type ProgramOptions = {|
   absolutePackageDir?: string,
 |}
 
+export type VersionGetterFn = (absolutePackageDir: string) => string;
+
 // TODO: add pipes to Flow type after https://github.com/facebook/flow/issues/2405 is fixed
 
 type ExecuteOptions = {
   checkForUpdates?: Function,
   systemProcess?: typeof process,
   logStream?: typeof defaultLogStream,
-  getVersion?: Function,
+  getVersion?: VersionGetterFn,
+  applyConfigToArgv?: typeof defaultApplyConfigToArgv,
+  loadJSConfigFile?: typeof defaultLoadJSConfigFile,
   shouldExitProgram?: boolean,
   globalEnv?: string,
 }
@@ -115,6 +123,8 @@ export class Program {
     {
       checkForUpdates = defaultUpdateChecker, systemProcess = process,
       logStream = defaultLogStream, getVersion = defaultVersionGetter,
+      applyConfigToArgv = defaultApplyConfigToArgv,
+      loadJSConfigFile = defaultLoadJSConfigFile,
       shouldExitProgram = true, globalEnv = WEBEXT_BUILD_ENV,
     }: ExecuteOptions = {}
   ): Promise<void> {
@@ -145,6 +155,17 @@ export class Program {
         });
       }
 
+      if (argv.config) {
+        const configFileName = path.resolve(argv.config);
+        const configObject = loadJSConfigFile(configFileName);
+        applyConfigToArgv({
+          argv,
+          configFileName,
+          configObject,
+          options: this.options,
+        });
+      }
+
       await runCommand(argv, {shouldExitProgram});
 
     } catch (error) {
@@ -194,7 +215,7 @@ export function defaultVersionGetter(
 // TODO: add pipes to Flow type after https://github.com/facebook/flow/issues/2405 is fixed
 
 type MainParams = {
-  getVersion?: Function,
+  getVersion?: VersionGetterFn,
   commands?: Object,
   argv: Array<any>,
   runOptions?: Object,
@@ -265,6 +286,13 @@ Example: $0 --help run.
       describe: 'Disable all features that require standard input',
       type: 'boolean',
     },
+    'config': {
+      alias: 'c',
+      describe: 'Location of the config file',
+      default: undefined,
+      requiresArg: true,
+      type: 'string',
+    },
   });
 
   program

src/util/logger.js

@@ -110,7 +110,7 @@ export type CreateBunyanLogParams = {|
 export type CreateBunyanLogFn = (params: CreateBunyanLogParams) => Logger;
 
 export type CreateLoggerOptions = {|
-  createBunyanLog: CreateBunyanLogFn,
+  createBunyanLog?: CreateBunyanLogFn,
 |};
 
 export function createLogger(

tests/unit/test.config.js

@@ -12,7 +12,7 @@ import {
   loadJSConfigFile,
 } from '../../src/config';
 import {withTempDir} from '../../src/util/temp-dir';
-import {UsageError, WebExtError} from '../../src/errors';
+import {UsageError} from '../../src/errors';
 
 type MakeArgvParams = {|
   userCmd?: Array<string>,
@@ -657,8 +657,8 @@ describe('config', () => {
       };
       assert.throws(() => {
         applyConf({...params, configObject});
-      }, WebExtError,
-        'WebExtError: Option: apiUrl was defined without a type.');
+      }, UsageError,
+        'UsageError: Option: apiUrl was defined without a type.');
     });
 
     it('throws an error when the type of one of them is in config' +
@@ -688,8 +688,8 @@ describe('config', () => {
       };
       assert.throws(() => {
         applyConf({...params, configObject});
-      }, WebExtError,
-        'WebExtError: Option: apiUrl was defined without a type.');
+      }, UsageError,
+        'UsageError: Option: apiUrl was defined without a type.');
     });
 
     it('throws an error when type of unrelated sub option is invalid', () => {

tests/unit/test.program.js

@@ -9,15 +9,20 @@ import {assert} from 'chai';
 
 import {defaultVersionGetter, main, Program} from '../../src/program';
 import commands from '../../src/cmd';
-import {onlyInstancesOf, UsageError} from '../../src/errors';
+import {
+  onlyInstancesOf,
+  UsageError,
+} from '../../src/errors';
 import {
   createFakeProcess,
   fake,
   makeSureItFails,
   ErrorWithCode,
 } from './helpers';
-import {ConsoleStream} from '../../src/util/logger';
-
+import {
+  consoleStream,
+  ConsoleStream,
+} from '../../src/util/logger';
 
 describe('program.Program', () => {
 
@@ -26,7 +31,7 @@ describe('program.Program', () => {
     const absolutePackageDir = path.join(__dirname, '..', '..');
     return program.execute(
       absolutePackageDir, {
-        getVersion: () => spy(),
+        getVersion: () => 'not-a-real-version',
         checkForUpdates: spy(),
         systemProcess: fakeProcess,
         shouldExitProgram: false,
@@ -430,6 +435,205 @@ describe('program.main', () => {
       assert.strictEqual(options.shouldExitProgram, false);
     });
   });
+
+  it('applies options from the specified config file', () => {
+    const fakeCommands = fake(commands, {
+      lint: () => Promise.resolve(),
+    });
+    const fakePath = 'path/to/web-ext-config.js';
+    const resolvedFakePath = path.resolve(fakePath);
+    const fakeLoadJSConfigFile = sinon.spy(() => {});
+    const fakeApplyConfigToArgv = sinon.spy(() => {});
+
+    return execProgram(
+      ['lint', '--config', fakePath],
+      {
+        commands: fakeCommands,
+        runOptions: {
+          applyConfigToArgv: fakeApplyConfigToArgv,
+          loadJSConfigFile: fakeLoadJSConfigFile,
+        },
+      })
+      .then(() => {
+        const options = fakeCommands.lint.firstCall.args[0];
+        assert.strictEqual(options.config, fakePath);
+        sinon.assert.calledOnce(fakeLoadJSConfigFile);
+        sinon.assert.calledWith(fakeLoadJSConfigFile,
+                                sinon.match(resolvedFakePath));
+        sinon.assert.calledOnce(fakeApplyConfigToArgv);
+        sinon.assert.calledWith(fakeApplyConfigToArgv, sinon.match({
+          configFileName: resolvedFakePath,
+        }));
+      });
+  });
+
+  it('throws a UsageError when the config file can\'t be loaded', () => {
+    const fakeProcess = createFakeProcess();
+    const fakeCommands = fake(commands, {
+      lint: () => Promise.resolve(),
+    });
+    const fakePath = 'path/to/web-ext-config.js';
+    const fakeLoadJSConfigFile = sinon.spy(() => {
+      throw new UsageError('bad path');
+    });
+    const fakeApplyConfigToArgv = sinon.spy(() => {});
+
+    consoleStream.stopCapturing();
+    consoleStream.flushCapturedLogs();
+    consoleStream.startCapturing();
+
+    return execProgram(
+      ['lint', '--config', fakePath],
+      {
+        commands: fakeCommands,
+        runOptions: {
+          shouldExitProgram: false,
+          systemProcess: fakeProcess,
+          applyConfigToArgv: fakeApplyConfigToArgv,
+          loadJSConfigFile: fakeLoadJSConfigFile,
+        },
+      })
+      .then(makeSureItFails())
+      .catch(onlyInstancesOf(UsageError, (error) => {
+        const {capturedMessages} = consoleStream;
+        consoleStream.stopCapturing();
+
+        assert.match(error.message, /bad path/);
+        assert.ok(
+          capturedMessages.some(
+            (message) => message.match(/bad path/)
+        ));
+        sinon.assert.notCalled(fakeApplyConfigToArgv);
+        sinon.assert.notCalled(fakeProcess.exit);
+      }));
+  });
+
+  it('throws when config file loading raises an unexpected error', () => {
+    const fakeProcess = createFakeProcess();
+    const fakeCommands = fake(commands, {
+      lint: () => Promise.resolve(),
+    });
+    const fakePath = 'path/to/web-ext-config.js';
+    const fakeLoadJSConfigFile = sinon.spy(() => {
+      throw new Error('some error');
+    });
+    const fakeApplyConfigToArgv = sinon.spy(() => {});
+
+    consoleStream.stopCapturing();
+    consoleStream.flushCapturedLogs();
+    consoleStream.startCapturing();
+
+    return execProgram(
+      ['lint', '--config', fakePath],
+      {
+        commands: fakeCommands,
+        runOptions: {
+          shouldExitProgram: false,
+          systemProcess: fakeProcess,
+          applyConfigToArgv: fakeApplyConfigToArgv,
+          loadJSConfigFile: fakeLoadJSConfigFile,
+        },
+      })
+      .then(makeSureItFails())
+      .catch((error) => {
+        const {capturedMessages} = consoleStream;
+        consoleStream.stopCapturing();
+
+        if (error instanceof UsageError) {
+          throw error;
+        }
+
+        assert.match(error.message, /some error/);
+        assert.ok(capturedMessages.some(
+          (message) => message.match(/some error/)
+        ));
+        sinon.assert.notCalled(fakeApplyConfigToArgv);
+        sinon.assert.notCalled(fakeProcess.exit);
+      });
+  });
+
+  it('throws a UsageError when the loaded config can\'t be applied', () => {
+    const fakeProcess = createFakeProcess();
+    const fakeCommands = fake(commands, {
+      lint: () => Promise.resolve(),
+    });
+    const fakePath = 'path/to/web-ext-config.js';
+    const fakeLoadJSConfigFile = sinon.spy(() => {});
+    const fakeApplyConfigToArgv = sinon.spy(() => {
+      throw new UsageError('bad config option');
+    });
+
+    consoleStream.stopCapturing();
+    consoleStream.flushCapturedLogs();
+    consoleStream.startCapturing();
+
+    return execProgram(
+      ['lint', '--config', fakePath],
+      {
+        commands: fakeCommands,
+        runOptions: {
+          shouldExitProgram: false,
+          systemProcess: fakeProcess,
+          applyConfigToArgv: fakeApplyConfigToArgv,
+          loadJSConfigFile: fakeLoadJSConfigFile,
+        },
+      })
+      .then(makeSureItFails())
+      .catch(onlyInstancesOf(UsageError, (error) => {
+        const {capturedMessages} = consoleStream;
+        consoleStream.stopCapturing();
+
+        assert.match(error.message, /bad config option/);
+        assert.ok(
+          capturedMessages.some(
+            (message) => message.match(/bad config option/)
+        ));
+        sinon.assert.notCalled(fakeProcess.exit);
+      }));
+  });
+
+  it('throws when fakeApplyConfigToArgv throws an unexpected error', () => {
+    const fakeProcess = createFakeProcess();
+    const fakeCommands = fake(commands, {
+      lint: () => Promise.resolve(),
+    });
+    const fakePath = 'path/to/web-ext-config.js';
+    const fakeLoadJSConfigFile = sinon.spy(() => {});
+    const fakeApplyConfigToArgv = sinon.spy(() => {
+      throw new Error('some error');
+    });
+
+    consoleStream.stopCapturing();
+    consoleStream.flushCapturedLogs();
+    consoleStream.startCapturing();
+
+    return execProgram(
+      ['lint', '--config', fakePath],
+      {
+        commands: fakeCommands,
+        runOptions: {
+          shouldExitProgram: false,
+          systemProcess: fakeProcess,
+          applyConfigToArgv: fakeApplyConfigToArgv,
+          loadJSConfigFile: fakeLoadJSConfigFile,
+        },
+      })
+      .then(makeSureItFails())
+      .catch((error) => {
+        const {capturedMessages} = consoleStream;
+        consoleStream.stopCapturing();
+
+        if (error instanceof UsageError) {
+          throw error;
+        }
+
+        assert.match(error.message, /some error/);
+        assert.ok(capturedMessages.some(
+          (message) => message.match(/some error/)
+        ));
+        sinon.assert.notCalled(fakeProcess.exit);
+      });
+  });
 });
 
 describe('program.defaultVersionGetter', () => {