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)
