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"