def test_ignore_none_values():
field = 'test'
schema = {field: {'type': 'string', 'empty': False, 'required': False}}
document = {field: None}
# Test normal behaviour
validator = Validator(schema, ignore_none_values=False)
assert_fail(document, validator=validator)
validator.schema[field]['required'] = True
validator.schema.validate()
_errors = assert_fail(document, validator=validator)
assert_not_has_error(_errors, field, (field, 'required'),
errors.REQUIRED_FIELD, True)
# Test ignore None behaviour
validator = Validator(schema, ignore_none_values=True)
validator.schema[field]['required'] = False
validator.schema.validate()
assert_success(document, validator=validator)
validator.schema[field]['required'] = True
_errors = assert_fail(schema=schema, document=document, validator=validator)
assert_has_error(_errors, field, (field, 'required'), errors.REQUIRED_FIELD,
True)
assert_not_has_error(_errors, field, (field, 'type'), errors.BAD_TYPE,
'string')
def test_ignore_none_values():
# original commits:
# 96532fc8efbc0b057dd6cd23d0324c8c5a929456
# d6422991c41587467673716cb6e4e929fa9d7b77
field = 'test'
schema = {field: {'type': ('string',), 'empty': False, 'required': False}}
document = {field: None}
# Test normal behaviour
validator = Validator(schema, ignore_none_values=False)
assert_fail(document, validator=validator)
validator.schema[field]['required'] = True
validator.schema.validate()
_errors = assert_fail(document, validator=validator)
assert_not_has_error(
_errors, field, (field, 'required'), errors.REQUIRED_FIELD, True
)
# Test ignore None behaviour
validator = Validator(schema, ignore_none_values=True)
validator.schema[field]['required'] = False
validator.schema.validate()
assert_success(document, validator=validator)
validator.schema[field]['required'] = True
assert validator.schema[field].get('required') is True
_errors = assert_fail(document=document, validator=validator)
assert_has_error(_errors, field, (field, 'required'), errors.REQUIRED_FIELD, True)
assert_not_has_error(_errors, field, (field, 'type'), errors.TYPE, 'string')
def test_ignore_none_values():
field = 'test'
schema = {field: {'type': 'string', 'empty': False, 'required': False}}
document = {field: None}
# Test normal behaviour
validator = Validator(schema, ignore_none_values=False)
assert_fail(document, validator=validator)
validator.schema[field]['required'] = True
validator.schema.validate()
_errors = assert_fail(document, validator=validator)
assert_not_has_error(_errors, field, (field, 'required'),
errors.REQUIRED_FIELD, True)
# Test ignore None behaviour
validator = Validator(schema, ignore_none_values=True)
validator.schema[field]['required'] = False
validator.schema.validate()
assert_success(document, validator=validator)
validator.schema[field]['required'] = True
_errors = assert_fail(schema=schema, document=document, validator=validator)
assert_has_error(_errors, field, (field, 'required'), errors.REQUIRED_FIELD,
True)
assert_not_has_error(_errors, field, (field, 'type'), errors.BAD_TYPE,
'string')
def test_anyof_schema(validator):
# test that a list of schemas can be specified.
valid_parts = [{'schema': {'model number': {'type': 'string'},
'count': {'type': 'integer'}}},
{'schema': {'serial number': {'type': 'string'},
'count': {'type': 'integer'}}}]
valid_item = {'type': ['dict', 'string'], 'anyof': valid_parts}
schema = {'parts': {'type': 'list', 'schema': valid_item}}
document = {'parts': [{'model number': 'MX-009', 'count': 100},
{'serial number': '898-001'},
'misc']}
# document is valid. each entry in 'parts' matches a type or schema
assert_success(document, schema, validator=validator)
document['parts'].append({'product name': "Monitors", 'count': 18})
# document is invalid. 'product name' does not match any valid schemas
assert_fail(document, schema, validator=validator)
document['parts'].pop()
# document is valid again
assert_success(document, schema, validator=validator)
document['parts'].append({'product name': "Monitors", 'count': 18})
document['parts'].append(10)
# and invalid. numbers are not allowed.
exp_child_errors = [
(('parts', 3), ('parts', 'schema', 'anyof'), errors.ANYOF,
valid_parts),
(('parts', 4), ('parts', 'schema', 'type'), errors.BAD_TYPE,
['dict', 'string'])
]
_errors = assert_fail(document, schema, validator=validator,
error=('parts', ('parts', 'schema'),
errors.SEQUENCE_SCHEMA, valid_item),
child_errors=exp_child_errors)
assert_not_has_error(_errors, ('parts', 4), ('parts', 'schema', 'anyof'),
errors.ANYOF, valid_parts)
v_errors = validator.errors
assert 'parts' in v_errors
assert 3 in v_errors['parts'][-1]
assert 'anyof' in v_errors['parts'][-1][3][-1]
assert v_errors['parts'][-1][3][-1]['anyof'][0] == "no definitions validate"
scope = v_errors['parts'][-1][3][-1]['anyof'][-1]
assert 'anyof definition 0' in scope
assert 'anyof definition 1' in scope
assert scope['anyof definition 0'] == ["unknown field"]
assert scope['anyof definition 1'] == ["unknown field"]
assert v_errors['parts'][-1][4] == ["must be of ['dict', 'string'] type"]
def test_anyof_schema(validator):
# test that a list of schemas can be specified.
valid_parts = [{'schema': {'model number': {'type': 'string'},
'count': {'type': 'integer'}}},
{'schema': {'serial number': {'type': 'string'},
'count': {'type': 'integer'}}}]
valid_item = {'type': ['dict', 'string'], 'anyof': valid_parts}
schema = {'parts': {'type': 'list', 'schema': valid_item}}
document = {'parts': [{'model number': 'MX-009', 'count': 100},
{'serial number': '898-001'},
'misc']}
# document is valid. each entry in 'parts' matches a type or schema
assert_success(document, schema, validator=validator)
document['parts'].append({'product name': "Monitors", 'count': 18})
# document is invalid. 'product name' does not match any valid schemas
assert_fail(document, schema, validator=validator)
document['parts'].pop()
# document is valid again
assert_success(document, schema, validator=validator)
document['parts'].append({'product name': "Monitors", 'count': 18})
document['parts'].append(10)
# and invalid. numbers are not allowed.
exp_child_errors = [
(('parts', 3), ('parts', 'schema', 'anyof'), errors.ANYOF,
valid_parts),
(('parts', 4), ('parts', 'schema', 'type'), errors.BAD_TYPE,
['dict', 'string'])
]
_errors = assert_fail(document, schema, validator=validator,
error=('parts', ('parts', 'schema'),
errors.SEQUENCE_SCHEMA, valid_item),
child_errors=exp_child_errors)
assert_not_has_error(_errors, ('parts', 4), ('parts', 'schema', 'anyof'),
errors.ANYOF, valid_parts)
v_errors = validator.errors
assert 'parts' in v_errors
assert 3 in v_errors['parts'][-1]
assert 'anyof' in v_errors['parts'][-1][3][-1]
assert v_errors['parts'][-1][3][-1]['anyof'][0] == "no definitions validate"
scope = v_errors['parts'][-1][3][-1]['anyof'][-1]
assert 'anyof definition 0' in scope
assert 'anyof definition 1' in scope
assert scope['anyof definition 0'] == ["unknown field"]
assert scope['anyof definition 1'] == ["unknown field"]
assert v_errors['parts'][-1][4] == ["must be of ['dict', 'string'] type"]
def test_anyof_schema(validator):
# test that a list of schemas can be specified.
valid_parts = [
{"schema": {"model number": {"type": "string"}, "count": {"type": "integer"}}},
{"schema": {"serial number": {"type": "string"}, "count": {"type": "integer"}}},
]
valid_item = {"type": ["dict", "string"], "anyof": valid_parts}
schema = {"parts": {"type": "list", "schema": valid_item}}
document = {"parts": [{"model number": "MX-009", "count": 100}, {"serial number": "898-001"}, "misc"]}
# document is valid. each entry in 'parts' matches a type or schema
assert_success(document, schema, validator=validator)
document["parts"].append({"product name": "Monitors", "count": 18})
# document is invalid. 'product name' does not match any valid schemas
assert_fail(document, schema, validator=validator)
document["parts"].pop()
# document is valid again
assert_success(document, schema, validator=validator)
document["parts"].append({"product name": "Monitors", "count": 18})
document["parts"].append(10)
# and invalid. numbers are not allowed.
exp_child_errors = [
(("parts", 3), ("parts", "schema", "anyof"), errors.ANYOF, valid_parts),
(("parts", 4), ("parts", "schema", "type"), errors.BAD_TYPE, ["dict", "string"]),
]
_errors = assert_fail(
document,
schema,
validator=validator,
error=("parts", ("parts", "schema"), errors.SEQUENCE_SCHEMA, valid_item),
child_errors=exp_child_errors,
)
assert_not_has_error(_errors, ("parts", 4), ("parts", "schema", "anyof"), errors.ANYOF, valid_parts)
v_errors = validator.errors
assert "parts" in v_errors
assert 3 in v_errors["parts"][-1]
assert "anyof" in v_errors["parts"][-1][3][-1]
assert v_errors["parts"][-1][3][-1]["anyof"][0] == "no definitions validate"
scope = v_errors["parts"][-1][3][-1]["anyof"][-1]
assert "anyof definition 0" in scope
assert "anyof definition 1" in scope
assert scope["anyof definition 0"] == ["unknown field"]
assert scope["anyof definition 1"] == ["unknown field"]
assert v_errors["parts"][-1][4] == ["must be of ['dict', 'string'] type"]
def test_ignore_none_values():
field = "test"
schema = {field: {"type": "string", "empty": False, "required": False}}
document = {field: None}
# Test normal behaviour
validator = Validator(schema, ignore_none_values=False)
assert_fail(document, validator=validator)
validator.schema[field]["required"] = True
validator.schema.validate()
_errors = assert_fail(document, validator=validator)
assert_not_has_error(_errors, field, (field, "required"), errors.REQUIRED_FIELD, True)
# Test ignore None behaviour
validator = Validator(schema, ignore_none_values=True)
validator.schema[field]["required"] = False
validator.schema.validate()
assert_success(document, validator=validator)
validator.schema[field]["required"] = True
_errors = assert_fail(schema=schema, document=document, validator=validator)
assert_has_error(_errors, field, (field, "required"), errors.REQUIRED_FIELD, True)
assert_not_has_error(_errors, field, (field, "type"), errors.BAD_TYPE, "string")
def test_anyof_in_itemsrules(validator):
# test that a list of schemas can be specified.
valid_parts = (
{
'schema': {
'model number': {
'type': ('string', )
},
'count': {
'type': ('integer', )
},
}
},
{
'schema': {
'serial number': {
'type': (str, )
},
'count': {
'type': (int, )
}
}
},
)
valid_item = {'type': ('dict', 'string'), 'anyof': valid_parts}
schema = {'parts': {'type': 'list', 'itemsrules': valid_item}}
document = {
'parts': [
{
'model number': 'MX-009',
'count': 100
},
{
'serial number': '898-001'
},
'misc',
]
}
# document is valid. each entry in 'parts' matches a type or schema
assert_success(document=document, schema=schema, validator=validator)
document['parts'].append({'product name': "Monitors", 'count': 18})
# document is invalid. 'product name' does not match any valid schemas
assert_fail(document=document, schema=schema, validator=validator)
document['parts'].pop()
# document is valid again
assert_success(document=document, schema=schema, validator=validator)
document['parts'].append({'product name': "Monitors", 'count': 18})
document['parts'].append(10)
# and invalid. numbers are not allowed.
_errors = assert_fail(
document,
schema,
validator=validator,
error=('parts', ('parts', 'itemsrules'), errors.ITEMSRULES,
valid_item),
child_errors=[
(('parts', 3), ('parts', 'itemsrules', 'anyof'), errors.ANYOF,
valid_parts),
(
('parts', 4),
('parts', 'itemsrules', 'type'),
errors.TYPE,
('dict', 'string'),
),
],
)
assert_not_has_error(
_errors,
('parts', 4),
('parts', 'itemsrules', 'anyof'),
errors.ANYOF,
valid_parts,
)
# tests errors.BasicErrorHandler's tree representation
_errors = validator.errors
assert 'parts' in _errors
assert 3 in _errors['parts'][-1]
assert _errors['parts'][-1][3][0] == "no definitions validate"
scope = _errors['parts'][-1][3][-1]
assert 'anyof definition 0' in scope
assert 'anyof definition 1' in scope
assert scope['anyof definition 0'] == [{"product name": ["unknown field"]}]
assert scope['anyof definition 1'] == [{"product name": ["unknown field"]}]
assert _errors['parts'][-1][4] == [
"must be one of these types: ('dict', 'string')"
]
