def sync(state, client, list_path, resource_path, payload, check_mode):
datastore = utils.get(client, resource_path)
# When we are deleting stores, we do not care if there is more than one
# datastore present. We just make sure the currently manipulated store is
# gone. This makes our module useful in "let us clean up the mess"
# scenarios.
if state == "absent" and datastore is None:
return False, None
if state == "absent":
if not check_mode:
utils.delete(client, resource_path)
return True, None
# If the store exists, update it and ignore the fact that there might be
# more than one present.
if datastore:
if _do_differ(datastore, payload):
if check_mode:
return True, payload
utils.put(client, resource_path, payload)
return True, utils.get(client, resource_path)
return False, datastore
# When adding a new datastore, we first make sure there is no other
# datastore present because we do not want to be the ones who brought
# backends into an inconsistent state.
if utils.get(client, list_path):
raise errors.Error("Some other external datastore is already active.")
if check_mode:
return True, payload
utils.put(client, resource_path, payload)
return True, utils.get(client, resource_path)
def test_abort_on_invalid_status(self, mocker, status):
client = mocker.Mock()
client.delete.return_value = http.Response(status, "")
with pytest.raises(errors.SyncError, match=str(status)):
utils.delete(client, "/delete")
client.delete.assert_called_once_with("/delete")
def update_state(client, path, old_disabled, new_disabled, check_mode):
changed = old_disabled != new_disabled
if not check_mode and changed:
if new_disabled: # `state: disabled` input parameter
utils.delete(client, path)
else: # `state: enabled` input parameter
utils.put(client, path + '/reinstate', None)
return changed
def sync(remote_object, state, client, path, payload, check_mode):
if state == 'disabled' and remote_object is not None:
if not check_mode:
utils.delete(client, path)
return True, utils.get(client, path)
if utils.do_differ(remote_object, payload):
if check_mode:
return True, payload
utils.put(client, path, payload)
return True, utils.get(client, path)
return False, remote_object
def update_groups(client, path, old_groups, new_groups, check_mode):
to_delete = set(old_groups).difference(new_groups)
to_add = set(new_groups).difference(old_groups)
if not check_mode:
# Next few lines are far from atomic, which means that we can leave a
# user in any of the intermediate states, but this is the best we can
# do given the API limitations.
for g in to_add:
utils.put(client, path + '/groups/' + g, None)
for g in to_delete:
utils.delete(client, path + '/groups/' + g)
return len(to_delete) + len(to_add) > 0
def test_valid_delete(self, mocker):
client = mocker.Mock()
client.delete.return_value = http.Response(204, "{}")
object = utils.delete(client, "/delete")
assert object is None
client.delete.assert_called_once_with("/delete")
