def test_reraise_builtin_nomessage(self):
thrown = TypeError()
def inner(value):
raise thrown
with self.assertRaises(TypeError) as cm:
validate_structure({'one': 1}, schema={'one': inner})
caught = cm.exception
self.assertIs(caught, thrown)
def test_dont_reraise_builtin_nonstring(self):
thrown = ValueError(1)
def inner(value):
raise thrown
with self.assertRaises(ValueError) as cm:
validate_structure({'three': 3}, schema={'three': inner})
caught = cm.exception
self.assertIs(caught, thrown)
def test_reraise_builtin(self):
thrown = TypeError("message")
def inner(value):
raise thrown
with self.assertRaises(TypeError) as cm:
validate_structure({'two': 2}, schema={'two': inner})
caught = cm.exception
self.assertIsNot(caught, thrown)
self.assertEqual(str(caught), "invalid value for key 'two': message")
def test_dont_reraise_builtin_subclass(self):
class DerivedException(ValueError):
pass
thrown = DerivedException("message")
def inner(value):
raise thrown
with self.assertRaises(ValueError) as cm:
validate_structure({"key": "value"}, schema={"key": inner})
caught = cm.exception
self.assertIs(caught, thrown)
def test_schema_valid(self): # type: () -> None
validator = validate_structure(schema={
'hello': validate_text(),
'count': validate_int(),
})
validator({'hello': u"world", 'count': 2})
def test_schema_missing_key(self): # type: () -> None
validator = validate_structure(schema={
'expected': validate_int(),
})
with self.assertRaises(KeyError):
validator({})
def test_schema_missing_as_none_optional(self): # type: () -> None
validator = validate_structure(schema={
'required':
validate_int(required=False),
},
missing_as_none=True)
validator({})
def test_schema_missing_as_none_required(self): # type: () -> None
validator = validate_structure(schema={
'required': validate_int(),
},
missing_as_none=True)
with self.assertRaises(TypeError):
validator({})
def test_schema_unexpected_key(self): # type: () -> None
validator = validate_structure(schema={
'expected': validate_int(),
})
with self.assertRaises(ValueError):
validator({
'expected': 1,
'unexpected': 2,
})
def test_schema_allow_extra(self): # type: () -> None
validator = validate_structure(schema={
'expected': validate_int(),
},
allow_extra=True)
validator({
'expected': 1,
'unexpected': 2,
})
def test_schema_invalid_value(self): # type: () -> None
validator = validate_structure(schema={
'hello': validate_text(),
'count': validate_int(min_value=0),
})
with self.assertRaises(ValueError):
validator({
'hello': u"world",
'count': -1,
})
def test_schema_invalid_value_type(self):
validator = validate_structure(schema={
'hello': validate_text(),
'count': validate_int(),
})
with self.assertRaises(TypeError):
validator({
'hello': u"world",
'count': "one hundred",
})
def test_repr_2(self): # type: () -> None
validator = validate_structure(allow_extra=True, required=False)
self.assertEqual(
repr(validator),
'validate_structure(allow_extra=True, required=False)',
)
def test_repr_1(self): # type: () -> None
validator = validate_structure(schema={'key': validate_int()})
self.assertEqual(
repr(validator),
'validate_structure(schema={\'key\': validate_int()})',
)
def test_not_required(self): # type: () -> None
validate_structure(None, required=False)
def test_basic_valid(self):
validate_structure({'hello': "world"})
def test_required(self):
with self.assertRaises(TypeError):
validate_structure(None)
def test_basic_valid(self): # type: () -> None
validate_structure({'hello': "world"})
def test_invalid_container_type(self):
with self.assertRaises(TypeError):
validate_structure([])
def test_schema_positional_argument(self): # type: () -> None
def validator(*args):
assert len(args) == 1
validate_structure({"key": "value"}, schema={"key": validator})
