navy 6.0.0 → 7.0.0-alpha.2

package/lib/middleware/__tests__/helpers.js

@@ -0,0 +1,154 @@
+"use strict";
+
+var _chai = require("chai");
+var _helpers = require("../helpers");
+/* eslint-env mocha */
+
+describe('middlewareHelpers', function () {
+  describe('rewriteServices', function () {
+    it('should map every service in config.services through the mapper, preserving config', function () {
+      const config = {
+        version: '3',
+        services: {
+          api: {
+            image: 'api:1',
+            ports: ['80']
+          },
+          web: {
+            image: 'web:1'
+          }
+        },
+        networks: {
+          default: {}
+        }
+      };
+      const result = _helpers.middlewareHelpers.rewriteServices(config, (service, name) => ({
+        ...service,
+        image: name + '-rewritten'
+      }));
+      (0, _chai.expect)(result).to.have.property('version', '3');
+      (0, _chai.expect)(result).to.have.property('networks').that.eql({
+        default: {}
+      });
+      (0, _chai.expect)(result.services.api).to.eql({
+        image: 'api-rewritten',
+        ports: ['80']
+      });
+      (0, _chai.expect)(result.services.web).to.eql({
+        image: 'web-rewritten'
+      });
+    });
+    it('should treat a missing services property as an empty object', function () {
+      const result = _helpers.middlewareHelpers.rewriteServices({}, () => ({}));
+      (0, _chai.expect)(result).to.have.property('services').that.eql({});
+    });
+  });
+  describe('rewriteServicesWithState', function () {
+    it('should pass per-service state into the mapper', function () {
+      const config = {
+        services: {
+          api: {
+            image: 'api'
+          }
+        }
+      };
+      const state = {
+        services: {
+          api: {
+            _ports: {
+              80: 8080
+            }
+          }
+        }
+      };
+      const result = _helpers.middlewareHelpers.rewriteServicesWithState(config, state, (service, name, serviceState) => ({
+        ...service,
+        meta: {
+          name,
+          hasState: !!serviceState,
+          ports: serviceState && serviceState._ports
+        }
+      }));
+      (0, _chai.expect)(result.services.api.meta).to.eql({
+        name: 'api',
+        hasState: true,
+        ports: {
+          80: 8080
+        }
+      });
+    });
+    it('should pass undefined service state when the service is not in state', function () {
+      const config = {
+        services: {
+          web: {
+            image: 'web'
+          }
+        }
+      };
+      const state = {
+        services: {}
+      };
+      const result = _helpers.middlewareHelpers.rewriteServicesWithState(config, state, (service, name, serviceState) => ({
+        ...service,
+        seenState: serviceState
+      }));
+      (0, _chai.expect)(result.services.web.seenState).to.equal(undefined);
+    });
+    it('should normalise a null state to an empty services map', function () {
+      const config = {
+        services: {
+          api: {
+            image: 'api'
+          }
+        }
+      };
+      const result = _helpers.middlewareHelpers.rewriteServicesWithState(config, null, (service, name, serviceState) => ({
+        ...service,
+        seenState: serviceState
+      }));
+      (0, _chai.expect)(result.services.api.seenState).to.equal(undefined);
+    });
+    it('should preserve other keys on the config object', function () {
+      const config = {
+        version: '3',
+        services: {},
+        volumes: {
+          v1: {}
+        }
+      };
+      const result = _helpers.middlewareHelpers.rewriteServicesWithState(config, {
+        services: {}
+      }, s => s);
+      (0, _chai.expect)(result.version).to.equal('3');
+      (0, _chai.expect)(result.volumes).to.eql({
+        v1: {}
+      });
+    });
+    it('should treat a missing services property on config as an empty object', function () {
+      const result = _helpers.middlewareHelpers.rewriteServicesWithState({}, {
+        services: {}
+      }, () => ({}));
+      (0, _chai.expect)(result).to.have.property('services').that.eql({});
+    });
+  });
+  describe('addVolumes', function () {
+    it('should append the new volumes to existing service volumes', function () {
+      const result = _helpers.middlewareHelpers.addVolumes({
+        volumes: ['./local:/app']
+      }, ['./extra:/extra']);
+      (0, _chai.expect)(result).to.eql(['./local:/app', './extra:/extra']);
+    });
+    it('should treat a missing volumes property as an empty array', function () {
+      const result = _helpers.middlewareHelpers.addVolumes({}, ['./extra:/extra']);
+      (0, _chai.expect)(result).to.eql(['./extra:/extra']);
+    });
+    it('should not mutate the existing volumes array on the service', function () {
+      const original = ['./local:/app'];
+      const service = {
+        volumes: original
+      };
+      _helpers.middlewareHelpers.addVolumes(service, ['./extra:/extra']);
+      (0, _chai.expect)(original).to.eql(['./local:/app']);
+    });
+  });
+});

package/lib/middleware/__tests__/port-override.js

@@ -0,0 +1,125 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _portOverride = _interopRequireDefault(require("../port-override"));
+/* eslint-env mocha */
+
+describe('port-override middleware', function () {
+  it('should leave service.ports untouched when no port state exists', function () {
+    const config = {
+      services: {
+        api: {
+          ports: ['80:80']
+        }
+      }
+    };
+    const state = {
+      services: {}
+    };
+    const result = (0, _portOverride.default)(config, state);
+    (0, _chai.expect)(result.services.api.ports).to.eql(['80:80']);
+  });
+  it('should leave ports untouched when state has the service but no _ports', function () {
+    const config = {
+      services: {
+        api: {
+          ports: ['80:80']
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {}
+      }
+    };
+    const result = (0, _portOverride.default)(config, state);
+    (0, _chai.expect)(result.services.api.ports).to.eql(['80:80']);
+  });
+  it('should override an internal port mapping with the configured external port', function () {
+    const config = {
+      services: {
+        api: {
+          ports: ['80', '443']
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {
+          _ports: {
+            80: 8080
+          }
+        }
+      }
+    };
+    const result = (0, _portOverride.default)(config, state);
+    (0, _chai.expect)(result.services.api.ports).to.include('443');
+    (0, _chai.expect)(result.services.api.ports).to.include('8080:80');
+    (0, _chai.expect)(result.services.api.ports).to.not.include('80');
+  });
+  it('should drop entries whose external port is falsy when port state exists', function () {
+    const config = {
+      services: {
+        api: {
+          ports: ['80', '443']
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {
+          _ports: {
+            80: undefined,
+            443: 4433
+          }
+        }
+      }
+    };
+    const result = (0, _portOverride.default)(config, state);
+    (0, _chai.expect)(result.services.api.ports).to.eql(['80', '4433:443']);
+  });
+  it('should produce an empty ports list when service.ports is missing and there are no internal overrides', function () {
+    const config = {
+      services: {
+        api: {}
+      }
+    };
+    const state = {
+      services: {
+        api: {
+          _ports: {
+            80: undefined
+          }
+        }
+      }
+    };
+    const result = (0, _portOverride.default)(config, state);
+    (0, _chai.expect)(result.services.api.ports).to.eql([]);
+  });
+  it('should set ports to an empty array when neither the service nor state declare any ports', function () {
+    const config = {
+      services: {
+        api: {}
+      }
+    };
+    const state = {
+      services: {}
+    };
+    const result = (0, _portOverride.default)(config, state);
+    (0, _chai.expect)(result.services.api.ports).to.eql([]);
+  });
+  it('should preserve top-level config keys', function () {
+    const config = {
+      version: '3',
+      services: {
+        api: {}
+      }
+    };
+    const state = {
+      services: {}
+    };
+    const result = (0, _portOverride.default)(config, state);
+    (0, _chai.expect)(result).to.have.property('version', '3');
+  });
+});

package/lib/middleware/__tests__/set-env-vars.js

@@ -0,0 +1,94 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _setEnvVars = _interopRequireDefault(require("../set-env-vars"));
+/* eslint-env mocha */
+
+describe('set-env-vars middleware', function () {
+  it('should leave the service environment unchanged when no state exists for it', function () {
+    const config = {
+      services: {
+        api: {
+          environment: {
+            FOO: 'bar'
+          }
+        }
+      }
+    };
+    const state = {
+      services: {}
+    };
+    const result = (0, _setEnvVars.default)(config, state);
+    (0, _chai.expect)(result.services.api.environment).to.eql({
+      FOO: 'bar'
+    });
+  });
+  it('should merge state.services[name].environment over the config environment', function () {
+    const config = {
+      services: {
+        api: {
+          environment: {
+            FOO: 'bar',
+            BAZ: 'qux'
+          }
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {
+          environment: {
+            FOO: 'overridden',
+            NEW: 'value'
+          }
+        }
+      }
+    };
+    const result = (0, _setEnvVars.default)(config, state);
+    (0, _chai.expect)(result.services.api.environment).to.eql({
+      FOO: 'overridden',
+      BAZ: 'qux',
+      NEW: 'value'
+    });
+  });
+  it('should produce an empty environment when neither config nor state defines one', function () {
+    const config = {
+      services: {
+        api: {}
+      }
+    };
+    const state = {
+      services: {}
+    };
+    const result = (0, _setEnvVars.default)(config, state);
+    (0, _chai.expect)(result.services.api.environment).to.eql({});
+  });
+  it('should preserve service config keys other than environment', function () {
+    const config = {
+      services: {
+        api: {
+          image: 'api:1',
+          environment: {
+            A: '1'
+          }
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {
+          environment: {
+            B: '2'
+          }
+        }
+      }
+    };
+    const result = (0, _setEnvVars.default)(config, state);
+    (0, _chai.expect)(result.services.api.image).to.equal('api:1');
+    (0, _chai.expect)(result.services.api.environment).to.eql({
+      A: '1',
+      B: '2'
+    });
+  });
+});

package/lib/middleware/__tests__/set-image.js

@@ -0,0 +1,76 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _setImage = _interopRequireDefault(require("../set-image"));
+/* eslint-env mocha */
+
+describe('set-image middleware', function () {
+  it('should leave the image unchanged when no state image is set', function () {
+    const config = {
+      services: {
+        api: {
+          image: 'api:1'
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {}
+      }
+    };
+    const result = (0, _setImage.default)(config, state);
+    (0, _chai.expect)(result.services.api.image).to.equal('api:1');
+  });
+  it('should leave the image unchanged when there is no service state at all', function () {
+    const config = {
+      services: {
+        api: {
+          image: 'api:1'
+        }
+      }
+    };
+    const state = {
+      services: {}
+    };
+    const result = (0, _setImage.default)(config, state);
+    (0, _chai.expect)(result.services.api.image).to.equal('api:1');
+  });
+  it('should override the image when state has one', function () {
+    const config = {
+      services: {
+        api: {
+          image: 'api:1'
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {
+          image: 'api:override'
+        }
+      }
+    };
+    const result = (0, _setImage.default)(config, state);
+    (0, _chai.expect)(result.services.api.image).to.equal('api:override');
+  });
+  it('should preserve other service config keys', function () {
+    const config = {
+      services: {
+        api: {
+          image: 'api:1',
+          ports: ['80:80']
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {
+          image: 'api:override'
+        }
+      }
+    };
+    const result = (0, _setImage.default)(config, state);
+    (0, _chai.expect)(result.services.api.ports).to.eql(['80:80']);
+  });
+});

package/lib/middleware/__tests__/set-logging-driver.js

@@ -0,0 +1,94 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _setLoggingDriver = _interopRequireDefault(require("../set-logging-driver"));
+/* eslint-env mocha */
+
+describe('set-logging-driver middleware', function () {
+  it('should produce an empty logging object when neither config nor state set one', function () {
+    const config = {
+      services: {
+        api: {}
+      }
+    };
+    const state = {
+      services: {}
+    };
+    const result = (0, _setLoggingDriver.default)(config, state);
+    (0, _chai.expect)(result.services.api.logging).to.eql({});
+  });
+  it('should pass the config logging through when state has no logging entry', function () {
+    const config = {
+      services: {
+        api: {
+          logging: {
+            driver: 'json-file'
+          }
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {}
+      }
+    };
+    const result = (0, _setLoggingDriver.default)(config, state);
+    (0, _chai.expect)(result.services.api.logging).to.eql({
+      driver: 'json-file'
+    });
+  });
+  it('should merge state logging over config logging', function () {
+    const config = {
+      services: {
+        api: {
+          logging: {
+            driver: 'json-file',
+            options: {
+              'max-size': '10m'
+            }
+          }
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {
+          logging: {
+            driver: 'syslog'
+          }
+        }
+      }
+    };
+    const result = (0, _setLoggingDriver.default)(config, state);
+    (0, _chai.expect)(result.services.api.logging).to.eql({
+      driver: 'syslog',
+      options: {
+        'max-size': '10m'
+      }
+    });
+  });
+  it('should preserve other service config keys', function () {
+    const config = {
+      services: {
+        api: {
+          image: 'api:1'
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {
+          logging: {
+            driver: 'syslog'
+          }
+        }
+      }
+    };
+    const result = (0, _setLoggingDriver.default)(config, state);
+    (0, _chai.expect)(result.services.api.image).to.equal('api:1');
+    (0, _chai.expect)(result.services.api.logging).to.eql({
+      driver: 'syslog'
+    });
+  });
+});

package/lib/middleware/__tests__/tag-override.js

@@ -0,0 +1,92 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+var _chai = require("chai");
+var _tagOverride = _interopRequireDefault(require("../tag-override"));
+/* eslint-env mocha */
+
+describe('tag-override middleware', function () {
+  it('should add the tag when service image has no tag', function () {
+    const config = {
+      services: {
+        api: {
+          image: 'navy/api'
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {
+          _tag: 'v1.2.3'
+        }
+      }
+    };
+    const result = (0, _tagOverride.default)(config, state);
+    (0, _chai.expect)(result.services.api.image).to.equal('navy/api:v1.2.3');
+  });
+  it('should replace an existing tag with the override', function () {
+    const config = {
+      services: {
+        api: {
+          image: 'navy/api:old'
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {
+          _tag: 'new'
+        }
+      }
+    };
+    const result = (0, _tagOverride.default)(config, state);
+    (0, _chai.expect)(result.services.api.image).to.equal('navy/api:new');
+  });
+  it('should leave the image untouched when state has no _tag for the service', function () {
+    const config = {
+      services: {
+        api: {
+          image: 'navy/api:old'
+        }
+      }
+    };
+    const state = {
+      services: {
+        api: {}
+      }
+    };
+    const result = (0, _tagOverride.default)(config, state);
+    (0, _chai.expect)(result.services.api.image).to.equal('navy/api:old');
+  });
+  it('should ignore state services that have no matching service in config', function () {
+    const config = {
+      services: {
+        api: {
+          image: 'api:1'
+        }
+      }
+    };
+    const state = {
+      services: {
+        web: {
+          _tag: 'lts'
+        }
+      }
+    };
+    const result = (0, _tagOverride.default)(config, state);
+    (0, _chai.expect)(result.services.api.image).to.equal('api:1');
+    (0, _chai.expect)(result.services).to.not.have.property('web');
+  });
+  it('should treat a missing state.services as an empty object', function () {
+    const config = {
+      services: {
+        api: {
+          image: 'api:1'
+        }
+      }
+    };
+    const state = {};
+    const result = (0, _tagOverride.default)(config, state);
+    (0, _chai.expect)(result.services.api.image).to.equal('api:1');
+  });
+});

package/lib/middleware/add-service-proxy-config.js

@@ -4,21 +4,15 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.default = void 0;
-
 var _lodash = require("lodash");
-
 var _serviceHost = require("../util/service-host");
-
 var _https = require("../util/https");
-
 const getServiceHTTPProxyConfig = (serviceName, navyFile) => {
   if (navyFile && navyFile.httpProxy && navyFile.httpProxy[serviceName]) {
     return navyFile.httpProxy[serviceName];
   }
-
   return null;
 };
-
 const serviceGetAutoProxyPortOr80 = (service, navyFile) => {
   const autoPorts = navyFile && Array.isArray(navyFile.httpProxyAutoPorts) && navyFile.httpProxyAutoPorts || ['80'];
   return service.ports && (0, _lodash.find)(autoPorts, autoPort => {
@@ -32,45 +26,43 @@ const serviceGetAutoProxyPortOr80 = (service, navyFile) => {
     });
   });
 };
-
 var _default = navy => async (config, state) => {
   const navyFile = await navy.getNavyFile();
   const services = {};
   const externalIP = await navy.externalIP();
   await Promise.all(Object.keys(config.services).map(async serviceName => {
     const service = config.services[serviceName];
-    let proxyConfig = getServiceHTTPProxyConfig(serviceName, navyFile); // proxy port 80 even without service config, or a different port with config httpProxyAutoPorts
+    let proxyConfig = getServiceHTTPProxyConfig(serviceName, navyFile);
 
+    // proxy port 80 even without service config, or a different port with config httpProxyAutoPorts
     if (!proxyConfig) {
       const autoPort = serviceGetAutoProxyPortOr80(service, navyFile);
-
       if (autoPort) {
         proxyConfig = {
           port: parseInt(autoPort)
         };
       }
     }
-
     if (proxyConfig) {
       const hostName = await (0, _serviceHost.createHostForService)(serviceName, navy.normalisedName, externalIP);
       if (proxyConfig.enableHttps) await (0, _https.createCert)({
         hostName
       });
-      return services[serviceName] = { ...service,
+      return services[serviceName] = {
+        ...service,
         environment: {
-          'VIRTUAL_HOST': hostName,
-          'VIRTUAL_PORT': proxyConfig.port,
+          VIRTUAL_HOST: hostName,
+          VIRTUAL_PORT: proxyConfig.port,
           ...service.environment
         }
       };
     }
-
     return services[serviceName] = service;
   }));
-  return { ...config,
+  return {
+    ...config,
     services
   };
 };
-
 exports.default = _default;
 module.exports = exports.default;