navy 7.0.0-alpha.2 → 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

@@ -28,6 +28,7 @@ describe('cli/program', function () {
     helpHandlersByCommand = {};
     fakeProgram = {
       option: sandbox.stub().returnsThis(),
+      enablePositionalOptions: sandbox.stub().returnsThis(),
       command(spec) {
         const name = spec.split(' ')[0];
         const cmd = {
@@ -155,6 +156,10 @@ describe('cli/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 () {
@@ -454,6 +459,7 @@ describe('cli/program', function () {
     capturedActions = {};
     return {
       option: sandbox.stub().returnsThis(),
+      enablePositionalOptions: sandbox.stub().returnsThis(),
       command(spec) {
         const name = spec.split(' ')[0];
         const cmd = {

package/lib/cli/program.js

@@ -135,6 +135,11 @@ function lazyRequire(path) {
   };
 }
 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));

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

@@ -44,4 +44,28 @@ describe('cli/util/merge-action-options', function () {
     });
     (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

@@ -6,15 +6,26 @@ Object.defineProperty(exports, "__esModule", {
 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.
+ * `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;
   }
-  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.2",
+  "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",