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

package/build/test/schema/schema-specs.js

@@ -0,0 +1,389 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+require("source-map-support/register");
+
+var _lodash = _interopRequireDefault(require("lodash"));
+
+var _sinon = _interopRequireDefault(require("sinon"));
+
+var _appiumConfigSchema = _interopRequireDefault(require("../../lib/schema/appium-config-schema"));
+
+var _defaultArgs = _interopRequireDefault(require("../fixtures/default-args"));
+
+var _driver = _interopRequireDefault(require("../fixtures/driver.schema"));
+
+var _flattenedSchema = _interopRequireDefault(require("../fixtures/flattened-schema"));
+
+var _helpers = require("../helpers");
+
+var _argSpec = require("../../lib/schema/arg-spec");
+
+const {
+  expect
+} = chai;
+describe('schema', function () {
+  let schema;
+  let sandbox;
+  let SchemaFinalizationError;
+  let SchemaUnknownSchemaError;
+  let mocks;
+  beforeEach(function () {
+    sandbox = _sinon.default.createSandbox();
+    mocks = {
+      '../../lib/extension-config': {
+        DRIVER_TYPE: 'driver',
+        PLUGIN_TYPE: 'plugin'
+      },
+      'resolve-from': sandbox.stub(),
+      '@sidvind/better-ajv-errors': sandbox.stub()
+    };
+    schema = _helpers.rewiremock.proxy(() => require('../../lib/schema/schema'), mocks);
+    SchemaFinalizationError = schema.SchemaFinalizationError;
+    SchemaUnknownSchemaError = schema.SchemaUnknownSchemaError;
+    schema.resetSchema();
+  });
+  afterEach(function () {
+    sandbox.restore();
+  });
+  describe('registerSchema()', function () {
+    describe('error conditions', function () {
+      describe('when provided no parameters', function () {
+        it('should throw a TypeError', function () {
+          expect(() => schema.registerSchema()).to.throw(TypeError, 'Expected nonempty extension type, extension name and schema parameters');
+        });
+      });
+      describe('when provided `type` and `name`, but not `schema`', function () {
+        it('should throw a TypeError', function () {
+          expect(() => schema.registerSchema('driver', 'whoopeee')).to.throw(TypeError, 'Expected nonempty extension type, extension name and schema parameters');
+        });
+      });
+      describe('when provided `type`, a nonempty `name`, but an empty `schema`', function () {
+        it('should throw a TypeError', function () {
+          expect(() => schema.registerSchema('driver', 'whoopeee', {})).to.throw(TypeError, 'Expected nonempty extension type, extension name and schema parameters');
+        });
+      });
+      describe('when provided `type` and nonempty `schema`, but no `name`', function () {
+        it('should throw a TypeError', function () {
+          expect(() => schema.registerSchema('driver', undefined, {
+            title: 'whoopeee'
+          })).to.throw(TypeError, 'Expected nonempty extension type, extension name and schema parameters');
+        });
+      });
+      describe('when provided a `type` and nonempty `name`, but an invalid `schema`', function () {
+        it('should throw', function () {
+          const schemaObject = [45];
+          expect(() => schema.registerSchema('driver', 'whoopeee', schemaObject)).to.throw(/schema is invalid/i);
+        });
+      });
+      describe('when schema previously registered', function () {
+        describe('when the schema is identical', function () {
+          it('should not throw', function () {
+            const schemaObject = {
+              title: 'whoopee'
+            };
+            schema.registerSchema('driver', 'whoopee', schemaObject);
+            expect(() => schema.registerSchema('driver', 'whoopee', schemaObject)).not.to.throw();
+          });
+        });
+        describe('when the schema is different', function () {
+          it('should throw', function () {
+            const schemaObject = {
+              title: 'whoopee'
+            };
+            schema.registerSchema('driver', 'whoopee', schemaObject);
+            expect(() => schema.registerSchema('driver', 'whoopee', {
+              title: 'cushion?'
+            })).to.throw(Error, /conflicts with an existing schema/);
+          });
+        });
+      });
+    });
+    describe('when provided a nonempty `type`, `schema` and `name`', function () {
+      it('should register the schema', function () {
+        const schemaObject = {
+          title: 'whoopee'
+        };
+        expect(() => schema.registerSchema('driver', 'whoopee', schemaObject)).not.to.throw();
+      });
+      describe('when the `name` is not unique but `type` is', function () {
+        it('should register both', function () {
+          const schema1 = {
+            title: 'pro-skub'
+          };
+          const schema2 = {
+            title: 'anti-skub'
+          };
+          schema.registerSchema('driver', 'skub', schema1);
+          expect(() => schema.registerSchema('plugin', 'skub', schema2)).not.to.throw();
+        });
+      });
+    });
+  });
+  describe('getSchema()', function () {
+    describe('when schema not yet compiled', function () {
+      it('should throw', function () {
+        expect(() => schema.getSchema()).to.throw(SchemaFinalizationError);
+      });
+    });
+    describe('when schema already compiled', function () {
+      beforeEach(function () {
+        schema.finalizeSchema();
+      });
+      it('should return a schema', function () {
+        expect(schema.getSchema()).to.eql(_appiumConfigSchema.default);
+      });
+    });
+    describe('when schema already compiled and provided a schema ID', function () {
+      beforeEach(function () {
+        schema.finalizeSchema();
+      });
+      describe('when schema ID is the base schema ID', function () {
+        it('should return the base schema', function () {
+          expect(schema.getSchema(_argSpec.APPIUM_CONFIG_SCHEMA_ID)).to.eql(_appiumConfigSchema.default);
+        });
+      });
+      describe('when the schema ID is a reference', function () {
+        it('should return the schema for the reference', function () {
+          expect(schema.getSchema(`${_argSpec.APPIUM_CONFIG_SCHEMA_ID}#/properties/server/properties/address`)).to.exist.and.to.eql(_appiumConfigSchema.default.properties.server.properties.address);
+        });
+      });
+      describe('when schema ID is invalid', function () {
+        it('should throw', function () {
+          expect(() => schema.getSchema('schema-the-clown')).to.throw(SchemaUnknownSchemaError);
+        });
+      });
+    });
+    describe('when schema already compiled including an extension', function () {
+      beforeEach(function () {
+        schema.registerSchema('driver', 'stuff', _driver.default);
+        schema.finalizeSchema();
+      });
+      it('should return the extension schema', function () {
+        expect(schema.getSchema('driver-stuff.json')).to.eql(_driver.default);
+      });
+    });
+  });
+  describe('getDefaultsFromSchema()', function () {
+    describe('when schema not yet compiled', function () {
+      it('should throw', function () {
+        expect(() => schema.getDefaultsFromSchema()).to.throw(SchemaFinalizationError);
+      });
+    });
+    describe('when schema already compiled', function () {
+      it('should return a Record object with only defined default values', function () {
+        schema.finalizeSchema();
+        const defaults = schema.getDefaultsFromSchema();
+        expect(defaults).to.eql(_defaultArgs.default);
+      });
+      describe('when extension schemas include defaults', function () {
+        it('should return a Record object containing defaults for the extensions', function () {
+          schema.registerSchema('driver', 'stuff', _driver.default);
+          schema.finalizeSchema();
+          const defaults = schema.getDefaultsFromSchema();
+          expect(defaults).to.have.property('driver.stuff.answer', 50);
+        });
+      });
+    });
+  });
+  describe('flattenSchema()', function () {
+    describe('when schema not yet compiled', function () {
+      it('should throw', function () {
+        expect(() => schema.flattenSchema()).to.throw(SchemaFinalizationError);
+      });
+    });
+    describe('when schema compiled', function () {
+      beforeEach(function () {
+        schema.resetSchema();
+        schema.finalizeSchema();
+      });
+      it('should flatten a schema', function () {
+        expect(schema.flattenSchema()).to.eql(_flattenedSchema.default);
+      });
+    });
+    describe('when extensions provide schemas', function () {
+      let expected;
+      beforeEach(function () {
+        schema.registerSchema('driver', 'fake', require('@appium/fake-driver/build/lib/fake-driver-schema').default);
+        schema.finalizeSchema();
+        expected = [..._flattenedSchema.default, {
+          schema: {
+            type: 'integer',
+            minimum: 1,
+            maximum: 65535,
+            description: 'The port to use for the fake web server'
+          },
+          argSpec: {
+            name: 'silly-web-server-port',
+            extType: 'driver',
+            extName: 'fake',
+            ref: 'driver-fake.json#/properties/silly-web-server-port',
+            arg: 'driver-fake-silly-web-server-port',
+            dest: 'driver.fake.sillyWebServerPort',
+            defaultValue: undefined
+          }
+        }, {
+          schema: {
+            type: 'string',
+            description: 'The host to use for the fake web server',
+            default: 'sillyhost'
+          },
+          argSpec: {
+            name: 'sillyWebServerHost',
+            extType: 'driver',
+            extName: 'fake',
+            ref: 'driver-fake.json#/properties/sillyWebServerHost',
+            arg: 'driver-fake-silly-web-server-host',
+            dest: 'driver.fake.sillyWebServerHost',
+            defaultValue: 'sillyhost'
+          }
+        }];
+      });
+      it('should flatten a schema', function () {
+        expect(schema.flattenSchema()).to.eql(expected);
+      });
+    });
+  });
+  describe('finalizeSchema()', function () {
+    describe('when no extensions registered schemas', function () {
+      it('should return a Record containing the single base schema', function () {
+        expect(schema.finalizeSchema()).to.eql({
+          [_argSpec.APPIUM_CONFIG_SCHEMA_ID]: _appiumConfigSchema.default
+        });
+      });
+    });
+    describe('when extensions register schemas', function () {
+      beforeEach(function () {
+        schema.registerSchema('driver', 'stuff', _driver.default);
+      });
+      it('should return a Record containing all extension schemas _and_ the base schema containing references to the extension schemas', function () {
+        const baseSchemaWithRefs = _lodash.default.cloneDeep(_appiumConfigSchema.default);
+
+        baseSchemaWithRefs.properties.server.properties.driver.properties.stuff = {
+          $ref: 'driver-stuff.json',
+          $comment: 'stuff'
+        };
+        expect(schema.finalizeSchema()).to.eql({
+          [_argSpec.APPIUM_CONFIG_SCHEMA_ID]: baseSchemaWithRefs,
+          'driver-stuff.json': _driver.default
+        });
+      });
+    });
+  });
+  describe('isFinalized()', function () {
+    describe('when the schema is finalized', function () {
+      it('should return true', function () {
+        schema.finalizeSchema();
+        expect(schema.isFinalized()).to.be.true;
+      });
+    });
+    describe('when the schema is not finalized', function () {
+      it('should return false', function () {
+        schema.resetSchema();
+        expect(schema.isFinalized()).to.be.false;
+      });
+    });
+  });
+  describe('validate()', function () {
+    describe('when schema not yet compiled', function () {
+      it('should throw', function () {
+        expect(() => schema.validate('foo')).to.throw(SchemaFinalizationError);
+      });
+    });
+    describe('when schema already compiled, with no extensions', function () {
+      beforeEach(function () {
+        schema.finalizeSchema();
+      });
+      describe('when provided an invalid schema ID ref', function () {
+        it('should throw', function () {
+          expect(() => schema.validate('foo', 'bar')).to.throw(SchemaUnknownSchemaError);
+        });
+      });
+      describe('when not provided a schema ID ref', function () {
+        describe('when provided a valid value', function () {
+          it('should return an empty array of no errors', function () {
+            expect(schema.validate({
+              server: {
+                address: '127.0.0.1'
+              }
+            })).to.eql([]);
+          });
+        });
+        describe('when provided an invalid value', function () {
+          it('should return an array containing errors', function () {
+            expect(schema.validate({
+              address: '127.0.0.1'
+            })).to.be.an('array').and.to.not.be.empty;
+          });
+        });
+      });
+      describe('when provided a schema ID ref', function () {
+        describe('when provided a valid value', function () {
+          it('should return an empty array of no errors', function () {
+            expect(schema.validate('127.0.0.1', 'appium.json#/properties/server/properties/address')).to.eql([]);
+          });
+        });
+        describe('when provided an invalid value', function () {
+          it('should return an array containing errors', function () {
+            expect(schema.validate('127.0.0.1', 'appium.json#/properties/server/properties/port')).to.be.an('array').and.to.not.be.empty;
+          });
+        });
+      });
+    });
+    describe('when schema already compiled, with extensions', function () {
+      beforeEach(function () {
+        schema.registerSchema('driver', 'stuff', _driver.default);
+        schema.finalizeSchema();
+      });
+      describe('when provided an invalid schema ID ref', function () {
+        it('should throw', function () {
+          expect(() => schema.validate('foo', 'bar')).to.throw(SchemaUnknownSchemaError);
+        });
+      });
+      describe('when not provided a schema ID ref', function () {
+        describe('when provided a valid value', function () {
+          it('should return an empty array of no errors', function () {
+            expect(schema.validate({
+              server: {
+                driver: {
+                  stuff: {
+                    answer: 99
+                  }
+                }
+              }
+            })).to.eql([]);
+          });
+        });
+        describe('when provided an invalid value', function () {
+          it('should return an array containing errors', function () {
+            expect(schema.validate({
+              server: {
+                driver: {
+                  stuff: {
+                    answer: 101
+                  }
+                }
+              }
+            })).to.be.an('array').and.to.not.be.empty;
+          });
+        });
+      });
+      describe('when provided a schema ID ref', function () {
+        describe('when provided a valid value', function () {
+          it('should return an empty array of no errors', function () {
+            expect(schema.validate(99, 'driver-stuff.json#/properties/answer')).to.eql([]);
+          });
+        });
+        describe('when provided an invalid value', function () {
+          it('should return an array containing errors', function () {
+            expect(schema.validate(101, 'driver-stuff.json#/properties/answer')).to.be.an('array').and.to.not.be.empty;
+          });
+        });
+      });
+    });
+  });
+});require('source-map-support').install();
+
+
+//# sourceMappingURL=data:application/json;charset=utf8;base64,{"version":3,"sources":["test/schema/schema-specs.js"],"names":["expect","chai","describe","schema","sandbox","SchemaFinalizationError","SchemaUnknownSchemaError","mocks","beforeEach","sinon","createSandbox","DRIVER_TYPE","PLUGIN_TYPE","stub","rewiremock","proxy","require","resetSchema","afterEach","restore","it","registerSchema","to","throw","TypeError","undefined","title","schemaObject","not","Error","schema1","schema2","getSchema","finalizeSchema","eql","appiumConfigSchema","APPIUM_CONFIG_SCHEMA_ID","exist","and","properties","server","address","DRIVER_SCHEMA_FIXTURE","getDefaultsFromSchema","defaults","defaultArgsFixture","have","property","flattenSchema","flattenedSchemaFixture","expected","default","type","minimum","maximum","description","argSpec","name","extType","extName","ref","arg","dest","defaultValue","baseSchemaWithRefs","_","cloneDeep","driver","stuff","$ref","$comment","isFinalized","be","true","false","validate","an","empty","answer"],"mappings":"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","sourcesContent":["// @ts-check\n\nimport _ from 'lodash';\nimport sinon from 'sinon';\nimport appiumConfigSchema from '../../lib/schema/appium-config-schema';\nimport defaultArgsFixture from '../fixtures/default-args';\nimport DRIVER_SCHEMA_FIXTURE from '../fixtures/driver.schema';\nimport flattenedSchemaFixture from '../fixtures/flattened-schema';\nimport {rewiremock} from '../helpers';\nimport {APPIUM_CONFIG_SCHEMA_ID} from '../../lib/schema/arg-spec';\n\nconst {expect} = chai;\n\ndescribe('schema', function () {\n  /** @type {import('../../lib/schema/schema')} */\n  let schema;\n  /** @type {import('sinon').SinonSandbox} */\n  let sandbox;\n\n  /**\n   * @type {typeof import('../../lib/schema/schema').SchemaFinalizationError}\n   */\n  let SchemaFinalizationError;\n\n  /**\n   * @type {typeof import('../../lib/schema/schema').SchemaUnknownSchemaError}\n   */\n  let SchemaUnknownSchemaError;\n\n  let mocks;\n\n  beforeEach(function () {\n    sandbox = sinon.createSandbox();\n\n    mocks = {\n      '../../lib/extension-config': {\n        DRIVER_TYPE: 'driver',\n        PLUGIN_TYPE: 'plugin',\n      },\n\n      'resolve-from': sandbox.stub(),\n\n      '@sidvind/better-ajv-errors': sandbox.stub(),\n    };\n\n    schema = rewiremock.proxy(() => require('../../lib/schema/schema'), mocks);\n    SchemaFinalizationError = schema.SchemaFinalizationError;\n    SchemaUnknownSchemaError = schema.SchemaUnknownSchemaError;\n    schema.resetSchema();\n  });\n\n  afterEach(function () {\n    sandbox.restore();\n  });\n\n  describe('registerSchema()', function () {\n    describe('error conditions', function () {\n      describe('when provided no parameters', function () {\n        it('should throw a TypeError', function () {\n          // @ts-ignore\n          expect(() => schema.registerSchema()).to.throw(\n            TypeError,\n            'Expected nonempty extension type, extension name and schema parameters',\n          );\n        });\n      });\n\n      describe('when provided `type` and `name`, but not `schema`', function () {\n        it('should throw a TypeError', function () {\n          expect(() =>\n            // @ts-ignore\n            schema.registerSchema('driver', 'whoopeee'),\n          ).to.throw(\n            TypeError,\n            'Expected nonempty extension type, extension name and schema parameters',\n          );\n        });\n      });\n\n      describe('when provided `type`, a nonempty `name`, but an empty `schema`', function () {\n        it('should throw a TypeError', function () {\n          expect(() =>\n            schema.registerSchema('driver', 'whoopeee', {}),\n          ).to.throw(\n            TypeError,\n            'Expected nonempty extension type, extension name and schema parameters',\n          );\n        });\n      });\n\n      describe('when provided `type` and nonempty `schema`, but no `name`', function () {\n        it('should throw a TypeError', function () {\n          expect(() =>\n            // @ts-ignore\n            schema.registerSchema('driver', undefined, {\n              title: 'whoopeee',\n            }),\n          ).to.throw(\n            TypeError,\n            'Expected nonempty extension type, extension name and schema parameters',\n          );\n        });\n      });\n\n      describe('when provided a `type` and nonempty `name`, but an invalid `schema`', function () {\n        it('should throw', function () {\n          const schemaObject = [45];\n          expect(() =>\n            schema.registerSchema('driver', 'whoopeee', schemaObject),\n          ).to.throw(/schema is invalid/i);\n        });\n      });\n\n      describe('when schema previously registered', function () {\n        describe('when the schema is identical', function () {\n          it('should not throw', function () {\n            const schemaObject = {title: 'whoopee'};\n            schema.registerSchema('driver', 'whoopee', schemaObject);\n            expect(() =>\n              schema.registerSchema('driver', 'whoopee', schemaObject),\n            ).not.to.throw();\n          });\n        });\n\n        describe('when the schema is different', function () {\n          it('should throw', function () {\n            const schemaObject = {title: 'whoopee'};\n            schema.registerSchema('driver', 'whoopee', schemaObject);\n            expect(() =>\n              schema.registerSchema('driver', 'whoopee', {\n                title: 'cushion?',\n              }),\n            ).to.throw(Error, /conflicts with an existing schema/);\n          });\n        });\n      });\n    });\n\n    describe('when provided a nonempty `type`, `schema` and `name`', function () {\n      it('should register the schema', function () {\n        const schemaObject = {title: 'whoopee'};\n        expect(() =>\n          schema.registerSchema('driver', 'whoopee', schemaObject),\n        ).not.to.throw();\n      });\n\n      describe('when the `name` is not unique but `type` is', function () {\n        it('should register both', function () {\n          const schema1 = {title: 'pro-skub'};\n          const schema2 = {title: 'anti-skub'};\n          schema.registerSchema('driver', 'skub', schema1);\n          expect(() =>\n            schema.registerSchema('plugin', 'skub', schema2),\n          ).not.to.throw();\n        });\n      });\n    });\n  });\n\n  describe('getSchema()', function () {\n    describe('when schema not yet compiled', function () {\n      it('should throw', function () {\n        expect(() => schema.getSchema()).to.throw(SchemaFinalizationError);\n      });\n    });\n\n    describe('when schema already compiled', function () {\n      beforeEach(function () {\n        schema.finalizeSchema();\n      });\n\n      it('should return a schema', function () {\n        expect(schema.getSchema()).to.eql(appiumConfigSchema);\n      });\n    });\n\n    describe('when schema already compiled and provided a schema ID', function () {\n      beforeEach(function () {\n        schema.finalizeSchema();\n      });\n\n      describe('when schema ID is the base schema ID', function () {\n        it('should return the base schema', function () {\n          expect(schema.getSchema(APPIUM_CONFIG_SCHEMA_ID)).to.eql(\n            appiumConfigSchema,\n          );\n        });\n      });\n\n      describe('when the schema ID is a reference', function () {\n        it('should return the schema for the reference', function () {\n          expect(\n            schema.getSchema(\n              `${APPIUM_CONFIG_SCHEMA_ID}#/properties/server/properties/address`,\n            ),\n          ).to.exist.and.to.eql(\n            appiumConfigSchema.properties.server.properties.address,\n          );\n        });\n      });\n\n      describe('when schema ID is invalid', function () {\n        it('should throw', function () {\n          expect(() => schema.getSchema('schema-the-clown')).to.throw(\n            SchemaUnknownSchemaError,\n          );\n        });\n      });\n    });\n\n    describe('when schema already compiled including an extension', function () {\n      beforeEach(function () {\n        schema.registerSchema('driver', 'stuff', DRIVER_SCHEMA_FIXTURE);\n        schema.finalizeSchema();\n      });\n\n      it('should return the extension schema', function () {\n        expect(schema.getSchema('driver-stuff.json')).to.eql(\n          DRIVER_SCHEMA_FIXTURE,\n        );\n      });\n    });\n  });\n\n  describe('getDefaultsFromSchema()', function () {\n    describe('when schema not yet compiled', function () {\n      it('should throw', function () {\n        expect(() => schema.getDefaultsFromSchema()).to.throw(\n          SchemaFinalizationError,\n        );\n      });\n    });\n\n    describe('when schema already compiled', function () {\n      it('should return a Record object with only defined default values', function () {\n        schema.finalizeSchema();\n        const defaults = schema.getDefaultsFromSchema();\n        expect(defaults).to.eql(defaultArgsFixture);\n      });\n\n      describe('when extension schemas include defaults', function () {\n        it('should return a Record object containing defaults for the extensions', function () {\n          schema.registerSchema('driver', 'stuff', DRIVER_SCHEMA_FIXTURE);\n          schema.finalizeSchema();\n          const defaults = schema.getDefaultsFromSchema();\n          // extensions have a key that looks like a keypath. we may want to change that\n          expect(defaults).to.have.property('driver.stuff.answer', 50);\n        });\n      });\n    });\n  });\n\n  describe('flattenSchema()', function () {\n    describe('when schema not yet compiled', function () {\n      it('should throw', function () {\n        expect(() => schema.flattenSchema()).to.throw(SchemaFinalizationError);\n      });\n    });\n\n    describe('when schema compiled', function () {\n      beforeEach(function () {\n        schema.resetSchema();\n        schema.finalizeSchema();\n      });\n\n      it('should flatten a schema', function () {\n        expect(schema.flattenSchema()).to.eql(flattenedSchemaFixture);\n      });\n    });\n\n    describe('when extensions provide schemas', function () {\n      let expected;\n\n      beforeEach(function () {\n        schema.registerSchema(\n          'driver',\n          'fake',\n          // TS complains about this require()\n          // @ts-ignore\n          require('@appium/fake-driver/build/lib/fake-driver-schema').default,\n        );\n        schema.finalizeSchema();\n\n        // these props would be added by the fake-driver extension\n        expected = [\n          ...flattenedSchemaFixture,\n          {\n            schema: {\n              type: 'integer',\n              minimum: 1,\n              maximum: 65535,\n              description: 'The port to use for the fake web server',\n            },\n            argSpec: {\n              name: 'silly-web-server-port',\n              extType: 'driver',\n              extName: 'fake',\n              ref: 'driver-fake.json#/properties/silly-web-server-port',\n              arg: 'driver-fake-silly-web-server-port',\n              dest: 'driver.fake.sillyWebServerPort',\n              defaultValue: undefined,\n            },\n          },\n          {\n            schema: {\n              type: 'string',\n              description: 'The host to use for the fake web server',\n              default: 'sillyhost',\n            },\n            argSpec: {\n              name: 'sillyWebServerHost',\n              extType: 'driver',\n              extName: 'fake',\n              ref: 'driver-fake.json#/properties/sillyWebServerHost',\n              arg: 'driver-fake-silly-web-server-host',\n              dest: 'driver.fake.sillyWebServerHost',\n              defaultValue: 'sillyhost',\n            },\n          },\n        ];\n      });\n\n      it('should flatten a schema', function () {\n        expect(schema.flattenSchema()).to.eql(expected);\n      });\n    });\n  });\n\n  describe('finalizeSchema()', function () {\n    describe('when no extensions registered schemas', function () {\n      it('should return a Record containing the single base schema', function () {\n        expect(schema.finalizeSchema()).to.eql({\n          [APPIUM_CONFIG_SCHEMA_ID]: appiumConfigSchema,\n        });\n      });\n    });\n\n    describe('when extensions register schemas', function () {\n      beforeEach(function () {\n        schema.registerSchema('driver', 'stuff', DRIVER_SCHEMA_FIXTURE);\n      });\n\n      it('should return a Record containing all extension schemas _and_ the base schema containing references to the extension schemas', function () {\n        const baseSchemaWithRefs = _.cloneDeep(appiumConfigSchema);\n        baseSchemaWithRefs.properties.server.properties.driver.properties.stuff =\n          {$ref: 'driver-stuff.json', $comment: 'stuff'};\n        expect(schema.finalizeSchema()).to.eql({\n          [APPIUM_CONFIG_SCHEMA_ID]: baseSchemaWithRefs,\n          'driver-stuff.json': DRIVER_SCHEMA_FIXTURE,\n        });\n      });\n    });\n  });\n\n  describe('isFinalized()', function () {\n    describe('when the schema is finalized', function () {\n      it('should return true', function () {\n        schema.finalizeSchema();\n        expect(schema.isFinalized()).to.be.true;\n      });\n    });\n\n    describe('when the schema is not finalized', function () {\n      it('should return false', function () {\n        schema.resetSchema();\n        expect(schema.isFinalized()).to.be.false;\n      });\n    });\n  });\n\n  describe('validate()', function () {\n    describe('when schema not yet compiled', function () {\n      it('should throw', function () {\n        expect(() => schema.validate('foo')).to.throw(SchemaFinalizationError);\n      });\n    });\n\n    describe('when schema already compiled, with no extensions', function () {\n      beforeEach(function () {\n        schema.finalizeSchema();\n      });\n\n      describe('when provided an invalid schema ID ref', function () {\n        it('should throw', function () {\n          expect(() => schema.validate('foo', 'bar')).to.throw(\n            SchemaUnknownSchemaError,\n          );\n        });\n      });\n\n      describe('when not provided a schema ID ref', function () {\n        describe('when provided a valid value', function () {\n          it('should return an empty array of no errors', function () {\n            expect(schema.validate({server: {address: '127.0.0.1'}})).to.eql(\n              [],\n            );\n          });\n        });\n\n        describe('when provided an invalid value', function () {\n          it('should return an array containing errors', function () {\n            expect(schema.validate({address: '127.0.0.1'})).to.be.an('array')\n              .and.to.not.be.empty;\n          });\n        });\n      });\n\n      describe('when provided a schema ID ref', function () {\n        describe('when provided a valid value', function () {\n          it('should return an empty array of no errors', function () {\n            expect(\n              schema.validate(\n                '127.0.0.1',\n                'appium.json#/properties/server/properties/address',\n              ),\n            ).to.eql([]);\n          });\n        });\n\n        describe('when provided an invalid value', function () {\n          it('should return an array containing errors', function () {\n            expect(\n              schema.validate(\n                '127.0.0.1',\n                'appium.json#/properties/server/properties/port',\n              ),\n            ).to.be.an('array').and.to.not.be.empty;\n          });\n        });\n      });\n    });\n\n    describe('when schema already compiled, with extensions', function () {\n      beforeEach(function () {\n        schema.registerSchema('driver', 'stuff', DRIVER_SCHEMA_FIXTURE);\n        schema.finalizeSchema();\n      });\n\n      describe('when provided an invalid schema ID ref', function () {\n        it('should throw', function () {\n          expect(() => schema.validate('foo', 'bar')).to.throw(\n            SchemaUnknownSchemaError,\n          );\n        });\n      });\n\n      describe('when not provided a schema ID ref', function () {\n        describe('when provided a valid value', function () {\n          it('should return an empty array of no errors', function () {\n            expect(\n              schema.validate({server: {driver: {stuff: {answer: 99}}}}),\n            ).to.eql([]);\n          });\n        });\n\n        describe('when provided an invalid value', function () {\n          it('should return an array containing errors', function () {\n            expect(\n              schema.validate({server: {driver: {stuff: {answer: 101}}}}),\n            ).to.be.an('array').and.to.not.be.empty;\n          });\n        });\n      });\n\n      describe('when provided a schema ID ref', function () {\n        describe('when provided a valid value', function () {\n          it('should return an empty array of no errors', function () {\n            expect(\n              schema.validate(99, 'driver-stuff.json#/properties/answer'),\n            ).to.eql([]);\n          });\n        });\n\n        describe('when provided an invalid value', function () {\n          it('should return an array containing errors', function () {\n            expect(\n              schema.validate(101, 'driver-stuff.json#/properties/answer'),\n            ).to.be.an('array').and.to.not.be.empty;\n          });\n        });\n      });\n    });\n  });\n});\n\n/**\n * @template P,R\n * @typedef {import('sinon').SinonStub<P,R>} SinonStub<P,R>\n */\n\n/**\n * @typedef {import('ajv').default['addSchema']} AjvAddSchema\n * @typedef {import('ajv').default['getSchema']} AjvGetSchema<any>\n * @typedef {import('ajv').default['validateSchema']} AjvValidateSchema\n */\n\n/**\n * @typedef {import('ajv/dist/core').AnyValidateFunction<any>} AnyValidateFunction\n */\n"],"file":"test/schema/schema-specs.js","sourceRoot":"../../.."}