navy 6.0.0 → 7.0.0-alpha.2

package/lib/cli/__tests__/ps.js

@@ -0,0 +1,345 @@
+"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 */
+
+describe('cli/ps', function () {
+  let sandbox;
+  let getNavyStub;
+  let getUrlFromServiceStub;
+  let navyStub;
+  let consoleLogStub;
+  let originalIsTTY;
+  let originalGetWindowSize;
+  let psCli;
+  function makeService(overrides = {}) {
+    return {
+      id: 'abcdefghijklmnop',
+      name: 'api',
+      image: 'navy/api:latest',
+      status: 'running',
+      raw: undefined,
+      ...overrides
+    };
+  }
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    navyStub = {
+      ps: sandbox.stub().resolves([]),
+      getState: sandbox.stub().resolves(null)
+    };
+    getNavyStub = sandbox.stub().returns(navyStub);
+    getUrlFromServiceStub = sandbox.stub().returns(null);
+    consoleLogStub = sandbox.stub(console, 'log');
+    originalIsTTY = process.stdout.isTTY;
+    originalGetWindowSize = process.stdout.getWindowSize;
+    process.stdout.isTTY = false;
+    process.stdout.getWindowSize = () => [200, 50];
+    psCli = _proxyquire.default.noCallThru()('../ps', {
+      '../': {
+        getNavy: getNavyStub
+      },
+      '../util/service-host': {
+        getUrlFromService: getUrlFromServiceStub
+      }
+    });
+  });
+  afterEach(function () {
+    sandbox.restore();
+    process.stdout.isTTY = originalIsTTY;
+    if (originalGetWindowSize === undefined) {
+      delete process.stdout.getWindowSize;
+    } else {
+      process.stdout.getWindowSize = originalGetWindowSize;
+    }
+  });
+  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 psCli({
+        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 JSON when opts.json is true', async function () {
+      const services = [makeService({
+        id: 'svc-id',
+        name: 'api'
+      })];
+      navyStub.ps.resolves(services);
+      await psCli({
+        navy: 'env-1',
+        json: true
+      });
+      (0, _chai.expect)(consoleLogStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(consoleLogStub.firstCall.args[0]).to.equal(JSON.stringify(services, null, 2));
+    });
+    it('should render the wide 6-column table by default in non-TTY', async function () {
+      navyStub.ps.resolves([makeService()]);
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('IMAGE');
+      (0, _chai.expect)(text).to.contain('navy/api:latest');
+    });
+    it('should render the small 5-column table when TTY width is below threshold', async function () {
+      process.stdout.isTTY = true;
+      process.stdout.getWindowSize = () => [80, 50];
+      navyStub.ps.resolves([makeService()]);
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('NAME');
+      (0, _chai.expect)(text).to.contain('STATUS');
+      (0, _chai.expect)(text).to.not.contain('IMAGE');
+    });
+    it('should render the wide 6-column table when TTY width is at or above threshold', async function () {
+      process.stdout.isTTY = true;
+      process.stdout.getWindowSize = () => [200, 50];
+      navyStub.ps.resolves([makeService()]);
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('IMAGE');
+    });
+    it('should truncate the service id to 12 characters', async function () {
+      navyStub.ps.resolves([makeService({
+        id: '0123456789abcdef9999'
+      })]);
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('0123456789ab');
+      (0, _chai.expect)(text).not.to.contain('0123456789abcdef');
+    });
+  });
+  describe('getStatus (via default export)', function () {
+    it('should print the status as-is when not exited and no state present', async function () {
+      navyStub.ps.resolves([makeService({
+        status: 'running'
+      })]);
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('running');
+      (0, _chai.expect)(text).not.to.contain('(development)');
+      (0, _chai.expect)(text).not.to.contain('@');
+    });
+    it('should render the exited status (taking the chalk.red branch)', async function () {
+      navyStub.ps.resolves([makeService({
+        status: 'exited'
+      })]);
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('exited');
+    });
+    it('should append (development) when the service has _develop set in state', async function () {
+      navyStub.ps.resolves([makeService({
+        name: 'api'
+      })]);
+      navyStub.getState.resolves({
+        services: {
+          api: {
+            _develop: true
+          }
+        }
+      });
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('(development)');
+    });
+    it('should append the @ tag when the service has _tag set in state', async function () {
+      navyStub.ps.resolves([makeService({
+        name: 'api'
+      })]);
+      navyStub.getState.resolves({
+        services: {
+          api: {
+            _tag: 'v1.2.3'
+          }
+        }
+      });
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('@ v1.2.3');
+    });
+    it('should append both (development) and the @ tag when both are set', async function () {
+      navyStub.ps.resolves([makeService({
+        name: 'api'
+      })]);
+      navyStub.getState.resolves({
+        services: {
+          api: {
+            _develop: true,
+            _tag: 'v9'
+          }
+        }
+      });
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('(development)');
+      (0, _chai.expect)(text).to.contain('@ v9');
+    });
+    it('should not annotate the status when state has no entry for the service name', async function () {
+      navyStub.ps.resolves([makeService({
+        name: 'api'
+      })]);
+      navyStub.getState.resolves({
+        services: {
+          web: {
+            _develop: true
+          }
+        }
+      });
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).not.to.contain('(development)');
+    });
+    it('should handle a state object with no services map', async function () {
+      navyStub.ps.resolves([makeService({
+        name: 'api'
+      })]);
+      navyStub.getState.resolves({});
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('running');
+      (0, _chai.expect)(text).not.to.contain('(development)');
+    });
+  });
+  describe('getPorts (via default export)', function () {
+    it('should render - when raw is missing', async function () {
+      navyStub.ps.resolves([makeService({
+        raw: undefined
+      })]);
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.match(/-/);
+    });
+    it('should render - when raw.NetworkSettings is missing', async function () {
+      navyStub.ps.resolves([makeService({
+        raw: {}
+      })]);
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.match(/-/);
+    });
+    it('should render - when raw.NetworkSettings.Ports is missing', async function () {
+      navyStub.ps.resolves([makeService({
+        raw: {
+          NetworkSettings: {}
+        }
+      })]);
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.match(/-/);
+    });
+    it('should render only the port key when there are no host bindings', async function () {
+      navyStub.ps.resolves([makeService({
+        raw: {
+          NetworkSettings: {
+            Ports: {
+              '8080/tcp': null
+            }
+          }
+        }
+      })]);
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('8080/tcp');
+      (0, _chai.expect)(text).not.to.contain('->');
+    });
+    it('should render HostPort->portKey when bindings exist', async function () {
+      navyStub.ps.resolves([makeService({
+        raw: {
+          NetworkSettings: {
+            Ports: {
+              '8080/tcp': [{
+                HostPort: '32001'
+              }, {
+                HostPort: '32002'
+              }]
+            }
+          }
+        }
+      })]);
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('32001, 32002->8080/tcp');
+    });
+    it('should join multiple port keys with commas', async function () {
+      navyStub.ps.resolves([makeService({
+        raw: {
+          NetworkSettings: {
+            Ports: {
+              '8080/tcp': [{
+                HostPort: '32001'
+              }],
+              '9090/tcp': null
+            }
+          }
+        }
+      })]);
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('32001->8080/tcp');
+      (0, _chai.expect)(text).to.contain('9090/tcp');
+    });
+  });
+  describe('getDisplayUrl (via default export)', function () {
+    it('should render - when getUrlFromService returns null', async function () {
+      getUrlFromServiceStub.returns(null);
+      navyStub.ps.resolves([makeService()]);
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.match(/\s-\s|\s-$/);
+    });
+    it('should render the URL string when getUrlFromService returns a string', async function () {
+      getUrlFromServiceStub.returns('https://api.example.local');
+      navyStub.ps.resolves([makeService()]);
+      await psCli({
+        navy: 'env-1'
+      });
+      const text = (0, _stripAnsi.default)(lastLoggedString());
+      (0, _chai.expect)(text).to.contain('https://api.example.local');
+    });
+  });
+});

package/lib/cli/__tests__/refresh-config.js

@@ -0,0 +1,95 @@
+"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/refresh-config', function () {
+  let sandbox;
+  let getNavyStub;
+  let navyStub;
+  let configProvider;
+  let startDriverLoggingStub;
+  let stopDriverLoggingStub;
+  let consoleLogStub;
+  let refreshConfigCli;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    configProvider = {
+      refreshConfig: sandbox.stub().resolves()
+    };
+    navyStub = {
+      name: 'env-1',
+      getConfigProvider: sandbox.stub().resolves(configProvider),
+      reconfigure: sandbox.stub().resolves()
+    };
+    getNavyStub = sandbox.stub().returns(navyStub);
+    startDriverLoggingStub = sandbox.stub();
+    stopDriverLoggingStub = sandbox.stub();
+    consoleLogStub = sandbox.stub(console, 'log');
+    refreshConfigCli = _proxyquire.default.noCallThru()('../refresh-config', {
+      '../': {
+        getNavy: getNavyStub
+      },
+      '../driver-logging': {
+        startDriverLogging: startDriverLoggingStub,
+        stopDriverLogging: stopDriverLoggingStub
+      }
+    });
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    it('should resolve the navy instance using opts.navy', async function () {
+      await refreshConfigCli({
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(getNavyStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(getNavyStub.firstCall.args[0]).to.equal('env-1');
+    });
+    it('should call refreshConfig on the resolved config provider', async function () {
+      await refreshConfigCli({
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(navyStub.getConfigProvider.calledOnce).to.equal(true);
+      (0, _chai.expect)(configProvider.refreshConfig.calledOnce).to.equal(true);
+    });
+    it('should bracket reconfigure with start/stopDriverLogging', async function () {
+      await refreshConfigCli({
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(startDriverLoggingStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.reconfigure.calledOnce).to.equal(true);
+      (0, _chai.expect)(stopDriverLoggingStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(startDriverLoggingStub.calledBefore(navyStub.reconfigure)).to.equal(true);
+      (0, _chai.expect)(navyStub.reconfigure.calledBefore(stopDriverLoggingStub)).to.equal(true);
+    });
+    it('should log a success message naming the navy', async function () {
+      await refreshConfigCli({
+        navy: 'env-1'
+      });
+      const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join(' ');
+      (0, _chai.expect)(printed).to.contain('Config refreshed');
+      (0, _chai.expect)(printed).to.contain('env-1');
+    });
+    it('should throw an invariant violation when the navy has no config provider', async function () {
+      navyStub.getConfigProvider.resolves(null);
+      let caught;
+      try {
+        await refreshConfigCli({
+          navy: 'env-1'
+        });
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.an('error');
+      (0, _chai.expect)(caught.message).to.match(/NO_CONFIG_PROVIDER/);
+      (0, _chai.expect)(configProvider.refreshConfig.called).to.equal(false);
+      (0, _chai.expect)(navyStub.reconfigure.called).to.equal(false);
+      (0, _chai.expect)(startDriverLoggingStub.called).to.equal(false);
+    });
+  });
+});

package/lib/cli/__tests__/run.js

@@ -0,0 +1,54 @@
+"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/run', function () {
+  let sandbox;
+  let getNavyStub;
+  let navyStub;
+  let run;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    navyStub = {
+      ensurePluginsLoaded: sandbox.stub().resolves(),
+      invokeCommand: sandbox.stub().resolves()
+    };
+    getNavyStub = sandbox.stub().returns(navyStub);
+    run = _proxyquire.default.noCallThru()('../run', {
+      '../': {
+        getNavy: getNavyStub
+      }
+    });
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('default export', function () {
+    it('should resolve the navy instance using opts.navy', async function () {
+      await run('cmd', [], {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(getNavyStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(getNavyStub.firstCall.args[0]).to.equal('env-1');
+    });
+    it('should call ensurePluginsLoaded before invokeCommand', async function () {
+      await run('cmd', ['a'], {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(navyStub.ensurePluginsLoaded.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.invokeCommand.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.ensurePluginsLoaded.calledBefore(navyStub.invokeCommand)).to.equal(true);
+    });
+    it('should pass through name and args to invokeCommand', async function () {
+      await run('migrate', ['--up', 'db'], {
+        navy: 'env-1'
+      });
+      (0, _chai.expect)(navyStub.invokeCommand.firstCall.args[0]).to.equal('migrate');
+      (0, _chai.expect)(navyStub.invokeCommand.firstCall.args[1]).to.eql(['--up', 'db']);
+    });
+  });
+});

package/lib/cli/__tests__/status.js

@@ -0,0 +1,204 @@
+"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 */
+
+describe('cli/status', function () {
+  let sandbox;
+  let getLaunchedNaviesStub;
+  let getConfigStub;
+  let consoleLogStub;
+  let statusCli;
+  function makeNavy(overrides = {}) {
+    return {
+      name: 'env-1',
+      ps: sandbox.stub().resolves([]),
+      getState: sandbox.stub().resolves({
+        configProvider: 'filesystem'
+      }),
+      getConfigProvider: sandbox.stub().resolves({
+        getLocationDisplayName: sandbox.stub().resolves('/path/to/cfg')
+      }),
+      url: sandbox.stub().callsFake(async svc => `http://${svc}.local`),
+      ...overrides
+    };
+  }
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    getLaunchedNaviesStub = sandbox.stub().resolves([]);
+    getConfigStub = sandbox.stub().resolves({
+      defaultNavy: 'env-1'
+    });
+    consoleLogStub = sandbox.stub(console, 'log');
+    statusCli = _proxyquire.default.noCallThru()('../status', {
+      '../': {
+        getLaunchedNavies: getLaunchedNaviesStub
+      },
+      '../config': {
+        getConfig: getConfigStub
+      }
+    });
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  function combinedLog() {
+    return consoleLogStub.getCalls().map(c => String(c.args[0] || '')).join('\n');
+  }
+  describe('default export', function () {
+    it('should render an empty table when there are no navies', async function () {
+      getLaunchedNaviesStub.resolves([]);
+      await statusCli({});
+      (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('ACTIVE');
+      (0, _chai.expect)(text).to.contain('SERVICES');
+      (0, _chai.expect)(text).to.contain('CONFIG PROVIDER');
+      (0, _chai.expect)(text).to.contain('CONFIG LOCATION');
+      (0, _chai.expect)(text).to.contain('URL');
+    });
+    it('should mark a navy with at least one running service as active', async function () {
+      const navy = makeNavy();
+      navy.ps.resolves([{
+        name: 'api',
+        status: 'running'
+      }, {
+        name: 'db',
+        status: 'exited'
+      }]);
+      getLaunchedNaviesStub.resolves([navy]);
+      await statusCli({});
+      const text = (0, _stripAnsi.default)(combinedLog());
+      (0, _chai.expect)(text).to.contain('yes');
+      (0, _chai.expect)(text).to.contain('2');
+    });
+    it('should mark a navy with no running services as inactive', async function () {
+      const navy = makeNavy();
+      navy.ps.resolves([{
+        name: 'api',
+        status: 'exited'
+      }]);
+      getLaunchedNaviesStub.resolves([navy]);
+      await statusCli({});
+      const text = (0, _stripAnsi.default)(combinedLog());
+      (0, _chai.expect)(text).to.contain('no');
+      (0, _chai.expect)(text).to.contain('1');
+    });
+    it('should highlight the default navy with (default)', async function () {
+      const navy = makeNavy({
+        name: 'env-1'
+      });
+      getLaunchedNaviesStub.resolves([navy]);
+      getConfigStub.resolves({
+        defaultNavy: 'env-1'
+      });
+      await statusCli({});
+      const text = (0, _stripAnsi.default)(combinedLog());
+      (0, _chai.expect)(text).to.contain('env-1');
+      (0, _chai.expect)(text).to.contain('(default)');
+    });
+    it('should not highlight non-default navies as default', async function () {
+      const navy = makeNavy({
+        name: 'env-2'
+      });
+      getLaunchedNaviesStub.resolves([navy]);
+      getConfigStub.resolves({
+        defaultNavy: 'env-1'
+      });
+      await statusCli({});
+      const text = (0, _stripAnsi.default)(combinedLog());
+      (0, _chai.expect)(text).to.contain('env-2');
+      (0, _chai.expect)(text).not.to.contain('(default)');
+    });
+    it('should include the config provider name and the config location', async function () {
+      const navy = makeNavy();
+      navy.getState.resolves({
+        configProvider: 'filesystem'
+      });
+      navy.getConfigProvider.resolves({
+        getLocationDisplayName: sandbox.stub().resolves('/etc/navy')
+      });
+      getLaunchedNaviesStub.resolves([navy]);
+      await statusCli({});
+      const text = (0, _stripAnsi.default)(combinedLog());
+      (0, _chai.expect)(text).to.contain('filesystem');
+      (0, _chai.expect)(text).to.contain('/etc/navy');
+    });
+    it('should call navy.url with the dimmed "service" placeholder for the table column', async function () {
+      const navy = makeNavy();
+      getLaunchedNaviesStub.resolves([navy]);
+      await statusCli({});
+      (0, _chai.expect)(navy.url.calledOnce).to.equal(true);
+      (0, _chai.expect)((0, _stripAnsi.default)(navy.url.firstCall.args[0])).to.equal('service');
+    });
+    it('should print JSON when opts.json is true', async function () {
+      const navy = makeNavy({
+        name: 'env-1'
+      });
+      navy.ps.resolves([{
+        name: 'api',
+        status: 'running'
+      }]);
+      navy.getState.resolves({
+        configProvider: 'filesystem'
+      });
+      navy.getConfigProvider.resolves({
+        getLocationDisplayName: sandbox.stub().resolves('/cfg/location')
+      });
+      navy.url.resolves('http://[service].local');
+      getLaunchedNaviesStub.resolves([navy]);
+      await statusCli({
+        json: true
+      });
+      (0, _chai.expect)(consoleLogStub.calledOnce).to.equal(true);
+      const parsed = JSON.parse(consoleLogStub.firstCall.args[0]);
+      (0, _chai.expect)(parsed).to.be.an('array').with.lengthOf(1);
+      (0, _chai.expect)(parsed[0]).to.deep.include({
+        name: 'env-1',
+        isActive: true,
+        configProvider: 'filesystem',
+        configLocation: '/cfg/location',
+        url: 'http://[service].local'
+      });
+      (0, _chai.expect)(parsed[0].services).to.be.an('array').with.lengthOf(1);
+      (0, _chai.expect)(parsed[0].state).to.deep.equal({
+        configProvider: 'filesystem'
+      });
+    });
+    it('should mark JSON output as inactive when no services are running', async function () {
+      const navy = makeNavy();
+      navy.ps.resolves([{
+        name: 'api',
+        status: 'exited'
+      }]);
+      getLaunchedNaviesStub.resolves([navy]);
+      await statusCli({
+        json: true
+      });
+      const parsed = JSON.parse(consoleLogStub.firstCall.args[0]);
+      (0, _chai.expect)(parsed[0].isActive).to.equal(false);
+    });
+    it('should not call getConfig when running in json mode', async function () {
+      const navy = makeNavy();
+      getLaunchedNaviesStub.resolves([navy]);
+      await statusCli({
+        json: true
+      });
+      (0, _chai.expect)(getConfigStub.called).to.equal(false);
+    });
+    it('should pass [service] (not chalk-dim "service") to navy.url when in json mode', async function () {
+      const navy = makeNavy();
+      getLaunchedNaviesStub.resolves([navy]);
+      await statusCli({
+        json: true
+      });
+      (0, _chai.expect)(navy.url.calledOnce).to.equal(true);
+      (0, _chai.expect)(navy.url.firstCall.args[0]).to.equal('[service]');
+    });
+  });
+});