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_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_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_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'], )