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_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_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 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 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_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 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 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 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)