def test_dict_keys(self):
res = t.DictKeys(["a", "b"]).check({"a": 1, "b": 2})
self.assertEqual(res, {"a": 1, "b": 2})
res = extract_error(t.DictKeys(["a", "b"]), {"a": 1, "b": 2, "c": 3})
self.assertEqual(res, {"c": "c is not allowed key"})
res = extract_error(t.DictKeys(["key", "key2"]), {"key": "val"})
self.assertEqual(res, {"key2": "is required"})
def test_mapping_interface(self):
trafaret = t.Dict({t.Key("foo"): t.String, t.Key("bar"): t.Float})
# class with mapping interface but not subclass of dict
class Map(AbcMapping):
def __init__(self, data, *a, **kw):
super(Map, self).__init__(*a, **kw)
self._data = data
def __getitem__(self, key):
return self._data[key]
def __iter__(self):
for x in self._data:
yield x
def __len__(self):
return len(self._data)
trafaret.check(Map({"foo": "xxx", "bar": 0.1}))
res = extract_error(trafaret, object())
self.assertEqual(res, "value does not provide Mapping interface")
res = extract_error(trafaret, Map({"foo": "xxx"}))
self.assertEqual(res, {"bar": "is required"})
res = extract_error(trafaret, Map({"foo": "xxx", "bar": "str"}))
self.assertEqual(res, {"bar": "value can't be converted to float"})
def test_dict_keys(self):
res = t.DictKeys(['a', 'b']).check({'a': 1, 'b': 2})
self.assertEqual(res, {'a': 1, 'b': 2})
res = extract_error(t.DictKeys(['a', 'b']), {'a': 1, 'b': 2, 'c': 3})
self.assertEqual(res, {'c': 'c is not allowed key'})
res = extract_error(t.DictKeys(['key', 'key2']), {'key': 'val'})
self.assertEqual(res, {'key2': 'is required'})
def test_string(self):
res = t.String()
self.assertEqual(repr(res), '<String>')
res = t.String(allow_blank=True)
self.assertEqual(repr(res), '<String(blank)>')
res = t.String().check("foo")
self.assertEqual(res, 'foo')
res = extract_error(t.String(), "")
self.assertEqual(res, 'blank value is not allowed')
res = t.String(allow_blank=True).check("")
self.assertEqual(res, '')
res = extract_error(t.String(), 1)
self.assertEqual(res, 'value is not a string')
res = t.String(regex='\w+').check('wqerwqer')
self.assertEqual(res, 'wqerwqer')
res = extract_error(t.String(regex='^\w+$'), 'wqe rwqer')
self.assertEqual(res, "value does not match pattern: '^\\\\w+$'")
res = t.String(min_length=2, max_length=3).check('123')
self.assertEqual(res, '123')
res = extract_error(t.String(min_length=2, max_length=6), '1')
self.assertEqual(res, 'String is shorter than 2 characters')
res = extract_error(t.String(min_length=2, max_length=6), '1234567')
self.assertEqual(res, 'String is longer than 6 characters')
# TODO
# res = String(min_length=2, max_length=6, allow_blank=True)
# self.assertEqual(res, Traceback (most recent call last):
# ...
# AssertionError: Either allow_blank or min_length should be specified, not both
res = t.String(min_length=0, max_length=6, allow_blank=True).check('123')
self.assertEqual(res, '123')
def test_mutually_exclusive(self):
trafaret = t.Dict({
t.Key('ami', optional=True): t.String,
t.Key('ami_config_key', optional=True): t.String,
t.Key('label'): t.String
}).mutually_exclusive(* [('ami', 'ami_config_key')])
self.assertEqual(
trafaret.check({
'label': 'nya',
'ami_config_key': 'the_key'
}), {'label': 'nya',
'ami_config_key': 'the_key'})
self.assertEqual(
trafaret.check({
'label': 'nya',
'ami': 'ami-d2384821'
}), {'label': 'nya',
'ami': 'ami-d2384821'})
res = t.extract_error(trafaret, {
'label': 'nya',
'ami_config_key': 'the_key',
'ami': 'ami-d2384821'
})
self.assertEqual(res, {'ami': 'ami mutually exclusive with ami_config_key'})
res = t.extract_error(trafaret, {
'label': 'nya'
})
self.assertEqual(res, {'ami': 'at least one key required from set: ami, ami_config_key'})
def test_string(self):
res = t.String()
self.assertEqual(repr(res), "<String>")
res = t.String(allow_blank=True)
self.assertEqual(repr(res), "<String(blank)>")
res = t.String().check("foo")
self.assertEqual(res, "foo")
res = extract_error(t.String(), "")
self.assertEqual(res, "blank value is not allowed")
res = t.String(allow_blank=True).check("")
self.assertEqual(res, "")
res = extract_error(t.String(), 1)
self.assertEqual(res, "value is not a string")
res = t.String(regex="\w+").check("wqerwqer")
self.assertEqual(res, "wqerwqer")
res = extract_error(t.String(regex="^\w+$"), "wqe rwqer")
self.assertEqual(res, "value does not match pattern: '^\\\\w+$'")
res = t.String(min_length=2, max_length=3).check("123")
self.assertEqual(res, "123")
res = extract_error(t.String(min_length=2, max_length=6), "1")
self.assertEqual(res, "String is shorter than 2 characters")
res = extract_error(t.String(min_length=2, max_length=6), "1234567")
self.assertEqual(res, "String is longer than 6 characters")
# TODO
# res = String(min_length=2, max_length=6, allow_blank=True)
# self.assertEqual(res, Traceback (most recent call last):
# ...
# AssertionError: Either allow_blank or min_length should be specified, not both
res = t.String(min_length=0, max_length=6, allow_blank=True).check("123")
self.assertEqual(res, "123")
def test_mapping(self):
trafaret = t.Mapping(t.String, t.Int)
self.assertEqual(repr(trafaret), "<Mapping(<String> => <Int>)>")
res = trafaret.check({"foo": 1, "bar": 2})
self.assertEqual(res, {"bar": 2, "foo": 1})
res = extract_error(trafaret, {"foo": 1, "bar": None})
self.assertEqual(res, {"bar": {"value": "value is not int"}})
res = extract_error(trafaret, {"foo": 1, 2: "bar"})
self.assertEqual(res, {2: {"key": "value is not a string", "value": "value can't be converted to int"}})
def test_base2(self):
trafaret = t.Dict({t.Key("bar", optional=True): t.String}, foo=t.Int)
trafaret.allow_extra("*")
res = trafaret.check({"foo": 1, "ham": 100, "baz": None})
self.assertEqual(res, {"baz": None, "foo": 1, "ham": 100})
res = extract_error(trafaret, {"bar": 1, "ham": 100, "baz": None})
self.assertEqual(res, {"bar": "value is not a string", "foo": "is required"})
res = extract_error(trafaret, {"foo": 1, "bar": 1, "ham": 100, "baz": None})
self.assertEqual(res, {"bar": "value is not a string"})
def test_mapping(self):
trafaret = t.Mapping(t.String, t.Int)
self.assertEqual(repr(trafaret), '<Mapping(<String> => <Int>)>')
res = trafaret.check({"foo": 1, "bar": 2})
self.assertEqual(res, {'bar': 2, 'foo': 1})
res = extract_error(trafaret, {"foo": 1, "bar": None})
self.assertEqual(res, {'bar': {'value': 'value is not int'}})
res = extract_error(trafaret, {"foo": 1, 2: "bar"})
self.assertEqual(res, {2: {'key': 'value is not a string', 'value': "value can't be converted to int"}})
def test_meta_res(self):
res = (t.Int > 5).check(10)
self.assertEqual(res, 10)
res = extract_error(t.Int > 5, 1)
self.assertEqual(res, 'value should be greater than 5')
res = (t.Int < 3).check(1)
self.assertEqual(res, 1)
res = extract_error(t.Int < 3, 3)
self.assertEqual(res, 'value should be less than 3')
def test_base2(self):
trafaret = t.Dict({t.Key('bar', optional=True): t.String}, foo=t.Int)
trafaret.allow_extra('*')
res = trafaret.check({"foo": 1, "ham": 100, "baz": None})
self.assertEqual(res, {'baz': None, 'foo': 1, 'ham': 100})
res = extract_error(trafaret, {"bar": 1, "ham": 100, "baz": None})
self.assertEqual(res, {'bar': 'value is not a string', 'foo': 'is required'})
res = extract_error(trafaret, {"foo": 1, "bar": 1, "ham": 100, "baz": None})
self.assertEqual(res, {'bar': 'value is not a string'})
def test_int(self):
res = repr(t.Int())
self.assertEqual(res, '<Int>')
res = t.Int().check(5)
self.assertEqual(res, 5)
res = extract_error(t.Int(), 1.1)
self.assertEqual(res, 'value is not int')
res = extract_error(t.Int(), 1 + 1j)
self.assertEqual(res, 'value is not int')
def test_mongo_id(self):
c = MongoId()
self.assertIsInstance(repr(c), str)
self.assertEqual(c.check("5583f69d690b2d70a4afdfae"),
ObjectId('5583f69d690b2d70a4afdfae'))
res = extract_error(c, 'just_id')
self.assertEqual(res, "'just_id' is not a valid ObjectId, it must be"
" a 12-byte input or a 24-character hex string")
res = extract_error(c, None)
self.assertEqual(res, "blank value is not allowed")
def test_mongo_id(self):
from trafaret.contrib.object_id import ObjectId
c = t.MongoId()
self.assertIsInstance(repr(c), str)
self.assertEqual(c.check("5583f69d690b2d70a4afdfae"), ObjectId("5583f69d690b2d70a4afdfae"))
res = extract_error(c, "just_id")
self.assertEqual(
res, "'just_id' is not a valid ObjectId, it must be" " a 12-byte input or a 24-character hex string"
)
res = extract_error(c, None)
self.assertEqual(res, "blank value is not allowed")
def test_forward(self):
node = t.Forward()
node << t.Dict(name=t.String, children=t.List[node])
self.assertEqual(repr(node), "<Forward(<Dict(children=<List(<recur>)>, name=<String>)>)>")
res = node.check({"name": "foo", "children": []}) == {"children": [], "name": "foo"}
self.assertEqual(res, True)
res = extract_error(node, {"name": "foo", "children": [1]})
self.assertEqual(res, {"children": {0: "value does not provide Mapping interface"}})
res = node.check({"name": "foo", "children": [{"name": "bar", "children": []}]})
self.assertEqual(res, {"children": [{"children": [], "name": "bar"}], "name": "foo"})
empty_node = t.Forward()
self.assertEqual(repr(empty_node), "<Forward(None)>")
res = extract_error(empty_node, "something")
self.assertEqual(res, "trafaret not set yet")
def test_forward(self):
node = t.Forward()
node << t.Dict(name=t.String, children=t.List[node])
self.assertEqual(repr(node), '<Forward(<Dict(children=<List(<recur>)>, name=<String>)>)>')
res = node.check({"name": "foo", "children": []}) == {'children': [], 'name': 'foo'}
self.assertEqual(res, True)
res = extract_error(node, {"name": "foo", "children": [1]})
self.assertEqual(res, {'children': {0: 'value is not dict'}})
res = node.check({"name": "foo", "children": [{"name": "bar", "children": []}]})
self.assertEqual(res, {'children': [{'children': [], 'name': 'bar'}], 'name': 'foo'})
empty_node = t.Forward()
self.assertEqual(repr(empty_node), '<Forward(None)>')
res = extract_error(empty_node, 'something')
self.assertEqual(res, 'trafaret not set yet')
def test_email(self):
res = t.Email().check('*****@*****.**')
self.assertEqual(res, '*****@*****.**')
res = extract_error(t.Email(),'someone@example') # try without domain-part
self.assertEqual(res, 'value is not a valid email address')
res = str(t.Email().check('someone@пример.рф')) # try with `idna` encoding
self.assertEqual(res, '[email protected]')
res = (t.Email() >> (lambda m: m.groupdict()['domain'])).check('*****@*****.**')
self.assertEqual(res, 'example.net')
res = extract_error(t.Email(), 'foo')
self.assertEqual(res, 'value is not a valid email address')
res = extract_error(t.Email(), 'f' * 10000 + '@correct.domain.edu')
self.assertEqual(res, 'value is not a valid email address')
res = extract_error(t.Email(), 'f' * 248 + '@x.edu') == 'f' * 248 + '@x.edu'
self.assertEqual(res, True)
def test_email(self):
res = t.Email().check("*****@*****.**")
self.assertEqual(res, "*****@*****.**")
res = extract_error(t.Email(), "someone@example") # try without domain-part
self.assertEqual(res, "value is not a valid email address")
res = str(t.Email().check("someone@пример.рф")) # try with `idna` encoding
self.assertEqual(res, "[email protected]")
res = (t.Email() >> (lambda m: m.groupdict()["domain"])).check("*****@*****.**")
self.assertEqual(res, "example.net")
res = extract_error(t.Email(), "foo")
self.assertEqual(res, "value is not a valid email address")
res = extract_error(t.Email(), "f" * 10000 + "@correct.domain.edu")
self.assertEqual(res, "value is not a valid email address")
res = extract_error(t.Email(), "f" * 248 + "@x.edu") == "f" * 248 + "@x.edu"
self.assertEqual(res, True)
def test_tuple(self):
tup = t.Tuple(t.Int, t.Int, t.String)
self.assertEqual(repr(tup), "<Tuple(<Int>, <Int>, <String>)>")
res = tup.check([3, 4, "5"])
self.assertEqual(res, (3, 4, "5"))
res = extract_error(tup, [3, 4, 5])
self.assertEqual(res, {2: "value is not a string"})
def test_enum(self):
trafaret = t.Enum("foo", "bar", 1) >> ignore
self.assertEqual(repr(trafaret), "<Enum('foo', 'bar', 1)>")
res = trafaret.check("foo")
res = trafaret.check(1)
res = extract_error(trafaret, 2)
self.assertEqual(res, "value doesn't match any variant")
def test_tuple(self):
tup = t.Tuple(t.Int, t.Int, t.String)
self.assertEqual(repr(tup), '<Tuple(<Int>, <Int>, <String>)>')
res = tup.check([3, 4, '5'])
self.assertEqual(res, (3, 4, '5'))
res = extract_error(tup, [3, 4, 5])
self.assertEqual(res, {2: 'value is not a string'})
def test_str_bool(self):
res = extract_error(t.StrBool(), 'aloha')
self.assertEqual(res, "value can't be converted to Bool")
res = t.StrBool().check(1)
self.assertEqual(res, True)
res = t.StrBool().check(0)
self.assertEqual(res, False)
res = t.StrBool().check('y')
self.assertEqual(res, True)
res = t.StrBool().check('n')
self.assertEqual(res, False)
res = t.StrBool().check(None)
self.assertEqual(res, False)
res = t.StrBool().check('1')
self.assertEqual(res, True)
res = t.StrBool().check('0')
self.assertEqual(res, False)
res = t.StrBool().check('YeS')
self.assertEqual(res, True)
res = t.StrBool().check('No')
self.assertEqual(res, False)
res = t.StrBool().check(True)
self.assertEqual(res, True)
res = t.StrBool().check(False)
self.assertEqual(res, False)
def test_str_bool(self):
res = extract_error(t.StrBool(), "aloha")
self.assertEqual(res, "value can't be converted to Bool")
res = t.StrBool().check(1)
self.assertEqual(res, True)
res = t.StrBool().check(0)
self.assertEqual(res, False)
res = t.StrBool().check("y")
self.assertEqual(res, True)
res = t.StrBool().check("n")
self.assertEqual(res, False)
res = t.StrBool().check(None)
self.assertEqual(res, False)
res = t.StrBool().check("1")
self.assertEqual(res, True)
res = t.StrBool().check("0")
self.assertEqual(res, False)
res = t.StrBool().check("YeS")
self.assertEqual(res, True)
res = t.StrBool().check("No")
self.assertEqual(res, False)
res = t.StrBool().check(True)
self.assertEqual(res, True)
res = t.StrBool().check(False)
self.assertEqual(res, False)
def is_valid(self, validator):
assert validator
try:
self.validated_data = validator.check(self.raw_data)
return True
except trafaret.DataError:
self.errors = trafaret.extract_error(validator, self.raw_data)
return False
def test_float(self):
res = t.Float().check(1.0)
self.assertEqual(res, 1.0)
res = extract_error(t.Float(), 1 + 3j)
self.assertEqual(res, 'value is not float')
res = extract_error(t.Float(), 1)
self.assertEqual(res, 1.0)
res = t.Float(gte=2).check(3.0)
self.assertEqual(res, 3.0)
res = extract_error(t.Float(gte=2), 1.0)
self.assertEqual(res, 'value is less than 2')
res = t.Float(lte=10).check(5.0)
self.assertEqual(res, 5.0)
res = extract_error(t.Float(lte=3), 5.0)
self.assertEqual(res, 'value is greater than 3')
res = t.Float().check("5.0")
self.assertEqual(res, 5.0)
def test_type(self):
res = t.Type(int)
self.assertEqual(repr(res), '<Type(int)>')
c = t.Type[int]
res = c.check(1)
self.assertEqual(res, 1)
res = extract_error(c, "foo")
self.assertEqual(res, 'value is not int')
def test_bool(self):
res = t.Bool().check(True)
self.assertEqual(res, True)
res = t.Bool().check(False)
self.assertEqual(res, False)
err = extract_error(t.Bool(), 1)
self.assertEqual(err, 'value should be True or False')
def test_mongo_id_blank(self):
c = t.MongoId(allow_blank=True)
self.assertEqual(c.check("5583f69d690b2d70a4afdfae"),
ObjectId('5583f69d690b2d70a4afdfae'))
res = extract_error(c, 'just_id')
self.assertEqual(res, "'just_id' is not a valid ObjectId, it must be"
" a 12-byte input or a 24-character hex string")
self.assertIsInstance(c.check(None), ObjectId)
def test_or(self):
nullString = t.Or(t.String, t.Null)
self.assertEqual(repr(nullString), '<Or(<String>, <Null>)>')
res = nullString.check(None)
res = nullString.check("test")
self.assertEqual(res, 'test')
res = extract_error(nullString, 1)
self.assertEqual(res, {0: 'value is not a string', 1: 'value should be None'})
res = t.Or << t.Int << t.String
self.assertEqual(repr(res), '<Or(<Int>, <String>)>')
def test_call(self):
def validator(value):
if value != "foo":
return t.DataError("I want only foo!")
return 'foo'
trafaret = t.Call(validator)
res = trafaret.check("foo")
self.assertEqual(res, 'foo')
err = extract_error(trafaret, "bar")
self.assertEqual(err, 'I want only foo!')
def test_string(self):
res = t.String().check(u"foo")
assert res == u'foo'
res = extract_error(t.String(), u"")
assert res == 'blank value is not allowed'
res = t.String(allow_blank=True).check(u"")
assert res == u''
res = extract_error(t.String(), 1)
assert res == 'value is not a string'
res = t.String(min_length=2, max_length=3).check(u'123')
assert res == u'123'
res = extract_error(t.String(min_length=2, max_length=6), u'1')
assert res == 'String is shorter than 2 characters'
res = extract_error(t.String(min_length=2, max_length=6), u'1234567')
assert res == 'String is longer than 6 characters'
with pytest.raises(AssertionError) as exc_info:
t.String(min_length=2, max_length=6, allow_blank=True)
assert exc_info.value.args[0] == 'Either allow_blank or min_length should be specified, not both'
res = t.String(min_length=0, max_length=6, allow_blank=True).check(u'123')
assert res == u'123'
def test_base(self):
trafaret = t.Dict(foo=t.Int, bar=t.String)
trafaret.check({"foo": 1, "bar": "spam"})
res = t.extract_error(trafaret, {"foo": 1, "bar": 2})
self.assertEqual(res, {'bar': 'value is not a string'})
res = extract_error(trafaret, {"foo": 1})
self.assertEqual(res, {'bar': 'is required'})
res = extract_error(trafaret, {"foo": 1, "bar": "spam", "eggs": None})
self.assertEqual(res, {'eggs': 'eggs is not allowed key'})
res = trafaret.allow_extra("eggs")
self.assertEqual(
repr(res),
'<Dict(extras=(eggs) | <Key "bar" <String>>, <Key "foo" <Int>>)>')
trafaret.check({"foo": 1, "bar": "spam", "eggs": None})
trafaret.check({"foo": 1, "bar": "spam"})
res = extract_error(trafaret, {"foo": 1, "bar": "spam", "ham": 100})
self.assertEqual(res, {'ham': 'ham is not allowed key'})
trafaret.allow_extra("*")
trafaret.check({"foo": 1, "bar": "spam", "ham": 100})
trafaret.check({"foo": 1, "bar": "spam", "ham": 100, "baz": None})
res = extract_error(trafaret, {"foo": 1, "ham": 100, "baz": None})
self.assertEqual(res, {'bar': 'is required'})
def test_or(self):
nullString = t.Or(t.String, t.Null)
self.assertEqual(repr(nullString), '<Or(<String>, <Null>)>')
res = nullString.check(None)
res = nullString.check("test")
self.assertEqual(res, 'test')
res = extract_error(nullString, 1)
self.assertEqual(res, {
0: 'value is not a string',
1: 'value should be None'
})
res = t.Int | t.String
self.assertEqual(repr(res), '<Or(<Int>, <String>)>')
def test_email(self):
res = t.Email().check('*****@*****.**')
self.assertEqual(res, '*****@*****.**')
res = extract_error(t.Email(),
'someone@example') # try without domain-part
self.assertEqual(res, 'value is not a valid email address')
res = str(
t.Email().check('someone@пример.рф')) # try with `idna` encoding
self.assertEqual(res, '[email protected]')
res = (
t.Email() >>
(lambda m: m.groupdict()['domain'])).check('*****@*****.**')
self.assertEqual(res, 'example.net')
res = extract_error(t.Email(), 'foo')
self.assertEqual(res, 'value is not a valid email address')
res = extract_error(t.Email(), 'f' * 10000 + '@correct.domain.edu')
self.assertEqual(res, 'value is not a valid email address')
res = extract_error(t.Email(),
'f' * 248 + '@x.edu') == 'f' * 248 + '@x.edu'
self.assertEqual(res, True)
res = extract_error(t.Email(), 123)
self.assertEqual(res, 'value is not a string')
def test_base3(self):
trafaret = t.Dict({t.Key('bar', default='nyanya') >> 'baz': t.String}, foo=t.Int)
res = trafaret.check({'foo': 4})
self.assertEqual(res, {'baz': 'nyanya', 'foo': 4})
trafaret.allow_extra('*')
res = extract_error(trafaret, {'baz': 'spam', 'foo': 4})
self.assertEqual(res, {'baz': 'baz key was shadowed'})
trafaret.allow_extra('*', trafaret=t.String)
res = extract_error(trafaret, {'baaz': 5, 'foo': 4})
self.assertEqual(res, {'baaz': 'value is not a string'})
res = trafaret({'baaz': 'strstr', 'foo':4})
self.assertEqual(res, {'baaz': 'strstr', 'foo':4, 'baz': 'nyanya'})
trafaret.ignore_extra('fooz')
res = trafaret.check({'foo': 4, 'fooz': 5})
self.assertEqual(res, {'baz': 'nyanya', 'foo': 4})
trafaret.ignore_extra('*')
res = trafaret.check({'foo': 4, 'foor': 5})
self.assertEqual(res, {'baz': 'nyanya', 'foo': 4})
def test_enum_py3(self):
import enum
class Colors(enum.Enum):
red = 0
green = 1
blue = 2
trafaret = t.Enum.from_enum(Colors)
self.assertEqual(repr(trafaret), "<Enum('red', 'green', 'blue')>")
res = trafaret.check('red')
res = trafaret.check('green')
res = extract_error(trafaret, 'unknown')
self.assertEqual(res, "value doesn't match any variant")
with self.assertRaises(TypeError):
trafaret = t.Enum.from_enum('not a enum instance')
def test_type(self):
c = t.Type[int]
res = c.check(1)
assert res == 1
res = extract_error(c, "foo")
assert res == 'value is not int'
def test_call(self):
trafaret = t.Call(self.validator)
res = trafaret.check("foo")
assert res == 'foo'
err = extract_error(trafaret, "bar")
assert err == 'I want only foo!'
def test_extract_error(self):
res = extract_error(t.ToBool(), 'aloha')
assert res == "value can't be converted to Bool"
def test_null(self):
res = t.Null().check(None)
assert res is None
res = extract_error(t.Null(), 1)
assert res == 'value should be None'
def test_extract_error(self):
err = extract_error(t.Bool(), 1)
assert err == 'value should be True or False'
def test_raise_error(self):
other = lambda v: DataError('other error')
fail_other = t.Atom('a') & other
res = extract_error(fail_other, 'a')
self.assertEqual(res, 'other error')
def test_null(self):
res = t.Null()
self.assertEqual(repr(res), '<Null>')
res = t.Null().check(None)
res = extract_error(t.Null(), 1)
self.assertEqual(res, 'value should be None')
def test_enum(self):
trafaret = t.Enum("foo", "bar", 1)
trafaret.check("foo")
trafaret.check(1)
res = extract_error(trafaret, 2)
assert res == "value doesn't match any variant"
def test_key_shadowed(self):
trafaret = t.Dict(t.Key('a', to_name='b', trafaret=t.Int))
res = extract_error(trafaret, {'a': 5, 'b': 7})
assert res == {'b': 'b key was shadowed'}
def test_extract_error(self):
result = t.extract_error(t.ToDecimal(), '')
assert result == 'value can\'t be converted to Decimal'
def test_bad_id(self):
c = MongoId(allow_blank=True)
res = extract_error(c, 123)
assert res == "value is not ObjectId"
assert isinstance(c.check(None), ObjectId)
def test_callable(self):
t.Callable().check(lambda: 1)
res = extract_error(t.Callable(), 1)
assert res == 'value is not callable'
def test_atom(self):
res = t.Atom('atom').check('atom')
assert res == 'atom'
err = extract_error(t.Atom('atom'), 'molecule')
assert err == "value is not exactly 'atom'"
def test_atom(self):
res = t.Atom('atom').check('atom')
self.assertEqual(res, 'atom')
err = extract_error(t.Atom('atom'), 'molecule')
self.assertEqual(err, "value is not exactly 'atom'")
def test_iterable(self):
res = extract_error(t.Iterable(t.ToInt), 1)
assert res == 'value is not iterable'
def test_none_to_decimal(self):
with pytest.raises(TypeError) as err:
t.extract_error(t.ToDecimal(), None)
assert err == 'conversion from NoneType to Decimal is not supported'
def test_extract_error(self):
result = t.extract_error(t.ToInt(), '')
assert result == 'value can\'t be converted to int'
def test_callable(self):
t.Callable().check(lambda: 1)
res = extract_error(t.Callable(), 1)
self.assertEqual(res, 'value is not callable')
def test_atom(self):
res = t.Atom('atom').check('atom')
assert res == 'atom'
err = extract_error(t.Atom('atom'), 'molecule')
assert err == "value doesn't match any variant"
