def validate(self, operation, params): """Validates the request data This method relies on jsonschema and exists just as a way for third-party transport to validate the request. It's not recommended to validate every request since they are already validated server side. :param operation: Operation's for which params need to be validated. :type operation: `six.text_type` :param params: Params to validate :type params: dict :returns: True if the schema is valid, False otherwise :raises: `errors.InvalidOperation` if the operation does not exist """ if operation not in self.validators: schema = self.get_schema(operation) self.validators[operation] = validators.Draft4Validator(schema) try: self.validators[operation].validate(params) except jsonschema.ValidationError: LOG.debug('Operation is invalid.') return False return True
def check_schema(schema): """ Check a given schema to make sure it is valid YAML schema. """ # We also want to validate the "default" values in the schema # against the schema itself. jsonschema as a library doesn't do # this on its own. def validate_default(validator, default, instance, schema): if not validator.is_type(instance, 'object'): return if 'default' in instance: with instance_validator.resolver.in_scope(scope): for err in instance_validator.iter_errors( instance['default'], instance): yield err VALIDATORS = util.HashableDict( mvalidators.Draft4Validator.VALIDATORS.copy()) VALIDATORS.update({'default': validate_default}) meta_schema = load_schema(YAML_SCHEMA_METASCHEMA_ID, mresolver.default_resolver) resolver = _make_resolver(mresolver.default_resolver) cls = mvalidators.create(meta_schema=meta_schema, validators=VALIDATORS) validator = cls(meta_schema, resolver=resolver) instance_validator = mvalidators.Draft4Validator(schema, resolver=resolver) scope = schema.get('id', '') validator.validate(schema, _schema=meta_schema)
def validate(self, action, body): """Validates the request data This method relies on jsonschema and exists just as a way for third-party transport to validate the request. It's not recommended to validate every request since they are already validated server side. :param action: Action's for which body need to be validated. :type action: `six.text_type` :param body: Params to validate :type body: dict :returns: True if the schema is valid, False otherwise :raises: `errors.InvalidAction` if the action does not exist """ if action not in self.validators: schema = self.get_schema(action) self.validators[action] = validators.Draft4Validator(schema) try: self.validators[action].validate(body) except jsonschema.ValidationError as ex: LOG.debug('Schema validation failed. %s.' % str(ex)) return False return True
def test_compute_schema(self): test_scope = fake_scopes.compute_scope validators.Draft4Validator( audit_template.AuditTemplatePostType._build_schema() ).validate(test_scope)
def test_recursive(self): schema = { "definitions": { "node": { "anyOf": [{ "type": "object", "required": ["name", "children"], "properties": { "name": { "type": "string", }, "children": { "type": "object", "patternProperties": { "^.*$": { "$ref": "#/definitions/node", }, }, }, }, }], }, }, "type": "object", "required": ["root"], "properties": { "root": { "$ref": "#/definitions/node" } }, } instance = { "root": { "name": "root", "children": { "a": { "name": "a", "children": { "ab": { "name": "ab", # missing "children" }, }, }, }, }, } validator = validators.Draft4Validator(schema) e, = validator.iter_errors(instance) self.assertEqual(e.absolute_path, deque(["root"])) self.assertEqual( e.absolute_schema_path, deque(["properties", "root", "anyOf"]), ) e1, = e.context self.assertEqual(e1.absolute_path, deque(["root", "children", "a"])) self.assertEqual( e1.absolute_schema_path, deque([ "properties", "root", "anyOf", 0, "properties", "children", "patternProperties", "^.*$", "anyOf", ], ), ) e2, = e1.context self.assertEqual( e2.absolute_path, deque(["root", "children", "a", "children", "ab"], ), ) self.assertEqual( e2.absolute_schema_path, deque([ "properties", "root", "anyOf", 0, "properties", "children", "patternProperties", "^.*$", "anyOf", 0, "properties", "children", "patternProperties", "^.*$", "anyOf", ], ), )
def test_anyOf(self): instance = 5 schema = { "anyOf": [ { "minimum": 20 }, { "type": "string" }, ], } validator = validators.Draft4Validator(schema) errors = list(validator.iter_errors(instance)) self.assertEqual(len(errors), 1) e = errors[0] self.assertEqual(e.validator, "anyOf") self.assertEqual(e.validator_value, schema["anyOf"]) self.assertEqual(e.instance, instance) self.assertEqual(e.schema, schema) self.assertIsNone(e.parent) self.assertEqual(e.path, deque([])) self.assertEqual(e.relative_path, deque([])) self.assertEqual(e.absolute_path, deque([])) self.assertEqual(e.schema_path, deque(["anyOf"])) self.assertEqual(e.relative_schema_path, deque(["anyOf"])) self.assertEqual(e.absolute_schema_path, deque(["anyOf"])) self.assertEqual(len(e.context), 2) e1, e2 = sorted_errors(e.context) self.assertEqual(e1.validator, "minimum") self.assertEqual(e1.validator_value, schema["anyOf"][0]["minimum"]) self.assertEqual(e1.instance, instance) self.assertEqual(e1.schema, schema["anyOf"][0]) self.assertIs(e1.parent, e) self.assertEqual(e1.path, deque([])) self.assertEqual(e1.absolute_path, deque([])) self.assertEqual(e1.relative_path, deque([])) self.assertEqual(e1.schema_path, deque([0, "minimum"])) self.assertEqual(e1.relative_schema_path, deque([0, "minimum"])) self.assertEqual( e1.absolute_schema_path, deque(["anyOf", 0, "minimum"]), ) self.assertFalse(e1.context) self.assertEqual(e2.validator, "type") self.assertEqual(e2.validator_value, schema["anyOf"][1]["type"]) self.assertEqual(e2.instance, instance) self.assertEqual(e2.schema, schema["anyOf"][1]) self.assertIs(e2.parent, e) self.assertEqual(e2.path, deque([])) self.assertEqual(e2.relative_path, deque([])) self.assertEqual(e2.absolute_path, deque([])) self.assertEqual(e2.schema_path, deque([1, "type"])) self.assertEqual(e2.relative_schema_path, deque([1, "type"])) self.assertEqual(e2.absolute_schema_path, deque(["anyOf", 1, "type"])) self.assertEqual(len(e2.context), 0)
def test(self, format=format): v = validators.Draft4Validator( {"format": format}, format_checker=FormatChecker(), ) v.validate(123)
def test_default_schema(self): test_scope = fake_scopes.default_scope validators.Draft4Validator( default.DefaultScope.DEFAULT_SCHEMA).validate(test_scope)
def test_json_schema_validator(): schema = { "$schema": "http://json-schema.org/draft-04/schema#", "type": "object", "properties": { "data": { "type": "object", "properties": { "cur_num": { "type": "integer", "minimum": 1, "maximum": 10, "exclusiveMaximum": False }, "keyword": { "type": "string", "minLength": 1, "maxLength": 10 }, "vip": { "type": "boolean" }, "list": { "type": "array", "minItems": 1, "maxItems": 10, "items": { "type": "object", "properties": { "album_id": { "type": "integer" }, "publish": { "type": "string", "format": "date-time" } }, "required": ["album_id", "publish"] } } }, "required": ["cur_num", "keyword", "vip", "list"] } }, "required": ["data"] } respose_data = { "data": { "cur_num": 20, "keyword": "朴树", "vip": True, "list": [{ "album_id": 2032482, "publish": "2018-11-13T20:20:39+00:00" }, { "album_id": 7986, "publish": "2018-11-13T20:20:39+00:00" }] } } va = validators.Draft4Validator(schema) va.validate(respose_data)