navy 6.0.0 → 7.0.0-alpha.2

package/lib/cli/config/__tests__/wrapper.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _proxyquire = _interopRequireDefault(require("proxyquire"));
+/* eslint-env mocha */
+
+describe('cli/config/wrapper', function () {
+  let sandbox;
+  let execSyncStub;
+  let originalArgv;
+  let wrapperCli;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    execSyncStub = sandbox.stub();
+    originalArgv = process.argv;
+    wrapperCli = _proxyquire.default.noCallThru()('../wrapper', {
+      child_process: {
+        execSync: execSyncStub
+      }
+    });
+  });
+  afterEach(function () {
+    process.argv = originalArgv;
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    it('should invoke navy-config.js via execSync with stdio inherit', async function () {
+      process.argv = ['node', 'navy', 'config'];
+      await wrapperCli('env-1');
+      (0, _chai.expect)(execSyncStub.calledOnce).to.equal(true);
+      const command = execSyncStub.firstCall.args[0];
+      (0, _chai.expect)(command).to.contain('navy-config.js');
+      const opts = execSyncStub.firstCall.args[1];
+      (0, _chai.expect)(opts).to.eql({
+        stdio: 'inherit'
+      });
+    });
+    it('should pass through any extra command-line args from process.argv', async function () {
+      process.argv = ['node', 'navy', 'config', 'set', 'default-navy', 'dev'];
+      await wrapperCli('env-1');
+      const command = execSyncStub.firstCall.args[0];
+      (0, _chai.expect)(command).to.contain('set default-navy dev');
+    });
+    it('should invoke with no extra args when only the wrapper command is supplied', async function () {
+      process.argv = ['node', 'navy', 'config'];
+      await wrapperCli('env-1');
+      const command = execSyncStub.firstCall.args[0];
+      (0, _chai.expect)(command.endsWith('navy-config.js ')).to.equal(true);
+    });
+  });
+});

package/lib/cli/config/index.js

@@ -1,80 +1,64 @@
 "use strict";
 
-var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.reconfigureIfNecessary = reconfigureIfNecessary;
-
-var _commander = _interopRequireDefault(require("commander"));
-
+var _commander = require("commander");
 var _config = require("../../config");
-
 var _errors = require("../../errors");
-
 var _reconfigure = require("../util/reconfigure");
-
 const NAME_MAP = {
   'default-navy': 'defaultNavy',
   'external-ip': 'externalIP',
   'tlsCa-dir': 'tlsRootCaDir'
 };
 const configWhichNeedsReconfigure = ['externalIP'];
-
 async function reconfigureIfNecessary(configProp) {
   if (configWhichNeedsReconfigure.indexOf(configProp) === -1) {
     return;
   }
-
   await (0, _reconfigure.reconfigureAllNavies)();
 }
-
-_commander.default.command('set <key> <value>').description('Sets the given config key').action(async (key, value) => {
+_commander.program.command('set <key> <value>').description('Sets the given config key').action(async (key, value) => {
   const configProp = NAME_MAP[key];
-
   if (!configProp) {
     throw new _errors.NavyError('Invalid config key: ' + key);
   }
-
-  await (0, _config.setConfig)({ ...(await (0, _config.getConfig)()),
-    [configProp]: value
-  });
+  const updated = {
+    ...(await (0, _config.getConfig)())
+  };
+  updated[configProp] = value;
+  await (0, _config.setConfig)(updated);
   await reconfigureIfNecessary(configProp);
 });
-
-_commander.default.command('get <key>').description('Gets the given config by key').action(async key => {
+_commander.program.command('get <key>').description('Gets the given config by key').action(async key => {
   if (!NAME_MAP[key]) {
     throw new _errors.NavyError('Invalid config key: ' + key);
   }
-
   const config = await (0, _config.getConfig)();
   console.log(config[NAME_MAP[key]]);
 });
-
-_commander.default.command('rm <key>').description('Removes the current config value').action(async key => {
+_commander.program.command('rm <key>').description('Removes the current config value').action(async key => {
   const configProp = NAME_MAP[key];
-
   if (!configProp) {
     throw new _errors.NavyError('Invalid config key: ' + key);
   }
-
-  await (0, _config.setConfig)({ ...(await (0, _config.getConfig)()),
-    [configProp]: null
-  });
+  const updated = {
+    ...(await (0, _config.getConfig)())
+  };
+  updated[configProp] = null;
+  await (0, _config.setConfig)(updated);
   await reconfigureIfNecessary(configProp);
 });
-
-_commander.default.command('ls').description('Lists all of the Navy config keys and values that have been set').action(async () => {
+_commander.program.command('ls').description('Lists all of the Navy config keys and values that have been set').action(async () => {
   const configKeys = Object.keys(NAME_MAP);
   const config = await (0, _config.getConfig)();
   console.log(configKeys.map(key => `${key}=${config[NAME_MAP[key]] != null ? config[NAME_MAP[key]] : 'null'}`).join('\n'));
 });
-
-_commander.default.command('json').description('Dumps out all Navy config as JSON').action(async () => {
+_commander.program.command('json').description('Dumps out all Navy config as JSON').action(async () => {
   console.log(JSON.stringify(await (0, _config.getConfig)(), null, 2));
 });
-
 process.on('unhandledRejection', err => {
   if (err instanceof _errors.NavyError) {
     err.prettyPrint();
@@ -82,9 +66,7 @@ process.on('unhandledRejection', err => {
     console.error(err.stack);
   }
 });
-
-_commander.default.parse(process.argv);
-
-if (_commander.default.args.length === 0) {
-  _commander.default.help();
+_commander.program.parse(process.argv);
+if (_commander.program.args.length === 0) {
+  _commander.program.help();
 }

package/lib/cli/config/wrapper.js

@@ -1,21 +1,15 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = _default;
-
 var _child_process = require("child_process");
-
 var _path = _interopRequireDefault(require("path"));
-
 async function _default(navy) {
-  // $FlowIgnore flow bug with execSync
   (0, _child_process.execSync)(_path.default.join(__dirname, '../../../bin/navy-config.js') + ' ' + process.argv.slice(3).join(' '), {
     stdio: 'inherit'
   });
 }
-
 module.exports = exports.default;

package/lib/cli/develop.js

@@ -1,55 +1,44 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = _default;
-
 var _path = _interopRequireDefault(require("path"));
-
 var _chalk = _interopRequireDefault(require("chalk"));
-
 var _invariant = _interopRequireDefault(require("invariant"));
-
 var _ = require("../");
-
 var _errors = require("../errors");
-
 var _dockerClient = _interopRequireDefault(require("../util/docker-client"));
-
 var _navyrc = _interopRequireDefault(require("../util/navyrc"));
-
 async function _default(service, opts) {
   const navy = (0, _.getNavy)(opts.navy);
   const cwd = process.cwd();
   const navyRc = await (0, _navyrc.default)(cwd);
-
   if (!navyRc || !navyRc.services) {
     throw new _errors.NavyError(`No valid .navyrc file was found in "${cwd}"`);
   }
-
   if (!navyRc.develop) {
     throw new _errors.NavyError('No develop mounts found in .navyrc');
   }
-
   if (navyRc.services.length > 1 && !service) {
     throw new _errors.NavyError('Multiple service mappings are defined in .navyrc, you need to explicitly specify what service to develop');
   }
-
   if (!service) service = navyRc.services[0];
-
   if (navyRc.services.indexOf(service) === -1) {
     throw new _errors.NavyError(`Service "${service}" is not a valid development target`);
   }
-
   const mounts = {};
   Object.keys(navyRc.develop.mounts).forEach(localPath => mounts[_path.default.resolve(localPath)] = navyRc.develop.mounts[localPath]);
   const state = (await navy.getState()) || {};
-  await navy.saveState({ ...state,
-    services: { ...state.services,
-      [service]: { ...(state.services || {})[service],
+  const stateServices = state.services || {};
+  await navy.saveState({
+    ...state,
+    services: {
+      ...stateServices,
+      [service]: {
+        ...stateServices[service],
         _develop: {
           mounts,
           command: navyRc.develop.command
@@ -68,9 +57,7 @@ async function _default(service, opts) {
   const container = (await navy.ps()).filter(_service => _service.name === service)[0];
   (0, _invariant.default)(container, "DEVELOP_NO_CONTAINER_ID: Could not determine container ID for log attachment");
   const containerId = container.id;
-
   const containerObj = _dockerClient.default.getContainer(containerId);
-
   containerObj.attach({
     stream: true,
     stdout: true,
@@ -81,5 +68,4 @@ async function _default(service, opts) {
     console.log();
   });
 }
-
 module.exports = exports.default;

package/lib/cli/doctor/__tests__/clean-compose-files.js

@@ -0,0 +1,78 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _proxyquire = _interopRequireDefault(require("proxyquire"));
+/* eslint-env mocha */
+
+describe('cli/doctor/clean-compose-files', function () {
+  let sandbox;
+  let getLaunchedNavyNamesStub;
+  let startStub;
+  let pathToNavyStub;
+  let normaliseNavyNameStub;
+  let rmStub;
+  let cleanComposeFiles;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    getLaunchedNavyNamesStub = sandbox.stub().resolves([]);
+    startStub = sandbox.stub();
+    pathToNavyStub = sandbox.stub().callsFake(name => `/state/${name}`);
+    normaliseNavyNameStub = sandbox.stub().callsFake(name => name.toLowerCase());
+    rmStub = sandbox.stub().resolves();
+    cleanComposeFiles = _proxyquire.default.noCallThru()('../clean-compose-files', {
+      '../../': {
+        getLaunchedNavyNames: getLaunchedNavyNamesStub
+      },
+      './util': {
+        start: startStub
+      },
+      '../../navy/state': {
+        pathToNavy: pathToNavyStub
+      },
+      '../../navy/util': {
+        normaliseNavyName: normaliseNavyNameStub
+      },
+      fs: {
+        promises: {
+          rm: rmStub
+        }
+      }
+    });
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    it('should print a starting message', async function () {
+      await cleanComposeFiles();
+      (0, _chai.expect)(startStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(startStub.firstCall.args[0]).to.contain('Cleaning');
+    });
+    it('should not call rm when there are no launched navies', async function () {
+      getLaunchedNavyNamesStub.resolves([]);
+      await cleanComposeFiles();
+      (0, _chai.expect)(rmStub.called).to.equal(false);
+    });
+    it('should remove docker-compose.tmp.yml from each launched navy path', async function () {
+      getLaunchedNavyNamesStub.resolves(['env-1', 'Dev']);
+      await cleanComposeFiles();
+      (0, _chai.expect)(rmStub.callCount).to.equal(2);
+      const paths = rmStub.getCalls().map(c => c.args[0]);
+      (0, _chai.expect)(paths).to.include('/state/env-1/docker-compose.tmp.yml');
+      (0, _chai.expect)(paths).to.include('/state/dev/docker-compose.tmp.yml');
+      rmStub.getCalls().forEach(call => {
+        (0, _chai.expect)(call.args[1]).to.eql({
+          recursive: true,
+          force: true
+        });
+      });
+    });
+    it('should normalise navy names when resolving paths', async function () {
+      getLaunchedNavyNamesStub.resolves(['MyEnv']);
+      await cleanComposeFiles();
+      (0, _chai.expect)(normaliseNavyNameStub.calledWith('MyEnv')).to.equal(true);
+    });
+  });
+});

package/lib/cli/doctor/__tests__/index.js

@@ -0,0 +1,67 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _proxyquire = _interopRequireDefault(require("proxyquire"));
+/* eslint-env mocha */
+
+describe('cli/doctor/index', function () {
+  let sandbox;
+  let cleanComposeStub;
+  let invalidStateStub;
+  let invalidComposeConfigStub;
+  let consoleLogStub;
+  let doctorCli;
+  function loadModule() {
+    doctorCli = _proxyquire.default.noCallThru()('../index', {
+      './clean-compose-files': cleanComposeStub,
+      './invalid-state': invalidStateStub,
+      './invalid-compose-config': invalidComposeConfigStub
+    });
+  }
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    cleanComposeStub = sandbox.stub().resolves();
+    invalidStateStub = sandbox.stub().resolves();
+    invalidComposeConfigStub = sandbox.stub().resolves();
+    consoleLogStub = sandbox.stub(console, 'log');
+    loadModule();
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    it('should run all checks in order', async function () {
+      await doctorCli();
+      (0, _chai.expect)(cleanComposeStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(invalidStateStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(invalidComposeConfigStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(cleanComposeStub.calledBefore(invalidStateStub)).to.equal(true);
+      (0, _chai.expect)(invalidStateStub.calledBefore(invalidComposeConfigStub)).to.equal(true);
+    });
+    it('should print a success message when all checks pass', async function () {
+      await doctorCli();
+      const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+      (0, _chai.expect)(printed).to.contain('Finished tests');
+    });
+    it('should print error stacks and a warning when checks fail', async function () {
+      const error1 = new Error('boom1');
+      const error2 = new Error('boom2');
+      cleanComposeStub.rejects(error1);
+      invalidStateStub.rejects(error2);
+      await doctorCli();
+      const printedArgs = consoleLogStub.getCalls().map(c => c.args[0] || '');
+      const all = printedArgs.join('\n');
+      (0, _chai.expect)(all).to.contain('There were some issues');
+      (0, _chai.expect)(printedArgs.some(arg => typeof arg === 'string' && arg.includes(error1.stack))).to.equal(true);
+      (0, _chai.expect)(printedArgs.some(arg => typeof arg === 'string' && arg.includes(error2.stack))).to.equal(true);
+    });
+    it('should run all checks even when an early one throws', async function () {
+      cleanComposeStub.rejects(new Error('boom'));
+      await doctorCli();
+      (0, _chai.expect)(invalidStateStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(invalidComposeConfigStub.calledOnce).to.equal(true);
+    });
+  });
+});

package/lib/cli/doctor/__tests__/invalid-compose-config.js

@@ -0,0 +1,103 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _proxyquire = _interopRequireDefault(require("proxyquire"));
+/* eslint-env mocha */
+
+describe('cli/doctor/invalid-compose-config', function () {
+  let sandbox;
+  let getLaunchedNaviesStub;
+  let startStub;
+  let fixStub;
+  let catchInvariantStub;
+  let invalidComposeConfig;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    getLaunchedNaviesStub = sandbox.stub().resolves([]);
+    startStub = sandbox.stub();
+    fixStub = sandbox.stub().callsFake(async (msg, name, callback) => callback());
+    catchInvariantStub = sandbox.stub().callsFake(async (code, fn, catchCallback) => {
+      try {
+        await fn();
+      } catch (err) {
+        if (err.name === 'Invariant Violation' && err.message.indexOf(code) === 0) {
+          await catchCallback();
+        }
+      }
+    });
+    invalidComposeConfig = _proxyquire.default.noCallThru()('../invalid-compose-config', {
+      '../../': {
+        getLaunchedNavies: getLaunchedNaviesStub
+      },
+      './util': {
+        start: startStub,
+        fix: fixStub,
+        catchInvariant: catchInvariantStub
+      }
+    });
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    it('should log a starting message', async function () {
+      await invalidComposeConfig();
+      (0, _chai.expect)(startStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(startStub.firstCall.args[0]).to.contain('compose');
+    });
+    it('should do nothing further when there are no launched navies', async function () {
+      getLaunchedNaviesStub.resolves([]);
+      await invalidComposeConfig();
+      (0, _chai.expect)(catchInvariantStub.called).to.equal(false);
+      (0, _chai.expect)(fixStub.called).to.equal(false);
+    });
+    it('should call safeGetDriver().getConfig() for each navy', async function () {
+      const driver = {
+        getConfig: sandbox.stub().resolves({})
+      };
+      const navy = {
+        name: 'env-1',
+        safeGetDriver: sandbox.stub().resolves(driver),
+        delete: sandbox.stub().resolves()
+      };
+      getLaunchedNaviesStub.resolves([navy]);
+      await invalidComposeConfig();
+      (0, _chai.expect)(navy.safeGetDriver.calledOnce).to.equal(true);
+      (0, _chai.expect)(driver.getConfig.calledOnce).to.equal(true);
+    });
+    it('should remove a navy whose driver throws NO_DOCKER_COMPOSE_FILE invariant', async function () {
+      const err = new Error('NO_DOCKER_COMPOSE_FILE: not found');
+      err.name = 'Invariant Violation';
+      const driver = {
+        getConfig: sandbox.stub().rejects(err)
+      };
+      const navy = {
+        name: 'env-1',
+        safeGetDriver: sandbox.stub().resolves(driver),
+        delete: sandbox.stub().resolves()
+      };
+      getLaunchedNaviesStub.resolves([navy]);
+      await invalidComposeConfig();
+      (0, _chai.expect)(fixStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(navy.delete.calledOnce).to.equal(true);
+    });
+    it('should not call delete when the driver throws a different invariant', async function () {
+      const err = new Error('SOMETHING_ELSE: nope');
+      err.name = 'Invariant Violation';
+      const driver = {
+        getConfig: sandbox.stub().rejects(err)
+      };
+      const navy = {
+        name: 'env-1',
+        safeGetDriver: sandbox.stub().resolves(driver),
+        delete: sandbox.stub().resolves()
+      };
+      getLaunchedNaviesStub.resolves([navy]);
+      await invalidComposeConfig();
+      (0, _chai.expect)(fixStub.called).to.equal(false);
+      (0, _chai.expect)(navy.delete.called).to.equal(false);
+    });
+  });
+});

package/lib/cli/doctor/__tests__/invalid-state.js

@@ -0,0 +1,83 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _proxyquire = _interopRequireDefault(require("proxyquire"));
+/* eslint-env mocha */
+
+describe('cli/doctor/invalid-state', function () {
+  let sandbox;
+  let getLaunchedNaviesStub;
+  let startStub;
+  let fixStub;
+  let invalidState;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    getLaunchedNaviesStub = sandbox.stub().resolves([]);
+    startStub = sandbox.stub();
+    fixStub = sandbox.stub().callsFake(async (msg, name, callback) => callback());
+    invalidState = _proxyquire.default.noCallThru()('../invalid-state', {
+      '../../': {
+        getLaunchedNavies: getLaunchedNaviesStub
+      },
+      './util': {
+        start: startStub,
+        fix: fixStub
+      }
+    });
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    it('should log a starting message', async function () {
+      await invalidState();
+      (0, _chai.expect)(startStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(startStub.firstCall.args[0]).to.contain('dangling');
+    });
+    it('should remove a navy that has no config provider', async function () {
+      const navy = {
+        name: 'env-1',
+        getConfigProvider: sandbox.stub().resolves(null),
+        delete: sandbox.stub().resolves()
+      };
+      getLaunchedNaviesStub.resolves([navy]);
+      await invalidState();
+      (0, _chai.expect)(fixStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(fixStub.firstCall.args[0]).to.contain('without config provider');
+      (0, _chai.expect)(navy.delete.calledOnce).to.equal(true);
+    });
+    it('should destroy a dangling navy whose config is invalid', async function () {
+      const configProvider = {
+        isDangling: sandbox.stub().resolves(true)
+      };
+      const navy = {
+        name: 'env-1',
+        getConfigProvider: sandbox.stub().resolves(configProvider),
+        destroy: sandbox.stub().resolves()
+      };
+      getLaunchedNaviesStub.resolves([navy]);
+      await invalidState();
+      (0, _chai.expect)(fixStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(fixStub.firstCall.args[0]).to.contain('dangling Navy');
+      (0, _chai.expect)(navy.destroy.calledOnce).to.equal(true);
+    });
+    it('should leave alone a navy whose config provider exists and is not dangling', async function () {
+      const configProvider = {
+        isDangling: sandbox.stub().resolves(false)
+      };
+      const navy = {
+        name: 'env-1',
+        getConfigProvider: sandbox.stub().resolves(configProvider),
+        destroy: sandbox.stub().resolves(),
+        delete: sandbox.stub().resolves()
+      };
+      getLaunchedNaviesStub.resolves([navy]);
+      await invalidState();
+      (0, _chai.expect)(fixStub.called).to.equal(false);
+      (0, _chai.expect)(navy.destroy.called).to.equal(false);
+      (0, _chai.expect)(navy.delete.called).to.equal(false);
+    });
+  });
+});