mirror of
https://github.com/correl/openapi-core.git
synced 2024-11-28 11:09:52 +00:00
1065 lines
30 KiB
Python
1065 lines
30 KiB
Python
import datetime
|
|
import uuid
|
|
|
|
import mock
|
|
import pytest
|
|
|
|
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, OpenAPISchemaError,
|
|
)
|
|
from openapi_core.schema.schemas.models import Schema
|
|
from openapi_core.schema.schemas.types import NoValue
|
|
from openapi_core.unmarshalling.schemas.exceptions import (
|
|
InvalidCustomFormatSchemaValue,
|
|
FormatterNotFoundError,
|
|
UnmarshalError,
|
|
UnmarshallerStrictTypeError,
|
|
)
|
|
|
|
from six import b, u
|
|
|
|
|
|
class TestSchemaIteritems(object):
|
|
|
|
@pytest.fixture
|
|
def schema(self):
|
|
properties = {
|
|
'application/json': mock.sentinel.application_json,
|
|
'text/csv': mock.sentinel.text_csv,
|
|
}
|
|
return Schema('object', properties=properties)
|
|
|
|
@property
|
|
def test_valid(self, schema):
|
|
for name in schema.properties:
|
|
assert schema[name] == schema.properties[name]
|
|
|
|
|
|
class TestSchemaUnmarshal(object):
|
|
|
|
def test_deprecated(self):
|
|
schema = Schema('string', deprecated=True)
|
|
value = 'test'
|
|
|
|
with pytest.warns(DeprecationWarning):
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == value
|
|
|
|
@pytest.mark.parametrize('schema_type', [
|
|
'boolean', 'array', 'integer', 'number',
|
|
])
|
|
def test_non_string_empty_value(self, schema_type):
|
|
schema = Schema(schema_type)
|
|
value = ''
|
|
|
|
with pytest.raises(UnmarshallerStrictTypeError):
|
|
schema.unmarshal(value)
|
|
|
|
def test_string_valid(self):
|
|
schema = Schema('string')
|
|
value = 'test'
|
|
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == value
|
|
|
|
def test_string_format_uuid_valid(self):
|
|
schema = Schema(SchemaType.STRING, schema_format=SchemaFormat.UUID)
|
|
value = str(uuid.uuid4())
|
|
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == uuid.UUID(value)
|
|
|
|
def test_string_format_uuid_uuid_quirks_valid(self):
|
|
schema = Schema(SchemaType.STRING, schema_format=SchemaFormat.UUID)
|
|
value = uuid.uuid4()
|
|
|
|
result = schema.unmarshal(value, strict=False)
|
|
|
|
assert result == value
|
|
|
|
def test_string_format_password(self):
|
|
schema = Schema(SchemaType.STRING, schema_format=SchemaFormat.PASSWORD)
|
|
value = 'password'
|
|
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == 'password'
|
|
|
|
def test_string_float_invalid(self):
|
|
schema = Schema('string')
|
|
value = 1.23
|
|
|
|
with pytest.raises(UnmarshallerStrictTypeError):
|
|
schema.unmarshal(value)
|
|
|
|
def test_string_default(self):
|
|
default_value = 'default'
|
|
schema = Schema('string', default=default_value)
|
|
value = NoValue
|
|
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == default_value
|
|
|
|
@pytest.mark.parametrize('default_value', ['default', None])
|
|
def test_string_default_nullable(self, default_value):
|
|
schema = Schema('string', default=default_value, nullable=True)
|
|
value = NoValue
|
|
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == default_value
|
|
|
|
def test_string_format_date(self):
|
|
schema = Schema('string', schema_format='date')
|
|
value = '2018-01-02'
|
|
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == datetime.date(2018, 1, 2)
|
|
|
|
def test_string_format_datetime(self):
|
|
schema = Schema('string', schema_format='date-time')
|
|
value = '2018-01-02T00:00:00Z'
|
|
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == datetime.datetime(2018, 1, 2, 0, 0)
|
|
|
|
def test_string_format_custom(self):
|
|
def custom_formatter(value):
|
|
return 'x-custom'
|
|
custom_format = 'custom'
|
|
schema = Schema('string', schema_format=custom_format)
|
|
value = 'x'
|
|
|
|
result = schema.unmarshal(
|
|
value, custom_formatters={custom_format: custom_formatter})
|
|
|
|
assert result == custom_formatter(value)
|
|
|
|
def test_string_format_custom_value_error(self):
|
|
def custom_formatter(value):
|
|
raise ValueError
|
|
custom_format = 'custom'
|
|
schema = Schema('string', schema_format=custom_format)
|
|
value = 'x'
|
|
|
|
with pytest.raises(InvalidCustomFormatSchemaValue):
|
|
schema.unmarshal(
|
|
value, custom_formatters={custom_format: custom_formatter})
|
|
|
|
def test_string_format_unknown(self):
|
|
unknown_format = 'unknown'
|
|
schema = Schema('string', schema_format=unknown_format)
|
|
value = 'x'
|
|
|
|
with pytest.raises(FormatterNotFoundError):
|
|
schema.unmarshal(value)
|
|
|
|
def test_string_format_invalid_value(self):
|
|
custom_format = 'custom'
|
|
schema = Schema('string', schema_format=custom_format)
|
|
value = 'x'
|
|
|
|
with pytest.raises(
|
|
FormatterNotFoundError,
|
|
message=(
|
|
'Formatter not found for custom format'
|
|
),
|
|
):
|
|
schema.unmarshal(value)
|
|
|
|
def test_integer_valid(self):
|
|
schema = Schema('integer')
|
|
value = 123
|
|
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == int(value)
|
|
|
|
def test_integer_string_invalid(self):
|
|
schema = Schema('integer')
|
|
value = '123'
|
|
|
|
with pytest.raises(UnmarshallerStrictTypeError):
|
|
schema.unmarshal(value)
|
|
|
|
def test_integer_enum_invalid(self):
|
|
schema = Schema('integer', enum=[1, 2, 3])
|
|
value = '123'
|
|
|
|
with pytest.raises(UnmarshalError):
|
|
schema.unmarshal(value)
|
|
|
|
def test_integer_enum(self):
|
|
schema = Schema('integer', enum=[1, 2, 3])
|
|
value = 2
|
|
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == int(value)
|
|
|
|
def test_integer_enum_string_invalid(self):
|
|
schema = Schema('integer', enum=[1, 2, 3])
|
|
value = '2'
|
|
|
|
with pytest.raises(UnmarshalError):
|
|
schema.unmarshal(value)
|
|
|
|
def test_integer_default(self):
|
|
default_value = 123
|
|
schema = Schema('integer', default=default_value)
|
|
value = NoValue
|
|
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == default_value
|
|
|
|
def test_integer_default_nullable(self):
|
|
default_value = 123
|
|
schema = Schema('integer', default=default_value, nullable=True)
|
|
value = None
|
|
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result is None
|
|
|
|
def test_integer_invalid(self):
|
|
schema = Schema('integer')
|
|
value = 'abc'
|
|
|
|
with pytest.raises(UnmarshallerStrictTypeError):
|
|
schema.unmarshal(value)
|
|
|
|
def test_array_valid(self):
|
|
schema = Schema('array', items=Schema('integer'))
|
|
value = [1, 2, 3]
|
|
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == value
|
|
|
|
def test_array_of_string_string_invalid(self):
|
|
schema = Schema('array', items=Schema('string'))
|
|
value = '123'
|
|
|
|
with pytest.raises(UnmarshallerStrictTypeError):
|
|
schema.unmarshal(value)
|
|
|
|
def test_array_of_integer_string_invalid(self):
|
|
schema = Schema('array', items=Schema('integer'))
|
|
value = '123'
|
|
|
|
with pytest.raises(UnmarshallerStrictTypeError):
|
|
schema.unmarshal(value)
|
|
|
|
def test_boolean_valid(self):
|
|
schema = Schema('boolean')
|
|
value = True
|
|
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == value
|
|
|
|
def test_boolean_string_invalid(self):
|
|
schema = Schema('boolean')
|
|
value = 'True'
|
|
|
|
with pytest.raises(UnmarshallerStrictTypeError):
|
|
schema.unmarshal(value)
|
|
|
|
def test_number_valid(self):
|
|
schema = Schema('number')
|
|
value = 1.23
|
|
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == value
|
|
|
|
def test_number_string_invalid(self):
|
|
schema = Schema('number')
|
|
value = '1.23'
|
|
|
|
with pytest.raises(UnmarshallerStrictTypeError):
|
|
schema.unmarshal(value)
|
|
|
|
def test_number_int(self):
|
|
schema = Schema('number')
|
|
value = 1
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == 1
|
|
assert type(result) == int
|
|
|
|
def test_number_float(self):
|
|
schema = Schema('number')
|
|
value = 1.2
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == 1.2
|
|
assert type(result) == float
|
|
|
|
def test_number_format_float(self):
|
|
schema = Schema('number', schema_format='float')
|
|
value = 1.2
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == 1.2
|
|
|
|
def test_number_format_double(self):
|
|
schema = Schema('number', schema_format='double')
|
|
value = 1.2
|
|
result = schema.unmarshal(value)
|
|
|
|
assert result == 1.2
|
|
|
|
def test_schema_any_one_of(self):
|
|
schema = Schema(one_of=[
|
|
Schema('string'),
|
|
Schema('array', items=Schema('string')),
|
|
])
|
|
assert schema.unmarshal(['hello']) == ['hello']
|
|
|
|
def test_schema_any(self):
|
|
schema = Schema()
|
|
assert schema.unmarshal('string') == 'string'
|
|
|
|
|
|
class TestSchemaValidate(object):
|
|
|
|
@pytest.mark.parametrize('schema_type', [
|
|
'boolean', 'array', 'integer', 'number', 'string',
|
|
])
|
|
def test_null(self, schema_type):
|
|
schema = Schema(schema_type)
|
|
value = None
|
|
|
|
with pytest.raises(InvalidSchemaValue):
|
|
schema.validate(value)
|
|
|
|
@pytest.mark.parametrize('schema_type', [
|
|
'boolean', 'array', 'integer', 'number', 'string',
|
|
])
|
|
def test_nullable(self, schema_type):
|
|
schema = Schema(schema_type, nullable=True)
|
|
value = None
|
|
|
|
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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [False, True])
|
|
def test_boolean(self, value):
|
|
schema = Schema('boolean')
|
|
|
|
result = schema.validate(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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [(1, 2)])
|
|
def test_array_no_schema(self, value):
|
|
schema = Schema('array')
|
|
|
|
with pytest.raises(OpenAPISchemaError):
|
|
schema.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [[1, 2]])
|
|
def test_array(self, value):
|
|
schema = Schema('array', items=Schema('integer'))
|
|
|
|
result = schema.validate(value)
|
|
|
|
assert result is None
|
|
|
|
@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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [1, 3])
|
|
def test_integer(self, value):
|
|
schema = Schema('integer')
|
|
|
|
result = schema.validate(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.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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [4, 5, 6])
|
|
def test_integer_minimum(self, value):
|
|
schema = Schema('integer', minimum=3)
|
|
|
|
result = schema.validate(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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [0, 1, 2])
|
|
def test_integer_maximum(self, value):
|
|
schema = Schema('integer', maximum=3)
|
|
|
|
result = schema.validate(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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [3, 6, 18])
|
|
def test_integer_multiple_of(self, value):
|
|
schema = Schema('integer', multiple_of=3)
|
|
|
|
result = schema.validate(value)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.parametrize('value', [1, 3.14])
|
|
def test_number(self, value):
|
|
schema = Schema('number')
|
|
|
|
result = schema.validate(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.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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [3, 4, 5])
|
|
def test_number_minimum(self, value):
|
|
schema = Schema('number', minimum=3)
|
|
|
|
result = schema.validate(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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [4, 5, 6])
|
|
def test_number_exclusive_minimum(self, value):
|
|
schema = Schema('number', minimum=3)
|
|
|
|
result = schema.validate(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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [1, 2, 3])
|
|
def test_number_maximum(self, value):
|
|
schema = Schema('number', maximum=3)
|
|
|
|
result = schema.validate(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.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.validate(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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [3, 6, 18])
|
|
def test_number_multiple_of(self, value):
|
|
schema = Schema('number', multiple_of=3)
|
|
|
|
result = schema.validate(value)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.parametrize('value', [u('true'), b('test')])
|
|
def test_string(self, value):
|
|
schema = Schema('string')
|
|
|
|
result = schema.validate(value)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.parametrize('value', [False, 1, 3.14, [1, 3]])
|
|
def test_string_invalid(self, value):
|
|
schema = Schema('string')
|
|
|
|
with pytest.raises(InvalidSchemaValue):
|
|
schema.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
b('true'), u('test'), False, 1, 3.14, [1, 3],
|
|
datetime.datetime(1989, 1, 2),
|
|
])
|
|
def test_string_format_date_invalid(self, value):
|
|
schema = Schema('string', schema_format='date')
|
|
|
|
with pytest.raises(InvalidSchemaValue):
|
|
schema.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
u('1989-01-02'), u('2018-01-02'),
|
|
])
|
|
def test_string_format_date(self, value):
|
|
schema = Schema('string', schema_format='date')
|
|
|
|
result = schema.validate(value)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
u('12345678-1234-5678-1234-567812345678'),
|
|
])
|
|
def test_string_format_uuid(self, value):
|
|
schema = Schema('string', schema_format='uuid')
|
|
|
|
result = schema.validate(value)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
b('true'), u('true'), False, 1, 3.14, [1, 3],
|
|
datetime.date(2018, 1, 2), datetime.datetime(2018, 1, 2, 23, 59, 59),
|
|
])
|
|
def test_string_format_uuid_invalid(self, value):
|
|
schema = Schema('string', schema_format='uuid')
|
|
|
|
with pytest.raises(InvalidSchemaValue):
|
|
schema.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
b('true'), u('true'), False, 1, 3.14, [1, 3],
|
|
u('1989-01-02'),
|
|
])
|
|
def test_string_format_datetime_invalid(self, value):
|
|
schema = Schema('string', schema_format='date-time')
|
|
|
|
with pytest.raises(InvalidSchemaValue):
|
|
schema.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
u('1989-01-02T00:00:00Z'),
|
|
u('2018-01-02T23:59:59Z'),
|
|
])
|
|
@mock.patch(
|
|
'openapi_core.schema.schemas._format.'
|
|
'DATETIME_HAS_STRICT_RFC3339', True
|
|
)
|
|
@mock.patch(
|
|
'openapi_core.schema.schemas._format.'
|
|
'DATETIME_HAS_ISODATE', False
|
|
)
|
|
def test_string_format_datetime_strict_rfc3339(self, value):
|
|
schema = Schema('string', schema_format='date-time')
|
|
|
|
result = schema.validate(value)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
u('1989-01-02T00:00:00Z'),
|
|
u('2018-01-02T23:59:59Z'),
|
|
])
|
|
@mock.patch(
|
|
'openapi_core.schema.schemas._format.'
|
|
'DATETIME_HAS_STRICT_RFC3339', False
|
|
)
|
|
@mock.patch(
|
|
'openapi_core.schema.schemas._format.'
|
|
'DATETIME_HAS_ISODATE', True
|
|
)
|
|
def test_string_format_datetime_isodate(self, value):
|
|
schema = Schema('string', schema_format='date-time')
|
|
|
|
result = schema.validate(value)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
b('stream'), b('text'),
|
|
])
|
|
def test_string_format_binary(self, value):
|
|
schema = Schema('string', schema_format='binary')
|
|
|
|
result = schema.validate(value)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
u('test'), b('stream'), datetime.date(1989, 1, 2),
|
|
datetime.datetime(1989, 1, 2, 0, 0, 0),
|
|
])
|
|
def test_string_format_unknown(self, value):
|
|
unknown_format = 'unknown'
|
|
schema = Schema('string', schema_format=unknown_format)
|
|
|
|
with pytest.raises(InvalidSchemaValue):
|
|
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.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.validate(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.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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [u(""), u("a")])
|
|
def test_string_max_length(self, value):
|
|
schema = Schema('string', max_length=1)
|
|
|
|
result = schema.validate(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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [u("bar"), u("foobar")])
|
|
def test_string_pattern(self, value):
|
|
schema = Schema('string', pattern='bar')
|
|
|
|
result = schema.validate(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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [Model(), ])
|
|
def test_object_multiple_one_of(self, value):
|
|
one_of = [
|
|
Schema('object'), Schema('object'),
|
|
]
|
|
schema = Schema('object', one_of=one_of)
|
|
|
|
with pytest.raises(InvalidSchemaValue):
|
|
schema.validate(value)
|
|
|
|
@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(InvalidSchemaValue):
|
|
schema.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [{}, ])
|
|
def test_object_no_one_of(self, value):
|
|
one_of = [
|
|
Schema(
|
|
'object',
|
|
properties={'test1': Schema('string')},
|
|
required=['test1', ],
|
|
),
|
|
Schema(
|
|
'object',
|
|
properties={'test2': Schema('string')},
|
|
required=['test2', ],
|
|
),
|
|
]
|
|
schema = Schema('object', one_of=one_of)
|
|
|
|
with pytest.raises(InvalidSchemaValue):
|
|
schema.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
{
|
|
'foo': u("FOO"),
|
|
},
|
|
{
|
|
'foo': u("FOO"),
|
|
'bar': u("BAR"),
|
|
},
|
|
])
|
|
def test_unambiguous_one_of(self, value):
|
|
one_of = [
|
|
Schema(
|
|
'object',
|
|
properties={
|
|
'foo': Schema('string'),
|
|
},
|
|
additional_properties=False,
|
|
required=['foo'],
|
|
),
|
|
Schema(
|
|
'object',
|
|
properties={
|
|
'foo': Schema('string'),
|
|
'bar': Schema('string'),
|
|
},
|
|
additional_properties=False,
|
|
required=['foo', 'bar'],
|
|
),
|
|
]
|
|
schema = Schema('object', one_of=one_of)
|
|
|
|
result = schema.validate(value)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.parametrize('value', [{}, ])
|
|
def test_object_default_property(self, value):
|
|
schema = Schema('object', default='value1')
|
|
|
|
result = schema.validate(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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
{'a': 1},
|
|
{'a': 1, 'b': 2},
|
|
{'a': 1, 'b': 2, 'c': 3},
|
|
])
|
|
def test_object_min_properties_invalid(self, value):
|
|
schema = Schema(
|
|
'object',
|
|
properties={k: Schema('number')
|
|
for k in ['a', 'b', 'c']},
|
|
min_properties=4,
|
|
)
|
|
|
|
with pytest.raises(InvalidSchemaValue):
|
|
schema.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
{'a': 1},
|
|
{'a': 1, 'b': 2},
|
|
{'a': 1, 'b': 2, 'c': 3},
|
|
])
|
|
def test_object_min_properties(self, value):
|
|
schema = Schema(
|
|
'object',
|
|
properties={k: Schema('number')
|
|
for k in ['a', 'b', 'c']},
|
|
min_properties=1,
|
|
)
|
|
|
|
result = schema.validate(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.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
{'a': 1},
|
|
{'a': 1, 'b': 2},
|
|
{'a': 1, 'b': 2, 'c': 3},
|
|
])
|
|
def test_object_max_properties_invalid(self, value):
|
|
schema = Schema(
|
|
'object',
|
|
properties={k: Schema('number')
|
|
for k in ['a', 'b', 'c']},
|
|
max_properties=0,
|
|
)
|
|
|
|
with pytest.raises(InvalidSchemaValue):
|
|
schema.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
{'a': 1},
|
|
{'a': 1, 'b': 2},
|
|
{'a': 1, 'b': 2, 'c': 3},
|
|
])
|
|
def test_object_max_properties(self, value):
|
|
schema = Schema(
|
|
'object',
|
|
properties={k: Schema('number')
|
|
for k in ['a', 'b', 'c']},
|
|
max_properties=3,
|
|
)
|
|
|
|
result = schema.validate(value)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.parametrize('value', [{'additional': 1}, ])
|
|
def test_object_additional_propetries(self, value):
|
|
schema = Schema('object')
|
|
|
|
result = schema.validate(value)
|
|
|
|
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(InvalidSchemaValue):
|
|
schema.validate(value)
|
|
|
|
@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)
|
|
|
|
result = schema.validate(value)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.parametrize('value', [[], [1], [1, 2]])
|
|
def test_list_min_items_invalid(self, value):
|
|
schema = Schema(
|
|
'array',
|
|
items=Schema('number'),
|
|
min_items=3,
|
|
)
|
|
|
|
with pytest.raises(Exception):
|
|
schema.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [[], [1], [1, 2]])
|
|
def test_list_min_items(self, value):
|
|
schema = Schema(
|
|
'array',
|
|
items=Schema('number'),
|
|
min_items=0,
|
|
)
|
|
|
|
result = schema.validate(value)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.parametrize('value', [[], ])
|
|
def test_list_max_items_invalid_schema(self, value):
|
|
schema = Schema(
|
|
'array',
|
|
items=Schema('number'),
|
|
max_items=-1,
|
|
)
|
|
|
|
with pytest.raises(OpenAPISchemaError):
|
|
schema.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [[1, 2], [2, 3, 4]])
|
|
def test_list_max_items_invalid(self, value):
|
|
schema = Schema(
|
|
'array',
|
|
items=Schema('number'),
|
|
max_items=1,
|
|
)
|
|
|
|
with pytest.raises(Exception):
|
|
schema.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [[1, 2, 1], [2, 2]])
|
|
def test_list_unique_items_invalid(self, value):
|
|
schema = Schema(
|
|
'array',
|
|
items=Schema('number'),
|
|
unique_items=True,
|
|
)
|
|
|
|
with pytest.raises(Exception):
|
|
schema.validate(value)
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
{
|
|
'someint': 123,
|
|
},
|
|
{
|
|
'somestr': u('content'),
|
|
},
|
|
{
|
|
'somestr': u('content'),
|
|
'someint': 123,
|
|
},
|
|
])
|
|
def test_object_with_properties(self, value):
|
|
schema = Schema(
|
|
'object',
|
|
properties={
|
|
'somestr': Schema('string'),
|
|
'someint': Schema('integer'),
|
|
},
|
|
)
|
|
|
|
result = schema.validate(value)
|
|
|
|
assert result is None
|
|
|
|
@pytest.mark.parametrize('value', [
|
|
{
|
|
'somestr': {},
|
|
'someint': 123,
|
|
},
|
|
{
|
|
'somestr': [
|
|
'content1', 'content2'
|
|
],
|
|
'someint': 123,
|
|
},
|
|
{
|
|
'somestr': 123,
|
|
'someint': 123,
|
|
},
|
|
{
|
|
'somestr': 'content',
|
|
'someint': 123,
|
|
'not_in_scheme_prop': 123,
|
|
},
|
|
])
|
|
def test_object_with_invalid_properties(self, value):
|
|
schema = Schema(
|
|
'object',
|
|
properties={
|
|
'somestr': Schema('string'),
|
|
'someint': Schema('integer'),
|
|
},
|
|
additional_properties=False,
|
|
)
|
|
|
|
with pytest.raises(Exception):
|
|
schema.validate(value)
|