navy 6.0.0 → 7.0.0-alpha.2

package/lib/cli/__tests__/updates.js

@@ -0,0 +1,243 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _proxyquire = _interopRequireDefault(require("proxyquire"));
+var _readline = _interopRequireDefault(require("readline"));
+var _cliSpinners = require("cli-spinners");
+var _stripAnsi = _interopRequireDefault(require("strip-ansi"));
+/* eslint-env mocha */
+
+// NOTE (potential source bug in updates.js, not locked in by these tests):
+//   The Promise.all body checks `if (!service || !service.raw || !service.raw.Image)`
+//   then immediately runs `updateStatus[service.id] = 'NO_IMAGE'`. If `service` were
+//   falsy the guard would let us through, but the very next assignment dereferences
+//   `service.id` and would throw. The `!service` part of the guard is therefore
+//   either dead defensive code or a latent bug.
+
+describe('cli/updates', function () {
+  let sandbox;
+  let clock;
+  let getNavyStub;
+  let navyStub;
+  let hasUpdateStub;
+  let consoleLogStub;
+  let clearLineStub;
+  let cursorToStub;
+  let moveCursorStub;
+  let updatesCli;
+  function makeService(overrides = {}) {
+    return {
+      id: 'svc-1',
+      name: 'api',
+      image: 'navy/api:latest',
+      raw: {
+        Image: 'sha256:abcdef'
+      },
+      ...overrides
+    };
+  }
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    clock = sandbox.useFakeTimers();
+    navyStub = {
+      getNavyFile: sandbox.stub().resolves({}),
+      ps: sandbox.stub().resolves([])
+    };
+    getNavyStub = sandbox.stub().returns(navyStub);
+    hasUpdateStub = sandbox.stub().resolves(false);
+    consoleLogStub = sandbox.stub(console, 'log');
+    clearLineStub = sandbox.stub(_readline.default, 'clearLine');
+    cursorToStub = sandbox.stub(_readline.default, 'cursorTo');
+    moveCursorStub = sandbox.stub(_readline.default, 'moveCursor');
+    updatesCli = _proxyquire.default.noCallThru()('../updates', {
+      '../': {
+        getNavy: getNavyStub
+      },
+      '../util/has-update': hasUpdateStub
+    });
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  function combinedLog() {
+    return consoleLogStub.getCalls().map(c => (0, _stripAnsi.default)(String(c.args[0] || ''))).join('\n');
+  }
+  describe('default export', function () {
+    it('should resolve the navy instance using opts.navy', async function () {
+      await updatesCli({
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(getNavyStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(getNavyStub.firstCall.args[0]).to.equal('env-1');
+    });
+    it('should fetch the navy file and the running services list', async function () {
+      await updatesCli({
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(navyStub.getNavyFile.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.ps.calledOnce).to.equal(true);
+    });
+    it('should print the table headers in the initial draw', async function () {
+      navyStub.ps.resolves([]);
+      await updatesCli({
+        navy: 'env-1'
+      });
+      const text = combinedLog();
+      (0, _chai.expect)(text).to.contain('NAME');
+      (0, _chai.expect)(text).to.contain('IMAGE');
+      (0, _chai.expect)(text).to.contain('UPDATES');
+    });
+    it('should clear the spinner interval before resolving', async function () {
+      navyStub.ps.resolves([makeService()]);
+      await updatesCli({
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(clock.countTimers()).to.equal(0);
+    });
+    it('should call readline cursor/clear helpers when redrawing', async function () {
+      navyStub.ps.resolves([makeService()]);
+      await updatesCli({
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(clearLineStub.called).to.equal(true);
+      (0, _chai.expect)(cursorToStub.called).to.equal(true);
+      (0, _chai.expect)(moveCursorStub.called).to.equal(true);
+    });
+  });
+  describe('renderStatus (via default export, final draw)', function () {
+    it('should mark a service as NO_IMAGE when raw is missing', async function () {
+      navyStub.ps.resolves([makeService({
+        raw: undefined
+      })]);
+      await updatesCli({
+        navy: 'env-1'
+      });
+      const text = combinedLog();
+      (0, _chai.expect)(text).to.contain('No image for service');
+      (0, _chai.expect)(hasUpdateStub.called).to.equal(false);
+    });
+    it('should mark a service as NO_IMAGE when raw.Image is missing', async function () {
+      navyStub.ps.resolves([makeService({
+        raw: {}
+      })]);
+      await updatesCli({
+        navy: 'env-1'
+      });
+      const text = combinedLog();
+      (0, _chai.expect)(text).to.contain('No image for service');
+      (0, _chai.expect)(hasUpdateStub.called).to.equal(false);
+    });
+    it('should mark a service as Update available when hasUpdate returns true', async function () {
+      navyStub.ps.resolves([makeService()]);
+      hasUpdateStub.resolves(true);
+      await updatesCli({
+        navy: 'env-1'
+      });
+      const text = combinedLog();
+      (0, _chai.expect)(text).to.contain('Update available');
+    });
+    it('should mark a service as Up to date when hasUpdate returns false', async function () {
+      navyStub.ps.resolves([makeService()]);
+      hasUpdateStub.resolves(false);
+      await updatesCli({
+        navy: 'env-1'
+      });
+      const text = combinedLog();
+      (0, _chai.expect)(text).to.contain('Up to date');
+    });
+    it('should mark a service as Not found when hasUpdate returns UNKNOWN_REMOTE', async function () {
+      navyStub.ps.resolves([makeService()]);
+      hasUpdateStub.resolves('UNKNOWN_REMOTE');
+      await updatesCli({
+        navy: 'env-1'
+      });
+      const text = combinedLog();
+      (0, _chai.expect)(text).to.contain('Not found');
+    });
+    it('should mark a service as Up to date when hasUpdate returns an unrecognised string', async function () {
+      navyStub.ps.resolves([makeService()]);
+      hasUpdateStub.resolves('SOME_OTHER_VALUE');
+      await updatesCli({
+        navy: 'env-1'
+      });
+      const text = combinedLog();
+      (0, _chai.expect)(text).to.contain('Up to date');
+    });
+    it('should mark a service as Internal error when hasUpdate throws', async function () {
+      navyStub.ps.resolves([makeService()]);
+      hasUpdateStub.rejects(new Error('boom'));
+      await updatesCli({
+        navy: 'env-1'
+      });
+      const text = combinedLog();
+      (0, _chai.expect)(text).to.contain('Internal error');
+    });
+    it('should mark a service as Internal error when hasUpdate throws an error with no stack', async function () {
+      navyStub.ps.resolves([makeService()]);
+      const errNoStack = {
+        message: 'no stack'
+      };
+      hasUpdateStub.callsFake(() => Promise.reject(errNoStack));
+      await updatesCli({
+        navy: 'env-1'
+      });
+      const text = combinedLog();
+      (0, _chai.expect)(text).to.contain('Internal error');
+    });
+    it('should pass image, raw image id, and navy file through to hasUpdate', async function () {
+      const navyFile = {
+        ignoreUnauthorizedRequestsForRegistries: ['r']
+      };
+      navyStub.getNavyFile.resolves(navyFile);
+      navyStub.ps.resolves([makeService({
+        image: 'navy/api:latest',
+        raw: {
+          Image: 'sha256:abc'
+        }
+      })]);
+      await updatesCli({
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(hasUpdateStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(hasUpdateStub.firstCall.args).to.eql(['navy/api:latest', 'sha256:abc', navyFile]);
+    });
+  });
+  describe('renderStatus null branch (initial Checking... state)', function () {
+    it('should print Checking... in the very first draw before any update results', async function () {
+      let resolveHasUpdate;
+      hasUpdateStub.callsFake(() => new Promise(resolve => {
+        resolveHasUpdate = resolve;
+      }));
+      navyStub.ps.resolves([makeService()]);
+      const cliPromise = updatesCli({
+        navy: 'env-1'
+      });
+      await clock.tickAsync(0);
+      const before = combinedLog();
+      (0, _chai.expect)(before).to.contain('Checking...');
+      resolveHasUpdate(false);
+      await cliPromise;
+    });
+  });
+  describe('spinner interval', function () {
+    it('should advance the spinner frame on each interval tick and wrap back to 0 after frames.length ticks', async function () {
+      let resolveHasUpdate;
+      hasUpdateStub.callsFake(() => new Promise(resolve => {
+        resolveHasUpdate = resolve;
+      }));
+      navyStub.ps.resolves([makeService()]);
+      const cliPromise = updatesCli({
+        navy: 'env-1'
+      });
+      await clock.tickAsync(0);
+      const drawsBefore = consoleLogStub.callCount;
+      await clock.tickAsync(_cliSpinners.dots.interval * (_cliSpinners.dots.frames.length + 1));
+      (0, _chai.expect)(consoleLogStub.callCount).to.be.greaterThan(drawsBefore);
+      resolveHasUpdate(false);
+      await cliPromise;
+      (0, _chai.expect)(clock.countTimers()).to.equal(0);
+    });
+  });
+});

package/lib/cli/__tests__/wait-for-healthy.js

@@ -0,0 +1,134 @@
+"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/wait-for-healthy', function () {
+  let sandbox;
+  let getNavyStub;
+  let navyStub;
+  let readlineStub;
+  let consoleLogStub;
+  let originalIsTTY;
+  let waitForHealthyCli;
+  let clock;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    navyStub = {
+      name: 'env-1',
+      waitForHealthy: sandbox.stub().resolves()
+    };
+    getNavyStub = sandbox.stub().returns(navyStub);
+    readlineStub = {
+      clearLine: sandbox.stub(),
+      cursorTo: sandbox.stub(),
+      moveCursor: sandbox.stub()
+    };
+    consoleLogStub = sandbox.stub(console, 'log');
+    originalIsTTY = process.stdout.isTTY;
+    waitForHealthyCli = _proxyquire.default.noCallThru()('../wait-for-healthy', {
+      '../': {
+        getNavy: getNavyStub
+      },
+      readline: readlineStub
+    });
+  });
+  afterEach(function () {
+    process.stdout.isTTY = originalIsTTY;
+    if (clock) {
+      clock.restore();
+      clock = null;
+    }
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    describe('non-TTY mode', function () {
+      beforeEach(function () {
+        process.stdout.isTTY = false;
+      });
+      it('should call waitForHealthy with undefined when services are empty', async function () {
+        await waitForHealthyCli([], {
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(navyStub.waitForHealthy.calledOnce).to.equal(true);
+        (0, _chai.expect)(navyStub.waitForHealthy.firstCall.args[0]).to.equal(undefined);
+      });
+      it('should call waitForHealthy with the supplied services', async function () {
+        await waitForHealthyCli(['web', 'api'], {
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(navyStub.waitForHealthy.firstCall.args[0]).to.eql(['web', 'api']);
+      });
+      it('should log "Now available" after the wait completes', async function () {
+        await waitForHealthyCli([], {
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(consoleLogStub.calledWith('Now available')).to.equal(true);
+      });
+    });
+    describe('TTY mode', function () {
+      beforeEach(function () {
+        process.stdout.isTTY = true;
+        clock = _sinon.default.useFakeTimers();
+      });
+      it('should call waitForHealthy with a callback for service health updates', async function () {
+        const promise = waitForHealthyCli([], {
+          navy: 'env-1'
+        });
+        await promise;
+        (0, _chai.expect)(navyStub.waitForHealthy.calledOnce).to.equal(true);
+        (0, _chai.expect)(navyStub.waitForHealthy.firstCall.args[1]).to.be.a('function');
+      });
+      it('should print "Waiting" while no health status is reported', async function () {
+        await waitForHealthyCli([], {
+          navy: 'env-1'
+        });
+        const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+        (0, _chai.expect)(printed).to.contain('Waiting');
+      });
+      it('should render a checkmark for healthy services and spinner for unhealthy', async function () {
+        navyStub.waitForHealthy.callsFake(async (services, cb) => {
+          cb([{
+            service: 'web',
+            health: 'healthy'
+          }, {
+            service: 'api',
+            health: 'starting'
+          }]);
+        });
+        await waitForHealthyCli([], {
+          navy: 'env-1'
+        });
+        const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+        (0, _chai.expect)(printed).to.contain('web');
+        (0, _chai.expect)(printed).to.contain('api');
+      });
+      it('should advance the spinner frame and redraw on the timer interval', async function () {
+        navyStub.waitForHealthy.callsFake(() => new Promise(() => {}));
+        const promise = waitForHealthyCli([], {
+          navy: 'env-1'
+        });
+        clock.tick(1000);
+        (0, _chai.expect)(readlineStub.clearLine.called).to.equal(true);
+        promise.catch(() => {});
+      });
+      it('should wrap spinner index back to zero when reaching the end of frames', async function () {
+        navyStub.waitForHealthy.callsFake(() => new Promise(() => {}));
+        waitForHealthyCli([], {
+          navy: 'env-1'
+        }).catch(() => {});
+        clock.tick(10000);
+        (0, _chai.expect)(readlineStub.clearLine.called).to.equal(true);
+      });
+      it('should pass services through to waitForHealthy', async function () {
+        await waitForHealthyCli(['web'], {
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(navyStub.waitForHealthy.firstCall.args[0]).to.eql(['web']);
+      });
+    });
+  });
+});

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

@@ -0,0 +1,275 @@
+"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/config/index', function () {
+  let sandbox;
+  let getConfigStub;
+  let setConfigStub;
+  let reconfigureAllNaviesStub;
+  let consoleLogStub;
+  let consoleErrorStub;
+  let processOnStub;
+  let actions;
+  let program;
+  let mod;
+  function loadModule() {
+    actions = {};
+    function commandFactory() {
+      const builder = {
+        description() {
+          return builder;
+        },
+        action(handler) {
+          builder._lastAction = handler;
+          return builder;
+        }
+      };
+      return builder;
+    }
+    program = {
+      _commands: {},
+      command(spec) {
+        const name = spec.split(' ')[0];
+        const builder = commandFactory();
+        const origAction = builder.action.bind(builder);
+        builder.action = handler => {
+          actions[name] = handler;
+          return origAction(handler);
+        };
+        return builder;
+      },
+      parse: sandbox.stub(),
+      help: sandbox.stub(),
+      args: ['placeholder']
+    };
+    mod = _proxyquire.default.noCallThru()('../index', {
+      commander: {
+        program
+      },
+      '../../config': {
+        getConfig: getConfigStub,
+        setConfig: setConfigStub
+      },
+      '../../errors': {
+        NavyError: _errors.NavyError
+      },
+      '../util/reconfigure': {
+        reconfigureAllNavies: reconfigureAllNaviesStub
+      }
+    });
+  }
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    getConfigStub = sandbox.stub().resolves({});
+    setConfigStub = sandbox.stub().resolves();
+    reconfigureAllNaviesStub = sandbox.stub().resolves();
+    consoleLogStub = sandbox.stub(console, 'log');
+    consoleErrorStub = sandbox.stub(console, 'error');
+    processOnStub = sandbox.stub(process, 'on');
+    loadModule();
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('reconfigureIfNecessary', function () {
+    it('should call reconfigureAllNavies for externalIP', async function () {
+      await mod.reconfigureIfNecessary('externalIP');
+      (0, _chai.expect)(reconfigureAllNaviesStub.calledOnce).to.equal(true);
+    });
+    it('should not call reconfigureAllNavies for unrelated config props', async function () {
+      await mod.reconfigureIfNecessary('defaultNavy');
+      (0, _chai.expect)(reconfigureAllNaviesStub.called).to.equal(false);
+    });
+  });
+  describe('module side effects', function () {
+    it('should register a process unhandledRejection handler', function () {
+      (0, _chai.expect)(processOnStub.calledWith('unhandledRejection')).to.equal(true);
+    });
+    it('should call program.parse with process.argv', function () {
+      (0, _chai.expect)(program.parse.calledOnce).to.equal(true);
+      (0, _chai.expect)(program.parse.firstCall.args[0]).to.equal(process.argv);
+    });
+    it('should not call help when args are present', function () {
+      (0, _chai.expect)(program.help.called).to.equal(false);
+    });
+    it('should call help when args are empty', function () {
+      sandbox.restore();
+      sandbox = _sinon.default.createSandbox();
+      getConfigStub = sandbox.stub().resolves({});
+      setConfigStub = sandbox.stub().resolves();
+      reconfigureAllNaviesStub = sandbox.stub().resolves();
+      sandbox.stub(console, 'log');
+      sandbox.stub(console, 'error');
+      sandbox.stub(process, 'on');
+      actions = {};
+      program = {
+        command(spec) {
+          const name = spec.split(' ')[0];
+          const builder = {
+            description() {
+              return builder;
+            },
+            action(handler) {
+              actions[name] = handler;
+              return builder;
+            }
+          };
+          return builder;
+        },
+        parse: sandbox.stub(),
+        help: sandbox.stub(),
+        args: []
+      };
+      _proxyquire.default.noCallThru()('../index', {
+        commander: {
+          program
+        },
+        '../../config': {
+          getConfig: getConfigStub,
+          setConfig: setConfigStub
+        },
+        '../../errors': {
+          NavyError: _errors.NavyError
+        },
+        '../util/reconfigure': {
+          reconfigureAllNavies: reconfigureAllNaviesStub
+        }
+      });
+      (0, _chai.expect)(program.help.calledOnce).to.equal(true);
+    });
+    describe('unhandledRejection handler', function () {
+      it('should call prettyPrint on a NavyError', function () {
+        const handler = processOnStub.firstCall.args[1];
+        const err = new _errors.NavyError('boom');
+        const prettyPrintStub = sandbox.stub(err, 'prettyPrint');
+        handler(err);
+        (0, _chai.expect)(prettyPrintStub.calledOnce).to.equal(true);
+      });
+      it('should log the stack of a generic error', function () {
+        const handler = processOnStub.firstCall.args[1];
+        const err = new Error('boom');
+        handler(err);
+        (0, _chai.expect)(consoleErrorStub.calledWith(err.stack)).to.equal(true);
+      });
+    });
+  });
+  describe('set command', function () {
+    it('should throw a NavyError for an unknown key', async function () {
+      let caught;
+      try {
+        await actions.set('not-a-key', 'value');
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+      (0, _chai.expect)(caught.message).to.contain('Invalid config key');
+      (0, _chai.expect)(setConfigStub.called).to.equal(false);
+    });
+    it('should map default-navy and call setConfig with merged config', async function () {
+      getConfigStub.resolves({
+        existing: 'value'
+      });
+      await actions.set('default-navy', 'dev');
+      (0, _chai.expect)(setConfigStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(setConfigStub.firstCall.args[0]).to.eql({
+        existing: 'value',
+        defaultNavy: 'dev'
+      });
+    });
+    it('should reconfigure all navies when externalIP changes', async function () {
+      await actions.set('external-ip', '10.0.0.1');
+      (0, _chai.expect)(reconfigureAllNaviesStub.calledOnce).to.equal(true);
+    });
+    it('should not reconfigure when default-navy changes', async function () {
+      await actions.set('default-navy', 'dev');
+      (0, _chai.expect)(reconfigureAllNaviesStub.called).to.equal(false);
+    });
+  });
+  describe('get command', function () {
+    it('should throw a NavyError for an unknown key', async function () {
+      let caught;
+      try {
+        await actions.get('not-a-key');
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+    });
+    it('should print the mapped config value', async function () {
+      getConfigStub.resolves({
+        defaultNavy: 'dev'
+      });
+      await actions.get('default-navy');
+      (0, _chai.expect)(consoleLogStub.calledWith('dev')).to.equal(true);
+    });
+  });
+  describe('rm command', function () {
+    it('should throw a NavyError for an unknown key', async function () {
+      let caught;
+      try {
+        await actions.rm('not-a-key');
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+      (0, _chai.expect)(setConfigStub.called).to.equal(false);
+    });
+    it('should set the mapped property to null', async function () {
+      getConfigStub.resolves({
+        defaultNavy: 'dev'
+      });
+      await actions.rm('default-navy');
+      (0, _chai.expect)(setConfigStub.firstCall.args[0]).to.eql({
+        defaultNavy: null
+      });
+    });
+    it('should reconfigure all navies when externalIP is removed', async function () {
+      await actions.rm('external-ip');
+      (0, _chai.expect)(reconfigureAllNaviesStub.calledOnce).to.equal(true);
+    });
+    it('should not reconfigure when default-navy is removed', async function () {
+      await actions.rm('default-navy');
+      (0, _chai.expect)(reconfigureAllNaviesStub.called).to.equal(false);
+    });
+  });
+  describe('ls command', function () {
+    it('should print one line per known key with values', async function () {
+      getConfigStub.resolves({
+        defaultNavy: 'dev',
+        externalIP: '10.0.0.1',
+        tlsRootCaDir: null
+      });
+      await actions.ls();
+      const printed = consoleLogStub.firstCall.args[0];
+      (0, _chai.expect)(printed).to.contain('default-navy=dev');
+      (0, _chai.expect)(printed).to.contain('external-ip=10.0.0.1');
+      (0, _chai.expect)(printed).to.contain('tlsCa-dir=null');
+    });
+    it('should print null for missing keys', async function () {
+      getConfigStub.resolves({});
+      await actions.ls();
+      const printed = consoleLogStub.firstCall.args[0];
+      (0, _chai.expect)(printed).to.contain('default-navy=null');
+    });
+  });
+  describe('json command', function () {
+    it('should print the full config as pretty JSON', async function () {
+      getConfigStub.resolves({
+        a: 1,
+        b: 'two'
+      });
+      await actions.json();
+      (0, _chai.expect)(consoleLogStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(consoleLogStub.firstCall.args[0]).to.equal(JSON.stringify({
+        a: 1,
+        b: 'two'
+      }, null, 2));
+    });
+  });
+});