navy 6.0.0 → 7.0.0-alpha.2

package/lib/cli/__tests__/https.js

@@ -0,0 +1,210 @@
+"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/https', function () {
+  let sandbox;
+  let getNavyStub;
+  let navyStub;
+  let getConfigStub;
+  let getConfigDirStub;
+  let DEFAULT_TLS_ROOT_CA_DIR;
+  let reconfigureHTTPProxyStub;
+  let createCertStub;
+  let generateRootCaStub;
+  let removeCertStub;
+  let fsStub;
+  let consoleLogStub;
+  let httpsCli;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    navyStub = {
+      isInitialised: sandbox.stub().resolves(true),
+      getNavyFile: sandbox.stub().resolves({
+        ports: 'whatever'
+      }),
+      ensurePluginsLoaded: sandbox.stub().resolves(),
+      getAvailableServiceNames: sandbox.stub().resolves(['web', 'api']),
+      url: sandbox.stub().resolves('https://web.local')
+    };
+    getNavyStub = sandbox.stub().resolves(navyStub);
+    getConfigStub = sandbox.stub().returns({});
+    getConfigDirStub = sandbox.stub().returns('/cfg');
+    DEFAULT_TLS_ROOT_CA_DIR = '/default-ca-dir';
+    reconfigureHTTPProxyStub = sandbox.stub().resolves();
+    createCertStub = sandbox.stub().resolves();
+    generateRootCaStub = sandbox.stub().resolves();
+    removeCertStub = sandbox.stub().resolves();
+    fsStub = {
+      existsSync: sandbox.stub().returns(true),
+      readdirSync: sandbox.stub().returns(['web.local.crt', 'api.local.crt', 'something.txt'])
+    };
+    consoleLogStub = sandbox.stub(console, 'log');
+    httpsCli = _proxyquire.default.noCallThru()('../https', {
+      '../errors': {
+        NavyError: _errors.NavyError
+      },
+      '../navy': {
+        getNavy: getNavyStub
+      },
+      '../config': {
+        getConfig: getConfigStub,
+        getConfigDir: getConfigDirStub,
+        DEFAULT_TLS_ROOT_CA_DIR
+      },
+      '../http-proxy': {
+        reconfigureHTTPProxy: reconfigureHTTPProxyStub
+      },
+      '../util/https': {
+        createCert: createCertStub,
+        generateRootCa: generateRootCaStub,
+        removeCert: removeCertStub
+      },
+      fs: fsStub
+    });
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    describe('disable mode', function () {
+      it('should remove the cert and reconfigure the proxy', async function () {
+        await httpsCli([], {
+          navy: 'env-1',
+          disable: 'web'
+        });
+        (0, _chai.expect)(removeCertStub.calledOnce).to.equal(true);
+        (0, _chai.expect)(reconfigureHTTPProxyStub.calledOnce).to.equal(true);
+        (0, _chai.expect)(reconfigureHTTPProxyStub.firstCall.args[0].restart).to.equal(true);
+      });
+      it('should pass navyFile to reconfigureHTTPProxy when the navy is initialised', async function () {
+        navyStub.isInitialised.resolves(true);
+        navyStub.getNavyFile.resolves({
+          foo: 'bar'
+        });
+        await httpsCli([], {
+          navy: 'env-1',
+          disable: 'web'
+        });
+        (0, _chai.expect)(reconfigureHTTPProxyStub.firstCall.args[0].navyFile).to.eql({
+          foo: 'bar'
+        });
+      });
+      it('should pass undefined navyFile when the navy is not initialised', async function () {
+        navyStub.isInitialised.resolves(false);
+        await httpsCli([], {
+          navy: 'env-1',
+          disable: 'web'
+        });
+        (0, _chai.expect)(reconfigureHTTPProxyStub.firstCall.args[0].navyFile).to.equal(undefined);
+        (0, _chai.expect)(navyStub.getNavyFile.called).to.equal(false);
+      });
+      it('should print a confirmation message naming the disabled service', async function () {
+        await httpsCli([], {
+          navy: 'env-1',
+          disable: 'web'
+        });
+        const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+        (0, _chai.expect)(printed).to.contain('web');
+        (0, _chai.expect)(printed).to.contain('disabled');
+      });
+    });
+    describe('list mode (no services and no disable)', function () {
+      it('should return early when the certs path does not exist', async function () {
+        fsStub.existsSync.returns(false);
+        await httpsCli([], {
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(fsStub.readdirSync.called).to.equal(false);
+        (0, _chai.expect)(generateRootCaStub.called).to.equal(false);
+      });
+      it('should print only .crt urls when listing', async function () {
+        fsStub.existsSync.callsFake(p => p === '/cfg/tls-certs');
+        await httpsCli([], {
+          navy: 'env-1'
+        });
+        const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+        (0, _chai.expect)(printed).to.contain('https://web.local');
+        (0, _chai.expect)(printed).to.contain('https://api.local');
+        (0, _chai.expect)(printed).to.not.contain('something.txt');
+      });
+      it('should also handle a null services arg as list mode', async function () {
+        fsStub.existsSync.returns(false);
+        await httpsCli(null, {
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(generateRootCaStub.called).to.equal(false);
+      });
+    });
+    describe('enable mode', function () {
+      it('should generate the root CA when the CA cert/key are missing', async function () {
+        fsStub.existsSync.callsFake(p => !p.endsWith('ca.crt'));
+        await httpsCli(['web'], {
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(generateRootCaStub.calledOnce).to.equal(true);
+      });
+      it('should skip generating the root CA when ca.crt and ca.key both exist', async function () {
+        fsStub.existsSync.returns(true);
+        await httpsCli(['web'], {
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(generateRootCaStub.called).to.equal(false);
+      });
+      it('should create a cert for each available service', async function () {
+        await httpsCli(['web', 'api'], {
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(createCertStub.callCount).to.equal(2);
+      });
+      it('should skip services that are not in the available service list', async function () {
+        await httpsCli(['web', 'unknown'], {
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(createCertStub.callCount).to.equal(1);
+        const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+        (0, _chai.expect)(printed).to.contain('unknown');
+        (0, _chai.expect)(printed).to.contain('not found');
+      });
+      it('should rethrow as NavyError when createCert fails', async function () {
+        createCertStub.rejects(new Error('cert error'));
+        let caught;
+        try {
+          await httpsCli(['web'], {
+            navy: 'env-1'
+          });
+        } catch (err) {
+          caught = err;
+        }
+        (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+        (0, _chai.expect)(caught.message).to.contain('Could not generate TLS cert');
+      });
+      it('should reconfigure HTTPS proxy after enabling and print services list', async function () {
+        await httpsCli(['web', 'api'], {
+          navy: 'env-1'
+        });
+        (0, _chai.expect)(reconfigureHTTPProxyStub.calledOnce).to.equal(true);
+        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');
+        (0, _chai.expect)(printed).to.contain('HTTPS');
+      });
+      it('should use a custom tlsRootCaDir when set in config', async function () {
+        getConfigStub.returns({
+          tlsRootCaDir: '/custom-ca'
+        });
+        fsStub.existsSync.callsFake(p => p === '/custom-ca/ca.crt' || p === '/custom-ca/ca.key');
+        await httpsCli(['web'], {
+          navy: 'env-1'
+        });
+        const checkedPaths = fsStub.existsSync.getCalls().map(c => c.args[0]);
+        (0, _chai.expect)(checkedPaths.some(p => p === '/custom-ca/ca.crt')).to.equal(true);
+      });
+    });
+  });
+});

package/lib/cli/__tests__/import.js

@@ -0,0 +1,110 @@
+"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/import', function () {
+  let sandbox;
+  let getNavyStub;
+  let navyStub;
+  let getImportOptionsForCLIStub;
+  let importNavyStub;
+  let fsStub;
+  let consoleLogStub;
+  let originalIsTTY;
+  let importCli;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    navyStub = {
+      name: 'env-1'
+    };
+    getNavyStub = sandbox.stub().returns(navyStub);
+    getImportOptionsForCLIStub = sandbox.stub().resolves({
+      configProvider: 'filesystem',
+      path: '/some/path'
+    });
+    importNavyStub = sandbox.stub().resolves();
+    fsStub = {
+      readFileSync: sandbox.stub().returns('   ___   \n  /___\\  \n')
+    };
+    consoleLogStub = sandbox.stub(console, 'log');
+    originalIsTTY = process.stdout.isTTY;
+    process.stdout.isTTY = false;
+    importCli = _proxyquire.default.noCallThru()('../import', {
+      '../util/fs': fsStub,
+      '../': {
+        getNavy: getNavyStub
+      },
+      '../config-provider': {
+        getImportOptionsForCLI: getImportOptionsForCLIStub
+      },
+      './util': {
+        importNavy: importNavyStub
+      }
+    });
+  });
+  afterEach(function () {
+    process.stdout.isTTY = originalIsTTY;
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    it('should resolve the navy instance using opts.navy', async function () {
+      await importCli({
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(getNavyStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(getNavyStub.firstCall.args[0]).to.equal('env-1');
+    });
+    it('should read the sailing-boat ASCII art file', async function () {
+      await importCli({
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(fsStub.readFileSync.calledOnce).to.equal(true);
+      (0, _chai.expect)(fsStub.readFileSync.firstCall.args[0]).to.contain('sailing-boat.txt');
+    });
+    it('should derive initialise opts via getImportOptionsForCLI and pass them to importNavy', async function () {
+      const opts = {
+        navy: 'env-1',
+        someOpt: 'value'
+      };
+      const initialiseOpts = {
+        configProvider: 'filesystem',
+        path: '/cwd'
+      };
+      getImportOptionsForCLIStub.resolves(initialiseOpts);
+      await importCli(opts);
+      (0, _chai.expect)(getImportOptionsForCLIStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(getImportOptionsForCLIStub.firstCall.args[0]).to.equal(opts);
+      (0, _chai.expect)(importNavyStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(importNavyStub.firstCall.args[0]).to.equal(navyStub);
+      (0, _chai.expect)(importNavyStub.firstCall.args[1]).to.equal(initialiseOpts);
+    });
+    it('should log the post-import help line', async function () {
+      await importCli({
+        navy: 'env-1'
+      });
+      const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join(' ');
+      (0, _chai.expect)(printed).to.contain('navy');
+      (0, _chai.expect)(printed).to.contain('any directory');
+    });
+    it('should not print the boat ASCII art when stdout is not a TTY', async function () {
+      process.stdout.isTTY = false;
+      await importCli({
+        navy: 'env-1'
+      });
+      const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+      (0, _chai.expect)(printed).to.not.contain('___');
+    });
+    it('should print the boat ASCII art when stdout is a TTY', async function () {
+      process.stdout.isTTY = true;
+      await importCli({
+        navy: 'env-1'
+      });
+      const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+      (0, _chai.expect)(printed).to.contain('___');
+    });
+  });
+});

package/lib/cli/__tests__/index.js

@@ -0,0 +1,118 @@
+"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/index', function () {
+  let sandbox;
+  let programStub;
+  let helpCmdStub;
+  let parseCalls;
+  let actionHandlerForHelp;
+  let originalArgv;
+  function loadModule({
+    args = ['placeholder'],
+    parseImpl
+  } = {}) {
+    actionHandlerForHelp = null;
+    parseCalls = [];
+    helpCmdStub = {
+      alias: sandbox.stub().returnsThis(),
+      action: sandbox.stub().callsFake(handler => {
+        actionHandlerForHelp = handler;
+        return helpCmdStub;
+      })
+    };
+    programStub = {
+      args,
+      version: sandbox.stub().returnsThis(),
+      command: sandbox.stub().returns(helpCmdStub),
+      help: sandbox.stub(),
+      parse: sandbox.stub().callsFake(argv => {
+        parseCalls.push(argv);
+        if (parseImpl) parseImpl();
+      })
+    };
+    return _proxyquire.default.noCallThru()('../index', {
+      '../../package.json': {
+        version: '1.2.3'
+      },
+      './program': programStub,
+      '../errors': {
+        NavyError: _errors.NavyError
+      }
+    });
+  }
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    sandbox.stub(console, 'log');
+    sandbox.stub(console, 'error');
+    originalArgv = process.argv;
+  });
+  afterEach(function () {
+    process.argv = originalArgv;
+    sandbox.restore();
+  });
+  describe('module side effects', function () {
+    it('should set the program version from package.json', function () {
+      loadModule();
+      (0, _chai.expect)(programStub.version.calledOnce).to.equal(true);
+      (0, _chai.expect)(programStub.version.firstCall.args[0]).to.equal('1.2.3');
+    });
+    it('should register a help command with * alias', function () {
+      loadModule();
+      (0, _chai.expect)(programStub.command.calledWith('help')).to.equal(true);
+      (0, _chai.expect)(helpCmdStub.alias.calledWith('*')).to.equal(true);
+    });
+    it('should call program.help() when invoking the help action', function () {
+      loadModule();
+      actionHandlerForHelp();
+      (0, _chai.expect)(programStub.help.called).to.equal(true);
+    });
+    it('should call program.parse with process.argv', function () {
+      loadModule();
+      (0, _chai.expect)(parseCalls).to.have.length(1);
+      (0, _chai.expect)(parseCalls[0]).to.equal(process.argv);
+    });
+    it('should call program.help when no args are present', function () {
+      loadModule({
+        args: []
+      });
+      (0, _chai.expect)(programStub.help.calledOnce).to.equal(true);
+    });
+    it('should not call program.help when args are present', function () {
+      loadModule({
+        args: ['some-cmd']
+      });
+      (0, _chai.expect)(programStub.help.called).to.equal(false);
+    });
+    it('should pretty-print a NavyError when parse throws one', function () {
+      const navyError = new _errors.NavyError('boom');
+      const prettyPrintStub = sandbox.stub(navyError, 'prettyPrint');
+      loadModule({
+        parseImpl: () => {
+          throw navyError;
+        }
+      });
+      (0, _chai.expect)(prettyPrintStub.calledOnce).to.equal(true);
+    });
+    it('should rethrow non-NavyError exceptions from parse', function () {
+      const otherError = new Error('boom');
+      let caught;
+      try {
+        loadModule({
+          parseImpl: () => {
+            throw otherError;
+          }
+        });
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.equal(otherError);
+    });
+  });
+});

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

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