ui: Improve configuration/env/feature flag usage (also add build time year detection) (#7072)

* Add new getEnvironment util/function

* Use new-ish `env` function in all the places

* Clean up ember env file, add year detection from commit date
pull/7099/head
John Cowen 5 years ago committed by GitHub
parent ac613993bb
commit a65d941e76
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23

@ -1,61 +1,3 @@
import _config from './config/environment'; import config from './config/environment';
const doc = document; import getEnvironment from './utils/get-environment';
const getDevEnvVars = function() { export const env = getEnvironment(config, window, document);
return doc.cookie
.split(';')
.filter(item => item !== '')
.map(item => item.trim().split('='));
};
const getUserEnvVar = function(str) {
return window.localStorage.getItem(str);
};
// TODO: Look at `services/client` for pulling
// HTTP headers in here so we can let things be controlled
// via HTTP proxies, for example turning off blocking
// queries if its a busy cluster
// const getOperatorEnvVars = function() {}
// TODO: Not necessarily here but the entire app should
// use the `env` export not the `default` one
// but we might also change the name of this file, so wait for that first
export const env = function(str) {
let user = null;
switch (str) {
case 'CONSUL_UI_DISABLE_REALTIME':
case 'CONSUL_UI_DISABLE_ANCHOR_SELECTION':
case 'CONSUL_UI_REALTIME_RUNNER':
user = getUserEnvVar(str);
break;
}
// We use null here instead of an undefined check
// as localStorage will return null if not set
return user !== null ? user : _config[str];
};
export const config = function(key) {
let $;
switch (_config.environment) {
case 'development':
case 'staging':
case 'test':
$ = getDevEnvVars().reduce(function(prev, [key, value]) {
const val = !!JSON.parse(String(value).toLowerCase());
switch (key) {
case 'CONSUL_ACLS_ENABLE':
prev['CONSUL_ACLS_ENABLED'] = val;
break;
case 'CONSUL_NSPACES_ENABLE':
prev['CONSUL_NSPACES_ENABLED'] = val;
break;
default:
prev[key] = value;
}
return prev;
}, {});
if (typeof $[key] !== 'undefined') {
return $[key];
}
break;
}
return _config[key];
};
export default env;

@ -1,9 +1,6 @@
import { helper } from '@ember/component/helper'; import { helper } from '@ember/component/helper';
import { config } from 'consul-ui/env'; import { env } from 'consul-ui/env';
// TODO: env actually uses config values not env values export default helper(function([name, def = ''], hash) {
// see `app/env` for the renaming TODO's also const val = env(name);
export function env([name, def = ''], hash) { return val != null ? val : def;
return config(name) != null ? config(name) : def; });
}
export default helper(env);

@ -1,15 +0,0 @@
const scripts = document.getElementsByTagName('script');
const current = scripts[scripts.length - 1];
export function initialize(application) {
const Client = application.resolveRegistration('service:client/http');
Client.reopen({
isCurrent: function(src) {
return current.src === src;
},
});
}
export default {
initialize,
};

@ -1,5 +1,5 @@
import Route from '@ember/routing/route'; import Route from '@ember/routing/route';
import { config } from 'consul-ui/env'; import { env } from 'consul-ui/env';
import { routes } from 'consul-ui/router'; import { routes } from 'consul-ui/router';
import flat from 'flat'; import flat from 'flat';
@ -26,7 +26,7 @@ Route.reopen(
return prev; return prev;
}, {}) }, {})
); );
if (config('CONSUL_NSPACES_ENABLED')) { if (env('CONSUL_NSPACES_ENABLED')) {
const dotRe = /\./g; const dotRe = /\./g;
initialize = function(container) { initialize = function(container) {
const all = Object.keys(flat(routes)) const all = Object.keys(flat(routes))

@ -1,11 +1,11 @@
import env, { config } from 'consul-ui/env'; import { env } from 'consul-ui/env';
export function initialize(container) { export function initialize(container) {
if (env('CONSUL_UI_DISABLE_REALTIME')) { if (env('CONSUL_UI_DISABLE_REALTIME')) {
return; return;
} }
['node', 'coordinate', 'session', 'service', 'proxy', 'discovery-chain'] ['node', 'coordinate', 'session', 'service', 'proxy', 'discovery-chain']
.concat(config('CONSUL_NSPACES_ENABLED') ? ['nspace/enabled'] : []) .concat(env('CONSUL_NSPACES_ENABLED') ? ['nspace/enabled'] : [])
.map(function(item) { .map(function(item) {
// create repositories that return a promise resolving to an EventSource // create repositories that return a promise resolving to an EventSource
return { return {
@ -79,7 +79,7 @@ export function initialize(container) {
}, },
]) ])
.concat( .concat(
config('CONSUL_NSPACES_ENABLED') env('CONSUL_NSPACES_ENABLED')
? [ ? [
{ {
route: 'dc/nspaces/index', route: 'dc/nspaces/index',
@ -104,7 +104,7 @@ export function initialize(container) {
// but hardcode this for the moment // but hardcode this for the moment
if (typeof definition.route !== 'undefined') { if (typeof definition.route !== 'undefined') {
container.inject(`route:${definition.route}`, name, `service:${servicePath}`); container.inject(`route:${definition.route}`, name, `service:${servicePath}`);
if (config('CONSUL_NSPACES_ENABLED') && definition.route.startsWith('dc/')) { if (env('CONSUL_NSPACES_ENABLED') && definition.route.startsWith('dc/')) {
container.inject(`route:nspace/${definition.route}`, name, `service:${servicePath}`); container.inject(`route:nspace/${definition.route}`, name, `service:${servicePath}`);
} }
} else { } else {

@ -1,6 +1,6 @@
import { config } from 'consul-ui/env'; import { env } from 'consul-ui/env';
export function initialize(container) { export function initialize(container) {
if (config('CONSUL_NSPACES_ENABLED')) { if (env('CONSUL_NSPACES_ENABLED')) {
['dc', 'settings', 'dc.intentions.edit', 'dc.intentions.create'].forEach(function(item) { ['dc', 'settings', 'dc.intentions.edit', 'dc.intentions.create'].forEach(function(item) {
container.inject(`route:${item}`, 'nspacesRepo', 'service:repository/nspace/enabled'); container.inject(`route:${item}`, 'nspacesRepo', 'service:repository/nspace/enabled');
container.inject(`route:nspace.${item}`, 'nspacesRepo', 'service:repository/nspace/enabled'); container.inject(`route:nspace.${item}`, 'nspacesRepo', 'service:repository/nspace/enabled');
@ -15,7 +15,7 @@ export function initialize(container) {
// 1. Make it be about adding classes to the root dom node // 1. Make it be about adding classes to the root dom node
// 2. Make it be about config and things to do on initialization re: config // 2. Make it be about config and things to do on initialization re: config
// If we go with 1 then we need to move both this and the above nspaces class // If we go with 1 then we need to move both this and the above nspaces class
if (config('CONSUL_ACLS_ENABLED')) { if (env('CONSUL_ACLS_ENABLED')) {
container container
.lookup('service:dom') .lookup('service:dom')
.root() .root()

@ -1,4 +1,4 @@
import env from 'consul-ui/env'; import { env } from 'consul-ui/env';
const SECONDARY_BUTTON = 2; const SECONDARY_BUTTON = 2;
const isSelecting = function(win = window) { const isSelecting = function(win = window) {

@ -1,10 +1,10 @@
import EmberRouter from '@ember/routing/router'; import EmberRouter from '@ember/routing/router';
import { config } from 'consul-ui/env'; import { env } from 'consul-ui/env';
import walk from 'consul-ui/utils/routing/walk'; import walk from 'consul-ui/utils/routing/walk';
const Router = EmberRouter.extend({ const Router = EmberRouter.extend({
location: config('locationType'), location: env('locationType'),
rootURL: config('rootURL'), rootURL: env('rootURL'),
}); });
export const routes = { export const routes = {
// Our parent datacenter resource sets the namespace // Our parent datacenter resource sets the namespace
@ -107,7 +107,7 @@ export const routes = {
_options: { path: '/*path' }, _options: { path: '/*path' },
}, },
}; };
if (config('CONSUL_NSPACES_ENABLED')) { if (env('CONSUL_NSPACES_ENABLED')) {
routes.dc.nspaces = { routes.dc.nspaces = {
_options: { path: '/namespaces' }, _options: { path: '/namespaces' },
edit: { edit: {

@ -1,6 +1,6 @@
import Route from '@ember/routing/route'; import Route from '@ember/routing/route';
import { get } from '@ember/object'; import { get } from '@ember/object';
import { config } from 'consul-ui/env'; import { env } from 'consul-ui/env';
import { inject as service } from '@ember/service'; import { inject as service } from '@ember/service';
import WithBlockingActions from 'consul-ui/mixins/with-blocking-actions'; import WithBlockingActions from 'consul-ui/mixins/with-blocking-actions';
export default Route.extend(WithBlockingActions, { export default Route.extend(WithBlockingActions, {
@ -32,9 +32,9 @@ export default Route.extend(WithBlockingActions, {
return false; return false;
}); });
} else { } else {
// TODO: Ideally we wouldn't need to use config() at a route level // TODO: Ideally we wouldn't need to use env() at a route level
// transitionTo should probably remove it instead if NSPACES aren't enabled // transitionTo should probably remove it instead if NSPACES aren't enabled
if (config('CONSUL_NSPACES_ENABLED') && get(item, 'token.Namespace') !== nspace) { if (env('CONSUL_NSPACES_ENABLED') && get(item, 'token.Namespace') !== nspace) {
let routeName = this.router.currentRouteName; let routeName = this.router.currentRouteName;
if (!routeName.startsWith('nspace')) { if (!routeName.startsWith('nspace')) {
routeName = `nspace.${routeName}`; routeName = `nspace.${routeName}`;

@ -3,6 +3,7 @@ import Service, { inject as service } from '@ember/service';
import { get, set } from '@ember/object'; import { get, set } from '@ember/object';
import { Promise } from 'rsvp'; import { Promise } from 'rsvp';
import { env } from 'consul-ui/env';
import getObjectPool from 'consul-ui/utils/get-object-pool'; import getObjectPool from 'consul-ui/utils/get-object-pool';
import Request from 'consul-ui/utils/http/request'; import Request from 'consul-ui/utils/http/request';
import createURL from 'consul-ui/utils/createURL'; import createURL from 'consul-ui/utils/createURL';
@ -41,31 +42,7 @@ export default Service.extend({
settings: service('settings'), settings: service('settings'),
init: function() { init: function() {
this._super(...arguments); this._super(...arguments);
let protocol = 'http/1.1'; const maxConnections = env('CONSUL_HTTP_MAX_CONNECTIONS');
try {
protocol = performance.getEntriesByType('resource').find(item => {
// isCurrent is added in initializers/client and is used
// to ensure we use the consul-ui.js src to sniff what the protocol
// is. Based on the assumption that whereever this script is it's
// likely to be the same as the xmlhttprequests
return item.initiatorType === 'script' && this.isCurrent(item.name);
}).nextHopProtocol;
} catch (e) {
// pass through
}
let maxConnections;
// http/2, http2+QUIC/39 and SPDY don't have connection limits
switch (true) {
case protocol.indexOf('h2') === 0:
case protocol.indexOf('hq') === 0:
case protocol.indexOf('spdy') === 0:
break;
default:
// generally 6 are available
// reserve 1 for traffic that we can't manage
maxConnections = 5;
break;
}
set(this, 'connections', getObjectPool(dispose, maxConnections)); set(this, 'connections', getObjectPool(dispose, maxConnections));
if (typeof maxConnections !== 'undefined') { if (typeof maxConnections !== 'undefined') {
set(this, 'maxConnections', maxConnections); set(this, 'maxConnections', maxConnections);

@ -1,6 +1,6 @@
import { inject as service } from '@ember/service'; import { inject as service } from '@ember/service';
import { get } from '@ember/object'; import { get } from '@ember/object';
import { config } from 'consul-ui/env'; import { env } from 'consul-ui/env';
import RepositoryService from 'consul-ui/services/repository'; import RepositoryService from 'consul-ui/services/repository';
const modelName = 'nspace'; const modelName = 'nspace';
@ -18,7 +18,7 @@ export default RepositoryService.extend({
return this.store.query(this.getModelName(), query); return this.store.query(this.getModelName(), query);
}, },
authorize: function(dc, nspace) { authorize: function(dc, nspace) {
if (!config('CONSUL_ACLS_ENABLED')) { if (!env('CONSUL_ACLS_ENABLED')) {
return Promise.resolve([ return Promise.resolve([
{ {
Resource: 'operator', Resource: 'operator',

@ -18,7 +18,7 @@ import StorageEventSourceFactory from 'consul-ui/utils/dom/event-source/storage'
import EmberObject from '@ember/object'; import EmberObject from '@ember/object';
import { task } from 'ember-concurrency'; import { task } from 'ember-concurrency';
import env from 'consul-ui/env'; import { env } from 'consul-ui/env';
let runner; let runner;
switch (env('CONSUL_UI_REALTIME_RUNNER')) { switch (env('CONSUL_UI_REALTIME_RUNNER')) {

@ -0,0 +1,100 @@
export default function(config = {}, win = window, doc = document) {
const dev = function() {
return doc.cookie
.split(';')
.filter(item => item !== '')
.map(item => item.trim().split('='));
};
const user = function(str) {
const item = win.localStorage.getItem(str);
return item === null ? undefined : item;
};
const getCurrentResource = function(scripts) {
const current = scripts[scripts.length - 1];
try {
return win.performance.getEntriesByType('resource').find(item => {
// current is based on the assumption that whereever this script is it's
// likely to be the same as the xmlhttprequests
return item.initiatorType === 'script' && current.src === item.name;
});
} catch (e) {
return {};
}
};
const resource = getCurrentResource(doc.getElementsByTagName('script'));
// TODO: Look to see if we can pull in HTTP headers here
// so we can let things be controlled via HTTP proxies, for example
// turning off blocking queries if its a busy cluster etc
const operator = function(str, env) {
let protocol;
switch (str) {
case 'CONSUL_HTTP_PROTOCOL':
return resource.nextHopProtocol || 'http/1.1';
case 'CONSUL_HTTP_MAX_CONNECTIONS':
protocol = env('CONSUL_HTTP_PROTOCOL');
// http/2, http2+QUIC/39 and SPDY don't have connection limits
switch (true) {
case protocol.indexOf('h2') === 0:
case protocol.indexOf('hq') === 0:
case protocol.indexOf('spdy') === 0:
// TODO: Change this to return -1 so we try to consistently
// return a value from env vars
return;
default:
// generally 6 are available
// reserve 1 for traffic that we can't manage
return 5;
}
}
};
const ui = function(key) {
let $;
switch (config.environment) {
case 'development':
case 'staging':
case 'coverage':
case 'test':
$ = dev().reduce(function(prev, [key, value]) {
switch (key) {
case 'CONSUL_ACLS_ENABLE':
prev['CONSUL_ACLS_ENABLED'] = !!JSON.parse(String(value).toLowerCase());
break;
case 'CONSUL_NSPACES_ENABLE':
prev['CONSUL_NSPACES_ENABLED'] = !!JSON.parse(String(value).toLowerCase());
break;
default:
prev[key] = value;
}
return prev;
}, {});
if (typeof $[key] !== 'undefined') {
return $[key];
}
break;
}
return config[key];
};
return function env(str) {
switch (str) {
// All user providable values should start with CONSUL_UI
// We allow the user to set these ones via localStorage
// user value is preferred.
case 'CONSUL_UI_DISABLE_REALTIME':
case 'CONSUL_UI_DISABLE_ANCHOR_SELECTION':
// these are booleans cast things out
return !!JSON.parse(String(user(str) || 0).toLowerCase()) || ui(str);
case 'CONSUL_UI_REALTIME_RUNNER':
// these are strings
return user(str) || ui(str);
case 'CONSUL_HTTP_PROTOCOL':
case 'CONSUL_HTTP_MAX_CONNECTIONS':
// We allow the operator to set these ones via various methods
// although UI developer config is preferred
return ui(str) || operator(str, env);
default:
return ui(str);
}
};
}

@ -2,8 +2,6 @@
const fs = require('fs'); const fs = require('fs');
const path = require('path'); const path = require('path');
module.exports = function(environment) { module.exports = function(environment) {
const isDevLike = ['development', 'staging', 'test'].indexOf(environment) > -1;
const isProdLike = ['production', 'staging'].indexOf(environment) > -1;
let ENV = { let ENV = {
modulePrefix: 'consul-ui', modulePrefix: 'consul-ui',
environment, environment,
@ -19,7 +17,6 @@ module.exports = function(environment) {
Date: false, Date: false,
}, },
}, },
APP: { APP: {
// Here you can pass flags/options to your application instance // Here you can pass flags/options to your application instance
// when it is created // when it is created
@ -30,23 +27,33 @@ module.exports = function(environment) {
}; };
// TODO: These should probably go onto APP // TODO: These should probably go onto APP
ENV = Object.assign({}, ENV, { ENV = Object.assign({}, ENV, {
// TODO: Let people alter this, as with anchor selection CONSUL_UI_DISABLE_REALTIME: typeof process.env.CONSUL_UI_DISABLE_REALTIME !== 'undefined',
CONSUL_UI_DISABLE_REALTIME: false,
CONSUL_UI_DISABLE_ANCHOR_SELECTION: CONSUL_UI_DISABLE_ANCHOR_SELECTION:
typeof process.env.CONSUL_UI_DISABLE_ANCHOR_SELECTION !== 'undefined', typeof process.env.CONSUL_UI_DISABLE_ANCHOR_SELECTION !== 'undefined',
CONSUL_GIT_SHA: (function() { CONSUL_COPYRIGHT_YEAR: (function(val) {
if (process.env.CONSUL_GIT_SHA) { if (val) {
return process.env.CONSUL_GIT_SHA; return val;
}
return require('child_process')
.execSync('git show -s --format=%ci HEAD')
.toString()
.trim()
.split('-')
.shift();
})(process.env.CONSUL_COPYRIGHT_YEAR),
CONSUL_GIT_SHA: (function(val) {
if (val) {
return val;
} }
return require('child_process') return require('child_process')
.execSync('git rev-parse --short HEAD') .execSync('git rev-parse --short HEAD')
.toString() .toString()
.trim(); .trim();
})(), })(process.env.CONSUL_GIT_SHA),
CONSUL_VERSION: (function() { CONSUL_VERSION: (function(val) {
if (process.env.CONSUL_VERSION) { if (val) {
return process.env.CONSUL_VERSION; return val;
} }
// see /scripts/dist.sh:8 // see /scripts/dist.sh:8
const version_go = `${path.dirname(path.dirname(__dirname))}/version/version.go`; const version_go = `${path.dirname(path.dirname(__dirname))}/version/version.go`;
@ -58,72 +65,68 @@ module.exports = function(environment) {
}) })
.trim() .trim()
.split('"')[1]; .split('"')[1];
})(), })(process.env.CONSUL_VERSION),
CONSUL_BINARY_TYPE: (function() { CONSUL_BINARY_TYPE: process.env.CONSUL_BINARY_TYPE ? process.env.CONSUL_BINARY_TYPE : 'oss',
if (process.env.CONSUL_BINARY_TYPE) {
return process.env.CONSUL_BINARY_TYPE;
}
return 'oss';
})(),
CONSUL_ACLS_ENABLED: false, CONSUL_ACLS_ENABLED: false,
CONSUL_NSPACES_ENABLED: false, CONSUL_NSPACES_ENABLED: false,
CONSUL_HOME_URL: 'https://www.consul.io', CONSUL_HOME_URL: 'https://www.consul.io',
CONSUL_DOCS_URL: 'https://www.consul.io/docs', CONSUL_DOCS_URL: 'https://www.consul.io/docs',
CONSUL_DOCS_LEARN_URL: 'https://learn.hashicorp.com/consul', CONSUL_DOCS_LEARN_URL: 'https://learn.hashicorp.com/consul',
CONSUL_DOCS_API_URL: 'https://www.consul.io/api', CONSUL_DOCS_API_URL: 'https://www.consul.io/api',
CONSUL_COPYRIGHT_URL: 'https://www.hashicorp.com', CONSUL_COPYRIGHT_URL: 'https://www.hashicorp.com',
CONSUL_COPYRIGHT_YEAR: '2019',
}); });
const isDevLike = ['development', 'staging', 'test'].indexOf(environment) > -1;
const isProdLike = ['production', 'staging'].indexOf(environment) > -1;
switch (true) { switch (true) {
case environment === 'test':
ENV = Object.assign({}, ENV, {
locationType: 'none',
CONSUL_ACLS_ENABLED: true,
'@hashicorp/ember-cli-api-double': {
'auto-import': false,
enabled: true,
endpoints: ['/node_modules/@hashicorp/consul-api-double/v1'],
},
APP: Object.assign({}, ENV.APP, {
LOG_ACTIVE_GENERATION: false,
LOG_VIEW_LOOKUPS: false,
rootElement: '#ember-testing',
autoboot: false,
}),
});
// passthrough
case environment === 'staging':
ENV = Object.assign({}, ENV, {
'@hashicorp/ember-cli-api-double': {
enabled: true,
endpoints: ['/node_modules/@hashicorp/consul-api-double/v1'],
},
});
// passthrough
case environment === 'production':
ENV = Object.assign({}, ENV, {
CONSUL_ACLS_ENABLED: '{{.ACLsEnabled}}',
CONSUL_NSPACES_ENABLED:
'{{ if .NamespacesEnabled }}{{.NamespacesEnabled}}{{ else }}false{{ end }}',
});
// passthrough
case isDevLike: case isDevLike:
ENV = Object.assign({}, ENV, { ENV = Object.assign({}, ENV, {
CONSUL_NSPACES_ENABLED: true, CONSUL_NSPACES_ENABLED: true,
CONSUL_ACLS_ENABLED: true, CONSUL_ACLS_ENABLED: true,
// 'APP': Object.assign({}, ENV.APP, {
// 'LOG_RESOLVER': true,
// 'LOG_ACTIVE_GENERATION': true,
// 'LOG_TRANSITIONS': true,
// 'LOG_TRANSITIONS_INTERNAL': true,
// 'LOG_VIEW_LOOKUPS': true,
// })
}); });
// ENV.APP.LOG_RESOLVER = true;
// ENV.APP.LOG_ACTIVE_GENERATION = true;
// ENV.APP.LOG_TRANSITIONS = true;
// ENV.APP.LOG_TRANSITIONS_INTERNAL = true;
// ENV.APP.LOG_VIEW_LOOKUPS = true;
break; break;
case isProdLike: case isProdLike:
break; break;
} }
// TODO: Move this to use switch once the production forking
// below has been uncommented (once ACLs and NSPACEs flags are passed through)
if (environment === 'test') {
// Testem prefers this...
ENV.locationType = 'none';
// keep test console output quieter
ENV.APP.LOG_ACTIVE_GENERATION = false;
ENV.APP.LOG_VIEW_LOOKUPS = false;
ENV.APP.rootElement = '#ember-testing';
ENV.APP.autoboot = false;
ENV['@hashicorp/ember-cli-api-double'] = {
'auto-import': false,
enabled: true,
endpoints: ['/node_modules/@hashicorp/consul-api-double/v1'],
};
}
if (environment === 'staging') {
ENV['@hashicorp/ember-cli-api-double'] = {
enabled: true,
endpoints: ['/node_modules/@hashicorp/consul-api-double/v1'],
};
}
if (environment === 'production') {
ENV = Object.assign(
{},
ENV,
{
CONSUL_ACLS_ENABLED: '{{.ACLsEnabled}}',
CONSUL_NSPACES_ENABLED: '{{ if .NamespacesEnabled }}{{.NamespacesEnabled}}{{ else }}false{{ end }}'
}
);
// here you can enable a production-specific feature
}
return ENV; return ENV;
}; };

@ -0,0 +1,165 @@
import getEnvironment from 'consul-ui/utils/get-environment';
import { module, test } from 'qunit';
const getEntriesByType = function(type) {
return [
{
initiatorType: 'script',
name: '',
nextHopProtocol: 'spdy',
},
];
};
const getElementsByTagName = function(name) {
return [
{
src: '',
},
];
};
const win = {
performance: {
getEntriesByType: getEntriesByType,
},
localStorage: {
getItem: function(key) {},
},
};
const doc = {
cookie: '',
getElementsByTagName: getElementsByTagName,
};
module('Unit | Utility | getEnvironment', function() {
test('it returns a function', function(assert) {
const config = {};
const env = getEnvironment(config, win, doc);
assert.ok(typeof env === 'function');
});
test('it returns the correct operator value', function(assert) {
const config = {};
const env = getEnvironment(config, win, doc);
assert.equal(env('CONSUL_HTTP_PROTOCOL'), 'spdy');
});
test('it returns the correct operator value when set via config', function(assert) {
const config = {
CONSUL_HTTP_PROTOCOL: 'hq',
};
const env = getEnvironment(config, win, doc);
assert.equal(env('CONSUL_HTTP_PROTOCOL'), 'hq');
});
test('it returns the correct max connections depending on protocol', function(assert) {
let config = {
CONSUL_HTTP_PROTOCOL: 'hq',
};
let env = getEnvironment(config, win, doc);
assert.equal(env('CONSUL_HTTP_MAX_CONNECTIONS'), undefined);
config = {
CONSUL_HTTP_PROTOCOL: 'http/1.1',
};
env = getEnvironment(config, win, doc);
assert.equal(env('CONSUL_HTTP_MAX_CONNECTIONS'), 5);
});
test('it returns the correct max connections if performance.getEntriesByType is not available', function(assert) {
const config = {};
let win = {};
let env = getEnvironment(config, win, doc);
assert.equal(env('CONSUL_HTTP_MAX_CONNECTIONS'), 5);
win = {
performance: {},
};
env = getEnvironment(config, win, doc);
assert.equal(env('CONSUL_HTTP_MAX_CONNECTIONS'), 5);
});
test('it returns the correct user value', function(assert) {
const config = {};
let win = {
localStorage: {
getItem: function(key) {
return '1';
},
},
};
let env = getEnvironment(config, win, doc);
assert.ok(env('CONSUL_UI_DISABLE_REALTIME'));
win = {
localStorage: {
getItem: function(key) {
return '0';
},
},
};
env = getEnvironment(config, win, doc);
assert.notOk(env('CONSUL_UI_DISABLE_REALTIME'));
win = {
localStorage: {
getItem: function(key) {
return null;
},
},
};
env = getEnvironment(config, win, doc);
assert.notOk(env('CONSUL_UI_DISABLE_REALTIME'));
});
test('it returns the correct user value when set via config', function(assert) {
const config = {
CONSUL_UI_DISABLE_REALTIME: true,
};
const env = getEnvironment(config, win, doc);
assert.ok(env('CONSUL_UI_DISABLE_REALTIME'));
});
test('it returns the correct dev value (via cookies)', function(assert) {
let config = {
environment: 'test',
CONSUL_NSPACES_ENABLED: false,
};
let doc = {
cookie: 'CONSUL_NSPACES_ENABLE=1',
getElementsByTagName: getElementsByTagName,
};
let env = getEnvironment(config, win, doc);
assert.ok(env('CONSUL_NSPACES_ENABLED'));
config = {
environment: 'test',
CONSUL_NSPACES_ENABLED: true,
};
doc = {
cookie: 'CONSUL_NSPACES_ENABLE=0',
getElementsByTagName: getElementsByTagName,
};
env = getEnvironment(config, win, doc);
assert.notOk(env('CONSUL_NSPACES_ENABLED'));
});
test('it returns the correct dev value when set via config', function(assert) {
let config = {
CONSUL_NSPACES_ENABLED: true,
};
let env = getEnvironment(config, win, doc);
assert.ok(env('CONSUL_NSPACES_ENABLED'));
config = {
CONSUL_NSPACES_ENABLED: false,
};
env = getEnvironment(config, win, doc);
assert.notOk(env('CONSUL_NSPACES_ENABLED'));
});
test("it returns the correct dev value (ignoring cookies when the environment doesn't allow it)", function(assert) {
let config = {
environment: 'production',
CONSUL_NSPACES_ENABLED: false,
};
let doc = {
cookie: 'CONSUL_NSPACES_ENABLE=1',
getElementsByTagName: getElementsByTagName,
};
let env = getEnvironment(config, win, doc);
assert.notOk(env('CONSUL_NSPACES_ENABLED'));
config = {
environment: 'production',
CONSUL_NSPACES_ENABLED: true,
};
doc = {
cookie: 'CONSUL_NSPACES_ENABLE=0',
getElementsByTagName: getElementsByTagName,
};
env = getEnvironment(config, win, doc);
assert.ok(env('CONSUL_NSPACES_ENABLED'));
});
});
Loading…
Cancel
Save