def test_multiargument_callable(self):
"""Should unpack arguments if callable expects multiple
parameters.
"""
data = set([(5, 2), (1, 4), (10, 8)])
required = lambda x, y: x > y # <- Multiple positional parameters.
result = _compare_other(data, required)
self.assertEqual(result, [xInvalid((1, 4))])
required = lambda *z: z[0] > z[1] # <- Variable parameters.
result = _compare_other(data, required)
self.assertEqual(result, [xInvalid((1, 4))])
required = lambda a: a[0] > a[1] # <- Single parameter.
result = _compare_other(data, required)
self.assertEqual(result, [xInvalid((1, 4))])
data = [[], [], []]
required = lambda x, y: x > y # <- Multiple positional params.
with self.assertRaisesRegex(TypeError, 'missing 2|0 given'):
_compare_other(data, required)
data = (5, 2)
required = lambda x, y: x > y # <- Multiple positional params.
with self.assertRaisesRegex(TypeError, 'missing 1|1 given'):
_compare_other(data, required)
data = set([(5, 2), (1, 4), (10, 8)]) # Args and params match
def required(x, y): # but function raises
raise TypeError('other error') # some other TypeError.
with self.assertRaisesRegex(TypeError, 'other error'):
_compare_other(data, required)
def test_expected_handling(self):
item = xInvalid('foo', 'FOO')
self.assertEqual("xInvalid('foo', 'FOO')", repr(item))
# QUESTION: How should kwds be handled if keys match item or expected?
with self.assertRaises(TypeError):
item = xInvalid('foo', 'FOO', required='bar')
def test_repr(self):
item = xInvalid('foo')
self.assertEqual("xInvalid('foo')", repr(item))
item = xInvalid(None)
self.assertEqual("xInvalid(None)", repr(item))
item = xInvalid(2)
self.assertEqual("xInvalid(2)", repr(item))
def test_compare_mixed_types(self):
a = CompareDict({'aaa': 2, 'bbb': 3, 'ccc': 'z'}, 'foo')
b = CompareDict({'aaa': 'y', 'bbb': 4.0, 'ccc': 5}, 'foo')
expected = set([
xInvalid(2, 'y', foo='aaa'),
xDeviation(-1, 4, foo='bbb'),
xInvalid('z', 5, foo='ccc'),
])
self.assertEqual(expected, set(a.compare(b)))
def test_same(self):
"""The _xgetdiff() function returns differences for objects that
are KNOWN TO BE DIFFERENT--it does not test for differences
itself.
"""
diff = _xgetdiff('a', 'a')
self.assertEqual(diff, xInvalid('a', 'a'))
diff = _xgetdiff(None, None)
self.assertEqual(diff, xInvalid(None, None))
def test_str_or_noniterable(self):
isalpha = lambda x: x.isalpha()
data = 'ABCD'
result = _compare_other(data, isalpha)
self.assertEqual(result, [])
data = '!@#$'
result = _compare_other(data, isalpha)
self.assertEqual(result, [xInvalid('!@#$')])
data = 5
required = lambda x: 10 < x
result = _compare_other(data, required)
self.assertEqual(result, [xInvalid(5)])
def test_error_condition(self):
"""If callable raises an Exception, the result is counted as
False.
"""
isalpha = lambda x: x.isalpha() # Raises TypeError if given
# a non-string value.
data = set(['a', 'b', 3, '4']) # <- Value 3 raises an error.
result = _compare_other(data, isalpha)
expected = [xInvalid(3), xInvalid('4')]
self.assertEqual(set(result), set(expected))
data = 10
result = _compare_other(data, isalpha)
self.assertEqual(result, [xInvalid(data)])
def test_is_common(self):
"""If requirement is common it should be omitted from xInvalid
difference (but not from xDeviation differences).
"""
diff = _xgetdiff('a', 6, is_common=True)
self.assertEqual(diff, xInvalid('a'))
diff = _xgetdiff(_xNOTFOUND, 6, is_common=True)
self.assertEqual(diff, xDeviation(-6, 6))
def test_keywords(self):
"""Keywords should be passed to diff objet."""
diff = _xgetdiff(5, 6, col1='AAA')
self.assertEqual(diff, xDeviation(-1, 6, col1='AAA'))
diff = _xgetdiff('a', 6, col1='AAA')
self.assertEqual(diff, xInvalid('a', 6, col1='AAA'))
diff = _xgetdiff(_xNOTFOUND, 6, col1='AAA')
self.assertEqual(diff, xDeviation(-6, 6, col1='AAA'))
def test_sequence(self):
isalpha = lambda x: x.isalpha()
data = ['a', 'b', 'c']
result = _compare_other(data, isalpha)
self.assertEqual(result, {})
data = ['a', 'b', 'c', '9']
result = _compare_other(data, isalpha)
self.assertEqual(result, {3: xInvalid('9')})
def test_mapping(self):
isalpha = lambda x: x.isalpha()
data = {'AAA': 'a', 'BBB': 'b', 'CCC': 'c'}
result = _compare_other(data, isalpha)
self.assertEqual(result, {})
data = {'AAA': 'a', 'BBB': 'b', 'CCC': 'c', 'DDD': '3'}
result = _compare_other(data, isalpha)
self.assertEqual(result, {'DDD': xInvalid('3')})
def test_set(self):
isalpha = lambda x: x.isalpha()
data = set(['a', 'b', 'c'])
result = _compare_other(data, isalpha)
self.assertEqual(result, [])
data = set(['a', 'b', 'c', '3'])
result = _compare_other(data, isalpha)
self.assertEqual(result, [xInvalid('3')])
def test_iterable(self):
isalpha = lambda x: x.isalpha()
data = iter(['a', 'b', 'c'])
result = _compare_other(data, isalpha)
self.assertEqual(result, [])
data = iter(['a', 'b', 'c', '9'])
result = _compare_other(data, isalpha)
self.assertEqual(result, [xInvalid('9')])
def test_compare_function(self):
a = CompareDict({'aaa': 'x', 'bbb': 'y', 'ccc': 'z'}, 'foo')
# All True.
result = a.compare(lambda x: len(x) == 1)
self.assertEqual([], result)
# Some False.
result = a.compare(lambda a: a in ('x', 'y'))
expected = [xInvalid('z', foo='ccc')]
self.assertEqual(expected, result)
# All True, multiple args.
a = CompareDict({'aaa': (1, 2), 'bbb': (1, 3), 'ccc': (4, 8)}, 'foo')
result = a.compare(lambda x, y: x < y)
self.assertEqual([], result)
# Some False, multiple args.
a = CompareDict({'aaa': (1, 0), 'bbb': (1, 3), 'ccc': (3, 2)}, 'foo')
result = a.compare(lambda x, y: x < y)
expected = [xInvalid((1, 0), foo='aaa'), xInvalid((3, 2), foo='ccc')]
self.assertEqual(expected, result)
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_object_vs_object(self):
"""Non-numeric comparisons return xInvalid type."""
diff = _xgetdiff('a', 'b')
self.assertEqual(diff, xInvalid('a', 'b'))
diff = _xgetdiff(5, 'b')
self.assertEqual(diff, xInvalid(5, 'b'))
diff = _xgetdiff('a', 6)
self.assertEqual(diff, xInvalid('a', 6))
diff = _xgetdiff(float('nan'), 6)
self.assertEqual(diff, xInvalid(float('nan'), 6))
diff = _xgetdiff(5, float('nan'))
self.assertEqual(diff, xInvalid(5, float('nan')))
fn = lambda x: True
diff = _xgetdiff('a', fn)
self.assertEqual(diff, xInvalid('a', fn))
regex = re.compile('^test$')
diff = _xgetdiff('a', regex)
self.assertEqual(diff, xInvalid('a', re.compile('^test$')))
def test_compare_strings(self):
a = CompareDict({'aaa': 'x', 'bbb': 'y', 'ccc': 'z'}, 'foo')
b = CompareDict({'aaa': 'x', 'bbb': 'z', 'ccc': 'z'}, 'foo')
expected = [xInvalid('y', 'z', foo='bbb')]
self.assertEqual(expected, a.compare(b))
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='>'))
def test_required_string(self):
data = set(['AAA', 'BBB'])
string_val = 'AAA'
result = _compare_other(data, string_val)
self.assertEqual(result, [xInvalid('BBB')])
def test_required_regex(self):
data = set(['a1', 'b2', 'c3', 'd', 'e5'])
regex = re.compile('[a-z][0-9]+')
result = _compare_other(data, regex)
self.assertEqual(result, [xInvalid('d')])
def test_instantiation(self):
xInvalid('foo')
xInvalid('foo', expected='FOO')
