appium 2.0.0-beta.2 → 2.0.0-beta.23

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

@@ -0,0 +1,365 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _path = _interopRequireDefault(require("path"));
+
+var _node = _interopRequireDefault(require("rewiremock/node"));
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+const expect = chai.expect;
+describe('ExtensionConfig', function () {
+  describe('getGenericConfigProblems()', function () {
+    it('should have some tests');
+  });
+  describe('DriverConfig', function () {
+    let DriverConfig;
+    let mocks;
+    let sandbox;
+    beforeEach(function () {
+      mocks = {
+        'resolve-from': _sinon.default.stub().callsFake((cwd, id) => _path.default.join(cwd, id))
+      };
+      DriverConfig = _node.default.proxy(() => require('../lib/driver-config'), mocks).default;
+      sandbox = _sinon.default.createSandbox();
+    });
+    afterEach(function () {
+      sandbox.restore();
+    });
+    describe('extensionDesc()', function () {
+      it('should return the description of the extension', function () {
+        const config = DriverConfig.getInstance('/tmp/');
+        config.extensionDesc('foo', {
+          version: '1.0',
+          automationName: 'bar'
+        }).should.equal(`foo@1.0 (automationName 'bar')`);
+      });
+    });
+    describe('getConfigProblems()', function () {
+      let driverConfig;
+      beforeEach(function () {
+        driverConfig = DriverConfig.getInstance('/tmp/');
+      });
+      describe('when provided no arguments', function () {
+        it('should throw', function () {
+          (() => driverConfig.getConfigProblems()).should.throw();
+        });
+      });
+      describe('property `platformNames`', function () {
+        describe('when provided an object with no `platformNames` property', function () {
+          it('should return an array with an associated problem', function () {
+            driverConfig.getConfigProblems({}, 'foo').should.deep.include({
+              err: 'Missing or incorrect supported platformNames list.',
+              val: undefined
+            });
+          });
+        });
+        describe('when provided an object with an empty `platformNames` property', function () {
+          it('should return an array with an associated problem', function () {
+            driverConfig.getConfigProblems({
+              platformNames: []
+            }, 'foo').should.deep.include({
+              err: 'Empty platformNames list.',
+              val: []
+            });
+          });
+        });
+        describe('when provided an object with a non-array `platformNames` property', function () {
+          it('should return an array with an associated problem', function () {
+            driverConfig.getConfigProblems({
+              platformNames: 'foo'
+            }, 'foo').should.deep.include({
+              err: 'Missing or incorrect supported platformNames list.',
+              val: 'foo'
+            });
+          });
+        });
+        describe('when provided a non-empty array containing a non-string item', function () {
+          it('should return an array with an associated problem', function () {
+            driverConfig.getConfigProblems({
+              platformNames: ['a', 1]
+            }, 'foo').should.deep.include({
+              err: 'Incorrectly formatted platformName.',
+              val: 1
+            });
+          });
+        });
+      });
+      describe('property `automationName`', function () {
+        describe('when provided an object with a missing `automationName` property', function () {
+          it('should return an array with an associated problem', function () {
+            driverConfig.getConfigProblems({}, 'foo').should.deep.include({
+              err: 'Missing or incorrect automationName',
+              val: undefined
+            });
+          });
+        });
+        describe('when provided a conflicting automationName', function () {
+          it('should return an array with an associated problem', function () {
+            driverConfig.getConfigProblems({
+              automationName: 'foo'
+            }, 'foo');
+            driverConfig.getConfigProblems({
+              automationName: 'foo'
+            }, 'foo').should.deep.include({
+              err: 'Multiple drivers claim support for the same automationName',
+              val: 'foo'
+            });
+          });
+        });
+      });
+    });
+    describe('getSchemaProblems()', function () {
+      let driverConfig;
+      beforeEach(function () {
+        driverConfig = DriverConfig.getInstance('/tmp/');
+      });
+      describe('when provided an object with a defined non-string `schema` property', function () {
+        it('should return an array with an associated problem', function () {
+          driverConfig.getSchemaProblems({
+            schema: []
+          }, 'foo').should.deep.include({
+            err: 'Incorrectly formatted schema field; must be a path to a schema file or a schema object.',
+            val: []
+          });
+        });
+      });
+      describe('when provided a string `schema` property', function () {
+        describe('when the property ends in an unsupported extension', function () {
+          it('should return an array with an associated problem', function () {
+            driverConfig.getSchemaProblems({
+              schema: 'selenium.java'
+            }, 'foo').should.deep.include({
+              err: 'Schema file has unsupported extension. Allowed: .json, .js, .cjs',
+              val: 'selenium.java'
+            });
+          });
+        });
+        describe('when the property contains a supported extension', function () {
+          describe('when the property as a path cannot be found', function () {
+            it('should return an array with an associated problem', function () {
+              const problems = driverConfig.getSchemaProblems({
+                installPath: '/usr/bin/derp',
+                pkgName: 'doop',
+                schema: 'herp.json'
+              }, 'foo');
+              problems[0].err.should.match(/Unable to register schema at path herp\.json/i);
+            });
+          });
+          describe('when the property as a path is found', function () {
+            it('should return an empty array', function () {
+              const problems = driverConfig.getSchemaProblems({
+                pkgName: 'fixtures',
+                installPath: __dirname,
+                schema: 'driver.schema.js'
+              }, 'foo');
+              problems.should.be.empty;
+            });
+          });
+        });
+      });
+    });
+    describe('read()', function () {
+      let driverConfig;
+      beforeEach(function () {
+        driverConfig = DriverConfig.getInstance('/tmp/');
+        sandbox.spy(driverConfig, 'validate');
+      });
+      it('should validate the extension', async function () {
+        await driverConfig.read();
+        driverConfig.validate.should.have.been.calledOnce;
+      });
+    });
+    describe('readExtensionSchema()', function () {
+      let driverConfig;
+      let extData;
+      const extName = 'stuff';
+      beforeEach(function () {
+        extData = {
+          installPath: 'fixtures',
+          pkgName: 'some-pkg',
+          schema: 'driver.schema.js'
+        };
+        mocks['resolve-from'].returns(require.resolve('./fixtures/driver.schema.js'));
+        driverConfig = DriverConfig.getInstance('/tmp/');
+      });
+      describe('when the extension data is missing `schema`', function () {
+        it('should throw', function () {
+          delete extData.schema;
+          expect(() => driverConfig.readExtensionSchema(extName, extData)).to.throw(TypeError, /why is this function being called/i);
+        });
+      });
+      describe('when the extension schema has already been registered (with the same schema)', function () {
+        it('should not throw', function () {
+          driverConfig.readExtensionSchema(extName, extData);
+          expect(() => driverConfig.readExtensionSchema(extName, extData)).not.to.throw();
+        });
+      });
+      describe('when the extension schema has not yet been registered', function () {
+        it('should resolve and load the extension schema file', function () {
+          driverConfig.readExtensionSchema(extName, extData);
+          expect(mocks['resolve-from']).to.have.been.calledOnce;
+        });
+      });
+    });
+  });
+  describe('PluginConfig', function () {
+    let PluginConfig;
+    let mocks;
+    let sandbox;
+    beforeEach(function () {
+      mocks = {
+        'resolve-from': _sinon.default.stub().callsFake((cwd, id) => _path.default.join(cwd, id))
+      };
+      PluginConfig = _node.default.proxy(() => require('../lib/plugin-config'), mocks).default;
+      sandbox = _sinon.default.createSandbox();
+    });
+    afterEach(function () {
+      sandbox.restore();
+    });
+    describe('extensionDesc()', function () {
+      it('should return the description of the extension', function () {
+        const config = PluginConfig.getInstance('/tmp/');
+        config.extensionDesc('foo', {
+          version: '1.0'
+        }).should.equal(`foo@1.0`);
+      });
+    });
+    describe('getConfigProblems()', function () {
+      let pluginConfig;
+      beforeEach(function () {
+        pluginConfig = PluginConfig.getInstance('/tmp/');
+      });
+      describe('when provided no arguments', function () {
+        it('should not throw', function () {
+          (() => pluginConfig.getConfigProblems()).should.not.throw();
+        });
+      });
+    });
+    describe('getSchemaProblems()', function () {
+      let pluginConfig;
+      beforeEach(function () {
+        pluginConfig = PluginConfig.getInstance('/tmp/');
+      });
+      describe('when provided an object with a defined `schema` property of unsupported type', function () {
+        it('should return an array with an associated problem', function () {
+          pluginConfig.getSchemaProblems({
+            schema: []
+          }, 'foo').should.deep.include({
+            err: 'Incorrectly formatted schema field; must be a path to a schema file or a schema object.',
+            val: []
+          });
+        });
+      });
+      describe('when provided a string `schema` property', function () {
+        describe('when the property ends in an unsupported extension', function () {
+          it('should return an array with an associated problem', function () {
+            pluginConfig.getSchemaProblems({
+              schema: 'selenium.java'
+            }, 'foo').should.deep.include({
+              err: 'Schema file has unsupported extension. Allowed: .json, .js, .cjs',
+              val: 'selenium.java'
+            });
+          });
+        });
+        describe('when the property contains a supported extension', function () {
+          describe('when the property as a path cannot be found', function () {
+            it('should return an array with an associated problem', function () {
+              const problems = pluginConfig.getSchemaProblems({
+                installPath: '/usr/bin/derp',
+                pkgName: 'doop',
+                schema: 'herp.json'
+              }, 'foo');
+              problems[0].err.should.match(/Unable to register schema at path herp\.json/i);
+            });
+          });
+          describe('when the property as a path is found', function () {
+            it('should return an empty array', function () {
+              const problems = pluginConfig.getSchemaProblems({
+                pkgName: 'fixtures',
+                installPath: __dirname,
+                schema: 'plugin.schema.js'
+              }, 'foo');
+              problems.should.be.empty;
+            });
+          });
+        });
+      });
+      describe('when provided an object `schema` property', function () {
+        it('should return an empty array', function () {
+          const problems = pluginConfig.getSchemaProblems({
+            pkgName: 'fixtures',
+            installPath: __dirname,
+            schema: {
+              type: 'object',
+              properties: {
+                foo: {
+                  type: 'string'
+                }
+              }
+            }
+          }, 'foo');
+          problems.should.be.empty;
+        });
+      });
+    });
+    describe('read()', function () {
+      let pluginConfig;
+      beforeEach(function () {
+        pluginConfig = PluginConfig.getInstance('/tmp/');
+        sandbox.spy(pluginConfig, 'validate');
+      });
+      it('should validate the extension', async function () {
+        await pluginConfig.read();
+        pluginConfig.validate.should.have.been.calledOnce;
+      });
+    });
+    describe('readExtensionSchema()', function () {
+      let pluginConfig;
+      let extData;
+      const extName = 'stuff';
+      beforeEach(function () {
+        extData = {
+          installPath: 'fixtures',
+          pkgName: 'some-pkg',
+          schema: 'plugin.schema.js'
+        };
+        mocks['resolve-from'].returns(require.resolve('./fixtures/plugin.schema.js'));
+        pluginConfig = PluginConfig.getInstance('/tmp/');
+      });
+      describe('when the extension data is missing `schema`', function () {
+        it('should throw', function () {
+          delete extData.schema;
+          expect(() => pluginConfig.readExtensionSchema(extName, extData)).to.throw(TypeError, /why is this function being called/i);
+        });
+      });
+      describe('when the extension schema has already been registered', function () {
+        describe('when the schema is identical (presumably the same extension)', function () {
+          it('should not throw', function () {
+            pluginConfig.readExtensionSchema(extName, extData);
+            expect(() => pluginConfig.readExtensionSchema(extName, extData)).not.to.throw();
+          });
+        });
+        describe('when the schema differs (presumably a different extension)', function () {
+          it('should throw', function () {
+            pluginConfig.readExtensionSchema(extName, extData);
+            mocks['resolve-from'].returns(require.resolve('./fixtures/driver.schema.js'));
+            expect(() => pluginConfig.readExtensionSchema(extName, extData)).to.throw(/conflicts with an existing schema/i);
+          });
+        });
+      });
+      describe('when the extension schema has not yet been registered', function () {
+        it('should resolve and load the extension schema file', function () {
+          pluginConfig.readExtensionSchema(extName, extData);
+          expect(mocks['resolve-from']).to.have.been.calledOnce;
+        });
+      });
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/extension-config-specs.js"],"names":["expect","chai","describe","it","DriverConfig","mocks","sandbox","beforeEach","sinon","stub","callsFake","cwd","id","path","join","rewiremock","proxy","require","default","createSandbox","afterEach","restore","config","getInstance","extensionDesc","version","automationName","should","equal","driverConfig","getConfigProblems","throw","deep","include","err","val","undefined","platformNames","getSchemaProblems","schema","problems","installPath","pkgName","match","__dirname","be","empty","spy","read","validate","have","been","calledOnce","extData","extName","returns","resolve","readExtensionSchema","to","TypeError","not","PluginConfig","pluginConfig","type","properties","foo"],"mappings":"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","sourcesContent":["// @ts-check\n\nimport path from 'path';\nimport rewiremock from 'rewiremock/node';\nimport sinon from 'sinon';\n\nconst expect = chai.expect;\n\ndescribe('ExtensionConfig', function () {\n  describe('getGenericConfigProblems()', function () {\n    it('should have some tests');\n  });\n\n  describe('DriverConfig', function () {\n    /**\n     * @type {typeof import('../lib/driver-config').default}\n     */\n    let DriverConfig;\n    let mocks;\n    /** @type {import('sinon').SinonSandbox} */\n    let sandbox;\n    beforeEach(function () {\n      mocks = {\n        'resolve-from': sinon.stub().callsFake((cwd, id) => path.join(cwd, id)),\n      };\n\n      DriverConfig = rewiremock.proxy(\n        () => require('../lib/driver-config'),\n        mocks,\n      ).default;\n\n      sandbox = sinon.createSandbox();\n    });\n\n    afterEach(function () {\n      sandbox.restore();\n    });\n\n    describe('extensionDesc()', function () {\n      it('should return the description of the extension', function () {\n        const config = DriverConfig.getInstance('/tmp/');\n        config\n          .extensionDesc('foo', {version: '1.0', automationName: 'bar'})\n          .should.equal(`foo@1.0 (automationName 'bar')`);\n      });\n    });\n\n    describe('getConfigProblems()', function () {\n      /**\n       * @type {ReturnType<DriverConfig['getInstance']>}\n       */\n      let driverConfig;\n\n      beforeEach(function () {\n        driverConfig = DriverConfig.getInstance('/tmp/');\n      });\n\n      describe('when provided no arguments', function () {\n        it('should throw', function () {\n          // @ts-ignore\n          (() => driverConfig.getConfigProblems()).should.throw();\n        });\n      });\n\n      describe('property `platformNames`', function () {\n        describe('when provided an object with no `platformNames` property', function () {\n          it('should return an array with an associated problem', function () {\n            driverConfig.getConfigProblems({}, 'foo').should.deep.include({\n              err: 'Missing or incorrect supported platformNames list.',\n              val: undefined,\n            });\n          });\n        });\n\n        describe('when provided an object with an empty `platformNames` property', function () {\n          it('should return an array with an associated problem', function () {\n            driverConfig\n              .getConfigProblems({platformNames: []}, 'foo')\n              .should.deep.include({\n                err: 'Empty platformNames list.',\n                val: [],\n              });\n          });\n        });\n\n        describe('when provided an object with a non-array `platformNames` property', function () {\n          it('should return an array with an associated problem', function () {\n            driverConfig\n              .getConfigProblems({platformNames: 'foo'}, 'foo')\n              .should.deep.include({\n                err: 'Missing or incorrect supported platformNames list.',\n                val: 'foo',\n              });\n          });\n        });\n\n        describe('when provided a non-empty array containing a non-string item', function () {\n          it('should return an array with an associated problem', function () {\n            driverConfig\n              .getConfigProblems({platformNames: ['a', 1]}, 'foo')\n              .should.deep.include({\n                err: 'Incorrectly formatted platformName.',\n                val: 1,\n              });\n          });\n        });\n      });\n\n      describe('property `automationName`', function () {\n        describe('when provided an object with a missing `automationName` property', function () {\n          it('should return an array with an associated problem', function () {\n            driverConfig.getConfigProblems({}, 'foo').should.deep.include({\n              err: 'Missing or incorrect automationName',\n              val: undefined,\n            });\n          });\n        });\n        describe('when provided a conflicting automationName', function () {\n          it('should return an array with an associated problem', function () {\n            driverConfig.getConfigProblems({automationName: 'foo'}, 'foo');\n            driverConfig\n              .getConfigProblems({automationName: 'foo'}, 'foo')\n              .should.deep.include({\n                err: 'Multiple drivers claim support for the same automationName',\n                val: 'foo',\n              });\n          });\n        });\n      });\n    });\n\n    describe('getSchemaProblems()', function () {\n      /**\n       * @type {ReturnType<DriverConfig['getInstance']>}\n       */\n      let driverConfig;\n\n      beforeEach(function () {\n        driverConfig = DriverConfig.getInstance('/tmp/');\n      });\n      describe('when provided an object with a defined non-string `schema` property', function () {\n        it('should return an array with an associated problem', function () {\n          driverConfig\n            .getSchemaProblems({schema: []}, 'foo')\n            .should.deep.include({\n              err: 'Incorrectly formatted schema field; must be a path to a schema file or a schema object.',\n              val: [],\n            });\n        });\n      });\n\n      describe('when provided a string `schema` property', function () {\n        describe('when the property ends in an unsupported extension', function () {\n          it('should return an array with an associated problem', function () {\n            driverConfig\n              .getSchemaProblems({schema: 'selenium.java'}, 'foo')\n              .should.deep.include({\n                err: 'Schema file has unsupported extension. Allowed: .json, .js, .cjs',\n                val: 'selenium.java',\n              });\n          });\n        });\n\n        describe('when the property contains a supported extension', function () {\n          describe('when the property as a path cannot be found', function () {\n            it('should return an array with an associated problem', function () {\n              const problems = driverConfig.getSchemaProblems(\n                {\n                  installPath: '/usr/bin/derp',\n                  pkgName: 'doop',\n                  schema: 'herp.json',\n                },\n                'foo',\n              );\n              problems[0].err.should.match(/Unable to register schema at path herp\\.json/i);\n              // problems.should.deep.include({\n              //   err: `Unable to register schema at path herp.json`,\n              //   val: 'herp.json',\n              // });\n            });\n          });\n\n          describe('when the property as a path is found', function () {\n            it('should return an empty array', function () {\n              const problems = driverConfig.getSchemaProblems(\n                {\n                  pkgName: 'fixtures', // just corresponds to a directory name relative to `installPath` `(__dirname)`\n                  installPath: __dirname,\n                  schema: 'driver.schema.js',\n                },\n                'foo',\n              );\n              problems.should.be.empty;\n            });\n          });\n        });\n      });\n    });\n\n    describe('read()', function () {\n      /**\n       * @type {ReturnType<DriverConfig['getInstance']>}\n       */\n      let driverConfig;\n\n      beforeEach(function () {\n        driverConfig = DriverConfig.getInstance('/tmp/');\n        sandbox.spy(driverConfig, 'validate');\n      });\n\n      it('should validate the extension', async function () {\n        await driverConfig.read();\n        driverConfig.validate.should.have.been.calledOnce;\n      });\n    });\n\n    describe('readExtensionSchema()', function () {\n      /**\n       * @type {ReturnType<DriverConfig['getInstance']>}\n       */\n      let driverConfig;\n\n      /** @type {import('../lib/extension-config').ExtData} */\n      let extData;\n\n      const extName = 'stuff';\n\n      beforeEach(function () {\n        extData = {\n          installPath: 'fixtures',\n          pkgName: 'some-pkg',\n          schema: 'driver.schema.js',\n        };\n        mocks['resolve-from'].returns(\n          require.resolve('./fixtures/driver.schema.js'),\n        );\n        driverConfig = DriverConfig.getInstance('/tmp/');\n      });\n\n      describe('when the extension data is missing `schema`', function () {\n        it('should throw', function () {\n          delete extData.schema;\n          expect(() =>\n            driverConfig.readExtensionSchema(extName, extData),\n          ).to.throw(TypeError, /why is this function being called/i);\n        });\n      });\n\n      describe('when the extension schema has already been registered (with the same schema)', function () {\n        it('should not throw', function () {\n          driverConfig.readExtensionSchema(extName, extData);\n          expect(() => driverConfig.readExtensionSchema(extName, extData)).not.to.throw();\n        });\n      });\n\n      describe('when the extension schema has not yet been registered', function () {\n        it('should resolve and load the extension schema file', function () {\n          driverConfig.readExtensionSchema (extName, extData);\n\n          // we don't have access to the schema registration cache directly, so this is as close as we can get.\n          expect(mocks['resolve-from']).to.have.been.calledOnce;\n        });\n      });\n    });\n  });\n\n  describe('PluginConfig', function () {\n    /**\n     * @type {typeof import('../lib/plugin-config').default}\n     */\n    let PluginConfig;\n    let mocks;\n    /** @type {import('sinon').SinonSandbox} */\n    let sandbox;\n    beforeEach(function () {\n      mocks = {\n        'resolve-from': sinon.stub().callsFake((cwd, id) => path.join(cwd, id)),\n      };\n\n      PluginConfig = rewiremock.proxy(\n        () => require('../lib/plugin-config'),\n        mocks,\n      ).default;\n\n      sandbox = sinon.createSandbox();\n    });\n\n    afterEach(function () {\n      sandbox.restore();\n    });\n\n    describe('extensionDesc()', function () {\n      it('should return the description of the extension', function () {\n        const config = PluginConfig.getInstance('/tmp/');\n        config\n          .extensionDesc('foo', {version: '1.0'})\n          .should.equal(`foo@1.0`);\n      });\n    });\n\n    describe('getConfigProblems()', function () {\n      /**\n       * @type {ReturnType<PluginConfig['getInstance']>}\n       */\n      let pluginConfig;\n\n      beforeEach(function () {\n        pluginConfig = PluginConfig.getInstance('/tmp/');\n      });\n\n      describe('when provided no arguments', function () {\n        it('should not throw', function () {\n          // @ts-ignore\n          (() => pluginConfig.getConfigProblems()).should.not.throw();\n        });\n      });\n    });\n\n    describe('getSchemaProblems()', function () {\n      /**\n       * @type {ReturnType<PluginConfig['getInstance']>}\n       */\n      let pluginConfig;\n\n      beforeEach(function () {\n        pluginConfig = PluginConfig.getInstance('/tmp/');\n      });\n\n      describe('when provided an object with a defined `schema` property of unsupported type', function () {\n        it('should return an array with an associated problem', function () {\n          pluginConfig\n            .getSchemaProblems({schema: []}, 'foo')\n            .should.deep.include({\n              err: 'Incorrectly formatted schema field; must be a path to a schema file or a schema object.',\n              val: [],\n            });\n        });\n      });\n\n      describe('when provided a string `schema` property', function () {\n        describe('when the property ends in an unsupported extension', function () {\n          it('should return an array with an associated problem', function () {\n            pluginConfig\n              .getSchemaProblems({schema: 'selenium.java'}, 'foo')\n              .should.deep.include({\n                err: 'Schema file has unsupported extension. Allowed: .json, .js, .cjs',\n                val: 'selenium.java',\n              });\n          });\n        });\n\n        describe('when the property contains a supported extension', function () {\n          describe('when the property as a path cannot be found', function () {\n            it('should return an array with an associated problem', function () {\n              const problems = pluginConfig.getSchemaProblems(\n                {\n                  installPath: '/usr/bin/derp',\n                  pkgName: 'doop',\n                  schema: 'herp.json',\n                },\n                'foo',\n              );\n              problems[0].err.should.match(/Unable to register schema at path herp\\.json/i);\n            });\n          });\n\n          describe('when the property as a path is found', function () {\n            it('should return an empty array', function () {\n              const problems = pluginConfig.getSchemaProblems(\n                {\n                  pkgName: 'fixtures', // just corresponds to a directory name relative to `installPath` `(__dirname)`\n                  installPath: __dirname,\n                  schema: 'plugin.schema.js',\n                },\n                'foo',\n              );\n              problems.should.be.empty;\n            });\n          });\n        });\n      });\n\n      describe('when provided an object `schema` property', function () {\n        it('should return an empty array', function () {\n          const problems = pluginConfig.getSchemaProblems(\n            {\n              pkgName: 'fixtures', // just corresponds to a directory name relative to `installPath` `(__dirname)`\n              installPath: __dirname,\n              schema: {type: 'object', properties: {foo: {type: 'string'}}},\n            },\n            'foo',\n          );\n          problems.should.be.empty;\n        });\n      });\n    });\n\n    describe('read()', function () {\n      /**\n       * @type {ReturnType<PluginConfig['getInstance']>}\n       */\n      let pluginConfig;\n\n      beforeEach(function () {\n        pluginConfig = PluginConfig.getInstance('/tmp/');\n        sandbox.spy(pluginConfig, 'validate');\n      });\n\n      it('should validate the extension', async function () {\n        await pluginConfig.read();\n        pluginConfig.validate.should.have.been.calledOnce;\n      });\n    });\n\n    describe('readExtensionSchema()', function () {\n      /**\n       * @type {ReturnType<PluginConfig['getInstance']>}\n       */\n      let pluginConfig;\n\n      /** @type {import('../lib/extension-config').ExtData} */\n      let extData;\n\n      const extName = 'stuff';\n\n      beforeEach(function () {\n        extData = {\n          installPath: 'fixtures',\n          pkgName: 'some-pkg',\n          schema: 'plugin.schema.js',\n        };\n        mocks['resolve-from'].returns(\n          require.resolve('./fixtures/plugin.schema.js'),\n        );\n        pluginConfig = PluginConfig.getInstance('/tmp/');\n\n      });\n\n      describe('when the extension data is missing `schema`', function () {\n        it('should throw', function () {\n          delete extData.schema;\n          expect(() =>\n            pluginConfig.readExtensionSchema(extName, extData),\n          ).to.throw(TypeError, /why is this function being called/i);\n        });\n      });\n\n      describe('when the extension schema has already been registered', function () {\n        describe('when the schema is identical (presumably the same extension)', function () {\n          it('should not throw', function () {\n            pluginConfig.readExtensionSchema(extName, extData);\n            expect(() => pluginConfig.readExtensionSchema(extName, extData)).not.to.throw();\n          });\n        });\n\n        describe('when the schema differs (presumably a different extension)', function () {\n          it('should throw', function () {\n            pluginConfig.readExtensionSchema(extName, extData);\n            mocks['resolve-from'].returns(require.resolve('./fixtures/driver.schema.js'));\n            expect(() => pluginConfig.readExtensionSchema(extName, extData)).to.throw(/conflicts with an existing schema/i);\n          });\n        });\n      });\n\n      describe('when the extension schema has not yet been registered', function () {\n        it('should resolve and load the extension schema file', function () {\n          pluginConfig.readExtensionSchema(extName, extData);\n\n          // we don't have access to the schema registration cache directly, so this is as close as we can get.\n          expect(mocks['resolve-from']).to.have.been.calledOnce;\n        });\n      });\n    });\n  });\n});\n"],"file":"test/extension-config-specs.js","sourceRoot":"../.."}

package/build/test/fixtures/allow-feat.txt

@@ -0,0 +1,5 @@
+feature1
+feature2
+
+feature3
+

package/build/test/fixtures/caps.json

@@ -0,0 +1,3 @@
+{
+  "a": "b"
+}

package/build/test/fixtures/config/allow-insecure.txt

@@ -0,0 +1,3 @@
+foo
+bar
+baz

package/build/test/fixtures/config/appium.config.bad-nodeconfig.json

@@ -0,0 +1,5 @@
+{
+  "server": {
+    "nodeconfig": "./packages/appium/test/fixtures/config/nodeconfig.json"
+  }
+}

package/build/test/fixtures/config/appium.config.bad.json

@@ -0,0 +1,32 @@
+{
+  "appium-home": "foo",
+  "server": {
+    "address": "0.0.0.0",
+    "allow-cors": 1,
+    "allow-insecure": {},
+    "base-path": "/",
+    "callback-address": "0.0.0.0",
+    "callback-port": 43243234,
+    "debug-log-spacing": false,
+    "default-capabilities": {},
+    "deny-insecure": [],
+    "keep-alive-timeout": 0,
+    "local-timezone": false,
+    "log": "/tmp/appium.log",
+    "log-level": "smoosh",
+    "log-no-colors": 1,
+    "log-timestamp": false,
+    "long-stacktrace": false,
+    "no-perms-check": false,
+    "nodeconfig": {},
+    "port": "31337",
+    "relaxed-security": false,
+    "session-override": false,
+    "strict-caps": false,
+    "tmp": "/tmp",
+    "trace-dir": "/tmp/appium-instruments",
+    "use-drivers": [],
+    "use-plugins": ["all"],
+    "webhook": "http://0.0.0.0/hook"
+  }
+}

package/build/test/fixtures/config/appium.config.ext-good.json

@@ -0,0 +1,9 @@
+{
+  "server": {
+    "driver": {
+      "fake": {
+        "answer": 24
+      }
+    }
+  }
+}

package/build/test/fixtures/config/appium.config.ext-unknown-props.json

@@ -0,0 +1,10 @@
+{
+  "server": {
+    "driver": {
+      "fake": {
+        "answer": 24,
+        "bubb": "rubb"
+      }
+    }
+  }
+}

package/build/test/fixtures/config/appium.config.good.js

@@ -0,0 +1,40 @@
+"use strict";
+
+require("source-map-support/register");
+
+module.exports = {
+  server: {
+    address: '0.0.0.0',
+    'allow-cors': false,
+    'allow-insecure': [],
+    'base-path': '/',
+    'callback-address': '0.0.0.0',
+    'callback-port': 31337,
+    'debug-log-spacing': false,
+    'default-capabilities': {},
+    'deny-insecure': [],
+    'keep-alive-timeout': 600,
+    'local-timezone': false,
+    log: '/tmp/appium.log',
+    'log-level': 'info',
+    'log-no-colors': false,
+    'log-timestamp': false,
+    'long-stacktrace': false,
+    'no-perms-check': false,
+    nodeconfig: {
+      foo: 'bar'
+    },
+    port: 31337,
+    'relaxed-security': false,
+    'session-override': false,
+    'strict-caps': false,
+    tmp: '/tmp',
+    'trace-dir': '/tmp/appium-instruments',
+    'use-drivers': [],
+    'use-plugins': ['all'],
+    webhook: 'http://0.0.0.0/hook'
+  }
+};require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,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

package/build/test/fixtures/config/appium.config.good.json

@@ -0,0 +1,33 @@
+{
+  "server": {
+    "address": "0.0.0.0",
+    "allow-cors": false,
+    "allow-insecure": [],
+    "base-path": "/",
+    "callback-address": "0.0.0.0",
+    "callback-port": 31337,
+    "debug-log-spacing": false,
+    "default-capabilities": {},
+    "deny-insecure": [],
+    "keep-alive-timeout": 600,
+    "local-timezone": false,
+    "log": "/tmp/appium.log",
+    "log-level": "info",
+    "log-no-colors": false,
+    "log-timestamp": false,
+    "long-stacktrace": false,
+    "no-perms-check": false,
+    "nodeconfig": {
+      "foo": "bar"
+    },
+    "port": 31337,
+    "relaxed-security": false,
+    "session-override": false,
+    "strict-caps": false,
+    "tmp": "/tmp",
+    "trace-dir": "/tmp/appium-instruments",
+    "use-drivers": [],
+    "use-plugins": ["all"],
+    "webhook": "http://0.0.0.0/hook"
+  }
+}

package/build/test/fixtures/config/appium.config.good.yaml

@@ -0,0 +1,30 @@
+server:
+  address: '0.0.0.0'
+  port: 31337
+  allow-cors: false
+  allow-insecure: []
+  base-path: /
+  callback-address: '0.0.0.0'
+  callback-port: 31337
+  log-level: info
+  log-timestamp: false
+  debug-log-spacing: false
+  default-capabilities: {}
+  deny-insecure: []
+  keep-alive-timeout: 600
+  local-timezone: false
+  log: /tmp/appium.log
+  log-no-colors: false
+  long-stacktrace: false
+  no-perms-check: false
+  nodeconfig:
+    foo: bar
+  relaxed-security: false
+  session-override: false
+  strict-caps: false
+  tmp: /tmp
+  trace-dir: /tmp/appium-instruments
+  use-drivers: []
+  use-plugins:
+    - all
+  webhook: 'http://0.0.0.0/hook'