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': xExtra('3')})
data = {'AAA': 'a', 'CCC': 'c', 'DDD': '3'}
result = _compare_mapping(data, required)
self.assertEqual(result, {'BBB': xMissing('b'), 'DDD': xExtra('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, [xExtra('3')])
data = iter(['a', 'c', '3'])
result = _compare_set(data, required)
result = set(result)
self.assertEqual(result, set([xMissing('b'), xExtra('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, [xExtra('3')])
data = {'AAA': 'a', 'CCC': 'c', 'DDD': '3'}
result = _compare_set(data, required)
result = set(result)
self.assertEqual(result, set([xMissing('b'), xExtra('3')]))
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: xExtra('d')})
data = ['a', 'b']
result = _compare_sequence(data, required)
self.assertEqual(result, {2: xMissing('c')})
data = ['a', 'x', 'c', 'y']
result = _compare_sequence(data, required)
self.assertEqual(result, {1: xInvalid('x', 'b'), 3: xExtra('y')})
def test_notfound_comparisons(self):
diff = _xgetdiff('a', _xNOTFOUND)
self.assertEqual(diff, xExtra('a'))
diff = _xgetdiff(_xNOTFOUND, 'b')
self.assertEqual(diff, xMissing('b'))
# For numeric comparisons, _xNOTFOUND behaves like None.
diff = _xgetdiff(5, _xNOTFOUND)
self.assertEqual(diff, xDeviation(+5, None))
diff = _xgetdiff(0, _xNOTFOUND)
self.assertEqual(diff, xDeviation(0, None))
diff = _xgetdiff(_xNOTFOUND, 6)
self.assertEqual(diff, xDeviation(-6, 6)) # <- Assymetric behavior
# (see None vs numeric)!
diff = _xgetdiff(_xNOTFOUND, 0)
self.assertEqual(diff, xDeviation(None, 0))
def assertSubjectUnique(self, columns, msg=None, **kwds_filter):
"""Test that values in column or *columns* of subject are unique.
Any duplicate values are raised as Extra differences.
.. warning::
This method is unoptimized---it performs all operations
in-memory. Avoid using this method on data sets that exceed
available memory.
.. todo::
Optimize for memory usage (see issue #9 in development
repository). Move functionality into compare.py when
preparing for better py.test integration.
"""
if isinstance(columns, str):
get_value = lambda row: row[columns]
elif isinstance(columns, Sequence):
get_value = lambda row: tuple(row[column] for column in columns)
else:
raise TypeError('colums must be str or sequence')
seen_before = set()
extras = set()
for row in self.subject.filter_rows(**kwds_filter):
values =get_value(row)
if values in seen_before:
extras.add(values)
else:
seen_before.add(values)
if extras:
differences = sorted([xExtra(x) for x in extras])
default_msg = 'values in {0!r} are not unique'.format(columns)
self.fail(msg or default_msg, differences)
def test_compare(self):
a = CompareSet(['aaa', 'bbb', 'ddd'])
b = CompareSet(['aaa', 'bbb', 'ccc'])
expected = [xExtra('ddd'), xMissing('ccc')]
self.assertEqual(expected, a.compare(b))
a = CompareSet(['aaa', 'bbb', 'ccc'])
b = CompareSet(['aaa', 'bbb', 'ccc'])
self.assertEqual([], a.compare(b), ('When there is no difference, '
'compare should return an empty '
'list.'))
# Test callable other (all True).
result = a.compare(lambda x: len(x) == 3)
self.assertEqual([], result)
# Test callable other (some False).
result = a.compare(lambda x: x.startswith('b'))
expected = set([xInvalid('aaa'), xInvalid('ccc')])
self.assertEqual(expected, set(result))
# Test callable other, multiple arguments (all True).
a = CompareSet([(1, 1), (1, 2), (2, 1), (2, 2)])
result = a.compare(lambda x, y: x + y > 0)
self.assertEqual([], result)
# Test callable other, using single vararg (all True).
a = CompareSet([(1, 1), (1, 2), (2, 1), (2, 2)])
result = a.compare(lambda *x: x[0] + x[1] > 0)
self.assertEqual([], result)
# Test callable other, multiple arguments (some False).
a = CompareSet([(1, 1), (1, 2), (2, 1), (2, 2)])
result = a.compare(lambda x, y: x != y)
expected = set([xInvalid((1, 1)), xInvalid((2, 2))])
self.assertEqual(expected, set(result))
# Test subset (less-than-or-equal).
a = CompareSet(['aaa', 'bbb', 'ddd'])
b = CompareSet(['aaa', 'bbb', 'ccc'])
expected = [xExtra('ddd')]
self.assertEqual(expected, a.compare(b, op='<='))
# Test strict subset (less-than).
a = CompareSet(['aaa', 'bbb'])
b = CompareSet(['aaa', 'bbb', 'ccc'])
self.assertEqual([], a.compare(b, op='<'))
# Test strict subset (less-than) assertion violation.
a = CompareSet(['aaa', 'bbb', 'ccc'])
b = CompareSet(['aaa', 'bbb', 'ccc'])
self.assertEqual([xNotProperSubset()], a.compare(b, op='<'))
# Test superset (greater-than-or-equal).
a = CompareSet(['aaa', 'bbb', 'ccc'])
b = CompareSet(['aaa', 'bbb', 'ddd'])
expected = [xMissing('ddd')]
self.assertEqual(expected, a.compare(b, op='>='))
# Test superset subset (greater-than).
a = CompareSet(['aaa', 'bbb', 'ccc'])
b = CompareSet(['aaa', 'bbb'])
self.assertEqual([], a.compare(b, op='>'))
# Test superset subset (greater-than) assertion violation.
a = CompareSet(['aaa', 'bbb', 'ccc'])
b = CompareSet(['aaa', 'bbb', 'ccc'])
self.assertEqual([xNotProperSuperset()], a.compare(b, op='>'))
