ansible/community.general
1
0
Fork 0
mirror of https://github.com/ansible-collections/community.general.git synced 2024-09-14 20:13:21 +02:00
Code Releases Activity

gitlab: clean up modules and utils (#3694)

Browse source 
* gitlab: remove dead code in module_utils

* gitlab: use snake_case consistently in methods and functions

* gitlab: use snake_case consistently in variables

* gitlab: fix pep8 indentation issues

* gitlab: add changelog fragment

* gitlab: apply suggestions from code review

Co-authored-by: Alexei Znamensky <103110+russoz@users.noreply.github.com>
Co-authored-by: Chris Frage <git@sh0shin.org>

* gitlab: use consistent indentation

Co-authored-by: Alexei Znamensky <103110+russoz@users.noreply.github.com>
Co-authored-by: Chris Frage <git@sh0shin.org>
This commit is contained in:
Nejc Habjan 2021-11-16 13:01:32 +01:00 committed by GitHub
parent bf7a954f00
commit d29aecad26
No known key found for this signature in database
GPG key ID: 4AEE18F83AFDEB23
19 changed files with 375 additions and 379 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
changelogs/fragments/3694-gitlab-cleanup.yml Normal file
View file

@ -0,0 +1,2 @@
minor_changes:
- gitlab - clean up modules and utils (https://github.com/ansible-collections/community.general/pull/3694).

30
plugins/module_utils/gitlab.py
View file

@ -30,31 +30,7 @@ except Exception:
HAS_GITLAB_PACKAGE = False HAS_GITLAB_PACKAGE = False
def request(module, api_url, project, path, access_token, private_token, rawdata='', method='GET'): def find_project(gitlab_instance, identifier):
url = "%s/v4/projects/%s%s" % (api_url, quote_plus(project), path)
headers = {}
if access_token:
headers['Authorization'] = "Bearer %s" % access_token
else:
headers['Private-Token'] = private_token
headers['Accept'] = "application/json"
headers['Content-Type'] = "application/json"
response, info = fetch_url(module=module, url=url, headers=headers, data=rawdata, method=method)
status = info['status']
content = ""
if response:
content = response.read()
if status == 204:
return True, content
elif status == 200 or status == 201:
return True, json.loads(content)
else:
return False, str(status) + ": " + content
def findProject(gitlab_instance, identifier):
try: try:
project = gitlab_instance.projects.get(identifier) project = gitlab_instance.projects.get(identifier)
except Exception as e: except Exception as e:
@ -67,7 +43,7 @@ def findProject(gitlab_instance, identifier):
return project return project
def findGroup(gitlab_instance, identifier): def find_group(gitlab_instance, identifier):
try: try:
project = gitlab_instance.groups.get(identifier) project = gitlab_instance.groups.get(identifier)
except Exception as e: except Exception as e:
@ -76,7 +52,7 @@ def findGroup(gitlab_instance, identifier):
return project return project
def gitlabAuthentication(module): def gitlab_authentication(module):
gitlab_url = module.params['api_url'] gitlab_url = module.params['api_url']
validate_certs = module.params['validate_certs'] validate_certs = module.params['validate_certs']
gitlab_user = module.params['api_username'] gitlab_user = module.params['api_username']

86
plugins/modules/source_control/gitlab/gitlab_deploy_key.py
View file

@ -126,51 +126,51 @@ from ansible.module_utils.api import basic_auth_argument_spec
from ansible.module_utils.basic import AnsibleModule, missing_required_lib from ansible.module_utils.basic import AnsibleModule, missing_required_lib
from ansible.module_utils.common.text.converters import to_native from ansible.module_utils.common.text.converters import to_native
from ansible_collections.community.general.plugins.module_utils.gitlab import findProject, gitlabAuthentication from ansible_collections.community.general.plugins.module_utils.gitlab import find_project, gitlab_authentication
class GitLabDeployKey(object): class GitLabDeployKey(object):
def __init__(self, module, gitlab_instance): def __init__(self, module, gitlab_instance):
self._module = module self._module = module
self._gitlab = gitlab_instance self._gitlab = gitlab_instance
self.deployKeyObject = None self.deploy_key_object = None
''' '''
@param project Project object @param project Project object
@param key_title Title of the key @param key_title Title of the key
@param key_key String of the key @param key_key String of the key
@param key_can_push Option of the deployKey @param key_can_push Option of the deploy_key
@param options Deploy key options @param options Deploy key options
''' '''
def createOrUpdateDeployKey(self, project, key_title, key_key, options): def create_or_update_deploy_key(self, project, key_title, key_key, options):
changed = False changed = False
# note: unfortunately public key cannot be updated directly by # note: unfortunately public key cannot be updated directly by
# GitLab REST API, so for that case we need to delete and # GitLab REST API, so for that case we need to delete and
# than recreate the key # than recreate the key
if self.deployKeyObject and self.deployKeyObject.key != key_key: if self.deploy_key_object and self.deploy_key_object.key != key_key:
if not self._module.check_mode: if not self._module.check_mode:
self.deployKeyObject.delete() self.deploy_key_object.delete()
self.deployKeyObject = None self.deploy_key_object = None
# Because we have already call existsDeployKey in main() # Because we have already call exists_deploy_key in main()
if self.deployKeyObject is None: if self.deploy_key_object is None:
deployKey = self.createDeployKey(project, { deploy_key = self.create_deploy_key(project, {
'title': key_title, 'title': key_title,
'key': key_key, 'key': key_key,
'can_push': options['can_push']}) 'can_push': options['can_push']})
changed = True changed = True
else: else:
changed, deployKey = self.updateDeployKey(self.deployKeyObject, { changed, deploy_key = self.update_deploy_key(self.deploy_key_object, {
'can_push': options['can_push']}) 'can_push': options['can_push']})
self.deployKeyObject = deployKey self.deploy_key_object = deploy_key
if changed: if changed:
if self._module.check_mode: if self._module.check_mode:
self._module.exit_json(changed=True, msg="Successfully created or updated the deploy key %s" % key_title) self._module.exit_json(changed=True, msg="Successfully created or updated the deploy key %s" % key_title)
try: try:
deployKey.save() deploy_key.save()
except Exception as e: except Exception as e:
self._module.fail_json(msg="Failed to update deploy key: %s " % e) self._module.fail_json(msg="Failed to update deploy key: %s " % e)
return True return True
@ -179,61 +179,61 @@ class GitLabDeployKey(object):
''' '''
@param project Project Object @param project Project Object
@param arguments Attributes of the deployKey @param arguments Attributes of the deploy_key
''' '''
def createDeployKey(self, project, arguments): def create_deploy_key(self, project, arguments):
if self._module.check_mode: if self._module.check_mode:
return True return True
try: try:
deployKey = project.keys.create(arguments) deploy_key = project.keys.create(arguments)
except (gitlab.exceptions.GitlabCreateError) as e: except (gitlab.exceptions.GitlabCreateError) as e:
self._module.fail_json(msg="Failed to create deploy key: %s " % to_native(e)) self._module.fail_json(msg="Failed to create deploy key: %s " % to_native(e))
return deployKey return deploy_key
''' '''
@param deployKey Deploy Key Object @param deploy_key Deploy Key Object
@param arguments Attributes of the deployKey @param arguments Attributes of the deploy_key
''' '''
def updateDeployKey(self, deployKey, arguments): def update_deploy_key(self, deploy_key, arguments):
changed = False changed = False
for arg_key, arg_value in arguments.items(): for arg_key, arg_value in arguments.items():
if arguments[arg_key] is not None: if arguments[arg_key] is not None:
if getattr(deployKey, arg_key) != arguments[arg_key]: if getattr(deploy_key, arg_key) != arguments[arg_key]:
setattr(deployKey, arg_key, arguments[arg_key]) setattr(deploy_key, arg_key, arguments[arg_key])
changed = True changed = True
return (changed, deployKey) return (changed, deploy_key)
''' '''
@param project Project object @param project Project object
@param key_title Title of the key @param key_title Title of the key
''' '''
def findDeployKey(self, project, key_title): def find_deploy_key(self, project, key_title):
deployKeys = project.keys.list(all=True) deploy_keys = project.keys.list(all=True)
for deployKey in deployKeys: for deploy_key in deploy_keys:
if (deployKey.title == key_title): if (deploy_key.title == key_title):
return deployKey return deploy_key
''' '''
@param project Project object @param project Project object
@param key_title Title of the key @param key_title Title of the key
''' '''
def existsDeployKey(self, project, key_title): def exists_deploy_key(self, project, key_title):
# When project exists, object will be stored in self.projectObject. # When project exists, object will be stored in self.project_object.
deployKey = self.findDeployKey(project, key_title) deploy_key = self.find_deploy_key(project, key_title)
if deployKey: if deploy_key:
self.deployKeyObject = deployKey self.deploy_key_object = deploy_key
return True return True
return False return False
def deleteDeployKey(self): def delete_deploy_key(self):
if self._module.check_mode: if self._module.check_mode:
return True return True
return self.deployKeyObject.delete() return self.deploy_key_object.delete()
def main(): def main():
@ -271,32 +271,32 @@ def main():
if not HAS_GITLAB_PACKAGE: if not HAS_GITLAB_PACKAGE:
module.fail_json(msg=missing_required_lib("python-gitlab"), exception=GITLAB_IMP_ERR) module.fail_json(msg=missing_required_lib("python-gitlab"), exception=GITLAB_IMP_ERR)
gitlab_instance = gitlabAuthentication(module) gitlab_instance = gitlab_authentication(module)
gitlab_deploy_key = GitLabDeployKey(module, gitlab_instance) gitlab_deploy_key = GitLabDeployKey(module, gitlab_instance)
project = findProject(gitlab_instance, project_identifier) project = find_project(gitlab_instance, project_identifier)
if project is None: if project is None:
module.fail_json(msg="Failed to create deploy key: project %s doesn't exists" % project_identifier) module.fail_json(msg="Failed to create deploy key: project %s doesn't exists" % project_identifier)
deployKey_exists = gitlab_deploy_key.existsDeployKey(project, key_title) deploy_key_exists = gitlab_deploy_key.exists_deploy_key(project, key_title)
if state == 'absent': if state == 'absent':
if deployKey_exists: if deploy_key_exists:
gitlab_deploy_key.deleteDeployKey() gitlab_deploy_key.delete_deploy_key()
module.exit_json(changed=True, msg="Successfully deleted deploy key %s" % key_title) module.exit_json(changed=True, msg="Successfully deleted deploy key %s" % key_title)
else: else:
module.exit_json(changed=False, msg="Deploy key deleted or does not exists") module.exit_json(changed=False, msg="Deploy key deleted or does not exists")
if state == 'present': if state == 'present':
if gitlab_deploy_key.createOrUpdateDeployKey(project, key_title, key_keyfile, {'can_push': key_can_push}): if gitlab_deploy_key.create_or_update_deploy_key(project, key_title, key_keyfile, {'can_push': key_can_push}):
module.exit_json(changed=True, msg="Successfully created or updated the deploy key %s" % key_title, module.exit_json(changed=True, msg="Successfully created or updated the deploy key %s" % key_title,
deploy_key=gitlab_deploy_key.deployKeyObject._attrs) deploy_key=gitlab_deploy_key.deploy_key_object._attrs)
else: else:
module.exit_json(changed=False, msg="No need to update the deploy key %s" % key_title, module.exit_json(changed=False, msg="No need to update the deploy key %s" % key_title,
deploy_key=gitlab_deploy_key.deployKeyObject._attrs) deploy_key=gitlab_deploy_key.deploy_key_object._attrs)
if __name__ == '__main__': if __name__ == '__main__':

66
plugins/modules/source_control/gitlab/gitlab_group.py
View file

@ -169,19 +169,19 @@ from ansible.module_utils.api import basic_auth_argument_spec
from ansible.module_utils.basic import AnsibleModule, missing_required_lib from ansible.module_utils.basic import AnsibleModule, missing_required_lib
from ansible.module_utils.common.text.converters import to_native from ansible.module_utils.common.text.converters import to_native
from ansible_collections.community.general.plugins.module_utils.gitlab import findGroup, gitlabAuthentication from ansible_collections.community.general.plugins.module_utils.gitlab import find_group, gitlab_authentication
class GitLabGroup(object): class GitLabGroup(object):
def __init__(self, module, gitlab_instance): def __init__(self, module, gitlab_instance):
self._module = module self._module = module
self._gitlab = gitlab_instance self._gitlab = gitlab_instance
self.groupObject = None self.group_object = None
''' '''
@param group Group object @param group Group object
''' '''
def getGroupId(self, group): def get_group_id(self, group):
if group is not None: if group is not None:
return group.id return group.id
return None return None
@ -191,12 +191,12 @@ class GitLabGroup(object):
@param parent Parent group full path @param parent Parent group full path
@param options Group options @param options Group options
''' '''
def createOrUpdateGroup(self, name, parent, options): def create_or_update_group(self, name, parent, options):
changed = False changed = False
# Because we have already call userExists in main() # Because we have already call userExists in main()
if self.groupObject is None: if self.group_object is None:
parent_id = self.getGroupId(parent) parent_id = self.get_group_id(parent)
payload = { payload = {
'name': name, 'name': name,
@ -211,10 +211,10 @@ class GitLabGroup(object):
payload['description'] = options['description'] payload['description'] = options['description']
if options.get('require_two_factor_authentication'): if options.get('require_two_factor_authentication'):
payload['require_two_factor_authentication'] = options['require_two_factor_authentication'] payload['require_two_factor_authentication'] = options['require_two_factor_authentication']
group = self.createGroup(payload) group = self.create_group(payload)
changed = True changed = True
else: else:
changed, group = self.updateGroup(self.groupObject, { changed, group = self.update_group(self.group_object, {
'name': name, 'name': name,
'description': options['description'], 'description': options['description'],
'visibility': options['visibility'], 'visibility': options['visibility'],
@ -224,7 +224,7 @@ class GitLabGroup(object):
'require_two_factor_authentication': options['require_two_factor_authentication'], 'require_two_factor_authentication': options['require_two_factor_authentication'],
}) })
self.groupObject = group self.group_object = group
if changed: if changed:
if self._module.check_mode: if self._module.check_mode:
self._module.exit_json(changed=True, msg="Successfully created or updated the group %s" % name) self._module.exit_json(changed=True, msg="Successfully created or updated the group %s" % name)
@ -240,7 +240,7 @@ class GitLabGroup(object):
''' '''
@param arguments Attributes of the group @param arguments Attributes of the group
''' '''
def createGroup(self, arguments): def create_group(self, arguments):
if self._module.check_mode: if self._module.check_mode:
return True return True
@ -255,7 +255,7 @@ class GitLabGroup(object):
@param group Group Object @param group Group Object
@param arguments Attributes of the group @param arguments Attributes of the group
''' '''
def updateGroup(self, group, arguments): def update_group(self, group, arguments):
changed = False changed = False
for arg_key, arg_value in arguments.items(): for arg_key, arg_value in arguments.items():
@ -266,8 +266,8 @@ class GitLabGroup(object):
return (changed, group) return (changed, group)
def deleteGroup(self): def delete_group(self):
group = self.groupObject group = self.group_object
if len(group.projects.list()) >= 1: if len(group.projects.list()) >= 1:
self._module.fail_json( self._module.fail_json(
@ -285,11 +285,11 @@ class GitLabGroup(object):
@param name Name of the groupe @param name Name of the groupe
@param full_path Complete path of the Group including parent group path. <parent_path>/<group_path> @param full_path Complete path of the Group including parent group path. <parent_path>/<group_path>
''' '''
def existsGroup(self, project_identifier): def exists_group(self, project_identifier):
# When group/user exists, object will be stored in self.groupObject. # When group/user exists, object will be stored in self.group_object.
group = findGroup(self._gitlab, project_identifier) group = find_group(self._gitlab, project_identifier)
if group: if group:
self.groupObject = group self.group_object = group
return True return True
return False return False
@ -339,7 +339,7 @@ def main():
if not HAS_GITLAB_PACKAGE: if not HAS_GITLAB_PACKAGE:
module.fail_json(msg=missing_required_lib("python-gitlab"), exception=GITLAB_IMP_ERR) module.fail_json(msg=missing_required_lib("python-gitlab"), exception=GITLAB_IMP_ERR)
gitlab_instance = gitlabAuthentication(module) gitlab_instance = gitlab_authentication(module)
# Define default group_path based on group_name # Define default group_path based on group_name
if group_path is None: if group_path is None:
@ -349,34 +349,34 @@ def main():
parent_group = None parent_group = None
if parent_identifier: if parent_identifier:
parent_group = findGroup(gitlab_instance, parent_identifier) parent_group = find_group(gitlab_instance, parent_identifier)
if not parent_group: if not parent_group:
module.fail_json(msg="Failed create GitLab group: Parent group doesn't exists") module.fail_json(msg="Failed create GitLab group: Parent group doesn't exists")
group_exists = gitlab_group.existsGroup(parent_group.full_path + '/' + group_path) group_exists = gitlab_group.exists_group(parent_group.full_path + '/' + group_path)
else: else:
group_exists = gitlab_group.existsGroup(group_path) group_exists = gitlab_group.exists_group(group_path)
if state == 'absent': if state == 'absent':
if group_exists: if group_exists:
gitlab_group.deleteGroup() gitlab_group.delete_group()
module.exit_json(changed=True, msg="Successfully deleted group %s" % group_name) module.exit_json(changed=True, msg="Successfully deleted group %s" % group_name)
else: else:
module.exit_json(changed=False, msg="Group deleted or does not exists") module.exit_json(changed=False, msg="Group deleted or does not exists")
if state == 'present': if state == 'present':
if gitlab_group.createOrUpdateGroup(group_name, parent_group, { if gitlab_group.create_or_update_group(group_name, parent_group, {
"path": group_path, "path": group_path,
"description": description, "description": description,
"visibility": group_visibility, "visibility": group_visibility,
"project_creation_level": project_creation_level, "project_creation_level": project_creation_level,
"auto_devops_enabled": auto_devops_enabled, "auto_devops_enabled": auto_devops_enabled,
"subgroup_creation_level": subgroup_creation_level, "subgroup_creation_level": subgroup_creation_level,
"require_two_factor_authentication": require_two_factor_authentication, "require_two_factor_authentication": require_two_factor_authentication,
}): }):
module.exit_json(changed=True, msg="Successfully created or updated the group %s" % group_name, group=gitlab_group.groupObject._attrs) module.exit_json(changed=True, msg="Successfully created or updated the group %s" % group_name, group=gitlab_group.group_object._attrs)
else: else:
module.exit_json(changed=False, msg="No need to update the group %s" % group_name, group=gitlab_group.groupObject._attrs) module.exit_json(changed=False, msg="No need to update the group %s" % group_name, group=gitlab_group.group_object._attrs)
if __name__ == '__main__': if __name__ == '__main__':

6
plugins/modules/source_control/gitlab/gitlab_group_members.py
View file

@ -155,7 +155,7 @@ RETURN = r''' # '''
from ansible.module_utils.api import basic_auth_argument_spec from ansible.module_utils.api import basic_auth_argument_spec
from ansible.module_utils.basic import AnsibleModule, missing_required_lib from ansible.module_utils.basic import AnsibleModule, missing_required_lib
from ansible_collections.community.general.plugins.module_utils.gitlab import gitlabAuthentication from ansible_collections.community.general.plugins.module_utils.gitlab import gitlab_authentication
import traceback import traceback
@ -288,7 +288,7 @@ def main():
'reporter': gitlab.REPORTER_ACCESS, 'reporter': gitlab.REPORTER_ACCESS,
'developer': gitlab.DEVELOPER_ACCESS, 'developer': gitlab.DEVELOPER_ACCESS,
'maintainer': gitlab.MAINTAINER_ACCESS, 'maintainer': gitlab.MAINTAINER_ACCESS,
'owner': gitlab.OWNER_ACCESS 'owner': gitlab.OWNER_ACCESS,
} }
gitlab_group = module.params['gitlab_group'] gitlab_group = module.params['gitlab_group']
@ -300,7 +300,7 @@ def main():
purge_users = [access_level_int[level] for level in purge_users] purge_users = [access_level_int[level] for level in purge_users]
# connect to gitlab server # connect to gitlab server
gl = gitlabAuthentication(module) gl = gitlab_authentication(module)
group = GitLabGroup(module, gl) group = GitLabGroup(module, gl)

27
plugins/modules/source_control/gitlab/gitlab_group_variable.py
View file

@ -144,7 +144,7 @@ except Exception:
GITLAB_IMP_ERR = traceback.format_exc() GITLAB_IMP_ERR = traceback.format_exc()
HAS_GITLAB_PACKAGE = False HAS_GITLAB_PACKAGE = False
from ansible_collections.community.general.plugins.module_utils.gitlab import gitlabAuthentication from ansible_collections.community.general.plugins.module_utils.gitlab import gitlab_authentication
class GitlabGroupVariables(object): class GitlabGroupVariables(object):
@ -170,9 +170,13 @@ class GitlabGroupVariables(object):
def create_variable(self, key, value, masked, protected, variable_type): def create_variable(self, key, value, masked, protected, variable_type):
if self._module.check_mode: if self._module.check_mode:
return return
return self.group.variables.create({"key": key, "value": value, return self.group.variables.create({
"masked": masked, "protected": protected, "key": key,
"variable_type": variable_type}) "value": value,
"masked": masked,
"protected": protected,
"variable_type": variable_type,
})
def update_variable(self, key, var, value, masked, protected, variable_type): def update_variable(self, key, var, value, masked, protected, variable_type):
if var.value == value and var.protected == protected and var.masked == masked and var.variable_type == variable_type: if var.value == value and var.protected == protected and var.masked == masked and var.variable_type == variable_type:
@ -226,11 +230,14 @@ def native_python_main(this_gitlab, purge, var_list, state, module):
existing_variables[index] = None existing_variables[index] = None
if state == 'present': if state == 'present':
single_change = this_gitlab.update_variable(key, single_change = this_gitlab.update_variable(
gitlab_keys[index], key,
value, masked, gitlab_keys[index],
protected, value,
variable_type) masked,
protected,
variable_type,
)
change = single_change or change change = single_change or change
if single_change: if single_change:
return_value['updated'].append(key) return_value['updated'].append(key)
@ -291,7 +298,7 @@ def main():
if not HAS_GITLAB_PACKAGE: if not HAS_GITLAB_PACKAGE:
module.fail_json(msg=missing_required_lib("python-gitlab"), exception=GITLAB_IMP_ERR) module.fail_json(msg=missing_required_lib("python-gitlab"), exception=GITLAB_IMP_ERR)
gitlab_instance = gitlabAuthentication(module) gitlab_instance = gitlab_authentication(module)
this_gitlab = GitlabGroupVariables(module=module, gitlab_instance=gitlab_instance) this_gitlab = GitlabGroupVariables(module=module, gitlab_instance=gitlab_instance)

75
plugins/modules/source_control/gitlab/gitlab_hook.py
View file

@ -176,14 +176,14 @@ from ansible.module_utils.api import basic_auth_argument_spec
from ansible.module_utils.basic import AnsibleModule, missing_required_lib from ansible.module_utils.basic import AnsibleModule, missing_required_lib
from ansible.module_utils.common.text.converters import to_native from ansible.module_utils.common.text.converters import to_native
from ansible_collections.community.general.plugins.module_utils.gitlab import findProject, gitlabAuthentication from ansible_collections.community.general.plugins.module_utils.gitlab import find_project, gitlab_authentication
class GitLabHook(object): class GitLabHook(object):
def __init__(self, module, gitlab_instance): def __init__(self, module, gitlab_instance):
self._module = module self._module = module
self._gitlab = gitlab_instance self._gitlab = gitlab_instance
self.hookObject = None self.hook_object = None
''' '''
@param project Project Object @param project Project Object
@ -191,12 +191,12 @@ class GitLabHook(object):
@param description Description of the group @param description Description of the group
@param parent Parent group full path @param parent Parent group full path
''' '''
def createOrUpdateHook(self, project, hook_url, options): def create_or_update_hook(self, project, hook_url, options):
changed = False changed = False
# Because we have already call userExists in main() # Because we have already call userExists in main()
if self.hookObject is None: if self.hook_object is None:
hook = self.createHook(project, { hook = self.create_hook(project, {
'url': hook_url, 'url': hook_url,
'push_events': options['push_events'], 'push_events': options['push_events'],
'push_events_branch_filter': options['push_events_branch_filter'], 'push_events_branch_filter': options['push_events_branch_filter'],
@ -208,10 +208,11 @@ class GitLabHook(object):
'pipeline_events': options['pipeline_events'], 'pipeline_events': options['pipeline_events'],
'wiki_page_events': options['wiki_page_events'], 'wiki_page_events': options['wiki_page_events'],
'enable_ssl_verification': options['enable_ssl_verification'], 'enable_ssl_verification': options['enable_ssl_verification'],
'token': options['token']}) 'token': options['token'],
})
changed = True changed = True
else: else:
changed, hook = self.updateHook(self.hookObject, { changed, hook = self.update_hook(self.hook_object, {
'push_events': options['push_events'], 'push_events': options['push_events'],
'push_events_branch_filter': options['push_events_branch_filter'], 'push_events_branch_filter': options['push_events_branch_filter'],
'issues_events': options['issues_events'], 'issues_events': options['issues_events'],
@ -222,9 +223,10 @@ class GitLabHook(object):
'pipeline_events': options['pipeline_events'], 'pipeline_events': options['pipeline_events'],
'wiki_page_events': options['wiki_page_events'], 'wiki_page_events': options['wiki_page_events'],
'enable_ssl_verification': options['enable_ssl_verification'], 'enable_ssl_verification': options['enable_ssl_verification'],
'token': options['token']}) 'token': options['token'],
})
self.hookObject = hook self.hook_object = hook
if changed: if changed:
if self._module.check_mode: if self._module.check_mode:
self._module.exit_json(changed=True, msg="Successfully created or updated the hook %s" % hook_url) self._module.exit_json(changed=True, msg="Successfully created or updated the hook %s" % hook_url)
@ -241,7 +243,7 @@ class GitLabHook(object):
@param project Project Object @param project Project Object
@param arguments Attributes of the hook @param arguments Attributes of the hook
''' '''
def createHook(self, project, arguments): def create_hook(self, project, arguments):
if self._module.check_mode: if self._module.check_mode:
return True return True
@ -253,7 +255,7 @@ class GitLabHook(object):
@param hook Hook Object @param hook Hook Object
@param arguments Attributes of the hook @param arguments Attributes of the hook
''' '''
def updateHook(self, hook, arguments): def update_hook(self, hook, arguments):
changed = False changed = False
for arg_key, arg_value in arguments.items(): for arg_key, arg_value in arguments.items():
@ -268,7 +270,7 @@ class GitLabHook(object):
@param project Project object @param project Project object
@param hook_url Url to call on event @param hook_url Url to call on event
''' '''
def findHook(self, project, hook_url): def find_hook(self, project, hook_url):
hooks = project.hooks.list() hooks = project.hooks.list()
for hook in hooks: for hook in hooks:
if (hook.url == hook_url): if (hook.url == hook_url):
@ -278,19 +280,19 @@ class GitLabHook(object):
@param project Project object @param project Project object
@param hook_url Url to call on event @param hook_url Url to call on event
''' '''
def existsHook(self, project, hook_url): def exists_hook(self, project, hook_url):
# When project exists, object will be stored in self.projectObject. # When project exists, object will be stored in self.project_object.
hook = self.findHook(project, hook_url) hook = self.find_hook(project, hook_url)
if hook: if hook:
self.hookObject = hook self.hook_object = hook
return True return True
return False return False
def deleteHook(self): def delete_hook(self):
if self._module.check_mode: if self._module.check_mode:
return True return True
return self.hookObject.delete() return self.hook_object.delete()
def main(): def main():
@ -346,41 +348,42 @@ def main():
if not HAS_GITLAB_PACKAGE: if not HAS_GITLAB_PACKAGE:
module.fail_json(msg=missing_required_lib("python-gitlab"), exception=GITLAB_IMP_ERR) module.fail_json(msg=missing_required_lib("python-gitlab"), exception=GITLAB_IMP_ERR)
gitlab_instance = gitlabAuthentication(module) gitlab_instance = gitlab_authentication(module)
gitlab_hook = GitLabHook(module, gitlab_instance) gitlab_hook = GitLabHook(module, gitlab_instance)
project = findProject(gitlab_instance, project_identifier) project = find_project(gitlab_instance, project_identifier)
if project is None: if project is None:
module.fail_json(msg="Failed to create hook: project %s doesn't exists" % project_identifier) module.fail_json(msg="Failed to create hook: project %s doesn't exists" % project_identifier)
hook_exists = gitlab_hook.existsHook(project, hook_url) hook_exists = gitlab_hook.exists_hook(project, hook_url)
if state == 'absent': if state == 'absent':
if hook_exists: if hook_exists:
gitlab_hook.deleteHook() gitlab_hook.delete_hook()
module.exit_json(changed=True, msg="Successfully deleted hook %s" % hook_url) module.exit_json(changed=True, msg="Successfully deleted hook %s" % hook_url)
else: else:
module.exit_json(changed=False, msg="Hook deleted or does not exists") module.exit_json(changed=False, msg="Hook deleted or does not exists")
if state == 'present': if state == 'present':
if gitlab_hook.createOrUpdateHook(project, hook_url, { if gitlab_hook.create_or_update_hook(project, hook_url, {
"push_events": push_events, "push_events": push_events,
"push_events_branch_filter": push_events_branch_filter, "push_events_branch_filter": push_events_branch_filter,
"issues_events": issues_events, "issues_events": issues_events,
"merge_requests_events": merge_requests_events, "merge_requests_events": merge_requests_events,
"tag_push_events": tag_push_events, "tag_push_events": tag_push_events,
"note_events": note_events, "note_events": note_events,
"job_events": job_events, "job_events": job_events,
"pipeline_events": pipeline_events, "pipeline_events": pipeline_events,
"wiki_page_events": wiki_page_events, "wiki_page_events": wiki_page_events,
"enable_ssl_verification": enable_ssl_verification, "enable_ssl_verification": enable_ssl_verification,
"token": hook_token}): "token": hook_token,
}):
module.exit_json(changed=True, msg="Successfully created or updated the hook %s" % hook_url, hook=gitlab_hook.hookObject._attrs) module.exit_json(changed=True, msg="Successfully created or updated the hook %s" % hook_url, hook=gitlab_hook.hook_object._attrs)
else: else:
module.exit_json(changed=False, msg="No need to update the hook %s" % hook_url, hook=gitlab_hook.hookObject._attrs) module.exit_json(changed=False, msg="No need to update the hook %s" % hook_url, hook=gitlab_hook.hook_object._attrs)
if __name__ == '__main__': if __name__ == '__main__':

88
plugins/modules/source_control/gitlab/gitlab_project.py
View file

@ -237,21 +237,21 @@ from ansible.module_utils.api import basic_auth_argument_spec
from ansible.module_utils.basic import AnsibleModule, missing_required_lib from ansible.module_utils.basic import AnsibleModule, missing_required_lib
from ansible.module_utils.common.text.converters import to_native from ansible.module_utils.common.text.converters import to_native
from ansible_collections.community.general.plugins.module_utils.gitlab import findGroup, findProject, gitlabAuthentication from ansible_collections.community.general.plugins.module_utils.gitlab import find_group, find_project, gitlab_authentication
class GitLabProject(object): class GitLabProject(object):
def __init__(self, module, gitlab_instance): def __init__(self, module, gitlab_instance):
self._module = module self._module = module
self._gitlab = gitlab_instance self._gitlab = gitlab_instance
self.projectObject = None self.project_object = None
''' '''
@param project_name Name of the project @param project_name Name of the project
@param namespace Namespace Object (User or Group) @param namespace Namespace Object (User or Group)
@param options Options of the project @param options Options of the project
''' '''
def createOrUpdateProject(self, project_name, namespace, options): def create_or_update_project(self, project_name, namespace, options):
changed = False changed = False
project_options = { project_options = {
'name': project_name, 'name': project_name,
@ -273,20 +273,20 @@ class GitLabProject(object):
'shared_runners_enabled': options['shared_runners_enabled'], 'shared_runners_enabled': options['shared_runners_enabled'],
} }
# Because we have already call userExists in main() # Because we have already call userExists in main()
if self.projectObject is None: if self.project_object is None:
project_options.update({ project_options.update({
'path': options['path'], 'path': options['path'],
'import_url': options['import_url'], 'import_url': options['import_url'],
}) })
if options['initialize_with_readme']: if options['initialize_with_readme']:
project_options['initialize_with_readme'] = options['initialize_with_readme'] project_options['initialize_with_readme'] = options['initialize_with_readme']
project_options = self.getOptionsWithValue(project_options) project_options = self.get_options_with_value(project_options)
project = self.createProject(namespace, project_options) project = self.create_project(namespace, project_options)
changed = True changed = True
else: else:
changed, project = self.updateProject(self.projectObject, project_options) changed, project = self.update_project(self.project_object, project_options)
self.projectObject = project self.project_object = project
if changed: if changed:
if self._module.check_mode: if self._module.check_mode:
self._module.exit_json(changed=True, msg="Successfully created or updated the project %s" % project_name) self._module.exit_json(changed=True, msg="Successfully created or updated the project %s" % project_name)
@ -302,7 +302,7 @@ class GitLabProject(object):
@param namespace Namespace Object (User or Group) @param namespace Namespace Object (User or Group)
@param arguments Attributes of the project @param arguments Attributes of the project
''' '''
def createProject(self, namespace, arguments): def create_project(self, namespace, arguments):
if self._module.check_mode: if self._module.check_mode:
return True return True
@ -317,7 +317,7 @@ class GitLabProject(object):
''' '''
@param arguments Attributes of the project @param arguments Attributes of the project
''' '''
def getOptionsWithValue(self, arguments): def get_options_with_value(self, arguments):
ret_arguments = dict() ret_arguments = dict()
for arg_key, arg_value in arguments.items(): for arg_key, arg_value in arguments.items():
if arguments[arg_key] is not None: if arguments[arg_key] is not None:
@ -329,7 +329,7 @@ class GitLabProject(object):
@param project Project Object @param project Project Object
@param arguments Attributes of the project @param arguments Attributes of the project
''' '''
def updateProject(self, project, arguments): def update_project(self, project, arguments):
changed = False changed = False
for arg_key, arg_value in arguments.items(): for arg_key, arg_value in arguments.items():
@ -340,11 +340,11 @@ class GitLabProject(object):
return (changed, project) return (changed, project)
def deleteProject(self): def delete_project(self):
if self._module.check_mode: if self._module.check_mode:
return True return True
project = self.projectObject project = self.project_object
return project.delete() return project.delete()
@ -352,11 +352,11 @@ class GitLabProject(object):
@param namespace User/Group object @param namespace User/Group object
@param name Name of the project @param name Name of the project
''' '''
def existsProject(self, namespace, path): def exists_project(self, namespace, path):
# When project exists, object will be stored in self.projectObject. # When project exists, object will be stored in self.project_object.
project = findProject(self._gitlab, namespace.full_path + '/' + path) project = find_project(self._gitlab, namespace.full_path + '/' + path)
if project: if project:
self.projectObject = project self.project_object = project
return True return True
return False return False
@ -433,7 +433,7 @@ def main():
if not HAS_GITLAB_PACKAGE: if not HAS_GITLAB_PACKAGE:
module.fail_json(msg=missing_required_lib("python-gitlab"), exception=GITLAB_IMP_ERR) module.fail_json(msg=missing_required_lib("python-gitlab"), exception=GITLAB_IMP_ERR)
gitlab_instance = gitlabAuthentication(module) gitlab_instance = gitlab_authentication(module)
# Set project_path to project_name if it is empty. # Set project_path to project_name if it is empty.
if project_path is None: if project_path is None:
@ -444,7 +444,7 @@ def main():
namespace = None namespace = None
namespace_id = None namespace_id = None
if group_identifier: if group_identifier:
group = findGroup(gitlab_instance, group_identifier) group = find_group(gitlab_instance, group_identifier)
if group is None: if group is None:
module.fail_json(msg="Failed to create project: group %s doesn't exists" % group_identifier) module.fail_json(msg="Failed to create project: group %s doesn't exists" % group_identifier)
@ -466,40 +466,40 @@ def main():
if not namespace: if not namespace:
module.fail_json(msg="Failed to find the namespace for the project") module.fail_json(msg="Failed to find the namespace for the project")
project_exists = gitlab_project.existsProject(namespace, project_path) project_exists = gitlab_project.exists_project(namespace, project_path)
if state == 'absent': if state == 'absent':
if project_exists: if project_exists:
gitlab_project.deleteProject() gitlab_project.delete_project()
module.exit_json(changed=True, msg="Successfully deleted project %s" % project_name) module.exit_json(changed=True, msg="Successfully deleted project %s" % project_name)
module.exit_json(changed=False, msg="Project deleted or does not exists") module.exit_json(changed=False, msg="Project deleted or does not exists")
if state == 'present': if state == 'present':
if gitlab_project.createOrUpdateProject(project_name, namespace, { if gitlab_project.create_or_update_project(project_name, namespace, {
"path": project_path, "path": project_path,
"description": project_description, "description": project_description,
"initialize_with_readme": initialize_with_readme, "initialize_with_readme": initialize_with_readme,
"issues_enabled": issues_enabled, "issues_enabled": issues_enabled,
"merge_requests_enabled": merge_requests_enabled, "merge_requests_enabled": merge_requests_enabled,
"merge_method": merge_method, "merge_method": merge_method,
"wiki_enabled": wiki_enabled, "wiki_enabled": wiki_enabled,
"snippets_enabled": snippets_enabled, "snippets_enabled": snippets_enabled,
"visibility": visibility, "visibility": visibility,
"import_url": import_url, "import_url": import_url,
"lfs_enabled": lfs_enabled, "lfs_enabled": lfs_enabled,
"allow_merge_on_skipped_pipeline": allow_merge_on_skipped_pipeline, "allow_merge_on_skipped_pipeline": allow_merge_on_skipped_pipeline,
"only_allow_merge_if_all_discussions_are_resolved": only_allow_merge_if_all_discussions_are_resolved, "only_allow_merge_if_all_discussions_are_resolved": only_allow_merge_if_all_discussions_are_resolved,
"only_allow_merge_if_pipeline_succeeds": only_allow_merge_if_pipeline_succeeds, "only_allow_merge_if_pipeline_succeeds": only_allow_merge_if_pipeline_succeeds,
"packages_enabled": packages_enabled, "packages_enabled": packages_enabled,
"remove_source_branch_after_merge": remove_source_branch_after_merge, "remove_source_branch_after_merge": remove_source_branch_after_merge,
"squash_option": squash_option, "squash_option": squash_option,
"ci_config_path": ci_config_path, "ci_config_path": ci_config_path,
"shared_runners_enabled": shared_runners_enabled, "shared_runners_enabled": shared_runners_enabled,
}): }):
module.exit_json(changed=True, msg="Successfully created or updated the project %s" % project_name, project=gitlab_project.projectObject._attrs) module.exit_json(changed=True, msg="Successfully created or updated the project %s" % project_name, project=gitlab_project.project_object._attrs)
module.exit_json(changed=False, msg="No need to update the project %s" % project_name, project=gitlab_project.projectObject._attrs) module.exit_json(changed=False, msg="No need to update the project %s" % project_name, project=gitlab_project.project_object._attrs)
if __name__ == '__main__': if __name__ == '__main__':

4
plugins/modules/source_control/gitlab/gitlab_project_members.py
View file

@ -176,7 +176,7 @@ RETURN = r''' # '''
from ansible.module_utils.api import basic_auth_argument_spec from ansible.module_utils.api import basic_auth_argument_spec
from ansible.module_utils.basic import AnsibleModule, missing_required_lib from ansible.module_utils.basic import AnsibleModule, missing_required_lib
from ansible_collections.community.general.plugins.module_utils.gitlab import gitlabAuthentication from ansible_collections.community.general.plugins.module_utils.gitlab import gitlab_authentication
import traceback import traceback
@ -317,7 +317,7 @@ def main():
purge_users = [access_level_int[level] for level in purge_users] purge_users = [access_level_int[level] for level in purge_users]
# connect to gitlab server # connect to gitlab server
gl = gitlabAuthentication(module) gl = gitlab_authentication(module)
project = GitLabProjectMembers(module, gl) project = GitLabProjectMembers(module, gl)

6
plugins/modules/source_control/gitlab/gitlab_project_variable.py
View file

@ -143,7 +143,7 @@ except Exception:
GITLAB_IMP_ERR = traceback.format_exc() GITLAB_IMP_ERR = traceback.format_exc()
HAS_GITLAB_PACKAGE = False HAS_GITLAB_PACKAGE = False
from ansible_collections.community.general.plugins.module_utils.gitlab import gitlabAuthentication from ansible_collections.community.general.plugins.module_utils.gitlab import gitlab_authentication
class GitlabProjectVariables(object): class GitlabProjectVariables(object):
@ -172,7 +172,7 @@ class GitlabProjectVariables(object):
var = { var = {
"key": key, "value": value, "key": key, "value": value,
"masked": masked, "protected": protected, "masked": masked, "protected": protected,
"variable_type": variable_type "variable_type": variable_type,
} }
if environment_scope is not None: if environment_scope is not None:
var["environment_scope"] = environment_scope var["environment_scope"] = environment_scope
@ -300,7 +300,7 @@ def main():
if not HAS_GITLAB_PACKAGE: if not HAS_GITLAB_PACKAGE:
module.fail_json(msg=missing_required_lib("python-gitlab"), exception=GITLAB_IMP_ERR) module.fail_json(msg=missing_required_lib("python-gitlab"), exception=GITLAB_IMP_ERR)
gitlab_instance = gitlabAuthentication(module) gitlab_instance = gitlab_authentication(module)
this_gitlab = GitlabProjectVariables(module=module, gitlab_instance=gitlab_instance) this_gitlab = GitlabProjectVariables(module=module, gitlab_instance=gitlab_instance)

4
plugins/modules/source_control/gitlab/gitlab_protected_branch.py
View file

@ -87,7 +87,7 @@ except Exception:
GITLAB_IMP_ERR = traceback.format_exc() GITLAB_IMP_ERR = traceback.format_exc()
HAS_GITLAB_PACKAGE = False HAS_GITLAB_PACKAGE = False
from ansible_collections.community.general.plugins.module_utils.gitlab import gitlabAuthentication from ansible_collections.community.general.plugins.module_utils.gitlab import gitlab_authentication
class GitlabProtectedBranch(object): class GitlabProtectedBranch(object):
@ -179,7 +179,7 @@ def main():
module.fail_json(msg="community.general.gitlab_proteched_branch requires python-gitlab Python module >= 2.3.0 (installed version: [%s])." module.fail_json(msg="community.general.gitlab_proteched_branch requires python-gitlab Python module >= 2.3.0 (installed version: [%s])."
" Please upgrade python-gitlab to version 2.3.0 or above." % gitlab_version) " Please upgrade python-gitlab to version 2.3.0 or above." % gitlab_version)
gitlab_instance = gitlabAuthentication(module) gitlab_instance = gitlab_authentication(module)
this_gitlab = GitlabProtectedBranch(module=module, project=project, gitlab_instance=gitlab_instance) this_gitlab = GitlabProtectedBranch(module=module, project=project, gitlab_instance=gitlab_instance)
p_branch = this_gitlab.protected_branch_exist(name=name) p_branch = this_gitlab.protected_branch_exist(name=name)

65
plugins/modules/source_control/gitlab/gitlab_runner.py
View file

@ -186,7 +186,7 @@ from ansible.module_utils.api import basic_auth_argument_spec
from ansible.module_utils.basic import AnsibleModule, missing_required_lib from ansible.module_utils.basic import AnsibleModule, missing_required_lib
from ansible.module_utils.common.text.converters import to_native from ansible.module_utils.common.text.converters import to_native
from ansible_collections.community.general.plugins.module_utils.gitlab import gitlabAuthentication from ansible_collections.community.general.plugins.module_utils.gitlab import gitlab_authentication
try: try:
cmp cmp
@ -203,32 +203,34 @@ class GitLabRunner(object):
# See https://gitlab.com/gitlab-org/gitlab-ce/issues/60774 # See https://gitlab.com/gitlab-org/gitlab-ce/issues/60774
# for group runner token access # for group runner token access
self._runners_endpoint = project.runners if project else gitlab_instance.runners self._runners_endpoint = project.runners if project else gitlab_instance.runners
self.runnerObject = None self.runner_object = None
def createOrUpdateRunner(self, description, options): def create_or_update_runner(self, description, options):
changed = False changed = False
# Because we have already call userExists in main() # Because we have already call userExists in main()
if self.runnerObject is None: if self.runner_object is None:
runner = self.createRunner({ runner = self.create_runner({
'description': description, 'description': description,
'active': options['active'], 'active': options['active'],
'token': options['registration_token'], 'token': options['registration_token'],
'locked': options['locked'], 'locked': options['locked'],
'run_untagged': options['run_untagged'], 'run_untagged': options['run_untagged'],
'maximum_timeout': options['maximum_timeout'], 'maximum_timeout': options['maximum_timeout'],
'tag_list': options['tag_list']}) 'tag_list': options['tag_list'],
})
changed = True changed = True
else: else:
changed, runner = self.updateRunner(self.runnerObject, { changed, runner = self.update_runner(self.runner_object, {
'active': options['active'], 'active': options['active'],
'locked': options['locked'], 'locked': options['locked'],
'run_untagged': options['run_untagged'], 'run_untagged': options['run_untagged'],
'maximum_timeout': options['maximum_timeout'], 'maximum_timeout': options['maximum_timeout'],
'access_level': options['access_level'], 'access_level': options['access_level'],
'tag_list': options['tag_list']}) 'tag_list': options['tag_list'],
})
self.runnerObject = runner self.runner_object = runner
if changed: if changed:
if self._module.check_mode: if self._module.check_mode:
self._module.exit_json(changed=True, msg="Successfully created or updated the runner %s" % description) self._module.exit_json(changed=True, msg="Successfully created or updated the runner %s" % description)
@ -244,7 +246,7 @@ class GitLabRunner(object):
''' '''
@param arguments Attributes of the runner @param arguments Attributes of the runner
''' '''
def createRunner(self, arguments): def create_runner(self, arguments):
if self._module.check_mode: if self._module.check_mode:
return True return True
@ -259,7 +261,7 @@ class GitLabRunner(object):
@param runner Runner object @param runner Runner object
@param arguments Attributes of the runner @param arguments Attributes of the runner
''' '''
def updateRunner(self, runner, arguments): def update_runner(self, runner, arguments):
changed = False changed = False
for arg_key, arg_value in arguments.items(): for arg_key, arg_value in arguments.items():
@ -282,7 +284,7 @@ class GitLabRunner(object):
''' '''
@param description Description of the runner @param description Description of the runner
''' '''
def findRunner(self, description, owned=False): def find_runner(self, description, owned=False):
if owned: if owned:
runners = self._runners_endpoint.list(as_list=False) runners = self._runners_endpoint.list(as_list=False)
else: else:
@ -301,20 +303,20 @@ class GitLabRunner(object):
''' '''
@param description Description of the runner @param description Description of the runner
''' '''
def existsRunner(self, description, owned=False): def exists_runner(self, description, owned=False):
# When runner exists, object will be stored in self.runnerObject. # When runner exists, object will be stored in self.runner_object.
runner = self.findRunner(description, owned) runner = self.find_runner(description, owned)
if runner: if runner:
self.runnerObject = runner self.runner_object = runner
return True return True
return False return False
def deleteRunner(self): def delete_runner(self):
if self._module.check_mode: if self._module.check_mode:
return True return True
runner = self.runnerObject runner = self.runner_object
return runner.delete() return runner.delete()
@ -369,7 +371,7 @@ def main():
if not HAS_GITLAB_PACKAGE: if not HAS_GITLAB_PACKAGE:
module.fail_json(msg=missing_required_lib("python-gitlab"), exception=GITLAB_IMP_ERR) module.fail_json(msg=missing_required_lib("python-gitlab"), exception=GITLAB_IMP_ERR)
gitlab_instance = gitlabAuthentication(module) gitlab_instance = gitlab_authentication(module)
gitlab_project = None gitlab_project = None
if project: if project:
try: try:
@ -378,28 +380,29 @@ def main():
module.fail_json(msg='No such a project %s' % project, exception=to_native(e)) module.fail_json(msg='No such a project %s' % project, exception=to_native(e))
gitlab_runner = GitLabRunner(module, gitlab_instance, gitlab_project) gitlab_runner = GitLabRunner(module, gitlab_instance, gitlab_project)
runner_exists = gitlab_runner.existsRunner(runner_description, owned) runner_exists = gitlab_runner.exists_runner(runner_description, owned)
if state == 'absent': if state == 'absent':
if runner_exists: if runner_exists:
gitlab_runner.deleteRunner() gitlab_runner.delete_runner()
module.exit_json(changed=True, msg="Successfully deleted runner %s" % runner_description) module.exit_json(changed=True, msg="Successfully deleted runner %s" % runner_description)
else: else:
module.exit_json(changed=False, msg="Runner deleted or does not exists") module.exit_json(changed=False, msg="Runner deleted or does not exists")
if state == 'present': if state == 'present':
if gitlab_runner.createOrUpdateRunner(runner_description, { if gitlab_runner.create_or_update_runner(runner_description, {
"active": runner_active, "active": runner_active,
"tag_list": tag_list, "tag_list": tag_list,
"run_untagged": run_untagged, "run_untagged": run_untagged,
"locked": runner_locked, "locked": runner_locked,
"access_level": access_level, "access_level": access_level,
"maximum_timeout": maximum_timeout, "maximum_timeout": maximum_timeout,
"registration_token": registration_token}): "registration_token": registration_token,
module.exit_json(changed=True, runner=gitlab_runner.runnerObject._attrs, }):
module.exit_json(changed=True, runner=gitlab_runner.runner_object._attrs,
msg="Successfully created or updated the runner %s" % runner_description) msg="Successfully created or updated the runner %s" % runner_description)
else: else:
module.exit_json(changed=False, runner=gitlab_runner.runnerObject._attrs, module.exit_json(changed=False, runner=gitlab_runner.runner_object._attrs,
msg="No need to update the runner %s" % runner_description) msg="No need to update the runner %s" % runner_description)

140
plugins/modules/source_control/gitlab/gitlab_user.py
View file

@ -238,33 +238,34 @@ from ansible.module_utils.api import basic_auth_argument_spec
from ansible.module_utils.basic import AnsibleModule, missing_required_lib from ansible.module_utils.basic import AnsibleModule, missing_required_lib
from ansible.module_utils.common.text.converters import to_native from ansible.module_utils.common.text.converters import to_native
from ansible_collections.community.general.plugins.module_utils.gitlab import findGroup, gitlabAuthentication from ansible_collections.community.general.plugins.module_utils.gitlab import find_group, gitlab_authentication
class GitLabUser(object): class GitLabUser(object):
def __init__(self, module, gitlab_instance): def __init__(self, module, gitlab_instance):
self._module = module self._module = module
self._gitlab = gitlab_instance self._gitlab = gitlab_instance
self.userObject = None self.user_object = None
self.ACCESS_LEVEL = { self.ACCESS_LEVEL = {
'guest': gitlab.GUEST_ACCESS, 'guest': gitlab.GUEST_ACCESS,
'reporter': gitlab.REPORTER_ACCESS, 'reporter': gitlab.REPORTER_ACCESS,
'developer': gitlab.DEVELOPER_ACCESS, 'developer': gitlab.DEVELOPER_ACCESS,
'master': gitlab.MAINTAINER_ACCESS, 'master': gitlab.MAINTAINER_ACCESS,
'maintainer': gitlab.MAINTAINER_ACCESS, 'maintainer': gitlab.MAINTAINER_ACCESS,
'owner': gitlab.OWNER_ACCESS} 'owner': gitlab.OWNER_ACCESS,
}
''' '''
@param username Username of the user @param username Username of the user
@param options User options @param options User options
''' '''
def createOrUpdateUser(self, username, options): def create_or_update_user(self, username, options):
changed = False changed = False
potentionally_changed = False potentionally_changed = False
# Because we have already call userExists in main() # Because we have already call userExists in main()
if self.userObject is None: if self.user_object is None:
user = self.createUser({ user = self.create_user({
'name': options['name'], 'name': options['name'],
'username': username, 'username': username,
'password': options['password'], 'password': options['password'],
@ -277,8 +278,8 @@ class GitLabUser(object):
}) })
changed = True changed = True
else: else:
changed, user = self.updateUser( changed, user = self.update_user(
self.userObject, { self.user_object, {
# add "normal" parameters here, put uncheckable # add "normal" parameters here, put uncheckable
# params in the dict below # params in the dict below
'name': {'value': options['name']}, 'name': {'value': options['name']},
@ -313,7 +314,7 @@ class GitLabUser(object):
# Assign ssh keys # Assign ssh keys
if options['sshkey_name'] and options['sshkey_file']: if options['sshkey_name'] and options['sshkey_file']:
key_changed = self.addSshKeyToUser(user, { key_changed = self.add_ssh_key_to_user(user, {
'name': options['sshkey_name'], 'name': options['sshkey_name'],
'file': options['sshkey_file'], 'file': options['sshkey_file'],
'expires_at': options['sshkey_expires_at']}) 'expires_at': options['sshkey_expires_at']})
@ -321,10 +322,10 @@ class GitLabUser(object):
# Assign group # Assign group
if options['group_path']: if options['group_path']:
group_changed = self.assignUserToGroup(user, options['group_path'], options['access_level']) group_changed = self.assign_user_to_group(user, options['group_path'], options['access_level'])
changed = changed or group_changed changed = changed or group_changed
self.userObject = user self.user_object = user
if (changed or potentionally_changed) and not self._module.check_mode: if (changed or potentionally_changed) and not self._module.check_mode:
try: try:
user.save() user.save()
@ -341,7 +342,7 @@ class GitLabUser(object):
''' '''
@param group User object @param group User object
''' '''
def getUserId(self, user): def get_user_id(self, user):
if user is not None: if user is not None:
return user.id return user.id
return None return None
@ -350,7 +351,7 @@ class GitLabUser(object):
@param user User object @param user User object
@param sshkey_name Name of the ssh key @param sshkey_name Name of the ssh key
''' '''
def sshKeyExists(self, user, sshkey_name): def ssh_key_exists(self, user, sshkey_name):
keyList = map(lambda k: k.title, user.keys.list()) keyList = map(lambda k: k.title, user.keys.list())
return sshkey_name in keyList return sshkey_name in keyList
@ -359,8 +360,8 @@ class GitLabUser(object):
@param user User object @param user User object
@param sshkey Dict containing sshkey infos {"name": "", "file": "", "expires_at": ""} @param sshkey Dict containing sshkey infos {"name": "", "file": "", "expires_at": ""}
''' '''
def addSshKeyToUser(self, user, sshkey): def add_ssh_key_to_user(self, user, sshkey):
if not self.sshKeyExists(user, sshkey['name']): if not self.ssh_key_exists(user, sshkey['name']):
if self._module.check_mode: if self._module.check_mode:
return True return True
@ -381,7 +382,7 @@ class GitLabUser(object):
@param group Group object @param group Group object
@param user_id Id of the user to find @param user_id Id of the user to find
''' '''
def findMember(self, group, user_id): def find_member(self, group, user_id):
try: try:
member = group.members.get(user_id) member = group.members.get(user_id)
except gitlab.exceptions.GitlabGetError: except gitlab.exceptions.GitlabGetError:
@ -392,8 +393,8 @@ class GitLabUser(object):
@param group Group object @param group Group object
@param user_id Id of the user to check @param user_id Id of the user to check
''' '''
def memberExists(self, group, user_id): def member_exists(self, group, user_id):
member = self.findMember(group, user_id) member = self.find_member(group, user_id)
return member is not None return member is not None
@ -402,8 +403,8 @@ class GitLabUser(object):
@param user_id Id of the user to check @param user_id Id of the user to check
@param access_level GitLab access_level to check @param access_level GitLab access_level to check
''' '''
def memberAsGoodAccessLevel(self, group, user_id, access_level): def member_as_good_access_level(self, group, user_id, access_level):
member = self.findMember(group, user_id) member = self.find_member(group, user_id)
return member.access_level == access_level return member.access_level == access_level
@ -412,8 +413,8 @@ class GitLabUser(object):
@param group_path Complete path of the Group including parent group path. <parent_path>/<group_path> @param group_path Complete path of the Group including parent group path. <parent_path>/<group_path>
@param access_level GitLab access_level to assign @param access_level GitLab access_level to assign
''' '''
def assignUserToGroup(self, user, group_identifier, access_level): def assign_user_to_group(self, user, group_identifier, access_level):
group = findGroup(self._gitlab, group_identifier) group = find_group(self._gitlab, group_identifier)
if self._module.check_mode: if self._module.check_mode:
return True return True
@ -421,16 +422,16 @@ class GitLabUser(object):
if group is None: if group is None:
return False return False
if self.memberExists(group, self.getUserId(user)): if self.member_exists(group, self.get_user_id(user)):
member = self.findMember(group, self.getUserId(user)) member = self.find_member(group, self.get_user_id(user))
if not self.memberAsGoodAccessLevel(group, member.id, self.ACCESS_LEVEL[access_level]): if not self.member_as_good_access_level(group, member.id, self.ACCESS_LEVEL[access_level]):
member.access_level = self.ACCESS_LEVEL[access_level] member.access_level = self.ACCESS_LEVEL[access_level]
member.save() member.save()
return True return True
else: else:
try: try:
group.members.create({ group.members.create({
'user_id': self.getUserId(user), 'user_id': self.get_user_id(user),
'access_level': self.ACCESS_LEVEL[access_level]}) 'access_level': self.ACCESS_LEVEL[access_level]})
except gitlab.exceptions.GitlabCreateError as e: except gitlab.exceptions.GitlabCreateError as e:
self._module.fail_json(msg="Failed to assign user to group: %s" % to_native(e)) self._module.fail_json(msg="Failed to assign user to group: %s" % to_native(e))
@ -441,7 +442,7 @@ class GitLabUser(object):
@param user User object @param user User object
@param arguments User attributes @param arguments User attributes
''' '''
def updateUser(self, user, arguments, uncheckable_args): def update_user(self, user, arguments, uncheckable_args):
changed = False changed = False
for arg_key, arg_value in arguments.items(): for arg_key, arg_value in arguments.items():
@ -449,7 +450,7 @@ class GitLabUser(object):
if av is not None: if av is not None:
if arg_key == "identities": if arg_key == "identities":
changed = self.addIdentities(user, av, uncheckable_args['overwrite_identities']['value']) changed = self.add_identities(user, av, uncheckable_args['overwrite_identities']['value'])
elif getattr(user, arg_key) != av: elif getattr(user, arg_key) != av:
setattr(user, arg_value.get('setter', arg_key), av) setattr(user, arg_value.get('setter', arg_key), av)
@ -466,7 +467,7 @@ class GitLabUser(object):
''' '''
@param arguments User attributes @param arguments User attributes
''' '''
def createUser(self, arguments): def create_user(self, arguments):
if self._module.check_mode: if self._module.check_mode:
return True return True
@ -478,7 +479,7 @@ class GitLabUser(object):
try: try:
user = self._gitlab.users.create(arguments) user = self._gitlab.users.create(arguments)
if identities: if identities:
self.addIdentities(user, identities) self.add_identities(user, identities)
except (gitlab.exceptions.GitlabCreateError) as e: except (gitlab.exceptions.GitlabCreateError) as e:
self._module.fail_json(msg="Failed to create user: %s " % to_native(e)) self._module.fail_json(msg="Failed to create user: %s " % to_native(e))
@ -490,10 +491,10 @@ class GitLabUser(object):
@param identites List of identities to be added/updated @param identites List of identities to be added/updated
@param overwrite_identities Overwrite user identities with identities passed to this module @param overwrite_identities Overwrite user identities with identities passed to this module
''' '''
def addIdentities(self, user, identities, overwrite_identities=False): def add_identities(self, user, identities, overwrite_identities=False):
changed = False changed = False
if overwrite_identities: if overwrite_identities:
changed = self.deleteIdentities(user, identities) changed = self.delete_identities(user, identities)
for identity in identities: for identity in identities:
if identity not in user.identities: if identity not in user.identities:
@ -508,7 +509,7 @@ class GitLabUser(object):
@param user User object @param user User object
@param identites List of identities to be added/updated @param identites List of identities to be added/updated
''' '''
def deleteIdentities(self, user, identities): def delete_identities(self, user, identities):
changed = False changed = False
for identity in user.identities: for identity in user.identities:
if identity not in identities: if identity not in identities:
@ -520,7 +521,7 @@ class GitLabUser(object):
''' '''
@param username Username of the user @param username Username of the user
''' '''
def findUser(self, username): def find_user(self, username):
users = self._gitlab.users.list(search=username) users = self._gitlab.users.list(search=username)
for user in users: for user in users:
if (user.username == username): if (user.username == username):
@ -529,42 +530,42 @@ class GitLabUser(object):
''' '''
@param username Username of the user @param username Username of the user
''' '''
def existsUser(self, username): def exists_user(self, username):
# When user exists, object will be stored in self.userObject. # When user exists, object will be stored in self.user_object.
user = self.findUser(username) user = self.find_user(username)
if user: if user:
self.userObject = user self.user_object = user
return True return True
return False return False
''' '''
@param username Username of the user @param username Username of the user
''' '''
def isActive(self, username): def is_active(self, username):
user = self.findUser(username) user = self.find_user(username)
return user.attributes['state'] == 'active' return user.attributes['state'] == 'active'
def deleteUser(self): def delete_user(self):
if self._module.check_mode: if self._module.check_mode:
return True return True
user = self.userObject user = self.user_object
return user.delete() return user.delete()
def blockUser(self): def block_user(self):
if self._module.check_mode: if self._module.check_mode:
return True return True
user = self.userObject user = self.user_object
return user.block() return user.block()
def unblockUser(self): def unblock_user(self):
if self._module.check_mode: if self._module.check_mode:
return True return True
user = self.userObject user = self.user_object
return user.unblock() return user.unblock()
@ -636,55 +637,56 @@ def main():
if not HAS_GITLAB_PACKAGE: if not HAS_GITLAB_PACKAGE:
module.fail_json(msg=missing_required_lib("python-gitlab"), exception=GITLAB_IMP_ERR) module.fail_json(msg=missing_required_lib("python-gitlab"), exception=GITLAB_IMP_ERR)
gitlab_instance = gitlabAuthentication(module) gitlab_instance = gitlab_authentication(module)
gitlab_user = GitLabUser(module, gitlab_instance) gitlab_user = GitLabUser(module, gitlab_instance)
user_exists = gitlab_user.existsUser(user_username) user_exists = gitlab_user.exists_user(user_username)
if user_exists: if user_exists:
user_is_active = gitlab_user.isActive(user_username) user_is_active = gitlab_user.is_active(user_username)
else: else:
user_is_active = False user_is_active = False
if state == 'absent': if state == 'absent':
if user_exists: if user_exists:
gitlab_user.deleteUser() gitlab_user.delete_user()
module.exit_json(changed=True, msg="Successfully deleted user %s" % user_username) module.exit_json(changed=True, msg="Successfully deleted user %s" % user_username)
else: else:
module.exit_json(changed=False, msg="User deleted or does not exists") module.exit_json(changed=False, msg="User deleted or does not exists")
if state == 'blocked': if state == 'blocked':
if user_exists and user_is_active: if user_exists and user_is_active:
gitlab_user.blockUser() gitlab_user.block_user()
module.exit_json(changed=True, msg="Successfully blocked user %s" % user_username) module.exit_json(changed=True, msg="Successfully blocked user %s" % user_username)
else: else:
module.exit_json(changed=False, msg="User already blocked or does not exists") module.exit_json(changed=False, msg="User already blocked or does not exists")
if state == 'unblocked': if state == 'unblocked':
if user_exists and not user_is_active: if user_exists and not user_is_active:
gitlab_user.unblockUser() gitlab_user.unblock_user()
module.exit_json(changed=True, msg="Successfully unblocked user %s" % user_username) module.exit_json(changed=True, msg="Successfully unblocked user %s" % user_username)
else: else:
module.exit_json(changed=False, msg="User is not blocked or does not exists") module.exit_json(changed=False, msg="User is not blocked or does not exists")
if state == 'present': if state == 'present':
if gitlab_user.createOrUpdateUser(user_username, { if gitlab_user.create_or_update_user(user_username, {
"name": user_name, "name": user_name,
"password": user_password, "password": user_password,
"reset_password": user_reset_password, "reset_password": user_reset_password,
"email": user_email, "email": user_email,
"sshkey_name": user_sshkey_name, "sshkey_name": user_sshkey_name,
"sshkey_file": user_sshkey_file, "sshkey_file": user_sshkey_file,
"sshkey_expires_at": user_sshkey_expires_at, "sshkey_expires_at": user_sshkey_expires_at,
"group_path": group_path, "group_path": group_path,
"access_level": access_level, "access_level": access_level,
"confirm": confirm, "confirm": confirm,
"isadmin": user_isadmin, "isadmin": user_isadmin,
"external": user_external, "external": user_external,
"identities": user_identities, "identities": user_identities,
"overwrite_identities": overwrite_identities}): "overwrite_identities": overwrite_identities,
module.exit_json(changed=True, msg="Successfully created or updated the user %s" % user_username, user=gitlab_user.userObject._attrs) }):
module.exit_json(changed=True, msg="Successfully created or updated the user %s" % user_username, user=gitlab_user.user_object._attrs)
else: else:
module.exit_json(changed=False, msg="No need to update the user %s" % user_username, user=gitlab_user.userObject._attrs) module.exit_json(changed=False, msg="No need to update the user %s" % user_username, user=gitlab_user.user_object._attrs)
if __name__ == '__main__': if __name__ == '__main__':

24
tests/unit/plugins/modules/source_control/gitlab/test_gitlab_deploy_key.py
View file

@ -55,11 +55,11 @@ class TestGitlabDeployKey(GitlabModuleTestCase):
def test_deploy_key_exist(self): def test_deploy_key_exist(self):
project = self.gitlab_instance.projects.get(1) project = self.gitlab_instance.projects.get(1)
rvalue = self.moduleUtil.existsDeployKey(project, "Public key") rvalue = self.moduleUtil.exists_deploy_key(project, "Public key")
self.assertEqual(rvalue, True) self.assertEqual(rvalue, True)
rvalue = self.moduleUtil.existsDeployKey(project, "Private key") rvalue = self.moduleUtil.exists_deploy_key(project, "Private key")
self.assertEqual(rvalue, False) self.assertEqual(rvalue, False)
@ -68,11 +68,11 @@ class TestGitlabDeployKey(GitlabModuleTestCase):
def test_create_deploy_key(self): def test_create_deploy_key(self):
project = self.gitlab_instance.projects.get(1) project = self.gitlab_instance.projects.get(1)
deploy_key = self.moduleUtil.createDeployKey(project, {"title": "Public key", deploy_key = self.moduleUtil.create_deploy_key(project, {"title": "Public key",
"key": "ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAAIEAiPWx6WM" "key": "ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAAIEAiPWx6WM"
"4lhHNedGfBpPJNPpZ7yKu+dnn1SJejgt4596k6YjzGGphH2TUxwKzxc" "4lhHNedGfBpPJNPpZ7yKu+dnn1SJejgt4596k6YjzGGphH2TUxwKzxc"
"KDKKezwkpfnxPkSMkuEspGRt/aZZ9wa++Oi7Qkr8prgHc4soW6NUlfD" "KDKKezwkpfnxPkSMkuEspGRt/aZZ9wa++Oi7Qkr8prgHc4soW6NUlfD"
"zpvZK2H5E7eQaSeP3SAwGmQKUFHCddNaP0L+hM7zhFNzjFvpaMgJw0="}) "zpvZK2H5E7eQaSeP3SAwGmQKUFHCddNaP0L+hM7zhFNzjFvpaMgJw0="})
self.assertEqual(type(deploy_key), ProjectKey) self.assertEqual(type(deploy_key), ProjectKey)
self.assertEqual(deploy_key.title, "Public key") self.assertEqual(deploy_key.title, "Public key")
@ -82,15 +82,15 @@ class TestGitlabDeployKey(GitlabModuleTestCase):
@with_httmock(resp_create_project_deploy_key) @with_httmock(resp_create_project_deploy_key)
def test_update_deploy_key(self): def test_update_deploy_key(self):
project = self.gitlab_instance.projects.get(1) project = self.gitlab_instance.projects.get(1)
deployKey = self.moduleUtil.findDeployKey(project, "Public key") deploy_key = self.moduleUtil.find_deploy_key(project, "Public key")
changed, newDeploy_key = self.moduleUtil.updateDeployKey(deployKey, {"title": "Private key"}) changed, newDeploy_key = self.moduleUtil.update_deploy_key(deploy_key, {"title": "Private key"})
self.assertEqual(changed, True) self.assertEqual(changed, True)
self.assertEqual(type(newDeploy_key), ProjectKey) self.assertEqual(type(newDeploy_key), ProjectKey)
self.assertEqual(newDeploy_key.title, "Private key") self.assertEqual(newDeploy_key.title, "Private key")
changed, newDeploy_key = self.moduleUtil.updateDeployKey(deployKey, {"title": "Private key"}) changed, newDeploy_key = self.moduleUtil.update_deploy_key(deploy_key, {"title": "Private key"})
self.assertEqual(changed, False) self.assertEqual(changed, False)
self.assertEqual(newDeploy_key.title, "Private key") self.assertEqual(newDeploy_key.title, "Private key")
@ -101,8 +101,8 @@ class TestGitlabDeployKey(GitlabModuleTestCase):
def test_delete_deploy_key(self): def test_delete_deploy_key(self):
project = self.gitlab_instance.projects.get(1) project = self.gitlab_instance.projects.get(1)
self.moduleUtil.existsDeployKey(project, "Public key") self.moduleUtil.exists_deploy_key(project, "Public key")
rvalue = self.moduleUtil.deleteDeployKey() rvalue = self.moduleUtil.delete_deploy_key()
self.assertEqual(rvalue, None) self.assertEqual(rvalue, None)

45
tests/unit/plugins/modules/source_control/gitlab/test_gitlab_group.py
View file

@ -54,24 +54,25 @@ class TestGitlabGroup(GitlabModuleTestCase):
@with_httmock(resp_get_group) @with_httmock(resp_get_group)
def test_exist_group(self): def test_exist_group(self):
rvalue = self.moduleUtil.existsGroup(1) rvalue = self.moduleUtil.exists_group(1)
self.assertEqual(rvalue, True) self.assertEqual(rvalue, True)
@with_httmock(resp_get_missing_group) @with_httmock(resp_get_missing_group)
def test_exist_group(self): def test_exist_group(self):
rvalue = self.moduleUtil.existsGroup(1) rvalue = self.moduleUtil.exists_group(1)
self.assertEqual(rvalue, False) self.assertEqual(rvalue, False)
@with_httmock(resp_create_group) @with_httmock(resp_create_group)
def test_create_group(self): def test_create_group(self):
group = self.moduleUtil.createGroup({'name': "Foobar Group", group = self.moduleUtil.create_group({'name': "Foobar Group",
'path': "foo-bar", 'path': "foo-bar",
'description': "An interesting group", 'description': "An interesting group",
'project_creation_level': "developer", 'project_creation_level': "developer",
'subgroup_creation_level': "maintainer", 'subgroup_creation_level': "maintainer",
'require_two_factor_authentication': True}) 'require_two_factor_authentication': True,
})
self.assertEqual(type(group), Group) self.assertEqual(type(group), Group)
self.assertEqual(group.name, "Foobar Group") self.assertEqual(group.name, "Foobar Group")
@ -84,11 +85,12 @@ class TestGitlabGroup(GitlabModuleTestCase):
@with_httmock(resp_create_subgroup) @with_httmock(resp_create_subgroup)
def test_create_subgroup(self): def test_create_subgroup(self):
group = self.moduleUtil.createGroup({'name': "BarFoo Group", group = self.moduleUtil.create_group({'name': "BarFoo Group",
'path': "bar-foo", 'path': "bar-foo",
'parent_id': 1, 'parent_id': 1,
'project_creation_level': "noone", 'project_creation_level': "noone",
'require_two_factor_authentication': True}) 'require_two_factor_authentication': True,
})
self.assertEqual(type(group), Group) self.assertEqual(type(group), Group)
self.assertEqual(group.name, "BarFoo Group") self.assertEqual(group.name, "BarFoo Group")
@ -101,10 +103,11 @@ class TestGitlabGroup(GitlabModuleTestCase):
@with_httmock(resp_get_group) @with_httmock(resp_get_group)
def test_update_group(self): def test_update_group(self):
group = self.gitlab_instance.groups.get(1) group = self.gitlab_instance.groups.get(1)
changed, newGroup = self.moduleUtil.updateGroup(group, {'name': "BarFoo Group", changed, newGroup = self.moduleUtil.update_group(group, {'name': "BarFoo Group",
'visibility': "private", 'visibility': "private",
'project_creation_level': "maintainer", 'project_creation_level': "maintainer",
'require_two_factor_authentication': True}) 'require_two_factor_authentication': True,
})
self.assertEqual(changed, True) self.assertEqual(changed, True)
self.assertEqual(newGroup.name, "BarFoo Group") self.assertEqual(newGroup.name, "BarFoo Group")
@ -112,7 +115,7 @@ class TestGitlabGroup(GitlabModuleTestCase):
self.assertEqual(newGroup.project_creation_level, "maintainer") self.assertEqual(newGroup.project_creation_level, "maintainer")
self.assertEqual(newGroup.require_two_factor_authentication, True) self.assertEqual(newGroup.require_two_factor_authentication, True)
changed, newGroup = self.moduleUtil.updateGroup(group, {'name': "BarFoo Group"}) changed, newGroup = self.moduleUtil.update_group(group, {'name': "BarFoo Group"})
self.assertEqual(changed, False) self.assertEqual(changed, False)
@ -120,10 +123,10 @@ class TestGitlabGroup(GitlabModuleTestCase):
@with_httmock(resp_find_group_project) @with_httmock(resp_find_group_project)
@with_httmock(resp_delete_group) @with_httmock(resp_delete_group)
def test_delete_group(self): def test_delete_group(self):
self.moduleUtil.existsGroup(1) self.moduleUtil.exists_group(1)
print(self.moduleUtil.groupObject.projects) print(self.moduleUtil.group_object.projects)
rvalue = self.moduleUtil.deleteGroup() rvalue = self.moduleUtil.delete_group()
self.assertEqual(rvalue, None) self.assertEqual(rvalue, None)

16
tests/unit/plugins/modules/source_control/gitlab/test_gitlab_hook.py
View file

@ -55,11 +55,11 @@ class TestGitlabHook(GitlabModuleTestCase):
def test_hook_exist(self): def test_hook_exist(self):
project = self.gitlab_instance.projects.get(1) project = self.gitlab_instance.projects.get(1)
rvalue = self.moduleUtil.existsHook(project, "http://example.com/hook") rvalue = self.moduleUtil.exists_hook(project, "http://example.com/hook")
self.assertEqual(rvalue, True) self.assertEqual(rvalue, True)
rvalue = self.moduleUtil.existsHook(project, "http://gitlab.com/hook") rvalue = self.moduleUtil.exists_hook(project, "http://gitlab.com/hook")
self.assertEqual(rvalue, False) self.assertEqual(rvalue, False)
@ -68,7 +68,7 @@ class TestGitlabHook(GitlabModuleTestCase):
def test_create_hook(self): def test_create_hook(self):
project = self.gitlab_instance.projects.get(1) project = self.gitlab_instance.projects.get(1)
hook = self.moduleUtil.createHook(project, {"url": "http://example.com/hook"}) hook = self.moduleUtil.create_hook(project, {"url": "http://example.com/hook"})
self.assertEqual(type(hook), ProjectHook) self.assertEqual(type(hook), ProjectHook)
self.assertEqual(hook.url, "http://example.com/hook") self.assertEqual(hook.url, "http://example.com/hook")
@ -77,15 +77,15 @@ class TestGitlabHook(GitlabModuleTestCase):
@with_httmock(resp_find_project_hook) @with_httmock(resp_find_project_hook)
def test_update_hook(self): def test_update_hook(self):
project = self.gitlab_instance.projects.get(1) project = self.gitlab_instance.projects.get(1)
hook = self.moduleUtil.findHook(project, "http://example.com/hook") hook = self.moduleUtil.find_hook(project, "http://example.com/hook")
changed, newHook = self.moduleUtil.updateHook(hook, {"url": "http://gitlab.com/hook"}) changed, newHook = self.moduleUtil.update_hook(hook, {"url": "http://gitlab.com/hook"})
self.assertEqual(changed, True) self.assertEqual(changed, True)
self.assertEqual(type(newHook), ProjectHook) self.assertEqual(type(newHook), ProjectHook)
self.assertEqual(newHook.url, "http://gitlab.com/hook") self.assertEqual(newHook.url, "http://gitlab.com/hook")
changed, newHook = self.moduleUtil.updateHook(hook, {"url": "http://gitlab.com/hook"}) changed, newHook = self.moduleUtil.update_hook(hook, {"url": "http://gitlab.com/hook"})
self.assertEqual(changed, False) self.assertEqual(changed, False)
self.assertEqual(newHook.url, "http://gitlab.com/hook") self.assertEqual(newHook.url, "http://gitlab.com/hook")
@ -96,8 +96,8 @@ class TestGitlabHook(GitlabModuleTestCase):
def test_delete_hook(self): def test_delete_hook(self):
project = self.gitlab_instance.projects.get(1) project = self.gitlab_instance.projects.get(1)
self.moduleUtil.existsHook(project, "http://example.com/hook") self.moduleUtil.exists_hook(project, "http://example.com/hook")
rvalue = self.moduleUtil.deleteHook() rvalue = self.moduleUtil.delete_hook()
self.assertEqual(rvalue, None) self.assertEqual(rvalue, None)

18
tests/unit/plugins/modules/source_control/gitlab/test_gitlab_project.py
View file

@ -59,11 +59,11 @@ class TestGitlabProject(GitlabModuleTestCase):
def test_project_exist(self): def test_project_exist(self):
group = self.gitlab_instance.groups.get(1) group = self.gitlab_instance.groups.get(1)
rvalue = self.moduleUtil.existsProject(group, "diaspora-client") rvalue = self.moduleUtil.exists_project(group, "diaspora-client")
self.assertEqual(rvalue, True) self.assertEqual(rvalue, True)
rvalue = self.moduleUtil.existsProject(group, "missing-project") rvalue = self.moduleUtil.exists_project(group, "missing-project")
self.assertEqual(rvalue, False) self.assertEqual(rvalue, False)
@ -71,7 +71,7 @@ class TestGitlabProject(GitlabModuleTestCase):
@with_httmock(resp_create_project) @with_httmock(resp_create_project)
def test_create_project(self): def test_create_project(self):
group = self.gitlab_instance.groups.get(1) group = self.gitlab_instance.groups.get(1)
project = self.moduleUtil.createProject(group, {"name": "Diaspora Client", "path": "diaspora-client", "namespace_id": group.id}) project = self.moduleUtil.create_project(group, {"name": "Diaspora Client", "path": "diaspora-client", "namespace_id": group.id})
self.assertEqual(type(project), Project) self.assertEqual(type(project), Project)
self.assertEqual(project.name, "Diaspora Client") self.assertEqual(project.name, "Diaspora Client")
@ -80,13 +80,13 @@ class TestGitlabProject(GitlabModuleTestCase):
def test_update_project(self): def test_update_project(self):
project = self.gitlab_instance.projects.get(1) project = self.gitlab_instance.projects.get(1)
changed, newProject = self.moduleUtil.updateProject(project, {"name": "New Name"}) changed, newProject = self.moduleUtil.update_project(project, {"name": "New Name"})
self.assertEqual(changed, True) self.assertEqual(changed, True)
self.assertEqual(type(newProject), Project) self.assertEqual(type(newProject), Project)
self.assertEqual(newProject.name, "New Name") self.assertEqual(newProject.name, "New Name")
changed, newProject = self.moduleUtil.updateProject(project, {"name": "New Name"}) changed, newProject = self.moduleUtil.update_project(project, {"name": "New Name"})
self.assertEqual(changed, False) self.assertEqual(changed, False)
self.assertEqual(newProject.name, "New Name") self.assertEqual(newProject.name, "New Name")
@ -98,14 +98,14 @@ class TestGitlabProject(GitlabModuleTestCase):
# merge_method should be 'merge' by default # merge_method should be 'merge' by default
self.assertEqual(project.merge_method, "merge") self.assertEqual(project.merge_method, "merge")
changed, newProject = self.moduleUtil.updateProject(project, {"name": "New Name", "merge_method": "rebase_merge"}) changed, newProject = self.moduleUtil.update_project(project, {"name": "New Name", "merge_method": "rebase_merge"})
self.assertEqual(changed, True) self.assertEqual(changed, True)
self.assertEqual(type(newProject), Project) self.assertEqual(type(newProject), Project)
self.assertEqual(newProject.name, "New Name") self.assertEqual(newProject.name, "New Name")
self.assertEqual(newProject.merge_method, "rebase_merge") self.assertEqual(newProject.merge_method, "rebase_merge")
changed, newProject = self.moduleUtil.updateProject(project, {"name": "New Name", "merge_method": "rebase_merge"}) changed, newProject = self.moduleUtil.update_project(project, {"name": "New Name", "merge_method": "rebase_merge"})
self.assertEqual(changed, False) self.assertEqual(changed, False)
self.assertEqual(newProject.name, "New Name") self.assertEqual(newProject.name, "New Name")
@ -117,8 +117,8 @@ class TestGitlabProject(GitlabModuleTestCase):
def test_delete_project(self): def test_delete_project(self):
group = self.gitlab_instance.groups.get(1) group = self.gitlab_instance.groups.get(1)
self.moduleUtil.existsProject(group, "diaspora-client") self.moduleUtil.exists_project(group, "diaspora-client")
rvalue = self.moduleUtil.deleteProject() rvalue = self.moduleUtil.delete_project()
self.assertEqual(rvalue, None) self.assertEqual(rvalue, None)

20
tests/unit/plugins/modules/source_control/gitlab/test_gitlab_runner.py
View file

@ -54,28 +54,28 @@ class TestGitlabRunner(GitlabModuleTestCase):
@with_httmock(resp_find_runners_all) @with_httmock(resp_find_runners_all)
@with_httmock(resp_get_runner) @with_httmock(resp_get_runner)
def test_runner_exist_all(self): def test_runner_exist_all(self):
rvalue = self.moduleUtil.existsRunner("test-1-20150125") rvalue = self.moduleUtil.exists_runner("test-1-20150125")
self.assertEqual(rvalue, True) self.assertEqual(rvalue, True)
rvalue = self.moduleUtil.existsRunner("test-3-00000000") rvalue = self.moduleUtil.exists_runner("test-3-00000000")
self.assertEqual(rvalue, False) self.assertEqual(rvalue, False)
@with_httmock(resp_find_runners_list) @with_httmock(resp_find_runners_list)
@with_httmock(resp_get_runner) @with_httmock(resp_get_runner)
def test_runner_exist_owned(self): def test_runner_exist_owned(self):
rvalue = self.moduleUtil.existsRunner("test-1-20201214", True) rvalue = self.moduleUtil.exists_runner("test-1-20201214", True)
self.assertEqual(rvalue, True) self.assertEqual(rvalue, True)
rvalue = self.moduleUtil.existsRunner("test-3-00000000", True) rvalue = self.moduleUtil.exists_runner("test-3-00000000", True)
self.assertEqual(rvalue, False) self.assertEqual(rvalue, False)
@with_httmock(resp_create_runner) @with_httmock(resp_create_runner)
def test_create_runner(self): def test_create_runner(self):
runner = self.moduleUtil.createRunner({"token": "token", "description": "test-1-20150125"}) runner = self.moduleUtil.create_runner({"token": "token", "description": "test-1-20150125"})
self.assertEqual(type(runner), Runner) self.assertEqual(type(runner), Runner)
self.assertEqual(runner.description, "test-1-20150125") self.assertEqual(runner.description, "test-1-20150125")
@ -83,15 +83,15 @@ class TestGitlabRunner(GitlabModuleTestCase):
@with_httmock(resp_find_runners_all) @with_httmock(resp_find_runners_all)
@with_httmock(resp_get_runner) @with_httmock(resp_get_runner)
def test_update_runner(self): def test_update_runner(self):
runner = self.moduleUtil.findRunner("test-1-20150125") runner = self.moduleUtil.find_runner("test-1-20150125")
changed, newRunner = self.moduleUtil.updateRunner(runner, {"description": "Runner description"}) changed, newRunner = self.moduleUtil.update_runner(runner, {"description": "Runner description"})
self.assertEqual(changed, True) self.assertEqual(changed, True)
self.assertEqual(type(newRunner), Runner) self.assertEqual(type(newRunner), Runner)
self.assertEqual(newRunner.description, "Runner description") self.assertEqual(newRunner.description, "Runner description")
changed, newRunner = self.moduleUtil.updateRunner(runner, {"description": "Runner description"}) changed, newRunner = self.moduleUtil.update_runner(runner, {"description": "Runner description"})
self.assertEqual(changed, False) self.assertEqual(changed, False)
self.assertEqual(newRunner.description, "Runner description") self.assertEqual(newRunner.description, "Runner description")
@ -100,8 +100,8 @@ class TestGitlabRunner(GitlabModuleTestCase):
@with_httmock(resp_get_runner) @with_httmock(resp_get_runner)
@with_httmock(resp_delete_runner) @with_httmock(resp_delete_runner)
def test_delete_runner(self): def test_delete_runner(self):
self.moduleUtil.existsRunner("test-1-20150125") self.moduleUtil.exists_runner("test-1-20150125")
rvalue = self.moduleUtil.deleteRunner() rvalue = self.moduleUtil.delete_runner()
self.assertEqual(rvalue, None) self.assertEqual(rvalue, None)

32
tests/unit/plugins/modules/source_control/gitlab/test_gitlab_user.py
View file

@ -61,17 +61,17 @@ class TestGitlabUser(GitlabModuleTestCase):
@with_httmock(resp_find_user) @with_httmock(resp_find_user)
def test_exist_user(self): def test_exist_user(self):
rvalue = self.moduleUtil.existsUser("john_smith") rvalue = self.moduleUtil.exists_user("john_smith")
self.assertEqual(rvalue, True) self.assertEqual(rvalue, True)
rvalue = self.moduleUtil.existsUser("paul_smith") rvalue = self.moduleUtil.exists_user("paul_smith")
self.assertEqual(rvalue, False) self.assertEqual(rvalue, False)
@with_httmock(resp_find_user) @with_httmock(resp_find_user)
def test_find_user(self): def test_find_user(self):
user = self.moduleUtil.findUser("john_smith") user = self.moduleUtil.find_user("john_smith")
self.assertEqual(type(user), User) self.assertEqual(type(user), User)
self.assertEqual(user.name, "John Smith") self.assertEqual(user.name, "John Smith")
@ -79,7 +79,7 @@ class TestGitlabUser(GitlabModuleTestCase):
@with_httmock(resp_create_user) @with_httmock(resp_create_user)
def test_create_user(self): def test_create_user(self):
user = self.moduleUtil.createUser({'email': 'john@example.com', 'password': 's3cur3s3cr3T', user = self.moduleUtil.create_user({'email': 'john@example.com', 'password': 's3cur3s3cr3T',
'username': 'john_smith', 'name': 'John Smith'}) 'username': 'john_smith', 'name': 'John Smith'})
self.assertEqual(type(user), User) self.assertEqual(type(user), User)
self.assertEqual(user.name, "John Smith") self.assertEqual(user.name, "John Smith")
@ -89,7 +89,7 @@ class TestGitlabUser(GitlabModuleTestCase):
def test_update_user(self): def test_update_user(self):
user = self.gitlab_instance.users.get(1) user = self.gitlab_instance.users.get(1)
changed, newUser = self.moduleUtil.updateUser( changed, newUser = self.moduleUtil.update_user(
user, user,
{'name': {'value': "Jack Smith"}, "is_admin": {'value': "true", 'setter': 'admin'}}, {} {'name': {'value': "Jack Smith"}, "is_admin": {'value': "true", 'setter': 'admin'}}, {}
) )
@ -98,11 +98,11 @@ class TestGitlabUser(GitlabModuleTestCase):
self.assertEqual(newUser.name, "Jack Smith") self.assertEqual(newUser.name, "Jack Smith")
self.assertEqual(newUser.admin, "true") self.assertEqual(newUser.admin, "true")
changed, newUser = self.moduleUtil.updateUser(user, {'name': {'value': "Jack Smith"}}, {}) changed, newUser = self.moduleUtil.update_user(user, {'name': {'value': "Jack Smith"}}, {})
self.assertEqual(changed, False) self.assertEqual(changed, False)
changed, newUser = self.moduleUtil.updateUser( changed, newUser = self.moduleUtil.update_user(
user, user,
{}, { {}, {
'skip_reconfirmation': {'value': True}, 'skip_reconfirmation': {'value': True},
@ -118,8 +118,8 @@ class TestGitlabUser(GitlabModuleTestCase):
@with_httmock(resp_find_user) @with_httmock(resp_find_user)
@with_httmock(resp_delete_user) @with_httmock(resp_delete_user)
def test_delete_user(self): def test_delete_user(self):
self.moduleUtil.existsUser("john_smith") self.moduleUtil.exists_user("john_smith")
rvalue = self.moduleUtil.deleteUser() rvalue = self.moduleUtil.delete_user()
self.assertEqual(rvalue, None) self.assertEqual(rvalue, None)
@ -128,10 +128,10 @@ class TestGitlabUser(GitlabModuleTestCase):
def test_sshkey_exist(self): def test_sshkey_exist(self):
user = self.gitlab_instance.users.get(1) user = self.gitlab_instance.users.get(1)
exist = self.moduleUtil.sshKeyExists(user, "Public key") exist = self.moduleUtil.ssh_key_exists(user, "Public key")
self.assertEqual(exist, True) self.assertEqual(exist, True)
notExist = self.moduleUtil.sshKeyExists(user, "Private key") notExist = self.moduleUtil.ssh_key_exists(user, "Private key")
self.assertEqual(notExist, False) self.assertEqual(notExist, False)
@with_httmock(resp_get_user) @with_httmock(resp_get_user)
@ -140,7 +140,7 @@ class TestGitlabUser(GitlabModuleTestCase):
def test_create_sshkey(self): def test_create_sshkey(self):
user = self.gitlab_instance.users.get(1) user = self.gitlab_instance.users.get(1)
rvalue = self.moduleUtil.addSshKeyToUser(user, { rvalue = self.moduleUtil.add_ssh_key_to_user(user, {
'name': "Public key", 'name': "Public key",
'file': "ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAAIEAiPWx6WM4lhHNedGfBpPJNPpZ7yKu+dnn1SJe" 'file': "ssh-rsa AAAAB3NzaC1yc2EAAAABJQAAAIEAiPWx6WM4lhHNedGfBpPJNPpZ7yKu+dnn1SJe"
"jgt4596k6YjzGGphH2TUxwKzxcKDKKezwkpfnxPkSMkuEspGRt/aZZ9wa++Oi7Qkr8prgHc4" "jgt4596k6YjzGGphH2TUxwKzxcKDKKezwkpfnxPkSMkuEspGRt/aZZ9wa++Oi7Qkr8prgHc4"
@ -148,7 +148,7 @@ class TestGitlabUser(GitlabModuleTestCase):
'expires_at': ""}) 'expires_at': ""})
self.assertEqual(rvalue, False) self.assertEqual(rvalue, False)
rvalue = self.moduleUtil.addSshKeyToUser(user, { rvalue = self.moduleUtil.add_ssh_key_to_user(user, {
'name': "Private key", 'name': "Private key",
'file': "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDA1YotVDm2mAyk2tPt4E7AHm01sS6JZmcU" 'file': "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDA1YotVDm2mAyk2tPt4E7AHm01sS6JZmcU"
"dRuSuA5zszUJzYPPUSRAX3BCgTqLqYx//UuVncK7YqLVSbbwjKR2Ez5lISgCnVfLVEXzwhv+" "dRuSuA5zszUJzYPPUSRAX3BCgTqLqYx//UuVncK7YqLVSbbwjKR2Ez5lISgCnVfLVEXzwhv+"
@ -163,7 +163,7 @@ class TestGitlabUser(GitlabModuleTestCase):
def test_find_member(self): def test_find_member(self):
group = self.gitlab_instance.groups.get(1) group = self.gitlab_instance.groups.get(1)
user = self.moduleUtil.findMember(group, 1) user = self.moduleUtil.find_member(group, 1)
self.assertEqual(user.username, "raymond_smith") self.assertEqual(user.username, "raymond_smith")
@with_httmock(resp_get_user) @with_httmock(resp_get_user)
@ -176,8 +176,8 @@ class TestGitlabUser(GitlabModuleTestCase):
group = self.gitlab_instance.groups.get(1) group = self.gitlab_instance.groups.get(1)
user = self.gitlab_instance.users.get(1) user = self.gitlab_instance.users.get(1)
rvalue = self.moduleUtil.assignUserToGroup(user, group.id, "developer") rvalue = self.moduleUtil.assign_user_to_group(user, group.id, "developer")
self.assertEqual(rvalue, False) self.assertEqual(rvalue, False)
rvalue = self.moduleUtil.assignUserToGroup(user, group.id, "guest") rvalue = self.moduleUtil.assign_user_to_group(user, group.id, "guest")
self.assertEqual(rvalue, True) self.assertEqual(rvalue, True)