appium 2.0.0-beta.21 → 2.0.0-beta.25

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

@@ -0,0 +1,191 @@
+"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);
+        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);
+            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);
+            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);
+            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);
+            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);
+            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);
+          result.should.have.deep.property('config', (0, _configFile.normalizeConfig)(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);
+          });
+          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);
+          });
+          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","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, normalizeConfig } 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\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        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            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            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            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            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            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          result.should.have.deep.property('config', normalizeConfig(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          });\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          });\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":"../.."}

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

@@ -0,0 +1,281 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _fs = _interopRequireDefault(require("fs"));
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+var _yaml = _interopRequireDefault(require("yaml"));
+
+var schema = _interopRequireWildcard(require("../lib/schema/schema"));
+
+var _helpers = require("./helpers");
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+const expect = chai.expect;
+describe('config-file', function () {
+  const GOOD_YAML_CONFIG_FILEPATH = (0, _helpers.resolveFixture)('config', 'appium.config.good.yaml');
+  const GOOD_JSON_CONFIG_FILEPATH = (0, _helpers.resolveFixture)('config', 'appium.config.good.json');
+  const GOOD_JS_CONFIG_FILEPATH = (0, _helpers.resolveFixture)('config', 'appium.config.good.js');
+
+  const GOOD_YAML_CONFIG = _yaml.default.parse(_fs.default.readFileSync(GOOD_YAML_CONFIG_FILEPATH, 'utf8'));
+
+  const GOOD_JSON_CONFIG = require(GOOD_JSON_CONFIG_FILEPATH);
+
+  const BAD_JSON_CONFIG_FILEPATH = (0, _helpers.resolveFixture)('config', 'appium.config.bad.json');
+
+  const BAD_JSON_CONFIG = require(BAD_JSON_CONFIG_FILEPATH);
+
+  let sandbox;
+  let readConfigFile;
+  let lc;
+  let configFileModule;
+  let mocks;
+  before(function () {
+    schema.finalizeSchema();
+  });
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    const load = sandbox.stub().resolves({
+      config: GOOD_JSON_CONFIG,
+      filepath: GOOD_JSON_CONFIG_FILEPATH
+    });
+    load.withArgs(GOOD_YAML_CONFIG_FILEPATH).resolves({
+      config: GOOD_YAML_CONFIG,
+      filepath: GOOD_YAML_CONFIG_FILEPATH
+    });
+    load.withArgs(BAD_JSON_CONFIG_FILEPATH).resolves({
+      config: BAD_JSON_CONFIG,
+      filepath: BAD_JSON_CONFIG_FILEPATH
+    });
+    const search = sandbox.stub().resolves({
+      config: GOOD_JSON_CONFIG,
+      filepath: GOOD_JSON_CONFIG_FILEPATH
+    });
+    lc = {
+      load,
+      search
+    };
+    mocks = {
+      lilconfig: {
+        lilconfig: sandbox.stub().returns(lc)
+      },
+      '@sidvind/better-ajv-errors': sandbox.stub().returns('')
+    };
+    configFileModule = _helpers.rewiremock.proxy(() => require('../lib/config-file'), mocks);
+    readConfigFile = configFileModule.readConfigFile;
+    sandbox.spy(schema, 'validate');
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('readConfigFile()', function () {
+    let result;
+    it('should support yaml', async function () {
+      const {
+        config
+      } = await readConfigFile(GOOD_YAML_CONFIG_FILEPATH);
+      expect(config).to.eql(GOOD_JSON_CONFIG);
+      expect(schema.validate).to.have.been.calledOnce;
+    });
+    it('should support json', async function () {
+      const {
+        config
+      } = await readConfigFile(GOOD_JSON_CONFIG_FILEPATH);
+      expect(config).to.eql(GOOD_JSON_CONFIG);
+      expect(schema.validate).to.have.been.calledOnce;
+    });
+    it('should support js', async function () {
+      const {
+        config
+      } = await readConfigFile(GOOD_JS_CONFIG_FILEPATH);
+      expect(config).to.eql(GOOD_JSON_CONFIG);
+      expect(schema.validate).to.have.been.calledOnce;
+    });
+    describe('when no filepath provided', function () {
+      beforeEach(async function () {
+        result = await readConfigFile();
+      });
+      it('should search for a config file', function () {
+        expect(lc.search).to.have.been.calledOnce;
+        expect(schema.validate).to.have.been.calledOnce;
+      });
+      it('should not try to load a config file directly', function () {
+        expect(lc.load).to.not.have.been.called;
+      });
+      describe('when no config file is found', function () {
+        beforeEach(async function () {
+          lc.search.resolves();
+          schema.validate.resetHistory();
+          result = await readConfigFile();
+        });
+        it('should resolve with an empty object', function () {
+          expect(result).to.be.an('object').that.is.empty;
+          expect(schema.validate).not.to.have.been.called;
+        });
+      });
+      describe('when a config file is found', function () {
+        describe('when the config file is empty', function () {
+          beforeEach(async function () {
+            lc.search.resolves({
+              isEmpty: true,
+              filepath: '/path/to/file.json',
+              config: {}
+            });
+            result = await readConfigFile();
+          });
+          it('should resolve with an object with an `isEmpty` property', function () {
+            expect(result).to.have.property('isEmpty', true);
+          });
+        });
+        describe('when the config file is not empty', function () {
+          it('should validate the config against a schema', function () {
+            expect(schema.validate).to.have.been.calledOnceWith(GOOD_JSON_CONFIG);
+          });
+          describe('when the config file is valid', function () {
+            beforeEach(async function () {
+              result = await readConfigFile();
+            });
+            it('should resolve with an object having `config` property and empty array of errors', function () {
+              expect(result).to.deep.equal({
+                config: GOOD_JSON_CONFIG,
+                errors: [],
+                filepath: GOOD_JSON_CONFIG_FILEPATH
+              });
+            });
+          });
+          describe('when the config file is invalid', function () {
+            beforeEach(function () {
+              lc.search.resolves({
+                config: {
+                  foo: 'bar'
+                },
+                filepath: '/path/to/file.json'
+              });
+            });
+            beforeEach(async function () {
+              result = await readConfigFile();
+            });
+            it('should resolve with an object having a nonempty array of errors', function () {
+              expect(result).to.have.property('errors').that.is.not.empty;
+            });
+          });
+        });
+      });
+    });
+    describe('when filepath provided', function () {
+      beforeEach(async function () {
+        result = await readConfigFile('appium.json');
+      });
+      it('should not attempt to find a config file', function () {
+        expect(lc.search).to.not.have.been.called;
+      });
+      it('should try to load a config file directly', function () {
+        expect(lc.load).to.have.been.calledOnce;
+      });
+      describe('when no config file exists at path', function () {
+        beforeEach(function () {
+          lc.load.rejects(Object.assign(new Error(), {
+            code: 'ENOENT'
+          }));
+        });
+        it('should reject with user-friendly message', async function () {
+          await expect(readConfigFile('appium.json')).to.be.rejectedWith(/not found at user-provided path/);
+        });
+      });
+      describe('when the config file is invalid JSON', function () {
+        beforeEach(function () {
+          lc.load.rejects(new SyntaxError());
+        });
+        it('should reject with user-friendly message', async function () {
+          await expect(readConfigFile('appium.json')).to.be.rejectedWith(/Config file at user-provided path appium.json is invalid/);
+        });
+      });
+      describe('when something else is wrong with loading the config file', function () {
+        beforeEach(function () {
+          lc.load.rejects(new Error('guru meditation'));
+        });
+        it('should pass error through', async function () {
+          await expect(readConfigFile('appium.json')).to.be.rejectedWith(/guru meditation/);
+        });
+      });
+      describe('when a config file is found', function () {
+        describe('when the config file is empty', function () {
+          beforeEach(async function () {
+            lc.search.resolves({
+              isEmpty: true,
+              filepath: '/path/to/file.json',
+              config: {}
+            });
+            result = await readConfigFile();
+          });
+          it('should resolve with an object with an `isEmpty` property', function () {
+            expect(result).to.have.property('isEmpty', true);
+          });
+        });
+        describe('when the config file is not empty', function () {
+          it('should validate the config against a schema', function () {
+            expect(schema.validate).to.have.been.calledOnceWith(GOOD_JSON_CONFIG);
+          });
+          describe('when the config file is valid', function () {
+            beforeEach(async function () {
+              result = await readConfigFile();
+            });
+            it('should resolve with an object having `config` property and empty array of errors', function () {
+              expect(result).to.deep.equal({
+                errors: [],
+                config: GOOD_JSON_CONFIG,
+                filepath: GOOD_JSON_CONFIG_FILEPATH
+              });
+            });
+          });
+          describe('when the config file is invalid', function () {
+            beforeEach(async function () {
+              result = await readConfigFile(BAD_JSON_CONFIG_FILEPATH);
+            });
+            it('should resolve with an object having a nonempty array of errors', function () {
+              expect(result).to.have.property('errors').that.is.not.empty;
+            });
+          });
+        });
+      });
+    });
+  });
+  describe('formatErrors()', function () {
+    describe('when provided `errors` as an empty array', function () {
+      it('should throw', function () {
+        expect(() => configFileModule.formatErrors([])).to.throw(TypeError, 'Array of errors must be non-empty');
+      });
+    });
+    describe('when provided `errors` as `undefined`', function () {
+      it('should throw', function () {
+        expect(() => configFileModule.formatErrors()).to.throw(TypeError, 'Array of errors must be non-empty');
+      });
+    });
+    describe('when provided `errors` as a non-empty array', function () {
+      it('should return a string', function () {
+        expect(configFileModule.formatErrors([{}])).to.be.a('string');
+      });
+    });
+    describe('when `opts.json` is a string', function () {
+      it('should call `betterAjvErrors()` with option `json: opts.json`', function () {
+        configFileModule.formatErrors([{}], {}, {
+          json: '{"foo": "bar"}'
+        });
+        expect(mocks['@sidvind/better-ajv-errors']).to.have.been.calledWith(schema.getSchema(), {}, [{}], {
+          format: 'cli',
+          json: '{"foo": "bar"}'
+        });
+      });
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/config-file-specs.js"],"names":["expect","chai","describe","GOOD_YAML_CONFIG_FILEPATH","GOOD_JSON_CONFIG_FILEPATH","GOOD_JS_CONFIG_FILEPATH","GOOD_YAML_CONFIG","YAML","parse","fs","readFileSync","GOOD_JSON_CONFIG","require","BAD_JSON_CONFIG_FILEPATH","BAD_JSON_CONFIG","sandbox","readConfigFile","lc","configFileModule","mocks","before","schema","finalizeSchema","beforeEach","sinon","createSandbox","load","stub","resolves","config","filepath","withArgs","search","lilconfig","returns","rewiremock","proxy","spy","afterEach","restore","result","it","to","eql","validate","have","been","calledOnce","not","called","resetHistory","be","an","that","is","empty","isEmpty","property","calledOnceWith","deep","equal","errors","foo","rejects","Object","assign","Error","code","rejectedWith","SyntaxError","formatErrors","throw","TypeError","a","json","calledWith","getSchema","format"],"mappings":"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","sourcesContent":["// @ts-check\n\nimport fs from 'fs';\nimport sinon from 'sinon';\nimport YAML from 'yaml';\nimport * as schema from '../lib/schema/schema';\nimport { resolveFixture, rewiremock } from './helpers';\n\nconst expect = chai.expect;\n\ndescribe('config-file', function () {\n  const GOOD_YAML_CONFIG_FILEPATH = resolveFixture(\n    'config',\n    'appium.config.good.yaml',\n  );\n  const GOOD_JSON_CONFIG_FILEPATH = resolveFixture(\n    'config',\n    'appium.config.good.json',\n  );\n  const GOOD_JS_CONFIG_FILEPATH = resolveFixture('config', 'appium.config.good.js');\n  const GOOD_YAML_CONFIG = YAML.parse(\n    fs.readFileSync(GOOD_YAML_CONFIG_FILEPATH, 'utf8'),\n  );\n  const GOOD_JSON_CONFIG = require(GOOD_JSON_CONFIG_FILEPATH);\n  const BAD_JSON_CONFIG_FILEPATH = resolveFixture(\n    'config',\n    'appium.config.bad.json',\n  );\n  const BAD_JSON_CONFIG = require(BAD_JSON_CONFIG_FILEPATH);\n\n  /**\n   * @type {import('sinon').SinonSandbox}\n   */\n  let sandbox;\n\n  /**\n   * `readConfigFile()` from an isolated `config-file` module\n   * @type {typeof import('../lib/config-file').readConfigFile}\n   */\n  let readConfigFile;\n  /**\n   * Mock instance of `lilconfig` containing stubs for\n   * `lilconfig#search()` and `lilconfig#load`.\n   * Not _actually_ a `SinonStubbedInstance`, but duck-typed.\n   * @type {import('sinon').SinonStubbedInstance<ReturnType<import('lilconfig').lilconfig>>}\n   */\n  let lc;\n\n  /**\n   * @type {typeof import('../lib/config-file')}\n   */\n  let configFileModule;\n\n  let mocks;\n\n  before(function () {\n    // generally called via the CLI parser, this needs to be done manually in tests.\n    // we don't need to do this before _each_ test, because we're not changing the schema.\n    // if we did change the schema, this would need to be in `beforeEach()` and `afterEach()`\n    // would need to call `schema.reset()`.\n    schema.finalizeSchema();\n  });\n\n  beforeEach(function () {\n    sandbox = sinon.createSandbox();\n\n    // we have to manually type this (and `search()`) because we'd only get the real type\n    // when stubbing an object prop; e.g., `stub(lilconfig, 'load')`\n    const load = /** @type {AsyncSearcherLoadStub} */ (\n      sandbox.stub().resolves({\n        config: GOOD_JSON_CONFIG,\n        filepath: GOOD_JSON_CONFIG_FILEPATH,\n      })\n    );\n    load.withArgs(GOOD_YAML_CONFIG_FILEPATH).resolves({\n      config: GOOD_YAML_CONFIG,\n      filepath: GOOD_YAML_CONFIG_FILEPATH,\n    });\n    load.withArgs(BAD_JSON_CONFIG_FILEPATH).resolves({\n      config: BAD_JSON_CONFIG,\n      filepath: BAD_JSON_CONFIG_FILEPATH,\n    });\n\n    const search = /** @type {AsyncSearcherLoadStub} */ (\n      sandbox.stub().resolves({\n        config: GOOD_JSON_CONFIG,\n        filepath: GOOD_JSON_CONFIG_FILEPATH,\n      })\n    );\n\n    lc = {\n      load,\n      search,\n    };\n\n    mocks = {\n      lilconfig: {\n        lilconfig: sandbox.stub().returns(lc),\n      },\n      '@sidvind/better-ajv-errors': sandbox.stub().returns(''),\n    };\n\n    // loads the `config-file` module using the lilconfig mock.\n    // we only mock lilconfig because it'd otherwise be a pain in the rear to test\n    // searching for config files, and it increases the likelihood that we'd load the wrong file.\n    configFileModule = rewiremock.proxy(() => require('../lib/config-file'), mocks);\n    readConfigFile = configFileModule.readConfigFile;\n\n    // just want to be extra-sure `validate()` happens\n    sandbox.spy(schema, 'validate');\n  });\n\n  afterEach(function () {\n    sandbox.restore();\n  });\n\n  describe('readConfigFile()', function () {\n    /**\n     * @type {import('../lib/config-file').ReadConfigFileResult}\n     */\n    let result;\n\n    it('should support yaml', async function () {\n      const {config} = await readConfigFile(GOOD_YAML_CONFIG_FILEPATH);\n      expect(config).to.eql(GOOD_JSON_CONFIG);\n      expect(schema.validate).to.have.been.calledOnce;\n    });\n\n    it('should support json', async function () {\n      const {config} = await readConfigFile(GOOD_JSON_CONFIG_FILEPATH);\n      expect(config).to.eql(GOOD_JSON_CONFIG);\n      expect(schema.validate).to.have.been.calledOnce;\n    });\n\n    it('should support js', async function () {\n      const {config} = await readConfigFile(GOOD_JS_CONFIG_FILEPATH);\n      expect(config).to.eql(GOOD_JSON_CONFIG);\n      expect(schema.validate).to.have.been.calledOnce;\n    });\n\n    describe('when no filepath provided', function () {\n      beforeEach(async function () {\n        result = await readConfigFile();\n      });\n\n      it('should search for a config file', function () {\n        expect(lc.search).to.have.been.calledOnce;\n        expect(schema.validate).to.have.been.calledOnce;\n      });\n\n      it('should not try to load a config file directly', function () {\n        expect(lc.load).to.not.have.been.called;\n      });\n\n      describe('when no config file is found', function () {\n        beforeEach(async function () {\n          lc.search.resolves();\n          /** @type {import('sinon').SinonSpiedMember<typeof schema.validate>} */(schema.validate).resetHistory();\n          result = await readConfigFile();\n        });\n\n        it('should resolve with an empty object', function () {\n          expect(result).to.be.an('object').that.is.empty;\n          expect(schema.validate).not.to.have.been.called;\n        });\n      });\n\n      describe('when a config file is found', function () {\n        describe('when the config file is empty', function () {\n          beforeEach(async function () {\n            lc.search.resolves({\n              isEmpty: true,\n              filepath: '/path/to/file.json',\n              config: {},\n            });\n\n            result = await readConfigFile();\n          });\n\n          it('should resolve with an object with an `isEmpty` property', function () {\n            expect(result).to.have.property('isEmpty', true);\n          });\n        });\n\n        describe('when the config file is not empty', function () {\n          it('should validate the config against a schema', function () {\n            expect(schema.validate).to.have.been.calledOnceWith(\n              GOOD_JSON_CONFIG,\n            );\n          });\n\n          describe('when the config file is valid', function () {\n            beforeEach(async function () {\n              result = await readConfigFile();\n            });\n\n            it('should resolve with an object having `config` property and empty array of errors', function () {\n              expect(result).to.deep.equal({\n                config: GOOD_JSON_CONFIG,\n                errors: [],\n                filepath: GOOD_JSON_CONFIG_FILEPATH,\n              });\n            });\n          });\n\n          describe('when the config file is invalid', function () {\n            beforeEach(function () {\n              lc.search.resolves({\n                config: {foo: 'bar'},\n                filepath: '/path/to/file.json',\n              });\n            });\n\n            beforeEach(async function () {\n              result = await readConfigFile();\n            });\n\n            it('should resolve with an object having a nonempty array of errors', function () {\n              expect(result).to.have.property('errors').that.is.not.empty;\n            });\n          });\n        });\n      });\n    });\n\n    describe('when filepath provided', function () {\n      beforeEach(async function () {\n        result = await readConfigFile('appium.json');\n      });\n\n      it('should not attempt to find a config file', function () {\n        expect(lc.search).to.not.have.been.called;\n      });\n\n      it('should try to load a config file directly', function () {\n        expect(lc.load).to.have.been.calledOnce;\n      });\n\n      describe('when no config file exists at path', function () {\n        beforeEach(function () {\n          lc.load.rejects(Object.assign(new Error(), {code: 'ENOENT'}));\n        });\n\n        it('should reject with user-friendly message', async function () {\n          await expect(readConfigFile('appium.json')).to.be.rejectedWith(\n            /not found at user-provided path/,\n          );\n        });\n      });\n\n      describe('when the config file is invalid JSON', function () {\n        beforeEach(function () {\n          lc.load.rejects(new SyntaxError());\n        });\n\n        it('should reject with user-friendly message', async function () {\n          await expect(readConfigFile('appium.json')).to.be.rejectedWith(\n            /Config file at user-provided path appium.json is invalid/,\n          );\n        });\n      });\n\n      describe('when something else is wrong with loading the config file', function () {\n        beforeEach(function () {\n          lc.load.rejects(new Error('guru meditation'));\n        });\n\n        it('should pass error through', async function () {\n          await expect(readConfigFile('appium.json')).to.be.rejectedWith(\n            /guru meditation/,\n          );\n        });\n      });\n\n      describe('when a config file is found', function () {\n        describe('when the config file is empty', function () {\n          beforeEach(async function () {\n            lc.search.resolves({\n              isEmpty: true,\n              filepath: '/path/to/file.json',\n              config: {},\n            });\n            result = await readConfigFile();\n          });\n\n          it('should resolve with an object with an `isEmpty` property', function () {\n            expect(result).to.have.property('isEmpty', true);\n          });\n        });\n\n        describe('when the config file is not empty', function () {\n          it('should validate the config against a schema', function () {\n            expect(schema.validate).to.have.been.calledOnceWith(\n              GOOD_JSON_CONFIG,\n            );\n          });\n\n          describe('when the config file is valid', function () {\n            beforeEach(async function () {\n              result = await readConfigFile();\n            });\n\n            it('should resolve with an object having `config` property and empty array of errors', function () {\n              expect(result).to.deep.equal({\n                errors: [],\n                config: GOOD_JSON_CONFIG,\n                filepath: GOOD_JSON_CONFIG_FILEPATH,\n              });\n            });\n          });\n\n          describe('when the config file is invalid', function () {\n            beforeEach(async function () {\n              result = await readConfigFile(BAD_JSON_CONFIG_FILEPATH);\n            });\n\n            it('should resolve with an object having a nonempty array of errors', function () {\n              expect(result).to.have.property('errors').that.is.not.empty;\n            });\n          });\n        });\n      });\n    });\n  });\n\n  describe('formatErrors()', function () {\n    describe('when provided `errors` as an empty array', function () {\n      it('should throw', function () {\n        expect(() => configFileModule.formatErrors([])).to.throw(\n          TypeError,\n          'Array of errors must be non-empty',\n        );\n      });\n    });\n\n    describe('when provided `errors` as `undefined`', function () {\n      it('should throw', function () {\n        // @ts-ignore\n        expect(() => configFileModule.formatErrors()).to.throw(\n          TypeError,\n          'Array of errors must be non-empty',\n        );\n      });\n    });\n\n    describe('when provided `errors` as a non-empty array', function () {\n      it('should return a string', function () {\n        // @ts-ignore\n        expect(configFileModule.formatErrors([{}])).to.be.a('string');\n      });\n    });\n\n    describe('when `opts.json` is a string', function () {\n      it('should call `betterAjvErrors()` with option `json: opts.json`', function () {\n        // @ts-ignore\n        configFileModule.formatErrors([{}], {}, {json: '{\"foo\": \"bar\"}'});\n        expect(mocks['@sidvind/better-ajv-errors']).to.have.been.calledWith(\n          schema.getSchema(),\n          {},\n          [{}],\n          {format: 'cli', json: '{\"foo\": \"bar\"}'},\n        );\n      });\n    });\n  });\n});\n\n// the following are just aliases\n\n/**\n * @typedef {import('ajv').ErrorObject} ErrorObject\n */\n\n/**\n * @typedef {import('ajv').ValidateFunction} ValidateFunction\n */\n\n/**\n * @typedef {import('sinon').SinonStubbedMember<ReturnType<import('lilconfig').lilconfig>['load']>} AsyncSearcherLoadStub\n */\n\n/**\n * @typedef {import('sinon').SinonStubbedMember<ReturnType<import('lilconfig').lilconfig>['search']>} AsyncSearcherSearchStub\n */\n"],"file":"test/config-file-specs.js","sourceRoot":"../.."}