def test_concurrent_modification_key_added(self):
"""
This test shows that remote wins by default in the case of concurrent modification of
a shared key even when the shared key is not in the base.
It also shows that the on_conflict kwarg can override this.
:return:
"""
shared_key = "C"
base = {}
# Here the key "C" is changed from "base" to "remote" for remote and to "local" for local
remote = {"A": "remote", "B": None, shared_key: "remote"}
local = {"B": "local", shared_key: "local"}
expected = {"A": "remote", "B": "local", shared_key: "remote"}
result = three_way_merge(local=local, base=base, remote=remote)
self.assert_equal_dict(expected, result)
# Now with local set to win
expected = {"A": "remote", "B": "local", shared_key: "local"}
result = three_way_merge(local=local,
base=base,
remote=remote,
on_conflict="local")
self.assert_equal_dict(expected, result)
def test_key_removed_from_local(self):
base = {"C": "base"}
remote = {"C": "base"}
local = {"C": None}
expected = {"C": None}
result = three_way_merge(local=local, base=base, remote=remote)
self.assert_equal_dict(expected, result)
# Now with the on_conflict param set to "local"
expected = {"C": None}
result = three_way_merge(local=local, base=base, remote=remote, on_conflict="local")
self.assert_equal_dict(expected, result)
def test_merge(self):
"""
Shows that a change in only one place does not consitute a conflict.
"""
base = {"C": "base"}
remote = {"A": "remote", "C": "remote"}
local = {"B": "local", "C": "base"}
expected = {"A": "remote", "B": "local", "C": "remote"}
result = three_way_merge(local=local, base=base, remote=remote)
self.assert_equal_dict(expected, result)
# Now with local as the on_conflict winner
expected = {"A": "remote", "B": "local", "C": "remote"}
result = three_way_merge(local=local, base=base, remote=remote, on_conflict="local")
self.assert_equal_dict(expected, result)
def test_all_empty(self):
base = {}
remote = {}
local = {}
expected = {}
result = three_way_merge(local=local, base=base, remote=remote)
self.assert_equal_dict(expected, result)
def test_key_unset_from_remote_with_false_value(self):
base = {"C": "base"}
remote = {"C": None}
local = {"C": "base"}
expected = {"C": None}
result = three_way_merge(local=local, base=base, remote=remote)
self.assert_equal_dict(expected, result)
def test_key_no_longer_supported_from_remote(self):
base = {"C": "base"}
remote = {}
local = {"C": "base"}
expected = local
result = three_way_merge(local=local, base=base, remote=remote)
self.assert_equal_dict(expected, result)
def test_key_removed_remote_not_in_base(self):
base = {}
remote = {}
local = {"C": "local"}
expected = local # Expect Local to win
result = three_way_merge(local=local, base=base, remote=remote)
self.assert_equal_dict(expected, result)
def test_key_removed_no_conflict(self):
base = {"C": "base"}
remote = {"C": None}
local = {"C": None}
expected = {"C": None} # C should have the None value
result = three_way_merge(local=local, base=base, remote=remote)
self.assert_equal_dict(expected, result)
def test_remote_only(self):
base = {}
remote = {"A": "remote"}
local = {"A": None}
expected = remote
result = three_way_merge(local=local, base=base, remote=remote)
self.assert_equal_dict(expected, result)
def test_local_only(self):
base = {}
remote = {"B": None}
local = {"B": "local"}
expected = local
result = three_way_merge(local=local, base=base, remote=remote)
self.assert_equal_dict(expected, result)
def test_merge_conflicting_lists(self):
"""
This test shows that lists are treated atomically (as in we do not merge differing lists).
"""
shared_key = "C"
base = {shared_key: ["base"]}
# Here the key "C" is changed from "base" to "remote" for remote and to "local" for local
remote = {"A": "remote", "B": None, shared_key: ["remote"]}
local = {"B": "local", shared_key: ["local"]}
expected = {"A": "remote", "B": "local", shared_key: ["remote"]}
result = three_way_merge(local=local, base=base, remote=remote)
self.assert_equal_dict(expected, result)
# Now with local set to win
expected = {"A": "remote", "B": "local", shared_key: ["local"]}
result = three_way_merge(local=local, base=base, remote=remote, on_conflict="local")
self.assert_equal_dict(expected, result)
def test_merge_no_potential_conflict(self):
base = {"C": "base"}
# A key included from candlepin with a falsey value means that the key is supported, but
# that there is no value presently set for it.
remote = {"A": "remote", "B": None, "C": "base"}
local = {"B": "local", "C": "base"}
expected = {"A": "remote", "B": "local", "C": "base"}
result = three_way_merge(local=local, base=base, remote=remote)
self.assert_equal_dict(expected, result)
def test_merge_missing_remote_list(self):
"""
Shows that if the server does not have list, local can add it.
"""
base = {"B": None}
remote = {}
local = {"B": ["local"]}
expected = {"B": ["local"]}
result = three_way_merge(local=local, base=base, remote=remote)
self.assert_equal_dict(expected, result)
def test_merge_remote_empty_field(self):
"""
Shows that if the server has field with empty string, local gets to modify it.
"""
base = {"B": None}
remote = {"B": ""}
local = {"B": "local"}
expected = {"B": "local"}
result = three_way_merge(local=local, base=base, remote=remote)
self.assert_equal_dict(expected, result)
def test_merge_remote_missing_field(self):
"""
Shows that if the server does not support a field, local gets to modify it.
"""
base = {"B": None}
remote = {}
local = {"B": "local"}
expected = {"B": "local"}
result = three_way_merge(local=local, base=base, remote=remote)
self.assert_equal_dict(expected, result)
def test_empty_base_no_conflict(self):
base = {}
remote = {
"A": "remote",
"B": None,
}
local = {
"A": None,
"B": "local",
}
expected = {"A": "remote", "B": "local"}
result = three_way_merge(local=local, base=base, remote=remote)
self.assert_equal_dict(expected, result)
