def test_items_detects_invalid_schema_in_array():
schema = {
'type': ARRAY,
'items': [
{
'type': INTEGER,
'minLength': 4, # invalid with type 'integer'
},
{
'type': STRING,
'minimum': 4, # invalid with type 'string'
},
]
}
serializer = SchemaSerializer(
data=schema,
)
assert not serializer.is_valid()
assert 'items' in serializer.errors
assert 'minLength' in serializer.errors['items'][0]
assert_error_message_equal(
serializer.errors['items'][0]['minLength'][0],
serializer.error_messages['invalid_type_for_min_length'],
)
assert 'minimum' in serializer.errors['items'][1]
assert_error_message_equal(
serializer.errors['items'][1]['minimum'][0],
serializer.error_messages['invalid_type_for_minimum'],
)
def test_response_parameter_validation():
"""
Test that request validation does parameter validation. This is largely a
smoke test to ensure that parameter validation is wired into request
validation correctly.
"""
from django.core.exceptions import ValidationError
schema = SchemaFactory(
paths={
'/get': {
'get': {
'responses': {200: {'description': 'Success'}},
},
},
},
)
response = ResponseFactory(url='http://www.example.com/get', status_code=301)
with pytest.raises(ValidationError) as err:
validate_response(
response,
paths=schema['paths'],
base_path=schema.get('base_path', ''),
context=schema,
inner=True,
)
assert 'response' in err.value.messages[0]
assert_error_message_equal(
err.value.messages[0]['response'][0],
MESSAGES['response']['invalid_status_code'],
)
def test_path_serializer_path_parameter_validation_handles_references():
paths = {
'/get/no-parameters/': {
'parameters': [
'Id',
],
}
}
context = {
'parameters': {
'Id': {
'name': 'id',
'in': PATH,
'description': 'id',
'type': INTEGER,
'required': True,
},
}
}
serializer = PathsSerializer(data=paths, context=context)
assert not serializer.is_valid()
assert 'non_field_errors' in serializer.errors
assert '/get/no-parameters/' in serializer.errors['non_field_errors'][0]
assert_error_message_equal(
serializer.errors['non_field_errors'][0]['/get/no-parameters/'][0],
MESSAGES['path']['missing_parameter'],
)
def test_response_validation_with_invalid_operation_on_path():
"""
Test that response validation detects request paths that are not declared
in the schema.
"""
from django.core.exceptions import ValidationError
schema = SchemaFactory(
paths={
'/post': {
'post': None,
},
},
)
response = ResponseFactory(url='http://www.example.com/post')
with pytest.raises(ValidationError) as err:
validate_response(
response,
paths=schema['paths'],
base_path=schema.get('base_path', ''),
context=schema,
inner=True,
)
assert 'request' in err.value.messages[0]
assert_error_message_equal(
err.value.messages[0]['request'][0],
MESSAGES['request']['invalid_method'],
)
def test_response_parameter_validation():
"""
Test that request validation does parameter validation. This is largely a
smoke test to ensure that parameter validation is wired into request
validation correctly.
"""
schema = SchemaFactory(paths={
'/get': {
'get': {
'responses': {
'200': {
'description': 'Success'
}
},
},
},
}, )
response = ResponseFactory(url='http://www.example.com/get',
status_code=301)
with pytest.raises(ValidationError) as err:
validate_response(
response=response,
request_method='get',
schema=schema,
)
assert 'status_code' in err.value.messages[0]
assert_error_message_equal(
err.value.messages[0]['status_code'][0],
MESSAGES['response']['invalid_status_code'],
)
def test_parameter_format_validation_on_invalid_values(format_, value, error_key):
from django.core.exceptions import ValidationError
serializer = ParameterSerializer(many=True, data=(
{
'name': 'id',
'in': PATH,
'description': 'id',
'type': STRING,
'required': True,
'format': format_,
},
))
assert serializer.is_valid(), serializer.errors
parameters = serializer.object
parameter_values = {
'id': value,
}
with pytest.raises(ValidationError) as err:
validate_parameters(parameter_values, parameters, {}, inner=True)
assert 'id' in err.value.messages[0]
assert 'format' in err.value.messages[0]['id'][0]
assert_error_message_equal(
err.value.messages[0]['id'][0]['format'][0],
MESSAGES['format'][error_key],
)
def test_parameter_schema_validation_for_invalid_value(value, error_key, message_key):
from django.core.exceptions import ValidationError
serializer = ParameterSerializer(many=True, data=(
{
'name': 'id',
'in': BODY,
'description': 'id',
'required': True,
'schema': {'type': STRING, 'format': 'uuid'},
},
))
assert serializer.is_valid(), serializer.errors
parameters = serializer.object
parameter_values = {
'id': value,
}
with pytest.raises(ValidationError) as err:
validate_parameters(parameter_values, parameters, context={}, inner=True)
assert 'id' in err.value.messages[0]
assert error_key in err.value.messages[0]['id'][0]
assert_error_message_equal(
err.value.messages[0]['id'][0][error_key][0],
MESSAGES[error_key][message_key],
)
def test_response_parameter_validation():
"""
Test that request validation does parameter validation. This is largely a
smoke test to ensure that parameter validation is wired into request
validation correctly.
"""
schema = SchemaFactory(
paths={
'/get': {
'get': {
'responses': {200: {'description': 'Success'}},
},
},
},
)
response = ResponseFactory(url='http://www.example.com/get', status_code=301)
with pytest.raises(ValidationError) as err:
validate_response(
response=response,
request_method='get',
schema=schema,
)
assert 'status_code' in err.value.messages[0]
assert_error_message_equal(
err.value.messages[0]['status_code'][0],
MESSAGES['response']['invalid_status_code'],
)
def test_max_items_on_values_with_too_many_items(max_items, value):
from django.core.exceptions import ValidationError
serializer = ParameterSerializer(many=True, data=(
{
'name': 'id',
'in': PATH,
'description':'id',
'type': ARRAY,
'required': True,
'maxItems': max_items,
'items': {'type': STRING},
},
))
assert serializer.is_valid(), serializer.errors
parameters = serializer.object
parameter_values = {
'id': value,
}
with pytest.raises(ValidationError) as err:
validate_parameters(parameter_values, parameters, {}, inner=True)
assert 'id' in err.value.messages[0]
assert 'maxItems' in err.value.messages[0]['id'][0]
assert_error_message_equal(
err.value.messages[0]['id'][0]['maxItems'][0],
MESSAGES['max_items']['invalid'],
)
def test_multiple_of_validation_for_invalid_values(divisor, value):
from django.core.exceptions import ValidationError
serializer = ParameterSerializer(many=True, data=(
{
'name': 'id',
'in': PATH,
'description':'id',
'type': NUMBER,
'required': True,
'multipleOf': divisor,
},
))
assert serializer.is_valid(), serializer.errors
parameters = serializer.object
parameter_values = {
'id': value,
}
with pytest.raises(ValidationError) as err:
validate_parameters(parameter_values, parameters, {}, inner=True)
assert 'id' in err.value.messages[0]
assert 'multipleOf' in err.value.messages[0]['id'][0]
assert_error_message_equal(
err.value.messages[0]['id'][0]['multipleOf'][0],
MESSAGES['multiple_of']['invalid'],
)
def test_enum_validation_with_invalid_values(enum, value):
from django.core.exceptions import ValidationError
serializer = ParameterSerializer(many=True, data=(
{
'name': 'id',
'in': PATH,
'description':'id',
'type': [STRING, NUMBER, BOOLEAN],
'required': True,
'enum': enum,
},
))
assert serializer.is_valid(), serializer.errors
parameters = serializer.object
parameter_values = {
'id': value,
}
with pytest.raises(ValidationError) as err:
validate_parameters(parameter_values, parameters, {}, inner=True)
assert 'id' in err.value.messages[0]
assert 'enum' in err.value.messages[0]['id'][0]
assert_error_message_equal(
err.value.messages[0]['id'][0]['enum'][0],
MESSAGES['enum']['invalid'],
)
def test_items_is_required_when_type_is_array():
serializer = HeaderSerializer(
data={'type': ARRAY},
)
assert not serializer.is_valid()
assert 'items' in serializer.errors
assert_error_message_equal(
serializer.errors['items'][0],
serializer.error_messages['items_required'],
)
def test_flow_is_required_if_type_oath2():
serializer = SecuritySchemeSerializer(
data={'type': OAUTH_2},
)
assert not serializer.is_valid()
assert 'flow' in serializer.errors
assert_error_message_equal(
serializer.errors['flow'][0],
serializer.error_messages['flow_required']
)
def test_mistyped_header_default_boolean_to_string(type_, default):
serializer = HeaderSerializer(
data={'type': type_, 'default': default}
)
assert not serializer.is_valid()
assert 'default' in serializer.errors
assert_error_message_equal(
serializer.errors['default'][0],
serializer.error_messages['default_is_incorrect_type'],
)
def test_token_url_required_if_type_is_oath2(flow):
serializer = SecuritySchemeSerializer(
data={'type': OAUTH_2, 'flow': flow},
)
assert not serializer.is_valid()
assert 'tokenUrl' in serializer.errors
assert_error_message_equal(
serializer.errors['tokenUrl'][0],
serializer.error_messages['token_url_required']
)
def test_in_is_required_if_type_is_api_key():
serializer = SecuritySchemeSerializer(
data={'type': API_KEY, 'name': 'TestName'},
)
assert not serializer.is_valid()
assert 'in' in serializer.errors
assert_error_message_equal(
serializer.errors['in'][0],
serializer.error_messages['in_required']
)
def test_unknown_parameter_reference():
serializer = ParameterSerializer(
data=['SomeReference'],
context={},
)
assert not serializer.is_valid()
assert 'non_field_errors' in serializer.errors[0]
assert_error_message_equal(
serializer.errors[0]['non_field_errors'][0],
serializer.error_messages['unknown_reference']
)
def test_multiple_of_invalid_with_non_number_types(type_):
serializer = BaseSchemaSerializer(
data={
'type': type_,
'multipleOf': 10,
},
)
assert not serializer.is_valid()
assert 'multipleOf' in serializer.errors
assert_error_message_equal(
serializer.errors['multipleOf'][0],
serializer.error_messages['invalid_type_for_multiple_of'],
)
def test_exclusive_maximum_requires_maximum():
serializer = BaseSchemaSerializer(
data={
#'maximum': 0, # Intentionally commented out to show it's missing from data.
'exclusiveMaximum': True
},
)
assert not serializer.is_valid()
assert 'exclusiveMaximum' in serializer.errors
assert_error_message_equal(
serializer.errors['exclusiveMaximum'][0],
serializer.error_messages['exclusive_maximum_requires_maximum'],
)
def test_enum_with_invalid_items(letters):
schema = {
'enum': [True, False, 1.0, 2.0, 'A'],
}
validator = generate_validator_from_schema(schema)
with pytest.raises(ValidationError) as err:
validator(letters)
assert_error_message_equal(
err.value.messages[0]['enum'][0],
MESSAGES['enum']['invalid'],
)
def test_max_length_invalid_with_non_string_types(type_):
serializer = BaseSchemaSerializer(
data={
'type': type_,
'maxLength': 10,
},
)
assert not serializer.is_valid()
assert 'maxLength' in serializer.errors
assert_error_message_equal(
serializer.errors['maxLength'][0],
serializer.error_messages['invalid_type_for_max_length'],
)
def test_unique_items_invalid_with_non_arraw_type(type_):
serializer = BaseSchemaSerializer(
data={
'type': type_,
'uniqueItems': True,
},
)
assert not serializer.is_valid()
assert 'uniqueItems' in serializer.errors
assert_error_message_equal(
serializer.errors['uniqueItems'][0],
serializer.error_messages['invalid_type_for_unique_items'],
)
def test_max_items_invalid_with_non_array_type(type_):
serializer = BaseSchemaSerializer(
data={
'type': type_,
'maxItems': 5,
},
)
assert not serializer.is_valid()
assert 'maxItems' in serializer.errors
assert_error_message_equal(
serializer.errors['maxItems'][0],
serializer.error_messages['invalid_type_for_max_items'],
)
def test_max_properties_invalid_for_non_object_types(type_):
serializer = BaseSchemaSerializer(
data={
'type': type_,
'maxProperties': 3,
},
)
assert not serializer.is_valid()
assert 'maxProperties' in serializer.errors
assert_error_message_equal(
serializer.errors['maxProperties'][0],
serializer.error_messages['invalid_type_for_max_properties']
)
def test_enum_with_invalid_items(letters):
schema = {
'enum': [True, False, 1.0, 2.0, 'A'],
}
validator = generate_validator_from_schema(schema)
with pytest.raises(ValidationError) as err:
validator(letters)
assert_error_message_equal(
err.value.messages[0]['enum'][0],
MESSAGES['enum']['invalid'],
)
def test_maximum_is_invalid_for_non_numeric_types(type_):
serializer = BaseSchemaSerializer(
data={
'type': type_,
'maximum': 0,
},
)
assert not serializer.is_valid()
assert 'maximum' in serializer.errors
assert_error_message_equal(
serializer.errors['maximum'][0],
serializer.error_messages['invalid_type_for_maximum'],
)
def test_header_type_validation_for_invalid_values(type_, value):
header_definition = single_header_validator({
'type': type_,
})
validators = construct_header_validators(header_definition=header_definition, context={})
with pytest.raises(ValidationError) as err:
validate_object(value, validators)
assert 'type' in err.value.detail
assert_error_message_equal(
err.value.detail['type'][0],
MESSAGES['type']['invalid'],
)
def test_date_time_with_invalid_dates_strings(when):
schema = {
'format': 'date-time',
}
validator = generate_validator_from_schema(schema)
with pytest.raises(ValidationError) as err:
validator(when)
assert 'format' in err.value.messages[0]
assert_error_message_equal(
err.value.messages[0]['format'][0],
MESSAGES['format']['invalid_datetime'],
)
def test_invalid_multi_type(value):
schema = {
'type': [INTEGER, STRING],
}
validator = generate_validator_from_schema(schema)
with pytest.raises(ValidationError) as err:
validator(value)
assert 'type' in err.value.messages[0]
assert_error_message_equal(
err.value.messages[0]['type'][0],
MESSAGES['type']['invalid'],
)
def test_date_time_with_invalid_dates_strings(when):
schema = {
'format': 'date-time',
}
validator = generate_validator_from_schema(schema)
with pytest.raises(ValidationError) as err:
validator(when)
assert 'format' in err.value.messages[0]
assert_error_message_equal(
err.value.messages[0]['format'][0],
MESSAGES['format']['invalid_datetime'],
)
def test_field_declared_as_required():
schema = {
'required': True,
}
validator = generate_validator_from_schema(schema)
with pytest.raises(ValidationError) as err:
validator(EMPTY)
assert 'required' in err.value.messages[0]
assert_error_message_equal(
err.value.messages[0]['required'][0],
MESSAGES['required']['required'],
)
def test_string_type_raises_error():
schema = {
'type': INTEGER,
}
validator = generate_validator_from_schema(schema)
with pytest.raises(ValidationError) as err:
validator('abcd')
assert 'type' in err.value.messages[0]
assert_error_message_equal(
err.value.messages[0]['type'][0],
MESSAGES['type']['invalid'],
)
def test_inclusive_minimum_validation_with_invalid_numbers(width):
schema = {
'type': NUMBER,
'minimum': 5,
}
validator = generate_validator_from_schema(schema)
with pytest.raises(ValidationError) as err:
validator(width)
assert 'minimum' in err.value.messages[0]
assert_error_message_equal(
err.value.messages[0]['minimum'][0],
MESSAGES['minimum']['invalid'],
)
def test_float_not_multiple_of(count):
schema = {
'type': INTEGER,
'multipleOf': 0.3,
}
validator = generate_validator_from_schema(schema)
with pytest.raises(ValidationError) as err:
validator(count)
assert 'multipleOf' in err.value.messages[0]
assert_error_message_equal(
err.value.messages[0]['multipleOf'][0],
MESSAGES['multiple_of']['invalid'],
)
def test_max_properties_with_too_many_properties(element):
schema = {
'type': OBJECT,
'maxProperties': 2,
}
validator = generate_validator_from_schema(schema)
with pytest.raises(ValidationError) as err:
validator(element)
assert 'maxProperties' in err.value.messages[0]
assert_error_message_equal(
err.value.messages[0]['maxProperties'][0],
MESSAGES['max_properties']['invalid'],
)
def test_max_properties_with_too_many_properties(element):
schema = {
'type': OBJECT,
'maxProperties': 2,
}
validator = generate_validator_from_schema(schema)
with pytest.raises(ValidationError) as err:
validator(element)
assert 'maxProperties' in err.value.messages[0]
assert_error_message_equal(
err.value.messages[0]['maxProperties'][0],
MESSAGES['max_properties']['invalid'],
)
def test_header_type_validation_for_invalid_values(type_, value):
header_definition = single_header_validator({
'type': type_,
})
validators = construct_header_validators(
header_definition=header_definition, context={})
with pytest.raises(ValidationError) as err:
validate_object(value, validators)
assert 'type' in err.value.detail
assert_error_message_equal(
err.value.detail['type'][0],
MESSAGES['type']['invalid'],
)
def test_max_items_with_too_long_array(letters):
schema = {
'type': ARRAY,
'maxItems': 3,
}
validator = generate_validator_from_schema(schema)
with pytest.raises(ValidationError) as err:
validator(letters)
assert 'maxItems' in err.value.messages[0]
assert_error_message_equal(
err.value.messages[0]['maxItems'][0],
MESSAGES['max_items']['invalid'],
)
