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')