def test_delta_cases(self, t1, t2, deepdiff_kwargs, to_delta_kwargs,
expected_delta_dict):
diff = DeepDiff(t1, t2, **deepdiff_kwargs)
delta_dict = diff._to_delta_dict(**to_delta_kwargs)
assert expected_delta_dict == delta_dict
delta = Delta(diff, verify_symmetry=False, raise_errors=True)
assert t1 + delta == t2
def test_delta_dict_items_added_retain_order(self):
t1 = {
6: 6
}
t2 = {
6: 6,
7: 7,
3: 3,
5: 5,
2: 2,
4: 4
}
expected_delta_dict = {
'dictionary_item_added': {
'root[7]': 7,
'root[3]': 3,
'root[5]': 5,
'root[2]': 2,
'root[4]': 4
}
}
diff = DeepDiff(t1, t2)
delta_dict = diff._to_delta_dict()
assert expected_delta_dict == delta_dict
delta = Delta(diff, verify_symmetry=False, raise_errors=True)
result = t1 + delta
assert result == t2
assert list(result.keys()) == [6, 7, 3, 5, 2, 4]
assert list(result.keys()) == list(t2.keys())
def test_distance_of_list_sets_and_strings(self, verbose_level):
t1 = [{1, 2, 3}, {4, 5, 'hello', 'right!'}, {4, 5, (2, 4, 7)}]
t2 = [{4, 5, 6, (2, )}, {1, 2, 3}, {5, 'hello', 'right!'}]
ddiff = DeepDiff(t1,
t2,
ignore_order=True,
view=DELTA_VIEW,
verbose_level=verbose_level)
delta = ddiff._to_delta_dict(report_repetition_required=False)
expected = {
'set_item_removed': {
'root[1]': {4}
},
'iterable_items_added_at_indexes': {
'root': {
0: {(2, ), 4, 5, 6}
}
},
'iterable_items_removed_at_indexes': {
'root': {
2: {4, 5, (2, 4, 7)}
}
}
}
assert expected == ddiff
# If the diff was in delta view, spitting out another delta dict should produce identical results.
assert delta == ddiff
assert 10 == _get_item_length(ddiff)
def test_delta_view_and_to_delta_dict_are_equal_when_parameteres_passed(
self):
"""
This is a test that passes parameters in a dictionary instead of kwargs.
Note that when parameters are passed as a dictionary, all of them even the ones that
have default values need to be passed.
"""
t1 = [4, 2, 2, 1]
t2 = [4, 1, 1, 1]
_parameters = {
'ignore_order': True,
'ignore_numeric_type_changes': False,
'ignore_string_type_changes': False,
'ignore_type_in_groups': [],
'report_repetition': True,
'exclude_paths': None,
'exclude_regex_paths': None,
'exclude_types': None,
'exclude_types_tuple': None,
'ignore_type_subclasses': False,
'ignore_string_case': False,
'exclude_obj_callback': None,
'ignore_private_variables': True,
'ignore_nan_inequality': False,
'hasher': None,
'significant_digits': None,
'number_format_notation': 'f',
'verbose_level': 1,
'view': DELTA_VIEW,
'max_passes': 10000000,
'max_diffs': None,
'number_to_string': number_to_string,
'cache_tuning_sample_size': 500,
'cache_size': 500,
'cutoff_intersection_for_pairs': 0.6,
'group_by': None,
}
expected = {
'iterable_items_added_at_indexes': {
'root': {
1: 1,
2: 1,
3: 1
}
},
'iterable_items_removed_at_indexes': {
'root': {
1: 2,
2: 2
}
}
}
diff1 = DeepDiff(t1, t2, _parameters=_parameters)
assert expected == diff1
_parameters['view'] = TEXT_VIEW
diff2 = DeepDiff(t1, t2, _parameters=_parameters)
assert expected == diff2._to_delta_dict()
def test_ignore_order_delta_cases(
self, t1, t2, deepdiff_kwargs, to_delta_kwargs, expected_delta_dict, expected_t1_plus_delta):
diff = DeepDiff(t1, t2, **deepdiff_kwargs)
delta_dict = diff._to_delta_dict(**to_delta_kwargs)
assert expected_delta_dict == delta_dict
delta = Delta(diff, verify_symmetry=False, raise_errors=True)
expected_t1_plus_delta = t2 if expected_t1_plus_delta == 't2' else expected_t1_plus_delta
t1_plus_delta = t1 + delta
assert t1_plus_delta == expected_t1_plus_delta
assert t1 + delta == t1_plus_delta # asserting that delta is not mutated once it is applied.
def test_distance_of_list_sets(self):
t1 = [{1, 2, 3}, {4, 5}]
t2 = [{4, 5, 6}, {1, 2, 3}]
ddiff = DeepDiff(t1, t2, ignore_order=True, cache_purge_level=0)
delta = ddiff._to_delta_dict(report_repetition_required=False)
assert {'set_item_added': {'root[1]': {6}}} == delta
assert 1 == _get_item_length(ddiff)
assert '0.05882352' == str(ddiff._get_rough_distance())[:10]
assert 8 == ddiff._DistanceMixin__get_item_rough_length(ddiff.t1)
assert 9 == ddiff._DistanceMixin__get_item_rough_length(ddiff.t2)
def test_distance_of_list_sets2(self, verbose_level):
t1 = [{1, 2, 3}, {4, 5}, {1}]
t2 = [{4, 5, 6}, {1, 2, 3}, {1, 4}]
ddiff = DeepDiff(t1,
t2,
ignore_order=True,
verbose_level=verbose_level,
get_deep_distance=True,
cache_purge_level=0)
delta = ddiff._to_delta_dict(report_repetition_required=False)
assert {'set_item_added': {'root[2]': {4}, 'root[1]': {6}}} == delta
assert 2 == _get_item_length(ddiff)
assert '0.09090909' == str(ddiff['deep_distance'])[:10]
assert 10 == ddiff._DistanceMixin__get_item_rough_length(ddiff.t1)
assert 12 == ddiff._DistanceMixin__get_item_rough_length(ddiff.t2)
def test_numpy_delta_cases(self, t1, t2, deepdiff_kwargs, to_delta_kwargs, expected_delta_dict, expected_result):
diff = DeepDiff(t1, t2, **deepdiff_kwargs)
delta_dict = diff._to_delta_dict(**to_delta_kwargs)
if expected_delta_dict:
assert expected_delta_dict == delta_dict
delta = Delta(diff, verify_symmetry=False, raise_errors=True)
if expected_result == 't2':
result = delta + t1
assert np.array_equal(result, t2)
elif expected_result == 't2_via_deepdiff':
result = delta + t1
diff = DeepDiff(result, t2, ignore_order=True, report_repetition=True)
assert not diff
elif expected_result is DeltaNumpyOperatorOverrideError:
with pytest.raises(DeltaNumpyOperatorOverrideError):
assert t1 + delta
else:
result = delta + t1
assert np.array_equal(result, expected_result)
