def test_delete_user_in_backends_by_email(self):
""" Delete a user previously registered user by email
"""
# first, create a user and register it with services
try:
self.msu.create_user('josh', 'homme', '*****@*****.**')
except NotImplementedError:
skip("user management not supported in this version of managesf")
self.logout()
self.login('josh', 'homme', config.GATEWAY_URL)
# make sure user is in redmine and gerrit
self.assertEqual('*****@*****.**',
self.gu.get_account('josh').get('email'))
if has_issue_tracker():
users = self.rm.active_users()
users = [u for u in users if u[0] == 'josh']
self.assertEqual(1, len(users))
user = users[0]
self.assertEqual('*****@*****.**', user[1])
# now suppress it
del_url = config.GATEWAY_URL +\
'/manage/services_users/[email protected]'
auth_cookie = config.USERS[config.ADMIN_USER]['auth_cookie']
d = requests.delete(del_url, cookies={'auth_pubtkt': auth_cookie})
self.assertTrue(int(d.status_code) < 400, d.status_code)
# make sure the user does not exist anymore
self.assertEqual(False, self.gu.get_account('josh'))
if has_issue_tracker():
users = self.rm.active_users()
self.assertEqual(0, len([u for u in users if u[0] == 'josh']))
def test_delete_in_backend_and_recreate(self):
"""Make sure we can recreate a user but as a different one"""
# first, create a user and register it with services
try:
self.msu.create_user('freddie', 'mercury', '*****@*****.**')
except NotImplementedError:
skip("user management not supported in this version of managesf")
self.logout()
self.login('freddie', 'mercury', config.GATEWAY_URL)
gerrit_id = self.gu.get_account('freddie').get('_account_id')
if has_issue_tracker():
tracker_id = self.rm.get_user_id_by_username('freddie')
del_url = config.GATEWAY_URL +\
'/manage/services_users/[email protected]'
auth_cookie = config.USERS[config.ADMIN_USER]['auth_cookie']
d = requests.delete(del_url,
cookies={'auth_pubtkt': auth_cookie})
self.assertTrue(int(d.status_code) < 400, d.status_code)
self.assertEqual(False,
self.gu.get_account('freddie'))
if has_issue_tracker():
users = self.rm.active_users()
self.assertEqual(0,
len([u for u in users
if u[0] == 'freddie']))
# recreate the user in the backends
time.sleep(5)
self.logout()
self.login('freddie', 'mercury', config.GATEWAY_URL)
new_gerrit_id = self.gu.get_account('freddie').get('_account_id')
self.assertTrue(gerrit_id != new_gerrit_id)
if has_issue_tracker():
new_tracker_id = self.rm.get_user_id_by_username('freddie')
self.assertTrue(tracker_id != new_tracker_id)
def test_delete_user_in_backends_by_email(self):
""" Delete a user previously registered user by email
"""
# first, create a user and register it with services
try:
self.msu.create_user('josh', 'homme', '*****@*****.**')
except NotImplementedError:
skip("user management not supported in this version of managesf")
self.logout()
self.login('josh', 'homme', config.GATEWAY_URL)
# make sure user is in redmine and gerrit
self.assertEqual('*****@*****.**',
self.gu.get_account('josh').get('email'))
if has_issue_tracker():
users = self.rm.active_users()
users = [u for u in users if u[0] == 'josh']
self.assertEqual(1, len(users))
user = users[0]
self.assertEqual('*****@*****.**',
user[1])
# now suppress it
del_url = config.GATEWAY_URL +\
'/manage/services_users/[email protected]'
auth_cookie = config.USERS[config.ADMIN_USER]['auth_cookie']
d = requests.delete(del_url,
cookies={'auth_pubtkt': auth_cookie})
self.assertTrue(int(d.status_code) < 400, d.status_code)
# make sure the user does not exist anymore
self.assertEqual(False,
self.gu.get_account('josh'))
if has_issue_tracker():
users = self.rm.active_users()
self.assertEqual(0,
len([u for u in users if u[0] == 'josh']))
def test_delete_in_backend_and_recreate(self):
"""Make sure we can recreate a user but as a different one"""
# first, create a user and register it with services
try:
self.msu.create_user('freddie', 'mercury', '*****@*****.**')
except NotImplementedError:
skip("user management not supported in this version of managesf")
self.logout()
self.login('freddie', 'mercury', config.GATEWAY_URL)
gerrit_id = self.gu.get_account('freddie').get('_account_id')
if has_issue_tracker():
tracker_id = self.rm.get_user_id_by_username('freddie')
del_url = config.GATEWAY_URL +\
'/manage/services_users/[email protected]'
auth_cookie = config.USERS[config.ADMIN_USER]['auth_cookie']
d = requests.delete(del_url, cookies={'auth_pubtkt': auth_cookie})
self.assertTrue(int(d.status_code) < 400, d.status_code)
self.assertEqual(False, self.gu.get_account('freddie'))
if has_issue_tracker():
users = self.rm.active_users()
self.assertEqual(0, len([u for u in users if u[0] == 'freddie']))
# recreate the user in the backends
time.sleep(5)
self.logout()
self.login('freddie', 'mercury', config.GATEWAY_URL)
new_gerrit_id = self.gu.get_account('freddie').get('_account_id')
self.assertTrue(gerrit_id != new_gerrit_id)
if has_issue_tracker():
new_tracker_id = self.rm.get_user_id_by_username('freddie')
self.assertTrue(tracker_id != new_tracker_id)
def test_delete_user_in_backends_by_username(self):
""" Delete a user previously registered user by username
"""
# first, create a user and register it with services
try:
self.msu.create_user('bootsy', 'collins', '*****@*****.**')
except NotImplementedError:
skip("user management not supported in this version of managesf")
self.logout()
self.login('bootsy', 'collins', config.GATEWAY_URL)
# make sure user is in redmine and gerrit
self.assertEqual('*****@*****.**',
self.gu.get_account('bootsy').get('email'))
if has_issue_tracker():
users = self.rm.active_users()
users = [u for u in users if u[0] == 'bootsy']
self.assertEqual(1, len(users))
user = users[0]
self.assertEqual('*****@*****.**', user[1])
# now suppress it
del_url = config.GATEWAY_URL +\
'/manage/services_users/?username=bootsy'
# try with a a non-admin user, it should not work ...
auth_cookie = get_cookie('user5', config.ADMIN_PASSWORD)
d = requests.delete(del_url, cookies={'auth_pubtkt': auth_cookie})
self.assertTrue(400 < int(d.status_code) < 500)
# try with an admin ...
auth_cookie = config.USERS[config.ADMIN_USER]['auth_cookie']
d = requests.delete(del_url, cookies={'auth_pubtkt': auth_cookie})
self.assertTrue(int(d.status_code) < 400, d.status_code)
# make sure the user does not exist anymore
self.assertEqual(False, self.gu.get_account('bootsy'))
if has_issue_tracker():
users = self.rm.active_users()
self.assertEqual(0, len([u for u in users if u[0] == 'bootsy']))
def test_non_member_manage_project_members(self):
""" Test non project members can add and delete users to core group
"""
# Let admin create the project
pname = 'p_%s' % create_random_str()
self.create_project(pname, config.ADMIN_USER)
# Gerrit part
self.assertTrue(self.gu.project_exists(pname))
self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
self.assertTrue(self.gu.group_exists('%s-core' % pname))
# non project meber can't add user to core group
# user2 can't add user3 to core group
groups = 'core-group'
self.msu.addUsertoProjectGroups(config.USER_2, pname, config.USER_3,
groups)
# user3 shouldn't exist in core group
self.assertFalse(
self.gu.member_in_group(config.USER_3, '%s-core' % pname))
# tracker part
if has_issue_tracker():
self.assertFalse(
self.rm.check_user_role(pname, config.USER_3, 'Developer'))
groups = 'ptl-group'
# non project meber can't add usr to ptl group
# user2 can't add user3 to ptl group
self.msu.addUsertoProjectGroups(config.USER_2, pname, config.USER_3,
groups)
# user3 shouldn't exist in ptl group
self.assertFalse(
self.gu.member_in_group(config.USER_3, '%s-ptl' % pname))
# tracker part
if has_issue_tracker():
self.assertFalse(
self.rm.check_user_role(pname, config.USER_3, 'Manager'))
# non project meber can't delete usr from any group.
# Let admin add user3 to ptl and core groups,
# then try to remove user3 from ptl and core groups by
# user2 (i.e non member user)
groups = 'ptl-group core-group'
self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname,
config.USER_3, groups)
# non-admin user(user2) can't remove users from project groups
self.msu.deleteUserFromProjectGroups(config.USER_2, pname,
config.USER_3)
# user3 should exist in ptl and core group
self.assertTrue(
self.gu.member_in_group(config.USER_3, '%s-ptl' % pname))
self.assertTrue(
self.gu.member_in_group(config.USER_3, '%s-core' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(
self.rm.check_user_role(pname, config.USER_3, 'Manager'))
self.assertTrue(
self.rm.check_user_role(pname, config.USER_3, 'Developer'))
def test_delete_project_as_admin(self):
""" Check if admin can delete projects that are not owned by admin
"""
pname = 'p_%s' % create_random_str()
self.create_project(pname, config.USER_2)
self.assertTrue(self.gu.project_exists(pname))
if has_issue_tracker():
self.assertTrue(self.rm.project_exists(pname))
self.msu.deleteProject(pname, config.ADMIN_USER)
self.assertFalse(self.gu.project_exists(pname))
self.assertFalse(self.gu.group_exists('%s-ptl' % pname))
if has_issue_tracker():
self.assertFalse(self.rm.project_exists(pname))
self.assertFalse(self.gu.group_exists('%s-core' % pname))
self.projects.remove(pname)
def test_delete_project_as_admin(self):
""" Check if admin can delete projects that are not owned by admin
"""
pname = 'p_%s' % create_random_str()
self.create_project(pname, config.USER_2)
self.assertTrue(self.gu.project_exists(pname))
if has_issue_tracker():
self.assertTrue(self.rm.project_exists(pname))
self.msu.deleteProject(pname, config.ADMIN_USER)
self.assertFalse(self.gu.project_exists(pname))
self.assertFalse(self.gu.group_exists('%s-ptl' % pname))
if has_issue_tracker():
self.assertFalse(self.rm.project_exists(pname))
self.assertFalse(self.gu.group_exists('%s-core' % pname))
self.projects.remove(pname)
def test_delete_public_project_as_admin(self):
""" Delete public project on redmine and gerrit as admin
"""
pname = 'p_%s' % create_random_str()
self.create_project(pname, config.ADMIN_USER)
self.assertTrue(self.gu.project_exists(pname))
if has_issue_tracker():
self.assertTrue(self.rm.project_exists(pname))
self.msu.deleteProject(pname, config.ADMIN_USER)
self.assertFalse(self.gu.project_exists(pname))
self.assertFalse(self.gu.group_exists('%s-ptl' % pname))
if has_issue_tracker():
self.assertFalse(self.rm.project_exists(pname))
self.assertFalse(self.gu.group_exists('%s-core' % pname))
self.projects.remove(pname)
def test_delete_public_project_as_admin(self):
""" Delete public project on redmine and gerrit as admin
"""
pname = 'p_%s' % create_random_str()
self.create_project(pname, config.ADMIN_USER)
self.assertTrue(self.gu.project_exists(pname))
if has_issue_tracker():
self.assertTrue(self.rm.project_exists(pname))
self.msu.deleteProject(pname, config.ADMIN_USER)
self.assertFalse(self.gu.project_exists(pname))
self.assertFalse(self.gu.group_exists('%s-ptl' % pname))
if has_issue_tracker():
self.assertFalse(self.rm.project_exists(pname))
self.assertFalse(self.gu.group_exists('%s-core' % pname))
self.projects.remove(pname)
def test_basic_ops_project_namespace(self):
""" Check if a project named with a / (namespace) is handled
correctly on basic ops by managesf
"""
pname = 'skydive/%s' % create_random_str()
self.create_project(pname, config.USER_2)
self.assertTrue(self.gu.project_exists(pname))
self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
if is_present("redmine"):
rname = '_'.join(pname.split('/'))
self.assertTrue(self.rm.project_exists(rname))
# Try to clone
ggu = GerritGitUtils(config.ADMIN_USER, config.ADMIN_PRIV_KEY_PATH,
config.USERS[config.ADMIN_USER]['email'])
url = "ssh://%s@%s:29418/%s" % (config.ADMIN_USER, config.GATEWAY_HOST,
pname)
clone_dir = ggu.clone(url, pname.split('/')[-1])
self.dirs_to_delete.append(os.path.dirname(clone_dir))
# Test that the clone is a success
self.assertTrue(os.path.isdir(clone_dir))
# Verify master own the .gitreview file
self.assertTrue(os.path.isfile(os.path.join(clone_dir, '.gitreview')))
# Delete the project from SF
self.msu.deleteProject(pname, config.ADMIN_USER)
self.assertFalse(self.gu.project_exists(pname))
self.assertFalse(self.gu.group_exists('%s-ptl' % pname))
if has_issue_tracker():
rname = '_'.join(pname.split('/'))
self.assertFalse(self.rm.project_exists(rname))
self.assertFalse(self.gu.group_exists('%s-core' % pname))
# Clean local clone directory
self.projects.remove(pname)
def test_create_private_project_as_user(self):
""" Create private project on redmine and gerrit as user
"""
pname = 'p_%s' % create_random_str()
options = {"private": ""}
self.create_project(pname, config.USER_2, options=options)
# Gerrit part
self.assertTrue(self.gu.project_exists(pname))
self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
self.assertTrue(self.gu.group_exists('%s-core' % pname))
self.assertTrue(self.gu.group_exists('%s-dev' % pname))
# TODO(Project creator, as project owner, should only be in ptl group)
self.assertTrue(
self.gu.member_in_group(config.USER_2, '%s-ptl' % pname))
self.assertTrue(
self.gu.member_in_group(config.USER_2, '%s-core' % pname))
self.assertTrue(
self.gu.member_in_group(config.USER_2, '%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(self.rm.project_exists(pname))
self.assertTrue(self.project_exists_ex(pname, config.USER_2))
self.assertTrue(
self.rm.check_user_role(pname, config.USER_2, 'Manager'))
self.assertTrue(
self.rm.check_user_role(pname, config.USER_2, 'Developer'))
self.assertFalse(self.project_exists_ex(pname, config.USER_3))
def test_create_private_project_as_user(self):
""" Create private project on redmine and gerrit as user
"""
pname = 'p_%s' % create_random_str()
options = {"private": ""}
self.create_project(pname, config.USER_2,
options=options)
# Gerrit part
self.assertTrue(self.gu.project_exists(pname))
self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
self.assertTrue(self.gu.group_exists('%s-core' % pname))
self.assertTrue(self.gu.group_exists('%s-dev' % pname))
# TODO(Project creator, as project owner, should only be in ptl group)
self.assertTrue(
self.gu.member_in_group(config.USER_2, '%s-ptl' % pname))
self.assertTrue(
self.gu.member_in_group(config.USER_2, '%s-core' % pname))
self.assertTrue(
self.gu.member_in_group(config.USER_2, '%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(self.rm.project_exists(pname))
self.assertTrue(self.project_exists_ex(pname, config.USER_2))
self.assertTrue(
self.rm.check_user_role(pname, config.USER_2, 'Manager'))
self.assertTrue(
self.rm.check_user_role(pname, config.USER_2, 'Developer'))
self.assertFalse(self.project_exists_ex(pname, config.USER_3))
def test_create_private_project_with_users_in_group(self):
""" Create private project on redmine and gerrit with users in groups
"""
pname = 'p_%s' % create_random_str()
u2mail = config.USERS[config.USER_2]['email']
u3mail = config.USERS[config.USER_3]['email']
u4mail = config.USERS[config.USER_4]['email']
options = {"private": "",
"ptl-group": "",
"core-group": "%s,%s" % (u2mail, u3mail),
"dev-group": "%s" % u4mail,
}
self.create_project(pname, config.ADMIN_USER,
options=options)
# Gerrit part
self.assertTrue(self.gu.project_exists(pname))
# TODO(Project creator, as project owner, should only be in ptl group)
self.assertTrue(
self.gu.member_in_group(config.ADMIN_USER, '%s-ptl' % pname))
for user in (config.ADMIN_USER, config.USER_2, config.USER_3):
self.assertTrue(self.gu.member_in_group(user, '%s-core' % pname))
self.assertTrue(
self.gu.member_in_group(config.USER_4, '%s-dev' % pname))
# tracker part
if has_issue_tracker():
# it should be visible to admin
self.assertTrue(self.rm.project_exists(pname))
self.assertTrue(
self.rm.check_user_role(pname, config.ADMIN_USER, 'Manager'))
for user in (config.ADMIN_USER, config.USER_2,
config.USER_3, config.USER_4):
self.assertTrue(self.rm.check_user_role(pname, user,
'Developer'))
def test_basic_ops_project_namespace(self):
""" Check if a project named with a / (namespace) is handled
correctly on basic ops by managesf
"""
pname = 'skydive/%s' % create_random_str()
self.create_project(pname, config.USER_2)
self.assertTrue(self.gu.project_exists(pname))
self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
if is_present("SFRedmine"):
rname = '_'.join(pname.split('/'))
self.assertTrue(self.rm.project_exists(rname))
# Try to clone
ggu = GerritGitUtils(config.ADMIN_USER,
config.ADMIN_PRIV_KEY_PATH,
config.USERS[config.ADMIN_USER]['email'])
url = "ssh://%s@%s:29418/%s" % (config.ADMIN_USER,
config.GATEWAY_HOST, pname)
clone_dir = ggu.clone(url, pname.split('/')[-1])
self.dirs_to_delete.append(os.path.dirname(clone_dir))
# Test that the clone is a success
self.assertTrue(os.path.isdir(clone_dir))
# Verify master own the .gitreview file
self.assertTrue(os.path.isfile(os.path.join(clone_dir,
'.gitreview')))
# Delete the project from SF
self.msu.deleteProject(pname, config.ADMIN_USER)
self.assertFalse(self.gu.project_exists(pname))
self.assertFalse(self.gu.group_exists('%s-ptl' % pname))
if has_issue_tracker():
rname = '_'.join(pname.split('/'))
self.assertFalse(self.rm.project_exists(rname))
self.assertFalse(self.gu.group_exists('%s-core' % pname))
# Clean local clone directory
self.projects.remove(pname)
def test_ptl_manage_project_members(self):
""" Test ptl can add and delete users from all project groups
"""
# Let user2 create the project, so he will be ptl for this project
pname = 'p_%s' % create_random_str()
self.create_project(pname, config.USER_2)
# Gerrit part
self.assertTrue(self.gu.project_exists(pname))
self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
self.assertTrue(self.gu.group_exists('%s-core' % pname))
groups = 'ptl-group core-group'
# ptl should be ale to add users to all groups
# so user2 should be able to add user3 to ptl and core groups
self.msu.addUsertoProjectGroups(config.USER_2, pname,
config.USER_3, groups)
# Test if user3 exists in ptl and core groups
self.assertTrue(self.gu.member_in_group(config.USER_3,
'%s-ptl' % pname))
self.assertTrue(self.gu.member_in_group(config.USER_3,
'%s-core' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(self.rm.check_user_role(pname,
config.USER_3,
'Manager'))
self.assertTrue(self.rm.check_user_role(pname,
config.USER_3,
'Developer'))
# ptl should be able to remove users from all groups
self.msu.deleteUserFromProjectGroups(config.USER_2, pname,
config.USER_3)
# user3 shouldn't exist in any group
self.assertFalse(self.gu.member_in_group(config.USER_3,
'%s-ptl' % pname))
self.assertFalse(self.gu.member_in_group(config.USER_3,
'%s-core' % pname))
# tracker part
if has_issue_tracker():
self.assertFalse(self.rm.check_user_role(pname,
config.USER_3,
'Manager'))
self.assertFalse(self.rm.check_user_role(pname,
config.USER_3,
'Developer'))
def test_admin_manage_project_members(self):
""" Test admin can add and delete users from all project groups
"""
pname = 'p/%s' % create_random_str()
self.create_project(pname, config.ADMIN_USER)
# Gerrit part
self.assertTrue(self.gu.project_exists(pname))
self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
self.assertTrue(self.gu.group_exists('%s-core' % pname))
groups = 'ptl-group core-group'
# Add user2 to ptl and core groups
self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname,
config.USER_2, groups)
# Test if user2 exists in ptl and core groups
self.assertTrue(self.gu.member_in_group(config.USER_2,
'%s-ptl' % pname))
self.assertTrue(self.gu.member_in_group(config.USER_2,
'%s-core' % pname))
# tracker part
if has_issue_tracker():
rname = pname.replace('/', '_')
self.assertTrue(self.rm.check_user_role(rname,
config.USER_2,
'Manager'))
self.assertTrue(self.rm.check_user_role(rname,
config.USER_2,
'Developer'))
# Delete user2 from project groups
self.msu.deleteUserFromProjectGroups(config.ADMIN_USER, pname,
config.USER_2)
# Test if user exists in ptl and core groups
self.assertFalse(self.gu.member_in_group(config.USER_2,
'%s-ptl' % pname))
self.assertFalse(self.gu.member_in_group(config.USER_2,
'%s-core' % pname))
# tracker part
if has_issue_tracker():
rname = pname.replace('/', '_')
self.assertFalse(self.rm.check_user_role(rname,
config.USER_2,
'Manager'))
self.assertFalse(self.rm.check_user_role(rname,
config.USER_2,
'Developer'))
def test_ptl_manage_project_members(self):
""" Test ptl can add and delete users from all project groups
"""
# Let user2 create the project, so he will be ptl for this project
pname = 'p_%s' % create_random_str()
self.create_project(pname, config.USER_2)
# Gerrit part
self.assertTrue(self.gu.project_exists(pname))
self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
self.assertTrue(self.gu.group_exists('%s-core' % pname))
groups = 'ptl-group core-group'
# ptl should be ale to add users to all groups
# so user2 should be able to add user3 to ptl and core groups
self.msu.addUsertoProjectGroups(config.USER_2, pname, config.USER_3,
groups)
# Test if user3 exists in ptl and core groups
self.assertTrue(
self.gu.member_in_group(config.USER_3, '%s-ptl' % pname))
self.assertTrue(
self.gu.member_in_group(config.USER_3, '%s-core' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(
self.rm.check_user_role(pname, config.USER_3, 'Manager'))
self.assertTrue(
self.rm.check_user_role(pname, config.USER_3, 'Developer'))
# ptl should be able to remove users from all groups
self.msu.deleteUserFromProjectGroups(config.USER_2, pname,
config.USER_3)
# user3 shouldn't exist in any group
self.assertFalse(
self.gu.member_in_group(config.USER_3, '%s-ptl' % pname))
self.assertFalse(
self.gu.member_in_group(config.USER_3, '%s-core' % pname))
# tracker part
if has_issue_tracker():
self.assertFalse(
self.rm.check_user_role(pname, config.USER_3, 'Manager'))
self.assertFalse(
self.rm.check_user_role(pname, config.USER_3, 'Developer'))
def test_delete_user_in_backends_by_username(self):
""" Delete a user previously registered user by username
"""
# first, create a user and register it with services
try:
self.msu.create_user('bootsy', 'collins', '*****@*****.**')
except NotImplementedError:
skip("user management not supported in this version of managesf")
self.logout()
self.login('bootsy', 'collins', config.GATEWAY_URL)
# make sure user is in redmine and gerrit
self.assertEqual('*****@*****.**',
self.gu.get_account('bootsy').get('email'))
if has_issue_tracker():
users = self.rm.active_users()
users = [u for u in users if u[0] == 'bootsy']
self.assertEqual(1, len(users))
user = users[0]
self.assertEqual('*****@*****.**',
user[1])
# now suppress it
del_url = config.GATEWAY_URL +\
'/manage/services_users/?username=bootsy'
# try with a a non-admin user, it should not work ...
auth_cookie = get_cookie(config.GATEWAY_HOST,
'user5', config.ADMIN_PASSWORD)
d = requests.delete(del_url,
cookies={'auth_pubtkt': auth_cookie})
self.assertTrue(400 < int(d.status_code) < 500)
# try with an admin ...
auth_cookie = config.USERS[config.ADMIN_USER]['auth_cookie']
d = requests.delete(del_url,
cookies={'auth_pubtkt': auth_cookie})
self.assertTrue(int(d.status_code) < 400, d.status_code)
# make sure the user does not exist anymore
self.assertEqual(False,
self.gu.get_account('bootsy'))
if has_issue_tracker():
users = self.rm.active_users()
self.assertEqual(0,
len([u for u in users
if u[0] == 'bootsy']))
def test_admin_manage_project_members(self):
""" Test admin can add and delete users from all project groups
"""
pname = 'p/%s' % create_random_str()
self.create_project(pname, config.ADMIN_USER)
# Gerrit part
self.assertTrue(self.gu.project_exists(pname))
self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
self.assertTrue(self.gu.group_exists('%s-core' % pname))
groups = 'ptl-group core-group'
# Add user2 to ptl and core groups
self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname,
config.USER_2, groups)
# Test if user2 exists in ptl and core groups
self.assertTrue(
self.gu.member_in_group(config.USER_2, '%s-ptl' % pname))
self.assertTrue(
self.gu.member_in_group(config.USER_2, '%s-core' % pname))
# tracker part
if has_issue_tracker():
rname = pname.replace('/', '_')
self.assertTrue(
self.rm.check_user_role(rname, config.USER_2, 'Manager'))
self.assertTrue(
self.rm.check_user_role(rname, config.USER_2, 'Developer'))
# Delete user2 from project groups
self.msu.deleteUserFromProjectGroups(config.ADMIN_USER, pname,
config.USER_2)
# Test if user exists in ptl and core groups
self.assertFalse(
self.gu.member_in_group(config.USER_2, '%s-ptl' % pname))
self.assertFalse(
self.gu.member_in_group(config.USER_2, '%s-core' % pname))
# tracker part
if has_issue_tracker():
rname = pname.replace('/', '_')
self.assertFalse(
self.rm.check_user_role(rname, config.USER_2, 'Manager'))
self.assertFalse(
self.rm.check_user_role(rname, config.USER_2, 'Developer'))
def test_login_redirect_to_jenkins(self):
""" Verify the user creation and the login
"""
self.logout()
url = config.GATEWAY_URL + "/jenkins/"
quoted_url = urllib2.quote(url, safe='')
response = self.login('user5', config.ADMIN_PASSWORD, quoted_url)
self.assertEqual(url, response.url)
# verify if user is created in gerrit and tracker
self.verify_userdata_gerrit('user5')
if has_issue_tracker():
self.verify_userdata_issue_tracker('user5')
def test_login_redirect_to_jenkins(self):
""" Verify the user creation and the login
"""
self.logout()
url = config.GATEWAY_URL + "/jenkins/"
quoted_url = urllib2.quote(url, safe='')
response = self.login('user5', config.ADMIN_PASSWORD, quoted_url)
self.assertEqual(url, response.url)
# verify if user is created in gerrit and tracker
self.verify_userdata_gerrit('user5')
if has_issue_tracker():
self.verify_userdata_issue_tracker('user5')
def test_topmenu_links_shown(self):
""" Test if all service links are shown in topmenu
"""
subpaths = ["/r/", "/jenkins/",
"/zuul/", "/etherpad/", "/paste/", "/docs/"]
if has_issue_tracker():
tracker = get_issue_tracker_utils(
auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie'])
if 'redmine' in tracker.get_root_url():
subpaths.append('/%s/' % 'redmine')
url = config.GATEWAY_URL + "/topmenu.html"
resp = requests.get(url)
self.assertEqual(resp.status_code, 200)
for subpath in subpaths:
self.assertTrue(('href="%s"' % subpath) in resp.text,
'%s not present as a link' % subpath)
def test_topmenu_links_shown(self):
""" Test if all service links are shown in topmenu
"""
subpaths = [
"/r/", "/jenkins/", "/zuul/", "/etherpad/", "/paste/", "/docs/",
"/app/kibana"
]
if has_issue_tracker():
tracker = get_issue_tracker_utils(
auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie'])
if 'redmine' in tracker.get_root_url():
subpaths.append('/%s/' % 'redmine')
url = config.GATEWAY_URL + "/topmenu.html"
resp = requests.get(url)
self.assertEqual(resp.status_code, 200)
for subpath in subpaths:
self.assertTrue(('href="%s"' % subpath) in resp.text,
'%s not present as a link' % subpath)
def test_project_pages_config(self):
""" Check if managesf allow us to configure pages for a project
"""
project = 'p_%s' % create_random_str()
self.create_project(project, config.USER_2)
self.assertTrue(self.gu.project_exists(project))
if has_issue_tracker():
self.assertTrue(self.rm.project_exists(project))
self.msu.update_project_page(config.USER_2, project,
"https://tests.com/")
self.assertEqual(
self.msu.get_project_page(config.USER_2, project).strip(),
"https://tests.com/")
self.msu.delete_project_page(config.USER_3, project)
self.assertEqual(
self.msu.get_project_page(config.USER_2, project).strip(),
"https://tests.com/")
self.msu.delete_project_page(config.USER_2, project)
self.assertEqual(
self.msu.get_project_page(config.USER_2, project).strip(), "")
def test_create_public_project_as_admin(self):
""" Create public project on redmine and gerrit as admin
"""
pname = 'p_%s' % create_random_str()
self.create_project(pname, config.ADMIN_USER)
# Gerrit part
self.assertTrue(self.gu.project_exists(pname))
self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
self.assertTrue(self.gu.group_exists('%s-core' % pname))
# TODO(Project creator, as project owner, should only be in ptl group)
self.assertTrue(
self.gu.member_in_group(config.ADMIN_USER, '%s-ptl' % pname))
self.assertTrue(
self.gu.member_in_group(config.ADMIN_USER, '%s-core' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(self.rm.project_exists(pname))
self.assertTrue(
self.rm.check_user_role(pname, config.ADMIN_USER, 'Manager'))
self.assertTrue(
self.rm.check_user_role(pname, config.ADMIN_USER, 'Developer'))
self.assertTrue(self.project_exists_ex(pname, config.USER_2))
def test_create_public_project_as_admin(self):
""" Create public project on redmine and gerrit as admin
"""
pname = 'p_%s' % create_random_str()
self.create_project(pname, config.ADMIN_USER)
# Gerrit part
self.assertTrue(self.gu.project_exists(pname))
self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
self.assertTrue(self.gu.group_exists('%s-core' % pname))
# TODO(Project creator, as project owner, should only be in ptl group)
self.assertTrue(
self.gu.member_in_group(config.ADMIN_USER, '%s-ptl' % pname))
self.assertTrue(
self.gu.member_in_group(config.ADMIN_USER, '%s-core' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(self.rm.project_exists(pname))
self.assertTrue(
self.rm.check_user_role(pname, config.ADMIN_USER, 'Manager'))
self.assertTrue(
self.rm.check_user_role(pname, config.ADMIN_USER, 'Developer'))
self.assertTrue(self.project_exists_ex(pname, config.USER_2))
def test_manage_project_members_for_dev_group(self):
""" Add and Delete users from dev group by admin, ptl, core,
dev and non members
"""
pname = 'p_%s' % create_random_str()
options = {"private": ""}
self.create_project(pname, config.ADMIN_USER,
options=options)
# Gerrit part
self.assertTrue(self.gu.project_exists(pname))
self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
self.assertTrue(self.gu.group_exists('%s-core' % pname))
self.assertTrue(self.gu.group_exists('%s-dev' % pname))
self.assertTrue(self.gu.member_in_group(config.ADMIN_USER,
'%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(self.rm.project_exists(pname))
self.assertTrue(self.rm.check_user_role(pname,
config.ADMIN_USER,
'Developer'))
# Admin should add user to dev group
groups = 'dev-group'
self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname,
config.USER_3, groups)
# Test if user3 exists in dev group
self.assertTrue(self.gu.member_in_group(config.USER_3,
'%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(self.rm.check_user_role(pname,
config.USER_3,
'Developer'))
# admin should be able to remove users from dev group
self.msu.deleteUserFromProjectGroups(config.ADMIN_USER, pname,
config.USER_3)
# user3 shouldn't exist in dev group
self.assertFalse(self.gu.member_in_group(config.USER_3,
'%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertFalse(self.rm.check_user_role(pname,
config.USER_3,
'Developer'))
# ptl should add user to dev group
# let admin add user2 as ptl
groups = 'ptl-group'
self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname,
config.USER_2, groups)
groups = 'dev-group'
self.msu.addUsertoProjectGroups(config.USER_2, pname,
config.USER_3, groups)
# Test if user3 exists in dev group
self.assertTrue(self.gu.member_in_group(config.USER_3,
'%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(self.rm.check_user_role(pname,
config.USER_3,
'Developer'))
# ptl should be able to remove users from dev group
self.msu.deleteUserFromProjectGroups(config.USER_2, pname,
config.USER_3)
# user3 shouldn't exist in dev group
self.assertFalse(self.gu.member_in_group(config.USER_3,
'%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertFalse(self.rm.check_user_role(pname,
config.USER_3,
'Developer'))
# Remove user2 as ptl
self.msu.deleteUserFromProjectGroups(config.ADMIN_USER, pname,
config.USER_2)
# core should add user to dev group
# let admin add user2 as core
groups = 'core-group'
self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname,
config.USER_2, groups)
groups = 'dev-group'
self.msu.addUsertoProjectGroups(config.USER_2, pname,
config.USER_3, groups)
# Test if user3 exists in dev group
self.assertTrue(self.gu.member_in_group(config.USER_3,
'%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(self.rm.check_user_role(pname,
config.USER_3,
'Developer'))
# core should be able to remove users from dev group
group = 'dev-group'
self.msu.deleteUserFromProjectGroups(config.USER_2, pname,
config.USER_3, group)
# user3 shouldn't exist in dev group
self.assertFalse(self.gu.member_in_group(config.USER_3,
'%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertFalse(self.rm.check_user_role(pname,
config.USER_3,
'Developer'))
# Remove user2 as core
self.msu.deleteUserFromProjectGroups(config.ADMIN_USER, pname,
config.USER_2)
# let admin add user2 as developer
groups = 'dev-group'
self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname,
config.USER_2, groups)
# dev user should be able to add a new user to dev group
groups = 'dev-group'
self.msu.addUsertoProjectGroups(config.USER_2, pname,
config.USER_3, groups)
# Test if user3 exists in dev group
self.assertTrue(self.gu.member_in_group(config.USER_3,
'%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(self.rm.check_user_role(pname,
config.USER_3,
'Developer'))
# developer should be able to remove users from dev group
group = 'dev-group'
self.msu.deleteUserFromProjectGroups(config.USER_2, pname,
config.USER_3, group)
# user3 shouldn't exist in dev group
self.assertFalse(self.gu.member_in_group(config.USER_3,
'%s-dev' % pname))
# Redmine part
if has_issue_tracker():
self.assertFalse(self.rm.check_user_role(pname,
config.USER_3,
'Developer'))
# Remove user2 ifrom dev group
self.msu.deleteUserFromProjectGroups(config.ADMIN_USER, pname,
config.USER_2)
def test_non_member_manage_project_members(self):
""" Test non project members can add and delete users to core group
"""
# Let admin create the project
pname = 'p_%s' % create_random_str()
self.create_project(pname, config.ADMIN_USER)
# Gerrit part
self.assertTrue(self.gu.project_exists(pname))
self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
self.assertTrue(self.gu.group_exists('%s-core' % pname))
# non project meber can't add user to core group
# user2 can't add user3 to core group
groups = 'core-group'
self.msu.addUsertoProjectGroups(config.USER_2, pname,
config.USER_3, groups)
# user3 shouldn't exist in core group
self.assertFalse(self.gu.member_in_group(config.USER_3,
'%s-core' % pname))
# tracker part
if has_issue_tracker():
self.assertFalse(self.rm.check_user_role(pname,
config.USER_3,
'Developer'))
groups = 'ptl-group'
# non project meber can't add usr to ptl group
# user2 can't add user3 to ptl group
self.msu.addUsertoProjectGroups(config.USER_2, pname,
config.USER_3, groups)
# user3 shouldn't exist in ptl group
self.assertFalse(self.gu.member_in_group(config.USER_3,
'%s-ptl' % pname))
# tracker part
if has_issue_tracker():
self.assertFalse(self.rm.check_user_role(pname,
config.USER_3,
'Manager'))
# non project meber can't delete usr from any group.
# Let admin add user3 to ptl and core groups,
# then try to remove user3 from ptl and core groups by
# user2 (i.e non member user)
groups = 'ptl-group core-group'
self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname,
config.USER_3, groups)
# non-admin user(user2) can't remove users from project groups
self.msu.deleteUserFromProjectGroups(config.USER_2, pname,
config.USER_3)
# user3 should exist in ptl and core group
self.assertTrue(self.gu.member_in_group(config.USER_3,
'%s-ptl' % pname))
self.assertTrue(self.gu.member_in_group(config.USER_3,
'%s-core' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(self.rm.check_user_role(pname,
config.USER_3,
'Manager'))
self.assertTrue(self.rm.check_user_role(pname,
config.USER_3,
'Developer'))
def test_core_manage_project_members(self):
""" Test core can add and delete users to core group
"""
# let admin create the project
pname = 'p_%s' % create_random_str()
self.create_project(pname, config.ADMIN_USER)
# Gerrit part
self.assertTrue(self.gu.project_exists(pname))
self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
self.assertTrue(self.gu.group_exists('%s-core' % pname))
groups = 'core-group'
# Add user2 as core user
self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname,
config.USER_2, groups)
# Test if user2 exists in core group
self.assertTrue(
self.gu.member_in_group(config.USER_2, '%s-core' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(
self.rm.check_user_role(pname, config.USER_2, 'Developer'))
groups = 'core-group'
# core should be ale to add users to only core group and not ptl group
# so user2 should be able to add user3 to only core group and not
# ptl group
self.msu.addUsertoProjectGroups(config.USER_2, pname, config.USER_3,
groups)
# user3 should exist in core group
self.assertTrue(
self.gu.member_in_group(config.USER_3, '%s-core' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(
self.rm.check_user_role(pname, config.USER_3, 'Developer'))
groups = 'ptl-group'
# core should not be allowed to add users to ptl group
# so user2 should not be able to add user3 to ptl group
self.msu.addUsertoProjectGroups(config.USER_2, pname, config.USER_3,
groups)
# user3 shouldn't exist in ptl group
self.assertFalse(
self.gu.member_in_group(config.USER_3, '%s-ptl' % pname))
# tracker part
if has_issue_tracker():
self.assertFalse(
self.rm.check_user_role(pname, config.USER_3, 'Manager'))
# core should be able to remove users from core group
group = 'core-group'
self.msu.deleteUserFromProjectGroups(config.USER_2, pname,
config.USER_3, group)
# user3 shouldn't exist in core group
self.assertFalse(
self.gu.member_in_group(config.USER_3, '%s-core' % pname))
# tracker part
if has_issue_tracker():
self.assertFalse(
self.rm.check_user_role(pname, config.USER_3, 'Developer'))
def test_core_manage_project_members(self):
""" Test core can add and delete users to core group
"""
# let admin create the project
pname = 'p_%s' % create_random_str()
self.create_project(pname, config.ADMIN_USER)
# Gerrit part
self.assertTrue(self.gu.project_exists(pname))
self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
self.assertTrue(self.gu.group_exists('%s-core' % pname))
groups = 'core-group'
# Add user2 as core user
self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname,
config.USER_2, groups)
# Test if user2 exists in core group
self.assertTrue(self.gu.member_in_group(config.USER_2,
'%s-core' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(self.rm.check_user_role(pname,
config.USER_2,
'Developer'))
groups = 'core-group'
# core should be ale to add users to only core group and not ptl group
# so user2 should be able to add user3 to only core group and not
# ptl group
self.msu.addUsertoProjectGroups(config.USER_2, pname,
config.USER_3, groups)
# user3 should exist in core group
self.assertTrue(self.gu.member_in_group(config.USER_3,
'%s-core' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(self.rm.check_user_role(pname,
config.USER_3,
'Developer'))
groups = 'ptl-group'
# core should not be allowed to add users to ptl group
# so user2 should not be able to add user3 to ptl group
self.msu.addUsertoProjectGroups(config.USER_2, pname,
config.USER_3, groups)
# user3 shouldn't exist in ptl group
self.assertFalse(self.gu.member_in_group(config.USER_3,
'%s-ptl' % pname))
# tracker part
if has_issue_tracker():
self.assertFalse(self.rm.check_user_role(pname,
config.USER_3,
'Manager'))
# core should be able to remove users from core group
group = 'core-group'
self.msu.deleteUserFromProjectGroups(config.USER_2, pname,
config.USER_3, group)
# user3 shouldn't exist in core group
self.assertFalse(self.gu.member_in_group(config.USER_3,
'%s-core' % pname))
# tracker part
if has_issue_tracker():
self.assertFalse(self.rm.check_user_role(pname,
config.USER_3,
'Developer'))
def test_manage_project_members_for_dev_group(self):
""" Add and Delete users from dev group by admin, ptl, core,
dev and non members
"""
pname = 'p_%s' % create_random_str()
options = {"private": ""}
self.create_project(pname, config.ADMIN_USER, options=options)
# Gerrit part
self.assertTrue(self.gu.project_exists(pname))
self.assertTrue(self.gu.group_exists('%s-ptl' % pname))
self.assertTrue(self.gu.group_exists('%s-core' % pname))
self.assertTrue(self.gu.group_exists('%s-dev' % pname))
self.assertTrue(
self.gu.member_in_group(config.ADMIN_USER, '%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(self.rm.project_exists(pname))
self.assertTrue(
self.rm.check_user_role(pname, config.ADMIN_USER, 'Developer'))
# Admin should add user to dev group
groups = 'dev-group'
self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname,
config.USER_3, groups)
# Test if user3 exists in dev group
self.assertTrue(
self.gu.member_in_group(config.USER_3, '%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(
self.rm.check_user_role(pname, config.USER_3, 'Developer'))
# admin should be able to remove users from dev group
self.msu.deleteUserFromProjectGroups(config.ADMIN_USER, pname,
config.USER_3)
# user3 shouldn't exist in dev group
self.assertFalse(
self.gu.member_in_group(config.USER_3, '%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertFalse(
self.rm.check_user_role(pname, config.USER_3, 'Developer'))
# ptl should add user to dev group
# let admin add user2 as ptl
groups = 'ptl-group'
self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname,
config.USER_2, groups)
groups = 'dev-group'
self.msu.addUsertoProjectGroups(config.USER_2, pname, config.USER_3,
groups)
# Test if user3 exists in dev group
self.assertTrue(
self.gu.member_in_group(config.USER_3, '%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(
self.rm.check_user_role(pname, config.USER_3, 'Developer'))
# ptl should be able to remove users from dev group
self.msu.deleteUserFromProjectGroups(config.USER_2, pname,
config.USER_3)
# user3 shouldn't exist in dev group
self.assertFalse(
self.gu.member_in_group(config.USER_3, '%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertFalse(
self.rm.check_user_role(pname, config.USER_3, 'Developer'))
# Remove user2 as ptl
self.msu.deleteUserFromProjectGroups(config.ADMIN_USER, pname,
config.USER_2)
# core should add user to dev group
# let admin add user2 as core
groups = 'core-group'
self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname,
config.USER_2, groups)
groups = 'dev-group'
self.msu.addUsertoProjectGroups(config.USER_2, pname, config.USER_3,
groups)
# Test if user3 exists in dev group
self.assertTrue(
self.gu.member_in_group(config.USER_3, '%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(
self.rm.check_user_role(pname, config.USER_3, 'Developer'))
# core should be able to remove users from dev group
group = 'dev-group'
self.msu.deleteUserFromProjectGroups(config.USER_2, pname,
config.USER_3, group)
# user3 shouldn't exist in dev group
self.assertFalse(
self.gu.member_in_group(config.USER_3, '%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertFalse(
self.rm.check_user_role(pname, config.USER_3, 'Developer'))
# Remove user2 as core
self.msu.deleteUserFromProjectGroups(config.ADMIN_USER, pname,
config.USER_2)
# let admin add user2 as developer
groups = 'dev-group'
self.msu.addUsertoProjectGroups(config.ADMIN_USER, pname,
config.USER_2, groups)
# dev user should be able to add a new user to dev group
groups = 'dev-group'
self.msu.addUsertoProjectGroups(config.USER_2, pname, config.USER_3,
groups)
# Test if user3 exists in dev group
self.assertTrue(
self.gu.member_in_group(config.USER_3, '%s-dev' % pname))
# tracker part
if has_issue_tracker():
self.assertTrue(
self.rm.check_user_role(pname, config.USER_3, 'Developer'))
# developer should be able to remove users from dev group
group = 'dev-group'
self.msu.deleteUserFromProjectGroups(config.USER_2, pname,
config.USER_3, group)
# user3 shouldn't exist in dev group
self.assertFalse(
self.gu.member_in_group(config.USER_3, '%s-dev' % pname))
# Redmine part
if has_issue_tracker():
self.assertFalse(
self.rm.check_user_role(pname, config.USER_3, 'Developer'))
# Remove user2 ifrom dev group
self.msu.deleteUserFromProjectGroups(config.ADMIN_USER, pname,
config.USER_2)
