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)