def setUp(self):
super(UserValidationTestCase, self).setUp()
schema_user_create = identity_schema.user_create_v2
schema_user_update = identity_schema.user_update_v2
self.create_validator = validators.SchemaValidator(schema_user_create)
self.update_validator = validators.SchemaValidator(schema_user_update)
def setUp(self):
super(TenantValidationTestCase, self).setUp()
schema_tenant_create = resource_schema.tenant_create
schema_tenant_update = resource_schema.tenant_update
self.create_validator = validators.SchemaValidator(
schema_tenant_create)
self.update_validator = validators.SchemaValidator(
schema_tenant_update)
def validated(request_body_schema, resource_to_validate):
"""Register a schema to validate a resource reference.
Registered schema will be used for validating a request body just before
API method execution.
:param request_body_schema: a schema to validate the resource reference
:param resource_to_validate: the reference to validate
:raises TypeError: at decoration time when the expected resource to
validate isn't found in the decorated method's
signature
"""
schema_validator = validators.SchemaValidator(request_body_schema)
def add_validator(func):
argspec = inspect.getargspec(func)
try:
arg_index = argspec.args.index(resource_to_validate)
except ValueError:
raise TypeError(_('validated expected to find %(param_name)r in '
'function signature for %(func_name)r.') %
{'param_name': resource_to_validate,
'func_name': func.__name__})
@functools.wraps(func)
def wrapper(*args, **kwargs):
if resource_to_validate in kwargs:
schema_validator.validate(kwargs[resource_to_validate])
else:
schema_validator.validate(args[arg_index])
return func(*args, **kwargs)
return wrapper
return add_validator
def setUp(self):
super(ValidationTestCase, self).setUp()
self.resource_name = 'some resource name'
self.description = 'Some valid description'
self.valid_enabled = True
self.valid_url = 'http://example.com'
self.valid_email = '*****@*****.**'
self.create_schema_validator = validators.SchemaValidator(_CREATE)
def validated(request_body_schema, resource_to_validate):
"""Register a schema to validate a resource reference.
Registered schema will be used for validating a request body just before
API method execution.
:param request_body_schema: a schema to validate the resource reference
:param resource_to_validate: the reference to validate
:raises keystone.exception.ValidationError: if `resource_to_validate` is
not passed by or passed with an empty value (see wrapper method
below).
:raises TypeError: at decoration time when the expected resource to
validate isn't found in the decorated method's
signature
"""
schema_validator = validators.SchemaValidator(request_body_schema)
def add_validator(func):
argspec = inspect.getargspec(func)
try:
arg_index = argspec.args.index(resource_to_validate)
except ValueError:
raise TypeError(
_('validated expected to find %(param_name)r in '
'function signature for %(func_name)r.') % {
'param_name': resource_to_validate,
'func_name': func.__name__
})
@functools.wraps(func)
def wrapper(*args, **kwargs):
if kwargs.get(resource_to_validate):
schema_validator.validate(kwargs[resource_to_validate])
else:
try:
resource = args[arg_index]
# If resource to be validated is empty, no need to do
# validation since the message given by jsonschema doesn't
# help in this case.
if resource:
schema_validator.validate(resource)
else:
raise exception.ValidationError(
attribute=resource_to_validate,
target='request body')
# We cannot find the resource neither from kwargs nor args.
except IndexError:
raise exception.ValidationError(
attribute=resource_to_validate, target='request body')
return func(*args, **kwargs)
return wrapper
return add_validator
def lazy_validate(request_body_schema, resource_to_validate):
"""A non-decorator way to validate a request, to be used inline.
:param request_body_schema: a schema to validate the resource reference
:param resource_to_validate: dictionary to validate
:raises keystone.exception.ValidationError: if `resource_to_validate` is
None. (see wrapper method below).
:raises TypeError: at decoration time when the expected resource to
validate isn't found in the decorated method's
signature
"""
schema_validator = validators.SchemaValidator(request_body_schema)
schema_validator.validate(resource_to_validate)
def test_get_default_limit_model_response_schema(self):
schema = {
'type': 'object',
'properties': {
'model': {
'type': 'object',
'properties': {
'name': {'type': 'string'},
'description': {'type': 'string'}
},
'required': ['name', 'description'],
'additionalProperties': False,
},
},
'required': ['model'],
'additionalProperties': False,
}
validator = validators.SchemaValidator(schema)
response = self.get('/limits/model')
validator.validate(response.json_body)
def validated(request_body_schema, resource_to_validate):
"""Register a schema to validate a resource reference.
Registered schema will be used for validating a request body just before
API method execution.
:param request_body_schema: a schema to validate the resource reference
:param resource_to_validate: the reference to validate
"""
schema_validator = validators.SchemaValidator(request_body_schema)
def add_validator(func):
@functools.wraps(func)
def wrapper(*args, **kwargs):
if resource_to_validate in kwargs:
schema_validator.validate(kwargs[resource_to_validate])
return func(*args, **kwargs)
return wrapper
return add_validator
def setUp(self):
super(ServiceValidationTestCase, self).setUp()
schema_create = catalog_schema.service_create
self.create_validator = validators.SchemaValidator(schema_create)
'properties': _role_properties,
'required': ['id', 'name'],
},
'minItems': 1,
},
'project': {
'type': ['object'],
'required': ['id', 'name', 'domain'],
'properties': _project_properties,
'additionalProperties': False,
},
'is_domain': parameter_types.boolean,
}
schema = {
'type':
'object',
'properties':
_project_scope_properties,
'required': [
'audit_ids', 'expires_at', 'issued_at', 'methods', 'user', 'project',
'catalog'
],
'optional': ['is_domain'],
'additionalProperties':
False,
}
# Validator objects
scoped_validator = validators.SchemaValidator(schema)
'additionalProperties': False,
},
}
_unscoped_access_properties = copy.deepcopy(_base_access_properties)
unscoped_metadata = _unscoped_access_properties['metadata']
unscoped_metadata['properties']['roles']['maxItems'] = 0
_unscoped_access_properties['user']['properties']['roles']['maxItems'] = 0
_unscoped_access_properties['serviceCatalog']['maxItems'] = 0
_scoped_access_properties = copy.deepcopy(_base_access_properties)
_scoped_access_properties['metadata']['properties']['roles']['minItems'] = 1
_scoped_access_properties['serviceCatalog']['minItems'] = 1
_scoped_access_properties['user']['properties']['roles']['minItems'] = 1
base_token_schema = {
'type': 'object',
'required': ['metadata', 'user', 'serviceCatalog', 'token'],
'additionalProperties': False,
}
unscoped_token_schema = copy.deepcopy(base_token_schema)
unscoped_token_schema['properties'] = _unscoped_access_properties
scoped_token_schema = copy.deepcopy(base_token_schema)
scoped_token_schema['properties'] = _scoped_access_properties
# Validator objects
unscoped_validator = validators.SchemaValidator(unscoped_token_schema)
scoped_validator = validators.SchemaValidator(scoped_token_schema)
def setUp(self):
super(RoleValidationTestCase, self).setUp()
schema_role_create = assignment_schema.role_create
self.create_validator = validators.SchemaValidator(schema_role_create)
