def test_recursive_diff_when_different_lengths(self): ''' Unlike Sequences, we should still attempt recursive diffs when the Ordered Mappings are different sizes. ''' d1 = OrderedDict( sorted({'a': 1, 'b': [2]}.items(), key=lambda i: i[0])) d2 = OrderedDict( sorted({'a': 1, 'b': [3], 'c': 4}.items(), key=lambda i: i[0])) diff_obj = diff_ordered_mapping(d1, d2) nested_diffs = [ DiffItem(remove, 2, (0, 1, 0, 0)), DiffItem(insert, 3, (1, 1, 0, 1)) ] nested_diff_obj = Diff(list, nested_diffs, depth=1) nested_diff_obj.context_blocks = [ nested_diff_obj.ContextBlock(list, nested_diffs, depth=1) ] diffs = [ MappingDiffItem(unchanged, 'a', unchanged, 1), MappingDiffItem( unchanged, 'b', changed, nested_diff_obj), MappingDiffItem(insert, 'c', insert, 4) ] expected_diff = Diff(OrderedDict, diffs) expected_diff.context_blocks = [ expected_diff.ContextBlock(OrderedDict, diffs[1:]) ] self.assertEqual(diff_obj, expected_diff) self.assertEqual(patch(d1, diff_obj), d2)
def test_common_keys_diff_order_matters_1(self): ''' There are two possible lcs's for the keys here. ('a', 'b') and ('a', 'c') the lcs algorithm picks only one of them (('a', 'b') in this case). We therefore get a recursive diff at key 'b'. and an insert and remove on key 'c'. If this were a standard Mapping type key 'c' would be unchanged. ''' d1 = OrderedDict(sorted( {'a': 1, 'b': 'a', 'c': 3}.items(), key=lambda i: i[0])) d2 = OrderedDict(sorted({'a': 1, 'c': 3}.items(), key=lambda i: i[0])) d2['b'] = 'b' diff_obj = diff_ordered_mapping(d1, d2) nested_diffs = [ DiffItem(remove, 'a', (0, 1, 0, 0)), DiffItem(insert, 'b', (1, 1, 0, 1)) ] nested_diff = Diff(str, nested_diffs, depth=1) nested_diff.context_blocks = [ nested_diff.ContextBlock(str, nested_diffs, depth=1) ] diffs = [ MappingDiffItem(unchanged, 'a', unchanged, 1), MappingDiffItem(insert, 'c', insert, 3), MappingDiffItem( unchanged, 'b', changed, nested_diff), MappingDiffItem(remove, 'c', remove, 3) ] expected_diff = Diff(OrderedDict, diffs) expected_diff.context_blocks = [ expected_diff.ContextBlock(OrderedDict, diffs[1:]) ] self.assertEqual(diff_obj, expected_diff) self.assertEqual(patch(d1, diff_obj), d2)
def test_no_difference(self): d1 = {'a': 1} od = OrderedDict(d1) diff_obj = diff_ordered_mapping(od, od) diffs = [ MappingDiffItem(unchanged, 'a', unchanged, 1)] expected_diff = Diff(OrderedDict, diffs) self.assertEqual(diff_obj, expected_diff) self.assertEqual(patch(od, diff_obj), od)
def test_common_keys_values_different_types(self): d1 = {'a': 1, 'b': ['a'], 'c': 3} d2 = {'a': 1, 'b': 'a', 'c': 3} od1 = OrderedDict(sorted(d1.items(), key=lambda i: i[0])) od2 = OrderedDict(sorted(d2.items(), key=lambda i: i[0])) diff_obj = diff_ordered_mapping(od1, od2) diffs = [ MappingDiffItem(unchanged, 'a', unchanged, 1), MappingDiffItem(unchanged, 'b', remove, ['a']), MappingDiffItem(unchanged, 'b', insert, 'a'), MappingDiffItem(unchanged, 'c', unchanged, 3) ] expected_diff = Diff(OrderedDict, diffs) expected_diff.context_blocks = [ expected_diff.ContextBlock(OrderedDict, diffs[1:3]) ] self.assertEqual(diff_obj, expected_diff) self.assertEqual(patch(od1, diff_obj), od2)
def test_common_keys_diff_order_matters_2(self): ''' The other possibility from number 1 above wherby we end up with no recursive You actually end up with insert b: b, remove b: b which looks odd but is one of the possible minimal edits. ''' d1 = OrderedDict(sorted({'a': 1, 'c': 3}.items(), key=lambda i: i[0])) d1['b'] = 'b' d2 = OrderedDict( sorted({'a': 1, 'b': 'b', 'c': 3}.items(), key=lambda i: i[0])) diff_obj = diff_ordered_mapping(d1, d2) diffs = [ MappingDiffItem(unchanged, 'a', unchanged, 1), MappingDiffItem(insert, 'b', insert, 'b'), MappingDiffItem( unchanged, 'c', unchanged, 3), MappingDiffItem(remove, 'b', remove, 'b') ] expected_diff = Diff(OrderedDict, diffs) expected_diff.context_blocks = [ expected_diff.ContextBlock(OrderedDict, diffs[1:]) ] self.assertEqual(diff_obj, expected_diff) self.assertEqual(patch(d1, diff_obj), d2)
def test_empty_diff(self): od = OrderedDict() diff_obj = diff_ordered_mapping(od, od) expected_diff = Diff(OrderedDict, []) self.assertEqual(diff_obj, expected_diff) self.assertEqual(patch(od, diff_obj), od)