navy 6.0.0 → 7.0.0-alpha.2

package/lib/__tests__/config-provider.js

@@ -0,0 +1,75 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _filesystem = _interopRequireDefault(require("../config-providers/filesystem"));
+var _npm = _interopRequireDefault(require("../config-providers/npm"));
+var _configProvider = require("../config-provider");
+/* eslint-env mocha */
+
+describe('config-provider', function () {
+  let sandbox;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('resolveConfigProviderFromName', function () {
+    it('should return the FileSystem provider for "filesystem"', function () {
+      (0, _chai.expect)((0, _configProvider.resolveConfigProviderFromName)('filesystem')).to.equal(_filesystem.default);
+    });
+    it('should return the NPM provider for "npm"', function () {
+      (0, _chai.expect)((0, _configProvider.resolveConfigProviderFromName)('npm')).to.equal(_npm.default);
+    });
+    it('should return null for unknown provider names', function () {
+      (0, _chai.expect)((0, _configProvider.resolveConfigProviderFromName)('git')).to.equal(null);
+    });
+  });
+  describe('getImportCommandLineOptions', function () {
+    it('should return the concatenation of every provider\'s importCliOptions', function () {
+      const options = (0, _configProvider.getImportCommandLineOptions)();
+      (0, _chai.expect)(options).to.be.an('array');
+      (0, _chai.expect)(options).to.eql([..._npm.default.importCliOptions, ..._filesystem.default.importCliOptions]);
+    });
+  });
+  describe('getImportOptionsForCLI', function () {
+    it('should return options from the first provider that returns a non-null value', async function () {
+      const npmStub = sandbox.stub(_npm.default, 'getImportOptionsForCLI').resolves(null);
+      const fsResult = {
+        configProvider: 'filesystem'
+      };
+      const fsStub = sandbox.stub(_filesystem.default, 'getImportOptionsForCLI').resolves(fsResult);
+      const result = await (0, _configProvider.getImportOptionsForCLI)({
+        path: '/tmp'
+      });
+      (0, _chai.expect)(result).to.equal(fsResult);
+      (0, _chai.expect)(npmStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(fsStub.calledOnce).to.equal(true);
+    });
+    it('should not call subsequent providers once one returns options', async function () {
+      const npmResult = {
+        configProvider: 'npm'
+      };
+      const npmStub = sandbox.stub(_npm.default, 'getImportOptionsForCLI').resolves(npmResult);
+      const fsStub = sandbox.stub(_filesystem.default, 'getImportOptionsForCLI').resolves(null);
+      const result = await (0, _configProvider.getImportOptionsForCLI)({});
+      (0, _chai.expect)(result).to.equal(npmResult);
+      (0, _chai.expect)(npmStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(fsStub.called).to.equal(false);
+    });
+    it('should throw an invariant violation when no provider matches', async function () {
+      sandbox.stub(_npm.default, 'getImportOptionsForCLI').resolves(null);
+      sandbox.stub(_filesystem.default, 'getImportOptionsForCLI').resolves(null);
+      let caught;
+      try {
+        await (0, _configProvider.getImportOptionsForCLI)({});
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.an('error');
+      (0, _chai.expect)(caught.message).to.match(/CLI_IMPORT_RESOLVE_OPTIONS_ERR/);
+    });
+  });
+});

package/lib/__tests__/config.js

@@ -0,0 +1,130 @@
+"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 = _interopRequireWildcard(require("fs"));
+var _config = require("../config");
+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 */
+
+async function clearConfigCache(sandbox) {
+  const mkdirRestore = sandbox.stub(_fs.promises, 'mkdir').resolves();
+  const writeRestore = sandbox.stub(_fs.promises, 'writeFile').resolves();
+  await (0, _config.setConfig)(null);
+  mkdirRestore.restore();
+  writeRestore.restore();
+}
+describe('config', function () {
+  let sandbox;
+  let originalHome;
+  beforeEach(async function () {
+    sandbox = _sinon.default.createSandbox();
+    originalHome = process.env.HOME;
+    process.env.HOME = '/home/test-user';
+    await clearConfigCache(sandbox);
+  });
+  afterEach(function () {
+    sandbox.restore();
+    if (originalHome === undefined) {
+      delete process.env.HOME;
+    } else {
+      process.env.HOME = originalHome;
+    }
+  });
+  describe('getConfigDir', function () {
+    it('should join $HOME with .navy', function () {
+      (0, _chai.expect)((0, _config.getConfigDir)()).to.equal(_path.default.join('/home/test-user', '.navy'));
+    });
+    it('should throw when HOME is not set', function () {
+      delete process.env.HOME;
+      (0, _chai.expect)(() => (0, _config.getConfigDir)()).to.throw(/NO_HOME_DIRECTORY/);
+    });
+  });
+  describe('getConfigPath', function () {
+    it('should return <configDir>/config.json', function () {
+      (0, _chai.expect)((0, _config.getConfigPath)()).to.equal(_path.default.join('/home/test-user', '.navy', 'config.json'));
+    });
+  });
+  describe('DEFAULT_TLS_ROOT_CA_DIR', function () {
+    it('should be exported as a string referencing tls-root-ca', function () {
+      (0, _chai.expect)(_config.DEFAULT_TLS_ROOT_CA_DIR).to.be.a('string');
+      (0, _chai.expect)(_config.DEFAULT_TLS_ROOT_CA_DIR).to.contain('tls-root-ca');
+    });
+  });
+  describe('getConfig', function () {
+    it('should read the config file from disk and parse it as JSON', function () {
+      const onDisk = {
+        defaultNavy: 'mine',
+        externalIP: '10.0.0.1',
+        tlsRootCaDir: '/tmp/ca'
+      };
+      sandbox.stub(_fs.default, 'readFileSync').returns(JSON.stringify(onDisk));
+      (0, _chai.expect)((0, _config.getConfig)()).to.eql(onDisk);
+    });
+    it('should return the cached config on subsequent calls', function () {
+      const onDisk = {
+        defaultNavy: 'mine'
+      };
+      const readStub = sandbox.stub(_fs.default, 'readFileSync').returns(JSON.stringify(onDisk));
+      (0, _config.getConfig)();
+      (0, _config.getConfig)();
+      (0, _config.getConfig)();
+      (0, _chai.expect)(readStub.callCount).to.equal(1);
+    });
+    it('should fall back to default config when reading the file fails', function () {
+      sandbox.stub(_fs.default, 'readFileSync').throws(new Error('ENOENT'));
+      const cfg = (0, _config.getConfig)();
+      (0, _chai.expect)(cfg).to.have.property('defaultNavy', 'dev');
+      (0, _chai.expect)(cfg).to.have.property('externalIP', null);
+      (0, _chai.expect)(cfg).to.have.property('tlsRootCaDir').that.is.a('string');
+    });
+  });
+  describe('setConfig', function () {
+    it('should write the provided config to the config file', async function () {
+      const mkdirStub = sandbox.stub(_fs.promises, 'mkdir').resolves();
+      const writeStub = sandbox.stub(_fs.promises, 'writeFile').resolves();
+      await (0, _config.setConfig)({
+        defaultNavy: 'env-1'
+      });
+      (0, _chai.expect)(mkdirStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(mkdirStub.firstCall.args[0]).to.equal(_path.default.join('/home/test-user', '.navy'));
+      (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-user', '.navy', 'config.json'));
+      (0, _chai.expect)(JSON.parse(writeStub.firstCall.args[1])).to.eql({
+        defaultNavy: 'env-1'
+      });
+    });
+    it('should write the default config when called with null', async function () {
+      sandbox.stub(_fs.promises, 'mkdir').resolves();
+      const writeStub = sandbox.stub(_fs.promises, 'writeFile').resolves();
+      await (0, _config.setConfig)(null);
+      const written = JSON.parse(writeStub.firstCall.args[1]);
+      (0, _chai.expect)(written).to.have.property('defaultNavy', 'dev');
+    });
+    it('should invalidate the cached config so the next getConfig re-reads', async function () {
+      const readStub = sandbox.stub(_fs.default, 'readFileSync').returns(JSON.stringify({
+        defaultNavy: 'one'
+      }));
+      (0, _config.getConfig)();
+      (0, _chai.expect)(readStub.callCount).to.equal(1);
+      sandbox.stub(_fs.promises, 'mkdir').resolves();
+      sandbox.stub(_fs.promises, 'writeFile').resolves();
+      await (0, _config.setConfig)({
+        defaultNavy: 'two'
+      });
+      readStub.returns(JSON.stringify({
+        defaultNavy: 'two'
+      }));
+      const cfg = (0, _config.getConfig)();
+      (0, _chai.expect)(readStub.callCount).to.equal(2);
+      (0, _chai.expect)(cfg).to.eql({
+        defaultNavy: 'two'
+      });
+    });
+  });
+});

package/lib/__tests__/driver-logging.js

@@ -0,0 +1,148 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _cliSpinners = require("cli-spinners");
+var _driverLogging = require("../driver-logging");
+/* eslint-env mocha */
+
+describe('driver-logging', function () {
+  let sandbox;
+  let clock;
+  let stdoutWrite;
+  let cursorTo;
+  let moveCursor;
+  let consoleLog;
+  let originalIsTTY;
+  let originalCursorTo;
+  let originalMoveCursor;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    clock = sandbox.useFakeTimers();
+    stdoutWrite = sandbox.stub(process.stdout, 'write').returns(true);
+    originalCursorTo = process.stdout.cursorTo;
+    originalMoveCursor = process.stdout.moveCursor;
+    process.stdout.cursorTo = function () {};
+    process.stdout.moveCursor = function () {};
+    cursorTo = sandbox.stub(process.stdout, 'cursorTo');
+    moveCursor = sandbox.stub(process.stdout, 'moveCursor');
+    consoleLog = sandbox.stub(console, 'log');
+    originalIsTTY = process.stdout.isTTY;
+    process.stdout.isTTY = true;
+  });
+  afterEach(function () {
+    if ((0, _driverLogging.isDriverLogging)()) {
+      (0, _driverLogging.stopDriverLogging)({
+        success: true
+      });
+    }
+    process.stdout.isTTY = originalIsTTY;
+    sandbox.restore();
+    if (originalCursorTo === undefined) {
+      delete process.stdout.cursorTo;
+    } else {
+      process.stdout.cursorTo = originalCursorTo;
+    }
+    if (originalMoveCursor === undefined) {
+      delete process.stdout.moveCursor;
+    } else {
+      process.stdout.moveCursor = originalMoveCursor;
+    }
+  });
+  describe('startDriverLogging / isDriverLogging', function () {
+    it('should mark logging as active and write the initial spinner frame', function () {
+      (0, _chai.expect)((0, _driverLogging.isDriverLogging)()).to.equal(false);
+      (0, _driverLogging.startDriverLogging)('Doing thing');
+      (0, _chai.expect)((0, _driverLogging.isDriverLogging)()).to.equal(true);
+      (0, _chai.expect)(stdoutWrite.called).to.equal(true);
+      const written = stdoutWrite.getCalls().map(c => c.args[0]).join('');
+      (0, _chai.expect)(written).to.contain('Doing thing');
+    });
+    it('should advance the spinner frame on each interval tick', function () {
+      (0, _driverLogging.startDriverLogging)('Working');
+      const writesBefore = stdoutWrite.callCount;
+      clock.tick(_cliSpinners.dots.interval);
+      (0, _chai.expect)(stdoutWrite.callCount).to.be.greaterThan(writesBefore);
+    });
+    it('should wrap the spinner frame index back to 0 after exhausting all frames', function () {
+      (0, _driverLogging.startDriverLogging)('Wrap test');
+      clock.tick(_cliSpinners.dots.interval * (_cliSpinners.dots.frames.length + 1));
+      (0, _chai.expect)((0, _driverLogging.isDriverLogging)()).to.equal(true);
+    });
+  });
+  describe('stopDriverLogging', function () {
+    it('should clear the logging state and emit a final success line', function () {
+      (0, _driverLogging.startDriverLogging)('Working');
+      (0, _driverLogging.stopDriverLogging)({
+        success: true
+      });
+      (0, _chai.expect)((0, _driverLogging.isDriverLogging)()).to.equal(false);
+    });
+    it('should default success to true when not provided', function () {
+      (0, _driverLogging.startDriverLogging)('Working');
+      (0, _driverLogging.stopDriverLogging)();
+      (0, _chai.expect)((0, _driverLogging.isDriverLogging)()).to.equal(false);
+    });
+    it('should mark a failure when success is false', function () {
+      (0, _driverLogging.startDriverLogging)('Working');
+      (0, _driverLogging.stopDriverLogging)({
+        success: false
+      });
+      (0, _chai.expect)((0, _driverLogging.isDriverLogging)()).to.equal(false);
+    });
+    it('should be a no-op if logging was never started', function () {
+      (0, _chai.expect)((0, _driverLogging.isDriverLogging)()).to.equal(false);
+      (0, _driverLogging.stopDriverLogging)({
+        success: true
+      });
+      (0, _chai.expect)(stdoutWrite.called).to.equal(false);
+      (0, _chai.expect)(cursorTo.called).to.equal(false);
+      (0, _chai.expect)(moveCursor.called).to.equal(false);
+    });
+  });
+  describe('non-TTY behaviour', function () {
+    beforeEach(function () {
+      process.stdout.isTTY = false;
+    });
+    it('should print a SUCCESS line via console.log when stopping with success', function () {
+      (0, _driverLogging.startDriverLogging)('Working');
+      (0, _driverLogging.stopDriverLogging)({
+        success: true
+      });
+      const messages = consoleLog.getCalls().map(c => c.args.join(' '));
+      const success = messages.find(m => m.includes('SUCCESS'));
+      (0, _chai.expect)(success).to.be.a('string');
+    });
+    it('should print a FAILURE line via console.log when stopping with success=false', function () {
+      (0, _driverLogging.startDriverLogging)('Working');
+      (0, _driverLogging.stopDriverLogging)({
+        success: false
+      });
+      const messages = consoleLog.getCalls().map(c => c.args.join(' '));
+      const failure = messages.find(m => m.includes('FAILURE'));
+      (0, _chai.expect)(failure).to.be.a('string');
+    });
+    it('should not print anything during ongoing spinner ticks while non-TTY', function () {
+      (0, _driverLogging.startDriverLogging)('Working');
+      const callsAtStart = consoleLog.callCount;
+      clock.tick(_cliSpinners.dots.interval * 3);
+      (0, _chai.expect)(consoleLog.callCount).to.equal(callsAtStart);
+    });
+  });
+  describe('log', function () {
+    it('should write the dimmed message to stdout while logging is active', function () {
+      (0, _driverLogging.startDriverLogging)('Active');
+      stdoutWrite.resetHistory();
+      (0, _driverLogging.log)('hello');
+      (0, _chai.expect)(stdoutWrite.calledOnce).to.equal(true);
+      (0, _chai.expect)(stdoutWrite.firstCall.args[0]).to.contain('hello');
+    });
+    it('should be a no-op when logging is not active', function () {
+      (0, _chai.expect)((0, _driverLogging.isDriverLogging)()).to.equal(false);
+      stdoutWrite.resetHistory();
+      (0, _driverLogging.log)('ignored');
+      (0, _chai.expect)(stdoutWrite.called).to.equal(false);
+    });
+  });
+});

package/lib/__tests__/driver.js

@@ -0,0 +1,19 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _driver = require("../driver");
+var _dockerCompose = _interopRequireDefault(require("../drivers/docker-compose"));
+/* eslint-env mocha */
+
+describe('driver', function () {
+  describe('resolveDriverFromName', function () {
+    it('should return the docker-compose driver factory when given "docker-compose"', function () {
+      (0, _chai.expect)((0, _driver.resolveDriverFromName)('docker-compose')).to.equal(_dockerCompose.default);
+    });
+    it('should return null for an unknown driver name', function () {
+      (0, _chai.expect)((0, _driver.resolveDriverFromName)('podman')).to.equal(null);
+      (0, _chai.expect)((0, _driver.resolveDriverFromName)('')).to.equal(null);
+    });
+  });
+});

package/lib/__tests__/errors.js

@@ -0,0 +1,49 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _errors = require("../errors");
+/* eslint-env mocha */
+
+describe('errors', function () {
+  describe('NavyError', function () {
+    it('should expose the message passed to the constructor', function () {
+      const err = new _errors.NavyError('something went wrong');
+      (0, _chai.expect)(err.message).to.equal('something went wrong');
+    });
+    it('should print a red ERROR banner followed by the message and blank lines via prettyPrint', function () {
+      const log = _sinon.default.stub(console, 'log');
+      try {
+        new _errors.NavyError('boom').prettyPrint();
+      } finally {
+        log.restore();
+      }
+      (0, _chai.expect)(log.callCount).to.equal(5);
+      (0, _chai.expect)(log.firstCall.args).to.eql([]);
+      (0, _chai.expect)(log.secondCall.args[0]).to.contain('ERROR');
+      (0, _chai.expect)(log.thirdCall.args).to.eql([]);
+      (0, _chai.expect)(log.getCall(3).args[0]).to.equal(' boom');
+      (0, _chai.expect)(log.getCall(4).args).to.eql([]);
+    });
+  });
+  describe('NavyNotInitialisedError', function () {
+    it('should be a NavyError that includes the navy name in the message', function () {
+      const err = new _errors.NavyNotInitialisedError('myenv');
+      (0, _chai.expect)(err).to.be.instanceof(_errors.NavyError);
+      (0, _chai.expect)(err.message).to.equal('Navy "myenv" not imported');
+    });
+    it('should call the parent prettyPrint and add a hint about navy import', function () {
+      const log = _sinon.default.stub(console, 'log');
+      try {
+        new _errors.NavyNotInitialisedError('foo').prettyPrint();
+      } finally {
+        log.restore();
+      }
+      const messages = log.getCalls().map(call => call.args[0] || '');
+      const hint = messages.find(m => typeof m === 'string' && m.includes('navy import'));
+      (0, _chai.expect)(hint).to.be.a('string');
+      (0, _chai.expect)(hint).to.contain('imported the navy');
+    });
+  });
+});

package/lib/__tests__/http-proxy.js

@@ -0,0 +1,214 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _os = _interopRequireDefault(require("os"));
+var _path = _interopRequireDefault(require("path"));
+var _jsYaml = _interopRequireDefault(require("js-yaml"));
+var _fs = _interopRequireDefault(require("fs"));
+var _dockerClient = _interopRequireDefault(require("../util/docker-client"));
+var httpsModule = _interopRequireWildcard(require("../util/https"));
+var execAsyncModule = _interopRequireWildcard(require("../util/exec-async"));
+var driverLogging = _interopRequireWildcard(require("../driver-logging"));
+var navyModule = _interopRequireWildcard(require("../navy"));
+var _httpProxy = require("../http-proxy");
+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 */
+
+describe('resolveProxyImage', function () {
+  afterEach(function () {
+    delete process.env.NAVY_HTTP_PROXY_IMAGE;
+  });
+  it('should return the default image when no env var or navyFile config is provided', function () {
+    (0, _chai.expect)((0, _httpProxy.resolveProxyImage)()).to.equal('navycloud/navy-proxy');
+    (0, _chai.expect)((0, _httpProxy.resolveProxyImage)(null)).to.equal('navycloud/navy-proxy');
+    (0, _chai.expect)((0, _httpProxy.resolveProxyImage)(undefined)).to.equal('navycloud/navy-proxy');
+  });
+  it('should return the default image when navyFile has no httpProxyImage', function () {
+    (0, _chai.expect)((0, _httpProxy.resolveProxyImage)({})).to.equal('navycloud/navy-proxy');
+    (0, _chai.expect)((0, _httpProxy.resolveProxyImage)({
+      plugins: []
+    })).to.equal('navycloud/navy-proxy');
+  });
+  it('should use httpProxyImage from navyFile when set', function () {
+    const navyFile = {
+      httpProxyImage: 'myregistry/custom-proxy:latest'
+    };
+    (0, _chai.expect)((0, _httpProxy.resolveProxyImage)(navyFile)).to.equal('myregistry/custom-proxy:latest');
+  });
+  it('should use NAVY_HTTP_PROXY_IMAGE env var when set', function () {
+    process.env.NAVY_HTTP_PROXY_IMAGE = 'envregistry/env-proxy:v2';
+    (0, _chai.expect)((0, _httpProxy.resolveProxyImage)()).to.equal('envregistry/env-proxy:v2');
+  });
+  it('should give NAVY_HTTP_PROXY_IMAGE env var precedence over navyFile httpProxyImage', function () {
+    process.env.NAVY_HTTP_PROXY_IMAGE = 'envregistry/env-proxy:v2';
+    const navyFile = {
+      httpProxyImage: 'myregistry/custom-proxy:latest'
+    };
+    (0, _chai.expect)((0, _httpProxy.resolveProxyImage)(navyFile)).to.equal('envregistry/env-proxy:v2');
+  });
+  it('should give NAVY_HTTP_PROXY_IMAGE env var precedence over default', function () {
+    process.env.NAVY_HTTP_PROXY_IMAGE = 'override/image:tag';
+    (0, _chai.expect)((0, _httpProxy.resolveProxyImage)(null)).to.equal('override/image:tag');
+  });
+  it('should fall back to default when httpProxyImage is an empty string', function () {
+    (0, _chai.expect)((0, _httpProxy.resolveProxyImage)({
+      httpProxyImage: ''
+    })).to.equal('navycloud/navy-proxy');
+  });
+  it('should fall back to default when NAVY_HTTP_PROXY_IMAGE is an empty string', function () {
+    process.env.NAVY_HTTP_PROXY_IMAGE = '';
+    (0, _chai.expect)((0, _httpProxy.resolveProxyImage)()).to.equal('navycloud/navy-proxy');
+  });
+});
+describe('resolveDockerSocketPath', function () {
+  let originalDockerHost;
+  beforeEach(function () {
+    originalDockerHost = process.env.DOCKER_HOST;
+    delete process.env.DOCKER_HOST;
+  });
+  afterEach(function () {
+    if (originalDockerHost === undefined) {
+      delete process.env.DOCKER_HOST;
+    } else {
+      process.env.DOCKER_HOST = originalDockerHost;
+    }
+  });
+  it('should default to /var/run/docker.sock when DOCKER_HOST is not set', function () {
+    (0, _chai.expect)((0, _httpProxy.resolveDockerSocketPath)()).to.equal('/var/run/docker.sock');
+  });
+  it('should default to /var/run/docker.sock when DOCKER_HOST is empty', function () {
+    process.env.DOCKER_HOST = '';
+    (0, _chai.expect)((0, _httpProxy.resolveDockerSocketPath)()).to.equal('/var/run/docker.sock');
+  });
+  it('should extract the socket path when DOCKER_HOST uses the unix:// scheme', function () {
+    process.env.DOCKER_HOST = 'unix:///home/runner/setup-docker-action-abc/docker.sock';
+    (0, _chai.expect)((0, _httpProxy.resolveDockerSocketPath)()).to.equal('/home/runner/setup-docker-action-abc/docker.sock');
+  });
+  it('should fall back to default when DOCKER_HOST is unix:// with no path', function () {
+    process.env.DOCKER_HOST = 'unix://';
+    (0, _chai.expect)((0, _httpProxy.resolveDockerSocketPath)()).to.equal('/var/run/docker.sock');
+  });
+  it('should fall back to default when DOCKER_HOST uses tcp:// scheme', function () {
+    process.env.DOCKER_HOST = 'tcp://localhost:2375';
+    (0, _chai.expect)((0, _httpProxy.resolveDockerSocketPath)()).to.equal('/var/run/docker.sock');
+  });
+});
+describe('reconfigureHTTPProxy', function () {
+  let sandbox;
+  let writeFileSyncStub;
+  let existsSyncStub;
+  let listNetworksStub;
+  let execStub;
+  let originalDockerHost;
+  const composeFile = _path.default.join(_os.default.tmpdir(), 'navyinternaldockercompose.yml');
+  beforeEach(function () {
+    originalDockerHost = process.env.DOCKER_HOST;
+    delete process.env.DOCKER_HOST;
+    sandbox = _sinon.default.createSandbox();
+    listNetworksStub = sandbox.stub(_dockerClient.default, 'listNetworks');
+    sandbox.stub(httpsModule, 'getCertsPath').resolves('');
+    sandbox.stub(driverLogging, 'log');
+    sandbox.stub(navyModule, 'getLaunchedNavyNames').resolves([]);
+    execStub = sandbox.stub(execAsyncModule, 'execAsync').resolves('');
+    writeFileSyncStub = sandbox.stub(_fs.default, 'writeFileSync');
+    existsSyncStub = sandbox.stub(_fs.default, 'existsSync').returns(false);
+  });
+  afterEach(function () {
+    sandbox.restore();
+    if (originalDockerHost === undefined) {
+      delete process.env.DOCKER_HOST;
+    } else {
+      process.env.DOCKER_HOST = originalDockerHost;
+    }
+  });
+  it('should default opts.navies via getLaunchedNavyNames when not supplied', async function () {
+    listNetworksStub.resolves([]);
+    navyModule.getLaunchedNavyNames.resolves(['navyA']);
+    await (0, _httpProxy.reconfigureHTTPProxy)();
+    (0, _chai.expect)(navyModule.getLaunchedNavyNames.calledOnce).to.equal(true);
+  });
+  it('should write a docker-compose config containing only matching docker-compose networks', async function () {
+    listNetworksStub.resolves([{
+      Name: 'navyA_default'
+    }, {
+      Name: 'navyB_default'
+    }, {
+      Name: 'host'
+    }, {
+      Name: 'navyB_other'
+    }, {
+      Name: 'name-without-underscore'
+    }]);
+    await (0, _httpProxy.reconfigureHTTPProxy)({
+      navies: ['navyA']
+    });
+    (0, _chai.expect)(writeFileSyncStub.calledOnce).to.equal(true);
+    (0, _chai.expect)(writeFileSyncStub.firstCall.args[0]).to.equal(composeFile);
+    const written = _jsYaml.default.load(writeFileSyncStub.firstCall.args[1]);
+    (0, _chai.expect)(written.networks).to.have.property('navyA_default').that.eql({
+      external: true
+    });
+    (0, _chai.expect)(written.networks).to.not.have.property('navyB_default');
+    (0, _chai.expect)(written.networks).to.not.have.property('host');
+    (0, _chai.expect)(written.services['nginx-proxy'].image).to.equal('navycloud/navy-proxy');
+    (0, _chai.expect)(written.services['nginx-proxy'].ports).to.eql(['80:80']);
+    (0, _chai.expect)(written.services['nginx-proxy'].volumes[0]).to.equal('/var/run/docker.sock:/tmp/docker.sock:ro');
+  });
+  it('should mount certs and expose port 443 when a certs path is available', async function () {
+    httpsModule.getCertsPath.resolves('/certs');
+    listNetworksStub.resolves([]);
+    await (0, _httpProxy.reconfigureHTTPProxy)({
+      navies: []
+    });
+    const written = _jsYaml.default.load(writeFileSyncStub.firstCall.args[1]);
+    (0, _chai.expect)(written.services['nginx-proxy'].ports).to.eql(['80:80', '443:443']);
+    (0, _chai.expect)(written.services['nginx-proxy'].volumes).to.include('/certs:/etc/nginx/certs');
+    (0, _chai.expect)(written.services['nginx-proxy'].volumes).to.include('/certs:/etc/nginx/dhparam');
+  });
+  it('should pass the configured proxy image from navyFile through to the compose config', async function () {
+    listNetworksStub.resolves([]);
+    await (0, _httpProxy.reconfigureHTTPProxy)({
+      navies: [],
+      navyFile: {
+        httpProxyImage: 'custom/proxy:1'
+      }
+    });
+    const written = _jsYaml.default.load(writeFileSyncStub.firstCall.args[1]);
+    (0, _chai.expect)(written.services['nginx-proxy'].image).to.equal('custom/proxy:1');
+  });
+  it('should run docker compose up after writing the config', async function () {
+    listNetworksStub.resolves([]);
+    await (0, _httpProxy.reconfigureHTTPProxy)({
+      navies: []
+    });
+    const upCall = execStub.getCalls().find(c => Array.isArray(c.args[1]) && c.args[1].includes('up'));
+    // eslint-disable-next-line no-unused-expressions
+    (0, _chai.expect)(upCall).to.exist;
+    (0, _chai.expect)(upCall.args[0]).to.equal('docker compose');
+    (0, _chai.expect)(upCall.args[1]).to.eql(['-f', composeFile, '-p', 'navyinternal', 'up', '-d']);
+  });
+  it('should rm the existing nginx-proxy container before reconfiguring when restart=true and the file exists', async function () {
+    listNetworksStub.resolves([]);
+    existsSyncStub.withArgs(composeFile).returns(true);
+    await (0, _httpProxy.reconfigureHTTPProxy)({
+      navies: [],
+      restart: true
+    });
+    const rmCall = execStub.getCalls().find(c => Array.isArray(c.args[1]) && c.args[1].includes('rm'));
+    // eslint-disable-next-line no-unused-expressions
+    (0, _chai.expect)(rmCall).to.exist;
+    (0, _chai.expect)(rmCall.args[1]).to.eql(['-f', composeFile, '-p', 'navyinternal', 'rm', '-s', '-f', 'nginx-proxy']);
+  });
+  it('should skip the rm step when restart=true but no compose file exists yet', async function () {
+    listNetworksStub.resolves([]);
+    existsSyncStub.withArgs(composeFile).returns(false);
+    await (0, _httpProxy.reconfigureHTTPProxy)({
+      navies: [],
+      restart: true
+    });
+    const rmCall = execStub.getCalls().find(c => Array.isArray(c.args[1]) && c.args[1].includes('rm'));
+    (0, _chai.expect)(rmCall).to.equal(undefined);
+  });
+});

package/lib/__tests__/index.js

@@ -0,0 +1,25 @@
+"use strict";
+
+var _chai = require("chai");
+var navyModule = _interopRequireWildcard(require("../index"));
+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 */
+
+describe('navy package entry point', function () {
+  it('should re-export the Navy class and navy lookup helpers', function () {
+    (0, _chai.expect)(navyModule).to.have.property('Navy').that.is.a('function');
+    (0, _chai.expect)(navyModule).to.have.property('getNavy').that.is.a('function');
+    (0, _chai.expect)(navyModule).to.have.property('getLaunchedNavies').that.is.a('function');
+    (0, _chai.expect)(navyModule).to.have.property('getLaunchedNavyNames').that.is.a('function');
+  });
+  it('should expose the Service module under Service', function () {
+    (0, _chai.expect)(navyModule).to.have.property('Service').that.is.an('object');
+    (0, _chai.expect)(navyModule.Service).to.have.property('Status').that.is.an('object');
+  });
+  it('should re-export NavyError', function () {
+    (0, _chai.expect)(navyModule).to.have.property('NavyError').that.is.a('function');
+  });
+  it('should re-export middlewareHelpers', function () {
+    (0, _chai.expect)(navyModule).to.have.property('middlewareHelpers').that.is.an('object');
+  });
+});