appium 2.0.0-beta.21 → 2.0.0-beta.22

package/build/test/config-e2e-specs.js

@@ -0,0 +1,112 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+var _config = require("../lib/config");
+
+var _axios = _interopRequireDefault(require("axios"));
+
+var _support = require("@appium/support");
+
+describe('Config', function () {
+  describe('getGitRev', function () {
+    it('should get a reasonable git revision', async function () {
+      let rev = await (0, _config.getGitRev)();
+      rev.should.be.a('string');
+      rev.length.should.be.equal(40);
+      rev.match(/[0-9a-f]+/i)[0].should.eql(rev);
+    });
+  });
+  describe('getBuildInfo', function () {
+    async function verifyBuildInfoUpdate(useLocalGit) {
+      const buildInfo = (0, _config.getBuildInfo)();
+      mockFs.expects('exists').atLeast(1).returns(useLocalGit);
+      buildInfo['git-sha'] = undefined;
+      buildInfo.built = undefined;
+      await (0, _config.updateBuildInfo)(true);
+      buildInfo.should.be.an('object');
+      should.exist(buildInfo['git-sha']);
+      should.exist(buildInfo.built);
+      should.exist(buildInfo.version);
+    }
+
+    let mockFs;
+    let getStub;
+    beforeEach(function () {
+      mockFs = _sinon.default.mock(_support.fs);
+      getStub = _sinon.default.stub(_axios.default, 'get');
+    });
+    afterEach(function () {
+      getStub.restore();
+      mockFs.restore();
+    });
+    it('should get a configuration object if the local git metadata is present', async function () {
+      await verifyBuildInfoUpdate(true);
+    });
+    it('should get a configuration object if the local git metadata is not present', async function () {
+      getStub.onCall(0).returns({
+        data: [{
+          name: `v${_config.APPIUM_VER}`,
+          zipball_url: 'https://api.github.com/repos/appium/appium/zipball/v1.9.0-beta.1',
+          tarball_url: 'https://api.github.com/repos/appium/appium/tarball/v1.9.0-beta.1',
+          commit: {
+            sha: '3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',
+            url: 'https://api.github.com/repos/appium/appium/commits/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c'
+          },
+          node_id: 'MDM6UmVmNzUzMDU3MDp2MS45LjAtYmV0YS4x'
+        }, {
+          name: 'v1.8.2-beta',
+          zipball_url: 'https://api.github.com/repos/appium/appium/zipball/v1.8.2-beta',
+          tarball_url: 'https://api.github.com/repos/appium/appium/tarball/v1.8.2-beta',
+          commit: {
+            sha: '5b98b9197e75aa85e7507d21d3126c1a63d1ce8f',
+            url: 'https://api.github.com/repos/appium/appium/commits/5b98b9197e75aa85e7507d21d3126c1a63d1ce8f'
+          },
+          node_id: 'MDM6UmVmNzUzMDU3MDp2MS44LjItYmV0YQ=='
+        }]
+      });
+      getStub.onCall(1).returns({
+        data: {
+          sha: '3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',
+          node_id: 'MDY6Q29tbWl0NzUzMDU3MDozYzI3NTJmOWY5YzU2MDAwNzA1YTRhZTE1YjNiYTY4YTVkMmU2NDRj',
+          commit: {
+            author: {
+              name: 'Isaac Murchie',
+              email: 'isaac@saucelabs.com',
+              date: '2018-08-17T19:48:00Z'
+            },
+            committer: {
+              name: 'Isaac Murchie',
+              email: 'isaac@saucelabs.com',
+              date: '2018-08-17T19:48:00Z'
+            },
+            message: 'v1.9.0-beta.1',
+            tree: {
+              sha: '2c0974727470eba419ea0b9951c52f72f8036b18',
+              url: 'https://api.github.com/repos/appium/appium/git/trees/2c0974727470eba419ea0b9951c52f72f8036b18'
+            },
+            url: 'https://api.github.com/repos/appium/appium/git/commits/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',
+            comment_count: 0,
+            verification: {
+              verified: false,
+              reason: 'unsigned',
+              signature: null,
+              payload: null
+            }
+          },
+          url: 'https://api.github.com/repos/appium/appium/commits/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',
+          html_url: 'https://github.com/appium/appium/commit/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',
+          comments_url: 'https://api.github.com/repos/appium/appium/commits/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c/comments'
+        }
+      });
+      await verifyBuildInfoUpdate(false);
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/config-e2e-specs.js"],"names":["describe","it","rev","should","be","a","length","equal","match","eql","verifyBuildInfoUpdate","useLocalGit","buildInfo","mockFs","expects","atLeast","returns","undefined","built","an","exist","version","getStub","beforeEach","sinon","mock","fs","stub","axios","afterEach","restore","onCall","data","name","APPIUM_VER","zipball_url","tarball_url","commit","sha","url","node_id","author","email","date","committer","message","tree","comment_count","verification","verified","reason","signature","payload","html_url","comments_url"],"mappings":"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","sourcesContent":["import sinon from 'sinon';\nimport {\n  getGitRev,\n  getBuildInfo,\n  updateBuildInfo,\n  APPIUM_VER,\n} from '../lib/config';\nimport axios from 'axios';\nimport { fs } from '@appium/support';\n\n\ndescribe('Config', function () {\n  describe('getGitRev', function () {\n    it('should get a reasonable git revision', async function () {\n      let rev = await getGitRev();\n      rev.should.be.a('string');\n      rev.length.should.be.equal(40);\n      rev.match(/[0-9a-f]+/i)[0].should.eql(rev);\n    });\n  });\n  describe('getBuildInfo', function () {\n    async function verifyBuildInfoUpdate (useLocalGit) {\n      const buildInfo = getBuildInfo();\n      mockFs.expects('exists').atLeast(1).returns(useLocalGit);\n      buildInfo['git-sha'] = undefined;\n      buildInfo.built = undefined;\n      await updateBuildInfo(true);\n      buildInfo.should.be.an('object');\n      should.exist(buildInfo['git-sha']);\n      should.exist(buildInfo.built);\n      should.exist(buildInfo.version);\n    }\n\n    let mockFs;\n    let getStub;\n    beforeEach(function () {\n      mockFs = sinon.mock(fs);\n      getStub = sinon.stub(axios, 'get');\n    });\n    afterEach(function () {\n      getStub.restore();\n      mockFs.restore();\n    });\n\n    it('should get a configuration object if the local git metadata is present', async function () {\n      await verifyBuildInfoUpdate(true);\n    });\n    it('should get a configuration object if the local git metadata is not present', async function () {\n      getStub.onCall(0).returns({\n        data: [\n          {\n            name: `v${APPIUM_VER}`,\n            zipball_url:\n              'https://api.github.com/repos/appium/appium/zipball/v1.9.0-beta.1',\n            tarball_url:\n              'https://api.github.com/repos/appium/appium/tarball/v1.9.0-beta.1',\n            commit: {\n              sha: '3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',\n              url: 'https://api.github.com/repos/appium/appium/commits/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',\n            },\n            node_id: 'MDM6UmVmNzUzMDU3MDp2MS45LjAtYmV0YS4x',\n          },\n          {\n            name: 'v1.8.2-beta',\n            zipball_url:\n              'https://api.github.com/repos/appium/appium/zipball/v1.8.2-beta',\n            tarball_url:\n              'https://api.github.com/repos/appium/appium/tarball/v1.8.2-beta',\n            commit: {\n              sha: '5b98b9197e75aa85e7507d21d3126c1a63d1ce8f',\n              url: 'https://api.github.com/repos/appium/appium/commits/5b98b9197e75aa85e7507d21d3126c1a63d1ce8f',\n            },\n            node_id: 'MDM6UmVmNzUzMDU3MDp2MS44LjItYmV0YQ==',\n          },\n        ],\n      });\n      getStub.onCall(1).returns({\n        data: {\n          sha: '3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',\n          node_id:\n            'MDY6Q29tbWl0NzUzMDU3MDozYzI3NTJmOWY5YzU2MDAwNzA1YTRhZTE1YjNiYTY4YTVkMmU2NDRj',\n          commit: {\n            author: {\n              name: 'Isaac Murchie',\n              email: 'isaac@saucelabs.com',\n              date: '2018-08-17T19:48:00Z',\n            },\n            committer: {\n              name: 'Isaac Murchie',\n              email: 'isaac@saucelabs.com',\n              date: '2018-08-17T19:48:00Z',\n            },\n            message: 'v1.9.0-beta.1',\n            tree: {\n              sha: '2c0974727470eba419ea0b9951c52f72f8036b18',\n              url: 'https://api.github.com/repos/appium/appium/git/trees/2c0974727470eba419ea0b9951c52f72f8036b18',\n            },\n            url: 'https://api.github.com/repos/appium/appium/git/commits/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',\n            comment_count: 0,\n            verification: {\n              verified: false,\n              reason: 'unsigned',\n              signature: null,\n              payload: null,\n            },\n          },\n          url: 'https://api.github.com/repos/appium/appium/commits/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',\n          html_url:\n            'https://github.com/appium/appium/commit/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c',\n          comments_url:\n            'https://api.github.com/repos/appium/appium/commits/3c2752f9f9c56000705a4ae15b3ba68a5d2e644c/comments',\n        },\n      });\n      await verifyBuildInfoUpdate(false);\n    });\n  });\n});\n"],"file":"test/config-e2e-specs.js","sourceRoot":"../.."}

package/build/test/config-file-e2e-specs.js

@@ -0,0 +1,209 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _configFile = require("../lib/config-file");
+
+var _schema = require("../lib/schema/schema");
+
+var _driverSchema = _interopRequireDefault(require("./fixtures/driver.schema.js"));
+
+var _helpers = require("./helpers");
+
+describe('config file behavior', function () {
+  const GOOD_FILEPATH = (0, _helpers.resolveFixture)('config', 'appium.config.good.json');
+  const BAD_NODECONFIG_FILEPATH = (0, _helpers.resolveFixture)('config', 'appium.config.bad-nodeconfig.json');
+  const BAD_FILEPATH = (0, _helpers.resolveFixture)('config', 'appium.config.bad.json');
+  const INVALID_JSON_FILEPATH = (0, _helpers.resolveFixture)('config', 'appium.config.invalid.json');
+  const SECURITY_ARRAY_FILEPATH = (0, _helpers.resolveFixture)('config', 'appium.config.security-array.json');
+  const SECURITY_DELIMITED_FILEPATH = (0, _helpers.resolveFixture)('config', 'appium.config.security-delimited.json');
+  const SECURITY_PATH_FILEPATH = (0, _helpers.resolveFixture)('config', 'appium.config.security-path.json');
+  const UNKNOWN_PROPS_FILEPATH = (0, _helpers.resolveFixture)('config', 'appium.config.ext-unknown-props.json');
+  const EXT_PROPS_FILEPATH = (0, _helpers.resolveFixture)('config', 'appium.config.ext-good.json');
+  beforeEach(function () {
+    (0, _schema.finalizeSchema)();
+  });
+  afterEach(function () {
+    (0, _schema.resetSchema)();
+  });
+  describe('when provided a path to a config file', function () {
+    describe('when the config file is valid per the schema', function () {
+      it('should return a valid config object', async function () {
+        const result = await (0, _configFile.readConfigFile)(GOOD_FILEPATH, {
+          normalize: false
+        });
+        result.should.deep.equal({
+          config: require(GOOD_FILEPATH),
+          filepath: GOOD_FILEPATH,
+          errors: []
+        });
+      });
+      describe('server.nodeconfig behavior', function () {
+        describe('when a string', function () {
+          it('should return errors', async function () {
+            const result = await (0, _configFile.readConfigFile)(BAD_NODECONFIG_FILEPATH, {
+              normalize: false
+            });
+            result.should.have.nested.property('errors[0].instancePath', '/server/nodeconfig');
+          });
+        });
+        describe('when an object', function () {
+          it('should return a valid config object', async function () {
+            const result = await (0, _configFile.readConfigFile)(GOOD_FILEPATH, {
+              normalize: false
+            });
+            result.should.have.property('errors').that.is.empty;
+          });
+        });
+      });
+      describe('server.allow-insecure behavior', function () {
+        describe('when a string path', function () {
+          it('should return errors', async function () {
+            const result = await (0, _configFile.readConfigFile)(SECURITY_PATH_FILEPATH, {
+              normalize: false
+            });
+            result.should.have.nested.property('errors[0].instancePath', '/server/allow-insecure');
+          });
+        });
+        describe('when a comma-delimited string', function () {
+          it('should return errors', async function () {
+            const result = await (0, _configFile.readConfigFile)(SECURITY_DELIMITED_FILEPATH, {
+              normalize: false
+            });
+            result.should.have.nested.property('errors[0].instancePath', '/server/allow-insecure');
+          });
+        });
+        describe('when an array', function () {
+          it('should return a valid config object', async function () {
+            const result = await (0, _configFile.readConfigFile)(SECURITY_ARRAY_FILEPATH, {
+              normalize: false
+            });
+            result.should.deep.equal({
+              config: require(SECURITY_ARRAY_FILEPATH),
+              filepath: SECURITY_ARRAY_FILEPATH,
+              errors: []
+            });
+          });
+        });
+      });
+    });
+    describe('when the config file is invalid per the schema', function () {
+      describe('without extensions', function () {
+        it('should return an object containing errors', async function () {
+          const result = await (0, _configFile.readConfigFile)(BAD_FILEPATH, {
+            normalize: false
+          });
+          result.should.have.deep.property('config', require(BAD_FILEPATH));
+          result.should.have.property('filepath', BAD_FILEPATH);
+          result.should.have.deep.property('errors').that.contains.members([{
+            instancePath: '',
+            schemaPath: '#/additionalProperties',
+            keyword: 'additionalProperties',
+            params: {
+              additionalProperty: 'appium-home'
+            },
+            message: 'must NOT have additional properties',
+            isIdentifierLocation: true
+          }, {
+            instancePath: '/server/allow-cors',
+            schemaPath: '#/properties/server/properties/allow-cors/type',
+            keyword: 'type',
+            params: {
+              type: 'boolean'
+            },
+            message: 'must be boolean'
+          }, {
+            instancePath: '/server/allow-insecure',
+            schemaPath: '#/properties/server/properties/allow-insecure/type',
+            keyword: 'type',
+            params: {
+              type: 'array'
+            },
+            message: 'must be array'
+          }, {
+            instancePath: '/server/callback-port',
+            schemaPath: '#/properties/server/properties/callback-port/maximum',
+            keyword: 'maximum',
+            params: {
+              comparison: '<=',
+              limit: 65535
+            },
+            message: 'must be <= 65535'
+          }, {
+            instancePath: '/server/log-level',
+            schemaPath: '#/properties/server/properties/log-level/enum',
+            keyword: 'enum',
+            params: {
+              allowedValues: ['info', 'info:debug', 'info:info', 'info:warn', 'info:error', 'warn', 'warn:debug', 'warn:info', 'warn:warn', 'warn:error', 'error', 'error:debug', 'error:info', 'error:warn', 'error:error', 'debug', 'debug:debug', 'debug:info', 'debug:warn', 'debug:error']
+            },
+            message: 'must be equal to one of the allowed values'
+          }, {
+            instancePath: '/server/log-no-colors',
+            schemaPath: '#/properties/server/properties/log-no-colors/type',
+            keyword: 'type',
+            params: {
+              type: 'boolean'
+            },
+            message: 'must be boolean'
+          }, {
+            instancePath: '/server/port',
+            schemaPath: '#/properties/server/properties/port/type',
+            keyword: 'type',
+            params: {
+              type: 'integer'
+            },
+            message: 'must be integer'
+          }]).and.lengthOf(7);
+          result.should.have.property('reason').that.is.a.string;
+        });
+      });
+      describe('with extensions', function () {
+        let result;
+        beforeEach(function () {
+          (0, _schema.resetSchema)();
+          (0, _schema.registerSchema)('driver', 'fake', _driverSchema.default);
+          (0, _schema.finalizeSchema)();
+        });
+        describe('when provided a config file with unknown properties', function () {
+          beforeEach(async function () {
+            result = await (0, _configFile.readConfigFile)(UNKNOWN_PROPS_FILEPATH, {
+              normalize: false
+            });
+          });
+          it('should return an object containing errors', function () {
+            result.should.have.deep.property('errors', [{
+              instancePath: '/server/driver/fake',
+              schemaPath: 'driver-fake.json/additionalProperties',
+              keyword: 'additionalProperties',
+              params: {
+                additionalProperty: 'bubb'
+              },
+              message: 'must NOT have additional properties',
+              isIdentifierLocation: true
+            }]);
+          });
+        });
+        describe('when provided a config file with valid properties', function () {
+          beforeEach(async function () {
+            result = await (0, _configFile.readConfigFile)(EXT_PROPS_FILEPATH, {
+              normalize: false
+            });
+          });
+          it('should return an object containing no errors', function () {
+            result.should.have.deep.property('errors', []);
+          });
+        });
+      });
+    });
+    describe('when the config file is invalid JSON', function () {
+      it('should reject with a user-friendly error message', async function () {
+        await (0, _configFile.readConfigFile)(INVALID_JSON_FILEPATH).should.be.rejectedWith(new RegExp(`${INVALID_JSON_FILEPATH} is invalid`));
+      });
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/config-file-e2e-specs.js"],"names":["describe","GOOD_FILEPATH","BAD_NODECONFIG_FILEPATH","BAD_FILEPATH","INVALID_JSON_FILEPATH","SECURITY_ARRAY_FILEPATH","SECURITY_DELIMITED_FILEPATH","SECURITY_PATH_FILEPATH","UNKNOWN_PROPS_FILEPATH","EXT_PROPS_FILEPATH","beforeEach","afterEach","it","result","normalize","should","deep","equal","config","require","filepath","errors","have","nested","property","that","is","empty","contains","members","instancePath","schemaPath","keyword","params","additionalProperty","message","isIdentifierLocation","type","comparison","limit","allowedValues","and","lengthOf","a","string","extSchema","be","rejectedWith","RegExp"],"mappings":"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","sourcesContent":["// @ts-check\n\nimport { readConfigFile } from '../lib/config-file';\nimport { finalizeSchema, registerSchema, resetSchema } from '../lib/schema/schema';\nimport extSchema from './fixtures/driver.schema.js';\nimport { resolveFixture } from './helpers';\n\ndescribe('config file behavior', function () {\n  const GOOD_FILEPATH = resolveFixture('config', 'appium.config.good.json');\n  const BAD_NODECONFIG_FILEPATH = resolveFixture(\n    'config',\n    'appium.config.bad-nodeconfig.json',\n  );\n  const BAD_FILEPATH = resolveFixture('config', 'appium.config.bad.json');\n  const INVALID_JSON_FILEPATH = resolveFixture(\n    'config',\n    'appium.config.invalid.json',\n  );\n  const SECURITY_ARRAY_FILEPATH = resolveFixture(\n    'config',\n    'appium.config.security-array.json',\n  );\n  const SECURITY_DELIMITED_FILEPATH = resolveFixture(\n    'config',\n    'appium.config.security-delimited.json',\n  );\n  const SECURITY_PATH_FILEPATH = resolveFixture(\n    'config',\n    'appium.config.security-path.json',\n  );\n  const UNKNOWN_PROPS_FILEPATH = resolveFixture(\n    'config',\n    'appium.config.ext-unknown-props.json',\n  );\n  const EXT_PROPS_FILEPATH = resolveFixture(\n    'config',\n    'appium.config.ext-good.json',\n  );\n\n  beforeEach(function () {\n    finalizeSchema();\n  });\n\n  afterEach(function () {\n    resetSchema();\n  });\n\n  describe('when provided a path to a config file', function () {\n    describe('when the config file is valid per the schema', function () {\n      it('should return a valid config object', async function () {\n        const result = await readConfigFile(GOOD_FILEPATH, {\n          normalize: false,\n        });\n        result.should.deep.equal({\n          config: require(GOOD_FILEPATH),\n          filepath: GOOD_FILEPATH,\n          errors: [],\n        });\n      });\n\n      describe('server.nodeconfig behavior', function () {\n        describe('when a string', function () {\n          it('should return errors', async function () {\n            const result = await readConfigFile(BAD_NODECONFIG_FILEPATH, {\n              normalize: false,\n            });\n            result.should.have.nested.property(\n              'errors[0].instancePath',\n              '/server/nodeconfig',\n            );\n          });\n        });\n\n        describe('when an object', function () {\n          it('should return a valid config object', async function () {\n            const result = await readConfigFile(GOOD_FILEPATH, {\n              normalize: false,\n            });\n            result.should.have.property('errors').that.is.empty;\n          });\n        });\n      });\n\n      describe('server.allow-insecure behavior', function () {\n        describe('when a string path', function () {\n          it('should return errors', async function () {\n            const result = await readConfigFile(SECURITY_PATH_FILEPATH, {\n              normalize: false,\n            });\n            result.should.have.nested.property(\n              'errors[0].instancePath',\n              '/server/allow-insecure',\n            );\n          });\n        });\n\n        describe('when a comma-delimited string', function () {\n          it('should return errors', async function () {\n            const result = await readConfigFile(SECURITY_DELIMITED_FILEPATH, {\n              normalize: false,\n            });\n            result.should.have.nested.property(\n              'errors[0].instancePath',\n              '/server/allow-insecure',\n            );\n          });\n        });\n\n        describe('when an array', function () {\n          it('should return a valid config object', async function () {\n            const result = await readConfigFile(SECURITY_ARRAY_FILEPATH, {\n              normalize: false,\n            });\n            result.should.deep.equal({\n              config: require(SECURITY_ARRAY_FILEPATH),\n              filepath: SECURITY_ARRAY_FILEPATH,\n              errors: [],\n            });\n          });\n        });\n      });\n    });\n\n    describe('when the config file is invalid per the schema', function () {\n      describe('without extensions', function () {\n        it('should return an object containing errors', async function () {\n          const result = await readConfigFile(BAD_FILEPATH, {\n            normalize: false,\n          });\n          result.should.have.deep.property('config', require(BAD_FILEPATH));\n          result.should.have.property('filepath', BAD_FILEPATH);\n          result.should.have.deep.property('errors').that.contains.members([\n            {\n              instancePath: '',\n              schemaPath: '#/additionalProperties',\n              keyword: 'additionalProperties',\n              params: {\n                additionalProperty: 'appium-home',\n              },\n              message: 'must NOT have additional properties',\n              isIdentifierLocation: true,\n            },\n            {\n              instancePath: '/server/allow-cors',\n              schemaPath: '#/properties/server/properties/allow-cors/type',\n              keyword: 'type',\n              params: {\n                type: 'boolean',\n              },\n              message: 'must be boolean',\n            },\n            {\n              instancePath: '/server/allow-insecure',\n              schemaPath: '#/properties/server/properties/allow-insecure/type',\n              keyword: 'type',\n              params: {\n                type: 'array'\n              },\n              message: 'must be array',\n            },\n            {\n              instancePath: '/server/callback-port',\n              schemaPath:\n                '#/properties/server/properties/callback-port/maximum',\n              keyword: 'maximum',\n              params: {\n                comparison: '<=',\n                limit: 65535,\n              },\n              message: 'must be <= 65535',\n            },\n            {\n              instancePath: '/server/log-level',\n              schemaPath: '#/properties/server/properties/log-level/enum',\n              keyword: 'enum',\n              params: {\n                allowedValues: [\n                  'info',\n                  'info:debug',\n                  'info:info',\n                  'info:warn',\n                  'info:error',\n                  'warn',\n                  'warn:debug',\n                  'warn:info',\n                  'warn:warn',\n                  'warn:error',\n                  'error',\n                  'error:debug',\n                  'error:info',\n                  'error:warn',\n                  'error:error',\n                  'debug',\n                  'debug:debug',\n                  'debug:info',\n                  'debug:warn',\n                  'debug:error',\n                ],\n              },\n              message: 'must be equal to one of the allowed values',\n            },\n            {\n              instancePath: '/server/log-no-colors',\n              schemaPath: '#/properties/server/properties/log-no-colors/type',\n              keyword: 'type',\n              params: {\n                type: 'boolean',\n              },\n              message: 'must be boolean',\n            },\n            {\n              instancePath: '/server/port',\n              schemaPath: '#/properties/server/properties/port/type',\n              keyword: 'type',\n              params: {\n                type: 'integer',\n              },\n              message: 'must be integer',\n            },\n          ]).and.lengthOf(7);\n\n          result.should.have.property('reason').that.is.a.string;\n        });\n      });\n\n      describe('with extensions', function () {\n        /** @type {import('../lib/config-file').ReadConfigFileResult} */\n        let result;\n\n        beforeEach(function () {\n          resetSchema();\n          registerSchema('driver', 'fake', extSchema);\n          finalizeSchema();\n        });\n\n        describe('when provided a config file with unknown properties', function () {\n          beforeEach(async function () {\n            result = await readConfigFile(UNKNOWN_PROPS_FILEPATH, {\n              normalize: false,\n            });\n          });\n          it('should return an object containing errors', function () {\n            result.should.have.deep.property('errors', [\n              {\n                instancePath: '/server/driver/fake',\n                schemaPath:\n                  'driver-fake.json/additionalProperties',\n                keyword: 'additionalProperties',\n                params: {additionalProperty: 'bubb'},\n                message: 'must NOT have additional properties',\n                isIdentifierLocation: true,\n              },\n            ]);\n          });\n        });\n\n        describe('when provided a config file with valid properties', function () {\n          beforeEach(async function () {\n            result = await readConfigFile(EXT_PROPS_FILEPATH, {\n              normalize: false,\n            });\n          });\n          it('should return an object containing no errors', function () {\n            result.should.have.deep.property('errors', []);\n          });\n        });\n      });\n    });\n\n    describe('when the config file is invalid JSON', function () {\n      it('should reject with a user-friendly error message', async function () {\n        await readConfigFile(INVALID_JSON_FILEPATH).should.be.rejectedWith(\n          new RegExp(`${INVALID_JSON_FILEPATH} is invalid`),\n        );\n      });\n    });\n  });\n});\n"],"file":"test/config-file-e2e-specs.js","sourceRoot":"../.."}