navy 6.0.0 → 7.0.0-alpha.1

package/lib/__tests__/service.js

@@ -0,0 +1,16 @@
+"use strict";
+
+var _chai = require("chai");
+var _service = require("../service");
+/* eslint-env mocha */
+
+describe('service', function () {
+  describe('Status', function () {
+    it('should expose RUNNING and EXITED string constants', function () {
+      (0, _chai.expect)(_service.Status).to.eql({
+        RUNNING: 'running',
+        EXITED: 'exited'
+      });
+    });
+  });
+});

package/lib/cli/__tests__/develop.js

@@ -0,0 +1,239 @@
+"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/develop', function () {
+  let sandbox;
+  let getNavyStub;
+  let navyStub;
+  let getNavyRcStub;
+  let dockerStub;
+  let containerObj;
+  let consoleLogStub;
+  let originalCwd;
+  let developCli;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    navyStub = {
+      name: 'env-1',
+      getState: sandbox.stub().resolves({}),
+      saveState: sandbox.stub().resolves(),
+      emitAsync: sandbox.stub().resolves(),
+      kill: sandbox.stub().resolves(),
+      launch: sandbox.stub().resolves(),
+      ps: sandbox.stub().resolves([{
+        name: 'web',
+        id: 'abc123'
+      }])
+    };
+    getNavyStub = sandbox.stub().returns(navyStub);
+    getNavyRcStub = sandbox.stub().resolves({
+      services: ['web'],
+      develop: {
+        mounts: {
+          './src': '/app/src'
+        },
+        command: 'npm start'
+      }
+    });
+    containerObj = {
+      attach: sandbox.stub().resolves('stream'),
+      modem: {
+        demuxStream: sandbox.stub()
+      }
+    };
+    dockerStub = {
+      getContainer: sandbox.stub().returns(containerObj)
+    };
+    consoleLogStub = sandbox.stub(console, 'log');
+    originalCwd = process.cwd;
+    sandbox.stub(process, 'cwd').returns('/work');
+    developCli = _proxyquire.default.noCallThru()('../develop', {
+      '../': {
+        getNavy: getNavyStub
+      },
+      '../errors': {
+        NavyError: _errors.NavyError
+      },
+      '../util/docker-client': dockerStub,
+      '../util/navyrc': getNavyRcStub
+    });
+  });
+  afterEach(function () {
+    process.cwd = originalCwd;
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    it('should throw a NavyError when navyrc is null', async function () {
+      getNavyRcStub.resolves(null);
+      let caught;
+      try {
+        await developCli('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 a NavyError when navyrc has no services', async function () {
+      getNavyRcStub.resolves({
+        services: undefined
+      });
+      let caught;
+      try {
+        await developCli('web', {
+          navy: 'env-1'
+        });
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+    });
+    it('should throw a NavyError when develop key is missing', async function () {
+      getNavyRcStub.resolves({
+        services: ['web']
+      });
+      let caught;
+      try {
+        await developCli('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 develop mounts');
+    });
+    it('should throw when multiple services are listed and none specified', async function () {
+      getNavyRcStub.resolves({
+        services: ['web', 'api'],
+        develop: {
+          mounts: {},
+          command: 'x'
+        }
+      });
+      let caught;
+      try {
+        await developCli(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 when one is listed', async function () {
+      await developCli(undefined, {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(navyStub.kill.calledWith(['web'])).to.equal(true);
+    });
+    it('should throw when the service is not in the navyrc list', async function () {
+      let caught;
+      try {
+        await developCli('unknown', {
+          navy: 'env-1'
+        });
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+      (0, _chai.expect)(caught.message).to.contain('not a valid development target');
+    });
+    it('should resolve mount keys to absolute paths and persist them in state', async function () {
+      await developCli('web', {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(navyStub.saveState.calledOnce).to.equal(true);
+      const newState = navyStub.saveState.firstCall.args[0];
+      const mountKeys = Object.keys(newState.services.web._develop.mounts);
+      (0, _chai.expect)(mountKeys[0].endsWith('src')).to.equal(true);
+      (0, _chai.expect)(newState.services.web._develop.command).to.equal('npm start');
+    });
+    it('should preserve existing state.services entries on save', async function () {
+      navyStub.getState.resolves({
+        services: {
+          api: {
+            _tag: 'v1'
+          }
+        }
+      });
+      await developCli('web', {
+        navy: 'env-1'
+      });
+      const newState = navyStub.saveState.firstCall.args[0];
+      (0, _chai.expect)(newState.services.api).to.eql({
+        _tag: 'v1'
+      });
+    });
+    it('should default to {} when navy.getState returns null', async function () {
+      navyStub.getState.resolves(null);
+      await developCli('web', {
+        navy: 'env-1'
+      });
+      const newState = navyStub.saveState.firstCall.args[0];
+      // eslint-disable-next-line no-unused-expressions
+      (0, _chai.expect)(newState.services.web._develop).to.exist;
+    });
+    it('should kill, then launch the service in develop mode', async function () {
+      await developCli('web', {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(navyStub.emitAsync.calledWith('cli.develop.beforeLaunch')).to.equal(true);
+      (0, _chai.expect)(navyStub.kill.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.launch.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.launch.firstCall.args[0]).to.eql(['web']);
+      (0, _chai.expect)(navyStub.launch.firstCall.args[1]).to.eql({
+        noDeps: true
+      });
+    });
+    it('should attach to the container and demux the stream', async function () {
+      await developCli('web', {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(dockerStub.getContainer.calledWith('abc123')).to.equal(true);
+      (0, _chai.expect)(containerObj.attach.calledOnce).to.equal(true);
+
+      // Wait for the .then callback to fire on the attach promise
+      await new Promise(resolve => setImmediate(resolve));
+      (0, _chai.expect)(containerObj.modem.demuxStream.calledOnce).to.equal(true);
+      (0, _chai.expect)(containerObj.modem.demuxStream.firstCall.args[0]).to.equal('stream');
+    });
+    it('should log a graceful exit message when attach rejects', async function () {
+      containerObj.attach.rejects(new Error('attach failed'));
+      await developCli('web', {
+        navy: 'env-1'
+      });
+
+      // Wait microtask flush
+      await new Promise(resolve => setImmediate(resolve));
+      await new Promise(resolve => setImmediate(resolve));
+      const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+      (0, _chai.expect)(printed).to.contain('exited');
+    });
+    it('should throw an invariant violation when no container is found for the service', async function () {
+      navyStub.ps.resolves([{
+        name: 'other',
+        id: 'xyz'
+      }]);
+      let caught;
+      try {
+        await developCli('web', {
+          navy: 'env-1'
+        });
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.an('error');
+      (0, _chai.expect)(caught.message).to.contain('DEVELOP_NO_CONTAINER_ID');
+    });
+  });
+});

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

@@ -0,0 +1,68 @@
+"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/external-ip', function () {
+  let sandbox;
+  let getConfigStub;
+  let getExternalIPStub;
+  let consoleLogStub;
+  let externalIpCli;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    getConfigStub = sandbox.stub();
+    getExternalIPStub = sandbox.stub();
+    consoleLogStub = sandbox.stub(console, 'log');
+    externalIpCli = _proxyquire.default.noCallThru()('../external-ip', {
+      '../config': {
+        getConfig: getConfigStub
+      },
+      '../util/external-ip': {
+        getExternalIP: getExternalIPStub
+      }
+    });
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    it('should pass the externalIP value from config to getExternalIP', async function () {
+      getConfigStub.returns({
+        externalIP: 'configured.host'
+      });
+      getExternalIPStub.resolves('1.2.3.4');
+      await externalIpCli();
+      (0, _chai.expect)(getConfigStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(getExternalIPStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(getExternalIPStub.firstCall.args[0]).to.equal('configured.host');
+    });
+    it('should log the resolved external IP', async function () {
+      getConfigStub.returns({
+        externalIP: null
+      });
+      getExternalIPStub.resolves('5.6.7.8');
+      await externalIpCli();
+      (0, _chai.expect)(consoleLogStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(consoleLogStub.firstCall.args[0]).to.equal('5.6.7.8');
+    });
+    it('should pass undefined when config has no externalIP key', async function () {
+      getConfigStub.returns({});
+      getExternalIPStub.resolves('127.0.0.1');
+      await externalIpCli();
+      (0, _chai.expect)(getExternalIPStub.firstCall.args[0]).to.equal(undefined);
+    });
+    it('should support an asynchronous getConfig implementation', async function () {
+      getConfigStub.resolves({
+        externalIP: 'async.host'
+      });
+      getExternalIPStub.resolves('9.9.9.9');
+      await externalIpCli();
+      (0, _chai.expect)(getExternalIPStub.firstCall.args[0]).to.equal('async.host');
+      (0, _chai.expect)(consoleLogStub.firstCall.args[0]).to.equal('9.9.9.9');
+    });
+  });
+});

package/lib/cli/__tests__/health.js

@@ -0,0 +1,257 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _proxyquire = _interopRequireDefault(require("proxyquire"));
+var _stripAnsi = _interopRequireDefault(require("strip-ansi"));
+/* eslint-env mocha */
+
+// NOTE (potential source bugs in health.js, not locked in by these tests):
+//   1. `getStatus` and `getHistory` both compute `service.raw && service.raw.State.Health`.
+//      If `service.raw` is truthy but `service.raw.State` is undefined, this throws a
+//      TypeError reading 'Health' of undefined. The guard chain is incomplete; it
+//      should be `service.raw && service.raw.State && service.raw.State.Health`.
+//   2. Both helpers accept a `state` parameter that is never used (dead parameter).
+
+describe('cli/health', function () {
+  let sandbox;
+  let getNavyStub;
+  let navyStub;
+  let consoleLogStub;
+  let healthCli;
+  function makeService(overrides = {}) {
+    return {
+      id: 'svc-1',
+      name: 'api',
+      raw: undefined,
+      ...overrides
+    };
+  }
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    navyStub = {
+      ps: sandbox.stub().resolves([]),
+      getState: sandbox.stub().resolves(null)
+    };
+    getNavyStub = sandbox.stub().returns(navyStub);
+    consoleLogStub = sandbox.stub(console, 'log');
+    healthCli = _proxyquire.default.noCallThru()('../health', {
+      '../': {
+        getNavy: getNavyStub
+      }
+    });
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  function lastLoggedString() {
+    const last = consoleLogStub.lastCall;
+    return last ? String(last.args[0]) : '';
+  }
+  describe('default export', function () {
+    it('should resolve the navy instance using opts.navy', async function () {
+      await healthCli({
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(getNavyStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(getNavyStub.firstCall.args[0]).to.equal('env-1');
+    });
+    it('should print the table headers even when there are no services', async function () {
+      navyStub.ps.resolves([]);
+      await healthCli({
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(consoleLogStub.calledOnce).to.equal(true);
+      const text = (0, _stripAnsi.default)(consoleLogStub.firstCall.args[0]);
+      (0, _chai.expect)(text).to.contain('NAME');
+      (0, _chai.expect)(text).to.contain('STATUS');
+      (0, _chai.expect)(text).to.contain('HISTORY');
+    });
+    it('should call ps and getState exactly once each', async function () {
+      navyStub.ps.resolves([makeService()]);
+      await healthCli({
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(navyStub.ps.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.getState.calledOnce).to.equal(true);
+    });
+  });
+  describe('getStatus (via default export)', function () {
+    it('should render - when the service has no raw container info', async function () {
+      navyStub.ps.resolves([makeService({
+        name: 'api',
+        raw: undefined
+      })]);
+      await healthCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('api');
+      (0, _chai.expect)(text).to.contain('-');
+    });
+    it('should render - when the service has raw but no Health record', async function () {
+      navyStub.ps.resolves([makeService({
+        name: 'api',
+        raw: {
+          State: {
+            Health: null
+          }
+        }
+      })]);
+      await healthCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('api');
+      (0, _chai.expect)(text).to.contain('-');
+    });
+    it('should render Healthy when health status is "healthy"', async function () {
+      navyStub.ps.resolves([makeService({
+        raw: {
+          State: {
+            Health: {
+              Status: 'healthy',
+              Log: []
+            }
+          }
+        }
+      })]);
+      await healthCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('Healthy');
+    });
+    it('should render Unhealthy when health status is anything other than healthy', async function () {
+      navyStub.ps.resolves([makeService({
+        raw: {
+          State: {
+            Health: {
+              Status: 'starting',
+              Log: []
+            }
+          }
+        }
+      })]);
+      await healthCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('Unhealthy');
+    });
+  });
+  describe('getHistory (via default export)', function () {
+    it('should render - when the service has no raw container info', async function () {
+      navyStub.ps.resolves([makeService({
+        name: 'api',
+        raw: undefined
+      })]);
+      await healthCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('-');
+    });
+    it('should render - when the service has raw but no Health record', async function () {
+      navyStub.ps.resolves([makeService({
+        raw: {
+          State: {
+            Health: null
+          }
+        }
+      })]);
+      await healthCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('-');
+    });
+    it('should render only success markers when every entry has ExitCode 0', async function () {
+      navyStub.ps.resolves([makeService({
+        raw: {
+          State: {
+            Health: {
+              Status: 'healthy',
+              Log: [{
+                ExitCode: 0
+              }, {
+                ExitCode: 0
+              }]
+            }
+          }
+        }
+      })]);
+      await healthCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('█ █');
+      (0, _chai.expect)(text).not.to.contain('x');
+    });
+    it('should render only failure markers when every entry has a non-zero ExitCode', async function () {
+      navyStub.ps.resolves([makeService({
+        raw: {
+          State: {
+            Health: {
+              Status: 'unhealthy',
+              Log: [{
+                ExitCode: 1
+              }, {
+                ExitCode: 2
+              }]
+            }
+          }
+        }
+      })]);
+      await healthCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('x x');
+      (0, _chai.expect)(text).not.to.contain('█');
+    });
+    it('should render mixed success and failure markers based on each entry ExitCode', async function () {
+      navyStub.ps.resolves([makeService({
+        raw: {
+          State: {
+            Health: {
+              Status: 'healthy',
+              Log: [{
+                ExitCode: 0
+              }, {
+                ExitCode: 1
+              }, {
+                ExitCode: 0
+              }]
+            }
+          }
+        }
+      })]);
+      await healthCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('█ x █');
+    });
+    it('should render an empty history string when Log is an empty array', async function () {
+      navyStub.ps.resolves([makeService({
+        raw: {
+          State: {
+            Health: {
+              Status: 'healthy',
+              Log: []
+            }
+          }
+        }
+      })]);
+      await healthCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('Healthy');
+      (0, _chai.expect)(text).not.to.contain('█');
+      (0, _chai.expect)(text).not.to.contain('x');
+    });
+  });
+});