Esempio n. 1
0
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)
Esempio n. 2
0
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
Esempio n. 3
0
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
Esempio n. 4
0
def generate_request_body_validator(body_parameters, context, **kwargs):
    if len(body_parameters) > 1:
        raise ValueError("Too many body parameters.  Should only be one")
    elif not body_parameters:
        return noop
    body_validators = construct_parameter_validators(body_parameters[0], context=context)
    return generate_object_validator(field_validators=body_validators)
Esempio n. 5
0
def generate_request_body_validator(body_parameters, context, **kwargs):
    if len(body_parameters) > 1:
        raise ValueError("Too many body parameters.  Should only be one")
    elif not body_parameters:
        return noop
    body_validators = construct_parameter_validators(
        body_parameters[0], context=context,
    )
    return generate_object_validator(field_validators=body_validators)
Esempio n. 6
0
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)
Esempio n. 7
0
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
Esempio n. 8
0
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
Esempio n. 9
0
            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,
)
Esempio n. 10
0
    '^'
    '(application|audio|example|image|message|model|multipart|text|video)'  # top-level type name
    '/'
    '(vnd(\.[-a-zA-Z0-9]+)*\.)?'  # vendor tree
    '([-a-zA-Z0-9]+)'  # media type
    '(\+(xml|json|ber|der|fastinfoset|wbxml|zip))?'
    '((; [-a-zA-Z0-9]+=(([-\.a-zA-Z0-9]+)|(("|\')[-\.a-zA-Z0-9]+("|\'))))+)?'  # parameters
    '$')


@skip_if_empty
@skip_if_not_of_type(ARRAY)
def validate_mimetype(values, **kwargs):
    for value in values:
        if not re.match(MIMETYPE_PATTERN, value):
            raise ValidationError(
                MESSAGES['mimetype']['invalid'].format(value), )


mimetype_schema = {
    'type': ARRAY,
}

non_field_validators = ValidationList()
non_field_validators.add_validator(validate_mimetype)

mimetype_validator = generate_object_validator(
    schema=mimetype_schema,
    non_field_validators=non_field_validators,
)
Esempio n. 11
0
from flex.constants import (
    BOOLEAN,
)
from flex.validation.common import (
    generate_object_validator,
)
from flex.validation.schema import (
    construct_schema_validators,
)


required_schema = {
    'type': BOOLEAN,
}
required_validators = construct_schema_validators(required_schema, {})

required_validator = generate_object_validator(
    field_validators=required_validators,
)
Esempio n. 12
0
    FORM_DATA,
    COLLECTION_FORMATS,
)
from flex.validation.common import (
    generate_object_validator, )
from flex.decorators import (
    pull_keys_from_obj,
    suffix_reserved_words,
    skip_if_any_kwargs_empty,
)


@pull_keys_from_obj('in', 'collectionFormat')
@skip_if_any_kwargs_empty('in', 'collectionFormat')
@suffix_reserved_words
def validate_collection_format_based_on_in_value(in_, collectionFormat,
                                                 **kwargs):
    if collectionFormat == MULTI:
        if in_ not in (QUERY, FORM_DATA):
            raise ValidationError(
                MESSAGES['collection_format']['invalid_based_on_in_value'])


collection_format_schema = {
    'type': STRING,
    'enum': COLLECTION_FORMATS,
}

collection_format_validator = generate_object_validator(
    schema=collection_format_schema, )
Esempio n. 13
0
from flex.datastructures import ValidationList
from flex.constants import (
    OBJECT,
)
from flex.validation.common import (
    generate_object_validator,
    apply_validator_to_object,
)

from .single import (
    single_header_validator,
)


headers_schema = {
    'type': OBJECT,
}


non_field_validators = ValidationList()
non_field_validators.add_validator(
    functools.partial(apply_validator_to_object, validator=single_header_validator),
)


headers_validator = generate_object_validator(
    schema=headers_schema,
    non_field_validators=non_field_validators,
)
Esempio n. 14
0
import functools
from flex.datastructures import (
    ValidationList, )
from flex.constants import (
    OBJECT, )
from flex.validation.common import (
    generate_object_validator,
    apply_validator_to_object,
)
from .single import (
    single_parameter_validator, )

parameters_schema = {
    'type': OBJECT,
}

parameters_non_field_validators = ValidationList()
parameters_non_field_validators.add_validator(
    functools.partial(apply_validator_to_object,
                      validator=single_parameter_validator), )

parameters_validator = generate_object_validator(
    schema=parameters_schema,
    non_field_validators=parameters_non_field_validators,
)
Esempio n. 15
0
__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,
)
Esempio n. 16
0

@pull_keys_from_obj('minLength', 'maxLength')
@skip_if_any_kwargs_empty('minLength', 'maxLength')
def validate_max_length_greater_than_or_equal_to_min_length(
        minLength, maxLength, **kwargs):
    if minLength is EMPTY or maxLength is EMPTY:
        return

    if not maxLength >= minLength:
        raise ValidationError(
            MESSAGES['max_length']['must_be_greater_than_min_length'])


@pull_keys_from_obj('type', 'maxLength')
@suffix_reserved_words
@skip_if_any_kwargs_empty('type_', 'maxLength')
def validate_type_for_max_length(type_, maxLength, **kwargs):
    types = pluralize(type_)

    if not set(types).intersection((STRING, )):
        raise ValidationError(
            MESSAGES['type']['invalid_type_for_max_length'], )


max_length_schema = {
    'type': INTEGER,
    'minimum': 1,
}
max_length_validator = generate_object_validator(schema=max_length_schema, )
Esempio n. 17
0
from flex.utils import (
    pluralize,
)
from flex.decorators import (
    pull_keys_from_obj,
    suffix_reserved_words,
    skip_if_any_kwargs_empty,
)


multiple_of_schema = {
    'type': NUMBER,
    'minimum': 0,
}

multiple_of_validator = generate_object_validator(
    schema=multiple_of_schema,
)


@pull_keys_from_obj('type', 'multipleOf')
@suffix_reserved_words
@skip_if_any_kwargs_empty('type_', 'multipleOf')
def validate_type_for_multiple_of(type_, multipleOf, **kwargs):
    types = pluralize(type_)

    if not set(types).intersection((INTEGER, NUMBER)):
        raise ValidationError(
            MESSAGES['type']['invalid_type_for_multiple_of'],
        )
Esempio n. 18
0
import functools
from flex.datastructures import (
    ValidationList,
)
from flex.constants import (
    OBJECT,
)
from flex.validation.common import (
    generate_object_validator,
    apply_validator_to_object,
)
from .single import (
    single_parameter_validator,
)


parameters_schema = {
    'type': OBJECT,
}

parameters_non_field_validators = ValidationList()
parameters_non_field_validators.add_validator(
    functools.partial(apply_validator_to_object, validator=single_parameter_validator),
)

parameters_validator = generate_object_validator(
    schema=parameters_schema,
    non_field_validators=parameters_non_field_validators,
)
Esempio n. 19
0
File: name.py Progetto: Arable/flex
from flex.constants import (
    STRING,
)
from flex.validation.common import (
    generate_object_validator,
)


name_schema = {
    'type': STRING,
}


name_validator = generate_object_validator(
    schema=name_schema,
)
Esempio n. 20
0
single_type_schema = {
    'type': STRING,
    'enum': [
        NULL,
        BOOLEAN,
        INTEGER,
        NUMBER,
        STRING,
        ARRAY,
        OBJECT,
    ],
}
single_type_validators = construct_schema_validators(single_type_schema, {})

single_type_validator = generate_object_validator(
    field_validators=single_type_validators,
)


@suffix_reserved_words
@skip_if_not_of_type(ARRAY, STRING)
def validate_types(type_, **kwargs):
    types = pluralize(type_)

    with ErrorList() as errors:
        for value in types:
            try:
                single_type_validator(value)
            except ValidationError as err:
                errors.add_error(err.detail)
Esempio n. 21
0
from flex.constants import (
    STRING,
)
from flex.validation.common import (
    generate_object_validator,
)
from flex.validation.schema import (
    construct_schema_validators,
)


format_schema = {
    'type': STRING,
}
format_validators = construct_schema_validators(format_schema, {})

format_validator = generate_object_validator(
    field_validators=format_validators,
)
Esempio n. 22
0
)


@pull_keys_from_obj('minItems', 'maxItems')
def validate_max_items_greater_than_or_equal_to_min_items(
        minItems, maxItems, **kwargs):
    if minItems is EMPTY or maxItems is EMPTY:
        return
    if not maxItems >= minItems:
        raise ValidationError(
            MESSAGES['max_items']['must_be_greater_than_min_items'])


@pull_keys_from_obj('type', 'maxItems')
@suffix_reserved_words
@skip_if_any_kwargs_empty('type_', 'maxItems')
def validate_type_for_max_items(type_, maxItems, **kwargs):
    types = pluralize(type_)

    if not set(types).intersection((ARRAY, )):
        raise ValidationError(MESSAGES['type']['invalid_type_for_max_items'], )


max_items_schema = {
    'type': INTEGER,
}
max_items_validators = construct_schema_validators(max_items_schema, {})

max_items_validator = generate_object_validator(
    field_validators=max_items_validators, )
Esempio n. 23
0
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)
Esempio n. 24
0

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,
            responseObject=single_response_validator,
        ),
    )
)


responses_validator = generate_object_validator(
    schema=responses_schema,
    field_validators=field_validators,
    non_field_validators=non_field_validators,
)
Esempio n. 25
0
)
from flex.validation.schema import (
    construct_schema_validators,
)
from flex.decorators import (
    skip_if_empty,
    skip_if_not_of_type,
)


@skip_if_empty
@skip_if_not_of_type(STRING)
def regex_validator(value, **kwargs):
    try:
        re.compile(value)
    except re.error:
        raise ValidationError(
            MESSAGES['pattern']['invalid_regex'].format(value)
        )


pattern_schema = {
    'type': STRING,
}
pattern_validators = construct_schema_validators(pattern_schema, {})
pattern_validators.add_validator('regex', regex_validator)

pattern_validator = generate_object_validator(
    field_validators=pattern_validators,
)
Esempio n. 26
0

@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,
)
Esempio n. 27
0
import functools

from flex.datastructures import (
    ValidationList, )
from flex.constants import OBJECT
from flex.validation.common import (
    generate_object_validator,
    apply_validator_to_object,
)
from .schema import (
    schema_validator, )

schema_definitions_schema = {
    'type': OBJECT,
}

non_field_validators = ValidationList()
non_field_validators.add_validator(
    functools.partial(apply_validator_to_object, validator=schema_validator), )

schema_definitions_validator = generate_object_validator(
    schema=schema_definitions_schema,
    non_field_validators=non_field_validators,
)
Esempio n. 28
0
            },
        },
        '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,
)
Esempio n. 29
0
from flex.exceptions import ValidationError
from flex.constants import INTEGER, NUMBER, EMPTY, BOOLEAN
from flex.utils import pluralize
from flex.error_messages import MESSAGES
from flex.validation.common import generate_object_validator
from flex.decorators import suffix_reserved_words, pull_keys_from_obj, skip_if_any_kwargs_empty


@pull_keys_from_obj("minimum", "exclusiveMinimum")
@skip_if_any_kwargs_empty("exclusiveMinimum")
def validate_minimum_required_if_exclusive_minimum_set(minimum, exclusiveMinimum, **kwargs):
    if exclusiveMinimum is True and minimum is EMPTY:
        raise ValidationError(MESSAGES["minimum"]["exclusive_minimum_required_minimum"])


@pull_keys_from_obj("type", "minimum")
@suffix_reserved_words
@skip_if_any_kwargs_empty("type_", "minimum")
def validate_type_for_minimum(type_, minimum, **kwargs):
    types = pluralize(type_)

    if not set(types).intersection((INTEGER, NUMBER)):
        raise ValidationError(MESSAGES["type"]["invalid_type_for_minimum"])


minimum_schema = {"type": NUMBER}
minimum_validator = generate_object_validator(schema=minimum_schema)

exclusive_minimum_schema = {"type": BOOLEAN}
exclusive_minimum_validator = generate_object_validator(schema=exclusive_minimum_schema)
Esempio n. 30
0
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)
Esempio n. 31
0
File: type.py Progetto: Arable/flex
from flex.validation.common import (
    generate_object_validator,
)

ALLOWED_TYPES = [STRING, NUMBER, INTEGER, BOOLEAN, ARRAY]

type_schema = {
    'type': [STRING, ARRAY],
    'items': {
        'type': STRING,
        'enum': ALLOWED_TYPES,
    },
}


@skip_if_not_of_type(STRING)
@skip_if_empty
def validate_type(_type, **kwargs):
    if _type not in ALLOWED_TYPES:
        raise ValidationError(MESSAGES['enum']['invalid'].format(_type, ALLOWED_TYPES))


non_field_validators = ValidationList()
non_field_validators.add_validator(validate_type)


type_validator = generate_object_validator(
    schema=type_schema,
    non_field_validators=non_field_validators,
)
Esempio n. 32
0
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.definitions.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,
)
Esempio n. 33
0
from flex.exceptions import ValidationError
from flex.error_messages import MESSAGES
from flex.constants import BOOLEAN, ARRAY
from flex.utils import pluralize
from flex.validation.common import generate_object_validator
from flex.validation.schema import construct_schema_validators
from flex.decorators import pull_keys_from_obj, suffix_reserved_words, skip_if_any_kwargs_empty


@pull_keys_from_obj("type", "uniqueItems")
@suffix_reserved_words
@skip_if_any_kwargs_empty("type_", "uniqueItems")
def validate_type_for_unique_items(type_, uniqueItems, **kwargs):
    types = pluralize(type_)

    if not uniqueItems:
        return

    if not set(types).intersection((ARRAY,)):
        raise ValidationError(MESSAGES["type"]["invalid_type_for_unique_items"])


unique_items_schema = {"type": BOOLEAN}
unique_items_validators = construct_schema_validators(unique_items_schema, {})

unique_items_validator = generate_object_validator(field_validators=unique_items_validators)
Esempio n. 34
0
from .path_item import (
    path_item_validator, )


@skip_if_empty
@skip_if_not_of_type(OBJECT)
def validate_path_items(paths, **kwargs):
    with ErrorCollection() as errors:
        for path, path_definition in paths.items():
            # TODO: move this to its own validation function that validates the keys.
            if not path.startswith('/'):
                errors.add_error(path,
                                 MESSAGES['path']['must_start_with_slash'])

            try:
                path_item_validator(path_definition, **kwargs)
            except ValidationError as err:
                errors.add_error(path, err.detail)


paths_schema = {
    'type': OBJECT,
}
non_field_validators = ValidationList()
non_field_validators.add_validator(validate_path_items)

paths_validator = generate_object_validator(
    schema=paths_schema,
    non_field_validators=non_field_validators,
)
Esempio n. 35
0
File: type.py Progetto: Arable/flex
single_type_schema = {
    'type': STRING,
    'enum': [
        NULL,
        BOOLEAN,
        INTEGER,
        NUMBER,
        STRING,
        ARRAY,
    ],
}
single_type_validators = construct_schema_validators(single_type_schema, {})

single_type_validator = generate_object_validator(
    field_validators=single_type_validators,
)


@suffix_reserved_words
@skip_if_not_of_type(ARRAY, STRING)
def validate_types(type_, **kwargs):
    types = pluralize(type_)

    with ErrorList() as errors:
        for value in types:
            try:
                single_type_validator(value)
            except ValidationError as err:
                errors.add_error(err.detail)
Esempio n. 36
0
from flex.constants import (
    ARRAY, )
from flex.validation.common import (
    generate_object_validator, )
from flex.validation.schema import (
    construct_schema_validators, )

enum_schema = {
    'type': ARRAY,
    'minItems': 1,
}
enum_validators = construct_schema_validators(enum_schema, {})

enum_validator = generate_object_validator(field_validators=enum_validators, )
Esempio n. 37
0
    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,
)
Esempio n. 38
0
import functools

from flex.datastructures import ValidationList
from flex.constants import OBJECT
from flex.validation.common import generate_object_validator, apply_validator_to_object
from .schema import schema_validator


schema_definitions_schema = {"type": OBJECT}

non_field_validators = ValidationList()
non_field_validators.add_validator(functools.partial(apply_validator_to_object, validator=schema_validator))

schema_definitions_validator = generate_object_validator(
    schema=schema_definitions_schema, non_field_validators=non_field_validators
)
Esempio n. 39
0
from flex.constants import (
    STRING,
)
from flex.validation.common import (
    generate_object_validator,
)


swagger_version_schema = {
    'enum': ['2.0'],
    'type': STRING,
}

swagger_version_validator = generate_object_validator(
    schema=swagger_version_schema,
)
Esempio n. 40
0
File: enum.py Progetto: Arable/flex
from flex.constants import (
    ARRAY,
)
from flex.validation.common import (
    generate_object_validator,
)
from flex.validation.schema import (
    construct_schema_validators,
)


enum_schema = {
    'type': ARRAY,
    'minItems': 1,
}
enum_validators = construct_schema_validators(enum_schema, {})

enum_validator = generate_object_validator(
    field_validators=enum_validators,
)
Esempio n. 41
0
from flex.constants import (
    STRING,
)
from flex.validation.common import (
    generate_object_validator,
)
from flex.validation.schema import (
    construct_schema_validators,
)


title_schema = {
    'type': STRING,
}
title_validators = construct_schema_validators(title_schema, {})

title_validator = generate_object_validator(
    field_validators=title_validators,
)
Esempio n. 42
0
    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.
#
properties_non_field_validators = ValidationDict()
properties_non_field_validators.add_validator(
    'properties', functools.partial(apply_validator_to_object, validator=schema_validator),
)

properties_validator = generate_object_validator(
    schema=common_properties_schema,
    non_field_validators=properties_non_field_validators,
Esempio n. 43
0
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)
Esempio n. 44
0
from flex.validation.schema import (
    construct_schema_validators,
)
from flex.decorators import (
    pull_keys_from_obj,
    suffix_reserved_words,
    skip_if_any_kwargs_empty,
)


@pull_keys_from_obj('type', 'minProperties')
@suffix_reserved_words
@skip_if_any_kwargs_empty('type_', 'minProperties')
def validate_type_for_min_properties(type_, minProperties, **kwargs):
    types = pluralize(type_)

    if not set(types).intersection((OBJECT,)):
        raise ValidationError(
            MESSAGES['type']['invalid_type_for_min_properties'],
        )


min_properties_schema = {
    'type': INTEGER,
    'minimum': 0,
}
min_properties_validators = construct_schema_validators(min_properties_schema, {})
min_properties_validator = generate_object_validator(
    field_validators=min_properties_validators,
)
Esempio n. 45
0
from flex.constants import (
    STRING, OBJECT
)
from flex.validation.common import (
    generate_object_validator,
)


info_schema = {
    'required': [
        'title',
    ],
    'properties': {
        'title': {
            'type': STRING,
        },
        'description': {'type': STRING},
        'termsOfService': {'type': STRING},
        'contact': {'type': OBJECT},
        'license': {'type': STRING},
        'version': {'type': STRING},
    }
}

info_validator = generate_object_validator(
    schema=info_schema,
)
Esempio n. 46
0
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,
)
Esempio n. 47
0
    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,
    field_validators=single_parameter_field_validators,
    non_field_validators=single_parameter_non_field_validators,
)
Esempio n. 48
0
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,
)
Esempio n. 49
0
    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,
)
Esempio n. 50
0
from flex.decorators import (
    pull_keys_from_obj,
    suffix_reserved_words,
    skip_if_any_kwargs_empty,
)


@pull_keys_from_obj('type', 'uniqueItems')
@suffix_reserved_words
@skip_if_any_kwargs_empty('type_', 'uniqueItems')
def validate_type_for_unique_items(type_, uniqueItems, **kwargs):
    types = pluralize(type_)

    if not uniqueItems:
        return

    if not set(types).intersection((ARRAY,)):
        raise ValidationError(
            MESSAGES['type']['invalid_type_for_unique_items'],
        )


unique_items_schema = {
    'type': BOOLEAN,
}
unique_items_validators = construct_schema_validators(unique_items_schema, {})

unique_items_validator = generate_object_validator(
    field_validators=unique_items_validators,
)
Esempio n. 51
0
        if not all(allowed.match(x) for x in hostname.split(".")):
            errors.add_error(
                'invalid',
                MESSAGES['host']['invalid'].format(value),
            )

        if path:
            errors.add_error(
                'path',
                MESSAGES['host']['may_not_include_path'].format(value),
            )

        if scheme:
            errors.add_error(
                'scheme',
                MESSAGES['host']['may_not_include_scheme'].format(value),
            )


host_schema = {
    'type': STRING,
}

non_field_validators = ValidationList()
non_field_validators.add_validator(host_validator)

host_validator = generate_object_validator(
    schema=host_schema,
    non_field_validators=non_field_validators,
)
Esempio n. 52
0
from .path_item import (
    path_item_validator,
)


@skip_if_empty
@skip_if_not_of_type(OBJECT)
def validate_path_items(paths, **kwargs):
    with ErrorDict() as errors:
        for path, path_definition in paths.items():
            # TODO: move this to its own validation function that validates the keys.
            if not path.startswith('/'):
                errors.add_error(path, MESSAGES['path']['must_start_with_slash'])

            try:
                path_item_validator(path_definition, **kwargs)
            except ValidationError as err:
                errors.add_error(path, err.detail)


paths_schema = {
    'type': OBJECT,
}
non_field_validators = ValidationList()
non_field_validators.add_validator(validate_path_items)

paths_validator = generate_object_validator(
    schema=paths_schema,
    non_field_validators=non_field_validators,
)
Esempio n. 53
0
File: in_.py Progetto: djta/5GCORE-1
@skip_if_any_kwargs_empty('in')
@suffix_reserved_words
def validate_path_parameters_must_be_required(in_, required, **kwargs):
    if in_ == PATH:
        if required is not True:
            raise ValidationError(
                MESSAGES['required']['path_parameters_must_be_required'])


@pull_keys_from_obj('in', 'schema')
@skip_if_any_kwargs_empty('in')
@suffix_reserved_words
def validate_body_parameters_must_include_a_schema(in_, schema, **kwargs):
    if in_ == BODY:
        if schema is EMPTY:
            raise ValidationError(
                MESSAGES['schema']['body_parameters_must_include_a_schema'])


@pull_keys_from_obj('in', 'type')
@skip_if_any_kwargs_empty('in')
@suffix_reserved_words
def validate_type_declared_for_non_body_parameters(in_, type_, **kwargs):
    if in_ != BODY:
        if type_ is EMPTY:
            raise ValidationError(
                MESSAGES['type']['non_body_parameters_must_declare_a_type'])


in_validator = generate_object_validator(schema=in_schema, )
Esempio n. 54
0
from flex.constants import (
    STRING, )
from flex.validation.common import (
    generate_object_validator, )

swagger_version_schema = {
    'enum': ['2.0'],
    'type': STRING,
}

swagger_version_validator = generate_object_validator(
    schema=swagger_version_schema, )
Esempio n. 55
0
from flex.constants import (
    STRING,
)
from flex.validation.common import (
    generate_object_validator,
)

description_schema = {
    'type': STRING,
}


description_validator = generate_object_validator(
    schema=description_schema,
)
Esempio n. 56
0
from flex.constants import (
    STRING,
)
from flex.validation.common import (
    generate_object_validator,
)


name_schema = {
    'type': STRING,
    'required': True,
}


name_validator = generate_object_validator(
    schema=name_schema,
)
Esempio n. 57
0
    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.
#
properties_non_field_validators = ValidationDict()
properties_non_field_validators.add_validator(
    'properties',
    functools.partial(apply_validator_to_object, validator=schema_validator),
)

properties_validator = generate_object_validator(
    schema=common_properties_schema,
    non_field_validators=properties_non_field_validators,
Esempio n. 58
0
import functools

from flex.datastructures import (
    ValidationList, )
from flex.constants import (
    OBJECT, )
from flex.validation.common import (
    generate_object_validator,
    apply_validator_to_object,
)
from .single import (
    single_response_validator, )

responses_schema = {
    'type': OBJECT,
}

non_field_validators = ValidationList()
non_field_validators.add_validator(
    functools.partial(apply_validator_to_object,
                      validator=single_response_validator), )

responses_validator = generate_object_validator(
    schema=responses_schema,
    non_field_validators=non_field_validators,
)