github/openapi-core
1
0
Fork 0
mirror of https://github.com/correl/openapi-core.git synced 2025-01-01 11:03:19 +00:00
Code Issues Projects Releases Packages Wiki Activity

Get rid of object validator

Browse source
This commit is contained in:
p1c2u 2019-09-11 22:47:16 +01:00
parent b2410e2f3a
commit a2fc5284c6
9 changed files with 403 additions and 438 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
openapi_core/schema/media_types/models.py
View file

@ -51,12 +51,6 @@ class MediaType(object):
raise InvalidMediaTypeValue(exc)
try:
unmarshalled = self.schema.unmarshal(value, custom_formatters=custom_formatters)
except OpenAPISchemaError as exc:
raise InvalidMediaTypeValue(exc)
try:
return self.schema.obj_validate(
unmarshalled, custom_formatters=custom_formatters)
return self.schema.unmarshal(value, custom_formatters=custom_formatters)
except OpenAPISchemaError as exc:
raise InvalidMediaTypeValue(exc)

8
openapi_core/schema/parameters/models.py
View file

@ -123,16 +123,10 @@ class Parameter(object):
raise InvalidParameterValue(self.name, exc)
try:
unmarshalled = self.schema.unmarshal(
return self.schema.unmarshal(
value,
custom_formatters=custom_formatters,
strict=True,
)
except OpenAPISchemaError as exc:
raise InvalidParameterValue(self.name, exc)
try:
return self.schema.obj_validate(
unmarshalled, custom_formatters=custom_formatters)
except OpenAPISchemaError as exc:
raise InvalidParameterValue(self.name, exc)

106
openapi_core/schema/schemas/_format.py
View file

@ -1,9 +1,105 @@
from jsonschema._format import FormatChecker
from six import binary_type
from base64 import b64encode, b64decode
import binascii
from datetime import datetime
from uuid import UUID
oas30_format_checker = FormatChecker()
from jsonschema._format import FormatChecker
from jsonschema.exceptions import FormatError
from six import binary_type, text_type, integer_types
class StrictFormatChecker(FormatChecker):
def check(self, instance, format):
if format not in self.checkers:
raise FormatError(
"Format checker for %r format not found" % (format, ))
return super(StrictFormatChecker, self).check(
instance, format)
oas30_format_checker = StrictFormatChecker()
@oas30_format_checker.checks('int32')
def is_int32(instance):
return isinstance(instance, integer_types)
@oas30_format_checker.checks('int64')
def is_int64(instance):
return isinstance(instance, integer_types)
@oas30_format_checker.checks('float')
def is_float(instance):
return isinstance(instance, float)
@oas30_format_checker.checks('double')
def is_double(instance):
# float has double precision in Python
# It's double in CPython and Jython
return isinstance(instance, float)
@oas30_format_checker.checks('binary')
def binary(value):
return isinstance(value, binary_type)
def is_binary(instance):
return isinstance(instance, binary_type)
@oas30_format_checker.checks('byte', raises=(binascii.Error, TypeError))
def is_byte(instance):
if isinstance(instance, text_type):
instance = instance.encode()
return b64encode(b64decode(instance)) == instance
try:
import strict_rfc3339
except ImportError:
try:
import isodate
except ImportError:
pass
else:
@oas30_format_checker.checks(
"date-time", raises=(ValueError, isodate.ISO8601Error))
def is_datetime(instance):
if isinstance(instance, binary_type):
return False
if not isinstance(instance, text_type):
return True
return isodate.parse_datetime(instance)
else:
@oas30_format_checker.checks("date-time")
def is_datetime(instance):
if isinstance(instance, binary_type):
return False
if not isinstance(instance, text_type):
return True
return strict_rfc3339.validate_rfc3339(instance)
@oas30_format_checker.checks("date", raises=ValueError)
def is_date(instance):
if isinstance(instance, binary_type):
return False
if not isinstance(instance, text_type):
return True
return datetime.strptime(instance, "%Y-%m-%d")
@oas30_format_checker.checks("uuid", raises=AttributeError)
def is_uuid(instance):
if isinstance(instance, binary_type):
return False
if not isinstance(instance, text_type):
return True
try:
uuid_obj = UUID(instance)
except ValueError:
return False
return text_type(uuid_obj) == instance

33
openapi_core/schema/schemas/_validators.py
View file

@ -1,4 +1,5 @@
from jsonschema.exceptions import ValidationError
from jsonschema._utils import find_additional_properties, extras_msg
from jsonschema.exceptions import ValidationError, FormatError
def type(validator, data_type, instance, schema):
@ -9,6 +10,17 @@ def type(validator, data_type, instance, schema):
yield ValidationError("%r is not of type %s" % (instance, data_type))
def format(validator, format, instance, schema):
if instance is None:
return
if validator.format_checker is not None:
try:
validator.format_checker.check(instance, format)
except FormatError as error:
yield ValidationError(error.message, cause=error.cause)
def items(validator, items, instance, schema):
if not validator.is_type(instance, "array"):
return
@ -23,5 +35,24 @@ def nullable(validator, is_nullable, instance, schema):
yield ValidationError("None for not nullable")
def additionalProperties(validator, aP, instance, schema):
if not validator.is_type(instance, "object"):
return
extras = set(find_additional_properties(instance, schema))
if not extras:
return
if validator.is_type(aP, "object"):
for extra in extras:
for error in validator.descend(instance[extra], aP, path=extra):
yield error
elif validator.is_type(aP, "boolean"):
if not aP:
error = "Additional properties are not allowed (%s %s unexpected)"
yield ValidationError(error % extras_msg(extras))
def not_implemented(validator, value, instance, schema):
pass

59
openapi_core/schema/schemas/factories.py
View file

@ -1,9 +1,12 @@
"""OpenAPI core schemas factories module"""
import logging
from six import iteritems
from openapi_core.compat import lru_cache
from openapi_core.schema.properties.generators import PropertiesGenerator
from openapi_core.schema.schemas.models import Schema
from openapi_core.schema.schemas.types import Contribution
log = logging.getLogger(__name__)
@ -86,3 +89,59 @@ class SchemaFactory(object):
def _create_items(self, items_spec):
return self.create(items_spec)
class SchemaDictFactory(object):
contributions = (
Contribution('type', src_prop_attr='value'),
Contribution('format'),
Contribution('properties', is_dict=True, dest_default={}),
Contribution('required', dest_default=[]),
Contribution('default'),
Contribution('nullable', dest_default=False),
Contribution('all_of', dest_prop_name='allOf', is_list=True, dest_default=[]),
Contribution('one_of', dest_prop_name='oneOf', is_list=True, dest_default=[]),
Contribution('additional_properties', dest_prop_name='additionalProperties', dest_default=True),
Contribution('min_items', dest_prop_name='minItems'),
Contribution('max_items', dest_prop_name='maxItems'),
Contribution('min_length', dest_prop_name='minLength'),
Contribution('max_length', dest_prop_name='maxLength'),
Contribution('pattern', src_prop_attr='pattern'),
Contribution('unique_items', dest_prop_name='uniqueItems', dest_default=False),
Contribution('minimum'),
Contribution('maximum'),
Contribution('multiple_of', dest_prop_name='multipleOf'),
Contribution('exclusive_minimum', dest_prop_name='exclusiveMinimum', dest_default=False),
Contribution('exclusive_maximum', dest_prop_name='exclusiveMaximum', dest_default=False),
Contribution('min_properties', dest_prop_name='minProperties'),
Contribution('max_properties', dest_prop_name='maxProperties'),
)
def create(self, schema):
schema_dict = {}
for contrib in self.contributions:
self._contribute(schema, schema_dict, contrib)
return schema_dict
def _contribute(self, schema, schema_dict, contrib):
def src_map(x):
return getattr(x, '__dict__')
src_val = getattr(schema, contrib.src_prop_name)
if src_val and contrib.src_prop_attr:
src_val = getattr(src_val, contrib.src_prop_attr)
if contrib.is_list:
src_val = list(map(src_map, src_val))
if contrib.is_dict:
src_val = dict(
(k, src_map(v))
for k, v in iteritems(src_val)
)
if src_val == contrib.dest_default:
return
dest_prop_name = contrib.dest_prop_name or contrib.src_prop_name
schema_dict[dest_prop_name] = src_val

242
openapi_core/schema/schemas/models.py
View file

@ -123,6 +123,14 @@ class Schema(object):
self._source = _source
@property
def __dict__(self):
return self._source or self.to_dict()
def to_dict(self):
from openapi_core.schema.schemas.factories import SchemaDictFactory
return SchemaDictFactory().create(self)
def __getitem__(self, name):
return self.properties[name]
@ -220,7 +228,7 @@ class Schema(object):
def get_validator(self, resolver=None):
return OAS30Validator(
self._source, resolver=resolver, format_checker=oas30_format_checker)
self.__dict__, resolver=resolver, format_checker=oas30_format_checker)
def validate(self, value, resolver=None):
validator = self.get_validator(resolver=resolver)
@ -396,236 +404,4 @@ class Schema(object):
except OpenAPISchemaError as exc:
raise InvalidSchemaProperty(prop_name, exc)
self._validate_properties(properties, one_of_schema=one_of_schema,
custom_formatters=custom_formatters)
return properties
def get_validator_mapping(self):
mapping = {
SchemaType.ARRAY: self._validate_collection,
SchemaType.STRING: self._validate_string,
SchemaType.OBJECT: self._validate_object,
SchemaType.INTEGER: self._validate_number,
SchemaType.NUMBER: self._validate_number,
}
def default(x, **kw):
return x
return defaultdict(lambda: default, mapping)
def obj_validate(self, value, custom_formatters=None):
if value is None:
if not self.nullable:
raise InvalidSchemaValue("Null value for non-nullable schema of type {type}", value, self.type)
return
# type validation
type_validator_callable = self.TYPE_VALIDATOR_CALLABLE_GETTER[
self.type]
if not type_validator_callable(value):
raise InvalidSchemaValue(
"Value {value} not valid type {type}", value, self.type.value)
# structure validation
validator_mapping = self.get_validator_mapping()
validator_callable = validator_mapping[self.type]
validator_callable(value, custom_formatters=custom_formatters)
return value
def _validate_collection(self, value, custom_formatters=None):
if self.items is None:
raise UndefinedItemsSchema(self.type)
if self.min_items is not None:
if self.min_items < 0:
raise OpenAPISchemaError(
"Schema for collection invalid:"
" minItems must be non-negative"
)
if len(value) < self.min_items:
raise InvalidSchemaValue(
"Value must contain at least {type} item(s),"
" {value} found", len(value), self.min_items)
if self.max_items is not None:
if self.max_items < 0:
raise OpenAPISchemaError(
"Schema for collection invalid:"
" maxItems must be non-negative"
)
if len(value) > self.max_items:
raise InvalidSchemaValue(
"Value must contain at most {value} item(s),"
" {type} found", len(value), self.max_items)
if self.unique_items and len(set(value)) != len(value):
raise OpenAPISchemaError("Value may not contain duplicate items")
f = functools.partial(self.items.obj_validate,
custom_formatters=custom_formatters)
return list(map(f, value))
def _validate_number(self, value, custom_formatters=None):
if self.minimum is not None:
if self.exclusive_minimum and value <= self.minimum:
raise InvalidSchemaValue(
"Value {value} is not less than or equal to {type}", value, self.minimum)
elif value < self.minimum:
raise InvalidSchemaValue(
"Value {value} is not less than {type}", value, self.minimum)
if self.maximum is not None:
if self.exclusive_maximum and value >= self.maximum:
raise InvalidSchemaValue(
"Value {value} is not greater than or equal to {type}", value, self.maximum)
elif value > self.maximum:
raise InvalidSchemaValue(
"Value {value} is not greater than {type}", value, self.maximum)
if self.multiple_of is not None and value % self.multiple_of:
raise InvalidSchemaValue(
"Value {value} is not a multiple of {type}",
value, self.multiple_of)
def _validate_string(self, value, custom_formatters=None):
try:
schema_format = SchemaFormat(self.format)
except ValueError:
msg = "Unsupported {0} format validation".format(self.format)
if custom_formatters is not None:
formatstring = custom_formatters.get(self.format)
if formatstring is None:
raise OpenAPISchemaError(msg)
else:
raise OpenAPISchemaError(msg)
else:
formatstring =\
self.STRING_FORMAT_CALLABLE_GETTER[schema_format]
if not formatstring.validate(value):
raise InvalidSchemaValue(
"Value {value} not valid format {type}", value, self.format)
if self.min_length is not None:
if self.min_length < 0:
raise OpenAPISchemaError(
"Schema for string invalid:"
" minLength must be non-negative"
)
if len(value) < self.min_length:
raise InvalidSchemaValue(
"Value is shorter ({value}) than the minimum length of {type}",
len(value), self.min_length
)
if self.max_length is not None:
if self.max_length < 0:
raise OpenAPISchemaError(
"Schema for string invalid:"
" maxLength must be non-negative"
)
if len(value) > self.max_length:
raise InvalidSchemaValue(
"Value is longer ({value}) than the maximum length of {type}",
len(value), self.max_length
)
if self.pattern is not None and not self.pattern.search(value):
raise InvalidSchemaValue(
"Value {value} does not match the pattern {type}",
value, self.pattern.pattern
)
return True
def _validate_object(self, value, custom_formatters=None):
properties = value.__dict__
if self.one_of:
valid_one_of_schema = None
for one_of_schema in self.one_of:
try:
self._validate_properties(
properties, one_of_schema,
custom_formatters=custom_formatters)
except OpenAPISchemaError:
pass
else:
if valid_one_of_schema is not None:
raise MultipleOneOfSchema(self.type)
valid_one_of_schema = True
if valid_one_of_schema is None:
raise NoOneOfSchema(self.type)
else:
self._validate_properties(properties,
custom_formatters=custom_formatters)
if self.min_properties is not None:
if self.min_properties < 0:
raise OpenAPISchemaError(
"Schema for object invalid:"
" minProperties must be non-negative"
)
if len(properties) < self.min_properties:
raise InvalidSchemaValue(
"Value must contain at least {type} properties,"
" {value} found", len(properties), self.min_properties
)
if self.max_properties is not None:
if self.max_properties < 0:
raise OpenAPISchemaError(
"Schema for object invalid:"
" maxProperties must be non-negative"
)
if len(properties) > self.max_properties:
raise InvalidSchemaValue(
"Value must contain at most {type} properties,"
" {value} found", len(properties), self.max_properties
)
return True
def _validate_properties(self, value, one_of_schema=None,
custom_formatters=None):
all_props = self.get_all_properties()
all_props_names = self.get_all_properties_names()
all_req_props_names = self.get_all_required_properties_names()
if one_of_schema is not None:
all_props.update(one_of_schema.get_all_properties())
all_props_names |= one_of_schema.\
get_all_properties_names()
all_req_props_names |= one_of_schema.\
get_all_required_properties_names()
value_props_names = value.keys()
extra_props = set(value_props_names) - set(all_props_names)
extra_props_allowed = self.are_additional_properties_allowed(
one_of_schema)
if extra_props and not extra_props_allowed:
raise UndefinedSchemaProperty(extra_props)
if self.additional_properties is not True:
for prop_name in extra_props:
prop_value = value[prop_name]
self.additional_properties.obj_validate(
prop_value, custom_formatters=custom_formatters)
for prop_name, prop in iteritems(all_props):
try:
prop_value = value[prop_name]
except KeyError:
if prop_name in all_req_props_names:
raise MissingSchemaProperty(prop_name)
if not prop.nullable and not prop.default:
continue
prop_value = prop.default
try:
prop.obj_validate(prop_value, custom_formatters=custom_formatters)
except OpenAPISchemaError as exc:
raise InvalidSchemaProperty(prop_name, original_exception=exc)
return True

11
openapi_core/schema/schemas/types.py Normal file
View file

@ -0,0 +1,11 @@
import attr
@attr.s(hash=True)
class Contribution(object):
src_prop_name = attr.ib()
src_prop_attr = attr.ib(default=None)
dest_prop_name = attr.ib(default=None)
is_list = attr.ib(default=False)
is_dict = attr.ib(default=False)
dest_default = attr.ib(default=None)

25
openapi_core/schema/schemas/validators.py
View file

@ -33,14 +33,14 @@ class AttributeValidator(object):
return True
OAS30Validator = create(
BaseOAS30Validator = create(
meta_schema=_utils.load_schema("draft4"),
validators={
u"multipleOf": _validators.multipleOf,
# exclusiveMaximum supported inside maximum_draft3_draft4
u"maximum": _legacy_validators.maximum_draft3_draft4,
u"exclusiveMaximum": _validators.exclusiveMaximum,
# exclusiveMinimum supported inside minimum_draft3_draft4
u"minimum": _legacy_validators.minimum_draft3_draft4,
u"exclusiveMinimum": _validators.exclusiveMinimum,
u"maxLength": _validators.maxLength,
u"minLength": _validators.minLength,
u"pattern": _validators.pattern,
@ -59,9 +59,9 @@ OAS30Validator = create(
u"not": _validators.not_,
u"items": oas_validators.items,
u"properties": _validators.properties,
u"additionalProperties": _validators.additionalProperties,
u"additionalProperties": oas_validators.additionalProperties,
# TODO: adjust description
u"format": _validators.format,
u"format": oas_validators.format,
# TODO: adjust default
u"$ref": _validators.ref,
# fixed OAS fields
@ -78,3 +78,18 @@ OAS30Validator = create(
version="oas30",
id_of=lambda schema: schema.get(u"id", ""),
)
class OAS30Validator(BaseOAS30Validator):
def iter_errors(self, instance, _schema=None):
if _schema is None:
_schema = self.schema
# append defaults to trigger validator (i.e. nullable)
if 'nullable' not in _schema:
_schema.update({
'nullable': False,
})
return super(OAS30Validator, self).iter_errors(instance, _schema)

349
tests/unit/schema/test_schemas.py
View file

@ -8,7 +8,6 @@ from openapi_core.extensions.models.models import Model
from openapi_core.schema.schemas.enums import SchemaFormat, SchemaType
from openapi_core.schema.schemas.exceptions import (
InvalidSchemaValue, MultipleOneOfSchema, NoOneOfSchema, OpenAPISchemaError,
UndefinedSchemaProperty
)
from openapi_core.schema.schemas.models import Schema
@ -347,7 +346,7 @@ class TestSchemaUnmarshal(object):
assert schema.unmarshal('string') == 'string'
class TestSchemaObjValidate(object):
class TestSchemaValidate(object):
@pytest.mark.parametrize('schema_type', [
'boolean', 'array', 'integer', 'number', 'string',
@ -357,7 +356,7 @@ class TestSchemaObjValidate(object):
value = None
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('schema_type', [
'boolean', 'array', 'integer', 'number', 'string',
@ -366,219 +365,221 @@ class TestSchemaObjValidate(object):
schema = Schema(schema_type, nullable=True)
value = None
result = schema.obj_validate(value)
result = schema.validate(value)
assert result is None
@pytest.mark.xfail(
reason="validation does not care about custom formats atm")
def test_string_format_custom_missing(self):
custom_format = 'custom'
schema = Schema('string', schema_format=custom_format)
value = 'x'
with pytest.raises(OpenAPISchemaError):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [False, True])
def test_boolean(self, value):
schema = Schema('boolean')
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [1, 3.14, u('true'), [True, False]])
def test_boolean_invalid(self, value):
schema = Schema('boolean')
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [[1, 2], (3, 4)])
@pytest.mark.parametrize('value', [(1, 2)])
def test_array_no_schema(self, value):
schema = Schema('array')
with pytest.raises(OpenAPISchemaError):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [[1, 2], (3, 4)])
@pytest.mark.parametrize('value', [[1, 2]])
def test_array(self, value):
schema = Schema('array', items=Schema('integer'))
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [False, 1, 3.14, u('true')])
@pytest.mark.parametrize('value', [False, 1, 3.14, u('true'), (3, 4)])
def test_array_invalid(self, value):
schema = Schema('array')
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [1, 3])
def test_integer(self, value):
schema = Schema('integer')
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [False, 3.14, u('true'), [1, 2]])
def test_integer_invalid(self, value):
schema = Schema('integer')
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [0, 1, 2])
def test_integer_minimum_invalid(self, value):
schema = Schema('integer', minimum=3)
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [4, 5, 6])
def test_integer_minimum(self, value):
schema = Schema('integer', minimum=3)
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [4, 5, 6])
def test_integer_maximum_invalid(self, value):
schema = Schema('integer', maximum=3)
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [0, 1, 2])
def test_integer_maximum(self, value):
schema = Schema('integer', maximum=3)
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [1, 2, 4])
def test_integer_multiple_of_invalid(self, value):
schema = Schema('integer', multiple_of=3)
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [3, 6, 18])
def test_integer_multiple_of(self, value):
schema = Schema('integer', multiple_of=3)
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [1, 3.14])
def test_number(self, value):
schema = Schema('number')
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [False, 'true', [1, 3]])
def test_number_invalid(self, value):
schema = Schema('number')
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [0, 1, 2])
def test_number_minimum_invalid(self, value):
schema = Schema('number', minimum=3)
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [3, 4, 5])
def test_number_minimum(self, value):
schema = Schema('number', minimum=3)
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [1, 2, 3])
def test_number_exclusive_minimum_invalid(self, value):
schema = Schema('number', minimum=3, exclusive_minimum=3)
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [4, 5, 6])
def test_number_exclusive_minimum(self, value):
schema = Schema('number', minimum=3)
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [4, 5, 6])
def test_number_maximum_invalid(self, value):
schema = Schema('number', maximum=3)
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [1, 2, 3])
def test_number_maximum(self, value):
schema = Schema('number', maximum=3)
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [3, 4, 5])
def test_number_exclusive_maximum_invalid(self, value):
schema = Schema('number', maximum=3, exclusive_maximum=True)
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [0, 1, 2])
def test_number_exclusive_maximum(self, value):
schema = Schema('number', maximum=3, exclusive_maximum=True)
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [1, 2, 4])
def test_number_multiple_of_invalid(self, value):
schema = Schema('number', multiple_of=3)
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [3, 6, 18])
def test_number_multiple_of(self, value):
schema = Schema('number', multiple_of=3)
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [u('true'), ])
@pytest.mark.parametrize('value', [u('true'), b('test')])
def test_string(self, value):
schema = Schema('string')
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [b('test'), False, 1, 3.14, [1, 3]])
@pytest.mark.parametrize('value', [False, 1, 3.14, [1, 3]])
def test_string_invalid(self, value):
schema = Schema('string')
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [
b('true'), u('test'), False, 1, 3.14, [1, 3],
@ -588,27 +589,27 @@ class TestSchemaObjValidate(object):
schema = Schema('string', schema_format='date')
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [
datetime.date(1989, 1, 2), datetime.date(2018, 1, 2),
u('1989-01-02'), u('2018-01-02'),
])
def test_string_format_date(self, value):
schema = Schema('string', schema_format='date')
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [
uuid.UUID('{12345678-1234-5678-1234-567812345678}'),
u('12345678-1234-5678-1234-567812345678'),
])
def test_string_format_uuid(self, value):
schema = Schema('string', schema_format='uuid')
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [
b('true'), u('true'), False, 1, 3.14, [1, 3],
@ -618,38 +619,38 @@ class TestSchemaObjValidate(object):
schema = Schema('string', schema_format='uuid')
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [
b('true'), u('true'), False, 1, 3.14, [1, 3],
datetime.date(1989, 1, 2),
u('1989-01-02'),
])
def test_string_format_datetime_invalid(self, value):
schema = Schema('string', schema_format='date-time')
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [
datetime.datetime(1989, 1, 2, 0, 0, 0),
datetime.datetime(2018, 1, 2, 23, 59, 59),
u('1989-01-02T00:00:00Z'),
u('2018-01-02T23:59:59Z'),
])
def test_string_format_datetime(self, value):
schema = Schema('string', schema_format='date-time')
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [
u('true'), False, 1, 3.14, [1, 3], datetime.date(1989, 1, 2),
datetime.datetime(1989, 1, 2, 0, 0, 0),
u('true'), False, 1, 3.14, [1, 3], u('1989-01-02'),
u('1989-01-02T00:00:00Z'),
])
def test_string_format_binary_invalid(self, value):
schema = Schema('string', schema_format='binary')
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [
b('stream'), b('text'),
@ -657,28 +658,28 @@ class TestSchemaObjValidate(object):
def test_string_format_binary(self, value):
schema = Schema('string', schema_format='binary')
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [
b('tsssst'), b('dGVzdA=='),
b('dGVzdA=='), u('dGVzdA=='),
])
def test_string_format_byte(self, value):
schema = Schema('string', schema_format='byte')
result = schema.validate(value)
assert result is None
@pytest.mark.parametrize('value', [
u('tsssst'), b('tsssst'), b('tesddddsdsdst'),
])
def test_string_format_byte_invalid(self, value):
schema = Schema('string', schema_format='byte')
with pytest.raises(OpenAPISchemaError):
schema.obj_validate(value)
@pytest.mark.parametrize('value', [
u('tsssst'), u('dGVzdA=='),
])
def test_string_format_byte(self, value):
schema = Schema('string', schema_format='byte')
result = schema.obj_validate(value)
assert result == value
schema.validate(value)
@pytest.mark.parametrize('value', [
u('test'), b('stream'), datetime.date(1989, 1, 2),
@ -689,73 +690,66 @@ class TestSchemaObjValidate(object):
schema = Schema('string', schema_format=unknown_format)
with pytest.raises(OpenAPISchemaError):
schema.obj_validate(value)
@pytest.mark.parametrize('value', [u(""), ])
def test_string_min_length_invalid_schema(self, value):
schema = Schema('string', min_length=-1)
with pytest.raises(OpenAPISchemaError):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [u(""), u("a"), u("ab")])
def test_string_min_length_invalid(self, value):
schema = Schema('string', min_length=3)
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [u("abc"), u("abcd")])
def test_string_min_length(self, value):
schema = Schema('string', min_length=3)
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [u(""), ])
def test_string_max_length_invalid_schema(self, value):
schema = Schema('string', max_length=-1)
with pytest.raises(OpenAPISchemaError):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [u("ab"), u("abc")])
def test_string_max_length_invalid(self, value):
schema = Schema('string', max_length=1)
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [u(""), u("a")])
def test_string_max_length(self, value):
schema = Schema('string', max_length=1)
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [u("foo"), u("bar")])
def test_string_pattern_invalid(self, value):
schema = Schema('string', pattern='baz')
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [u("bar"), u("foobar")])
def test_string_pattern(self, value):
schema = Schema('string', pattern='bar')
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', ['true', False, 1, 3.14, [1, 3]])
def test_object_not_an_object(self, value):
schema = Schema('object')
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [Model(), ])
def test_object_multiple_one_of(self, value):
@ -764,20 +758,20 @@ class TestSchemaObjValidate(object):
]
schema = Schema('object', one_of=one_of)
with pytest.raises(MultipleOneOfSchema):
schema.obj_validate(value)
with pytest.raises(InvalidSchemaValue):
schema.validate(value)
@pytest.mark.parametrize('value', [Model(), ])
@pytest.mark.parametrize('value', [{}, ])
def test_object_defferent_type_one_of(self, value):
one_of = [
Schema('integer'), Schema('string'),
]
schema = Schema('object', one_of=one_of)
with pytest.raises(MultipleOneOfSchema):
schema.obj_validate(value)
with pytest.raises(InvalidSchemaValue):
schema.validate(value)
@pytest.mark.parametrize('value', [Model(), ])
@pytest.mark.parametrize('value', [{}, ])
def test_object_no_one_of(self, value):
one_of = [
Schema(
@ -793,17 +787,17 @@ class TestSchemaObjValidate(object):
]
schema = Schema('object', one_of=one_of)
with pytest.raises(NoOneOfSchema):
schema.obj_validate(value)
with pytest.raises(InvalidSchemaValue):
schema.validate(value)
@pytest.mark.parametrize('value', [
Model({
{
'foo': u("FOO"),
}),
Model({
},
{
'foo': u("FOO"),
'bar': u("BAR"),
}),
},
])
def test_unambiguous_one_of(self, value):
one_of = [
@ -827,27 +821,30 @@ class TestSchemaObjValidate(object):
]
schema = Schema('object', one_of=one_of)
schema.obj_validate(value)
result = schema.validate(value)
@pytest.mark.parametrize('value', [Model(), ])
assert result is None
@pytest.mark.parametrize('value', [{}, ])
def test_object_default_property(self, value):
schema = Schema('object', default='value1')
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [Model(), ])
def test_object_min_properties_invalid_schema(self, value):
schema = Schema('object', min_properties=-1)
with pytest.raises(OpenAPISchemaError):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [
Model({'a': 1}),
Model({'a': 1, 'b': 2}),
Model({'a': 1, 'b': 2, 'c': 3})])
{'a': 1},
{'a': 1, 'b': 2},
{'a': 1, 'b': 2, 'c': 3},
])
def test_object_min_properties_invalid(self, value):
schema = Schema(
'object',
@ -857,12 +854,13 @@ class TestSchemaObjValidate(object):
)
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [
Model({'a': 1}),
Model({'a': 1, 'b': 2}),
Model({'a': 1, 'b': 2, 'c': 3})])
{'a': 1},
{'a': 1, 'b': 2},
{'a': 1, 'b': 2, 'c': 3},
])
def test_object_min_properties(self, value):
schema = Schema(
'object',
@ -871,21 +869,22 @@ class TestSchemaObjValidate(object):
min_properties=1,
)
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [Model(), ])
def test_object_max_properties_invalid_schema(self, value):
schema = Schema('object', max_properties=-1)
with pytest.raises(OpenAPISchemaError):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [
Model({'a': 1}),
Model({'a': 1, 'b': 2}),
Model({'a': 1, 'b': 2, 'c': 3})])
{'a': 1},
{'a': 1, 'b': 2},
{'a': 1, 'b': 2, 'c': 3},
])
def test_object_max_properties_invalid(self, value):
schema = Schema(
'object',
@ -895,12 +894,13 @@ class TestSchemaObjValidate(object):
)
with pytest.raises(InvalidSchemaValue):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [
Model({'a': 1}),
Model({'a': 1, 'b': 2}),
Model({'a': 1, 'b': 2, 'c': 3})])
{'a': 1},
{'a': 1, 'b': 2},
{'a': 1, 'b': 2, 'c': 3},
])
def test_object_max_properties(self, value):
schema = Schema(
'object',
@ -909,40 +909,33 @@ class TestSchemaObjValidate(object):
max_properties=3,
)
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [Model({'additional': 1}), ])
@pytest.mark.parametrize('value', [{'additional': 1}, ])
def test_object_additional_propetries(self, value):
schema = Schema('object')
schema.obj_validate(value)
result = schema.validate(value)
@pytest.mark.parametrize('value', [Model({'additional': 1}), ])
assert result is None
@pytest.mark.parametrize('value', [{'additional': 1}, ])
def test_object_additional_propetries_false(self, value):
schema = Schema('object', additional_properties=False)
with pytest.raises(UndefinedSchemaProperty):
schema.obj_validate(value)
with pytest.raises(InvalidSchemaValue):
schema.validate(value)
@pytest.mark.parametrize('value', [Model({'additional': 1}), ])
@pytest.mark.parametrize('value', [{'additional': 1}, ])
def test_object_additional_propetries_object(self, value):
additional_properties = Schema('integer')
schema = Schema('object', additional_properties=additional_properties)
schema.obj_validate(value)
result = schema.validate(value)
@pytest.mark.parametrize('value', [[], ])
def test_list_min_items_invalid_schema(self, value):
schema = Schema(
'array',
items=Schema('number'),
min_items=-1,
)
with pytest.raises(OpenAPISchemaError):
schema.obj_validate(value)
assert result is None
@pytest.mark.parametrize('value', [[], [1], [1, 2]])
def test_list_min_items_invalid(self, value):
@ -953,7 +946,7 @@ class TestSchemaObjValidate(object):
)
with pytest.raises(Exception):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [[], [1], [1, 2]])
def test_list_min_items(self, value):
@ -963,9 +956,9 @@ class TestSchemaObjValidate(object):
min_items=0,
)
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [[], ])
def test_list_max_items_invalid_schema(self, value):
@ -976,7 +969,7 @@ class TestSchemaObjValidate(object):
)
with pytest.raises(OpenAPISchemaError):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [[1, 2], [2, 3, 4]])
def test_list_max_items_invalid(self, value):
@ -987,7 +980,7 @@ class TestSchemaObjValidate(object):
)
with pytest.raises(Exception):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [[1, 2, 1], [2, 2]])
def test_list_unique_items_invalid(self, value):
@ -998,19 +991,19 @@ class TestSchemaObjValidate(object):
)
with pytest.raises(Exception):
schema.obj_validate(value)
schema.validate(value)
@pytest.mark.parametrize('value', [
Model({
{
'someint': 123,
}),
Model({
},
{
'somestr': u('content'),
}),
Model({
},
{
'somestr': u('content'),
'someint': 123,
}),
},
])
def test_object_with_properties(self, value):
schema = Schema(
@ -1021,34 +1014,30 @@ class TestSchemaObjValidate(object):
},
)
result = schema.obj_validate(value)
result = schema.validate(value)
assert result == value
assert result is None
@pytest.mark.parametrize('value', [
Model({
'somestr': Model(),
'someint': 123,
}),
Model({
{
'somestr': {},
'someint': 123,
}),
Model({
},
{
'somestr': [
'content1', 'content2'
],
'someint': 123,
}),
Model({
},
{
'somestr': 123,
'someint': 123,
}),
Model({
},
{
'somestr': 'content',
'someint': 123,
'not_in_scheme_prop': 123,
}),
},
])
def test_object_with_invalid_properties(self, value):
schema = Schema(
@ -1061,4 +1050,4 @@ class TestSchemaObjValidate(object):
)
with pytest.raises(Exception):
schema.obj_validate(value)
schema.validate(value)