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 is_present("SFRedmine"):
users = self.rm.r.user.filter(limit=20)
users = [u for u in users if u.firstname == 'josh']
self.assertEqual(1, len(users))
user = users[0]
self.assertEqual('*****@*****.**',
user.mail)
# 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 is_present("SFRedmine"):
users = self.rm.r.user.filter(limit=20)
self.assertEqual(0,
len([u for u in users if u.firstname == 'josh']))
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 is_present("SFRedmine"):
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_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 is_present("SFRedmine"):
users = self.rm.r.user.filter(limit=20)
users = [u for u in users if u.firstname == 'josh']
self.assertEqual(1, len(users))
user = users[0]
self.assertEqual('*****@*****.**', user.mail)
# 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 is_present("SFRedmine"):
users = self.rm.r.user.filter(limit=20)
self.assertEqual(0,
len([u for u in users if u.firstname == '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 is_present("SFRedmine"):
users = self.rm.r.user.filter(limit=20)
user = [u for u in users if u.firstname == 'freddie'][0]
redmine_id = user.id
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 is_present("SFRedmine"):
users = self.rm.r.user.filter(limit=20)
self.assertEqual(
0, len([u for u in users if u.firstname == '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 is_present("SFRedmine"):
users = self.rm.r.user.filter(limit=20)
user = [u for u in users if u.firstname == 'freddie'][0]
new_redmine_id = user.id
self.assertTrue(redmine_id != new_redmine_id)
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))
# Redmine part
if is_present("SFRedmine"):
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))
# Redmine part
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))
# Redmine part
if is_present("SFRedmine"):
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_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 is_present("SFRedmine"):
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 is_present("SFRedmine"):
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 is_present("SFRedmine"):
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 is_present("SFRedmine"):
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 is_present("SFRedmine"):
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 is_present("SFRedmine"):
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 is_present("SFRedmine"):
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 is_present("SFRedmine"):
self.assertFalse(self.rm.project_exists(pname))
self.assertFalse(self.gu.group_exists('%s-core' % pname))
self.projects.remove(pname)
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))
# Redmine part
if is_present("SFRedmine"):
# 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_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))
# Redmine part
if is_present("SFRedmine"):
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_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))
# Redmine part
if is_present("SFRedmine"):
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 check_project(self, name):
print " Check project %s exists ..." % name,
if not self.gu.project_exists(name) or \
(is_present('SFRedmine') and not self.rm.project_exists(name)):
print "FAIL"
exit(1)
print "OK"
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))
# Redmine part
if is_present("SFRedmine"):
# 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 check_project(self, name):
print " Check project %s exists ..." % name,
if not self.gu.project_exists(name) or \
(is_present('SFRedmine') and not self.rm.project_exists(name)):
print "FAIL"
exit(1)
print "OK"
def create_issues_on_project(self, name, issues):
print " Create %s issue(s) for that project ..." % len(issues)
for i in issues:
if is_present('SFRedmine'):
issue = self.rm.create_issue(name, i['name'])
else:
issue = random.randint(1, 100)
yield issue, i['review']
def create_issues_on_project(self, name, issues):
print " Create %s issue(s) for that project ..." % len(issues)
for i in issues:
if is_present('SFRedmine'):
issue = self.rm.create_issue(name, i['name'])
else:
issue = random.randint(1,100)
yield issue, i['review']
def create_issues_on_project(self, name, issues):
print " Create %s issue(s) for that project ..." % len(issues)
for i in issues:
if is_present('storyboard'):
issue = self.create_storyboard_issue(name, i['name'])
else:
issue = (random.randint(1, 100), random.randint(1, 100))
yield issue, i['review']
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))
# Redmine part
if is_present("SFRedmine"):
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))
# Redmine part
if is_present("SFRedmine"):
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))
# Redmine part
if is_present("SFRedmine"):
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))
# Redmine part
if is_present("SFRedmine"):
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_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 is_present("SFRedmine"):
users = self.rm.r.user.filter(limit=20)
users = [u for u in users if u.firstname == 'bootsy']
self.assertEqual(1, len(users))
user = users[0]
self.assertEqual('*****@*****.**',
user.mail)
# 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.assertEqual(401,
int(d.status_code))
# 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 is_present("SFRedmine"):
users = self.rm.r.user.filter(limit=20)
self.assertEqual(0,
len([u for u in users
if u.firstname == 'bootsy']))
def check_project(self, name):
print " Check project %s exists ..." % name,
if not self.gu.project_exists(name):
print "FAIL"
exit(1)
if is_present('storyboard'):
if name not in [
p.name for p in self.stb_client.projects.get_all()
]:
print "FAIL"
exit(1)
print "OK"
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 redmine
self.verify_userdata_gerrit('user5')
if is_present("SFRedmine"):
self.verify_userdata_redmine('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 redmine
self.verify_userdata_gerrit('user5')
if is_present("SFRedmine"):
self.verify_userdata_redmine('user5')
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 is_present("SFRedmine"):
users = self.rm.r.user.filter(limit=20)
user = [u for u in users if u.firstname == 'freddie'][0]
redmine_id = user.id
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 is_present("SFRedmine"):
users = self.rm.r.user.filter(limit=20)
self.assertEqual(0,
len([u for u in users
if u.firstname == '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 is_present("SFRedmine"):
users = self.rm.r.user.filter(limit=20)
user = [u for u in users if u.firstname == 'freddie'][0]
new_redmine_id = user.id
self.assertTrue(redmine_id != new_redmine_id)
def checker(self):
for project in self.resources['projects']:
print "Check user datas for %s" % project['name']
self.check_project(project['name'])
self.check_files_in_project(project['name'],
[f['name'] for f in project['files']])
if is_present('SFRedmine'):
self.check_issues_on_project(project['name'],
project['issues'])
self.check_reviews_on_project(project['name'], project['issues'])
self.check_jenkins_jobs(project['name'],
[j['name'] for j in project['jobnames']])
self.check_pads(2)
self.check_pasties(2)
def checker(self):
for project in self.resources['projects']:
print "Check user datas for %s" % project['name']
self.check_project(project['name'])
self.check_files_in_project(project['name'],
[f['name'] for f in project['files']])
if is_present('SFRedmine'):
self.check_issues_on_project(project['name'],
project['issues'])
self.check_reviews_on_project(project['name'], project['issues'])
self.check_jenkins_jobs(project['name'],
[j['name'] for j in project['jobnames']])
self.check_pads(2)
self.check_pasties(2)
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 is_present("SFRedmine"):
users = self.rm.r.user.filter(limit=20)
users = [u for u in users if u.firstname == 'bootsy']
self.assertEqual(1, len(users))
user = users[0]
self.assertEqual('*****@*****.**', user.mail)
# 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.assertEqual(401, int(d.status_code))
# 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 is_present("SFRedmine"):
users = self.rm.r.user.filter(limit=20)
self.assertEqual(
0, len([u for u in users if u.firstname == 'bootsy']))
def shortest_path(self, origin):
heap = []
shortest_path = []
for i in range(0, self.network.size):
if i == origin:
shortest_path.append(0)
heapq.heappush(heap, (i, 0))
else:
shortest_path.append(self.INF)
heapq.heappush(heap, (i, self.INF))
while len(heap) > 0:
u, heap = utils.get_min(heap)
for adjacent in self.network.adjacency[u[0]]:
if utils.is_present(heap, adjacent):
self.num_transmissions[origin] += 1
if shortest_path[adjacent] > u[1] + 1:
shortest_path[adjacent] = u[1] + 1
heap = utils.set_value(adjacent, u[1] + 1, heap)
return shortest_path
def shortest_path(self, origin):
heap = []
shortest_path = []
for i in range(0, self.network.size):
if i == origin:
shortest_path.append(0)
heapq.heappush(heap, (i, 0))
else:
shortest_path.append(self.INF)
heapq.heappush(heap, (i, self.INF))
while len(heap) > 0:
u, heap = utils.get_min(heap)
for adjacent in self.network.adjacency[u[0]]:
if utils.is_present(heap, adjacent):
self.num_transmissions[origin] += 1
if shortest_path[adjacent] > u[1] + 1:
shortest_path[adjacent] = u[1] + 1
heap = utils.set_value(adjacent, u[1] + 1, heap)
return shortest_path
def checker(self):
self.check_checksums()
self.check_users_list()
for project in self.resources['projects']:
print "Check user datas for %s" % project['name']
self.check_project(project['name'])
self.check_files_in_project(project['name'],
[f['name'] for f in project['files']])
if is_present('storyboard'):
self.check_issues_on_project(project['name'],
project['issues'])
self.check_reviews_on_project(project['name'], project['issues'])
self.check_pads(2)
self.check_pasties(2)
for user in self.resources['local_users']:
print "Check user %s can log in ..." % user['username'],
if self.simple_login(user['username'], user['password']):
print "OK"
else:
print "FAIL"
exit(1)
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))
# Redmine part
if is_present("SFRedmine"):
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))
# Redmine part
if is_present("SFRedmine"):
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 checker(self):
self.check_checksums()
self.check_users_list()
for project in self.resources['projects']:
print "Check user datas for %s" % project['name']
self.check_project(project['name'])
self.check_files_in_project(project['name'],
[f['name'] for f in project['files']])
if is_present('SFRedmine'):
self.check_issues_on_project(project['name'],
project['issues'])
self.check_reviews_on_project(project['name'], project['issues'])
self.check_jenkins_jobs(project['name'],
[j['name'] for j in project['jobnames']])
self.check_pads(2)
self.check_pasties(2)
for user in self.resources['local_users']:
print "Check user %s can log in ..." % user['username'],
if self.simple_login(user['username'],
user['password']):
print "OK"
else:
print "FAIL"
exit(1)
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))
# Redmine part
if is_present("SFRedmine"):
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))
# Redmine part
if is_present("SFRedmine"):
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))
# Redmine part
if is_present("SFRedmine"):
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))
# Redmine part
if is_present("SFRedmine"):
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))
# Redmine part
if is_present("SFRedmine"):
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))
# Redmine part
if is_present("SFRedmine"):
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))
# Redmine part
if is_present("SFRedmine"):
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))
# Redmine part
if is_present("SFRedmine"):
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))
# Redmine part
if is_present("SFRedmine"):
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))
# Redmine part
if is_present("SFRedmine"):
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))
# Redmine part
if is_present("SFRedmine"):
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))
# Redmine part
if is_present("SFRedmine"):
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 is_present("SFRedmine"):
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)
