def test_field_declared_as_required_with_field_present_is_valid():
    schema = {
        'type': OBJECT,
        'required': [
            'field-A',
            # 'field-B',
        ],
    }
    validator = generate_validator_from_schema(schema)

    try:
        validator({'field-A': 'present'})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors(
        'required.field-A',
        errors,
    )
    assert_path_not_in_errors(
        'required.field-B',
        errors,
    )

def test_format_for_valid_unregistered_format():
    try:
        schema_validator({'format': 'not-a-registered-format'})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors('format', errors)

def test_collection_format_is_not_required():
    try:
        single_parameter_validator({})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors("collectionFormat", errors)

def test_collection_format_with_valid_values():
    try:
        single_parameter_validator({"collectionFormat": CSV})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors("collectionFormat", errors)

def test_unique_items_with_valid_value():
    try:
        schema_validator({'uniqueItems': True})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors('uniqueItems', errors)

def test_unique_items_are_not_required():
    try:
        schema_validator({})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors('uniqueItems', errors)

def test_read_only_with_valid_value():
    try:
        schema_validator({'readOnly': True})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors('readOnly', errors)

def test_required_for_valid_required():
    try:
        schema_validator({'required': ['field-A', 'field-B']})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors('required', errors)

def test_pattern_for_valid_regex():
    try:
        schema_validator({'pattern': '^test$'})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors('pattern', errors)

def test_title_for_valid_title():
    try:
        schema_validator({'title': 'uuid'})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors('title', errors)

def test_type_validation_for_multiple_of_for_valid_types(type_):
    try:
        schema_validator({"multipleOf": 5, "type": type_})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors("type", errors)

def test_type_is_not_required():
    try:
        single_parameter_validator({})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors('type', errors)

def test_enum_with_empty_array_is_invalid():
    try:
        schema_validator({'enum': [1, 2, 3]})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors('enum', errors)

def test_headers_validation_with_valid_type():
    try:
        single_response_validator({'headers': {}})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors('headers', errors)

def test_multiple_for_valid_values(value):
    try:
        schema_validator({"multipleOf": value})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors("multipleOf", errors)

def test_read_only_is_not_required():
    try:
        schema_validator({})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors('readOnly', errors)

def test_headers_is_not_required():
    try:
        single_response_validator({})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors('headers', errors)

def test_properties_is_not_required():
    try:
        schema_validator({})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors('properties', errors)

def test_multiple_of_is_not_required():
    try:
        schema_validator({})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors("multipleOf", errors)

def test_min_and_max_length_with_valid_values():
    try:
        schema_validator({"minLength": 8, "maxLength": 10})
    except ValidationError as err:
        errors = err.detail
    else:
        errors = {}

    assert_path_not_in_errors("minLength", errors)
    assert_path_not_in_errors("maxLength", errors)