def test_int_in_list(self):
spec = ListOf(int)
# outer value is missing
with raises_regexp(ValidationError, 'must be list'):
spec(None)
# outer value is present, inner value is missing
with raises_regexp(ValidationError, 'lacks item: must be int'):
spec([])
# outer value is present, inner optional value is missing
relaxed_spec = ListOf(int) | None
relaxed_spec([])
# inner value is present but is None
with raises_regexp(ValidationError, 'item #0: must be int'):
spec([None])
# inner value is present
spec([123])
# multiple inner values are present
spec([123, 456])
# one of the inner values is of a wrong type
with raises_regexp(ValidationError, 'item #1: must be int'):
spec([123, 'bogus'])
def test_translate_list():
assert translate(list) == IsA(list)
assert translate([]) == IsA(list)
assert translate([int]) == ListOf(IsA(int))
assert translate([1]) == ListOf(IsA(int, default=1))
with raises_regexp(StructureSpecificationError,
'Expected a list containing exactly 1 item; '
'got 3: \[1, 2, 3\]'):
translate([1, 2, 3])
def test_merge_list_with_oneof(self):
"Non-rule node in list's inner spec"
# TODO: refactor and reformulate.
# This test was written for older implementation of Monk.
int_spec = IsA(int, default=123)
str_spec = IsA(str, default='foo')
# no defaults
#rule = Rule(datatype=list, inner_spec=OneOf([123, 456]))
item_spec = Any([int_spec, str_spec])
rule = ListOf(item_spec)
assert rule.get_default_for([]) == []
assert rule.get_default_for([789]) == [789]
# with defaults
# (same results because defaults have no effect on lists)
#rule = Rule(datatype=list,
# inner_spec=OneOf([123, 456], first_is_default=True))
item_spec = Any([int_spec, str_spec], first_is_default=True)
rule = ListOf(item_spec)
assert rule.get_default_for([]) == []
assert rule.get_default_for([789]) == [789]
def test_schemed_dict_in_list(self):
spec = ListOf({'foo': int})
# dict in list: missing key
with raises(ValidationError):
spec([{}])
with raises_regexp(ValidationError, "item #1: must have keys: 'foo'"):
spec([{'foo': 123}, {}])
# dict in list: missing value
with raises_regexp(ValidationError,
"item #0: 'foo' value must be int"):
spec([{'foo': None}])
with raises_regexp(ValidationError,
"item #1: 'foo' value must be int"):
spec([{'foo': 123}, {'foo': None}])
# multiple innermost values are present
spec([{'foo': 123}])
spec([{'foo': 123}, {'foo': 456}])
# one of the innermost values is of a wrong type
with raises_regexp(ValidationError,
"item #2: 'foo' value must be int"):
spec([{'foo': 123}, {'foo': 456}, {'foo': 'bogus'}])
def test_magic_eq():
assert IsA(str) == IsA(str)
assert IsA(str) != IsA(str, default='foo')
assert IsA(str) != IsA(int)
assert IsA(str) != Equals(int)
# nested
v1 = ListOf([DictOf([ (Equals('foo'), IsA(str)) ])])
v2 = ListOf([DictOf([ (Equals('foo'), IsA(str)) ])])
v3 = ListOf([DictOf([ (Equals('bar'), IsA(str)) ])])
v4 = ListOf([DictOf([ (Equals('foo'), IsA(int)) ])])
v5 = ListOf([DictOf([ (Equals('foo'), IsA(str, default='x')) ])])
assert v1 == v1
assert v1 == v2
assert v1 != v3
assert v1 != v4
assert v1 != v5
def test_regression_22():
~Anything()
~IsA(str)
~Equals(5)
~Contains('x')
~InRange(5)
~Length(5)
~ListOf(str)
~DictOf([])
~Exists()
def test_merge_list_with_oneof(self):
"Non-rule node in list's inner spec"
# TODO: refactor and reformulate.
# This test was written for older implementation of Monk.
int_spec = IsA(int, default=123)
str_spec = IsA(str, default="foo")
# no defaults
# rule = Rule(datatype=list, inner_spec=OneOf([123, 456]))
item_spec = Any([int_spec, str_spec])
rule = ListOf(item_spec)
assert rule.get_default_for([]) == []
assert rule.get_default_for([789]) == [789]
# with defaults
# (same results because defaults have no effect on lists)
# rule = Rule(datatype=list,
# inner_spec=OneOf([123, 456], first_is_default=True))
item_spec = Any([int_spec, str_spec], first_is_default=True)
rule = ListOf(item_spec)
assert rule.get_default_for([]) == []
assert rule.get_default_for([789]) == [789]
def test_freeform_dict_in_list(self):
spec = ListOf(dict)
# inner value is present
spec([{}])
spec([{'foo': 123}])
# multiple inner values are present
spec([{'foo': 123}, {'bar': 456}])
# one of the inner values is of a wrong type
with raises_regexp(ValidationError, 'item #1: must be dict'):
spec([{}, 'bogus'])
def test_merge_list(self):
## present but empty inner spec (optional)
rule = ListOf([]) | Equals(None)
# optional missing list
assert rule.get_default_for(None) == None
## present but empty inner spec (required)
rule = ListOf([])
# required missing list → empty list
assert rule.get_default_for(None) == []
## present non-empty inner spec (optional)
rule = ListOf(IsA(int, default=123)) | Equals(None)
# optional missing list with required item(s)
assert rule.get_default_for(None) == None
# optional empty list with required item(s)
assert rule.get_default_for([]) == []
## present non-empty inner spec (optional)
elem_spec = IsA(int, default=123) | Equals(None)
rule = ListOf(elem_spec) | Equals(None)
# optional missing list with optional item(s)
assert rule.get_default_for(None) == None
# optional empty list with optional item
assert rule.get_default_for([]) == []
## present non-empty inner spec (required)
rule = ListOf(IsA(int, default=123))
# required missing list → inner spec
assert rule.get_default_for(None) == []
# required empty list → inner spec
assert rule.get_default_for([]) == []
# required non-empty list → inner spec
# fallback = lambda s, v, **kw: v
assert rule.get_default_for([None]) == [None]
assert rule.get_default_for([456]) == [456]
## present inner spec with empty item spec
rule = ListOf(Anything())
assert rule.get_default_for([456]) == [456]
## present inner spec with item spec that has an inner spec
# rule = Rule(datatype=list, inner_spec=[123])
rule = ListOf(ListOf(IsA(int, default=123)))
# XXX CHANGED WTF was it before!?
##assert rule.get_default_for([None]) == [123]
# assert rule.get_default_for([[]]) == [[123]]
# bogus value; will not pass validation but should be preserved
assert rule.get_default_for(123) == 123
def test_merge_list(self):
## present but empty inner spec (optional)
rule = ListOf([]) | Equals(None)
# optional missing list
assert rule.get_default_for(None) == None
## present but empty inner spec (required)
rule = ListOf([])
# required missing list → empty list
assert rule.get_default_for(None) == []
## present non-empty inner spec (optional)
rule = ListOf(IsA(int, default=123)) | Equals(None)
# optional missing list with required item(s)
assert rule.get_default_for(None) == None
# optional empty list with required item(s)
assert rule.get_default_for([]) == []
## present non-empty inner spec (optional)
elem_spec = IsA(int, default=123) | Equals(None)
rule = ListOf(elem_spec) | Equals(None)
# optional missing list with optional item(s)
assert rule.get_default_for(None) == None
# optional empty list with optional item
assert rule.get_default_for([]) == []
## present non-empty inner spec (required)
rule = ListOf(IsA(int, default=123))
# required missing list → inner spec
assert rule.get_default_for(None) == []
# required empty list → inner spec
assert rule.get_default_for([]) == []
# required non-empty list → inner spec
# fallback = lambda s, v, **kw: v
assert rule.get_default_for([None]) == [None]
assert rule.get_default_for([456]) == [456]
## present inner spec with empty item spec
rule = ListOf(Anything())
assert rule.get_default_for([456]) == [456]
## present inner spec with item spec that has an inner spec
#rule = Rule(datatype=list, inner_spec=[123])
rule = ListOf(ListOf(IsA(int, default=123)))
# XXX CHANGED WTF was it before!?
##assert rule.get_default_for([None]) == [123]
#assert rule.get_default_for([[]]) == [[123]]
# bogus value; will not pass validation but should be preserved
assert rule.get_default_for(123) == 123
