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)