navy 7.0.0-alpha.3 → 7.0.0-alpha.4

package/lib/__tests__/http-proxy.js

@@ -62,6 +62,185 @@ describe('resolveProxyImage', function () {
     (0, _chai.expect)((0, _httpProxy.resolveProxyImage)()).to.equal('navycloud/navy-proxy');
   });
 });
+describe('resolveProxyEnvFromNavyFile', function () {
+  it('should return an empty object when no navyFile is provided', function () {
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)()).to.eql({});
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)(null)).to.eql({});
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)(undefined)).to.eql({});
+  });
+  it('should return an empty object when navyFile has no httpProxyEnv', function () {
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)({})).to.eql({});
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)({
+      plugins: []
+    })).to.eql({});
+  });
+  it('should return the httpProxyEnv map from navyFile', function () {
+    const navyFile = {
+      httpProxyEnv: {
+        FOO: 'bar',
+        BAZ: 'qux'
+      }
+    };
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)(navyFile)).to.eql({
+      FOO: 'bar',
+      BAZ: 'qux'
+    });
+  });
+  it('should drop entries with empty string, null, or undefined values', function () {
+    const navyFile = {
+      httpProxyEnv: {
+        EMPTY: '',
+        NULL: null,
+        UNDEF: undefined,
+        KEEP: 'value'
+      }
+    };
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)(navyFile)).to.eql({
+      KEEP: 'value'
+    });
+  });
+  it('should coerce numeric values to strings', function () {
+    const navyFile = {
+      httpProxyEnv: {
+        PORT: 8080,
+        ZERO: 0
+      }
+    };
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)(navyFile)).to.eql({
+      PORT: '8080',
+      ZERO: '0'
+    });
+  });
+  it('should return an empty object when httpProxyEnv is a string', function () {
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)({
+      httpProxyEnv: 'FOO=bar'
+    })).to.eql({});
+  });
+  it('should return an empty object when httpProxyEnv is an array', function () {
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvFromNavyFile)({
+      httpProxyEnv: ['FOO=bar']
+    })).to.eql({});
+  });
+});
+describe('resolveProxyEnvAllowlist', function () {
+  const namesSetDuringTest = [];
+  function setEnv(name, value) {
+    namesSetDuringTest.push(name);
+    process.env[name] = value;
+  }
+  afterEach(function () {
+    delete process.env.NAVY_HTTP_PROXY_ENV;
+    while (namesSetDuringTest.length > 0) {
+      delete process.env[namesSetDuringTest.pop()];
+    }
+  });
+  it('should return an empty object when NAVY_HTTP_PROXY_ENV is unset', function () {
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvAllowlist)()).to.eql({});
+  });
+  it('should return an empty object when NAVY_HTTP_PROXY_ENV is empty', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = '';
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvAllowlist)()).to.eql({});
+  });
+  it('should forward a single name whose value is present in process.env', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = 'FORWARD_ME';
+    setEnv('FORWARD_ME', 'hello');
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvAllowlist)()).to.eql({
+      FORWARD_ME: 'hello'
+    });
+  });
+  it('should trim whitespace from comma-separated names', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = '  FOO , BAR  ';
+    setEnv('FOO', 'one');
+    setEnv('BAR', 'two');
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvAllowlist)()).to.eql({
+      FOO: 'one',
+      BAR: 'two'
+    });
+  });
+  it('should deduplicate repeated names', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = 'FOO,FOO,BAR,FOO';
+    setEnv('FOO', 'one');
+    setEnv('BAR', 'two');
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvAllowlist)()).to.eql({
+      FOO: 'one',
+      BAR: 'two'
+    });
+  });
+  it('should drop names whose value is empty or unset', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = 'PRESENT,EMPTY,MISSING';
+    setEnv('PRESENT', 'value');
+    setEnv('EMPTY', '');
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvAllowlist)()).to.eql({
+      PRESENT: 'value'
+    });
+  });
+  it('should ignore empty entries produced by trailing or repeated commas', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = ',FOO,,';
+    setEnv('FOO', 'value');
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnvAllowlist)()).to.eql({
+      FOO: 'value'
+    });
+  });
+});
+describe('resolveProxyEnv', function () {
+  const namesSetDuringTest = [];
+  function setEnv(name, value) {
+    namesSetDuringTest.push(name);
+    process.env[name] = value;
+  }
+  afterEach(function () {
+    delete process.env.NAVY_HTTP_PROXY_ENV;
+    while (namesSetDuringTest.length > 0) {
+      delete process.env[namesSetDuringTest.pop()];
+    }
+  });
+  it('should return null when both sources are empty', function () {
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnv)()).to.equal(null);
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnv)({})).to.equal(null);
+  });
+  it('should return only the navyFile entries when no allowlist is set', function () {
+    const navyFile = {
+      httpProxyEnv: {
+        FOO: 'bar'
+      }
+    };
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnv)(navyFile)).to.eql({
+      FOO: 'bar'
+    });
+  });
+  it('should return only the allowlisted entries when navyFile has none', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = 'FORWARD_ME';
+    setEnv('FORWARD_ME', 'hello');
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnv)()).to.eql({
+      FORWARD_ME: 'hello'
+    });
+  });
+  it('should merge entries from both sources', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = 'FROM_ENV';
+    setEnv('FROM_ENV', 'env-value');
+    const navyFile = {
+      httpProxyEnv: {
+        FROM_FILE: 'file-value'
+      }
+    };
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnv)(navyFile)).to.eql({
+      FROM_FILE: 'file-value',
+      FROM_ENV: 'env-value'
+    });
+  });
+  it('should give the allowlist precedence on key collisions', function () {
+    process.env.NAVY_HTTP_PROXY_ENV = 'SHARED';
+    setEnv('SHARED', 'env-value');
+    const navyFile = {
+      httpProxyEnv: {
+        SHARED: 'file-value'
+      }
+    };
+    (0, _chai.expect)((0, _httpProxy.resolveProxyEnv)(navyFile)).to.eql({
+      SHARED: 'env-value'
+    });
+  });
+});
 describe('resolveDockerSocketPath', function () {
   let originalDockerHost;
   beforeEach(function () {
@@ -211,4 +390,35 @@ describe('reconfigureHTTPProxy', function () {
     const rmCall = execStub.getCalls().find(c => Array.isArray(c.args[1]) && c.args[1].includes('rm'));
     (0, _chai.expect)(rmCall).to.equal(undefined);
   });
+  it('should omit the environment block from the proxy compose service when no env config is provided', async function () {
+    listNetworksStub.resolves([]);
+    await (0, _httpProxy.reconfigureHTTPProxy)({
+      navies: []
+    });
+    const written = _jsYaml.default.load(writeFileSyncStub.firstCall.args[1]);
+    (0, _chai.expect)(written.services['nginx-proxy']).to.not.have.property('environment');
+  });
+  it('should include the merged environment block on the proxy compose service when httpProxyEnv or NAVY_HTTP_PROXY_ENV is set', async function () {
+    listNetworksStub.resolves([]);
+    process.env.NAVY_HTTP_PROXY_ENV = 'FROM_ENV';
+    process.env.FROM_ENV = 'env-value';
+    try {
+      await (0, _httpProxy.reconfigureHTTPProxy)({
+        navies: [],
+        navyFile: {
+          httpProxyEnv: {
+            FROM_FILE: 'file-value'
+          }
+        }
+      });
+      const written = _jsYaml.default.load(writeFileSyncStub.firstCall.args[1]);
+      (0, _chai.expect)(written.services['nginx-proxy'].environment).to.eql({
+        FROM_FILE: 'file-value',
+        FROM_ENV: 'env-value'
+      });
+    } finally {
+      delete process.env.NAVY_HTTP_PROXY_ENV;
+      delete process.env.FROM_ENV;
+    }
+  });
 });

package/lib/cli/__tests__/program.js

@@ -329,6 +329,103 @@ describe('cli/program', function () {
     // exercised in practice. We do not test it because asserting that
     // behaviour would lock in a latent bug.
   });
+  describe('normaliseLazyRequireArgs (via lazyRequire wrapped action)', function () {
+    let importSpy;
+    function loadWithImportSpy() {
+      importSpy = sandbox.stub().resolves('imported');
+      return _proxyquire.default.noCallThru()('../program', {
+        commander: {
+          program: createCapturingProgram()
+        },
+        '../errors': {
+          NavyError: _errors.NavyError
+        },
+        '../config': {
+          getConfig: getConfigStub
+        },
+        '../driver-logging': {
+          startDriverLogging: startDriverLoggingStub,
+          stopDriverLogging: stopDriverLoggingStub
+        },
+        '../config-provider': {
+          getImportCommandLineOptions: getImportCommandLineOptionsStub
+        },
+        '../navy': {
+          getNavy: getNavyStub
+        },
+        './import': importSpy,
+        './launch': () => Promise.resolve(),
+        './ps': () => Promise.resolve(),
+        './updates': () => Promise.resolve(),
+        './logs': () => Promise.resolve(),
+        './health': () => Promise.resolve(),
+        './wait-for-healthy': () => Promise.resolve(),
+        './https': () => Promise.resolve(),
+        './open': () => Promise.resolve(),
+        './develop': () => Promise.resolve(),
+        './live': () => Promise.resolve(),
+        './run': () => Promise.resolve(),
+        './refresh-config': () => Promise.resolve(),
+        './status': () => Promise.resolve(),
+        './doctor': () => Promise.resolve(),
+        './config/wrapper': () => Promise.resolve(),
+        './external-ip': () => Promise.resolve(),
+        './lan-ip': () => Promise.resolve(),
+        './local-ip': () => Promise.resolve()
+      });
+    }
+    it('should pass through unchanged when invoked with no arguments at all', async function () {
+      loadWithImportSpy();
+      capturedActions.import();
+      await new Promise(resolve => setImmediate(resolve));
+      (0, _chai.expect)(importSpy.calledOnce).to.equal(true);
+      (0, _chai.expect)(importSpy.firstCall.args).to.eql([]);
+    });
+    it('should strip the trailing Command instance when no other args were supplied', async function () {
+      loadWithImportSpy();
+      const fakeCommand = {
+        optsWithGlobals: () => ({
+          navy: 'global'
+        })
+      };
+      capturedActions.import(fakeCommand);
+      await new Promise(resolve => setImmediate(resolve));
+      (0, _chai.expect)(importSpy.calledOnce).to.equal(true);
+      (0, _chai.expect)(importSpy.firstCall.args).to.eql([]);
+    });
+    it('should merge inherited globals into the trailing options object before forwarding', async function () {
+      loadWithImportSpy();
+      const fakeCommand = {
+        optsWithGlobals: () => ({
+          navy: 'from-global',
+          extra: 1
+        }),
+        getOptionValueSource: () => 'default'
+      };
+      capturedActions.import({
+        navy: 'subcommand-default'
+      }, fakeCommand);
+      await new Promise(resolve => setImmediate(resolve));
+      (0, _chai.expect)(importSpy.calledOnce).to.equal(true);
+      (0, _chai.expect)(importSpy.firstCall.args).to.have.lengthOf(1);
+      (0, _chai.expect)(importSpy.firstCall.args[0]).to.eql({
+        navy: 'from-global',
+        extra: 1
+      });
+    });
+    it('should leave non-object trailing arguments untouched when stripping the command', async function () {
+      loadWithImportSpy();
+      const fakeCommand = {
+        optsWithGlobals: () => ({
+          navy: 'global'
+        })
+      };
+      capturedActions.import(['web', 'api'], fakeCommand);
+      await new Promise(resolve => setImmediate(resolve));
+      (0, _chai.expect)(importSpy.calledOnce).to.equal(true);
+      (0, _chai.expect)(importSpy.firstCall.args).to.eql([['web', 'api']]);
+    });
+  });
   describe('basicCliWrapper action', function () {
     beforeEach(function () {
       loadModule();
@@ -354,6 +451,18 @@ describe('cli/program', function () {
       }, fakeCommand);
       (0, _chai.expect)(getNavyStub.firstCall.args[0]).to.equal('from-global');
     });
+    it('should fall back to maybeServices as opts when only an opts object and command are passed', async function () {
+      navyStub.getAvailableServiceNames = sandbox.stub().resolves([]);
+      const fakeCommand = {
+        optsWithGlobals: () => ({
+          navy: 'from-global'
+        })
+      };
+      await actionsByCommand['available-services']({
+        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([], {

package/lib/http-proxy.js

@@ -6,6 +6,9 @@ Object.defineProperty(exports, "__esModule", {
 });
 exports.reconfigureHTTPProxy = reconfigureHTTPProxy;
 exports.resolveDockerSocketPath = resolveDockerSocketPath;
+exports.resolveProxyEnv = resolveProxyEnv;
+exports.resolveProxyEnvAllowlist = resolveProxyEnvAllowlist;
+exports.resolveProxyEnvFromNavyFile = resolveProxyEnvFromNavyFile;
 exports.resolveProxyImage = resolveProxyImage;
 var _os = _interopRequireDefault(require("os"));
 var _path = _interopRequireDefault(require("path"));
@@ -21,6 +24,43 @@ const DEFAULT_DOCKER_SOCKET = '/var/run/docker.sock';
 function resolveProxyImage(navyFile) {
   return process.env.NAVY_HTTP_PROXY_IMAGE || navyFile && navyFile.httpProxyImage || DEFAULT_PROXY_IMAGE;
 }
+function resolveProxyEnvFromNavyFile(navyFile) {
+  if (!navyFile) return {};
+  const raw = navyFile.httpProxyEnv;
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
+  const result = {};
+  for (const key of Object.keys(raw)) {
+    const value = raw[key];
+    if (value === null || value === undefined) continue;
+    const coerced = String(value);
+    if (coerced === '') continue;
+    result[key] = coerced;
+  }
+  return result;
+}
+function resolveProxyEnvAllowlist() {
+  const allowlist = process.env.NAVY_HTTP_PROXY_ENV;
+  if (!allowlist) return {};
+  const seen = new Set();
+  const result = {};
+  for (const rawName of allowlist.split(',')) {
+    const name = rawName.trim();
+    if (!name || seen.has(name)) continue;
+    seen.add(name);
+    const value = process.env[name];
+    if (typeof value !== 'string' || value === '') continue;
+    result[name] = value;
+  }
+  return result;
+}
+function resolveProxyEnv(navyFile) {
+  const merged = {
+    ...resolveProxyEnvFromNavyFile(navyFile),
+    ...resolveProxyEnvAllowlist()
+  };
+  if (Object.keys(merged).length === 0) return null;
+  return merged;
+}
 
 // Resolve the host path to the Docker socket. The proxy container needs to
 // read events from the same daemon as the rest of navy, so we honour
@@ -61,6 +101,7 @@ async function updateComposeConfig(navies, navyFile) {
     volumes.push(`${certsPath}:/etc/nginx/certs`);
     volumes.push(`${certsPath}:/etc/nginx/dhparam`); // to persist DH params
   }
+  const proxyEnv = resolveProxyEnv(navyFile);
   const config = {
     version: '2',
     services: {
@@ -69,6 +110,9 @@ async function updateComposeConfig(navies, navyFile) {
         ports,
         networks: networks.map(net => net.Name),
         volumes,
+        ...(proxyEnv ? {
+          environment: proxyEnv
+        } : {}),
         restart: 'always'
       }
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "navy",
-  "version": "7.0.0-alpha.3",
+  "version": "7.0.0-alpha.4",
   "description": "Quick and powerful development environments using Docker and Docker Compose",
   "main": "lib/index.js",
   "types": "lib/index.d.ts",