def test_exit_context(self):
"""The __exit__() method should re-raise exceptions that are
not allowed and it should return True when there are no errors
or if all differences have been allowed (see PEP 343 for
context manager protocol).
"""
try:
raise ValidationError([Missing('A'), Extra('B')], 'error description')
except ValidationError:
type, value, traceback = sys.exc_info() # Get exception info.
with self.assertRaises(ValidationError) as cm:
allowance = MinimalAllowance('allowance message')
allowance.__exit__(type, value, traceback)
description = cm.exception.description
self.assertEqual(description, 'allowance message: error description')
# Test with no error description.
try:
raise ValidationError([Missing('A'), Extra('B')]) # <- No description.
except ValidationError:
type, value, traceback = sys.exc_info() # Get exception info.
with self.assertRaises(ValidationError) as cm:
allowance = MinimalAllowance('allowance message')
allowance.__exit__(type, value, traceback)
description = cm.exception.description
self.assertEqual(description, 'allowance message')
def test_dict_with_predicates(self):
"""Ellipsis wildcard key matches all, treats as a single group."""
differences = {
'foo': Extra('xxx'),
'bar': [Extra('yyy'), Missing('yyy')],
'baz': [Extra('zzz'), Missing('zzz')],
}
allowed = {
lambda x: x.startswith('ba'): [
Extra('yyy'),
Extra('zzz'),
],
}
with self.assertRaises(ValidationError) as cm:
with allowed_specific(allowed):
raise ValidationError(differences)
actual = cm.exception.differences
expected = {
'foo': Extra('xxx'),
'bar': Missing('yyy'),
'baz': Missing('zzz'),
}
self.assertEqual(actual, expected)
def test_some_differences(self):
# Sequence order.
data = {'a': ['x', 'y']}
result = _apply_mapping_requirement(data, {'a': ['x', 'z']})
result = dict(result)
self.assertTrue(len(result) == 1)
self.assertEqual(result, {'a': {(1, 2): [Invalid('y', 'z')]}})
# Set membership.
data = {'a': ['x', 'x'], 'b': ['x', 'y', 'z']}
result = _apply_mapping_requirement(data, {
'a': set(['x', 'y']),
'b': set(['x', 'y'])
})
expected = {'a': [Missing('y')], 'b': [Extra('z')]}
self.assertEqual(dict(result), expected)
# Equality of single values.
data = {'a': 'x', 'b': 10}
result = _apply_mapping_requirement(data, {'a': 'j', 'b': 9})
expected = {'a': Invalid('x', expected='j'), 'b': Deviation(+1, 9)}
self.assertEqual(dict(result), expected)
# Equality of multiple values.
data = {'a': ['x', 'j'], 'b': [10, 9]}
result = _apply_mapping_requirement(data, {'a': 'j', 'b': 9})
expected = {'a': [Invalid('x')], 'b': [Deviation(+1, 9)]}
self.assertEqual(dict(result), expected)
# Equality of single tuples.
data = {'a': (1, 'x'), 'b': (9, 10)}
result = _apply_mapping_requirement(data, {'a': (1, 'j'), 'b': (9, 9)})
expected = {
'a': Invalid((1, 'x'), expected=(1, 'j')),
'b': Invalid((9, 10), expected=(9, 9))
}
self.assertEqual(dict(result), expected)
# Equality of multiple tuples.
data = {'a': [(1, 'j'), (1, 'x')], 'b': [(9, 9), (9, 10)]}
result = _apply_mapping_requirement(data, {'a': (1, 'j'), 'b': (9, 9)})
expected = {'a': [Invalid((1, 'x'))], 'b': [Invalid((9, 10))]}
self.assertEqual(dict(result), expected)
# Equality of multiple values, missing key with single item.
data = {'a': ['x', 'j'], 'b': [10, 9]}
result = _apply_mapping_requirement(data, {'a': 'j', 'b': 9, 'c': 'z'})
expected = {
'a': [Invalid('x')],
'b': [Deviation(+1, 9)],
'c': Missing('z')
}
self.assertEqual(dict(result), expected)
# Missing key, set membership.
data = {'a': 'x'}
result = _apply_mapping_requirement(data, {'a': 'x', 'b': set(['z'])})
expected = {'b': [Missing('z')]}
self.assertEqual(dict(result), expected)
def test_accepted_missing(self):
differences = [Missing('X'), Missing('Y'), Extra('X')]
with self.assertRaises(ValidationError) as cm:
with AcceptedDifferences(Missing): # <- Apply acceptance!
raise ValidationError(differences)
remaining_diffs = cm.exception.differences
self.assertEqual(list(remaining_diffs), [Extra('X')])
def test_mapping_vs_difference(self):
differences = {
'a': [Missing('X')],
'b': [Missing('Y'), Missing('X')],
}
acceptance = AcceptedDifferences(Missing('X'))
expected = {'b': Missing('Y')}
self.assertAcceptance(differences, acceptance, expected)
def test_string_or_noniterable(self):
data = 'a'
result = _require_set(data, self.requirement)
result = list(result)
self.assertEqual(len(result), 2)
self.assertIn(Missing('b'), result)
self.assertIn(Missing('c'), result)
def test_missing(self):
diff = Missing('foo')
with self.assertRaises(AttributeError):
diff.attr = ('bar', )
with self.assertRaises(AttributeError):
diff.new_attribute = 'baz'
def test_allowed_extra(self):
differences = [Extra('X'), Extra('Y'), Missing('X')]
with self.assertRaises(ValidationError) as cm:
with allowed_extra(): # <- Apply allowance!
raise ValidationError(differences)
remaining_diffs = cm.exception.differences
self.assertEqual(list(remaining_diffs), [Missing('X')])
def test_missing(self):
data = ['bbb', 'eee']
requirement = ['aaa', 'bbb', 'ccc', 'ddd', 'eee']
error = _require_sequence(data, requirement)
expected = {
(0, 0): [Missing('aaa')],
(1, 1): [Missing('ccc'), Missing('ddd')],
}
self.assertEqual(error, expected)
def test_difference_vs_type(self):
differences = Missing('X')
acceptance = AcceptedDifferences(Extra)
expected = [Missing('X')]
self.assertAcceptance(differences, acceptance, expected)
differences = Missing('X')
acceptance = AcceptedDifferences(Missing)
with acceptance: # <- No error, all diffs accepted
raise ValidationError(differences)
def test_composite_key(self):
with self.assertRaises(ValidationError) as cm:
with allowed_keys(('a', 7)): # <- Allow using tuple!
raise ValidationError({
('a', 7): Missing(1),
('b', 7): Missing(2)
})
remaining_diffs = cm.exception.differences
self.assertEqual(dict(remaining_diffs), {('b', 7): Missing(2)})
def test_allow_string(self):
with self.assertRaises(ValidationError) as cm:
with allowed_keys('aaa'): # <- Allow by string!
raise ValidationError({
'aaa': Missing(1),
'bbb': Missing(2),
})
remaining_diffs = cm.exception.differences
self.assertEqual(dict(remaining_diffs), {'bbb': Missing(2)})
def test_list_and_list(self):
differences = [Extra('xxx'), Missing('yyy')]
allowed = [Extra('xxx')]
expected = [Missing('yyy')]
with self.assertRaises(ValidationError) as cm:
with allowed_specific(allowed):
raise ValidationError(differences)
actual = list(cm.exception.differences)
self.assertEqual(actual, expected)
def test_get_deviation_expected_missing(self):
func = AcceptedTolerance._get_deviation_expected
self.assertEqual(func(Missing(2)), (-2, 2))
self.assertEqual(func(Missing(-2)), (2, -2))
self.assertEqual(func(Missing(0)), (0, 0))
with self.assertRaises(TypeError):
func(Missing((1, 2)))
with self.assertRaises(TypeError):
func(Missing('abc'))
def test_list_and_diff(self):
differences = [Extra('xxx'), Missing('yyy')]
allowed = Extra('xxx') # <- Single diff, not in a container.
with self.assertRaises(ValidationError) as cm:
with allowed_specific(allowed):
raise ValidationError(differences)
actual = list(cm.exception.differences)
expected = [Missing('yyy')]
self.assertEqual(actual, expected)
def test_dict_and_dict(self):
differences = {'foo': Extra('xxx'), 'bar': [Extra('xxx'), Missing('yyy')]}
allowed = {'bar': Extra('xxx')}
with self.assertRaises(ValidationError) as cm:
with allowed_specific(allowed):
raise ValidationError(differences)
actual = cm.exception.differences
expected = {'foo': Extra('xxx'), 'bar': Missing('yyy')}
self.assertEqual(actual, expected)
def test_nonmapping_container(self):
"""When differences container is not a mapping, the keys that
allowed_key() sees are all None.
"""
with self.assertRaises(ValidationError) as cm:
with allowed_keys('foo'): # <- Allow keys that equal 'foo'.
differences = [Missing(1), Extra(2)] # <- List has no keys!
raise ValidationError(differences)
remaining_diffs = cm.exception.differences
self.assertEqual(list(remaining_diffs), [Missing(1), Extra(2)])
def test_string_predicate(self):
with self.assertRaises(ValidationError) as cm:
with allowed_args('bbb'): # <- Allowance!
raise ValidationError([
Missing('aaa'),
Missing('bbb'),
Extra('bbb'),
])
remaining_diffs = cm.exception.differences
self.assertEqual(list(remaining_diffs), [Missing('aaa')])
def test_dict_and_list(self):
"""List of allowed differences applied to each group separately."""
differences = {'foo': Extra('xxx'), 'bar': [Extra('xxx'), Missing('yyy')]}
allowed = [Extra('xxx')]
with self.assertRaises(ValidationError) as cm:
with allowed_specific(allowed):
raise ValidationError(differences)
actual = cm.exception.differences
expected = {'bar': Missing('yyy')}
self.assertEqual(actual, expected)
def test_scope(self):
with self.assertRaises(ValidationError) as cm:
with AcceptedCount(2, scope='group'): # <- Accepts 2 per group.
raise ValidationError({
'foo': [Extra('xxx'), Extra('yyy')],
'bar': [Missing('xxx'), Missing('yyy')],
'baz': [Invalid('xxx'),
Invalid('yyy'),
Invalid('zzz')],
})
remaining = cm.exception.differences
self.assertEqual(remaining, {'baz': Invalid('zzz')})
def test_allow_function(self):
with self.assertRaises(ValidationError) as cm:
def function(key):
return key == 'aaa'
with allowed_keys(function): # <- Allow by function!
raise ValidationError({
'aaa': Missing(1),
'bbb': Missing(2),
})
remaining_diffs = cm.exception.differences
self.assertEqual(dict(remaining_diffs), {'bbb': Missing(2)})
def test_over_limit(self):
with self.assertRaises(ValidationError) as cm:
with allowed_limit(1): # <- Allows 1 but there are 2.
raise ValidationError([Extra('xxx'), Missing('yyy')])
remaining = list(cm.exception.differences)
self.assertEqual(remaining, [Missing('yyy')])
with self.assertRaises(ValidationError) as cm:
with allowed_limit(1): # <- Allows 1 and there are 2.
raise ValidationError({'foo': Extra('xxx'), 'bar': Missing('yyy')})
remaining = cm.exception.differences
self.assertIsInstance(remaining, collections.Mapping)
self.assertEqual(len(remaining), 1)
def test_UnionedAllowance(self):
original_diffs = [Missing('a'), Extra('a'), Missing('b'), Extra('b')]
with self.assertRaises(ValidationError) as cm:
with UnionedAllowance(self.allowed_missing, self.allowed_letter_a):
raise ValidationError(original_diffs)
differences = cm.exception.differences
self.assertEqual(list(differences), [Extra('b')])
# Test with allowances in reverse-order (should give same result).
with self.assertRaises(ValidationError) as cm:
with UnionedAllowance(self.allowed_letter_a, self.allowed_missing):
raise ValidationError(original_diffs)
differences = cm.exception.differences
self.assertEqual(list(differences), [Extra('b')])
def test_combination_of_cases(self):
"""This is a bit of an integration test."""
differences = {
'foo': [Extra('xxx'), Missing('yyy')],
'bar': [Extra('xxx')],
'baz': [Extra('xxx'), Missing('yyy'), Extra('zzz')],
}
#allowed = {Ellipsis: [Extra('xxx'), Missing('yyy')]}
allowed = [Extra('xxx'), Missing('yyy')]
with self.assertRaises(ValidationError) as cm:
with allowed_specific(allowed):
raise ValidationError(differences)
actual = cm.exception.differences
self.assertEqual(actual, {'baz': Extra('zzz')})
def test_dict_global_wildcard_predicate(self):
"""Ellipsis wildcard key matches all, treats as a single group."""
differences = {'foo': Extra('xxx'), 'bar': [Extra('xxx'), Missing('yyy')]}
allowed = {Ellipsis: Extra('xxx')}
with self.assertRaises(ValidationError) as cm:
with allowed_specific(allowed):
raise ValidationError(differences)
actual = cm.exception.differences
# Actual result can vary with unordered dictionaries.
if len(actual) == 1:
expected = {'bar': [Extra('xxx'), Missing('yyy')]}
else:
expected = {'foo': Extra('xxx'), 'bar': Missing('yyy')}
self.assertEqual(actual, expected)
def test_required_mapping(self):
with self.assertRaises(ValidationError) as cm:
data = {'AAA': 'a', 'BBB': 'x'}
required = {'AAA': 'a', 'BBB': 'b', 'CCC': 'c'}
self.assertValid(data, required)
differences = cm.exception.differences
self.assertEqual(differences, {'BBB': Invalid('x', 'b'), 'CCC': Missing('c')})
def test_nonmapping(self):
with self.assertRaises(ValidationError) as cm:
data = set([1, 2, 3])
required = set([1, 2, 4])
self.assertValid(data, required)
differences = cm.exception.differences
self.assertEqual(differences, [Missing(4), Extra(3)])
def test_data_mapping(self):
with self.assertRaises(ValidationError) as cm:
data = {'a': set([1, 2]), 'b': set([1]), 'c': set([1, 2, 3])}
required = set([1, 2])
self.assertValid(data, required)
differences = cm.exception.differences
self.assertEqual(differences, {'b': [Missing(2)], 'c': [Extra(3)]})
def test_missing_and_extra(self):
data = iter(['a', 'c', 'x'])
result = _require_set(data, self.requirement)
result = list(result)
self.assertEqual(len(result), 2)
self.assertIn(Missing('b'), result)
self.assertIn(Extra('x'), result)
def test_nonmapping(self):
"""When neither *data* or *requirement* are mappings."""
result = _get_invalid_info(set(['x', 'y']), set(['x', 'y']))
self.assertIsNone(result)
msg, diffs = _get_invalid_info(set(['x']), set(['x', 'y']))
self.assertTrue(exhaustible(diffs))
self.assertEqual(list(diffs), [Missing('y')])
