navy 6.0.0 → 7.0.0-alpha.2

package/lib/cli/util/__tests__/import.js

@@ -0,0 +1,123 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _proxyquire = _interopRequireDefault(require("proxyquire"));
+var _errors = require("../../../errors");
+/* eslint-env mocha */
+
+describe('cli/util/import', function () {
+  let sandbox;
+  let startDriverLoggingStub;
+  let stopDriverLoggingStub;
+  let consoleLogStub;
+  let navyStub;
+  let importNavy;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    navyStub = {
+      name: 'env-1',
+      isInitialised: sandbox.stub().resolves(false),
+      initialise: sandbox.stub().resolves(),
+      ensurePluginsLoaded: sandbox.stub().resolves(),
+      emitAsync: sandbox.stub().resolves(),
+      relaunch: sandbox.stub().resolves()
+    };
+    startDriverLoggingStub = sandbox.stub();
+    stopDriverLoggingStub = sandbox.stub();
+    consoleLogStub = sandbox.stub(console, 'log');
+    importNavy = _proxyquire.default.noCallThru()('../import', {
+      '../../driver-logging': {
+        startDriverLogging: startDriverLoggingStub,
+        stopDriverLogging: stopDriverLoggingStub
+      },
+      '../../errors': {
+        NavyError: _errors.NavyError
+      }
+    }).importNavy;
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('importNavy', function () {
+    it('should throw a NavyError when the navy has already been initialised', async function () {
+      navyStub.isInitialised.resolves(true);
+      let caught;
+      try {
+        await importNavy(navyStub, {});
+      } catch (err) {
+        caught = err;
+      }
+      (0, _chai.expect)(caught).to.be.instanceof(_errors.NavyError);
+      (0, _chai.expect)(caught.message).to.contain('env-1');
+      (0, _chai.expect)(caught.message).to.contain('already been imported');
+      (0, _chai.expect)(navyStub.initialise.called).to.equal(false);
+    });
+    it('should initialise the navy with the provided opts', async function () {
+      const opts = {
+        configProvider: 'filesystem',
+        path: '/cwd'
+      };
+      await importNavy(navyStub, opts);
+      (0, _chai.expect)(navyStub.initialise.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.initialise.firstCall.args[0]).to.equal(opts);
+    });
+    it('should ensure plugins are loaded and emit cli.import in order before relaunch', async function () {
+      await importNavy(navyStub, {});
+      (0, _chai.expect)(navyStub.ensurePluginsLoaded.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.emitAsync.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.emitAsync.firstCall.args[0]).to.equal('cli.import');
+      (0, _chai.expect)(navyStub.relaunch.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyStub.initialise.calledBefore(navyStub.ensurePluginsLoaded)).to.equal(true);
+      (0, _chai.expect)(navyStub.ensurePluginsLoaded.calledBefore(navyStub.emitAsync)).to.equal(true);
+      (0, _chai.expect)(navyStub.emitAsync.calledBefore(navyStub.relaunch)).to.equal(true);
+    });
+    it('should bracket relaunch with start/stopDriverLogging', async function () {
+      await importNavy(navyStub, {});
+      (0, _chai.expect)(startDriverLoggingStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(stopDriverLoggingStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(startDriverLoggingStub.calledBefore(navyStub.relaunch)).to.equal(true);
+      (0, _chai.expect)(navyStub.relaunch.calledBefore(stopDriverLoggingStub)).to.equal(true);
+    });
+    it('should log a success message containing the navy name', async function () {
+      await importNavy(navyStub, {});
+      const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join(' ');
+      (0, _chai.expect)(printed).to.contain('env-1');
+      (0, _chai.expect)(printed).to.contain('imported and initialised');
+    });
+    it('should print a labelled line for each known option key', async function () {
+      const opts = {
+        configProvider: 'filesystem',
+        path: '/cwd',
+        npmPackage: 'some-pkg'
+      };
+      await importNavy(navyStub, opts);
+      const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+      (0, _chai.expect)(printed).to.contain('Provider');
+      (0, _chai.expect)(printed).to.contain('filesystem');
+      (0, _chai.expect)(printed).to.contain('Directory');
+      (0, _chai.expect)(printed).to.contain('/cwd');
+      (0, _chai.expect)(printed).to.contain('NPM Package');
+      (0, _chai.expect)(printed).to.contain('some-pkg');
+    });
+    it('should ignore unknown option keys when printing labels', async function () {
+      const opts = {
+        configProvider: 'filesystem',
+        unrecognised: 'value'
+      };
+      await importNavy(navyStub, opts);
+      const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+      (0, _chai.expect)(printed).to.contain('Provider');
+      (0, _chai.expect)(printed).to.not.contain('unrecognised');
+      (0, _chai.expect)(printed).to.not.contain('value');
+    });
+    it('should not print any option label lines when no known options are supplied', async function () {
+      await importNavy(navyStub, {});
+      const printed = consoleLogStub.getCalls().map(c => c.args[0] || '').join('\n');
+      (0, _chai.expect)(printed).to.not.contain('Provider');
+      (0, _chai.expect)(printed).to.not.contain('Directory');
+      (0, _chai.expect)(printed).to.not.contain('NPM Package');
+    });
+  });
+});

package/lib/cli/util/__tests__/index.js

@@ -0,0 +1,17 @@
+"use strict";
+
+var _chai = require("chai");
+var cliUtil = _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('cli/util/index', function () {
+  describe('module exports', function () {
+    it('should re-export getOrInitialiseNavy as a function', function () {
+      (0, _chai.expect)(cliUtil).to.have.property('getOrInitialiseNavy').that.is.a('function');
+    });
+    it('should re-export importNavy as a function', function () {
+      (0, _chai.expect)(cliUtil).to.have.property('importNavy').that.is.a('function');
+    });
+  });
+});

package/lib/cli/util/__tests__/merge-action-options.js

@@ -0,0 +1,47 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _mergeActionOptions = require("../merge-action-options");
+/* eslint-env mocha */
+
+describe('cli/util/merge-action-options', function () {
+  it('should return parsed opts when command is missing', function () {
+    const opts = {
+      navy: 'dev'
+    };
+    (0, _chai.expect)((0, _mergeActionOptions.mergeActionOptions)(opts, null)).to.equal(opts);
+  });
+  it('should return parsed opts when optsWithGlobals is missing', function () {
+    const opts = {
+      navy: 'dev'
+    };
+    (0, _chai.expect)((0, _mergeActionOptions.mergeActionOptions)(opts, {})).to.equal(opts);
+  });
+  it('should merge optsWithGlobals so global navy wins over subcommand defaults', function () {
+    const command = {
+      optsWithGlobals: () => ({
+        navy: 'dev',
+        json: true
+      })
+    };
+    const merged = (0, _mergeActionOptions.mergeActionOptions)({
+      navy: 'default',
+      json: false
+    }, command);
+    (0, _chai.expect)(merged.navy).to.equal('dev');
+    (0, _chai.expect)(merged.json).to.equal(true);
+  });
+  it('should call optsWithGlobals on the command', function () {
+    const spy = _sinon.default.stub().returns({
+      navy: 'x'
+    });
+    (0, _mergeActionOptions.mergeActionOptions)({
+      navy: 'y'
+    }, {
+      optsWithGlobals: spy
+    });
+    (0, _chai.expect)(spy.calledOnce).to.equal(true);
+  });
+});

package/lib/cli/util/__tests__/reconfigure.js

@@ -0,0 +1,78 @@
+"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/util/reconfigure', function () {
+  let sandbox;
+  let getLaunchedNaviesStub;
+  let startDriverLoggingStub;
+  let stopDriverLoggingStub;
+  let reconfigureAllNavies;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    getLaunchedNaviesStub = sandbox.stub();
+    startDriverLoggingStub = sandbox.stub();
+    stopDriverLoggingStub = sandbox.stub();
+    reconfigureAllNavies = _proxyquire.default.noCallThru()('../reconfigure', {
+      '../../': {
+        getLaunchedNavies: getLaunchedNaviesStub
+      },
+      '../../driver-logging': {
+        startDriverLogging: startDriverLoggingStub,
+        stopDriverLogging: stopDriverLoggingStub
+      }
+    }).reconfigureAllNavies;
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('reconfigureAllNavies', function () {
+    it('should be a no-op when there are no launched navies', async function () {
+      getLaunchedNaviesStub.resolves([]);
+      await reconfigureAllNavies();
+      (0, _chai.expect)(getLaunchedNaviesStub.calledOnce).to.equal(true);
+      (0, _chai.expect)(startDriverLoggingStub.called).to.equal(false);
+      (0, _chai.expect)(stopDriverLoggingStub.called).to.equal(false);
+    });
+    it('should reconfigure each launched navy in turn with bracketed driver logging', async function () {
+      const navyA = {
+        name: 'envA',
+        reconfigure: sandbox.stub().resolves()
+      };
+      const navyB = {
+        name: 'envB',
+        reconfigure: sandbox.stub().resolves()
+      };
+      getLaunchedNaviesStub.resolves([navyA, navyB]);
+      await reconfigureAllNavies();
+      (0, _chai.expect)(navyA.reconfigure.calledOnce).to.equal(true);
+      (0, _chai.expect)(navyB.reconfigure.calledOnce).to.equal(true);
+      (0, _chai.expect)(startDriverLoggingStub.callCount).to.equal(2);
+      (0, _chai.expect)(stopDriverLoggingStub.callCount).to.equal(2);
+    });
+    it('should pass a message that includes the navy name to startDriverLogging', async function () {
+      const navy = {
+        name: 'envA',
+        reconfigure: sandbox.stub().resolves()
+      };
+      getLaunchedNaviesStub.resolves([navy]);
+      await reconfigureAllNavies();
+      (0, _chai.expect)(startDriverLoggingStub.firstCall.args[0]).to.contain('envA');
+      (0, _chai.expect)(startDriverLoggingStub.firstCall.args[0]).to.contain('Reconfiguring');
+    });
+    it('should call startDriverLogging before each reconfigure and stopDriverLogging after', async function () {
+      const navy = {
+        name: 'envA',
+        reconfigure: sandbox.stub().resolves()
+      };
+      getLaunchedNaviesStub.resolves([navy]);
+      await reconfigureAllNavies();
+      (0, _chai.expect)(startDriverLoggingStub.calledBefore(navy.reconfigure)).to.equal(true);
+      (0, _chai.expect)(navy.reconfigure.calledBefore(stopDriverLoggingStub)).to.equal(true);
+    });
+  });
+});

package/lib/cli/util/get-or-initialise-navy.js

@@ -1,24 +1,17 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.getOrInitialiseNavy = getOrInitialiseNavy;
-
 var _ = require("../../");
-
 var _import = require("./import");
-
 var _filesystem = _interopRequireDefault(require("../../config-providers/filesystem"));
-
 async function getOrInitialiseNavy(navyName) {
   const navy = (0, _.getNavy)(navyName);
-
   if (!(await navy.isInitialised())) {
     await (0, _import.importNavy)(navy, await _filesystem.default.getImportOptionsForCLI({}));
   }
-
   return navy;
 }

package/lib/cli/util/import.js

@@ -1,29 +1,22 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.importNavy = importNavy;
-
 var _chalk = _interopRequireDefault(require("chalk"));
-
 var _driverLogging = require("../../driver-logging");
-
 var _errors = require("../../errors");
-
 const OPTION_LABEL_MAP = {
   configProvider: 'Provider',
   path: 'Directory',
   npmPackage: 'NPM Package'
 };
-
 async function importNavy(navy, initialiseOpts) {
   if (await navy.isInitialised()) {
     throw new _errors.NavyError(`Navy "${navy.name}" has already been imported and initialised.`);
   }
-
   await navy.initialise(initialiseOpts);
   await navy.ensurePluginsLoaded();
   await navy.emitAsync('cli.import');
@@ -33,12 +26,10 @@ async function importNavy(navy, initialiseOpts) {
   console.log();
   console.log(_chalk.default.green(` Navy "${_chalk.default.white.bold(navy.name)}" has now been imported and initialised. 🎉`));
   console.log();
-
   for (const key in initialiseOpts) {
     if (OPTION_LABEL_MAP[key]) {
       console.log(` ${_chalk.default.bold(OPTION_LABEL_MAP[key])}: ${_chalk.default.dim(initialiseOpts[key])}`);
     }
   }
-
   console.log();
 }

package/lib/cli/util/index.js

@@ -15,7 +15,5 @@ Object.defineProperty(exports, "importNavy", {
     return _import.importNavy;
   }
 });
-
 var _getOrInitialiseNavy = require("./get-or-initialise-navy");
-
 var _import = require("./import");

package/lib/cli/util/merge-action-options.js

@@ -0,0 +1,20 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.mergeActionOptions = mergeActionOptions;
+/**
+ * Merge Commander's per-command opts with inherited globals (e.g. `navy -e dev ps`).
+ * `optsWithGlobals()` is the combined view; spread it after local opts so globals
+ * override stale option defaults on the subcommand.
+ */
+function mergeActionOptions(parsedOpts, command) {
+  if (!command || typeof command.optsWithGlobals !== 'function') {
+    return parsedOpts;
+  }
+  return {
+    ...parsedOpts,
+    ...command.optsWithGlobals()
+  };
+}

package/lib/cli/util/reconfigure.js

@@ -4,14 +4,10 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.reconfigureAllNavies = reconfigureAllNavies;
-
 var _ = require("../../");
-
 var _driverLogging = require("../../driver-logging");
-
 async function reconfigureAllNavies() {
   const navies = await (0, _.getLaunchedNavies)();
-
   for (const navy of navies) {
     (0, _driverLogging.startDriverLogging)('Reconfiguring ' + navy.name);
     await navy.reconfigure();

package/lib/cli/wait-for-healthy.js

@@ -1,71 +1,51 @@
 "use strict";
 
 var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
-
 Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = _default;
-
 var _chalk = _interopRequireDefault(require("chalk"));
-
 var _readline = _interopRequireDefault(require("readline"));
-
 var _cliSpinners = require("cli-spinners");
-
 var _ = require("../");
-
 let spinnerIndex = 0;
 let spinnerFrame = _cliSpinners.dots.frames[0];
-
 async function _default(services, opts) {
   const navy = (0, _.getNavy)(opts.navy);
   const servicesToCheck = services.length === 0 ? undefined : services;
-
   if (!process.stdout.isTTY) {
     await navy.waitForHealthy(servicesToCheck);
     console.log('Now available');
     return;
   }
-
   let healthyStatus = [];
   let drawnLines = 0;
-
   function draw() {
     drawnLines = 0;
-
     if (healthyStatus.length === 0) {
       console.log('Waiting');
       drawnLines = 1;
       return;
     }
-
     const lines = healthyStatus.map(service => `${service.health !== 'healthy' ? _chalk.default.yellow(spinnerFrame) : _chalk.default.green('✔')} ${service.service}`);
     drawnLines = lines.length;
     console.log(lines.join('\n'));
   }
-
   function redraw() {
     _readline.default.clearLine(process.stdout, 0);
-
     _readline.default.cursorTo(process.stdout, 0);
-
     for (let i = 0; i < drawnLines; i++) {
       _readline.default.moveCursor(process.stdout, 0, -1);
-
       _readline.default.clearLine(process.stdout, 0);
     }
-
     draw();
   }
-
   const spinner = setInterval(() => {
     spinnerIndex++;
-
     if (spinnerIndex >= _cliSpinners.dots.frames.length) {
       spinnerIndex = 0;
     }
-
     spinnerFrame = _cliSpinners.dots.frames[spinnerIndex];
     redraw();
   }, _cliSpinners.dots.interval);
@@ -74,5 +54,4 @@ async function _default(services, opts) {
   redraw();
   clearInterval(spinner);
 }
-
 module.exports = exports.default;

package/lib/client/registry/__tests__/get-credentials.js

@@ -0,0 +1,62 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var execAsyncModule = _interopRequireWildcard(require("../../../util/exec-async"));
+var _containerImage = require("../../../domain/container-image");
+var _getCredentials = _interopRequireDefault(require("../get-credentials"));
+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('get-credentials', function () {
+  let sandbox;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  it('should call docker-credential-desktop with the default auth URL when registry is the default registry', async function () {
+    const execStub = sandbox.stub(execAsyncModule, 'execAsync').resolves(JSON.stringify({
+      Username: 'u',
+      Secret: 's'
+    }));
+    const result = await (0, _getCredentials.default)(_containerImage.DEFAULT_REGISTRY);
+    (0, _chai.expect)(result).to.eql({
+      username: 'u',
+      password: 's'
+    });
+    const args = execStub.firstCall.args;
+    (0, _chai.expect)(args[0]).to.equal('echo');
+    (0, _chai.expect)(args[1]).to.include(_containerImage.DEFAULT_REGISTRY_AUTH);
+    (0, _chai.expect)(args[1]).to.include('docker-credential-desktop');
+    (0, _chai.expect)(args[1]).to.include('get');
+  });
+  it('should pass the registry hostname directly when not the default registry', async function () {
+    const execStub = sandbox.stub(execAsyncModule, 'execAsync').resolves(JSON.stringify({
+      Username: 'alice',
+      Secret: 'pw'
+    }));
+    const result = await (0, _getCredentials.default)('myregistry.local:5000');
+    (0, _chai.expect)(result).to.eql({
+      username: 'alice',
+      password: 'pw'
+    });
+    (0, _chai.expect)(execStub.firstCall.args[1]).to.include('myregistry.local:5000');
+  });
+  it('should return empty credentials when execAsync rejects', async function () {
+    sandbox.stub(execAsyncModule, 'execAsync').rejects(new Error('not installed'));
+    (0, _chai.expect)(await (0, _getCredentials.default)('any')).to.eql({
+      username: '',
+      password: ''
+    });
+  });
+  it('should return empty credentials when stdout is not valid JSON', async function () {
+    sandbox.stub(execAsyncModule, 'execAsync').resolves('not-json');
+    (0, _chai.expect)(await (0, _getCredentials.default)('any')).to.eql({
+      username: '',
+      password: ''
+    });
+  });
+});

package/lib/client/registry/__tests__/get-endpoint.js

@@ -0,0 +1,124 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _sinon = _interopRequireDefault(require("sinon"));
+var _nock = _interopRequireDefault(require("nock"));
+var _proxyquire = _interopRequireDefault(require("proxyquire"));
+/* eslint-env mocha */
+
+function loadModule({
+  getCredentials,
+  getToken
+} = {}) {
+  return _proxyquire.default.noCallThru()('../get-endpoint', {
+    './get-credentials': getCredentials || _sinon.default.stub().resolves({
+      username: 'u',
+      password: 'p'
+    }),
+    './get-token': getToken || _sinon.default.stub().resolves('the-token')
+  });
+}
+describe('get-endpoint', function () {
+  afterEach(function () {
+    _nock.default.cleanAll();
+  });
+  it('should return the response when the registry replies 200', async function () {
+    const body = {
+      schemaVersion: 2
+    };
+    (0, _nock.default)('https://reg.example.com').get('/v2/library/node/manifests/latest').reply(200, body);
+    const getEndpoint = loadModule();
+    const response = await getEndpoint({
+      registry: 'reg.example.com',
+      endpoint: 'library/node/manifests/latest'
+    });
+    (0, _chai.expect)(response.status).to.equal(200);
+    (0, _chai.expect)(await response.json()).to.eql(body);
+  });
+  it('should throw "Operation not found" when the registry returns 404', async function () {
+    (0, _nock.default)('https://reg.example.com').get('/v2/missing').reply(404, {
+      errors: []
+    });
+    const getEndpoint = loadModule();
+    let caught;
+    try {
+      await getEndpoint({
+        registry: 'reg.example.com',
+        endpoint: 'missing'
+      });
+    } catch (err) {
+      caught = err;
+    }
+    (0, _chai.expect)(caught).to.be.an('error');
+    (0, _chai.expect)(caught.message).to.equal('Operation not found');
+  });
+  it('should retry with a Bearer token when the response is 401 with a Bearer challenge', async function () {
+    (0, _nock.default)('https://reg.example.com').get('/v2/secret').reply(401, '', {
+      'WWW-Authenticate': 'Bearer realm="https://auth.example.com/token",service="reg.example.com",scope="repository:secret:pull"'
+    }).get('/v2/secret').matchHeader('authorization', 'Bearer the-token').reply(200, {
+      ok: true
+    });
+    const getToken = _sinon.default.stub().resolves('the-token');
+    const getEndpoint = loadModule({
+      getToken
+    });
+    const response = await getEndpoint({
+      registry: 'reg.example.com',
+      endpoint: 'secret'
+    });
+    (0, _chai.expect)(response.status).to.equal(200);
+    (0, _chai.expect)(await response.json()).to.eql({
+      ok: true
+    });
+    (0, _chai.expect)(getToken.calledOnce).to.equal(true);
+  });
+  it('should throw "Access denied" when the bearer-token retry still returns 401', async function () {
+    (0, _nock.default)('https://reg.example.com').get('/v2/secret').reply(401, '', {
+      'WWW-Authenticate': 'Bearer realm="https://auth.example.com/token",service="reg.example.com",scope="repository:secret:pull"'
+    }).get('/v2/secret').reply(401, '');
+    const getEndpoint = loadModule();
+    let caught;
+    try {
+      await getEndpoint({
+        registry: 'reg.example.com',
+        endpoint: 'secret'
+      });
+    } catch (err) {
+      caught = err;
+    }
+    (0, _chai.expect)(caught.message).to.equal('Access denied');
+  });
+  it('should throw "Invalid authentication" for a Basic challenge', async function () {
+    (0, _nock.default)('https://reg.example.com').get('/v2/needs-basic').reply(401, '', {
+      'WWW-Authenticate': 'Basic realm="reg"'
+    });
+    const getEndpoint = loadModule();
+    let caught;
+    try {
+      await getEndpoint({
+        registry: 'reg.example.com',
+        endpoint: 'needs-basic'
+      });
+    } catch (err) {
+      caught = err;
+    }
+    (0, _chai.expect)(caught.message).to.equal('Invalid authentication');
+  });
+  it('should throw "Invalid authentication" for an unknown auth scheme', async function () {
+    (0, _nock.default)('https://reg.example.com').get('/v2/weird').reply(401, '', {
+      'WWW-Authenticate': 'Digest realm="reg"'
+    });
+    const getEndpoint = loadModule();
+    let caught;
+    try {
+      await getEndpoint({
+        registry: 'reg.example.com',
+        endpoint: 'weird'
+      });
+    } catch (err) {
+      caught = err;
+    }
+    (0, _chai.expect)(caught.message).to.equal('Invalid authentication');
+  });
+});