@contrast/config 1.40.1 → 1.40.2

package/lib/config.js

@@ -41,6 +41,8 @@ const OS_CONFIG_DIR = os.platform() === 'win32'
 const REDACTED_KEYS = ['api.api_key', 'api.service_key', 'api.token'];
 const OVERRIDABLE_SOURCES = [DEFAULT_VALUE, CONTRAST_UI];
 
+const isValid = (opt) => opt !== undefined && opt !== null && opt !== '';
+
 module.exports = class Config {
   constructor(core) {
     // internals
@@ -88,7 +90,7 @@ module.exports = class Config {
       for (const [name, mapper] of Object.entries(mappings)) {
         if (OVERRIDABLE_SOURCES.includes(this.getEffectiveSource(name))) {
           const remoteValue = mapper(msg);
-          if (remoteValue != null) {
+          if (isValid(remoteValue)) {
             this._effectiveMap.set(name, {
               canonical_name: name,
               name,
@@ -202,10 +204,10 @@ module.exports = class Config {
       const fileValue = get(fileOptions, opt.name);
       let source, value;
 
-      if (envValue != null) {
+      if (isValid(envValue)) {
         source = ENVIRONMENT_VARIABLE;
         value = envValue;
-      } else if (fileValue != null) {
+      } else if (isValid(fileValue)) {
         source = USER_CONFIGURATION_FILE;
         value = fileValue;
       } else {

package/lib/index.d.ts

@@ -43,7 +43,7 @@ export type SyslogLevel =
 export interface ConfigOption<T> {
   name: string;
   abbrev?: string;
-  env?: string;
+  env: string;
   arg: string;
   enum?: T[];
   default?: T;

package/package.json

@@ -1,11 +1,14 @@
 {
   "name": "@contrast/config",
-  "version": "1.40.1",
+  "version": "1.40.2",
   "description": "An API for discovering Contrast agent configuration data",
   "license": "SEE LICENSE IN LICENSE",
   "author": "Contrast Security <nodejs@contrastsecurity.com> (https://www.contrastsecurity.com)",
   "files": [
-    "lib/"
+    "lib/",
+    "!*.test.*",
+    "!tsconfig.*",
+    "!*.map"
   ],
   "main": "lib/index.js",
   "types": "lib/index.d.ts",

package/lib/common.test.js

@@ -1,183 +0,0 @@
-'use strict';
-
-const { expect } = require('chai');
-const { ProtectRuleMode } = require('@contrast/common');
-const { mappings } = require('./common');
-
-describe('config effective value mappings', function () {
-  describe('"simple" mappings', function() {
-    const simplyMappedNames = [
-      'assess.enable',
-      'agent.logger.path',
-      'agent.security_logger.syslog.enable',
-      'agent.security_logger.syslog.ip',
-      'agent.security_logger.syslog.port',
-      'agent.security_logger.syslog.facility',
-      'server.environment',
-      'protect.enable',
-    ];
-
-    it('"simple" mappings will return any value for corresponding remote setting (todo: validation for each)', function () {
-      ['', 'foo', null, 0.3, 3, {}, [], true, false].forEach((val) => {
-        const remoteData = {
-          // server
-          assess: {
-            enable: val,
-            sampling: { enable: val }
-          },
-          logger: {
-            path: val,
-          },
-          security_logger: {
-            syslog: {
-              enable: val,
-              ip: val,
-              port: val,
-              facility: val,
-              serverity_exploited: val,
-              serverity_blocked: val,
-              exploited_probed: val,
-            }
-          },
-          environment: val,
-          // app
-          protect: {
-            enable: val,
-          },
-        };
-
-        for (const name of simplyMappedNames) {
-          const result = mappings[name](remoteData);
-          expect(result).to.equal(val);
-        }
-      });
-    });
-
-    it('"simple" mappings will return `undefined` if there is no corresponding remote setting', function () {
-      for (const name of simplyMappedNames) {
-        expect(mappings[name]({})).to.equal(undefined);
-      }
-    });
-  });
-
-  describe('maps \'assess.probabilistic_sampling.base_probability\'', function() {
-    [
-      {
-        desc: 'sets value by inverting request_frequency',
-        remoteData: {
-          assess: { sampling: { request_frequency: 20 } }
-        },
-        expected: 1 / 20,
-      },
-      {
-        desc: 'ignores and returns undefined if request_frequency is 0',
-        remoteData: {
-          assess: { sampling: { request_frequency: 0 } }
-        },
-        expected: undefined,
-      },
-      {
-        desc: 'ignores and returns undefined if calculating probability gives NaN',
-        remoteData: {
-          assess: { sampling: { request_frequency: 'forty five' } }
-        },
-        expected: undefined,
-      },
-      {
-        desc: 'ignores and returns undefined if value is negative',
-        remoteData: {
-          assess: { sampling: { request_frequency: -12 } }
-        },
-        expected: undefined,
-      },
-    ].forEach(({ desc, remoteData, expected }) => {
-      it(desc, function() {
-        expect(mappings['assess.probabilistic_sampling.base_probability'](remoteData)).to.equal(expected);
-      });
-    });
-  });
-
-  describe('maps Protect rule modes', function() {
-    [
-      {
-        tsValue: 'OFF',
-        expected: ProtectRuleMode.OFF,
-      },
-      {
-        tsValue: 'MONITORING',
-        expected: ProtectRuleMode.MONITOR,
-      },
-      {
-        tsValue: 'BLOCKING',
-        expected: ProtectRuleMode.BLOCK,
-      },
-      {
-        tsValue: 'BLOCK_AT_PERIMETER',
-        expected: ProtectRuleMode.BLOCK_AT_PERIMETER,
-      },
-      {
-        tsValue: 'FOO',
-        expected: undefined
-      },
-    ].forEach(({ desc, tsValue, expected }) => {
-      [
-        'protect.rules.cmd-injection.mode',
-        'protect.rules.cmd-injection-command-backdoors.mode',
-        'protect.rules.cmd-injection-semantic-chained-commands.mode',
-        'protect.rules.cmd-injection-semantic-dangerous-paths.mode',
-        'protect.rules.method-tampering.mode',
-        'protect.rules.nosql-injection.mode',
-        'protect.rules.nosql-injection-mongo.mode',
-        'protect.rules.path-traversal.mode',
-        'protect.rules.path-traversal-semantic-file-security-bypass.mode',
-        'protect.rules.reflected-xss.mode',
-        'protect.rules.sql-injection.mode',
-        'protect.rules.ssjs-injection.mode',
-        'protect.rules.unsafe-file-upload.mode',
-        'protect.rules.untrusted-deserialization.mode',
-        'protect.rules.xxe.mode',
-      ].forEach((fullName) => {
-        const ruleName = /rules\.(.*)\.mode/.exec(fullName)[1];
-        it(`sets ${ruleName} to ${expected} when value is ${tsValue}`, function() {
-          expect(mappings[fullName]({
-            protect: {
-              rules: {
-                [ruleName]: { mode: tsValue },
-              }
-            }
-          })).to.equal(expected);
-        });
-      });
-    });
-  });
-
-  describe('maps security logger severity levels (lowercase)', function() {
-    [
-      {
-        tsValue: 'FOO',
-        expected: 'foo',
-      },
-      {
-        tsValue: '',
-        expected: undefined,
-      }
-    ].forEach(({ tsValue, expected }) => {
-      [
-        'agent.security_logger.syslog.severity_exploited',
-        'agent.security_logger.syslog.severity_blocked',
-        'agent.security_logger.syslog.severity_probed',
-      ].forEach((fullName) => {
-        const severity = fullName.substr(fullName.lastIndexOf('.') + 1);
-        it(`maps to ${expected} when tsValue is ${tsValue}`, function() {
-          expect(mappings[fullName]({
-            security_logger: {
-              syslog: {
-                [severity]: tsValue,
-              },
-            }
-          })).to.equal(expected);
-        });
-      });
-    });
-  });
-});

package/lib/index.test.js

@@ -1,664 +0,0 @@
-'use strict';
-
-const EventEmitter = require('events');
-const path = require('path');
-const proxyquire = require('proxyquire');
-const sinon = require('sinon');
-const { expect } = require('chai');
-const { Event } = require('@contrast/common');
-const options = require('./options');
-const {
-  ConfigSource: { ENVIRONMENT_VARIABLE }
-} = require('./common');
-const {
-  getGoodConfig,
-  getBadConfig,
-  getAbsolutePath,
-  getDefaultConfig,
-  getProperties,
-  containsAllProps,
-} = require('../test/helpers');
-
-describe('config', function () {
-  let env, Config, config;
-
-  beforeEach(function () {
-    env = {
-      ProgramData: 'C:\\ProgramData',
-      CONTRAST_CONFIG_PATH: getGoodConfig(),
-    };
-    Config = proxyquire('./config', {
-      process: { env },
-    });
-    config = proxyquire('.', {
-      process: { env },
-      './config': Config,
-    });
-
-    sinon.stub(console, 'error');
-  });
-
-  describe('default config behavior', function () {
-    it('sets all default properties in the config', function () {
-      const defaultConfigProps = getProperties(getDefaultConfig());
-      const loadConfigProps = getProperties(config());
-      expect(containsAllProps(loadConfigProps, defaultConfigProps)).to.be.true;
-    });
-
-    it('logs an error a config file path is given and no config is found', function () {
-      env['CONTRAST_CONFIG_PATH'] = 'fake config';
-      const fn = () => config();
-      expect(fn).to.throw('1) Unable to read Contrast configuration file: \'fake config\'');
-    });
-
-    it('logs an error when the config cannot be parsed', function () {
-      env['CONTRAST_CONFIG_PATH'] = getBadConfig();
-      const fn = () => config();
-      expect(fn).to.throw(`Contrast configuration file is malformed: '${getBadConfig()}'`);
-    });
-
-    it('accepts overrides from env', function () {
-      env['CONTRAST__API__API_KEY'] = 'demo';
-      const cfg = config();
-      expect(cfg.api.api_key).to.equal('demo');
-    });
-
-    it('loads and sets properties from a valid config', function () {
-      env['CONTRAST_CONFIG_PATH'] = getGoodConfig();
-      const cfg = config();
-      expect(console.error).not.to.have.been.called;
-      expect(cfg.api.enable).to.be.true;
-      expect(cfg.api.url).to.equal('http://localhost:19080/Contrast');
-      expect(cfg.api.api_key).to.equal('demo');
-      expect(cfg.api.service_key).to.equal('demo');
-      expect(cfg.api.user_name).to.equal('contrast_admin');
-    });
-  });
-
-  describe('config file path precedence', function () {
-    it('should set config from environment variable even when default is present', function () {
-      sinon.stub(Config.prototype, '_configDirs').returns([
-        path.dirname(getGoodConfig())
-      ]);
-      env['CONTRAST_CONFIG_PATH'] = getGoodConfig('two');
-      const cfg = config();
-      expect(cfg).to.have.property('_filepath', getGoodConfig('two'));
-      expect(cfg.api.url).to.equal('https://localhost:9999/Contrast');
-      expect(cfg.api.api_key).to.equal('QWERTYUIOP');
-      expect(cfg.api.service_key).to.equal('ASDFGHJKL');
-      expect(cfg.api.user_name).to.equal('contrast_user');
-    });
-
-    it('should set config from default location when no env var is set', function () {
-      sinon.stub(Config.prototype, '_configDirs').returns([
-        path.dirname(getGoodConfig())
-      ]);
-      delete env['CONTRAST_CONFIG_PATH'];
-      const cfg = config();
-      expect(cfg).to.have.property('_filepath', getGoodConfig());
-      expect(cfg.api.url).to.equal('http://localhost:19080/Contrast');
-      expect(cfg.api.api_key).to.equal('demo');
-      expect(cfg.api.service_key).to.equal('demo');
-      expect(cfg.api.user_name).to.equal('contrast_admin');
-    });
-
-    it('should set config from top valid default location', function () {
-      sinon.stub(Config.prototype, '_configDirs').returns([
-        path.dirname(getGoodConfig('two')),
-        path.dirname(getGoodConfig()),
-      ]);
-      delete env['CONTRAST_CONFIG_PATH'];
-      const cfg = config();
-      expect(cfg).to.have.property('_filepath', getGoodConfig('two'));
-      expect(cfg.api.url).to.equal('https://localhost:9999/Contrast');
-      expect(cfg.api.api_key).to.equal('QWERTYUIOP');
-      expect(cfg.api.service_key).to.equal('ASDFGHJKL');
-      expect(cfg.api.user_name).to.equal('contrast_user');
-    });
-
-    it('should set from env variable even when present in multiple defaults', function () {
-      sinon.stub(Config.prototype, '_configDirs').returns([
-        path.dirname(getGoodConfig('two')),
-        path.dirname(getGoodConfig()),
-      ]);
-      env['CONTRAST_CONFIG_PATH'] = getGoodConfig('three');
-      const cfg = config();
-      expect(cfg).to.have.property('_filepath', getGoodConfig('three'));
-      expect(cfg.api.url).to.equal('https://localhost:8080/Contrast');
-      expect(cfg.api.api_key).to.equal('QAZWSX');
-      expect(cfg.api.service_key).to.equal('EDCRFV');
-      expect(cfg.api.user_name).to.equal('super_admin');
-    });
-  });
-
-  describe('config value precedence', function () {
-    let options;
-
-    beforeEach(function () {
-      options = getDefaultConfig();
-    });
-
-    it('should use env var before config file value', function () {
-      env['CONTRAST__API__API_KEY'] = 'NOPE';
-      const cfg = config(options);
-      expect(cfg.api.api_key).to.equal('NOPE');
-    });
-  });
-
-  describe('environment variables', function () {
-    it('should support CONTRAST__ options', function () {
-      const options = getDefaultConfig();
-      env['CONTRAST__AGENT__NODE__REWRITE__ENABLE'] = 'f';
-      const cfg = config(options);
-
-      expect(cfg.agent.node.rewrite.enable).to.be.false;
-    });
-
-    it('Should support CONTRAST__API__ options', function () {
-      const options = getDefaultConfig();
-      env['CONTRAST__API__API_KEY'] = 'abcdefg';
-      const cfg = config(options);
-
-      expect(cfg.api.api_key).to.equal('abcdefg');
-    });
-
-    it('should merge pm2 env variables', function () {
-      const options = getDefaultConfig();
-      const variables = {
-        CONTRAST_CONFIG_PATH: '/path/to/config',
-        CONTRAST__API__API_KEY: 'abcdefg',
-        env: {
-          CONTRAST_CONFIG_PATH: '/other/path/to/config'
-        }
-      };
-      delete env['CONTRAST_CONFIG_PATH'];
-      env['pm2_env'] = JSON.stringify(variables);
-
-      const fn = () => config(options);
-      expect(fn).throws('1) Unable to read Contrast configuration file: \'/other/path/to/config\'');
-    });
-
-    it('should throw an error if pm2_env is invalid', function () {
-      env['pm2_env'] = '{CONTRAST_';
-
-      const fn = () => config(options);
-      expect(fn).to.throw('1) Unable to parse pm2 environment variable: \'{CONTRAST_\'');
-    });
-  });
-
-  describe('api.token handling', function () {
-    it('sets api config vars when they are not present', function () {
-      env['CONTRAST_CONFIG_PATH'] = getGoodConfig('token');
-      const cfg = config();
-
-      expect(cfg.api).to.include({
-        url: 'http://localhost:12345/Contrast',
-        api_key: 'secret',
-        service_key: 'secret',
-        user_name: 'tokenuser'
-      });
-    });
-
-    it('does not override api config vars when they are explicitly set in config', function () {
-      // url: 'http://localhost:12345/Contrast',
-      // api_key: 'secret',
-      // service_key: 'secret',
-      // user_name: 'tokenuser'
-      env['CONTRAST__API__TOKEN'] = 'eyJ1cmwiOiJodHRwOi8vbG9jYWxob3N0OjEyMzQ1L0NvbnRyYXN0IiwiYXBpX2tleSI6InNlY3JldCIsInNlcnZpY2Vfa2V5Ijoic2VjcmV0IiwidXNlcl9uYW1lIjoidG9rZW51c2VyIn0=';
-      const cfg = config();
-
-      expect(cfg.api).to.include({
-        url: 'http://localhost:19080/Contrast',
-        api_key: 'demo',
-        service_key: 'demo',
-        user_name: 'contrast_admin'
-      });
-    });
-
-    it('observes the correct precedence', function () {
-      env['CONTRAST_CONFIG_PATH'] = getGoodConfig('token');
-      env['CONTRAST__API__API_KEY'] = 'something else';
-      const cfg = config();
-
-      expect(cfg.api).to.include({
-        url: 'http://localhost:12345/Contrast',
-        api_key: 'something else',
-        service_key: 'secret',
-        user_name: 'tokenuser'
-      });
-    });
-  });
-
-  describe('multiple errors can be thrown in an exception', function() {
-    it('should report multiple errors', function() {
-      const options = getDefaultConfig();
-      env['pm2_env'] = '{CONTRAST_';
-      env['CONTRAST__APPLICATION__SESSION_ID'] = 'abcd-1234';
-      env['CONTRAST__APPLICATION__SESSION_METADATA'] = 'a=1,b=2';
-      env['CONTRAST_CONFIG_PATH'] = getGoodConfig('three');
-
-      const fn = () => config(options);
-      expect(fn).throws(/1\) Unable to parse pm2 .+ 2\) Cannot set both/);
-    });
-  });
-
-  describe('config options functions', function () {
-    describe('clearBaseCase', function () {
-      it('should return string if defined', function () {
-        const string = 'asdf';
-        expect(options.clearBaseCase(string)).to.equal(string);
-      });
-
-      it('should return undefined if string is empty', function () {
-        const string = '';
-        expect(options.clearBaseCase(string)).to.be.undefined;
-      });
-
-      it('should return int if and number and defined', function () {
-        const num = 1;
-        expect(options.clearBaseCase(num)).to.equal(num);
-      });
-
-      it('should return undefined if value is NaN', function () {
-        const num = NaN;
-        expect(options.clearBaseCase(num)).to.be.undefined;
-      });
-    });
-
-    describe('castBoolean', function () {
-      [true, 'true', 'TRUE', 't', 'T'].forEach(val => {
-        it(`should return true if string value is ${val}`, function () {
-          expect(options.castBoolean(val)).to.be.true;
-        });
-      });
-
-      [false, 'false', 'FALSE', 'f', 'F'].forEach(val => {
-        it(`should return false if string value is ${val}`, function () {
-          expect(options.castBoolean(val)).to.be.false;
-        });
-      });
-
-      ['rando', [1, 2, 3], {}, 100, null, undefined].forEach(val => {
-        it(`should return undefined if ${val} not a boolean or string or not true/t/false/f`, function () {
-          expect(options.castBoolean(val)).to.be.undefined;
-        });
-      });
-    });
-  });
-
-  describe('enum', function () {
-    it('should use value from enum if there is a match', function () {
-      env['CONTRAST__AGENT__LOGGER__LEVEL'] = 'INFO';
-      const cfg = config();
-      expect(cfg.agent.logger.level).to.equal('info');
-    });
-
-    it('should fall back to the default when provided option value is invalid', function () {
-      env['CONTRAST__AGENT__LOGGER__LEVEL'] = 'doggo';
-      const cfg = config();
-      expect(cfg.agent.logger.level).to.equal('info');
-    });
-  });
-
-  describe('uppercase, lowercase, parsenum transformations', function () {
-    it('should uppercase server.environment', function () {
-      env['CONTRAST__SERVER__ENVIRONMENT'] = 'qa';
-      const cfg = config();
-      expect(cfg.server.environment).to.equal('QA');
-    });
-
-    it('should lowercase logger level', function () {
-      env['CONTRAST__AGENT__LOGGER__LEVEL'] = 'DEBUG';
-      const cfg = config();
-      expect(cfg.agent.logger.level).to.equal('debug');
-    });
-
-    it('should parse stack_trace_limit into a number', function () {
-      env['CONTRAST__AGENT__STACK_TRACE_LIMIT'] = '25';
-      const cfg = config();
-      expect(cfg.agent.stack_trace_limit).to.equal(25);
-    });
-
-    it('agent.stack_trace_limit (Infinity string --> number)', function () {
-      env['CONTRAST__AGENT__STACK_TRACE_LIMIT'] = 'Infinity';
-      const cfg = config();
-      expect(cfg.agent.stack_trace_limit).to.equal(Infinity);
-    });
-  });
-
-  describe('application', function () {
-    describe('validation', function () {
-      afterEach(function () {
-      });
-      it('allows one to be set without error', function () {
-        env['CONTRAST__APPLICATION__SESSION_ID'] = 'abcd-1234';
-        expect(() => {
-          config();
-        }).not.to.throw(/Configuration Error:/);
-      });
-      it('session options are mutually exclusive', function () {
-        env['CONTRAST__APPLICATION__SESSION_ID'] = 'abcd-1234';
-        env['CONTRAST__APPLICATION__SESSION_METADATA'] = 'a=1,b=2';
-        const fn = () => config();
-        expect(fn).throws('1) Cannot set both `application.session_id` and `application.session_metadata`');
-      });
-    });
-  });
-
-  describe('mapping', function () {
-    describe('logger', function () {
-      it('casts logger path to absolute path', function () {
-        env['CONTRAST__AGENT__LOGGER__PATH'] = 'loggy.log';
-        const cfg = config();
-        expect(cfg.agent.logger.path).to.equal(getAbsolutePath('loggy.log'));
-      });
-
-      it('--debug does not overwrite explicitly set log level', function () {
-        env['DEBUG'] = 'true';
-        env['CONTRAST__AGENT__LOGGER__LEVEL'] = 'info';
-        const cfg = config();
-        expect(cfg.agent.logger.level).to.equal('info');
-      });
-    });
-  });
-
-  describe('effective configuration', function () {
-    let core;
-    let config;
-
-    beforeEach(function () {
-      core = { messages: new EventEmitter() };
-      // there needs to be a valid config file or env var set so config doesn't throw
-      // an error.
-      process.env.CONTRAST_CONFIG_PATH = path.resolve(__dirname, '../../test/fixtures/protect_contrast_security.yaml');
-      //process.env.CONTRAST__PROTECT__RULES__DISABLED_RULES = 'cmd-injection,sql-injection';
-      config = require('.')(core);
-
-      config.setValue('contrast_config_path', path.resolve(__dirname, '../../test/fixtures/protect_contrast_security.yaml'), ENVIRONMENT_VARIABLE);
-      config.setValue('contrast__agent__stack_trace_limit', 20, ENVIRONMENT_VARIABLE);
-      config.setValue('protect.rules.disabled_rules', ['cmd-injection', 'sql-injection'], ENVIRONMENT_VARIABLE);
-      config.setValue('api.enable', true, ENVIRONMENT_VARIABLE);
-      config.setValue('api.api_key', 'ABCDEFGHIJ', ENVIRONMENT_VARIABLE);
-      config.setValue('api.service_key', 'KLMNOPQRST', ENVIRONMENT_VARIABLE);
-
-      core.messages.emit(Event.SERVER_SETTINGS_UPDATE, {
-        logger: {
-          // this will not take effect b/c value is set in config file
-          level: 'ERROR'
-        },
-        security_logger: {
-          syslog: {
-            enable: true,
-            ip: '127.0.0.1'
-          }
-        }
-      });
-    });
-
-    describe('.getEffectiveValue()', function () {
-      it('returns the resolved value based on precedence: env > file > UI > default', function () {
-        expect(config.getEffectiveValue('agent.security_logger.syslog.enable')).to.equal(true);
-      });
-    });
-
-    describe('.getReport', function () {
-      it('merges all the settings correctly and returns properly formatted config object', function () {
-
-        const result = config.getReport({ redact: false });
-        const {
-          config: {
-            effective_config,
-            environment_variable,
-          }
-        } = result;
-
-        expect(result.config).to.have.property('status', 'Success');
-        const expectedResults = [
-          {
-            canonical_name: 'api.enable',
-            name: 'api.enable',
-            source: 'ENVIRONMENT_VARIABLE',
-            value: 'true',
-          },
-          {
-            canonical_name: 'api.api_key',
-            name: 'api.api_key',
-            source: 'ENVIRONMENT_VARIABLE',
-            value: 'ABCDEFGHIJ',
-          },
-          {
-            canonical_name: 'api.service_key',
-            name: 'api.service_key',
-            source: 'ENVIRONMENT_VARIABLE',
-            value: 'KLMNOPQRST',
-          },
-          {
-            canonical_name: 'api.proxy.enable',
-            name: 'api.proxy.enable',
-            source: 'USER_CONFIGURATION_FILE',
-            value: 'false',
-          },
-          {
-            canonical_name: 'agent.diagnostics.enable',
-            name: 'agent.diagnostics.enable',
-            source: 'USER_CONFIGURATION_FILE',
-            value: 'false',
-          },
-          {
-            canonical_name: 'protect.enable',
-            name: 'protect.enable',
-            value: 'true',
-            source: 'USER_CONFIGURATION_FILE'
-          },
-          {
-            canonical_name: 'assess.enable',
-            name: 'assess.enable',
-            value: 'false',
-            source: 'USER_CONFIGURATION_FILE'
-          },
-          {
-            canonical_name: 'agent.security_logger.syslog.enable',
-            name: 'agent.security_logger.syslog.enable',
-            value: 'true',
-            source: 'CONTRAST_UI'
-          },
-          {
-            canonical_name: 'agent.polling.app_activity_ms',
-            name: 'agent.polling.app_activity_ms',
-            value: '5000',
-            source: 'DEFAULT_VALUE'
-          },
-          {
-            canonical_name: 'protect.rules.disabled_rules',
-            name: 'protect.rules.disabled_rules',
-            value: 'cmd-injection,sql-injection',
-            source: 'ENVIRONMENT_VARIABLE',
-          },
-          {
-            canonical_name: 'protect.probe_analysis.enable',
-            name: 'protect.probe_analysis.enable',
-            value: 'true',
-            source: 'DEFAULT_VALUE'
-          },
-          {
-            canonical_name: 'assess.trust_custom_validators',
-            name: 'assess.trust_custom_validators',
-            value: 'false',
-            source: 'DEFAULT_VALUE'
-          },
-          {
-            canonical_name: 'assess.max_propagation_events',
-            name: 'assess.max_propagation_events',
-            value: '500',
-            source: 'DEFAULT_VALUE'
-          },
-          {
-            canonical_name: 'assess.max_context_source_events',
-            name: 'assess.max_context_source_events',
-            value: '150',
-            source: 'DEFAULT_VALUE'
-          }
-        ];
-
-        const failures = [];
-        let effective;
-        let envs;
-        const envFailures = [];
-
-        for (const expected of expectedResults) {
-          effective = effective_config.filter(i => i.canonical_name === expected.canonical_name);
-          expect(effective).an('array').lengthOf(1); // eslint-disable-line
-          effective = effective[0];
-          try {
-            expect(expected).to.deep.equal(effective);
-          } catch (e) {
-            failures.push({ expected, actual: effective });
-          }
-          if (expected.source !== 'ENVIRONMENT_VARIABLE') continue;
-
-          envs = environment_variable.filter(i => i.canonical_name === expected.canonical_name);
-          expect(envs).an('array')
-            .lengthOf(1, `Expected to find ${expected.name} in environment_variable`);
-          envs = envs[0];
-          try {
-            expect(expected).to.deep.equal(envs);
-          } catch (e) {
-            envFailures.push({ expected, actual: envs });
-          }
-        }
-        // this provides a useful error message
-        expect(failures).eql([]);
-        expect(envFailures).eql([]);
-      });
-
-      it('stringifies values and redacts api keys when `redact` is set to true', function () {
-        const result = config.getReport({ redact: true });
-        const {
-          config: {
-            effective_config,
-            environment_variable,
-          }
-        } = result;
-
-        expect(result.config).to.have.property('status', 'Success');
-
-        const expectedResults = [
-          {
-            canonical_name: 'api.enable',
-            name: 'api.enable',
-            source: 'ENVIRONMENT_VARIABLE',
-            value: 'true',
-          },
-          {
-            canonical_name: 'api.api_key',
-            name: 'api.api_key',
-            source: 'ENVIRONMENT_VARIABLE',
-            value: 'contrast-redacted-api.api_key',
-          },
-          {
-            canonical_name: 'api.service_key',
-            name: 'api.service_key',
-            source: 'ENVIRONMENT_VARIABLE',
-            value: 'contrast-redacted-api.service_key',
-          },
-          {
-            canonical_name: 'api.proxy.enable',
-            name: 'api.proxy.enable',
-            source: 'USER_CONFIGURATION_FILE',
-            value: 'false',
-          },
-          {
-            canonical_name: 'agent.diagnostics.enable',
-            name: 'agent.diagnostics.enable',
-            source: 'USER_CONFIGURATION_FILE',
-            value: 'false',
-          },
-          {
-            canonical_name: 'protect.enable',
-            name: 'protect.enable',
-            value: 'true',
-            source: 'USER_CONFIGURATION_FILE'
-          },
-          {
-            canonical_name: 'assess.enable',
-            name: 'assess.enable',
-            value: 'false',
-            source: 'USER_CONFIGURATION_FILE'
-          },
-          {
-            canonical_name: 'agent.security_logger.syslog.enable',
-            name: 'agent.security_logger.syslog.enable',
-            value: 'true',
-            source: 'CONTRAST_UI'
-          },
-          {
-            canonical_name: 'agent.polling.app_activity_ms',
-            name: 'agent.polling.app_activity_ms',
-            value: '5000',
-            source: 'DEFAULT_VALUE'
-          },
-          {
-            canonical_name: 'protect.rules.disabled_rules',
-            name: 'protect.rules.disabled_rules',
-            value: 'cmd-injection,sql-injection',
-            source: 'ENVIRONMENT_VARIABLE',
-          },
-          {
-            canonical_name: 'protect.probe_analysis.enable',
-            name: 'protect.probe_analysis.enable',
-            value: 'true',
-            source: 'DEFAULT_VALUE'
-          },
-          {
-            canonical_name: 'assess.trust_custom_validators',
-            name: 'assess.trust_custom_validators',
-            value: 'false',
-            source: 'DEFAULT_VALUE'
-          },
-          {
-            canonical_name: 'assess.max_propagation_events',
-            name: 'assess.max_propagation_events',
-            value: '500',
-            source: 'DEFAULT_VALUE'
-          },
-          {
-            canonical_name: 'assess.max_context_source_events',
-            name: 'assess.max_context_source_events',
-            value: '150',
-            source: 'DEFAULT_VALUE'
-          }
-        ];
-
-        const failures = [];
-        let effective;
-        let envs;
-        const envFailures = [];
-
-        for (const expected of expectedResults) {
-          effective = effective_config.filter(i => i.canonical_name === expected.canonical_name);
-          expect(effective).an('array').lengthOf(1); // eslint-disable-line
-          effective = effective[0];
-          try {
-            expect(expected).to.deep.equal(effective);
-          } catch (e) {
-            failures.push({ expected, actual: effective });
-          }
-          if (expected.source !== 'ENVIRONMENT_VARIABLE') continue;
-
-          envs = environment_variable.filter(i => i.canonical_name === expected.canonical_name);
-          expect(envs).an('array')
-            .lengthOf(1, `Expected to find ${expected.name} in environment_variable`);
-          envs = envs[0];
-          try {
-            expect(expected).to.deep.equal(envs);
-          } catch (e) {
-            envFailures.push({ expected, actual: envs });
-          }
-        }
-        // this provides a useful error message
-        expect(failures).eql([]);
-        expect(envFailures).eql([]);
-      });
-    });
-  });
-});

package/lib/validators.test.js

@@ -1,42 +0,0 @@
-'use strict';
-
-const { expect } = require('chai');
-const mocks = require('@contrast/test/mocks');
-const validators = require('./validators');
-
-describe('config validators', function () {
-  let core;
-
-  beforeEach(function () {
-    core = { logger: mocks.logger() };
-  });
-
-  describe('config', function () {
-    it('calls `logger` for each log message provided', function () {
-      core.config = {
-        _logs: [
-          { level: 'info', msg: 'some info level message' },
-          {
-            level: 'debug',
-            obj: { foo: 'bar' },
-            msg: 'some debug level message with %d %s',
-            args: [2, 'args'],
-          },
-        ],
-      };
-
-      validators.config(core);
-
-      expect(core.logger.info).to.have.been.calledWith(
-        undefined,
-        'some info level message'
-      );
-      expect(core.logger.debug).to.have.been.calledWith(
-        { foo: 'bar' },
-        'some debug level message with %d %s',
-        2,
-        'args',
-      );
-    });
-  });
-});