def generate_response_header_validator(headers, context, **kwargs):
validators = ValidationDict()
for key, header_definition in headers.items():
# generate a function that will attempt to cast the header to the
# appropriate type.
header_processor = generate_value_processor(
context=context,
**header_definition
)
# generate a function that will validate the header.
header_validator = functools.partial(
validate_object,
field_validators=construct_header_validators(header_definition, context=context),
)
# Chain the type casting function, the individual header validation
# function with a methodcaller that will fetch the header with
# `response.headers.get(header_name, EMPTY)` and then feed that into
# the type casting function and then into the validation function.
validators.add_validator(key, chain_reduce_partial(
methodcaller('get', key, EMPTY),
header_processor,
header_validator,
))
return chain_reduce_partial(
attrgetter('headers'),
functools.partial(validate_object, field_validators=validators),
)
def generate_response_header_validator(headers, context, **kwargs):
validators = ValidationDict()
for key, header_definition in headers.items():
# generate a function that will attempt to cast the header to the
# appropriate type.
header_processor = generate_value_processor(
context=context,
**header_definition
)
# generate a function that will validate the header.
header_validator = functools.partial(
validate_object,
field_validators=construct_header_validators(header_definition, context=context),
)
# Chain the type casting function, the individual header validation
# function with a methodcaller that will fetch the header with
# `response.headers.get(header_name, EMPTY)` and then feed that into
# the type casting function and then into the validation function.
validators.add_validator(key, chain_reduce_partial(
methodcaller('get', key, EMPTY),
header_processor,
header_validator,
))
return chain_reduce_partial(
attrgetter('headers'),
functools.partial(validate_object, field_validators=validators),
)
def validate_object(obj,
field_validators=None,
non_field_validators=None,
schema=None,
context=None):
"""
Takes a mapping and applies a mapping of validator functions to it
collecting and reraising any validation errors that occur.
"""
if schema is None:
schema = {}
if context is None:
context = {}
if field_validators is None:
field_validators = ValidationDict()
if non_field_validators is None:
non_field_validators = ValidationList()
from flex.validation.schema import (
construct_schema_validators, )
schema_validators = construct_schema_validators(schema, context)
if '$ref' in schema_validators and hasattr(schema_validators['$ref'],
'validators'):
ref_ = field_validators.pop('$ref')
for k, v in ref_.validators.items():
if k not in schema_validators:
schema_validators.add_validator(k, v)
if 'discriminator' in schema:
add_polymorphism_requirements(obj, schema, context, schema_validators)
schema_validators.update(field_validators)
schema_validators.validate_object(obj, context=context)
non_field_validators.validate_object(obj, context=context)
return obj
def validate_object(obj, field_validators=None, non_field_validators=None,
schema=None, context=None):
"""
Takes a mapping and applies a mapping of validator functions to it
collecting and reraising any validation errors that occur.
"""
if schema is None:
schema = {}
if context is None:
context = {}
if field_validators is None:
field_validators = ValidationDict()
if non_field_validators is None:
non_field_validators = ValidationList()
from flex.validation.schema import (
construct_schema_validators,
)
schema_validators = construct_schema_validators(schema, context)
if '$ref' in schema_validators and hasattr(schema_validators['$ref'], 'validators'):
ref_ = field_validators.pop('$ref')
for k, v in ref_.validators.items():
if k not in schema_validators:
schema_validators.add_validator(k, v)
schema_validators.update(field_validators)
schema_validators.validate_object(obj, context=context)
non_field_validators.validate_object(obj, context=context)
return obj
def construct_header_validators(header_definition, context):
validators = ValidationDict()
for key in header_definition:
if key in validator_mapping:
validators.add_validator(
key,
validator_mapping[key](context=context, **header_definition),
)
return validators
def generate_header_validator(headers, context, **kwargs):
"""
Generates a validation function that will validate a dictionary of headers.
"""
validators = ValidationDict()
for header_definition in headers:
header_processor = generate_value_processor(context=context, **header_definition)
header_validator = generate_object_validator(
field_validators=construct_header_validators(header_definition, context=context)
)
validators.add_property_validator(
header_definition["name"], chain_reduce_partial(header_processor, header_validator)
)
return generate_object_validator(field_validators=validators)
def construct_schema_validators(schema, context):
"""
Given a schema object, construct a dictionary of validators needed to
validate a response matching the given schema.
Special Cases:
- $ref:
These validators need to be Lazily evaluating so that circular
validation dependencies do not result in an infinitely deep
validation chain.
- properties:
These validators are meant to apply to properties of the object
being validated rather than the object itself. In this case, we
need recurse back into this function to generate a dictionary of
validators for the property.
"""
validators = ValidationDict()
if '$ref' in schema:
validators.add_validator(
'$ref',
LazyReferenceValidator(schema['$ref'], context),
)
if 'properties' in schema:
for property_, property_schema in schema['properties'].items():
property_validator = generate_object_validator(
schema=property_schema,
context=context,
)
validators.add_property_validator(property_, property_validator)
assert 'context' not in schema
for key in schema:
if key in validator_mapping:
validators.add_validator(
key, validator_mapping[key](context=context, **schema))
return validators
def construct_schema_validators(schema, context):
"""
Given a schema object, construct a dictionary of validators needed to
validate a response matching the given schema.
Special Cases:
- $ref:
These validators need to be Lazily evaluating so that circular
validation dependencies do not result in an infinitely deep
validation chain.
- properties:
These validators are meant to apply to properties of the object
being validated rather than the object itself. In this case, we
need recurse back into this function to generate a dictionary of
validators for the property.
"""
validators = ValidationDict()
if '$ref' in schema:
validators.add_validator(
'$ref', SchemaReferenceValidator(schema['$ref'], context),
)
if 'properties' in schema:
for property_, property_schema in schema['properties'].items():
property_validator = generate_object_validator(
schema=property_schema,
context=context,
)
validators.add_property_validator(property_, property_validator)
assert 'context' not in schema
for key in schema:
if key in validator_mapping:
validators.add_validator(key, validator_mapping[key](context=context, **schema))
return validators
def construct_multi_parameter_validators(parameters, context):
"""
Given an iterable of parameters, returns a dictionary of validator
functions for each parameter. Note that this expects the parameters to be
unique in their name value, and throws an error if this is not the case.
"""
validators = ValidationDict()
for parameter in parameters:
key = parameter['name']
if key in validators:
raise ValueError("Duplicate parameter name {0}".format(key))
parameter_validators = construct_parameter_validators(parameter, context=context)
validators.add_validator(
key,
generate_object_validator(field_validators=parameter_validators),
)
return validators
def construct_multi_parameter_validators(parameters, context):
"""
Given an iterable of parameters, returns a dictionary of validator
functions for each parameter. Note that this expects the parameters to be
unique in their name value, and throws an error if this is not the case.
"""
validators = ValidationDict()
for parameter in parameters:
key = parameter['name']
if key in validators:
raise ValueError("Duplicate parameter name {0}".format(key))
parameter_validators = construct_parameter_validators(parameter,
context=context)
validators.add_validator(
key,
generate_object_validator(field_validators=parameter_validators),
)
return validators
def generate_header_validator(headers, context, **kwargs):
"""
Generates a validation function that will validate a dictionary of headers.
"""
validators = ValidationDict()
for header_definition in headers:
header_processor = generate_value_processor(context=context,
**header_definition)
header_validator = generate_object_validator(
field_validators=construct_header_validators(header_definition,
context=context), )
validators.add_property_validator(
header_definition['name'],
chain_reduce_partial(
header_processor,
header_validator,
),
)
return generate_object_validator(field_validators=validators)
def construct_parameter_validators(parameter, context):
"""
Constructs a dictionary of validator functions for the provided parameter
definition.
"""
validators = ValidationDict()
if '$ref' in parameter:
validators.add_validator(
'$ref',
ParameterReferenceValidator(parameter['$ref'], context),
)
for key in parameter:
if key in validator_mapping:
validators.add_validator(
key,
validator_mapping[key](context=context, **parameter),
)
if 'schema' in parameter:
schema_validators = construct_schema_validators(parameter['schema'],
context=context)
for key, value in schema_validators.items():
validators.setdefault(key, value)
return validators
def construct_parameter_validators(parameter, context):
"""
Constructs a dictionary of validator functions for the provided parameter
definition.
"""
validators = ValidationDict()
if '$ref' in parameter:
validators.add_validator(
'$ref', ParameterReferenceValidator(parameter['$ref'], context),
)
for key in parameter:
if key in validator_mapping:
validators.add_validator(
key,
validator_mapping[key](context=context, **parameter),
)
if 'schema' in parameter:
schema_validators = construct_schema_validators(parameter['schema'], context=context)
for key, value in schema_validators.items():
validators.setdefault(key, value)
return validators
validate_default_is_of_one_of_declared_types,
)
from .items import (
validate_items_required_if_array_type,
)
single_parameter_schema = {
'type': OBJECT,
'required': [
'name',
'in',
],
}
single_parameter_field_validators = ValidationDict()
single_parameter_field_validators.update(common_field_validators)
single_parameter_field_validators.add_property_validator('in', in_validator)
single_parameter_field_validators.add_property_validator('name', name_validator)
single_parameter_field_validators.add_property_validator('description', description_validator)
single_parameter_field_validators.add_property_validator('required', required_validator)
single_parameter_field_validators.add_property_validator('type', type_validator)
single_parameter_field_validators.add_property_validator('format', format_validator)
single_parameter_field_validators.add_property_validator(
'collectionFormat', collection_format_validator,
)
single_parameter_non_field_validators = ValidationDict()
single_parameter_non_field_validators.update(common_non_field_validators)
single_parameter_non_field_validators.update(common_type_validators)
def generate_response_validator(api_path, operation_definition, response_definition, path_definition, context):
validators = ValidationDict()
# Parameters is special cause it needs data from both the
# `operation_definition` and the `path_definition`
validators.add_validator(
"path",
generate_path_validator(
api_path=api_path,
path_definition=path_definition,
parameters=operation_definition.get("parameters", []),
context=context,
),
)
for key in validator_mapping:
if key in response_definition:
validators.add_validator(key, validator_mapping[key](context=context, **response_definition))
elif key in operation_definition:
validators.add_validator(key, validator_mapping[key](context=context, **operation_definition))
elif key in path_definition:
validators.add_validator(key, validator_mapping[key](context=context, **path_definition))
if "produces" in context and "produces" not in validators:
validators.add_validator("produces", generate_response_content_type_validator(**context))
return functools.partial(validate_object, field_validators=validators)
)
from flex.validation.common import (
generate_object_validator,
)
from .operation import (
operation_validator,
)
from .parameters import (
parameters_validator,
)
path_item_schema = {
'type': OBJECT,
}
non_field_validators = ValidationDict()
non_field_validators.add_property_validator('get', operation_validator)
non_field_validators.add_property_validator('put', operation_validator)
non_field_validators.add_property_validator('post', operation_validator)
non_field_validators.add_property_validator('delete', operation_validator)
non_field_validators.add_property_validator('options', operation_validator)
non_field_validators.add_property_validator('head', operation_validator)
non_field_validators.add_property_validator('patch', operation_validator)
non_field_validators.add_property_validator('parameters', parameters_validator)
path_item_validator = generate_object_validator(
schema=path_item_schema,
non_field_validators=non_field_validators,
)
from flex.validation.common import (
generate_object_validator,
apply_validator_to_object,
)
from flex.validation.utils import (
generate_any_validator, )
from flex.loading.common.reference import (
reference_object_validator, )
from .single import (
single_response_validator, )
responses_schema = {
'type': OBJECT,
}
field_validators = ValidationDict()
field_validators.add_property_validator(
'default',
generate_any_validator(
referenceObject=reference_object_validator,
responseObject=single_response_validator,
),
)
non_field_validators = ValidationList()
non_field_validators.add_validator(
functools.partial(
apply_validator_to_object,
validator=generate_any_validator(
referenceObject=reference_object_validator,
if parts.path:
from flex.core import load_source
if parts.path.startswith('/'):
schema = load_source(parts.path)
elif 'base_path' in kwargs:
schema = load_source(
os.path.join(kwargs['base_path'], parts.path))
try:
jsonpointer.resolve_pointer(schema, parts.fragment)
except jsonpointer.JsonPointerException:
errors.add_error(
reference,
MESSAGES['reference']['undefined'].format(reference),
)
field_validators = ValidationDict()
field_validators.add_property_validator('parameters', parameters_validator)
field_validators.add_property_validator('responses', responses_validator)
field_validators.add_property_validator('definitions',
schema_definitions_validator)
non_field_validators = ValidationDict()
non_field_validators.add_validator('definitions', validate_deferred_references)
definitions_validator = generate_object_validator(
schema=definitions_schema,
field_validators=field_validators,
non_field_validators=non_field_validators,
)
def generate_parameters_validator(api_path, path_definition, parameters,
context, **kwargs):
"""
Generates a validator function to validate.
- request.path against the path parameters.
- request.query against the query parameters.
- request.headers against the header parameters.
- TODO: request.body against the body parameters.
- TODO: request.formData against any form data.
"""
# TODO: figure out how to merge this with the same code in response
# validation.
validators = ValidationDict()
path_level_parameters = dereference_parameter_list(
path_definition.get('parameters', []),
context,
)
operation_level_parameters = dereference_parameter_list(
parameters,
context,
)
all_parameters = merge_parameter_lists(
path_level_parameters,
operation_level_parameters,
)
# PATH
in_path_parameters = filter_parameters(all_parameters, in_=PATH)
validators.add_validator(
'path',
chain_reduce_partial(
operator.attrgetter('path'),
generate_path_parameters_validator(api_path, in_path_parameters,
context),
),
)
# QUERY
in_query_parameters = filter_parameters(all_parameters, in_=QUERY)
validators.add_validator(
'query',
chain_reduce_partial(
operator.attrgetter('query_data'),
functools.partial(
validate_query_parameters,
query_parameters=in_query_parameters,
context=context,
),
),
)
# HEADERS
in_header_parameters = filter_parameters(all_parameters, in_=HEADER)
validators.add_validator(
'headers',
chain_reduce_partial(
operator.attrgetter('headers'),
generate_header_validator(in_header_parameters, context),
),
)
# FORM_DATA
# in_form_data_parameters = filter_parameters(all_parameters, in_=FORM_DATA)
# validators.add_validator(
# 'form_data',
# chain_reduce_partial(
# operator.attrgetter('data'),
# generate_form_data_validator(in_form_data_parameters, context),
# )
# )
# REQUEST_BODY
in_request_body_parameters = filter_parameters(all_parameters, in_=BODY)
validators.add_validator(
'request_body',
chain_reduce_partial(
operator.attrgetter('data'),
generate_request_body_validator(in_request_body_parameters,
context),
))
return generate_object_validator(field_validators=validators)
)
from .max_items import (
max_items_validator,
validate_max_items_greater_than_or_equal_to_min_items,
validate_type_for_max_items,
)
from .unique_items import (
unique_items_validator,
validate_type_for_unique_items,
)
from .enum import (
enum_validator,
)
field_validators = ValidationDict()
field_validators.add_property_validator('multipleOf', multiple_of_validator)
field_validators.add_property_validator('minimum', minimum_validator)
field_validators.add_property_validator('maximum', maximum_validator)
field_validators.add_property_validator('exclusiveMinimum', exclusive_minimum_validator)
field_validators.add_property_validator('exclusiveMaximum', exclusive_maximum_validator)
field_validators.add_property_validator('minLength', min_length_validator)
field_validators.add_property_validator('maxLength', max_length_validator)
field_validators.add_property_validator('pattern', pattern_validator)
field_validators.add_property_validator('minItems', min_items_validator)
field_validators.add_property_validator('maxItems', max_items_validator)
field_validators.add_property_validator('uniqueItems', unique_items_validator)
field_validators.add_property_validator('enum', enum_validator)
def generate_parameters_validator(api_path, path_definition, parameters,
context, **kwargs):
"""
Generates a validator function to validate.
- request.path against the path parameters.
- request.query against the query parameters.
- request.headers against the header parameters.
- TODO: request.body against the body parameters.
- TODO: request.formData against any form data.
"""
# TODO: figure out how to merge this with the same code in response
# validation.
validators = ValidationDict()
path_level_parameters = dereference_parameter_list(
path_definition.get('parameters', []),
context,
)
operation_level_parameters = dereference_parameter_list(
parameters,
context,
)
all_parameters = merge_parameter_lists(
path_level_parameters,
operation_level_parameters,
)
# PATH
in_path_parameters = filter_parameters(all_parameters, in_=PATH)
validators.add_validator(
'path',
chain_reduce_partial(
attrgetter('path'),
generate_path_parameters_validator(api_path, in_path_parameters, context),
),
)
# QUERY
in_query_parameters = filter_parameters(all_parameters, in_=QUERY)
validators.add_validator(
'query',
chain_reduce_partial(
attrgetter('query_data'),
functools.partial(
validate_query_parameters,
query_parameters=in_query_parameters,
context=context,
),
),
)
# HEADERS
in_header_parameters = filter_parameters(all_parameters, in_=HEADER)
validators.add_validator(
'headers',
chain_reduce_partial(
attrgetter('headers'),
generate_header_validator(in_header_parameters, context),
),
)
# FORM_DATA
# in_form_data_parameters = filter_parameters(all_parameters, in_=FORM_DATA)
# validators.add_validator(
# 'form_data',
# chain_reduce_partial(
# attrgetter('data'),
# generate_form_data_validator(in_form_data_parameters, context),
# )
# )
# REQUEST_BODY
in_request_body_parameters = filter_parameters(all_parameters, in_=BODY)
validators.add_validator(
'request_body',
chain_reduce_partial(
attrgetter('data'),
generate_request_body_validator(in_request_body_parameters, context),
)
)
return generate_object_validator(field_validators=validators)
generate_any_validator,
)
from flex.loading.common.reference import (
reference_object_validator,
)
from .single import (
single_response_validator,
)
responses_schema = {
'type': OBJECT,
}
field_validators = ValidationDict()
field_validators.add_property_validator(
'default',
generate_any_validator(
referenceObject=reference_object_validator,
responseObject=single_response_validator,
),
)
non_field_validators = ValidationList()
non_field_validators.add_validator(
functools.partial(
apply_validator_to_object,
validator=generate_any_validator(
def validate_deferred_references(schema, context, **kwargs):
try:
deferred_references = context["deferred_references"]
except:
raise KeyError("`deferred_references` not found in context")
with ErrorDict() as errors:
for reference in deferred_references:
parts = urlparse.urlparse(reference)
if any((parts.scheme, parts.netloc, parts.path, parts.params, parts.query)):
errors.add_error(reference, MESSAGES["reference"]["unsupported"].format(reference))
continue
try:
jsonpointer.resolve_pointer(schema, parts.fragment)
except jsonpointer.JsonPointerException:
errors.add_error(reference, MESSAGES["reference"]["undefined"].format(reference))
field_validators = ValidationDict()
field_validators.add_property_validator("parameters", parameters_validator)
field_validators.add_property_validator("responses", responses_validator)
field_validators.add_property_validator("definitions", schema_definitions_validator)
non_field_validators = ValidationDict()
non_field_validators.add_validator("definitions", validate_deferred_references)
definitions_validator = generate_object_validator(
schema=definitions_schema, field_validators=field_validators, non_field_validators=non_field_validators
)
@skip_if_not_of_type(STRING)
def validate_reference_pointer(reference, context, **kwargs):
parts = urlparse.urlparse(reference)
if any((parts.scheme, parts.netloc, parts.params, parts.query)):
raise ValidationError(
MESSAGES['reference']['unsupported'].format(reference), )
if parts.path:
from flex.core import load_source
if parts.path.startswith('/'):
context = load_source(parts.path)
elif 'base_path' in kwargs:
context = load_source(os.path.join(kwargs['base_path'],
parts.path))
try:
jsonpointer.resolve_pointer(context, parts.fragment)
except jsonpointer.JsonPointerException:
raise ValidationError(
MESSAGES['reference']['undefined'].format(reference), )
non_field_validators = ValidationDict()
non_field_validators.add_property_validator('$ref', validate_reference_pointer)
reference_object_validator = generate_object_validator(
schema=reference_object_schema,
non_field_validators=non_field_validators,
)
from .parameters import parameters_validator
from .responses import responses_validator
operation_schema = {
"type": OBJECT,
"properties": {
"tags": {"type": ARRAY, "items": {"type": STRING}},
"summary": {"type": STRING},
"description": {"type": STRING},
"operationId": {"type": STRING},
"consumes": {"type": ARRAY, "items": {"type": STRING}},
"produces": {"type": ARRAY, "items": {"type": STRING}},
# 'schemes': # TODO: Implement this.
"deprecated": {"type": BOOLEAN},
# 'security': # TODO: Implement this.
},
}
field_validators = ValidationDict()
field_validators.add_property_validator("parameters", parameters_validator)
field_validators.add_property_validator("responses", responses_validator)
field_validators.add_property_validator("externalDocs", external_docs_validator)
non_field_validators = ValidationDict()
non_field_validators.add_property_validator("consumes", mimetype_validator)
non_field_validators.add_property_validator("produces", mimetype_validator)
operation_validator = generate_object_validator(schema=operation_schema, field_validators=field_validators)
from flex.datastructures import (
ValidationDict, )
from flex.constants import (
OBJECT, )
from flex.validation.common import (
generate_object_validator, )
from .operation import (
operation_validator, )
from .parameters import (
parameters_validator, )
path_item_schema = {
'type': OBJECT,
}
non_field_validators = ValidationDict()
non_field_validators.add_property_validator('get', operation_validator)
non_field_validators.add_property_validator('put', operation_validator)
non_field_validators.add_property_validator('post', operation_validator)
non_field_validators.add_property_validator('delete', operation_validator)
non_field_validators.add_property_validator('options', operation_validator)
non_field_validators.add_property_validator('head', operation_validator)
non_field_validators.add_property_validator('patch', operation_validator)
non_field_validators.add_property_validator('parameters', parameters_validator)
path_item_validator = generate_object_validator(
schema=path_item_schema,
non_field_validators=non_field_validators,
)
def generate_response_validator(api_path, operation_definition, response_definition,
path_definition, context):
validators = ValidationDict()
# Parameters is special cause it needs data from both the
# `operation_definition` and the `path_definition`
validators.add_validator('path', generate_path_validator(
api_path=api_path,
path_definition=path_definition,
parameters=operation_definition.get('parameters', []),
context=context,
))
if '$ref' in response_definition:
response_definition = dereference_reference(response_definition['$ref'], context)
for key in validator_mapping:
if key in response_definition:
validators.add_validator(
key,
validator_mapping[key](context=context, **response_definition),
)
elif key in operation_definition:
validators.add_validator(
key,
validator_mapping[key](context=context, **operation_definition),
)
elif key in path_definition:
validators.add_validator(
key,
validator_mapping[key](context=context, **path_definition),
)
if 'produces' in context and 'produces' not in validators:
validators.add_validator(
'produces',
generate_response_content_type_validator(**context),
)
return functools.partial(
validate_object,
field_validators=validators,
)
from flex.datastructures import (
ValidationDict,
ValidationList,
)
from .ref import (
ref_validator,
)
from flex.loading.common.schema import (
schema_schema as common_schema_schema,
schema_field_validators as common_schema_field_validators,
schema_non_field_validators as common_schema_non_field_validators,
properties_schema as common_properties_schema,
items_schema as common_items_schema,
)
schema_field_validators = ValidationDict()
schema_field_validators.update(common_schema_field_validators)
schema_field_validators.add_property_validator('$ref', ref_validator)
schema_non_field_validators = ValidationDict()
schema_non_field_validators.update(common_schema_non_field_validators)
schema_validator = generate_object_validator(
schema=common_schema_schema,
field_validators=schema_field_validators,
non_field_validators=schema_non_field_validators,
)
from flex.loading.common import (
field_validators as common_field_validators,
non_field_validators as common_non_field_validators,
type_validators as common_type_validators,
)
schema_schema = {
'type': OBJECT,
'properties': {
'properties': {
'type': OBJECT,
},
}
}
schema_field_validators = ValidationDict()
schema_field_validators.update(common_field_validators)
schema_field_validators.add_property_validator('format', format_validator)
schema_field_validators.add_property_validator('title', title_validator)
schema_field_validators.add_property_validator('minProperties', min_properties_validator)
schema_field_validators.add_property_validator('maxProperties', max_properties_validator)
schema_field_validators.add_property_validator('required', required_validator)
schema_field_validators.add_property_validator('type', type_validator)
schema_field_validators.add_property_validator('readOnly', read_only_validator)
schema_field_validators.add_property_validator('externalDocs', external_docs_validator)
schema_non_field_validators = ValidationDict()
schema_non_field_validators.update(common_non_field_validators)
schema_non_field_validators.update(common_type_validators)
type_validator,
)
from .read_only import (
read_only_validator,
)
from flex.loading.common import (
field_validators as common_field_validators,
non_field_validators as common_non_field_validators,
type_validators as common_type_validators,
)
schema_schema = {
'type': OBJECT,
}
schema_field_validators = ValidationDict()
schema_field_validators.update(common_field_validators)
schema_field_validators.add_property_validator('format', format_validator)
schema_field_validators.add_property_validator('title', title_validator)
schema_field_validators.add_property_validator('minProperties', min_properties_validator)
schema_field_validators.add_property_validator('maxProperties', max_properties_validator)
schema_field_validators.add_property_validator('required', required_validator)
schema_field_validators.add_property_validator('type', type_validator)
schema_field_validators.add_property_validator('readOnly', read_only_validator)
schema_field_validators.add_property_validator('externalDocs', external_docs_validator)
schema_non_field_validators = ValidationDict()
schema_non_field_validators.update(common_non_field_validators)
schema_non_field_validators.update(common_type_validators)
format_validator, )
from .description import (
description_validator, )
from .type import (
type_validator, )
from .collection_format import (
collection_format_validator, )
single_header_schema = {
'type': OBJECT,
'required': [
'type',
]
}
single_header_field_validators = ValidationDict()
single_header_field_validators.update(common_field_validators)
single_header_field_validators.add_property_validator('description',
description_validator)
single_header_field_validators.add_property_validator('type', type_validator)
single_header_field_validators.add_property_validator('format',
format_validator)
single_header_field_validators.add_property_validator(
'collectionFormat',
collection_format_validator,
)
@pull_keys_from_obj('type', 'items')
@suffix_reserved_words
def validate_items_required_if_type_arraw(type_, items, **kwargs):
schema_validator,
)
from .headers import (
headers_validator,
)
single_response_schema = {
'type': OBJECT,
'required': [
'description',
],
'properties': {
'description': {
'type': STRING,
},
},
}
field_validators = ValidationDict()
field_validators.add_property_validator('schema', schema_validator)
field_validators.add_property_validator('headers', headers_validator)
single_response_validator = generate_object_validator(
schema=single_response_schema,
field_validators=field_validators,
)
__ALL__ = [
'info_validator',
'swagger_schema_validators',
'host_validator',
'base_path_validator',
'schemes_validator',
'mimetype_validator',
'paths_validator',
]
swagger_schema = {
'type': OBJECT,
}
non_field_validators = ValidationDict()
non_field_validators.add_property_validator('info', info_validator)
non_field_validators.add_property_validator('swagger',
swagger_version_validator)
non_field_validators.add_property_validator('host', host_validator)
non_field_validators.add_property_validator('basePath', base_path_validator)
non_field_validators.add_property_validator('schemes', schemes_validator)
non_field_validators.add_property_validator('produces', mimetype_validator)
non_field_validators.add_property_validator('consumes', mimetype_validator)
non_field_validators.add_property_validator('paths', paths_validator)
swagger_schema_validator = generate_object_validator(
schema=swagger_schema,
non_field_validators=non_field_validators,
)
def generate_response_validator(api_path, operation_definition, response_definition,
path_definition, context):
validators = ValidationDict()
# Parameters is special cause it needs data from both the
# `operation_definition` and the `path_definition`
validators.add_validator('path', generate_path_validator(
api_path=api_path,
path_definition=path_definition,
parameters=operation_definition.get('parameters', []),
context=context,
))
if '$ref' in response_definition:
response_definition = dereference_reference(response_definition['$ref'], context)
for key in validator_mapping:
if key in response_definition:
validators.add_validator(
key,
validator_mapping[key](context=context, **response_definition),
)
elif key in operation_definition:
validators.add_validator(
key,
validator_mapping[key](context=context, **operation_definition),
)
elif key in path_definition:
validators.add_validator(
key,
validator_mapping[key](context=context, **path_definition),
)
if 'produces' in context and 'produces' not in validators:
validators.add_validator(
'produces',
generate_response_content_type_validator(**context),
)
return functools.partial(
validate_object,
field_validators=validators,
)
from flex.constants import OBJECT, STRING
from flex.decorators import skip_if_not_of_type
from flex.validation.common import generate_object_validator
reference_object_schema = {
"type": OBJECT,
"additionalProperties": False,
"required": ["$ref"],
"properties": {"$ref": {"type": STRING}},
}
@skip_if_not_of_type(STRING)
def validate_reference_pointer(reference, context, **kwargs):
parts = urlparse.urlparse(reference)
if any((parts.scheme, parts.netloc, parts.path, parts.params, parts.query)):
raise ValidationError(MESSAGES["reference"]["unsupported"].format(reference))
try:
jsonpointer.resolve_pointer(context, parts.fragment)
except jsonpointer.JsonPointerException:
raise ValidationError(MESSAGES["reference"]["undefined"].format(reference))
non_field_validators = ValidationDict()
non_field_validators.add_property_validator("$ref", validate_reference_pointer)
reference_object_validator = generate_object_validator(
schema=reference_object_schema, non_field_validators=non_field_validators
)
},
},
'produces': {
'type': ARRAY,
'items': {
'type': STRING,
},
},
# 'schemes': # TODO: Implement this.
'deprecated': {
'type': BOOLEAN,
},
# 'security': # TODO: Implement this.
},
}
field_validators = ValidationDict()
field_validators.add_property_validator('parameters', parameters_validator)
field_validators.add_property_validator('responses', responses_validator)
field_validators.add_property_validator('externalDocs', external_docs_validator)
non_field_validators = ValidationDict()
non_field_validators.add_property_validator('consumes', mimetype_validator)
non_field_validators.add_property_validator('produces', mimetype_validator)
operation_validator = generate_object_validator(
schema=operation_schema,
field_validators=field_validators,
)
)
from flex.loading.common.single_parameter import (
single_parameter_schema,
single_parameter_field_validators as common_single_parameter_field_validators,
single_parameter_non_field_validators as common_single_parameter_non_field_validators,
)
from flex.validation.common import (
generate_object_validator,
)
from flex.loading.schema.paths.path_item.operation.responses.single.schema import (
schema_validator,
items_validator,
)
single_parameter_field_validators = ValidationDict()
single_parameter_field_validators.update(
common_single_parameter_field_validators
)
# schema fields
single_parameter_field_validators.add_property_validator('schema', schema_validator)
single_parameter_field_validators.add_property_validator('items', items_validator)
single_parameter_non_field_validators = ValidationDict()
single_parameter_non_field_validators.update(
common_single_parameter_non_field_validators
)
single_parameter_validator = generate_object_validator(
schema=single_parameter_schema,
from .type import (
type_validator,
)
from .collection_format import (
collection_format_validator,
)
single_header_schema = {
'type': OBJECT,
'required': [
'type',
]
}
single_header_field_validators = ValidationDict()
single_header_field_validators.update(common_field_validators)
single_header_field_validators.add_property_validator('description', description_validator)
single_header_field_validators.add_property_validator('type', type_validator)
single_header_field_validators.add_property_validator('format', format_validator)
single_header_field_validators.add_property_validator(
'collectionFormat', collection_format_validator,
)
@pull_keys_from_obj('type', 'items')
@suffix_reserved_words
def validate_items_required_if_type_arraw(type_, items, **kwargs):
types = pluralize(type_)
if ARRAY in types and items is EMPTY:
raise ValidationError(MESSAGES['required']['required'])
from flex.datastructures import (
ValidationDict,
)
from flex.loading.common.single_header import (
single_header_schema,
single_header_field_validators as common_single_header_field_validators,
single_header_non_field_validators as common_single_header_non_field_validators,
)
from flex.validation.common import (
generate_object_validator,
)
from flex.loading.schema.paths.path_item.operation.responses.single.schema import (
schema_validator,
items_validator,
)
single_header_field_validators = ValidationDict()
single_header_field_validators.update(common_single_header_field_validators)
single_header_field_validators.add_property_validator('schema', schema_validator)
single_header_field_validators.add_property_validator('items', items_validator)
single_header_validator = generate_object_validator(
schema=single_header_schema,
field_validators=single_header_field_validators,
non_field_validators=common_single_header_non_field_validators,
)
parts = urlparse.urlparse(reference)
if any((parts.scheme, parts.netloc, parts.path, parts.params, parts.query)):
errors.add_error(
reference,
MESSAGES['reference']['unsupported'].format(reference),
)
continue
try:
jsonpointer.resolve_pointer(schema, parts.fragment)
except jsonpointer.JsonPointerException:
errors.add_error(
reference,
MESSAGES['reference']['undefined'].format(reference),
)
field_validators = ValidationDict()
field_validators.add_property_validator('parameters', parameters_validator)
field_validators.add_property_validator('responses', responses_validator)
field_validators.add_property_validator('definitions', schema_definitions_validator)
non_field_validators = ValidationDict()
non_field_validators.add_validator('definitions', validate_deferred_references)
definitions_validator = generate_object_validator(
schema=definitions_schema,
field_validators=field_validators,
non_field_validators=non_field_validators,
)
'host_validator',
'base_path_validator',
'schemes_validator',
'mimetype_validator',
'paths_validator',
]
swagger_schema = {
'type': OBJECT,
'required': [
'info',
'paths',
'swagger',
],
}
non_field_validators = ValidationDict()
non_field_validators.add_property_validator('info', info_validator)
non_field_validators.add_property_validator('swagger', swagger_version_validator)
non_field_validators.add_property_validator('host', host_validator)
non_field_validators.add_property_validator('basePath', base_path_validator)
non_field_validators.add_property_validator('schemes', schemes_validator)
non_field_validators.add_property_validator('produces', mimetype_validator)
non_field_validators.add_property_validator('consumes', mimetype_validator)
non_field_validators.add_property_validator('paths', paths_validator)
swagger_schema_validator = generate_object_validator(
schema=swagger_schema,
non_field_validators=non_field_validators,
)
validate_collection_format_based_on_in_value,
)
from flex.loading.common.default import (
validate_default_is_of_one_of_declared_types, )
from .items import (
validate_items_required_if_array_type, )
single_parameter_schema = {
'type': OBJECT,
'required': [
'name',
'in',
],
}
single_parameter_field_validators = ValidationDict()
single_parameter_field_validators.update(common_field_validators)
single_parameter_field_validators.add_property_validator('in', in_validator)
single_parameter_field_validators.add_property_validator(
'name', name_validator)
single_parameter_field_validators.add_property_validator(
'description', description_validator)
single_parameter_field_validators.add_property_validator(
'required', required_validator)
single_parameter_field_validators.add_property_validator(
'type', type_validator)
single_parameter_field_validators.add_property_validator(
'format', format_validator)
single_parameter_field_validators.add_property_validator(
'collectionFormat',
from flex.datastructures import ValidationDict
from flex.loading.common.single_parameter import (
single_parameter_schema,
single_parameter_field_validators as common_single_parameter_field_validators,
single_parameter_non_field_validators as common_single_parameter_non_field_validators,
)
from flex.loading.definitions.schema import schema_validator, items_validator
from flex.validation.common import generate_object_validator
single_parameter_field_validators = ValidationDict()
single_parameter_field_validators.update(common_single_parameter_field_validators)
# schema fields
single_parameter_field_validators.add_property_validator("schema", schema_validator)
single_parameter_field_validators.add_property_validator("items", items_validator)
single_parameter_non_field_validators = ValidationDict()
single_parameter_non_field_validators.update(common_single_parameter_non_field_validators)
single_parameter_validator = generate_object_validator(
schema=single_parameter_schema,
field_validators=single_parameter_field_validators,
non_field_validators=single_parameter_non_field_validators,
)
STRING,
)
from flex.validation.common import (
generate_object_validator, )
from .headers import (
headers_validator, )
from .schema import (
schema_validator, )
single_response_schema = {
'type': OBJECT,
'required': [
'description',
],
'properties': {
'description': {
'type': STRING,
},
},
}
field_validators = ValidationDict()
field_validators.add_property_validator('schema', schema_validator)
field_validators.add_property_validator('headers', headers_validator)
single_response_validator = generate_object_validator(
schema=single_response_schema,
field_validators=field_validators,
)
)
from flex.datastructures import (
ValidationDict,
ValidationList,
)
from .ref import (
ref_validator, )
from flex.loading.common.schema import (
schema_schema as common_schema_schema,
schema_field_validators as common_schema_field_validators,
schema_non_field_validators as common_schema_non_field_validators,
properties_schema as common_properties_schema,
items_schema as common_items_schema,
)
schema_field_validators = ValidationDict()
schema_field_validators.update(common_schema_field_validators)
schema_field_validators.add_property_validator('$ref', ref_validator)
schema_non_field_validators = ValidationDict()
schema_non_field_validators.update(common_schema_non_field_validators)
schema_validator = generate_object_validator(
schema=common_schema_schema,
field_validators=schema_field_validators,
non_field_validators=schema_non_field_validators,
)
#
# Properties.
from flex.datastructures import ValidationDict
from flex.constants import OBJECT, STRING
from flex.validation.common import generate_object_validator
from .headers import headers_validator
from .schema import schema_validator
single_response_schema = {"type": OBJECT, "required": ["description"], "properties": {"description": {"type": STRING}}}
field_validators = ValidationDict()
field_validators.add_property_validator("schema", schema_validator)
field_validators.add_property_validator("headers", headers_validator)
single_response_validator = generate_object_validator(schema=single_response_schema, field_validators=field_validators)
