Current File : //opt/alt/python35/lib/python3.5/site-packages/cerberus/tests/__init__.py
# -*- coding: utf-8 -*-
import pytest
from cerberus import errors, Validator, SchemaError, DocumentError
from cerberus.tests.conftest import sample_schema
def assert_exception(exception, document={}, schema=None, validator=None,
msg=None):
""" Tests whether a specific exception is raised. Optionally also tests
whether the exception message is as expected. """
if validator is None:
validator = Validator(sample_schema)
if msg is None:
with pytest.raises(exception) as excinfo:
validator(document, schema)
else:
with pytest.raises(exception, message=msg) as excinfo: # noqa: F841
validator(document, schema)
def assert_schema_error(*args):
""" Tests whether a validation raises an exception due to a malformed
schema. """
assert_exception(SchemaError, *args)
def assert_document_error(*args):
""" Tests whether a validation raises an exception due to a malformed
document. """
assert_exception(DocumentError, *args)
def assert_fail(document, schema=None, validator=None, update=False,
error=None, errors=None, child_errors=None):
""" Tests whether a validation fails. """
if validator is None:
validator = Validator(sample_schema)
result = validator(document, schema, update)
assert isinstance(result, bool)
assert not result
actual_errors = validator._errors
assert not (error is not None and errors is not None)
assert not (errors is not None and child_errors is not None)
assert not (child_errors is not None and error is None)
if error is not None:
assert len(actual_errors) == 1
assert_has_error(actual_errors, *error)
if child_errors is not None:
assert len(actual_errors[0].child_errors) == len(child_errors)
assert_has_errors(actual_errors[0].child_errors, child_errors)
elif errors is not None:
assert len(actual_errors) == len(errors)
assert_has_errors(actual_errors, errors)
return actual_errors
def assert_success(document, schema=None, validator=None, update=False):
""" Tests whether a validation succeeds. """
if validator is None:
validator = Validator(sample_schema)
result = validator(document, schema, update)
assert isinstance(result, bool)
if not result:
raise AssertionError(validator.errors)
def assert_has_error(_errors, d_path, s_path, error_def, constraint, info=()):
if not isinstance(d_path, tuple):
d_path = (d_path,)
if not isinstance(info, tuple):
info = (info,)
assert isinstance(_errors, errors.ErrorList)
for i, error in enumerate(_errors):
assert isinstance(error, errors.ValidationError)
try:
assert error.document_path == d_path
assert error.schema_path == s_path
assert error.code == error_def.code
assert error.rule == error_def.rule
assert error.constraint == constraint
if not error.is_group_error:
assert error.info == info
except AssertionError:
pass
except Exception:
raise
else:
break
else:
raise AssertionError("""
Error with properties:
document_path={doc_path}
schema_path={schema_path}
code={code}
constraint={constraint}
info={info}
not found in errors:
{errors}
""".format(doc_path=d_path, schema_path=s_path,
code=hex(error.code), info=info,
constraint=constraint, errors=_errors))
return i
def assert_has_errors(_errors, _exp_errors):
assert isinstance(_exp_errors, list)
for error in _exp_errors:
assert isinstance(error, tuple)
assert_has_error(_errors, *error)
def assert_not_has_error(_errors, *args, **kwargs):
try:
assert_has_error(_errors, *args, **kwargs)
except AssertionError:
pass
except Exception as e:
raise e
else:
raise AssertionError('An unexpected error occurred.')
def assert_bad_type(field, data_type, value):
assert_fail({field: value},
error=(field, (field, 'type'), errors.BAD_TYPE, data_type))
def assert_normalized(document, expected, schema=None, validator=None):
if validator is None:
validator = Validator(sample_schema)
assert_success(document, schema, validator)
assert validator.document == expected
Mini Shell