navy 6.0.0 → 7.0.0-alpha.2

package/lib/cli/__tests__/launch.js

@@ -0,0 +1,179 @@
+"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/launch', function () {
+  let sandbox;
+  let inquirerStub;
+  let getOrInitialiseNavyStub;
+  let navyStub;
+  let startDriverLoggingStub;
+  let stopDriverLoggingStub;
+  let launchCli;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    navyStub = {
+      name: 'env-1',
+      ensurePluginsLoaded: sandbox.stub().resolves(),
+      getNavyFile: sandbox.stub().resolves(null),
+      getAvailableServiceNames: sandbox.stub().resolves(['web', 'api', 'db']),
+      getLaunchedServiceNames: sandbox.stub().resolves([]),
+      emitAsync: sandbox.stub().resolves(),
+      launch: sandbox.stub().resolves()
+    };
+    getOrInitialiseNavyStub = sandbox.stub().resolves(navyStub);
+    inquirerStub = {
+      prompt: sandbox.stub().resolves({
+        services: []
+      })
+    };
+    startDriverLoggingStub = sandbox.stub();
+    stopDriverLoggingStub = sandbox.stub();
+    launchCli = _proxyquire.default.noCallThru()('../launch', {
+      inquirer: inquirerStub,
+      './util': {
+        getOrInitialiseNavy: getOrInitialiseNavyStub
+      },
+      '../driver-logging': {
+        startDriverLogging: startDriverLoggingStub,
+        stopDriverLogging: stopDriverLoggingStub
+      }
+    });
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    it('should resolve the navy via getOrInitialiseNavy(opts.navy)', async function () {
+      await launchCli(['web'], {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(getOrInitialiseNavyStub.calledWith('env-1')).to.equal(true);
+    });
+    it('should launch services without prompting when services are provided', async function () {
+      await launchCli(['web', 'api'], {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(inquirerStub.prompt.called).to.equal(false);
+      (0, _chai.expect)(navyStub.launch.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.launch.firstCall.args[0]).to.eql(['web', 'api']);
+    });
+    it('should bracket launch with start/stopDriverLogging', async function () {
+      await launchCli(['web'], {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(startDriverLoggingStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(stopDriverLoggingStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(startDriverLoggingStub.calledBefore(navyStub.launch)).to.equal(true);
+      (0, _chai.expect)(navyStub.launch.calledBefore(stopDriverLoggingStub)).to.equal(true);
+    });
+    it('should emit cli.before.launch before launching', async function () {
+      await launchCli(['web'], {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(navyStub.emitAsync.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.emitAsync.firstCall.args[0]).to.equal('cli.before.launch');
+      (0, _chai.expect)(navyStub.emitAsync.calledBefore(navyStub.launch)).to.equal(true);
+    });
+    it('should prompt with inquirer when no services are provided', async function () {
+      inquirerStub.prompt.resolves({
+        services: ['web']
+      });
+      await launchCli([], {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(inquirerStub.prompt.calledOnce).to.equal(true);
+      const promptArgs = inquirerStub.prompt.firstCall.args[0];
+      (0, _chai.expect)(promptArgs[0].type).to.equal('checkbox');
+      (0, _chai.expect)(promptArgs[0].name).to.equal('services');
+      (0, _chai.expect)(promptArgs[0].choices.map(c => c.name)).to.have.members(['web', 'api', 'db']);
+    });
+    it('should pre-check services from launchedServiceNames when present', async function () {
+      navyStub.getLaunchedServiceNames.resolves(['api']);
+      inquirerStub.prompt.resolves({
+        services: []
+      });
+      await launchCli([], {
+        navy: 'env-1'
+      });
+      const choices = inquirerStub.prompt.firstCall.args[0][0].choices;
+      const apiChoice = choices.find(c => c.name === 'api');
+      const webChoice = choices.find(c => c.name === 'web');
+      (0, _chai.expect)(apiChoice.checked).to.equal(true);
+      (0, _chai.expect)(webChoice.checked).to.equal(false);
+    });
+    it('should pre-check services from navyFile.launchDefaults when nothing is launched', async function () {
+      navyStub.getNavyFile.resolves({
+        launchDefaults: ['web']
+      });
+      inquirerStub.prompt.resolves({
+        services: []
+      });
+      await launchCli([], {
+        navy: 'env-1'
+      });
+      const choices = inquirerStub.prompt.firstCall.args[0][0].choices;
+      const webChoice = choices.find(c => c.name === 'web');
+      (0, _chai.expect)(webChoice.checked).to.equal(true);
+    });
+    it('should fall back to no defaults when navyFile is null and nothing is launched', async function () {
+      navyStub.getNavyFile.resolves(null);
+      inquirerStub.prompt.resolves({
+        services: []
+      });
+      await launchCli([], {
+        navy: 'env-1'
+      });
+      const choices = inquirerStub.prompt.firstCall.args[0][0].choices;
+      choices.forEach(c => (0, _chai.expect)(c.checked).to.equal(false));
+    });
+    it('should fall back to empty defaults when navyFile lacks launchDefaults', async function () {
+      navyStub.getNavyFile.resolves({});
+      inquirerStub.prompt.resolves({
+        services: []
+      });
+      await launchCli([], {
+        navy: 'env-1'
+      });
+      const choices = inquirerStub.prompt.firstCall.args[0][0].choices;
+      choices.forEach(c => (0, _chai.expect)(c.checked).to.equal(false));
+    });
+    it('should return early without launching when the user selects no services', async function () {
+      inquirerStub.prompt.resolves({
+        services: []
+      });
+      await launchCli([], {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(navyStub.launch.called).to.equal(false);
+      (0, _chai.expect)(navyStub.emitAsync.called).to.equal(false);
+      (0, _chai.expect)(startDriverLoggingStub.called).to.equal(false);
+      (0, _chai.expect)(stopDriverLoggingStub.called).to.equal(false);
+    });
+    it('should launch with the services chosen via the interactive prompt', async function () {
+      inquirerStub.prompt.resolves({
+        services: ['db', 'web']
+      });
+      await launchCli([], {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(navyStub.launch.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.launch.firstCall.args[0]).to.eql(['db', 'web']);
+    });
+    it('should treat a null services arg as no selection and prompt', async function () {
+      inquirerStub.prompt.resolves({
+        services: ['web']
+      });
+      await launchCli(null, {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(inquirerStub.prompt.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.launch.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.launch.firstCall.args[0]).to.eql(['web']);
+    });
+  });
+});

package/lib/cli/__tests__/live.js

@@ -0,0 +1,155 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _proxyquire = _interopRequireDefault(require("proxyquire"));
+var _errors = require("../../errors");
+/* eslint-env mocha */
+
+describe('cli/live', function () {
+  let sandbox;
+  let getNavyStub;
+  let navyStub;
+  let getNavyRcStub;
+  let consoleLogStub;
+  let originalCwd;
+  let liveCli;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    navyStub = {
+      name: 'env-1',
+      getState: sandbox.stub().resolves({
+        services: {
+          web: {
+            _develop: {
+              mounts: {},
+              command: 'x'
+            }
+          }
+        }
+      }),
+      saveState: sandbox.stub().resolves(),
+      kill: sandbox.stub().resolves(),
+      relaunch: sandbox.stub().resolves()
+    };
+    getNavyStub = sandbox.stub().returns(navyStub);
+    getNavyRcStub = sandbox.stub().resolves(null);
+    consoleLogStub = sandbox.stub(console, 'log');
+    originalCwd = process.cwd;
+    sandbox.stub(process, 'cwd').returns('/work');
+    liveCli = _proxyquire.default.noCallThru()('../live', {
+      '../': {
+        getNavy: getNavyStub
+      },
+      '../errors': {
+        NavyError: _errors.NavyError
+      },
+      '../util/navyrc': getNavyRcStub
+    });
+  });
+  afterEach(function () {
+    process.cwd = originalCwd;
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    it('should throw NavyError when navyrc exists but services is missing', async function () {
+      getNavyRcStub.resolves({
+        services: undefined
+      });
+      let caught;
+      try {
+        await liveCli('web', {
+          navy: 'env-1'
+        });
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+      (0, _chai.expect)(caught.message).to.contain('No valid .navyrc');
+    });
+    it('should throw when navyrc lists multiple services and none specified', async function () {
+      getNavyRcStub.resolves({
+        services: ['web', 'api']
+      });
+      let caught;
+      try {
+        await liveCli(undefined, {
+          navy: 'env-1'
+        });
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+      (0, _chai.expect)(caught.message).to.contain('Multiple service mappings');
+    });
+    it('should infer the only service from a single-service navyrc', async function () {
+      getNavyRcStub.resolves({
+        services: ['only-svc']
+      });
+      navyStub.getState.resolves({
+        services: {
+          'only-svc': {
+            _develop: {
+              mounts: {}
+            }
+          }
+        }
+      });
+      await liveCli(undefined, {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(navyStub.kill.calledWith(['only-svc'])).to.equal(true);
+    });
+    it('should log a "nothing to do" message when service is not in develop mode', async function () {
+      navyStub.getState.resolves({
+        services: {
+          web: {}
+        }
+      });
+      await liveCli('web', {
+        navy: 'env-1'
+      });
+      const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+      (0, _chai.expect)(printed).to.contain('Nothing to do');
+      (0, _chai.expect)(navyStub.kill.called).to.equal(false);
+      (0, _chai.expect)(navyStub.relaunch.called).to.equal(false);
+    });
+    it('should log "nothing to do" when state has no services key', async function () {
+      navyStub.getState.resolves({});
+      await liveCli('web', {
+        navy: 'env-1'
+      });
+      const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+      (0, _chai.expect)(printed).to.contain('Nothing to do');
+    });
+    it('should log "nothing to do" when state is null', async function () {
+      navyStub.getState.resolves(null);
+      await liveCli('web', {
+        navy: 'env-1'
+      });
+      const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+      (0, _chai.expect)(printed).to.contain('Nothing to do');
+    });
+    it('should clear _develop, kill, and relaunch when service is in develop mode', async function () {
+      await liveCli('web', {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(navyStub.saveState.calledOnce).to.equal(true);
+      const newState = navyStub.saveState.firstCall.args[0];
+      (0, _chai.expect)(newState.services.web._develop).to.equal(undefined);
+      (0, _chai.expect)(navyStub.kill.calledWith(['web'])).to.equal(true);
+      (0, _chai.expect)(navyStub.relaunch.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.relaunch.firstCall.args[0]).to.eql({
+        noDeps: true
+      });
+    });
+    it('should log a confirmation message after switching out of dev mode', async function () {
+      await liveCli('web', {
+        navy: 'env-1'
+      });
+      const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+      (0, _chai.expect)(printed).to.contain('no longer in development');
+    });
+  });
+});

package/lib/cli/__tests__/local-ip.js

@@ -0,0 +1,72 @@
+"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/local-ip', function () {
+  let sandbox;
+  let setConfigStub;
+  let getConfigStub;
+  let reconfigureAllNaviesStub;
+  let consoleLogStub;
+  let localIpCli;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    setConfigStub = sandbox.stub().resolves();
+    getConfigStub = sandbox.stub();
+    reconfigureAllNaviesStub = sandbox.stub().resolves();
+    consoleLogStub = sandbox.stub(console, 'log');
+    localIpCli = _proxyquire.default.noCallThru()('../local-ip', {
+      '../config': {
+        setConfig: setConfigStub,
+        getConfig: getConfigStub
+      },
+      './util/reconfigure': {
+        reconfigureAllNavies: reconfigureAllNaviesStub
+      }
+    });
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    it('should write a config that merges existing config with externalIP=127.0.0.1', async function () {
+      getConfigStub.returns({
+        defaultNavy: 'dev',
+        tlsRootCaDir: '/ca'
+      });
+      await localIpCli();
+      (0, _chai.expect)(setConfigStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(setConfigStub.firstCall.args[0]).to.eql({
+        defaultNavy: 'dev',
+        tlsRootCaDir: '/ca',
+        externalIP: '127.0.0.1'
+      });
+    });
+    it('should override an existing externalIP in config with 127.0.0.1', async function () {
+      getConfigStub.returns({
+        externalIP: 'remote.host'
+      });
+      await localIpCli();
+      (0, _chai.expect)(setConfigStub.firstCall.args[0].externalIP).to.equal('127.0.0.1');
+    });
+    it('should reconfigure all navies after writing the new config', async function () {
+      getConfigStub.returns({});
+      await localIpCli();
+      (0, _chai.expect)(reconfigureAllNaviesStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(setConfigStub.calledBefore(reconfigureAllNaviesStub)).to.equal(true);
+    });
+    it('should log a confirmation including the local IP', async function () {
+      getConfigStub.returns({});
+      await localIpCli();
+      const messages = consoleLogStub.getCalls().map(c => c.args[0] || '');
+      const hasIp = messages.some(m => typeof m === 'string' && m.includes('127.0.0.1'));
+      (0, _chai.expect)(hasIp).to.equal(true);
+      const hasLabel = messages.some(m => typeof m === 'string' && m.includes('local IP'));
+      (0, _chai.expect)(hasLabel).to.equal(true);
+    });
+  });
+});

package/lib/cli/__tests__/logs.js

@@ -0,0 +1,52 @@
+"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/logs', function () {
+  let sandbox;
+  let getNavyStub;
+  let navyStub;
+  let logs;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    navyStub = {
+      spawnLogStream: sandbox.stub().resolves()
+    };
+    getNavyStub = sandbox.stub().returns(navyStub);
+    logs = _proxyquire.default.noCallThru()('../logs', {
+      '../': {
+        getNavy: getNavyStub
+      }
+    });
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    it('should resolve the navy instance using opts.navy', async function () {
+      await logs(['api'], {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(getNavyStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(getNavyStub.firstCall.args[0]).to.equal('env-1');
+    });
+    it('should call spawnLogStream with the supplied services array', async function () {
+      const services = ['api', 'web'];
+      await logs(services, {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(navyStub.spawnLogStream.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.spawnLogStream.firstCall.args[0]).to.equal(services);
+    });
+    it('should propagate empty service lists through to spawnLogStream', async function () {
+      await logs([], {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(navyStub.spawnLogStream.firstCall.args[0]).to.eql([]);
+    });
+  });
+});

package/lib/cli/__tests__/open.js

@@ -0,0 +1,65 @@
+"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/open', function () {
+  let sandbox;
+  let getNavyStub;
+  let navyStub;
+  let openStub;
+  let consoleLogStub;
+  let openCli;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    navyStub = {
+      url: sandbox.stub().resolves('http://service.local')
+    };
+    getNavyStub = sandbox.stub().returns(navyStub);
+    openStub = sandbox.stub();
+    consoleLogStub = sandbox.stub(console, 'log');
+    openCli = _proxyquire.default.noCallThru()('../open', {
+      open: openStub,
+      '../': {
+        getNavy: getNavyStub
+      }
+    });
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    it('should resolve the navy instance using opts.navy', async function () {
+      await openCli('api', {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(getNavyStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(getNavyStub.firstCall.args[0]).to.equal('env-1');
+    });
+    it('should resolve the URL for the requested service via navy.url', async function () {
+      await openCli('api', {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(navyStub.url.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.url.firstCall.args[0]).to.equal('api');
+    });
+    it('should pass the resolved URL to the open package', async function () {
+      navyStub.url.resolves('http://my-service.test');
+      await openCli('api', {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(openStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(openStub.firstCall.args[0]).to.equal('http://my-service.test');
+    });
+    it('should log a message indicating which service is being opened', async function () {
+      await openCli('api', {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(consoleLogStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(consoleLogStub.firstCall.args[0]).to.contain('Opening api...');
+    });
+  });
+});