navy 6.0.0 → 7.0.0-alpha.2

package/lib/domain/container-image.js

@@ -9,65 +9,52 @@ exports.getRegistryFromImage = getRegistryFromImage;
 exports.getRepositoryFromImage = getRepositoryFromImage;
 exports.getTagFromImageWithTag = getTagFromImageWithTag;
 // docker v2 registry URL
-const DEFAULT_REGISTRY = 'registry-1.docker.io'; // the url which docker stores in .docker/config.json for auth
-
-exports.DEFAULT_REGISTRY = DEFAULT_REGISTRY;
-const DEFAULT_REGISTRY_AUTH = 'https://index.docker.io/v1/'; // someregistry.com/some/image:latest -> someregistry.com/some/image
-
-exports.DEFAULT_REGISTRY_AUTH = DEFAULT_REGISTRY_AUTH;
+const DEFAULT_REGISTRY = exports.DEFAULT_REGISTRY = 'registry-1.docker.io';
+// the url which docker stores in .docker/config.json for auth
+const DEFAULT_REGISTRY_AUTH = exports.DEFAULT_REGISTRY_AUTH = 'https://index.docker.io/v1/';
 
+// someregistry.com/some/image:latest -> someregistry.com/some/image
 function getImageFromImageWithTag(imageWithTag) {
   if (imageWithTag.lastIndexOf('/') !== -1) {
     const lastSlash = imageWithTag.lastIndexOf('/');
-
     if (imageWithTag.indexOf(':', lastSlash) !== -1) {
       return imageWithTag.substring(0, imageWithTag.indexOf(':', lastSlash));
     }
-
     return imageWithTag;
   }
-
   if (imageWithTag.indexOf(':') !== -1) {
     return imageWithTag.substring(0, imageWithTag.indexOf(':'));
   }
-
   return imageWithTag;
-} // someregistry.com/some/image:latest -> latest
-
+}
 
+// someregistry.com/some/image:latest -> latest
 function getTagFromImageWithTag(imageWithTag) {
   if (imageWithTag.lastIndexOf('/') !== -1) {
     const lastSlash = imageWithTag.lastIndexOf('/');
-
     if (imageWithTag.indexOf(':', lastSlash) !== -1) {
       return imageWithTag.substring(imageWithTag.indexOf(':', lastSlash) + 1);
     }
-
     return 'latest';
   }
-
   if (imageWithTag.indexOf(':') !== -1) {
     return imageWithTag.substring(imageWithTag.indexOf(':') + 1);
   }
-
   return 'latest';
 }
-
 function getRegistryFromImage(image) {
   const parsedRegistry = image.match(/([a-zA-Z0-9-.:]+)\/[a-zA-Z0-9-]+\/[a-zA-Z0-9-]+/);
   const registry = parsedRegistry != null && parsedRegistry.length > 1 ? parsedRegistry[1] : DEFAULT_REGISTRY;
   return registry;
-} // someregistry.com/some/image -> some/image
-
+}
 
+// someregistry.com/some/image -> some/image
 function getRepositoryFromImage(image) {
   if (image.lastIndexOf('/') === -1) {
     return 'library/' + image;
   }
-
   if (image.split('/').length === 3) {
     return image.substring(image.indexOf('/') + 1);
   }
-
   return image;
 }

package/lib/domain/oci-api-specification.js

@@ -4,12 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.restSpecification = exports.MEDIA_TYPES = void 0;
-const restSpecification = {
+const restSpecification = exports.restSpecification = {
   operation: (registry, endpoint) => `https://${registry}/v2/${endpoint}`,
   getManifest: (repository, tag) => `${repository}/manifests/${tag}`
 };
-exports.restSpecification = restSpecification;
-const MEDIA_TYPES = {
+const MEDIA_TYPES = exports.MEDIA_TYPES = {
   FAT_MANIFEST: 'application/vnd.docker.distribution.manifest.list.v2+json'
-};
-exports.MEDIA_TYPES = MEDIA_TYPES;
+};

package/lib/driver-logging.js

@@ -1,7 +1,6 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
@@ -9,25 +8,19 @@ exports.isDriverLogging = isDriverLogging;
 exports.log = log;
 exports.startDriverLogging = startDriverLogging;
 exports.stopDriverLogging = stopDriverLogging;
-
 var _cliSpinners = require("cli-spinners");
-
 var _chalk = _interopRequireDefault(require("chalk"));
-
 let _isDriverLogging = false;
 let _spinnerInterval = null;
 let _spinnerIndex = 0;
 let _message = null;
-
 function _redraw(opts = {}) {
   let symbol = _chalk.default.cyan(_cliSpinners.dots.frames[_spinnerIndex]);
-
   if (opts.success === true) {
     symbol = _chalk.default.green('✔');
   } else if (opts.success === false) {
     symbol = _chalk.default.red('•');
   }
-
   if (!process.stdout.isTTY) {
     if (opts.success) {
       console.log();
@@ -36,49 +29,37 @@ function _redraw(opts = {}) {
       console.log();
       console.log(symbol, 'FAILURE');
     }
-
     return;
   }
-
   process.stdout.write('                                                                        \n');
   process.stdout.write(` ${symbol} ${opts.success === false ? _chalk.default.red(_message, 'FAILED') : _message}\n`);
   process.stdout.cursorTo(0);
   process.stdout.moveCursor(0, -2);
 }
-
 function startDriverLogging(message) {
   _isDriverLogging = true;
   _message = message;
-
   _redraw();
-
   _spinnerInterval = setInterval(() => {
     _spinnerIndex++;
-
     if (_spinnerIndex >= _cliSpinners.dots.frames.length) {
       _spinnerIndex = 0;
     }
-
     _redraw();
   }, _cliSpinners.dots.interval);
 }
-
 function stopDriverLogging(opts = {}) {
   if (!isDriverLogging()) return;
   _isDriverLogging = false;
   clearInterval(_spinnerInterval);
-
   _redraw({
     success: opts.success != null ? opts.success : true
   });
-
   if (process.stdout.isTTY) console.log('\n\n');
 }
-
 function isDriverLogging() {
   return _isDriverLogging;
 }
-
 function log(message) {
   if (!isDriverLogging()) return;
   process.stdout.write(_chalk.default.dim(message));

package/lib/driver.js

@@ -1,19 +1,15 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.resolveDriverFromName = resolveDriverFromName;
-
 var _dockerCompose = _interopRequireDefault(require("./drivers/docker-compose"));
-
 function resolveDriverFromName(driverName) {
   switch (driverName) {
     case 'docker-compose':
       return _dockerCompose.default;
   }
-
   return null;
 }

package/lib/drivers/docker-compose/__tests__/client.js

@@ -0,0 +1,249 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _path = _interopRequireDefault(require("path"));
+var _events = require("events");
+var _fs = _interopRequireDefault(require("../../../util/fs"));
+var execAsyncModule = _interopRequireWildcard(require("../../../util/exec-async"));
+var driverLogging = _interopRequireWildcard(require("../../../driver-logging"));
+var _client = require("../client");
+function _interopRequireWildcard(e, t) { if ("function" == typeof WeakMap) var r = new WeakMap(), n = new WeakMap(); return (_interopRequireWildcard = function (e, t) { if (!t && e && e.__esModule) return e; var o, i, f = { __proto__: null, default: e }; if (null === e || "object" != typeof e && "function" != typeof e) return f; if (o = t ? n : r) { if (o.has(e)) return o.get(e); o.set(e, f); } for (const t in e) "default" !== t && {}.hasOwnProperty.call(e, t) && ((i = (o = Object.defineProperty) && Object.getOwnPropertyDescriptor(e, t)) && (i.get || i.set) ? o(f, t, i) : f[t] = e[t]); return f; })(e, t); }
+/* eslint-env mocha */
+
+function makeNavy({
+  name = 'env',
+  normalisedName = 'env',
+  configProvider = null
+} = {}) {
+  return {
+    name,
+    normalisedName,
+    getConfigProvider: _sinon.default.stub().resolves(configProvider)
+  };
+}
+describe('docker-compose client', function () {
+  let sandbox;
+  let originalHome;
+  let execStub;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    originalHome = process.env.HOME;
+    process.env.HOME = '/home/test';
+    execStub = sandbox.stub(execAsyncModule, 'execAsync').resolves('');
+    sandbox.stub(driverLogging, 'log');
+  });
+  afterEach(function () {
+    sandbox.restore();
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+  });
+  describe('createComposeClient', function () {
+    it('should expose exec, getCompiledDockerComposePath, getDockerComposeFilePath, getOriginalDockerComposeDirectory', function () {
+      const client = (0, _client.createComposeClient)(makeNavy());
+      (0, _chai.expect)(client).to.have.property('exec').that.is.a('function');
+      (0, _chai.expect)(client).to.have.property('getCompiledDockerComposePath').that.is.a('function');
+      (0, _chai.expect)(client).to.have.property('getDockerComposeFilePath').that.is.a('function');
+      (0, _chai.expect)(client).to.have.property('getOriginalDockerComposeDirectory').that.is.a('function');
+    });
+  });
+  describe('getCompiledDockerComposePath', function () {
+    it('should return $HOME/.navy/navies/<env>/docker-compose.tmp.yml', function () {
+      const client = (0, _client.createComposeClient)(makeNavy({
+        normalisedName: 'envname'
+      }));
+      (0, _chai.expect)(client.getCompiledDockerComposePath()).to.equal(_path.default.join('/home/test', '.navy', 'navies', 'envname', 'docker-compose.tmp.yml'));
+    });
+  });
+  describe('getDockerComposeFilePath', function () {
+    it('should return the compiled path when the file exists', async function () {
+      const client = (0, _client.createComposeClient)(makeNavy());
+      sandbox.stub(_fs.default, 'statAsync').resolves({});
+      const result = await client.getDockerComposeFilePath();
+      (0, _chai.expect)(result).to.contain('docker-compose.tmp.yml');
+    });
+    it('should return null when the compiled file does not exist', async function () {
+      const client = (0, _client.createComposeClient)(makeNavy());
+      sandbox.stub(_fs.default, 'statAsync').rejects(new Error('ENOENT'));
+      (0, _chai.expect)(await client.getDockerComposeFilePath()).to.equal(null);
+    });
+  });
+  describe('getOriginalDockerComposeDirectory', function () {
+    it('should return the navy path from the config provider', async function () {
+      const client = (0, _client.createComposeClient)(makeNavy({
+        configProvider: {
+          getNavyPath: async () => '/some/path'
+        }
+      }));
+      (0, _chai.expect)(await client.getOriginalDockerComposeDirectory()).to.equal('/some/path');
+    });
+    it('should throw an invariant violation when there is no config provider', async function () {
+      const client = (0, _client.createComposeClient)(makeNavy({
+        configProvider: null
+      }));
+      let caught;
+      try {
+        await client.getOriginalDockerComposeDirectory();
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.an('error');
+      (0, _chai.expect)(caught.message).to.match(/NO_CONFIG_PROVIDER/);
+    });
+  });
+  describe('exec', function () {
+    it('should call docker compose with -p <name> -f <compiled path> when compiled file exists', async function () {
+      const client = (0, _client.createComposeClient)(makeNavy({
+        normalisedName: 'env'
+      }));
+      sandbox.stub(_fs.default, 'statAsync').resolves({});
+      await client.exec('up', ['-d']);
+      (0, _chai.expect)(execStub.calledOnce).to.equal(true);
+      const [cmd, args,, opts] = execStub.firstCall.args;
+      (0, _chai.expect)(cmd).to.equal('docker compose');
+      (0, _chai.expect)(args[0]).to.equal('-p');
+      (0, _chai.expect)(args[1]).to.equal('env');
+      (0, _chai.expect)(args[2]).to.equal('-f');
+      (0, _chai.expect)(args[3]).to.contain('docker-compose.tmp.yml');
+      (0, _chai.expect)(args.slice(4)).to.eql(['up', '-d']);
+      (0, _chai.expect)(opts.maxBuffer).to.equal(Infinity);
+    });
+    it('should set cwd to the original docker-compose directory when the compiled file is missing', async function () {
+      const client = (0, _client.createComposeClient)(makeNavy({
+        configProvider: {
+          getNavyPath: async () => '/orig/path'
+        }
+      }));
+      sandbox.stub(_fs.default, 'statAsync').rejects(new Error('ENOENT'));
+      await client.exec('config');
+      const [, args,, opts] = execStub.firstCall.args;
+      (0, _chai.expect)(args).to.not.include('-f');
+      (0, _chai.expect)(opts.cwd).to.equal('/orig/path');
+    });
+    it('should pass useOriginalDockerComposeFiles to bypass the compiled file', async function () {
+      const client = (0, _client.createComposeClient)(makeNavy({
+        configProvider: {
+          getNavyPath: async () => '/orig/path'
+        }
+      }));
+      sandbox.stub(_fs.default, 'statAsync').resolves({});
+      await client.exec('config', [], {
+        useOriginalDockerComposeFiles: true
+      });
+      const [, args,, opts] = execStub.firstCall.args;
+      (0, _chai.expect)(args).to.not.include('-f');
+      (0, _chai.expect)(opts.cwd).to.equal('/orig/path');
+    });
+    it('should respect a custom maxBuffer', async function () {
+      const client = (0, _client.createComposeClient)(makeNavy());
+      sandbox.stub(_fs.default, 'statAsync').resolves({});
+      await client.exec('up', [], {
+        maxBuffer: 1024
+      });
+      const [,,, opts] = execStub.firstCall.args;
+      (0, _chai.expect)(opts.maxBuffer).to.equal(1024);
+    });
+    it('should default args to an empty array', async function () {
+      const client = (0, _client.createComposeClient)(makeNavy());
+      sandbox.stub(_fs.default, 'statAsync').resolves({});
+      await client.exec('config');
+      (0, _chai.expect)(execStub.calledOnce).to.equal(true);
+    });
+    it('should pipe child stdout/stderr through the spinner log when noLog and pipeLog are not set', async function () {
+      const client = (0, _client.createComposeClient)(makeNavy());
+      sandbox.stub(_fs.default, 'statAsync').resolves({});
+      const child = new _events.EventEmitter();
+      child.stdout = new _events.EventEmitter();
+      child.stderr = new _events.EventEmitter();
+      execStub.callsFake(async (cmd, args, callback) => {
+        callback(child);
+        child.stdout.emit('data', 'out-line');
+        child.stderr.emit('data', 'err-line');
+        return '';
+      });
+      await client.exec('up');
+      (0, _chai.expect)(driverLogging.log.callCount).to.equal(2);
+      (0, _chai.expect)(driverLogging.log.firstCall.args[0]).to.equal('out-line');
+      (0, _chai.expect)(driverLogging.log.secondCall.args[0]).to.equal('err-line');
+    });
+    it('should pipe child stdout/stderr to process.stdout/stderr when pipeLog is true', async function () {
+      const client = (0, _client.createComposeClient)(makeNavy());
+      sandbox.stub(_fs.default, 'statAsync').resolves({});
+      const child = new _events.EventEmitter();
+      child.stdout = new _events.EventEmitter();
+      child.stderr = new _events.EventEmitter();
+      const stdoutWrite = sandbox.stub(process.stdout, 'write').returns(true);
+      const stderrWrite = sandbox.stub(process.stderr, 'write').returns(true);
+      execStub.callsFake(async (cmd, args, callback) => {
+        callback(child);
+        child.stdout.emit('data', 'out');
+        child.stderr.emit('data', 'err');
+        return '';
+      });
+      await client.exec('logs', [], {
+        pipeLog: true
+      });
+      (0, _chai.expect)(stdoutWrite.calledWith('out')).to.equal(true);
+      (0, _chai.expect)(stderrWrite.calledWith('err')).to.equal(true);
+    });
+    it('should NOT attach stdout/stderr listeners when noLog is true', async function () {
+      const client = (0, _client.createComposeClient)(makeNavy());
+      sandbox.stub(_fs.default, 'statAsync').resolves({});
+      const child = new _events.EventEmitter();
+      child.stdout = new _events.EventEmitter();
+      child.stderr = new _events.EventEmitter();
+      execStub.callsFake(async (cmd, args, callback) => {
+        callback(child);
+        return '';
+      });
+      await client.exec('config', [], {
+        noLog: true
+      });
+      (0, _chai.expect)(child.stdout.listenerCount('data')).to.equal(0);
+      (0, _chai.expect)(child.stderr.listenerCount('data')).to.equal(0);
+    });
+    it('should map "Can\'t find a suitable configuration file" errors to NO_DOCKER_COMPOSE_FILE invariant', async function () {
+      const client = (0, _client.createComposeClient)(makeNavy());
+      sandbox.stub(_fs.default, 'statAsync').resolves({});
+      execStub.rejects(new Error("Can't find a suitable configuration file"));
+      let caught;
+      try {
+        await client.exec('config');
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.an('error');
+      (0, _chai.expect)(caught.message).to.match(/NO_DOCKER_COMPOSE_FILE/);
+    });
+    it('should rethrow other exec errors as-is', async function () {
+      const client = (0, _client.createComposeClient)(makeNavy());
+      sandbox.stub(_fs.default, 'statAsync').resolves({});
+      const err = new Error('some other failure');
+      execStub.rejects(err);
+      let caught;
+      try {
+        await client.exec('up');
+      } catch (e) {
+        caught = e;
+      }
+      (0, _chai.expect)(caught).to.equal(err);
+    });
+    it('should rethrow errors that have no message', async function () {
+      const client = (0, _client.createComposeClient)(makeNavy());
+      sandbox.stub(_fs.default, 'statAsync').resolves({});
+      const err = {};
+      execStub.rejects(err);
+      let caught;
+      try {
+        await client.exec('up');
+      } catch (e) {
+        caught = e;
+      }
+      (0, _chai.expect)(caught).to.equal(err);
+    });
+  });
+});