navy 7.0.0-alpha.1 → 7.0.0-alpha.3

package/lib/cli/__tests__/program-unknown-options.js

@@ -0,0 +1,69 @@
+"use strict";
+
+var _chai = require("chai");
+var _commander = require("commander");
+/* eslint-env mocha */
+
+/**
+ * These tests check that the commander configuration the navy CLI relies on
+ * (positional options + per-subcommand option declarations) rejects options
+ * that a subcommand does not declare, using the exact error format commander
+ * emits by default.
+ *
+ * We build a minimal program with the same shape as packages/navy/src/cli/program.js
+ * rather than loading that module, because importing program.js has side effects
+ * (config reading, action wiring) that are not relevant to argument parsing.
+ */
+describe('cli/program unknown option handling', function () {
+  function buildProgram() {
+    const program = new _commander.Command();
+    program.exitOverride();
+    program.configureOutput({
+      writeErr: () => {},
+      writeOut: () => {}
+    });
+    program.enablePositionalOptions();
+    program.option('-e, --navy [env]', 'set the navy name to be used', 'dev');
+    program.command('status').option('--json', 'output JSON instead of a table').action(() => {});
+    program.command('start [services...]').option('-e, --navy [env]', 'set the navy name to be used', 'dev').action(() => {});
+    return program;
+  }
+  describe('a subcommand that does not declare the option', function () {
+    it('should throw a commander error for an unknown short option', function () {
+      const program = buildProgram();
+      (0, _chai.expect)(() => program.parse(['node', 'navy', 'status', '-e', 'foo'])).to.throw(/unknown option '-e'/);
+    });
+    it('should produce a non-zero exit code on the thrown error', function () {
+      const program = buildProgram();
+      try {
+        program.parse(['node', 'navy', 'status', '-e', 'foo']);
+        _chai.expect.fail('expected parse to throw');
+      } catch (ex) {
+        (0, _chai.expect)(ex.exitCode).to.be.greaterThan(0);
+      }
+    });
+    it('should emit the canonical commander unknown-option message', function () {
+      const program = buildProgram();
+      try {
+        program.parse(['node', 'navy', 'status', '-e', 'foo']);
+        _chai.expect.fail('expected parse to throw');
+      } catch (ex) {
+        (0, _chai.expect)(ex.message).to.equal("error: unknown option '-e'");
+      }
+    });
+    it('should still accept declared options on the same subcommand', function () {
+      const program = buildProgram();
+      (0, _chai.expect)(() => program.parse(['node', 'navy', 'status', '--json'])).to.not.throw();
+    });
+  });
+  describe('a subcommand that declares the option', function () {
+    it('should accept the option after the subcommand name', function () {
+      const program = buildProgram();
+      (0, _chai.expect)(() => program.parse(['node', 'navy', 'start', '-e', 'foo'])).to.not.throw();
+    });
+    it('should accept the option before the subcommand name (parent inherits)', function () {
+      const program = buildProgram();
+      (0, _chai.expect)(() => program.parse(['node', 'navy', '-e', 'foo', 'start'])).to.not.throw();
+    });
+  });
+});

package/lib/cli/__tests__/program.js

@@ -27,6 +27,8 @@ describe('cli/program', function () {
     actionsByCommand = {};
     helpHandlersByCommand = {};
     fakeProgram = {
+      option: sandbox.stub().returnsThis(),
+      enablePositionalOptions: sandbox.stub().returnsThis(),
       command(spec) {
         const name = spec.split(' ')[0];
         const cmd = {
@@ -150,6 +152,14 @@ describe('cli/program', function () {
       });
       (0, _chai.expect)(consoleLogStub.called).to.equal(true);
     });
+    it('should register a global -e, --navy option on the root program', function () {
+      loadModule();
+      (0, _chai.expect)(fakeProgram.option.calledWith('-e, --navy [env]', _sinon.default.match.string, 'dev')).to.equal(true);
+    });
+    it('should enable positional options so unknown subcommand options are rejected', function () {
+      loadModule();
+      (0, _chai.expect)(fakeProgram.enablePositionalOptions.calledOnce).to.equal(true);
+    });
   });
   describe('lazyRequire wrapped action', function () {
     it('should pass through arguments to the underlying module', async function () {
@@ -332,6 +342,18 @@ describe('cli/program', function () {
       (0, _chai.expect)(navyStub.start.firstCall.args[0]).to.eql(['web', 'api']);
       (0, _chai.expect)(navyStub.ensurePluginsLoaded.calledOnce).to.equal(true);
     });
+    it('should merge optsWithGlobals so global navy is used when Commander passes the command', async function () {
+      navyStub.start = sandbox.stub().resolves();
+      const fakeCommand = {
+        optsWithGlobals: () => ({
+          navy: 'from-global'
+        })
+      };
+      await actionsByCommand.start(['web'], {
+        navy: 'subcommand-default'
+      }, fakeCommand);
+      (0, _chai.expect)(getNavyStub.firstCall.args[0]).to.equal('from-global');
+    });
     it('should pass undefined when called with an empty service list', async function () {
       navyStub.start = sandbox.stub().resolves();
       await actionsByCommand.start([], {
@@ -436,6 +458,8 @@ describe('cli/program', function () {
   function createCapturingProgram() {
     capturedActions = {};
     return {
+      option: sandbox.stub().returnsThis(),
+      enablePositionalOptions: sandbox.stub().returnsThis(),
       command(spec) {
         const name = spec.split(' ')[0];
         const cmd = {

package/lib/cli/program.js

@@ -11,6 +11,7 @@ var _errors = require("../errors");
 var _config = require("../config");
 var _driverLogging = require("../driver-logging");
 var _configProvider = require("../config-provider");
+var _mergeActionOptions = require("./util/merge-action-options");
 const loadingLabelMap = {
   destroy: 'Destroying services...',
   start: 'Starting services...',
@@ -28,6 +29,23 @@ const loadingLabelMap = {
 function removeFirstLineFromStackTrace(stack) {
   return stack?.split('\n')?.slice(1)?.join('\n');
 }
+function normaliseLazyRequireArgs(args) {
+  if (args.length === 0) return args;
+  const last = args[args.length - 1];
+  if (!last || typeof last.optsWithGlobals !== 'function') {
+    return args;
+  }
+  const command = last;
+  const rest = args.slice(0, -1);
+  if (rest.length === 0) {
+    return rest;
+  }
+  const lastOpt = rest[rest.length - 1];
+  if (lastOpt && typeof lastOpt === 'object' && !Array.isArray(lastOpt)) {
+    return [...rest.slice(0, -1), (0, _mergeActionOptions.mergeActionOptions)(lastOpt, command)];
+  }
+  return rest;
+}
 function wrapper(res) {
   if (res.catch) {
     res.catch(ex => {
@@ -62,11 +80,21 @@ function basicCliWrapper(fnName, wrapperOpts = {}) {
     } = require('../navy');
 
     // commander v12 invokes action handlers with a trailing Command instance
-    // appended after the parsed options. Strip it so the rest of this wrapper
-    // can continue to treat the last remaining `args` element as the options.
-    if (args.length > 0) args = args.slice(0, -1);
-    const opts = args.length === 0 ? maybeServices : args[args.length - 1];
+    // appended after the parsed options. Strip it and merge global options
+    // (e.g. `navy -e dev start`) into the opts object.
+    let command = null;
+    if (args.length > 0) {
+      const last = args[args.length - 1];
+      if (last && typeof last.optsWithGlobals === 'function') {
+        command = last;
+        args = args.slice(0, -1);
+      }
+    }
+    let opts = args.length === 0 ? maybeServices : args[args.length - 1];
     const otherArgs = args.slice(0, args.length - 1);
+    if (command && opts && typeof opts === 'object' && !Array.isArray(opts)) {
+      opts = (0, _mergeActionOptions.mergeActionOptions)(opts, command);
+    }
     const envName = opts.navy;
     if (wrapperOpts.serviceBasedAlias && maybeServices.length) {
       console.log(`This command should not be called with a list of services. calling '${wrapperOpts.serviceBasedAlias}' instead`);
@@ -102,10 +130,17 @@ function basicCliWrapper(fnName, wrapperOpts = {}) {
 function lazyRequire(path) {
   return function (...args) {
     const mod = require(path);
-    return wrapper((mod.default || mod)(...args));
+    const normalised = normaliseLazyRequireArgs(args);
+    return wrapper((mod.default || mod)(...normalised));
   };
 }
 const defaultNavy = process.env.NAVY_NAME || (0, _config.getConfig)().defaultNavy;
+
+// Strictly separate parent and subcommand options so an option that isn't
+// declared on a subcommand (e.g. `navy status -e foo`) is reported as
+// unknown rather than silently absorbed by the parent program.
+_commander.program.enablePositionalOptions();
+_commander.program.option('-e, --navy [env]', `set the navy name to be used [${defaultNavy}]`, defaultNavy);
 const importCommand = _commander.program.command('import').option('-e, --navy [env]', `set the navy name to be used [${defaultNavy}]`, defaultNavy).description('Imports docker compose configuration from the current working directory and initialises a new navy').action(lazyRequire('./import'));
 (0, _configProvider.getImportCommandLineOptions)().forEach(opt => importCommand.option(...opt));
 _commander.program.command('launch [services...]').option('-e, --navy [env]', `set the navy name to be used [${defaultNavy}]`, defaultNavy).description('Launches the given services in a navy').action(lazyRequire('./launch')).on('--help', () => console.log(`

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

@@ -0,0 +1,71 @@
+"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);
+  });
+  it('should let an explicit subcommand option beat the inherited parent default', function () {
+    const command = {
+      optsWithGlobals: () => ({
+        navy: 'parent-default'
+      }),
+      getOptionValueSource: key => key === 'navy' ? 'cli' : 'default'
+    };
+    const merged = (0, _mergeActionOptions.mergeActionOptions)({
+      navy: 'from-subcommand'
+    }, command);
+    (0, _chai.expect)(merged.navy).to.equal('from-subcommand');
+  });
+  it('should keep the parent value when the subcommand value came from its default', function () {
+    const command = {
+      optsWithGlobals: () => ({
+        navy: 'from-parent'
+      }),
+      getOptionValueSource: () => 'default'
+    };
+    const merged = (0, _mergeActionOptions.mergeActionOptions)({
+      navy: 'subcommand-default'
+    }, command);
+    (0, _chai.expect)(merged.navy).to.equal('from-parent');
+  });
+});

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

@@ -0,0 +1,31 @@
+"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()` has "globals overwrite locals" semantics, which makes parent
+ * defaults win over child defaults. With positional options enabled, however, a
+ * value supplied after the subcommand name (e.g. `navy ps -e dev`) is parsed onto
+ * the subcommand, not the parent, so we re-apply any option whose source on the
+ * subcommand is non-default to keep the explicit value.
+ */
+function mergeActionOptions(parsedOpts, command) {
+  if (!command || typeof command.optsWithGlobals !== 'function') {
+    return parsedOpts;
+  }
+  const merged = {
+    ...command.optsWithGlobals()
+  };
+  if (typeof command.getOptionValueSource === 'function') {
+    for (const key of Object.keys(parsedOpts)) {
+      const source = command.getOptionValueSource(key);
+      if (source && source !== 'default') {
+        merged[key] = parsedOpts[key];
+      }
+    }
+  }
+  return merged;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "navy",
-  "version": "7.0.0-alpha.1",
+  "version": "7.0.0-alpha.3",
   "description": "Quick and powerful development environments using Docker and Docker Compose",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",
@@ -49,6 +49,5 @@
     "resolve": "^1.20.0",
     "strip-ansi": "^6.0.1",
     "www-authenticate": "^0.6.3"
-  },
-  "gitHead": "c977d36ee1e962134aee34d5fa20071cd863a619"
+  }
 }