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)
