navy 6.0.0 → 7.0.0-alpha.2

package/lib/navy/__tests__/middleware.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _middleware = require("../middleware");
+/* eslint-env mocha */
+
+function makeNavy({
+  driver,
+  registered = []
+} = {}) {
+  return {
+    name: 'env',
+    normalisedName: 'env',
+    getDriver: _sinon.default.stub().resolves(driver),
+    ensurePluginsLoaded: _sinon.default.stub().resolves(),
+    getNavyFile: _sinon.default.stub().resolves(null),
+    externalIP: _sinon.default.stub().resolves('127.0.0.1'),
+    _registeredMiddleware: registered
+  };
+}
+function makeDriver() {
+  return {
+    getConfig: _sinon.default.stub().resolves({
+      services: {}
+    }),
+    writeConfig: _sinon.default.stub().resolves()
+  };
+}
+describe('navy/middleware', function () {
+  describe('middlewareRunner', function () {
+    it('should be a no-op when the navy has no driver', async function () {
+      const navy = makeNavy({
+        driver: null
+      });
+      await (0, _middleware.middlewareRunner)(navy, {
+        services: {}
+      });
+      (0, _chai.expect)(navy.ensurePluginsLoaded.called).to.equal(false);
+    });
+    it('should ensure plugins are loaded before running middleware', async function () {
+      const driver = makeDriver();
+      const navy = makeNavy({
+        driver
+      });
+      await (0, _middleware.middlewareRunner)(navy, {
+        services: {}
+      });
+      (0, _chai.expect)(navy.ensurePluginsLoaded.calledOnce).to.equal(true);
+    });
+    it('should pipe the driver config through default + registered middleware and write the result', async function () {
+      const driver = makeDriver();
+      const tagged = _sinon.default.stub().callsFake(async config => ({
+        ...config,
+        _tagged: true
+      }));
+      const navy = makeNavy({
+        driver,
+        registered: [tagged]
+      });
+      await (0, _middleware.middlewareRunner)(navy, {
+        services: {}
+      });
+      (0, _chai.expect)(tagged.calledOnce).to.equal(true);
+      (0, _chai.expect)(driver.writeConfig.calledOnce).to.equal(true);
+      const written = driver.writeConfig.firstCall.args[0];
+      (0, _chai.expect)(written).to.have.property('_tagged', true);
+    });
+  });
+});

package/lib/navy/__tests__/plugin-interface.js

@@ -0,0 +1,121 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _proxyquire = _interopRequireDefault(require("proxyquire"));
+/* eslint-env mocha */
+
+describe('navy/plugin-interface', function () {
+  describe('loadPlugins', function () {
+    function loadModule(stubs) {
+      return _proxyquire.default.noCallThru()('../plugin-interface', stubs);
+    }
+    it('should throw an invariant violation if the navy has no config provider', async function () {
+      const {
+        loadPlugins
+      } = loadModule({});
+      const navy = {
+        name: 'env',
+        getConfigProvider: async () => null
+      };
+      let caught;
+      try {
+        await loadPlugins(navy, {
+          plugins: []
+        });
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.an('error');
+      (0, _chai.expect)(caught.message).to.match(/NO_CONFIG_PROVIDER/);
+    });
+    it('should return an empty array when navyFile has no plugins entry', async function () {
+      const {
+        loadPlugins
+      } = loadModule({});
+      const navy = {
+        getConfigProvider: async () => ({
+          getNavyPath: async () => '/some/path'
+        })
+      };
+      (0, _chai.expect)(await loadPlugins(navy, {})).to.eql([]);
+    });
+    it('should resolve plugins by name relative to the navy path and instantiate them with the navy', async function () {
+      const fakePluginPath = '/abs/path/to/plugin';
+      const fakePluginInstance = {
+        meta: 'instance'
+      };
+      const PluginCtor = navy => ({
+        ...fakePluginInstance,
+        navy
+      });
+      const {
+        loadPlugins
+      } = loadModule({
+        resolve: (pluginName, opts, cb) => cb(null, fakePluginPath),
+        [fakePluginPath]: PluginCtor
+      });
+      const navy = {
+        getConfigProvider: async () => ({
+          getNavyPath: async () => '/navy/path'
+        })
+      };
+      const plugins = await loadPlugins(navy, {
+        plugins: ['my-plugin']
+      });
+      (0, _chai.expect)(plugins).to.have.lengthOf(1);
+      (0, _chai.expect)(plugins[0]).to.have.property('meta', 'instance');
+      (0, _chai.expect)(plugins[0]).to.have.property('navy', navy);
+    });
+    it('should throw PLUGIN_RESOLVE_ERR with the joined plugin names when resolution fails', async function () {
+      const {
+        loadPlugins
+      } = loadModule({
+        resolve: (pluginName, opts, cb) => cb(new Error('not found'))
+      });
+      const navy = {
+        getConfigProvider: async () => ({
+          getNavyPath: async () => '/navy/path'
+        })
+      };
+      let caught;
+      try {
+        await loadPlugins(navy, {
+          plugins: ['plugin-a', 'plugin-b']
+        });
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.an('error');
+      (0, _chai.expect)(caught.message).to.match(/PLUGIN_RESOLVE_ERR/);
+      (0, _chai.expect)(caught.message).to.contain('plugin-a, plugin-b');
+    });
+    it('should throw PLUGIN_DOESNT_EXPORT_FUNCTION when a plugin module is not a function', async function () {
+      const fakePluginPath = '/abs/path/to/bad-plugin';
+      const {
+        loadPlugins
+      } = loadModule({
+        resolve: (pluginName, opts, cb) => cb(null, fakePluginPath),
+        [fakePluginPath]: {
+          notAFunction: true
+        }
+      });
+      const navy = {
+        getConfigProvider: async () => ({
+          getNavyPath: async () => '/navy/path'
+        })
+      };
+      let caught;
+      try {
+        await loadPlugins(navy, {
+          plugins: ['bad-plugin']
+        });
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.an('error');
+      (0, _chai.expect)(caught.message).to.match(/PLUGIN_DOESNT_EXPORT_FUNCTION/);
+      (0, _chai.expect)(caught.message).to.contain('bad-plugin');
+    });
+  });
+});

package/lib/navy/__tests__/state.js

@@ -0,0 +1,103 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _path = _interopRequireDefault(require("path"));
+var _fs = require("fs");
+var _fs2 = _interopRequireDefault(require("../../util/fs"));
+var _state = require("../state");
+/* eslint-env mocha */
+
+describe('navy/state', function () {
+  let sandbox;
+  let originalHome;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    originalHome = process.env.HOME;
+    process.env.HOME = '/home/test';
+  });
+  afterEach(function () {
+    sandbox.restore();
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+  });
+  describe('pathToNavyRoot', function () {
+    it('should return $HOME/.navy', function () {
+      (0, _chai.expect)((0, _state.pathToNavyRoot)()).to.equal(_path.default.join('/home/test', '.navy'));
+    });
+    it('should throw when HOME is not set', function () {
+      delete process.env.HOME;
+      (0, _chai.expect)(() => (0, _state.pathToNavyRoot)()).to.throw(/NO_HOME_DIRECTORY/);
+    });
+  });
+  describe('pathToNavys', function () {
+    it('should return $HOME/.navy/navies', function () {
+      (0, _chai.expect)((0, _state.pathToNavys)()).to.equal(_path.default.join('/home/test', '.navy', 'navies'));
+    });
+  });
+  describe('pathToNavy', function () {
+    it('should return $HOME/.navy/navies/<env>', function () {
+      (0, _chai.expect)((0, _state.pathToNavy)('myenv')).to.equal(_path.default.join('/home/test', '.navy', 'navies', 'myenv'));
+    });
+  });
+  describe('pathToState', function () {
+    it('should return $HOME/.navy/navies/<env>/state.json', function () {
+      (0, _chai.expect)((0, _state.pathToState)('myenv')).to.equal(_path.default.join('/home/test', '.navy', 'navies', 'myenv', 'state.json'));
+    });
+  });
+  describe('getState', function () {
+    it('should read and parse the state.json file', async function () {
+      const state = {
+        driver: 'docker-compose',
+        services: {
+          api: {}
+        }
+      };
+      const buf = Buffer.from(JSON.stringify(state));
+      sandbox.stub(_fs2.default, 'readFileAsync').resolves(buf);
+      (0, _chai.expect)(await (0, _state.getState)('myenv')).to.eql(state);
+    });
+    it('should return null when the state file cannot be read', async function () {
+      sandbox.stub(_fs2.default, 'readFileAsync').rejects(new Error('ENOENT'));
+      (0, _chai.expect)(await (0, _state.getState)('myenv')).to.equal(null);
+    });
+    it('should return null when the state file content is not valid JSON', async function () {
+      sandbox.stub(_fs2.default, 'readFileAsync').resolves(Buffer.from('not json'));
+      (0, _chai.expect)(await (0, _state.getState)('myenv')).to.equal(null);
+    });
+  });
+  describe('saveState', function () {
+    it('should mkdir -p the navy directory and write the state JSON file', async function () {
+      const mkdirStub = sandbox.stub(_fs.promises, 'mkdir').resolves();
+      const writeStub = sandbox.stub(_fs2.default, 'writeFileAsync').resolves();
+      const state = {
+        driver: 'docker-compose'
+      };
+      await (0, _state.saveState)('myenv', state);
+      (0, _chai.expect)(mkdirStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(mkdirStub.firstCall.args[0]).to.equal(_path.default.join('/home/test', '.navy', 'navies', 'myenv'));
+      (0, _chai.expect)(mkdirStub.firstCall.args[1]).to.eql({
+        recursive: true
+      });
+      (0, _chai.expect)(writeStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(writeStub.firstCall.args[0]).to.equal(_path.default.join('/home/test', '.navy', 'navies', 'myenv', 'state.json'));
+      (0, _chai.expect)(JSON.parse(writeStub.firstCall.args[1])).to.eql(state);
+    });
+  });
+  describe('deleteState', function () {
+    it('should rm -rf the navy directory recursively', async function () {
+      const rmStub = sandbox.stub(_fs.promises, 'rm').resolves();
+      await (0, _state.deleteState)('myenv');
+      (0, _chai.expect)(rmStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(rmStub.firstCall.args[0]).to.equal(_path.default.join('/home/test', '.navy', 'navies', 'myenv'));
+      (0, _chai.expect)(rmStub.firstCall.args[1]).to.eql({
+        recursive: true,
+        force: true
+      });
+    });
+  });
+});

package/lib/navy/__tests__/util.js

@@ -0,0 +1,24 @@
+"use strict";
+
+var _chai = require("chai");
+var _util = require("../util");
+/* eslint-env mocha */
+
+describe('navy/util', function () {
+  describe('normaliseNavyName', function () {
+    it('should strip non-word characters from a navy name', function () {
+      (0, _chai.expect)((0, _util.normaliseNavyName)('my-navy')).to.equal('mynavy');
+      (0, _chai.expect)((0, _util.normaliseNavyName)('my navy')).to.equal('mynavy');
+      (0, _chai.expect)((0, _util.normaliseNavyName)('a.b.c')).to.equal('abc');
+    });
+    it('should preserve underscores and digits (which are word characters)', function () {
+      (0, _chai.expect)((0, _util.normaliseNavyName)('env_1_test_2')).to.equal('env_1_test_2');
+    });
+    it('should leave a name with no special characters unchanged', function () {
+      (0, _chai.expect)((0, _util.normaliseNavyName)('plain')).to.equal('plain');
+    });
+    it('should return an empty string for a name made entirely of special characters', function () {
+      (0, _chai.expect)((0, _util.normaliseNavyName)('!@#$%^&*()')).to.equal('');
+    });
+  });
+});

package/lib/navy/default-middleware.js

@@ -1,27 +1,17 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _develop = _interopRequireDefault(require("../middleware/develop"));
-
 var _tagOverride = _interopRequireDefault(require("../middleware/tag-override"));
-
 var _portOverride = _interopRequireDefault(require("../middleware/port-override"));
-
 var _addServiceProxyConfig = _interopRequireDefault(require("../middleware/add-service-proxy-config"));
-
 var _setEnvVars = _interopRequireDefault(require("../middleware/set-env-vars"));
-
 var _setLoggingDriver = _interopRequireDefault(require("../middleware/set-logging-driver"));
-
 var _setImage = _interopRequireDefault(require("../middleware/set-image"));
-
 var _default = navy => [_develop.default, _tagOverride.default, _portOverride.default, _setEnvVars.default, _setLoggingDriver.default, _setImage.default, (0, _addServiceProxyConfig.default)(navy)];
-
 exports.default = _default;
 module.exports = exports.default;