def test_named_comparator():
comparators = DeepDelta(DEFAULT_DELTA_CONFIG
^ DeltaConfig.ValueCaseIgnored)
compare_p = lambda l, r, p: DeepDelta.convert_to_compare(
l, r, comparators, lambda n, case_ignored: 'no' in n)
named = {
'Id':
lambda l, r, p: None if l == r or l + r == 0 else (l, r),
'products':
compare_p,
'Purchased':
lambda l, r, p: None
if Comparator.compare_as_datetime_values(l, r) else (l, r)
}
order1 = {'id': 100, 'purchased': '2020 Aug 6', 'products': products1}
order2 = {'ID': -100, 'PURCHASED': '6/Aug/2020', 'PRODUCTS': products2}
delta = DeepDelta.compare(order1, order2, None, None, named)
assert delta == {
'products': {
'1202': {
'description': ('Subway', 'SUBWAY')
},
'2009': {
'description': ('Hochy', 'Hochey'),
'name': ('wipes', 'Wipes')
},
'5001': {
'unit': ('per', 'piece')
}
}
}
def test_none_unequal_default():
default_dict = {
'int': 0,
'str': '',
'float': 0.0,
'bool': False,
'list': [],
'set': set(),
'dict': {}
}
none_dict = {
'int': None,
'str': None,
'float': None,
'bool': None,
'list': None,
'set': None,
'dict': None
}
delta = DeepDelta.compare(default_dict, none_dict)
assert len(delta) == 0
delta = DeepDelta.compare(default_dict, none_dict,
DeltaConfig.NoneUnequalDefault)
pprint(delta)
assert len(delta) == len(default_dict)
delta = DeepDelta.compare(none_dict, default_dict,
DeltaConfig.NoneUnequalDefault)
pprint(delta)
assert len(delta) == len(default_dict)
def test_convert_to_compare():
delta = DeepDelta.convert_to_compare(
products1, products2, None, lambda name, case_ignored: 'no' in name)
assert delta == {
'2009': {
'description': ('Hochy', 'Hochey')
},
'5001': {
'unit': ('per', 'piece')
}
}
comparators = DeepDelta(DEFAULT_DELTA_CONFIG
^ DeltaConfig.ValueCaseIgnored)
delta = DeepDelta.convert_to_compare(
products1, products2, comparators,
lambda name, case_ignored: 'no' in name)
assert delta == {
'1202': {
'description': ('Subway', 'SUBWAY')
},
'2009': {
'description': ('Hochy', 'Hochey'),
'name': ('wipes', 'Wipes')
},
'5001': {
'unit': ('per', 'piece')
}
}
def test_compare_with_default_settings():
result = DeepDelta.compare(shopping_list, basket,
DeltaConfig.KeyCaseIgnored)
pprint(result)
assert set(result['0'].keys()) == {'brand', 'name', 'price'} and set(
result['1'].keys()) == {'name', 'expired'}
result = DeepDelta.compare(shopping_list, basket, DeltaConfig.CaseIgnored)
pprint(result)
assert set(result['0'].keys()) == {'price'} and set(
result['1'].keys()) == {'expired'}
def test_missing_as_none():
d1 = {'key1': 123, 'key2': False, 'key3': None}
d2 = {'KEY1': '123', 'KEY2': None}
delta = DeepDelta.compare(d1, d2)
pprint(delta)
assert len(delta) == 0
delta = DeepDelta.compare(d1, d2,
DEFAULT_DELTA_CONFIG ^ DeltaConfig.MissingAsNone)
pprint(delta)
assert len(delta) == 1
def test_compare_with_exclusive_key_strings():
result = DeepDelta.compare(shopping_list, basket,
DeltaConfig.KeyCaseIgnored, None, None, 'BRAND',
'PRICE')
pprint(result)
assert set(result['0'].keys()) == {'name'} and set(
result['1'].keys()) == {'name', 'expired'}
def test_compare_with_named_comparator():
named = {
'price':
lambda l, r, p: float(l) >= float(r),
re.compile('>0.*brand'):
lambda l, r, p: str(l).casefold() != str(r).casefold(),
}
result = DeepDelta.compare(shopping_list, basket,
DeltaConfig.KeyCaseIgnored, None, named)
pprint(result)
assert set(result['0'].keys()) == {'name'} and set(
result['1'].keys()) == {'name', 'expired', 'price'}
result = DeepDelta.compare(basket, shopping_list,
DeltaConfig.KeyCaseIgnored, None, named)
pprint(result)
assert set(result['0'].keys()) == {'name', 'price'} and set(
result['1'].keys()) == {'name', 'expired'}
def test_compare_with_exclusive_key_patterns():
result = DeepDelta.compare(shopping_list, basket,
DeltaConfig.KeyCaseIgnored, None, None,
re.compile(r'>0>.*[ce|me]'),
re.compile('>1.*ex.+'))
pprint(result)
assert set(result['0'].keys()) == {'brand'} and set(
result['1'].keys()) == {'name'}
def test_compare_array_with_dif_type():
left = {'extra': [1, 2]}
right = {'extra': [1, 2, 3]}
delta = DeepDelta.compare(left, right)
print(delta)
def test_compare_with_options_dif_outputs():
for option in Output_Buffer.keys():
result = DeepDelta.compare(dict_list, dict_list2, option)
pprint(f'{option}:\n{result}')
class Employee:
def __init__(self, dId, dep, eId, name, gender):
self.departmentId = dId
self.department = dep
self.employeeId = eId
self.name = name
self.gender = gender
named_comparators = {
'date': Comparator.compare_as_datetime_values,
'total': with_precision(3)
}
default_comparator = DeepDelta(None, None, named_comparators, 'abc', 'ef')
employees = [
Employee(1, 'Sales', 123, 'Ali', 'male'),
Employee(2, 'IT', 235, 'Tom', 'male'),
Employee(1, 'Sales', 135, 'Linda', 'female'),
Employee(1, 'Sales', 178, 'Clair', 'female'),
Employee(3, 'Support', 326, 'Bruce', 'male'),
Employee(3, 'Support', 377, 'Ben', 'male'),
Employee(1, 'Sales', 138, 'Frank', 'male'),
]
dict_list = [
{
'departmentId': 1,
'department': 'Sales',