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

Quick and powerful development environments using Docker and Docker Compose

"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);
    });
  });
});