def test_allow_one_but_find_duplicate(self):
with self.assertRaises(DataError) as cm:
with allow_only(Extra('xxx')):
raise DataError('example error', [Extra('xxx'), Extra('xxx')])
result_string = str(cm.exception)
self.assertEqual("example error:\n xExtra('xxx')", result_string)
def test_allow_duplicate_but_find_only_one(self):
with self.assertRaises(DataError) as cm:
with allow_only([Extra('xxx'), Extra('xxx')]):
raise DataError('example error', [Extra('xxx')])
result_string = str(cm.exception)
self.assertEqual("Allowed difference not found:\n Extra('xxx')", result_string)
def test_allow_all(self):
differences = [Missing('xxx'), Extra('yyy')]
with allow_only(differences):
raise DataError('example error', [Missing('xxx'), Extra('yyy')])
# Order of differences should not matter!
differences = [Extra('yyy'), Missing('xxx')]
with allow_only(differences):
raise DataError('example error', reversed(differences))
def test_allow_some(self):
differences = [Extra('xxx'), Missing('yyy')]
with self.assertRaises(DataError) as cm:
with allow_missing():
raise DataError('example error', differences)
rejected = list(cm.exception.differences)
self.assertEqual(rejected, [Extra('xxx')])
def test_allow_some(self):
with self.assertRaises(DataError) as cm:
with allow_only(Extra('xxx'), 'example allowance'):
raise DataError('example error', [Extra('xxx'), Missing('yyy')])
result_str = str(cm.exception)
self.assertEqual("example allowance: example error:\n Missing('yyy')", result_str)
result_diffs = list(cm.exception.differences)
self.assertEqual([Missing('yyy')], result_diffs)
def test_not_found(self):
with self.assertRaises(DataError) as cm:
with allow_only([Extra('xxx'), Missing('yyy')]):
raise DataError('example error', [Extra('xxx')])
result_str = str(cm.exception)
self.assertTrue(result_str.startswith('Allowed difference not found'))
result_diffs = list(cm.exception.differences)
self.assertEqual([Missing('yyy')], result_diffs)
def test_mapping_some_allowed(self):
differences = {'foo': Extra('xxx'), 'bar': Missing('yyy')}
allowed = {'foo': Extra('xxx')}
with self.assertRaises(DataError) as cm:
with allow_only(allowed):
raise DataError('example error', differences)
expected = {'bar': Missing('yyy')}
actual = cm.exception.differences
self.assertEqual(expected, actual)
def test_single_diff_without_container(self):
differences = [Extra('xxx'), Missing('yyy')]
allowed = Extra('xxx') # <- Single diff, not in list.
with self.assertRaises(DataError) as cm:
with allow_only(allowed):
raise DataError('example error', differences)
expected = [Missing('yyy')]
actual = list(cm.exception.differences)
self.assertEqual(expected, actual)
def test_kwds_under_limit(self):
differences = [Extra('xxx'), Missing('yyy'), Extra('zzz')]
with self.assertRaises(DataError) as cm:
is_extra = lambda x: isinstance(x, Extra)
with allow_limit(4,
diffs=is_extra): # <- Limit of 4 and is_extra().
raise DataError('example error', differences)
rejected = list(cm.exception.differences)
self.assertEqual([Missing('yyy')], rejected)
def test_some_allowed(self):
differences = [Extra('xxx'), Missing('yyy')]
allowed = [Extra('xxx')]
with self.assertRaises(DataError) as cm:
with allow_only(allowed):
raise DataError('example error', differences)
expected = [Missing('yyy')]
actual = list(cm.exception.differences)
self.assertEqual(expected, actual)
def test_function_all_bad(self):
function = lambda iterable: iterable # <- Rejects everything.
in_diffs = [
Extra('foo'),
Extra('bar'),
]
with self.assertRaises(DataError) as cm:
with allow_iter(function, 'example message'):
raise DataError('example error', in_diffs)
rejected = cm.exception.differences
self.assertEqual(rejected, in_diffs)
def test_kwds(self):
in_diffs = [
Extra('xxx', aaa='foo'),
Extra('yyy', aaa='bar'),
Missing('zzz', aaa='foo'),
]
with self.assertRaises(DataError) as cm:
with allow_any('example message', aaa='foo'):
raise DataError('example error', in_diffs)
rejected = list(cm.exception.differences)
self.assertEqual(rejected, [Extra('yyy', aaa='bar')])
def test_no_kwds(self):
in_diffs = [
Extra('xxx', aaa='foo'),
Extra('yyy', aaa='bar'),
]
with self.assertRaises(TypeError) as cm:
with allow_any('example message'): # <- Missing keyword argument!
raise DataError('example error', in_diffs)
result = cm.exception
expected = 'requires 1 or more keyword arguments (0 given)'
self.assertEqual(expected, str(result))
def test_iterable_all_bad(self):
"""Given a non-mapping iterable in which all items are invalid,
*function* should return a non-mapping iterable containing all
items.
"""
function = lambda iterable: iterable # <- Rejects everything.
in_diffs = [Extra('foo'), Extra('bar')]
with self.assertRaises(DataError) as cm:
with allow_iter(function):
raise DataError('example error', in_diffs)
out_diffs = cm.exception.differences
self.assertEqual(out_diffs, in_diffs)
def test_mapping(self):
required = {'AAA': 'a', 'BBB': 'b', 'CCC': 'c'}
data = {'AAA': 'a', 'BBB': 'b', 'CCC': 'c'}
result = _compare_mapping(data, required)
self.assertEqual(result, {})
data = {'AAA': 'a', 'BBB': 'b', 'CCC': 'c', 'DDD': '3'}
result = _compare_mapping(data, required)
self.assertEqual(result, {'DDD': Extra('3')})
data = {'AAA': 'a', 'CCC': 'c', 'DDD': '3'}
result = _compare_mapping(data, required)
self.assertEqual(result, {'BBB': Missing('b'), 'DDD': Extra('3')})
def test_iterable(self):
required = set(['a', 'b', 'c'])
data = iter(['a', 'b', 'c'])
result = _compare_set(data, required)
self.assertEqual(result, [])
data = iter(['a', 'b', 'c', '3'])
result = _compare_set(data, required)
self.assertEqual(result, [Extra('3')])
data = iter(['a', 'c', '3'])
result = _compare_set(data, required)
result = set(result)
self.assertEqual(result, set([Missing('b'), Extra('3')]))
def test_mapping(self):
required = set(['a', 'b', 'c'])
data = {'AAA': 'a', 'BBB': 'b', 'CCC': 'c'}
result = _compare_set(data, required)
self.assertEqual(result, [])
data = {'AAA': 'a', 'BBB': 'b', 'CCC': 'c', 'DDD': '3'}
result = _compare_set(data, required)
self.assertEqual(result, [Extra('3')])
data = {'AAA': 'a', 'CCC': 'c', 'DDD': '3'}
result = _compare_set(data, required)
result = set(result)
self.assertEqual(result, set([Missing('b'), Extra('3')]))
def test_compareset_v_set_fail(self):
with self.assertRaises(DataError) as cm:
first = CompareSet([1, 2, 3, 4, 5, 6, 7])
second = set([1, 2, 3, 4, 5, 6])
self.assertEqual(first, second)
differences = cm.exception.differences
super(DataTestCase, self).assertEqual(differences, [Extra(7)])
def test_required_set(self):
"""When *required* is a set, _compare_set() should be called."""
with self.assertRaises(DataError) as cm:
required = set([1, 2, 4])
data = set([1, 2, 3])
self.assertValid(data, required)
differences = cm.exception.differences
self.assertEqual(set(differences), set([Extra(3), Missing(4)]))
def test_sequence(self):
required = ['a', 'b', 'c']
data = ['a', 'b', 'c']
result = _compare_sequence(data, required)
self.assertEqual(result, {})
data = ['a', 'b', 'c', 'd']
result = _compare_sequence(data, required)
self.assertEqual(result, {3: Extra('d')})
data = ['a', 'b']
result = _compare_sequence(data, required)
self.assertEqual(result, {2: Missing('c')})
data = ['a', 'x', 'c', 'y']
result = _compare_sequence(data, required)
self.assertEqual(result, {1: Invalid('x', 'b'), 3: Extra('y')})
def test_allow_some(self):
differences = [Extra('xxx'), Missing('yyy')]
with self.assertRaises(DataError) as cm:
with allow_limit(1): # <- Allows only 1 but there are 2!
raise DataError('example error', differences)
rejected = list(cm.exception.differences)
self.assertEqual(differences, rejected)
def test_dict_of_diffs_exceeds(self):
differences = {'foo': Extra('xxx'), 'bar': Missing('yyy')}
with self.assertRaises(DataError) as cm:
with allow_limit(1): # <- Allows only 1 but there are 2!
raise DataError('example error', differences)
rejected = cm.exception.differences
self.assertEqual(differences, rejected)
def test_keys_keyword(self):
in_diffs = {
'foo': Extra('xxx'),
'bar': Extra('yyy'),
'baz': Missing('zzz'),
}
with self.assertRaises(DataError) as cm:
def additional_helper(x):
return x in ('foo', 'baz')
with allow_extra(keys=additional_helper):
raise DataError('example error', in_diffs)
rejected = cm.exception.differences
self.assertEqual(rejected, {
'bar': Extra('yyy'),
'baz': Missing('zzz')
})
def test_dict_of_diffs_kwds_func_under_limit(self):
differences = {'foo': Extra('xxx'), 'bar': Missing('yyy')}
with self.assertRaises(DataError) as cm:
is_extra = lambda x: isinstance(x, Extra)
with allow_limit(2, diffs=is_extra):
raise DataError('example error', differences)
rejected = cm.exception.differences
self.assertEqual({'bar': Missing('yyy')}, rejected)
def test_required_mapping(self):
"""When *required* is a mapping, _compare_mapping() should be
called."""
with self.assertRaises(DataError) as cm:
required = {'AAA': 'a', 'BBB': 'b', 'CCC': 'c'}
data = {'AAA': 'a', 'BBB': 'b', 'DDD': 'd'}
self.assertValid(data, required)
differences = cm.exception.differences
self.assertEqual(differences, {'CCC': Missing('c'), 'DDD': Extra('d')})
def test_mapping_mismatched_types(self):
# Dict of diffs vs list of allowed.
differences = {'foo': Extra('xxx'), 'bar': Missing('yyy')}
allowed = [Extra('xxx'), Missing('yyy')]
regex = ("expects non-mapping differences but found 'dict' of "
"differences")
with self.assertRaisesRegex(ValueError, regex):
with allow_only(allowed):
raise DataError('example error', differences)
# List of diffs vs dict of allowed.
differences = [Extra('xxx'), Missing('yyy')]
allowed = {'foo': Extra('xxx'), 'bar': Missing('yyy')}
regex = ("expects mapping of differences but found 'list' of "
"differences")
with self.assertRaisesRegex(ValueError, regex):
with allow_only(allowed):
raise DataError('example error', differences)
def test_extra(self):
data = [('label1', 'label2', 'value'), ('a', 'x', '6'),
('b', 'y', '7')]
self.subject = MinimalSource(data)
with self.assertRaises(DataError) as cm:
required_set = set(['label1', 'value'])
self.assertSubjectColumns(required=required_set) # <- test assert
differences = cm.exception.differences
self.assertEqual(set(differences), set([Extra('label2')]))
def test_keyword_combinations(self):
in_diffs = {
('AAA', 'XXX'): Missing('foo'),
('BBB', 'YYY'): Missing('foo'),
('CCC', 'XXX'): Extra('bar'),
('DDD', 'XXX'): Missing('foo')
}
def fn1(key1, key2):
return key2 == 'XXX'
def fn2(diff):
return diff.value == 'foo'
with self.assertRaises(DataError) as cm:
with allow_any(keys=fn1, diffs=fn2):
raise DataError('example error', in_diffs)
rejected = cm.exception.differences
self.assertEqual(rejected, {
('BBB', 'YYY'): Missing('foo'),
('CCC', 'XXX'): Extra('bar')
})
def test_extra(self):
ref = [
('label1', 'label2'),
('a', 'x'),
('b', 'y'),
#('c', 'z'), <- Intentionally omitted.
]
self.reference = MinimalSource(ref)
with self.assertRaises(DataError) as cm:
self.assertSubjectSet('label1')
differences = cm.exception.differences
self.assertEqual(differences, [Extra('c')])
def test_kwds(self):
diff_set = set([
Missing('xxx', aaa='foo'),
Missing('yyy', aaa='bar'),
Extra('zzz', aaa='foo'),
])
with self.assertRaises(DataError) as cm:
# Allows 2 with aaa='foo' and there are two (only aaa='bar' is rejected).
with allow_limit(2, 'example message', aaa='foo'):
raise DataError('example error', diff_set)
rejected = set(cm.exception.differences)
self.assertEqual(rejected, set([Missing('yyy', aaa='bar')]))
with self.assertRaises(DataError) as cm:
# Allows 1 with aaa='foo' but there are 2 (all are rejected)!
with allow_limit(1, 'example message', aaa='foo'):
raise DataError('example error', diff_set)
rejected = set(cm.exception.differences)
self.assertEqual(rejected, diff_set)
