def test_review_labels(self): """ Test if list of review labels are as expected """ pname = 'p_%s' % create_random_str() self.create_project(pname) un = config.ADMIN_USER gu = GerritUtils(config.GATEWAY_URL, auth_cookie=config.USERS[un]['auth_cookie']) k_index = gu.add_pubkey(config.USERS[un]["pubkey"]) self.assertTrue(gu.project_exists(pname)) priv_key_path = set_private_key(config.USERS[un]["privkey"]) gitu = GerritGitUtils(un, priv_key_path, config.USERS[un]['email']) url = "ssh://%s@%s:29418/%s" % (un, config.GATEWAY_HOST, pname) clone_dir = gitu.clone(url, pname) self.dirs_to_delete.append(os.path.dirname(clone_dir)) gitu.add_commit_and_publish(clone_dir, "master", "Test commit") change_ids = gu.get_my_changes_for_project(pname) self.assertEqual(len(change_ids), 1) change_id = change_ids[0] labels = gu.get_labels_list_for_change(change_id) self.assertIn('Workflow', labels) self.assertIn('Code-Review', labels) self.assertIn('Verified', labels) self.assertEqual(len(labels.keys()), 3) gu.del_pubkey(k_index)
def _prepare_review_submit_testing(self, data=None): pname = 'p_%s' % create_random_str() self.create_project(pname) gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) k_index = gu.add_pubkey(config.USERS[config.ADMIN_USER]["pubkey"]) self.assertTrue(gu.project_exists(pname)) priv_key_path = set_private_key( config.USERS[config.ADMIN_USER]["privkey"]) gitu = GerritGitUtils(config.ADMIN_USER, priv_key_path, config.USERS[config.ADMIN_USER]['email']) url = "ssh://%s@%s:29418/%s" % (config.ADMIN_USER, config.GATEWAY_HOST, pname) clone_dir = gitu.clone(url, pname) self.dirs_to_delete.append(os.path.dirname(clone_dir)) if not data: gitu.add_commit_and_publish(clone_dir, "master", "Test commit") else: file(os.path.join(clone_dir, "file"), 'w').write(data[1]) gitu.add_commit_and_publish(clone_dir, "master", "Test commit", fnames=[data[0]]) change_ids = gu.get_my_changes_for_project(pname) self.assertEqual(len(change_ids), 1) change_id = change_ids[0] return change_id, gu, k_index, pname
def _prepare_review_submit_testing(self, project_options=None): if project_options is None: u2mail = config.USERS[config.USER_2]['email'] project_options = {'core-group': u2mail} pname = 'p_%s' % create_random_str() self.create_project(pname, project_options) un = config.ADMIN_USER gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[un]['auth_cookie']) k_index = gu.add_pubkey(config.USERS[un]["pubkey"]) self.assertTrue(gu.project_exists(pname)) priv_key_path = set_private_key(config.USERS[un]["privkey"]) gitu = GerritGitUtils(un, priv_key_path, config.USERS[un]['email']) url = "ssh://%s@%s:29418/%s" % (un, config.GATEWAY_HOST, pname) clone_dir = gitu.clone(url, pname) self.dirs_to_delete.append(os.path.dirname(clone_dir)) gitu.add_commit_and_publish(clone_dir, "master", "Test commit") change_ids = gu.get_my_changes_for_project(pname) self.assertEqual(len(change_ids), 1) change_id = change_ids[0] return change_id, gu, k_index
def test_review_labels(self): """ Test if list of review labels are as expected """ pname = 'p_%s' % create_random_str() self.create_project(pname) un = config.ADMIN_USER gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[un]['auth_cookie']) k_index = gu.add_pubkey(config.USERS[un]["pubkey"]) self.assertTrue(gu.project_exists(pname)) priv_key_path = set_private_key(config.USERS[un]["privkey"]) gitu = GerritGitUtils(un, priv_key_path, config.USERS[un]['email']) url = "ssh://%s@%s:29418/%s" % (un, config.GATEWAY_HOST, pname) clone_dir = gitu.clone(url, pname) self.dirs_to_delete.append(os.path.dirname(clone_dir)) gitu.add_commit_and_publish(clone_dir, "master", "Test commit") change_ids = gu.get_my_changes_for_project(pname) self.assertEqual(len(change_ids), 1) change_id = change_ids[0] labels = gu.get_labels_list_for_change(change_id) self.assertIn('Workflow', labels) self.assertIn('Code-Review', labels) self.assertIn('Verified', labels) self.assertEqual(len(labels.keys()), 3) gu.del_pubkey(k_index)
def test_check_config_repo_exists(self): """ Validate config repo has been bootstraped """ pname = "config" gu = GerritUtils(config.GATEWAY_URL, auth_cookie=config.USERS[config.ADMIN_USER]["auth_cookie"]) self.assertTrue(gu.project_exists(pname)) 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) # Test that the clone is a success self.assertTrue(os.path.isdir(clone_dir)) # Check if the clone dir has projects file self.assertTrue(os.path.isfile(os.path.join(clone_dir, "jobs/projects.yaml")))
def test_check_download_commands(self): """ Test if download commands plugin works """ pname = 'p_%s' % create_random_str() self.create_project(pname) un = config.ADMIN_USER gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[un]['auth_cookie']) self.assertTrue(gu.project_exists(pname)) k_index = gu.add_pubkey(config.USERS[un]["pubkey"]) priv_key_path = set_private_key(config.USERS[un]["privkey"]) gitu = GerritGitUtils(un, priv_key_path, config.USERS[un]['email']) url = "ssh://%s@%s:29418/%s" % (un, config.GATEWAY_HOST, pname) clone_dir = gitu.clone(url, pname) self.dirs_to_delete.append(os.path.dirname(clone_dir)) gitu.add_commit_and_publish(clone_dir, "master", "Test commit") change_ids = gu.get_my_changes_for_project(pname) self.assertEqual(len(change_ids), 1) change_id = change_ids[0] resp = gu.get_change_last_patchset(change_id) self.assertIn("current_revision", resp) self.assertIn("revisions", resp) current_rev = resp["current_revision"] fetch = resp["revisions"][current_rev]["fetch"] self.assertGreater(fetch.keys(), 0) # disable and check if the fetch has anything gu.e_d_plugin("download-commands", 'disable') resp = gu.get_change_last_patchset(change_id) fetch = resp["revisions"][current_rev]["fetch"] self.assertEqual(len(fetch.keys()), 0) # enable the plugin and check if the fetch information is valid gu.e_d_plugin("download-commands", 'enable') resp = gu.get_change_last_patchset(change_id) fetch = resp["revisions"][current_rev]["fetch"] self.assertGreater(len(fetch.keys()), 0) gu.del_pubkey(k_index)
def test_check_config_repo_exists(self): pname = 'config' gu = GerritUtils( 'https://%s/' % config.GATEWAY_HOST, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) self.assertTrue(gu.project_exists(pname)) 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) # Test that the clone is a success self.assertTrue(os.path.isdir(clone_dir)) # Check if the clone dir has projects file self.assertTrue(os.path.isfile(os.path.join(clone_dir, "jobs/projects.yaml")))
def test_check_config_repo_exists(self): """ Validate config repo has been bootstraped """ pname = 'config' gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) self.assertTrue(gu.project_exists(pname)) 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) # Test that the clone is a success self.assertTrue(os.path.isdir(clone_dir)) # Check if the clone dir has projects file self.assertTrue( os.path.isfile(os.path.join(clone_dir, "jobs/projects.yaml")))
def test_check_download_commands(self): """ Test if download commands plugin works """ pname = 'p_%s' % create_random_str() self.create_project(pname) un = config.ADMIN_USER gu = GerritUtils(config.GATEWAY_URL, auth_cookie=config.USERS[un]['auth_cookie']) self.assertTrue(gu.project_exists(pname)) k_index = gu.add_pubkey(config.USERS[un]["pubkey"]) priv_key_path = set_private_key(config.USERS[un]["privkey"]) gitu = GerritGitUtils(un, priv_key_path, config.USERS[un]['email']) url = "ssh://%s@%s:29418/%s" % (un, config.GATEWAY_HOST, pname) clone_dir = gitu.clone(url, pname) self.dirs_to_delete.append(os.path.dirname(clone_dir)) gitu.add_commit_and_publish(clone_dir, "master", "Test commit") change_ids = gu.get_my_changes_for_project(pname) self.assertEqual(len(change_ids), 1) change_id = change_ids[0] resp = gu.get_change_last_patchset(change_id) self.assertIn("current_revision", resp) self.assertIn("revisions", resp) current_rev = resp["current_revision"] fetch = resp["revisions"][current_rev]["fetch"] self.assertGreater(fetch.keys(), 0) # disable and check if the fetch has anything gu.e_d_plugin("download-commands", 'disable') resp = gu.get_change_last_patchset(change_id) fetch = resp["revisions"][current_rev]["fetch"] self.assertEqual(len(fetch.keys()), 0) # enable the plugin and check if the fetch information is valid gu.e_d_plugin("download-commands", 'enable') resp = gu.get_change_last_patchset(change_id) fetch = resp["revisions"][current_rev]["fetch"] self.assertGreater(len(fetch.keys()), 0) gu.del_pubkey(k_index)
def _prepare_review_submit_testing(self, project_options=None): if project_options is None: u2mail = config.USERS[config.USER_2]['email'] project_options = {'core-group': u2mail} pname = 'p_%s' % create_random_str() self.create_project(pname, project_options) un = config.ADMIN_USER gu = GerritUtils(config.GATEWAY_URL, auth_cookie=config.USERS[un]['auth_cookie']) k_index = gu.add_pubkey(config.USERS[un]["pubkey"]) self.assertTrue(gu.project_exists(pname)) priv_key_path = set_private_key(config.USERS[un]["privkey"]) gitu = GerritGitUtils(un, priv_key_path, config.USERS[un]['email']) url = "ssh://%s@%s:29418/%s" % (un, config.GATEWAY_HOST, pname) clone_dir = gitu.clone(url, pname) self.dirs_to_delete.append(os.path.dirname(clone_dir)) gitu.add_commit_and_publish(clone_dir, "master", "Test commit") change_ids = gu.get_my_changes_for_project(pname) self.assertEqual(len(change_ids), 1) change_id = change_ids[0] return change_id, gu, k_index
class SFchecker: """ This checker is only intended for testin SF backup/restore and update. It checks that the user data defined in resourses.yaml are present on the SF. Those data must have been provisioned by SFProvisioner. """ def __init__(self): with open("%s/resources.yaml" % pwd, 'r') as rsc: self.resources = yaml.load(rsc) config.USERS[config.ADMIN_USER]['auth_cookie'] = get_cookie( config.ADMIN_USER, config.USERS[config.ADMIN_USER]['password']) self.gu = GerritUtils( 'http://%s/' % config.GATEWAY_HOST, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) self.ggu = GerritGitUtils(config.ADMIN_USER, config.ADMIN_PRIV_KEY_PATH, config.USERS[config.ADMIN_USER]['email']) self.ju = JenkinsUtils() self.rm = RedmineUtils( config.GATEWAY_URL + "/redmine/", auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) def check_project(self, name): print " Check project %s exists ..." % name, if not self.gu.project_exists(name) or \ not self.rm.project_exists(name): print "FAIL" exit(1) print "OK" def check_files_in_project(self, name, files): print " Check files(%s) exists in project ..." % ",".join(files), # TODO(fbo); use gateway host instead of gerrit host url = "ssh://%s@%s:29418/%s" % (config.ADMIN_USER, config.GATEWAY_HOST, name) clone_dir = self.ggu.clone(url, name, config_review=False) for f in files: if not os.path.isfile(os.path.join(clone_dir, f)): print "FAIL" exit(1) def check_issues_on_project(self, name, issues): print " Check that at least %s issues exists for that project ...," %\ len(issues) current_issues = self.rm.get_issues_by_project(name) if len(current_issues) < len(issues): print "FAIL: expected %s, project has %s" % ( len(issues), len(current_issues)) exit(1) print "OK" def check_jenkins_jobs(self, name, jobnames): print " Check that jenkins jobs(%s) exists ..." % ",".join(jobnames), for jobname in jobnames: if not '%s_%s' % (name, jobname) in self.ju.list_jobs(): print "FAIL" exit(1) print "OK" def check_reviews_on_project(self, name, issues): reviews = [i for i in issues if i['review']] print " Check that at least %s reviews exists for that project ..." %\ len(reviews), pending_reviews = self.ggu.list_open_reviews(name, config.GATEWAY_HOST) if not len(pending_reviews) >= len(reviews): print "FAIL" exit(1) print "OK" def check_pads(self, amount): pass def check_pasties(self, amount): pass 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']]) 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_check_add_automatic_reviewers(self): """ Test if reviewers-by-blame plugin works """ pname = 'p_%s' % create_random_str() u2mail = config.USERS[config.USER_2]['email'] options = {'core-group': u2mail} self.create_project(pname, options) first_u = config.ADMIN_USER gu_first_u = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[first_u]['auth_cookie']) self.assertTrue(gu_first_u.project_exists(pname)) # Push data in the create project as Admin user k1_index = gu_first_u.add_pubkey(config.USERS[first_u]["pubkey"]) priv_key_path = set_private_key(config.USERS[first_u]["privkey"]) gitu = GerritGitUtils(first_u, priv_key_path, config.USERS[first_u]['email']) url = "ssh://%s@%s:29418/%s" % (first_u, config.GATEWAY_HOST, pname) clone_dir = gitu.clone(url, pname) self.dirs_to_delete.append(os.path.dirname(clone_dir)) data = ['this', 'is', 'a', 'couple', 'of', 'lines'] clone_dir = gitu.clone(url, pname) file(os.path.join(clone_dir, "file"), 'w').write("\n".join(data)) gitu.add_commit_and_publish(clone_dir, "master", "Test commit", fnames=["file"]) # Get the change id change_ids = gu_first_u.get_my_changes_for_project(pname) self.assertEqual(len(change_ids), 1) change_id = change_ids[0] # Merge the change gu_first_u.submit_change_note(change_id, "current", "Code-Review", "2") gu_first_u.submit_change_note(change_id, "current", "Verified", "2") gu_first_u.submit_change_note(change_id, "current", "Workflow", "1") second_u = config.USER_2 gu_second_u = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[second_u]['auth_cookie']) self.assertTrue(gu_first_u.submit_patch(change_id, "current")) # Change the file we have commited with Admin user k2_index = gu_second_u.add_pubkey(config.USERS[second_u]["pubkey"]) priv_key_path = set_private_key(config.USERS[second_u]["privkey"]) gitu = GerritGitUtils(second_u, priv_key_path, config.USERS[second_u]['email']) url = "ssh://%s@%s:29418/%s" % (second_u, config.GATEWAY_HOST, pname) clone_dir = gitu.clone(url, pname) self.dirs_to_delete.append(os.path.dirname(clone_dir)) data = ['this', 'is', 'some', 'lines'] file(os.path.join(clone_dir, "file"), 'w').write("\n".join(data)) gitu.add_commit_and_publish(clone_dir, "master", "Test commit", fnames=["file"]) # Get the change id change_ids = gu_second_u.get_my_changes_for_project(pname) self.assertEqual(len(change_ids), 1) change_id = change_ids[0] # Verify first_u has been automatically added to reviewers attempts = 0 while True: if len(gu_second_u.get_reviewers(change_id)) > 0 or attempts >= 3: break attempts += 1 time.sleep(1) reviewers = gu_second_u.get_reviewers(change_id) self.assertGreaterEqual(len(reviewers), 1) self.assertTrue(first_u in reviewers) gu_first_u.del_pubkey(k1_index) gu_second_u.del_pubkey(k2_index)
class TestManageSF(Base): """ Functional tests that validate managesf features. Here we do basic verifications about project creation with managesf. """ @classmethod def setUpClass(cls): cls.msu = ManageSfUtils(config.GATEWAY_URL) @classmethod def tearDownClass(cls): pass def setUp(self): self.projects = [] self.dirs_to_delete = [] self.rm = RedmineUtils( config.GATEWAY_URL + "/redmine/", auth_cookie=config.USERS[config.ADMIN_USER]["auth_cookie"] ) self.gu = GerritUtils(config.GATEWAY_URL, auth_cookie=config.USERS[config.ADMIN_USER]["auth_cookie"]) def project_exists_ex(self, name, user): # Test here the project is "public" # ( Redmine API project detail does not return the private/public flag) rm = RedmineUtils(config.GATEWAY_URL + "/redmine/", auth_cookie=config.USERS[user]["auth_cookie"]) try: return rm.project_exists(name) except Exception: return False def tearDown(self): for name in self.projects: self.msu.deleteProject(name, config.ADMIN_USER) for dirs in self.dirs_to_delete: shutil.rmtree(dirs) def create_project(self, name, user, options=None): self.msu.createProject(name, user, options) self.projects.append(name) 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 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_private_project_as_admin(self): """ Create private project on redmine and gerrit as admin """ 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)) # 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)) self.assertTrue(self.gu.member_in_group(config.ADMIN_USER, "%s-dev" % pname)) # Redmine part 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.assertFalse(self.project_exists_ex(pname, config.USER_2)) 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)) 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)) self.assertFalse(self.rm.project_exists(pname)) self.assertFalse(self.gu.group_exists("%s-core" % pname)) self.projects.remove(pname) def test_create_public_project_as_user(self): """ Create public project on redmine and gerrit as user """ 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)) # 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 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.assertTrue(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)) # Redmine part 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_public_project_with_users_in_group(self): """ Create public 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"] options = {"ptl-group": "", "core-group": "%s,%s" % (u2mail, u3mail)} 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)) # Redmine part 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): self.assertTrue(self.rm.check_user_role(pname, user, "Developer")) 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 # 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_public_project_as_admin_clone_as_admin(self): """ Clone public project as admin and check content """ pname = "p_%s" % create_random_str() self.create_project(pname, config.ADMIN_USER) 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) 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"))) # Verify meta/config branch own both group and ACLs config file ggu.fetch_meta_config(clone_dir) self.assertTrue(os.path.isfile(os.path.join(clone_dir, "project.config"))) self.assertTrue(os.path.isfile(os.path.join(clone_dir, "groups"))) # There is no group dev for a public project content = file(os.path.join(clone_dir, "project.config")).read() self.assertFalse("%s-dev" % pname in content) content = file(os.path.join(clone_dir, "groups")).read() self.assertFalse("%s-dev" % pname in content) def test_create_private_project_as_admin_clone_as_admin(self): """ Clone private project as admin and check content """ pname = "p_%s" % create_random_str() options = {"private": ""} self.create_project(pname, config.ADMIN_USER, options=options) 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) 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"))) # Verify meta/config branch own both group and ACLs config file ggu.fetch_meta_config(clone_dir) self.assertTrue(os.path.isfile(os.path.join(clone_dir, "project.config"))) self.assertTrue(os.path.isfile(os.path.join(clone_dir, "groups"))) # There is a group dev for a private project content = file(os.path.join(clone_dir, "project.config")).read() self.assertTrue("%s-dev" % pname in content) content = file(os.path.join(clone_dir, "groups")).read() self.assertTrue("%s-dev" % pname in content) def test_create_public_project_as_admin_clone_as_user(self): """ Create public project as admin then clone as user """ pname = "p_%s" % create_random_str() # create the project as admin self.create_project(pname, config.ADMIN_USER) # add user2 ssh pubkey to user2 gu = GerritUtils(config.GATEWAY_URL, auth_cookie=config.USERS[config.USER_2]["auth_cookie"]) gu.add_pubkey(config.USER_2_PUB_KEY) # prepare to clone priv_key_path = set_private_key(config.USER_2_PRIV_KEY) self.dirs_to_delete.append(os.path.dirname(priv_key_path)) ggu = GerritGitUtils(config.USER_2, priv_key_path, config.USERS[config.USER_2]["email"]) url = "ssh://%s@%s:29418/%s" % (config.USER_2, config.GATEWAY_HOST, pname) # clone clone_dir = ggu.clone(url, pname) 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"))) def test_create_public_project_as_user_clone_as_user(self): """ Create public project as user then clone as user """ pname = "p_%s" % create_random_str() # create the project as admin self.create_project(pname, config.USER_2) # add user2 ssh pubkey to user2 gu = GerritUtils(config.GATEWAY_URL, auth_cookie=config.USERS[config.USER_2]["auth_cookie"]) gu.add_pubkey(config.USER_2_PUB_KEY) # prepare to clone priv_key_path = set_private_key(config.USER_2_PRIV_KEY) self.dirs_to_delete.append(os.path.dirname(priv_key_path)) ggu = GerritGitUtils(config.USER_2, priv_key_path, config.USERS[config.USER_2]["email"]) url = "ssh://%s@%s:29418/%s" % (config.USER_2, config.GATEWAY_HOST, pname) # clone clone_dir = ggu.clone(url, pname) 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"))) def test_upstream(self): """ Validate upstream feature of managesf """ # Create a test upstream project pname_us = "p_upstream" self.create_project(pname_us, config.ADMIN_USER) ggu_us = 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_us) # clone us_clone_dir = ggu_us.clone(url, pname_us) self.dirs_to_delete.append(os.path.dirname(us_clone_dir)) # Test that the clone is a success self.assertTrue(os.path.isdir(us_clone_dir)) # push some test files to the upstream project us_files = [str(x) for x in range(1, 10)] for f in us_files: file(os.path.join(us_clone_dir, f), "w").write(f) os.chmod(os.path.join(us_clone_dir, f), 0755) ggu_us.add_commit_in_branch(us_clone_dir, "master", commit="Adding files 1-10", files=us_files) ggu_us.direct_push_branch(us_clone_dir, "master") # No create a test project with upstream pointing to the above upstream_url = "ssh://%s@%s:29418/%s" % (config.ADMIN_USER, config.GATEWAY_HOST, pname_us) pname = "p_%s" % create_random_str() # create the project as admin options = {"upstream": upstream_url, "upstream-ssh-key": config.ADMIN_PRIV_KEY_PATH} self.create_project(pname, config.ADMIN_USER, options=options) 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 clone_dir = ggu.clone(url, pname) self.dirs_to_delete.append(os.path.dirname(clone_dir)) # Check if the files pushed in upstream project is present files = [f for f in os.listdir(clone_dir) if not f.startswith(".")] self.assertEqual(set(files), set(us_files)) 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)) 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)) self.assertFalse(self.rm.project_exists(pname)) self.assertFalse(self.gu.group_exists("%s-core" % pname)) self.projects.remove(pname) def test_list_active_members(self): """ Check the list of members as a list of tuples of emails and names """ self.assertTrue(self.msu.list_active_members(config.USER_2)) def test_init_user_tests(self): """ Check if a test init feature behave as expected """ project = "p_%s" % create_random_str() self.create_project(project, config.USER_4) self.msu.create_init_tests(project, config.USER_4) ggu = GerritGitUtils(config.ADMIN_USER, config.ADMIN_PRIV_KEY_PATH, config.USERS[config.ADMIN_USER]["email"]) open_reviews = ggu.list_open_reviews("config", config.GATEWAY_HOST) match = [ True for review in open_reviews if review["commitMessage"].startswith( "%s proposes initial test " "definition for project %s" % (config.USER_4, project) ) ] self.assertEqual(len(match), 1) open_reviews = ggu.list_open_reviews(project, config.GATEWAY_HOST) match = [ True for review in open_reviews if review["commitMessage"].startswith( "%s proposes initial test " "scripts for project %s" % (config.USER_4, project) ) ] self.assertEqual(len(match), 1) def test_rest_urls_accessible(self): """ Check if managesf URLs are all working """ project = "p_%s" % create_random_str() self.create_project(project, config.ADMIN_USER) cookies = dict(auth_pubtkt=config.USERS[config.ADMIN_USER]["auth_cookie"]) paths = ["/manage/project/", "/manage/project/%s" % project, "/manage/project/membership/"] for path in paths: url = "http://%s%s" % (config.GATEWAY_HOST, path) resp = requests.get(url, cookies=cookies) self.assertEqual(200, resp.status_code) def test_validate_get_all_project_details(self): """ Check if managesf allow us to fetch projects details """ project = "p_%s" % create_random_str() self.create_project(project, config.USER_2) admin_cookies = dict(auth_pubtkt=config.USERS[config.ADMIN_USER]["auth_cookie"]) user2_cookies = dict(auth_pubtkt=config.USERS[config.USER_2]["auth_cookie"]) url = "http://%s%s" % (config.GATEWAY_HOST, "/manage/project/") resp = requests.get(url, cookies=admin_cookies) self.assertEqual(200, resp.status_code) self.assertTrue(project in resp.json()) self.assertTrue("config" in resp.json()) resp = requests.get(url, cookies=user2_cookies) self.assertEqual(200, resp.status_code) self.assertTrue(project in resp.json()) self.assertTrue("config" in resp.json()) resp = requests.get(url, cookies=user2_cookies)
class SFchecker: """ This checker is only intended for testin SF backup/restore and update. It checks that the user data defined in resourses.yaml are present on the SF. Those data must have been provisioned by SFProvisioner. """ def __init__(self): with open("%s/resources.yaml" % pwd, 'r') as rsc: self.resources = yaml.load(rsc) config.USERS[config.ADMIN_USER]['auth_cookie'] = get_cookie( config.ADMIN_USER, config.USERS[config.ADMIN_USER]['password']) self.gu = GerritUtils( 'http://%s/' % config.GATEWAY_HOST, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) self.ggu = GerritGitUtils(config.ADMIN_USER, config.ADMIN_PRIV_KEY_PATH, config.USERS[config.ADMIN_USER]['email']) self.ju = JenkinsUtils() self.rm = RedmineUtils( config.GATEWAY_URL + "/redmine/", auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) 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 check_files_in_project(self, name, files): print " Check files(%s) exists in project ..." % ",".join(files), # TODO(fbo); use gateway host instead of gerrit host url = "ssh://%s@%s:29418/%s" % (config.ADMIN_USER, config.GATEWAY_HOST, name) clone_dir = self.ggu.clone(url, name, config_review=False) for f in files: if not os.path.isfile(os.path.join(clone_dir, f)): print "FAIL" exit(1) def check_issues_on_project(self, name, issues): print " Check that at least %s issues exists for that project ...," %\ len(issues) current_issues = self.rm.get_issues_by_project(name) if len(current_issues) < len(issues): print "FAIL: expected %s, project has %s" % ( len(issues), len(current_issues)) exit(1) print "OK" def check_jenkins_jobs(self, name, jobnames): print " Check that jenkins jobs(%s) exists ..." % ",".join(jobnames), for jobname in jobnames: if not '%s_%s' % (name, jobname) in self.ju.list_jobs(): print "FAIL" exit(1) print "OK" def check_reviews_on_project(self, name, issues): reviews = [i for i in issues if i['review']] print " Check that at least %s reviews exists for that project ..." %\ len(reviews), pending_reviews = self.ggu.list_open_reviews(name, config.GATEWAY_HOST) if not len(pending_reviews) >= len(reviews): print "FAIL" exit(1) print "OK" def check_pads(self, amount): pass def check_pasties(self, amount): pass def command(self, cmd): return ssh_run_cmd(os.path.expanduser("~/.ssh/id_rsa"), "root", config.GATEWAY_HOST, shlex.split(cmd)) def compute_checksum(self, f): out = self.command("md5sum %s" % f)[0] if out: return out.split()[0] def read_file(self, f): return self.command("cat %s" % f)[0] def simple_login(self, user, password): """log as user""" return get_cookie(user, password) def check_users_list(self): print "Check that users are listable ...", users = [u['name'] for u in self.resources['users']] c = {'auth_pubtkt': config.USERS[config.ADMIN_USER]['auth_cookie']} url = 'http://%s/manage/project/membership/' % config.GATEWAY_HOST registered = requests.get(url, cookies=c).json() # usernames are in first position r_users = [u[0] for u in registered] if not set(users).issubset(set(r_users)): print "FAIL" exit(1) print "OK" def check_checksums(self): print "Check that expected file are there" checksum_list = yaml.load(file('/tmp/pc_checksums.yaml')) mismatch = False for f, checksum in checksum_list.items(): c = self.compute_checksum(f) if c == checksum: print "Expected checksum (%s) for %s is OK." % ( checksum, f) else: print "Expected checksum (%s) for %s is WRONG (%s)." % ( checksum, f, c) print "New file is:" print " %s" % self.read_file(f).replace("\n", "\n ") mismatch = True if "checksum_warn_only" not in sys.argv and mismatch: sys.exit(1) 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_check_zuul_operations(self): """ Test if zuul verifies project correctly through zuul-demo project """ # zuul-demo - test project used exclusively to test zuul installation # The necessary project descriptions are already declared in Jenkins # and zuul pname = 'demo/zuul-demo' self.create_project(pname, config.ADMIN_USER) un = config.ADMIN_USER gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[un]['auth_cookie']) ju = JenkinsUtils() k_index = gu.add_pubkey(config.USERS[un]["pubkey"]) # Gerrit part self.assertTrue(gu.project_exists(pname)) priv_key_path = set_private_key(config.USERS[un]["privkey"]) gitu = GerritGitUtils(un, priv_key_path, config.USERS[un]['email']) url = "ssh://%s@%s:29418/%s" % (un, config.GATEWAY_HOST, pname) clone_dir = gitu.clone(url, pname) self.dirs_to_delete.append(os.path.dirname(clone_dir)) last_fail_build_num_ft = \ ju.get_last_build_number("zuul-demo-functional-tests", "lastFailedBuild") last_fail_build_num_ut = \ ju.get_last_build_number("zuul-demo-unit-tests", "lastFailedBuild") last_succeed_build_num_ft = \ ju.get_last_build_number("zuul-demo-functional-tests", "lastSuccessfulBuild") last_succeed_build_num_ut = \ ju.get_last_build_number("zuul-demo-unit-tests", "lastSuccessfulBuild") gitu.add_commit_and_publish(clone_dir, "master", "Test commit") change_ids = gu.get_my_changes_for_project(pname) self.assertGreater(len(change_ids), 0) change_id = change_ids[0] # Give some time for jenkins to work ju.wait_till_job_completes("zuul-demo-functional-tests", last_fail_build_num_ft, "lastFailedBuild") ju.wait_till_job_completes("zuul-demo-unit-tests", last_fail_build_num_ut, "lastFailedBuild") attempt = 0 while "jenkins" not in gu.get_reviewers(change_id): if attempt >= 90: break time.sleep(1) attempt += 1 attempt = 0 while gu.get_reviewer_approvals(change_id, 'jenkins')['Verified'] \ != '-1': if attempt >= 90: break time.sleep(1) attempt += 1 self.assertEqual( gu.get_reviewer_approvals(change_id, 'jenkins')['Verified'], '-1') # Add the test case files and resubmit for review data = "echo Working" files = ["run_functional-tests.sh", "run_tests.sh"] for f in files: file(os.path.join(clone_dir, f), 'w').write(data) os.chmod(os.path.join(clone_dir, f), 0755) gitu.add_commit_and_publish(clone_dir, "master", None, fnames=files) # Give some time for jenkins to work ju.wait_till_job_completes("zuul-demo-functional-tests", last_succeed_build_num_ft, "lastSuccessfulBuild") ju.wait_till_job_completes("zuul-demo-unit-tests", last_succeed_build_num_ut, "lastSuccessfulBuild") attempt = 0 while "jenkins" not in gu.get_reviewers(change_id): if attempt >= 90: break time.sleep(1) attempt += 1 attempt = 0 while gu.get_reviewer_approvals(change_id, 'jenkins')['Verified'] \ != '+1': if attempt >= 90: break time.sleep(1) attempt += 1 self.assertEqual( gu.get_reviewer_approvals(change_id, 'jenkins')['Verified'], '+1') gu.del_pubkey(k_index)
class TestManageSF(Base): """ Functional tests that validate managesf features. Here we do basic verifications about project creation with managesf. """ @classmethod def setUpClass(cls): cls.msu = ManageSfUtils(config.GATEWAY_URL) @classmethod def tearDownClass(cls): pass def setUp(self): self.projects = [] self.dirs_to_delete = [] self.rm = RedmineUtils( config.REDMINE_URL, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) self.gu = GerritUtils( 'https://%s/' % config.GATEWAY_HOST, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) def project_exists_ex(self, name, user): # Test here the project is "public" # ( Redmine API project detail does not return the private/public flag) rm = RedmineUtils( config.REDMINE_URL, auth_cookie=config.USERS[user]['auth_cookie']) try: return rm.project_exists(name) except Exception: return False def tearDown(self): for name in self.projects: self.msu.deleteProject(name, config.ADMIN_USER) for dirs in self.dirs_to_delete: shutil.rmtree(dirs) def create_project(self, name, user, options=None): self.msu.createProject(name, user, options) self.projects.append(name) 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 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_private_project_as_admin(self): """ Create private project on redmine and gerrit as admin """ 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)) # 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)) self.assertTrue( self.gu.member_in_group(config.ADMIN_USER, '%s-dev' % pname)) # Redmine part 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.assertFalse(self.project_exists_ex(pname, config.USER_2)) 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)) 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)) self.assertFalse(self.rm.project_exists(pname)) self.assertFalse(self.gu.group_exists('%s-core' % pname)) self.projects.remove(pname) def test_create_public_project_as_user(self): """ Create public project on redmine and gerrit as user """ 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)) # 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 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.assertTrue(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)) # Redmine part 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_public_project_with_users_in_group(self): """ Create public 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'] options = {"ptl-group": "", "core-group": "%s,%s" % (u2mail, u3mail), } 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)) # Redmine part 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): self.assertTrue(self.rm.check_user_role(pname, user, 'Developer')) 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 # 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_public_project_as_admin_clone_as_admin(self): """ Clone public project as admin and check content """ pname = 'p_%s' % create_random_str() self.create_project(pname, config.ADMIN_USER) 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) 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'))) # Verify meta/config branch own both group and ACLs config file ggu.fetch_meta_config(clone_dir) self.assertTrue(os.path.isfile(os.path.join(clone_dir, 'project.config'))) self.assertTrue(os.path.isfile(os.path.join(clone_dir, 'groups'))) # There is no group dev for a public project content = file(os.path.join(clone_dir, 'project.config')).read() self.assertFalse('%s-dev' % pname in content) content = file(os.path.join(clone_dir, 'groups')).read() self.assertFalse('%s-dev' % pname in content) def test_create_private_project_as_admin_clone_as_admin(self): """ Clone private project as admin and check content """ pname = 'p_%s' % create_random_str() options = {"private": ""} self.create_project(pname, config.ADMIN_USER, options=options) 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) 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'))) # Verify meta/config branch own both group and ACLs config file ggu.fetch_meta_config(clone_dir) self.assertTrue(os.path.isfile(os.path.join(clone_dir, 'project.config'))) self.assertTrue(os.path.isfile(os.path.join(clone_dir, 'groups'))) # There is a group dev for a private project content = file(os.path.join(clone_dir, 'project.config')).read() self.assertTrue('%s-dev' % pname in content) content = file(os.path.join(clone_dir, 'groups')).read() self.assertTrue('%s-dev' % pname in content) def test_create_public_project_as_admin_clone_as_user(self): """ Create public project as admin then clone as user """ pname = 'p_%s' % create_random_str() # create the project as admin self.create_project(pname, config.ADMIN_USER) # add user2 ssh pubkey to user2 gu = GerritUtils( 'https://%s/' % config.GATEWAY_HOST, auth_cookie=config.USERS[config.USER_2]['auth_cookie']) gu.add_pubkey(config.USER_2_PUB_KEY) # prepare to clone priv_key_path = set_private_key(config.USER_2_PRIV_KEY) self.dirs_to_delete.append(os.path.dirname(priv_key_path)) ggu = GerritGitUtils(config.USER_2, priv_key_path, config.USERS[config.USER_2]['email']) url = "ssh://%s@%s:29418/%s" % (config.USER_2, config.GATEWAY_HOST, pname) # clone clone_dir = ggu.clone(url, pname) 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'))) def test_create_public_project_as_user_clone_as_user(self): """ Create public project as user then clone as user """ pname = 'p_%s' % create_random_str() # create the project as admin self.create_project(pname, config.USER_2) # add user2 ssh pubkey to user2 gu = GerritUtils( 'https://%s/' % config.GATEWAY_HOST, auth_cookie=config.USERS[config.USER_2]['auth_cookie']) gu.add_pubkey(config.USER_2_PUB_KEY) # prepare to clone priv_key_path = set_private_key(config.USER_2_PRIV_KEY) self.dirs_to_delete.append(os.path.dirname(priv_key_path)) ggu = GerritGitUtils(config.USER_2, priv_key_path, config.USERS[config.USER_2]['email']) url = "ssh://%s@%s:29418/%s" % (config.USER_2, config.GATEWAY_HOST, pname) # clone clone_dir = ggu.clone(url, pname) 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'))) def test_upstream(self): """ Validate upstream feature of managesf """ # Create a test upstream project pname_us = 'p_upstream' self.create_project(pname_us, config.ADMIN_USER) ggu_us = 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_us) # clone us_clone_dir = ggu_us.clone(url, pname_us) self.dirs_to_delete.append(os.path.dirname(us_clone_dir)) # Test that the clone is a success self.assertTrue(os.path.isdir(us_clone_dir)) # push some test files to the upstream project us_files = [str(x) for x in range(1, 10)] for f in us_files: file(os.path.join(us_clone_dir, f), 'w').write(f) os.chmod(os.path.join(us_clone_dir, f), 0755) ggu_us.add_commit_in_branch(us_clone_dir, "master", commit="Adding files 1-10", files=us_files) ggu_us.direct_push_branch(us_clone_dir, "master") # No create a test project with upstream pointing to the above upstream_url = "ssh://%s@%s:29418/%s" % ( config.ADMIN_USER, config.GATEWAY_HOST, pname_us) pname = 'p_%s' % create_random_str() # create the project as admin options = {"upstream": upstream_url} self.create_project(pname, config.ADMIN_USER, options=options) 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 clone_dir = ggu.clone(url, pname) self.dirs_to_delete.append(os.path.dirname(clone_dir)) # Check if the files pushed in upstream project is present files = [f for f in os.listdir(clone_dir) if not f.startswith('.')] self.assertEqual(set(files), set(us_files)) def test_delete_project_as_admin(self): """ Checking 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)) 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)) self.assertFalse(self.rm.project_exists(pname)) self.assertFalse(self.gu.group_exists('%s-core' % pname)) self.projects.remove(pname) def test_list_active_members(self): """ Check the list of members as a list of tuples of emails and names """ self.assertTrue(self.msu.list_active_members(config.USER_2))
class TestManageSF(Base): """ Functional tests that validate managesf features. Here we do basic verifications about project creation with managesf. """ @classmethod def setUpClass(cls): cls.msu = ManageSfUtils(config.GATEWAY_URL) @classmethod def tearDownClass(cls): pass def setUp(self): self.projects = [] self.dirs_to_delete = [] self.rm = RedmineUtils( config.GATEWAY_URL + "/redmine/", auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) self.gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) def project_exists_ex(self, name, user): # Test here the project is "public" # ( Redmine API project detail does not return the private/public flag) rm = RedmineUtils( config.GATEWAY_URL + "/redmine/", auth_cookie=config.USERS[user]['auth_cookie']) try: return rm.project_exists(name) except Exception: return False def tearDown(self): for name in self.projects: self.msu.deleteProject(name, config.ADMIN_USER) for dirs in self.dirs_to_delete: shutil.rmtree(dirs) def create_project(self, name, user, options=None): self.msu.createProject(name, user, options) self.projects.append(name) 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 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_private_project_as_admin(self): """ Create private project on redmine and gerrit as admin """ 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)) # 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)) self.assertTrue( self.gu.member_in_group(config.ADMIN_USER, '%s-dev' % pname)) # Redmine part 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.assertFalse(self.project_exists_ex(pname, config.USER_2)) 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)) 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)) self.assertFalse(self.rm.project_exists(pname)) self.assertFalse(self.gu.group_exists('%s-core' % pname)) self.projects.remove(pname) def test_create_public_project_as_user(self): """ Create public project on redmine and gerrit as user """ 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)) # 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 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.assertTrue(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)) # Redmine part 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_public_project_with_users_in_group(self): """ Create public 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'] options = {"ptl-group": "", "core-group": "%s,%s" % (u2mail, u3mail), } 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)) # Redmine part 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): self.assertTrue(self.rm.check_user_role(pname, user, 'Developer')) 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 # 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_public_project_as_admin_clone_as_admin(self): """ Clone public project as admin and check content """ pname = 'p_%s' % create_random_str() self.create_project(pname, config.ADMIN_USER) 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) 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'))) # Verify meta/config branch own both group and ACLs config file ggu.fetch_meta_config(clone_dir) self.assertTrue(os.path.isfile(os.path.join(clone_dir, 'project.config'))) self.assertTrue(os.path.isfile(os.path.join(clone_dir, 'groups'))) # There is no group dev for a public project content = file(os.path.join(clone_dir, 'project.config')).read() self.assertFalse('%s-dev' % pname in content) content = file(os.path.join(clone_dir, 'groups')).read() self.assertFalse('%s-dev' % pname in content) def test_create_private_project_as_admin_clone_as_admin(self): """ Clone private project as admin and check content """ pname = 'p_%s' % create_random_str() options = {"private": ""} self.create_project(pname, config.ADMIN_USER, options=options) 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) 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'))) # Verify meta/config branch own both group and ACLs config file ggu.fetch_meta_config(clone_dir) self.assertTrue(os.path.isfile(os.path.join(clone_dir, 'project.config'))) self.assertTrue(os.path.isfile(os.path.join(clone_dir, 'groups'))) # There is a group dev for a private project content = file(os.path.join(clone_dir, 'project.config')).read() self.assertTrue('%s-dev' % pname in content) content = file(os.path.join(clone_dir, 'groups')).read() self.assertTrue('%s-dev' % pname in content) def test_create_public_project_as_admin_clone_as_user(self): """ Create public project as admin then clone as user """ pname = 'p_%s' % create_random_str() # create the project as admin self.create_project(pname, config.ADMIN_USER) # add user2 ssh pubkey to user2 gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.USER_2]['auth_cookie']) gu.add_pubkey(config.USER_2_PUB_KEY) # prepare to clone priv_key_path = set_private_key(config.USER_2_PRIV_KEY) self.dirs_to_delete.append(os.path.dirname(priv_key_path)) ggu = GerritGitUtils(config.USER_2, priv_key_path, config.USERS[config.USER_2]['email']) url = "ssh://%s@%s:29418/%s" % (config.USER_2, config.GATEWAY_HOST, pname) # clone clone_dir = ggu.clone(url, pname) 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'))) def test_create_public_project_as_user_clone_as_user(self): """ Create public project as user then clone as user """ pname = 'p_%s' % create_random_str() # create the project as admin self.create_project(pname, config.USER_2) # add user2 ssh pubkey to user2 gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.USER_2]['auth_cookie']) gu.add_pubkey(config.USER_2_PUB_KEY) # prepare to clone priv_key_path = set_private_key(config.USER_2_PRIV_KEY) self.dirs_to_delete.append(os.path.dirname(priv_key_path)) ggu = GerritGitUtils(config.USER_2, priv_key_path, config.USERS[config.USER_2]['email']) url = "ssh://%s@%s:29418/%s" % (config.USER_2, config.GATEWAY_HOST, pname) # clone clone_dir = ggu.clone(url, pname) 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'))) def test_upstream(self): """ Validate upstream feature of managesf """ # Create a test upstream project pname_us = 'p_upstream' self.create_project(pname_us, config.ADMIN_USER) ggu_us = 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_us) # clone us_clone_dir = ggu_us.clone(url, pname_us) self.dirs_to_delete.append(os.path.dirname(us_clone_dir)) # Test that the clone is a success self.assertTrue(os.path.isdir(us_clone_dir)) # push some test files to the upstream project us_files = [str(x) for x in range(1, 10)] for f in us_files: file(os.path.join(us_clone_dir, f), 'w').write(f) os.chmod(os.path.join(us_clone_dir, f), 0755) ggu_us.add_commit_in_branch(us_clone_dir, "master", commit="Adding files 1-10", files=us_files) ggu_us.direct_push_branch(us_clone_dir, "master") # No create a test project with upstream pointing to the above upstream_url = "ssh://%s@%s:29418/%s" % ( config.ADMIN_USER, config.GATEWAY_HOST, pname_us) pname = 'p_%s' % create_random_str() # create the project as admin options = {"upstream": upstream_url, "upstream-ssh-key": config.ADMIN_PRIV_KEY_PATH} self.create_project(pname, config.ADMIN_USER, options=options) 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 clone_dir = ggu.clone(url, pname) self.dirs_to_delete.append(os.path.dirname(clone_dir)) # Check if the files pushed in upstream project is present files = [f for f in os.listdir(clone_dir) if not f.startswith('.')] self.assertEqual(set(files), set(us_files)) 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)) 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)) self.assertFalse(self.rm.project_exists(pname)) self.assertFalse(self.gu.group_exists('%s-core' % pname)) self.projects.remove(pname) def test_list_active_members(self): """ Check the list of members as a list of tuples of emails and names """ self.assertTrue(self.msu.list_active_members(config.USER_2)) def test_init_user_tests(self): """ Check if a test init feature behave as expected """ project = 'p_%s' % create_random_str() self.create_project(project, config.USER_4) self.msu.create_init_tests(project, config.USER_4) ggu = GerritGitUtils(config.ADMIN_USER, config.ADMIN_PRIV_KEY_PATH, config.USERS[config.ADMIN_USER]['email']) open_reviews = ggu.list_open_reviews('config', config.GATEWAY_HOST) match = [True for review in open_reviews if review['commitMessage']. startswith("%s proposes initial test " "definition for project %s" % (config.USER_4, project))] self.assertEqual(len(match), 1) open_reviews = ggu.list_open_reviews(project, config.GATEWAY_HOST) match = [True for review in open_reviews if review['commitMessage']. startswith("%s proposes initial test " "scripts for project %s" % (config.USER_4, project))] self.assertEqual(len(match), 1) def test_rest_urls_accessible(self): """ Check if managesf URLs are all working """ project = 'p_%s' % create_random_str() self.create_project(project, config.ADMIN_USER) cookies = dict( auth_pubtkt=config.USERS[config.ADMIN_USER]['auth_cookie']) paths = [ "/manage/project/", "/manage/project/%s" % project, "/manage/project/membership/"] for path in paths: url = "http://%s%s" % (config.GATEWAY_HOST, path) resp = requests.get(url, cookies=cookies) self.assertEqual(200, resp.status_code) def test_validate_get_all_project_details(self): """ Check if managesf allow us to fetch projects details """ project = 'p_%s' % create_random_str() self.create_project(project, config.USER_2) admin_cookies = dict( auth_pubtkt=config.USERS[config.ADMIN_USER]['auth_cookie']) user2_cookies = dict( auth_pubtkt=config.USERS[config.USER_2]['auth_cookie']) url = "http://%s%s" % (config.GATEWAY_HOST, "/manage/project/") resp = requests.get(url, cookies=admin_cookies) self.assertEqual(200, resp.status_code) self.assertTrue(project in resp.json()) self.assertTrue('config' in resp.json()) resp = requests.get(url, cookies=user2_cookies) self.assertEqual(200, resp.status_code) self.assertTrue(project in resp.json()) self.assertTrue('config' in resp.json()) resp = requests.get(url, cookies=user2_cookies)
class TestProjectMembership(Base): """ Functional tests that validate adding or deleting users to project groups using managesf. """ @classmethod def setUpClass(cls): cls.msu = ManageSfUtils(config.GATEWAY_URL) @classmethod def tearDownClass(cls): pass def setUp(self): super(TestProjectMembership, self).setUp() self.projects = [] self.rm = get_issue_tracker_utils( auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) self.gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) def tearDown(self): super(TestProjectMembership, self).tearDown() for name in self.projects: self.msu.deleteProject(name, config.ADMIN_USER) def create_project(self, name, user, options=None): self.msu.createProject(name, user, options) self.projects.append(name) 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_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_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_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)
class SFchecker: """ This checker is only intended for testin SF backup/restore and update. It checks that the user data defined in resourses.yaml are present on the SF. Those data must have been provisioned by SFProvisioner. """ def __init__(self): with open("%s/resources.yaml" % pwd, 'r') as rsc: self.resources = yaml.load(rsc) config.USERS[config.ADMIN_USER]['auth_cookie'] = get_cookie( config.ADMIN_USER, config.USERS[config.ADMIN_USER]['password']) self.gu = GerritUtils( 'http://%s/' % config.GATEWAY_HOST, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) self.ggu = GerritGitUtils(config.ADMIN_USER, config.ADMIN_PRIV_KEY_PATH, config.USERS[config.ADMIN_USER]['email']) self.ju = JenkinsUtils() self.rm = RedmineUtils( config.GATEWAY_URL + "/redmine/", auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) 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 check_files_in_project(self, name, files): print " Check files(%s) exists in project ..." % ",".join(files), # TODO(fbo); use gateway host instead of gerrit host url = "ssh://%s@%s:29418/%s" % (config.ADMIN_USER, config.GATEWAY_HOST, name) clone_dir = self.ggu.clone(url, name, config_review=False) for f in files: if not os.path.isfile(os.path.join(clone_dir, f)): print "FAIL" exit(1) def check_issues_on_project(self, name, issues): print " Check that at least %s issues exists for that project ...," %\ len(issues) current_issues = self.rm.get_issues_by_project(name) if len(current_issues) < len(issues): print "FAIL: expected %s, project has %s" % (len(issues), len(current_issues)) exit(1) print "OK" def check_jenkins_jobs(self, name, jobnames): print " Check that jenkins jobs(%s) exists ..." % ",".join(jobnames), for jobname in jobnames: if not '%s_%s' % (name, jobname) in self.ju.list_jobs(): print "FAIL" exit(1) print "OK" def check_reviews_on_project(self, name, issues): reviews = [i for i in issues if i['review']] print " Check that at least %s reviews exists for that project ..." %\ len(reviews), pending_reviews = self.ggu.list_open_reviews(name, config.GATEWAY_HOST) if not len(pending_reviews) >= len(reviews): print "FAIL" exit(1) print "OK" def check_pads(self, amount): pass def check_pasties(self, amount): pass 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_check_zuul_operations(self): """ Test if zuul verifies project correctly through zuul-demo project """ # zuul-demo - test project used exclusively to test zuul installation # The necessary project descriptions are already declared in Jenkins # and zuul pname = 'zuul-demo' self.create_project(pname, config.ADMIN_USER) un = config.ADMIN_USER gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[un]['auth_cookie']) ju = JenkinsUtils() k_index = gu.add_pubkey(config.USERS[un]["pubkey"]) # Gerrit part self.assertTrue(gu.project_exists(pname)) priv_key_path = set_private_key(config.USERS[un]["privkey"]) gitu = GerritGitUtils(un, priv_key_path, config.USERS[un]['email']) url = "ssh://%s@%s:29418/%s" % (un, config.GATEWAY_HOST, pname) clone_dir = gitu.clone(url, pname) self.dirs_to_delete.append(os.path.dirname(clone_dir)) last_fail_build_num_ft = \ ju.get_last_build_number("zuul-demo-functional-tests", "lastFailedBuild") last_fail_build_num_ut = \ ju.get_last_build_number("zuul-demo-unit-tests", "lastFailedBuild") last_succeed_build_num_ft = \ ju.get_last_build_number("zuul-demo-functional-tests", "lastSuccessfulBuild") last_succeed_build_num_ut = \ ju.get_last_build_number("zuul-demo-unit-tests", "lastSuccessfulBuild") gitu.add_commit_and_publish(clone_dir, "master", "Test commit") change_ids = gu.get_my_changes_for_project(pname) self.assertEqual(len(change_ids), 1) change_id = change_ids[0] # Give some time for jenkins to work ju.wait_till_job_completes("zuul-demo-functional-tests", last_fail_build_num_ft, "lastFailedBuild") ju.wait_till_job_completes("zuul-demo-unit-tests", last_fail_build_num_ut, "lastFailedBuild") attempt = 0 while "jenkins" not in gu.get_reviewers(change_id): if attempt >= 90: break time.sleep(1) attempt += 1 attempt = 0 while gu.get_reviewer_approvals(change_id, 'jenkins')['Verified'] \ != '-1': if attempt >= 90: break time.sleep(1) attempt += 1 self.assertEqual( gu.get_reviewer_approvals(change_id, 'jenkins')['Verified'], '-1') # Add the test case files and resubmit for review data = "echo Working" files = ["run_functional-tests.sh", "run_tests.sh"] for f in files: file(os.path.join(clone_dir, f), 'w').write(data) os.chmod(os.path.join(clone_dir, f), 0755) gitu.add_commit_and_publish(clone_dir, "master", None, fnames=files) # Give some time for jenkins to work ju.wait_till_job_completes("zuul-demo-functional-tests", last_succeed_build_num_ft, "lastSuccessfulBuild") ju.wait_till_job_completes("zuul-demo-unit-tests", last_succeed_build_num_ut, "lastSuccessfulBuild") attempt = 0 while "jenkins" not in gu.get_reviewers(change_id): if attempt >= 90: break time.sleep(1) attempt += 1 attempt = 0 while gu.get_reviewer_approvals(change_id, 'jenkins')['Verified'] \ != '+1': if attempt >= 90: break time.sleep(1) attempt += 1 self.assertEqual( gu.get_reviewer_approvals(change_id, 'jenkins')['Verified'], '+1') gu.del_pubkey(k_index)
class TestManageSF(Base): """ Functional tests that validate managesf features. Here we do basic verifications about project creation with managesf. """ @classmethod def setUpClass(cls): cls.msu = ManageSfUtils(config.GATEWAY_URL) @classmethod def tearDownClass(cls): pass def setUp(self): self.projects = [] self.dirs_to_delete = [] self.rm = RedmineUtils( config.GATEWAY_URL + "/redmine/", auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) self.gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) def project_exists_ex(self, name, user): # Test here the project is "public" # ( Redmine API project detail does not return the private/public flag) rm = RedmineUtils( config.GATEWAY_URL + "/redmine/", auth_cookie=config.USERS[user]['auth_cookie']) try: return rm.project_exists(name) except Exception: return False def tearDown(self): for name in self.projects: self.msu.deleteProject(name, config.ADMIN_USER) for dirs in self.dirs_to_delete: shutil.rmtree(dirs) def create_project(self, name, user, options=None): self.msu.createProject(name, user, options) self.projects.append(name) 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_private_project_as_admin(self): """ Create private project on redmine and gerrit as admin """ 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)) # 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)) 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, 'Manager')) self.assertTrue( self.rm.check_user_role(pname, config.ADMIN_USER, 'Developer')) self.assertFalse(self.project_exists_ex(pname, config.USER_2)) 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_create_public_project_as_user(self): """ Create public project on redmine and gerrit as user """ 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)) # 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.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.assertTrue(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)) # 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_create_public_project_with_users_in_group(self): """ Create public 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'] options = {"ptl-group": "", "core-group": "%s,%s" % (u2mail, u3mail), } 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)) if is_present("SFRedmine"): 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): self.assertTrue(self.rm.check_user_role(pname, user, 'Developer')) 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_public_project_as_admin_clone_as_admin(self): """ Clone public project as admin and check content """ pname = 'a_%s' % create_random_str() self.create_project(pname, config.ADMIN_USER) 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) 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'))) # Verify meta/config branch own both group and ACLs config file ggu.fetch_meta_config(clone_dir) self.assertTrue(os.path.isfile(os.path.join(clone_dir, 'project.config'))) self.assertTrue(os.path.isfile(os.path.join(clone_dir, 'groups'))) # There is no group dev for a public project content = file(os.path.join(clone_dir, 'project.config')).read() self.assertFalse('%s-dev' % pname in content) content = file(os.path.join(clone_dir, 'groups')).read() self.assertFalse('%s-dev' % pname in content) def test_create_private_project_as_admin_clone_as_admin(self): """ Clone private project as admin and check content """ pname = 'p_%s' % create_random_str() options = {"private": ""} self.create_project(pname, config.ADMIN_USER, options=options) 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) 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'))) # Verify meta/config branch own both group and ACLs config file ggu.fetch_meta_config(clone_dir) self.assertTrue(os.path.isfile(os.path.join(clone_dir, 'project.config'))) self.assertTrue(os.path.isfile(os.path.join(clone_dir, 'groups'))) # There is a group dev for a private project content = file(os.path.join(clone_dir, 'project.config')).read() self.assertTrue('%s-dev' % pname in content) content = file(os.path.join(clone_dir, 'groups')).read() self.assertTrue('%s-dev' % pname in content) def test_create_public_project_as_admin_clone_as_user(self): """ Create public project as admin then clone as user """ pname = 'p_%s' % create_random_str() # create the project as admin self.create_project(pname, config.ADMIN_USER) # add user2 ssh pubkey to user2 gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.USER_2]['auth_cookie']) gu.add_pubkey(config.USER_2_PUB_KEY) # prepare to clone priv_key_path = set_private_key(config.USER_2_PRIV_KEY) self.dirs_to_delete.append(os.path.dirname(priv_key_path)) ggu = GerritGitUtils(config.USER_2, priv_key_path, config.USERS[config.USER_2]['email']) url = "ssh://%s@%s:29418/%s" % (config.USER_2, config.GATEWAY_HOST, pname) # clone clone_dir = ggu.clone(url, pname) 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'))) def test_create_public_project_as_user_clone_as_user(self): """ Create public project as user then clone as user """ pname = 'p_%s' % create_random_str() # create the project as admin self.create_project(pname, config.USER_2) # add user2 ssh pubkey to user2 gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.USER_2]['auth_cookie']) gu.add_pubkey(config.USER_2_PUB_KEY) # prepare to clone priv_key_path = set_private_key(config.USER_2_PRIV_KEY) self.dirs_to_delete.append(os.path.dirname(priv_key_path)) ggu = GerritGitUtils(config.USER_2, priv_key_path, config.USERS[config.USER_2]['email']) url = "ssh://%s@%s:29418/%s" % (config.USER_2, config.GATEWAY_HOST, pname) # clone clone_dir = ggu.clone(url, pname) 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'))) def test_upstream(self): """ Validate upstream feature of managesf """ # Create a test upstream project pname_us = 'p_upstream' self.create_project(pname_us, config.ADMIN_USER) ggu_us = 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_us) # clone us_clone_dir = ggu_us.clone(url, pname_us) self.dirs_to_delete.append(os.path.dirname(us_clone_dir)) # Test that the clone is a success self.assertTrue(os.path.isdir(us_clone_dir)) # push some test files to the upstream project us_files = [str(x) for x in range(1, 10)] for f in us_files: file(os.path.join(us_clone_dir, f), 'w').write(f) os.chmod(os.path.join(us_clone_dir, f), 0755) ggu_us.add_commit_in_branch(us_clone_dir, "master", commit="Adding files 1-10", files=us_files) ggu_us.direct_push_branch(us_clone_dir, "master") ggu_us.add_commit_in_branch(us_clone_dir, "branch1") ggu_us.direct_push_branch(us_clone_dir, "branch1") # No create a test project with upstream pointing to the above upstream_url = "ssh://%s@%s:29418/%s" % ( config.ADMIN_USER, config.GATEWAY_HOST, pname_us) pname = 'p_%s' % create_random_str() # create the project as admin options = {"upstream": upstream_url, "upstream-ssh-key": config.ADMIN_PRIV_KEY_PATH} self.create_project(pname, config.ADMIN_USER, options=options) 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 clone_dir = ggu.clone(url, pname) # Check if the files pushed in upstream project is present files = [f for f in os.listdir(clone_dir) if not f.startswith('.')] self.assertEqual(set(files), set(us_files)) branches = ggu.get_branches(clone_dir, True) self.assertNotIn('gerrit/branch1', branches) # Test upstream with additional branches pname2 = 'p_%s' % create_random_str() options['add-branches'] = '' self.create_project(pname2, config.ADMIN_USER, options=options) url = "ssh://%s@%s:29418/%s" % (config.ADMIN_USER, config.GATEWAY_HOST, pname2) clone_dir = ggu.clone(url, pname2) branches = ggu.get_branches(clone_dir, True) self.assertIn('gerrit/branch1', branches) self.dirs_to_delete.append(os.path.dirname(clone_dir)) 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_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) # For now listing users comes from Redmine @skipIfIssueTrackerMissing() def test_list_active_members(self): """ Check the list of members as a list of tuples of emails and names """ self.assertTrue(self.msu.list_active_members(config.USER_2)) def test_init_user_tests(self): """ Check if a test init feature behave as expected """ project = 'p_%s' % create_random_str() self.create_project(project, config.USER_4) self.msu.create_init_tests(project, config.USER_4) ggu = GerritGitUtils(config.ADMIN_USER, config.ADMIN_PRIV_KEY_PATH, config.USERS[config.ADMIN_USER]['email']) open_reviews = ggu.list_open_reviews('config', config.GATEWAY_HOST) match = [True for review in open_reviews if review['commitMessage']. startswith("%s proposes initial test " "definition for project %s" % (config.USER_4, project))] self.assertEqual(len(match), 1) open_reviews = ggu.list_open_reviews(project, config.GATEWAY_HOST) match = [True for review in open_reviews if review['commitMessage']. startswith("%s proposes initial test " "scripts for project %s" % (config.USER_4, project))] self.assertEqual(len(match), 1) def test_rest_urls_accessible(self): """ Check if managesf URLs are all working """ project = 'p_%s' % create_random_str() self.create_project(project, config.ADMIN_USER) cookies = dict( auth_pubtkt=config.USERS[config.ADMIN_USER]['auth_cookie']) paths = [ "/manage/project/", "/manage/project/%s" % project, "/manage/project/membership/"] for path in paths: url = "http://%s%s" % (config.GATEWAY_HOST, path) resp = requests.get(url, cookies=cookies) self.assertEqual(200, resp.status_code) def test_validate_get_all_project_details(self): """ Check if managesf allow us to fetch projects details """ project = 'p_%s' % create_random_str() self.create_project(project, config.USER_2) admin_cookies = dict( auth_pubtkt=config.USERS[config.ADMIN_USER]['auth_cookie']) user2_cookies = dict( auth_pubtkt=config.USERS[config.USER_2]['auth_cookie']) url = "http://%s%s" % (config.GATEWAY_HOST, "/manage/project/") resp = requests.get(url, cookies=admin_cookies) self.assertEqual(200, resp.status_code) self.assertTrue(project in resp.json()) self.assertTrue('config' in resp.json()) resp = requests.get(url, cookies=user2_cookies) self.assertEqual(200, resp.status_code) self.assertTrue(project in resp.json()) self.assertTrue('config' in resp.json()) resp = requests.get(url, cookies=user2_cookies) # Validate the same behavior with project including a '/' project = 'p/%s' % create_random_str() self.create_project(project, config.USER_2) url = "http://%s%s" % (config.GATEWAY_HOST, "/manage/project/") # Wait 15 seconds for managesf cache invalidation import time time.sleep(15) resp = requests.get(url, cookies=user2_cookies) self.assertEqual(200, resp.status_code) self.assertTrue(project in resp.json()) 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)) self.assertTrue(self.rm.project_exists(project)) self.msu.update_project_page(config.USER_2, project, "http://tests.com/") self.assertEqual(self.msu.get_project_page(config.USER_2, project).strip(), "\"http://tests.com/\"") self.msu.delete_project_page(config.USER_3, project) self.assertEqual(self.msu.get_project_page(config.USER_2, project).strip(), "\"http://tests.com/\"") self.msu.delete_project_page(config.USER_2, project) self.assertEqual(self.msu.get_project_page(config.USER_2, project).strip(), "")
class SFchecker: """ This checker is only intended for testin SF backup/restore and update. It checks that the user data defined in resourses.yaml are present on the SF. Those data must have been provisioned by SFProvisioner. """ def __init__(self): with open("%s/resources.yaml" % pwd, 'r') as rsc: self.resources = yaml.load(rsc) config.USERS[config.ADMIN_USER]['auth_cookie'] = get_cookie( config.ADMIN_USER, config.USERS[config.ADMIN_USER]['password']) self.gu = GerritUtils( 'http://%s/' % config.GATEWAY_HOST, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) self.ggu = GerritGitUtils(config.ADMIN_USER, config.ADMIN_PRIV_KEY_PATH, config.USERS[config.ADMIN_USER]['email']) self.ju = JenkinsUtils() self.stb_client = SFStoryboard( config.GATEWAY_URL + "/storyboard_api", config.USERS[config.ADMIN_USER]['auth_cookie']) 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 check_files_in_project(self, name, files): print " Check files(%s) exists in project ..." % ",".join(files), # TODO(fbo); use gateway host instead of gerrit host url = "ssh://%s@%s:29418/%s" % (config.ADMIN_USER, config.GATEWAY_HOST, name) clone_dir = self.ggu.clone(url, name, config_review=False) for f in files: if not os.path.isfile(os.path.join(clone_dir, f)): print "FAIL" exit(1) def check_issues_on_project(self, name, issues): print(" Check that at least %s issues exists " "for that project ..." % len(issues)) p = [p for p in self.stb_client.projects.get_all() if p.name == name][0] pt = [ t for t in self.stb_client.tasks.get_all() if t.project_id == p.id ] if len(pt) != len(issues): print "FAIL: expected %s, project has %s" % (len(issues), len(pt)) exit(1) print "OK" def check_jenkins_jobs(self, name, jobnames): print " Check that jenkins jobs(%s) exists ..." % ",".join(jobnames) for jobname in jobnames: if not '%s_%s' % (name, jobname) in self.ju.list_jobs(): print "FAIL" exit(1) print "OK" def check_reviews_on_project(self, name, issues): reviews = [i for i in issues if i['review']] print " Check that at least %s reviews exists for that project ..." %\ len(reviews), pending_reviews = self.ggu.list_open_reviews(name, config.GATEWAY_HOST) if not len(pending_reviews) >= len(reviews): print "FAIL" exit(1) print "OK" def check_pads(self, amount): pass def check_pasties(self, amount): pass def command(self, cmd): return ssh_run_cmd(os.path.expanduser("~/.ssh/id_rsa"), "root", config.GATEWAY_HOST, shlex.split(cmd)) def compute_checksum(self, f): out = self.command("md5sum %s" % f)[0] if out: return out.split()[0] def read_file(self, f): return self.command("cat %s" % f)[0] def simple_login(self, user, password): """log as user""" return get_cookie(user, password) def check_users_list(self): print "Check that users are listable ...", users = [u['name'] for u in self.resources['users']] c = {'auth_pubtkt': config.USERS[config.ADMIN_USER]['auth_cookie']} url = 'http://%s/manage/project/membership/' % config.GATEWAY_HOST registered = requests.get(url, cookies=c).json() # usernames are in first position r_users = [u[0] for u in registered] if not set(users).issubset(set(r_users)): print "FAIL: expected %s, got %s" % (users, r_users) exit(1) print "OK" def check_checksums(self): print "Check that expected file are there" checksum_list = yaml.load(file('pc_checksums.yaml')) mismatch = False for f, checksum in checksum_list.items(): if f.startswith("content_"): continue c = self.compute_checksum(f) if c == checksum: print "Expected checksum (%s) for %s is OK." % (checksum, f) else: print "Expected checksum (%s) for %s is WRONG (%s)." % ( checksum, f, c) print "New file is:" print " %s" % self.read_file(f).replace("\n", "\n ") print "Old file was:" print " %s" % checksum_list['content_' + f].replace( "\n", "\n ") mismatch = True if "checksum_warn_only" not in sys.argv and mismatch: sys.exit(1) 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_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)
class TestProjectMembership(Base): """ Functional tests that validate adding or deleting users to project groups using managesf. """ @classmethod def setUpClass(cls): cls.msu = ManageSfUtils(config.GATEWAY_URL) @classmethod def tearDownClass(cls): pass def setUp(self): self.projects = [] self.rm = RedmineUtils( config.GATEWAY_URL + "/redmine/", auth_cookie=config.USERS[config.ADMIN_USER]["auth_cookie"] ) self.gu = GerritUtils(config.GATEWAY_URL, auth_cookie=config.USERS[config.ADMIN_USER]["auth_cookie"]) def tearDown(self): for name in self.projects: self.msu.deleteProject(name, config.ADMIN_USER) def create_project(self, name, user, options=None): self.msu.createProject(name, user, options) self.projects.append(name) 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 self.assertTrue(self.rm.check_user_role(pname, config.USER_2, "Manager")) self.assertTrue(self.rm.check_user_role(pname, 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 self.assertFalse(self.rm.check_user_role(pname, config.USER_2, "Manager")) self.assertFalse(self.rm.check_user_role(pname, 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)) # Redmine part 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 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_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 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 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 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 self.assertFalse(self.rm.check_user_role(pname, config.USER_3, "Developer")) 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 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 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_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 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 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 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 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 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 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 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 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 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)
class TestResourcesWorkflow(Base): def setUp(self): super(TestResourcesWorkflow, self).setUp() priv_key_path = set_private_key( config.USERS[config.ADMIN_USER]["privkey"]) self.gitu_admin = GerritGitUtils( config.ADMIN_USER, priv_key_path, config.USERS[config.ADMIN_USER]['email']) self.gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) self.ju = JenkinsUtils() self.dirs_to_delete = [] def tearDown(self): super(TestResourcesWorkflow, self).tearDown() for dirs in self.dirs_to_delete: shutil.rmtree(dirs) def ssh_run_cmd(self, sshkey_priv_path, user, host, subcmd): host = '%s@%s' % (user, host) sshcmd = [ 'ssh', '-o', 'LogLevel=ERROR', '-o', 'StrictHostKeyChecking=no', '-o', 'UserKnownHostsFile=/dev/null', '-i', sshkey_priv_path, host ] cmd = sshcmd + subcmd devnull = open(os.devnull, 'wb') p = Popen(cmd, stdout=devnull, stderr=devnull) return p.communicate(), p.returncode def clone_as_admin(self, pname): url = "ssh://%s@%s:29418/%s" % (config.ADMIN_USER, config.GATEWAY_HOST, pname) clone_dir = self.gitu_admin.clone(url, pname) if os.path.dirname(clone_dir) not in self.dirs_to_delete: self.dirs_to_delete.append(os.path.dirname(clone_dir)) return clone_dir def commit_direct_push_as_admin(self, clone_dir, msg): # Stage, commit and direct push the additions on master self.gitu_admin.add_commit_for_all_new_additions(clone_dir, msg) return self.gitu_admin.direct_push_branch(clone_dir, 'master') def set_resources_then_direct_push(self, fpath, resources=None, mode='add'): config_clone_dir = self.clone_as_admin("config") path = os.path.join(config_clone_dir, fpath) if mode == 'add': file(path, 'w').write(resources) elif mode == 'del': os.unlink(path) change_sha = self.commit_direct_push_as_admin( config_clone_dir, "Add new resources for functional tests") config_update_log = self.ju.wait_for_config_update(change_sha) self.assertIn("SUCCESS", config_update_log) def wait_for_jenkins_note(self, change_id): attempt = 0 while "jenkins" not in self.gu.get_reviewers(change_id): if attempt >= 90: break time.sleep(1) attempt += 1 def propose_resources_change_check_ci(self, fpath, resources=None, mode='add', expected_note=1, msg=None): config_clone_dir = self.clone_as_admin("config") path = os.path.join(config_clone_dir, fpath) if mode == 'add': file(path, 'w').write(resources) elif mode == 'del': os.unlink(path) if not msg: msg = "Validate resources" if mode == 'add': change_sha = self.gitu_admin.add_commit_and_publish( config_clone_dir, "master", msg, fnames=[path]) if mode == 'del': change_sha = self.gitu_admin.add_commit_for_all_new_additions( config_clone_dir, msg, publish=True) change_nr = self.gu.get_change_number(change_sha) note = self.gu.wait_for_verify(change_nr) self.assertEqual(note, expected_note) def get_resources(self): gateau = config.USERS[config.ADMIN_USER]['auth_cookie'] resp = requests.get("%s/manage/resources/" % config.GATEWAY_URL, cookies={'auth_pubtkt': gateau}) return resp.json() def test_validate_wrong_resource_workflow(self): """ Check resources - wrong model is detected by config-check """ # This resource is not correct fpath = "resources/%s.yaml" % create_random_str() name = create_random_str() resources = """resources: groups: %s: unknown-key: value description: test for functional test """ # Add the resource file with review then check CI resources = resources % name self.propose_resources_change_check_ci(fpath, resources=resources, mode='add', expected_note=-1) def test_validate_correct_resource_workflow(self): """ Check resources - good model is detected by config-check """ # This resource is correct fpath = "resources/%s.yaml" % create_random_str() name = create_random_str() resources = """resources: groups: %s: description: test for functional test members: - [email protected] """ # Add the resource file with review then check CI resources = resources % name self.propose_resources_change_check_ci(fpath, resources=resources, mode='add') def test_validate_resources_deletion(self): """ Check resources - deletions detected and authorized via flag """ fpath = "resources/%s.yaml" % create_random_str() name = create_random_str() resources = """resources: groups: %s: description: test for functional test members: [] """ # Add the resources file w/o review resources = resources % name self.set_resources_then_direct_push(fpath, resources=resources, mode='add') # Remove the resource file via the review self.propose_resources_change_check_ci(fpath, mode='del', expected_note=-1) # Remove the resource file with "allow-delete" flag via the review shutil.rmtree(os.path.join(self.gitu_admin.tempdir, 'config')) msg = "Remove resource with flag\nsf-resources: allow-delete" self.propose_resources_change_check_ci(fpath, mode='del', msg=msg) @skipIfServiceMissing('storyboard') def test_CUD_project(self): """ Check resources - ops on project work as expected """ sclient = SFStoryboard(config.GATEWAY_URL + "/storyboard_api", config.USERS[config.USER_4]['auth_cookie']) fpath = "resources/%s.yaml" % create_random_str() name = create_random_str() resources = """resources: projects: %(pname)s: description: An awesome project issue-tracker: SFStoryboard source-repositories: - %(pname)s/%(r1name)s repos: %(pname)s/%(r1name)s: description: The server part acl: %(pname)s acls: %(pname)s: file: | [access "refs/*"] read = group Anonymous Users """ tmpl_keys = { 'pname': create_random_str(), 'r1name': create_random_str() } resources = resources % tmpl_keys # Add the resources file w/o review self.set_resources_then_direct_push(fpath, resources=resources, mode='add') # Some checks to validate stuff have been created projects = [p.name for p in sclient.projects.get_all()] self.assertIn("%s/%s" % (tmpl_keys['pname'], tmpl_keys['r1name']), projects) project_groups = [p.name for p in sclient.project_groups.get_all()] self.assertIn(tmpl_keys['pname'], project_groups) # Modify the project resource resources = """resources: projects: %(pname)s: description: An awesome project issue-tracker: SFStoryboard source-repositories: - %(pname)s/%(r1name)s - %(pname)s/%(r2name)s repos: %(pname)s/%(r1name)s: description: The server part acl: %(pname)s %(pname)s/%(r2name)s: description: The server part acl: %(pname)s acls: %(pname)s: file: | [access "refs/*"] read = group Anonymous Users """ tmpl_keys.update({'r2name': create_random_str()}) resources = resources % tmpl_keys self.set_resources_then_direct_push(fpath, resources=resources, mode='add') # Some checks to validate stuff have been updated projects = [p.name for p in sclient.projects.get_all()] for name in (tmpl_keys['r1name'], tmpl_keys['r2name']): self.assertIn("%s/%s" % (tmpl_keys['pname'], name), projects) project_groups = [p.name for p in sclient.project_groups.get_all()] self.assertIn(tmpl_keys['pname'], project_groups) # Del the resources file w/o review self.set_resources_then_direct_push(fpath, mode='del') # Check the project group has been deleted # Note the project (in storyboard) is not deleted # this is a current limitation of the API (01/13/2017) project_groups = [p.name for p in sclient.project_groups.get_all()] self.assertFalse(tmpl_keys['pname'] in project_groups) def test_CUD_group(self): """ Check resources - ops on group work as expected """ fpath = "resources/%s.yaml" % create_random_str() name = create_random_str() resources = """resources: groups: %s: description: test for functional test members: - [email protected] - [email protected] """ # Add the resources file w/o review resources = resources % name self.set_resources_then_direct_push(fpath, resources=resources, mode='add') # Check members on Gerrit gid = self.gu.get_group_id(name) members = [m['email'] for m in self.gu.get_group_members(gid)] self.assertIn("*****@*****.**", members) self.assertIn("*****@*****.**", members) # Modify resources Add/Remove members w/o review resources = """resources: groups: %s: description: test for functional test members: - [email protected] - [email protected] """ resources = resources % name self.set_resources_then_direct_push(fpath, resources=resources, mode='add') # Check members on Gerrit gid = self.gu.get_group_id(name) members = [m['email'] for m in self.gu.get_group_members(gid)] self.assertIn("*****@*****.**", members) self.assertIn("*****@*****.**", members) self.assertNotIn("*****@*****.**", members) # Del the resources file w/o review self.set_resources_then_direct_push(fpath, mode='del') # Check the group has been deleted self.assertFalse(self.gu.get_group_id(name)) def test_CD_repo(self): """ Check resources - ops on git repositories work as expected """ fpath = "resources/%s.yaml" % create_random_str() name = create_random_str() resources = """resources: repos: %s: description: test for functional test default-branch: br1 branches: br1: HEAD br2: HEAD master: '0' """ # Add the resources file w/o review resources = resources % name self.set_resources_then_direct_push(fpath, resources=resources, mode='add') # Check the project has been created self.assertTrue(self.gu.project_exists(name)) # Check branches branches = self.gu.g.get('/projects/%s/branches/' % name) for wref in ("HEAD", "br1", "br2"): found = False for ref in branches: if found: continue if ref['ref'].endswith(wref): found = True if ref['ref'] == 'HEAD' and ref['revision'] != "br1": raise Exception("Wrong default branch") if not found: raise Exception("Requested branch %s not found" % wref) # Del the resources file w/o review self.set_resources_then_direct_push(fpath, mode='del') # Check the project has been deleted self.assertFalse(self.gu.project_exists(name)) def test_CRUD_resources(self): """ Check resources - bulk ops on resources work as expected """ fpath = "resources/%s.yaml" % create_random_str() tmpl_keys = { 'pname': create_random_str(), 'r1name': create_random_str(), 'r2name': create_random_str(), 'aname': create_random_str(), 'g1name': create_random_str(), 'g2name': create_random_str() } resources = """resources: projects: %(pname)s: description: An awesome project contacts: - [email protected] source-repositories: - %(pname)s/%(r1name)s - %(pname)s/%(r2name)s website: http://ichiban-cloud.io documentation: http://ichiban-cloud.io/docs issue-tracker-url: http://ichiban-cloud.bugtrackers.io repos: %(pname)s/%(r1name)s: description: The server part acl: %(aname)s %(pname)s/%(r2name)s: description: The client part acl: %(aname)s acls: %(aname)s: file: | [access "refs/*"] read = group Anonymous Users read = group %(pname)s/%(g2name)s owner = group %(pname)s/%(g1name)s [access "refs/heads/*"] label-Code-Review = -2..+2 group %(pname)s/%(g2name)s label-Verified = -2..+2 group %(pname)s/%(g1name)s label-Workflow = -1..+1 group %(pname)s/%(g2name)s submit = group %(pname)s/%(g2name)s read = group Anonymous Users read = group %(pname)s/%(g2name)s [access "refs/meta/config"] read = group %(pname)s/%(g2name)s [receive] requireChangeId = true [submit] mergeContent = false action = fast forward only groups: - %(pname)s/%(g1name)s - %(pname)s/%(g2name)s groups: %(pname)s/%(g1name)s: members: - [email protected] %(pname)s/%(g2name)s: members: - [email protected] - [email protected] """ # Add the resources file w/o review resources = resources % tmpl_keys self.set_resources_then_direct_push(fpath, resources=resources, mode='add') # Check resources have been created self.assertTrue( self.gu.project_exists( os.path.join(tmpl_keys['pname'], tmpl_keys['r1name']))) self.assertTrue( self.gu.project_exists( os.path.join(tmpl_keys['pname'], tmpl_keys['r2name']))) gid = self.gu.get_group_id( os.path.join(tmpl_keys['pname'], tmpl_keys['g1name'])) members = [m['email'] for m in self.gu.get_group_members(gid)] self.assertEqual(len(members), 1) self.assertIn("*****@*****.**", members) gid2 = self.gu.get_group_id( os.path.join(tmpl_keys['pname'], tmpl_keys['g2name'])) members = [m['email'] for m in self.gu.get_group_members(gid2)] self.assertEqual(len(members), 2) self.assertIn("*****@*****.**", members) self.assertIn("*****@*****.**", members) # Verify ACLs have been written for both repo for r in ('r1name', 'r2name'): rname = os.path.join(tmpl_keys['pname'], tmpl_keys[r]) acl = self.gu.g.get('access/?project=%s' % rname) self.assertIn( gid2, acl[rname]['local']['refs/heads/*']['permissions'] ['submit']['rules'].keys()) # Verify the resources endpoint know about what we pushed res = self.get_resources() self.assertIn(tmpl_keys['pname'], res['resources']['projects'].keys()) self.assertIn(tmpl_keys['aname'], res['resources']['acls'].keys()) self.assertIn(os.path.join(tmpl_keys['pname'], tmpl_keys['g1name']), res['resources']['groups'].keys()) self.assertIn(os.path.join(tmpl_keys['pname'], tmpl_keys['g2name']), res['resources']['groups'].keys()) self.assertIn(os.path.join(tmpl_keys['pname'], tmpl_keys['r1name']), res['resources']['repos'].keys()) self.assertIn(os.path.join(tmpl_keys['pname'], tmpl_keys['r2name']), res['resources']['repos'].keys()) # Modify the ACL to verify repos ACL are updated resources = re.sub( 'submit = group .*', 'submit = group %s' % os.path.join(tmpl_keys['pname'], tmpl_keys['g1name']), resources) self.set_resources_then_direct_push(fpath, resources=resources, mode='add') # Verify ACLs have been updated for both repo for r in ('r1name', 'r2name'): rname = os.path.join(tmpl_keys['pname'], tmpl_keys[r]) acl = self.gu.g.get('access/?project=%s' % rname) self.assertIn( gid, acl[rname]['local']['refs/heads/*']['permissions'] ['submit']['rules'].keys()) # Now let's remove all that awesome resources self.set_resources_then_direct_push(fpath, mode='del') # Check resources have been deleted self.assertFalse( self.gu.project_exists( os.path.join(tmpl_keys['pname'], tmpl_keys['r1name']))) self.assertFalse( self.gu.project_exists( os.path.join(tmpl_keys['pname'], tmpl_keys['r2name']))) self.assertFalse( self.gu.get_group_id( os.path.join(tmpl_keys['pname'], tmpl_keys['g1name']))) self.assertFalse( self.gu.get_group_id( os.path.join(tmpl_keys['pname'], tmpl_keys['g2name']))) res = self.get_resources() projects = res['resources'].get('projects', {}) acls = res['resources'].get('acls', {}) groups = res['resources'].get('groups', {}) repos = res['resources'].get('repos', {}) self.assertNotIn(tmpl_keys['pname'], projects.keys()) self.assertNotIn(tmpl_keys['aname'], acls.keys()) self.assertNotIn(os.path.join(tmpl_keys['pname'], tmpl_keys['g1name']), groups.keys()) self.assertNotIn(os.path.join(tmpl_keys['pname'], tmpl_keys['g2name']), groups.keys()) self.assertNotIn(os.path.join(tmpl_keys['pname'], tmpl_keys['r1name']), repos.keys()) self.assertNotIn(os.path.join(tmpl_keys['pname'], tmpl_keys['r2name']), repos.keys()) def test_GET_resources(self): """ Check resources - GET resources works as expected""" cookies = dict(auth_pubtkt=config.USERS[config.USER_1]['auth_cookie']) ret = requests.get("%s/manage/resources/" % config.GATEWAY_URL, cookies=cookies) self.assertIn('resources', ret.json()) def test_GET_missing_resources(self): """ Check resources - GET missing resources works as expected""" token = config.USERS[config.ADMIN_USER]['auth_cookie'] prev = "resources: {}" new = """resources: groups: %(gname)s: description: A test group members: ['*****@*****.**'] """ group_name = create_random_str() data = {'prev': prev, 'new': new % {'gname': group_name}} # Direct PUT resources bypassing the config repo workflow requests.put("%s/manage/resources/" % config.GATEWAY_URL, json=data, cookies={'auth_pubtkt': token}) # Verify managesf detects diff and propose a re-sync resource struct ret = requests.get("%s/manage/resources/?get_missing_" "resources=true" % config.GATEWAY_URL, cookies={'auth_pubtkt': token}) logs, resources = ret.json() self.assertListEqual(logs, []) self.assertIn(group_name, resources['resources']['groups']) # Call the resources.sh script on managesf node to propose # a review on the config repo to re-sync with the reality cmd = [ '/usr/local/bin/resources.sh', 'get_missing_resources', 'submit' ] self.ssh_run_cmd(config.SERVICE_PRIV_KEY_PATH, 'root', config.GATEWAY_HOST, cmd) # Get change id of the submitted review search_string = "Propose missing resources to the config repo" r = requests.get('%s/r/changes/?q=%s' % (config.GATEWAY_URL, search_string)) lastid = 0 for r in json.loads(r.content[4:]): if r['_number'] > lastid: lastid = r['_number'] self.assertEqual(self.gu.wait_for_verify(lastid), 1) # Check flag "sf-resources: skip-apply" in the commit msg change = self.gu.g.get( 'changes/?q=%s&o=CURRENT_REVISION&o=CURRENT_COMMIT' % lastid)[0] revision = change["current_revision"] commit = change['revisions'][revision]["commit"] self.assertEqual(commit["message"].split('\n')[0], 'Propose missing resources to the config repo') self.assertTrue(commit["message"].find('sf-resources: skip-apply') > 0) # Approve the change and wait for the +2 self.gu.submit_change_note(change['id'], "current", "Code-Review", "2") self.gu.submit_change_note(change['id'], "current", "Workflow", "1") # Check config-update return a success # The flag sf-resources: skip-apply should be detected # by the config update. Then missing resources won't # by concidered new and the resources apply will be skipped. # This tests (checking config-update succeed) confirm # resource apply have been skipped if not managesf resources # apply would have return 409 error making config-update failed too. # If not True then we cannot concider config-update succeed config_update_log = self.ju.wait_for_config_update(revision) self.assertIn("Skip resources apply.", config_update_log) self.assertIn("SUCCESS", config_update_log) # Checking again missing resources must return nothing ret = requests.get("%s/manage/resources/?get_missing_" "resources=true" % config.GATEWAY_URL, cookies={'auth_pubtkt': token}) logs, resources = ret.json() self.assertListEqual(logs, []) self.assertEqual(len(resources['resources']), 0)
class TestManageSF(Base): """ Functional tests that validate managesf features. Here we do basic verifications about project creation with managesf. """ @classmethod def setUpClass(cls): cls.msu = ManageSfUtils(config.GATEWAY_URL) @classmethod def tearDownClass(cls): pass def setUp(self): super(TestManageSF, self).setUp() self.projects = [] self.dirs_to_delete = [] self.rm = get_issue_tracker_utils( auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) self.gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) def project_exists_ex(self, name, user): # Test here the project is "public" # ( Redmine API project detail does not return the private/public flag) rm = get_issue_tracker_utils( auth_cookie=config.USERS[user]['auth_cookie']) try: return rm.project_exists(name) except Exception: return False def tearDown(self): super(TestManageSF, self).tearDown() for name in self.projects: self.msu.deleteProject(name, config.ADMIN_USER) for dirs in self.dirs_to_delete: shutil.rmtree(dirs) def create_project(self, name, user, options=None): self.msu.createProject(name, user, options) self.projects.append(name) 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_private_project_as_admin(self): """ Create private project on redmine and gerrit as admin """ 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)) # 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)) 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, 'Manager')) self.assertTrue( self.rm.check_user_role(pname, config.ADMIN_USER, 'Developer')) self.assertFalse(self.project_exists_ex(pname, config.USER_2)) 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_create_public_project_as_user(self): """ Create public project on redmine and gerrit as user """ 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)) # 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.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.assertTrue(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_public_project_as_admin_clone_as_admin(self): """ Clone public project as admin and check content """ pname = 'a_%s' % create_random_str() self.create_project(pname, config.ADMIN_USER) 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) 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'))) # Verify meta/config branch own both group and ACLs config file ggu.fetch_meta_config(clone_dir) self.assertTrue( os.path.isfile(os.path.join(clone_dir, 'project.config'))) self.assertTrue(os.path.isfile(os.path.join(clone_dir, 'groups'))) # There is no group dev for a public project content = file(os.path.join(clone_dir, 'project.config')).read() self.assertFalse('%s-dev' % pname in content) content = file(os.path.join(clone_dir, 'groups')).read() self.assertFalse('%s-dev' % pname in content) def test_create_private_project_as_admin_clone_as_admin(self): """ Clone private project as admin and check content """ pname = 'p_%s' % create_random_str() options = {"private": ""} self.create_project(pname, config.ADMIN_USER, options=options) 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) 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'))) # Verify meta/config branch own both group and ACLs config file ggu.fetch_meta_config(clone_dir) self.assertTrue( os.path.isfile(os.path.join(clone_dir, 'project.config'))) self.assertTrue(os.path.isfile(os.path.join(clone_dir, 'groups'))) # There is a group dev for a private project content = file(os.path.join(clone_dir, 'project.config')).read() self.assertTrue('%s-dev' % pname in content) content = file(os.path.join(clone_dir, 'groups')).read() self.assertTrue('%s-dev' % pname in content) def test_create_public_project_as_admin_clone_as_user(self): """ Create public project as admin then clone as user """ pname = 'p_%s' % create_random_str() # create the project as admin self.create_project(pname, config.ADMIN_USER) # add user2 ssh pubkey to user2 gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.USER_2]['auth_cookie']) gu.add_pubkey(config.USER_2_PUB_KEY) # prepare to clone priv_key_path = set_private_key(config.USER_2_PRIV_KEY) self.dirs_to_delete.append(os.path.dirname(priv_key_path)) ggu = GerritGitUtils(config.USER_2, priv_key_path, config.USERS[config.USER_2]['email']) url = "ssh://%s@%s:29418/%s" % (config.USER_2, config.GATEWAY_HOST, pname) # clone clone_dir = ggu.clone(url, pname) 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'))) def test_create_public_project_as_user_clone_as_user(self): """ Create public project as user then clone as user """ pname = 'p_%s' % create_random_str() # create the project as admin self.create_project(pname, config.USER_2) # add user2 ssh pubkey to user2 gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.USER_2]['auth_cookie']) gu.add_pubkey(config.USER_2_PUB_KEY) # prepare to clone priv_key_path = set_private_key(config.USER_2_PRIV_KEY) self.dirs_to_delete.append(os.path.dirname(priv_key_path)) ggu = GerritGitUtils(config.USER_2, priv_key_path, config.USERS[config.USER_2]['email']) url = "ssh://%s@%s:29418/%s" % (config.USER_2, config.GATEWAY_HOST, pname) # clone clone_dir = ggu.clone(url, pname) 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'))) def test_upstream(self): """ Validate upstream feature of managesf """ # Create a test upstream project pname_us = 'p_upstream' self.create_project(pname_us, config.ADMIN_USER) ggu_us = 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_us) # clone us_clone_dir = ggu_us.clone(url, pname_us) self.dirs_to_delete.append(os.path.dirname(us_clone_dir)) # Test that the clone is a success self.assertTrue(os.path.isdir(us_clone_dir)) # push some test files to the upstream project us_files = [str(x) for x in range(1, 10)] for f in us_files: file(os.path.join(us_clone_dir, f), 'w').write(f) os.chmod(os.path.join(us_clone_dir, f), 0755) ggu_us.add_commit_in_branch(us_clone_dir, "master", commit="Adding files 1-10", files=us_files) ggu_us.direct_push_branch(us_clone_dir, "master") ggu_us.add_commit_in_branch(us_clone_dir, "branch1") ggu_us.direct_push_branch(us_clone_dir, "branch1") # Now create a test project with upstream pointing to the above upstream_url = "ssh://%s@%s:29418/%s" % (config.ADMIN_USER, config.GATEWAY_HOST, pname_us) pname = 'p_%s' % create_random_str() # create the project as admin options = { "upstream": upstream_url, "upstream-ssh-key": config.ADMIN_PRIV_KEY_PATH } self.create_project(pname, config.ADMIN_USER, options=options) 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 clone_dir = ggu.clone(url, pname) # Check if the files pushed in upstream project is present files = [f for f in os.listdir(clone_dir) if not f.startswith('.')] self.assertEqual(set(files), set(us_files)) branches = ggu.get_branches(clone_dir, True) self.assertNotIn('gerrit/branch1', branches) # Test upstream with additional branches pname2 = 'p_%s' % create_random_str() options['add-branches'] = '' self.create_project(pname2, config.ADMIN_USER, options=options) url = "ssh://%s@%s:29418/%s" % (config.ADMIN_USER, config.GATEWAY_HOST, pname2) clone_dir = ggu.clone(url, pname2) branches = ggu.get_branches(clone_dir, True) self.assertIn('gerrit/branch1', branches) self.dirs_to_delete.append(os.path.dirname(clone_dir)) 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_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_list_active_members(self): """ Check the list of members as a list of tuples of emails and names """ active_users = self.msu.list_active_members(config.USER_2) for user in active_users: # Remove the if below once managesf change is merged # I9f994288b9991dda81b98f59357b8ea753e6d200 if "idp_sync" in user.keys(): del user["idp_sync"] # TODO: add idp_sync in bellow key list self.assertEqual( sorted(['username', 'fullname', 'email', 'cauth_id', 'id']), sorted(user.keys()), "Unexpected user %r" % user) self.assertTrue(config.USER_2 in [u['username'] for u in active_users], active_users) def test_register_user(self): active_users = self.msu.list_active_members(config.ADMIN_USER) self.msu.register_user(config.ADMIN_USER, "a", "b") new_a_u = self.msu.list_active_members(config.ADMIN_USER) self.assertEqual( len(active_users) + 1, len(new_a_u), "%i <-> %i" % (len(active_users), len(new_a_u))) self.assertTrue('a' in [u['username'] for u in new_a_u]) self.assertTrue('b' in [u['email'] for u in new_a_u]) self.assertTrue('a' in [u['fullname'] for u in new_a_u]) def test_deregister_user(self): self.msu.register_user(config.ADMIN_USER, "c", "d") self.msu.deregister_user(config.ADMIN_USER, "c") active_users = self.msu.list_active_members(config.ADMIN_USER) self.assertTrue('c' not in [u['username'] for u in active_users]) def test_init_user_tests(self): """ Check if a test init feature behave as expected """ project = 'p_%s' % create_random_str() self.create_project(project, config.USER_4) self.msu.create_init_tests(project, config.USER_4) ggu = GerritGitUtils(config.ADMIN_USER, config.ADMIN_PRIV_KEY_PATH, config.USERS[config.ADMIN_USER]['email']) open_reviews = ggu.list_open_reviews('config', config.GATEWAY_HOST) match = [ True for review in open_reviews if review['commitMessage'].startswith("%s proposes initial test " "definition for project %s" % (config.USER_4, project)) ] self.assertEqual(len(match), 1) open_reviews = ggu.list_open_reviews(project, config.GATEWAY_HOST) match = [ True for review in open_reviews if review['commitMessage'].startswith("%s proposes initial test " "scripts for project %s" % (config.USER_4, project)) ] self.assertEqual(len(match), 1) def test_rest_urls_accessible(self): """ Check if managesf URLs are all working """ project = 'p_%s' % create_random_str() self.create_project(project, config.ADMIN_USER) cookies = dict( auth_pubtkt=config.USERS[config.ADMIN_USER]['auth_cookie']) paths = [ "/manage/project/", "/manage/project/%s" % project, "/manage/project/membership/", "/manage/nodes/" ] for path in paths: url = "https://%s%s" % (config.GATEWAY_HOST, path) resp = requests.get(url, cookies=cookies) self.assertEqual(200, resp.status_code) def test_validate_get_all_project_details(self): """ Check if managesf allow us to fetch projects details """ project = 'p_%s' % create_random_str() self.create_project(project, config.USER_2) admin_cookies = dict( auth_pubtkt=config.USERS[config.ADMIN_USER]['auth_cookie']) user2_cookies = dict( auth_pubtkt=config.USERS[config.USER_2]['auth_cookie']) url = "https://%s%s" % (config.GATEWAY_HOST, "/manage/project/") resp = requests.get(url, cookies=admin_cookies) self.assertEqual(200, resp.status_code) self.assertTrue(project in resp.json()) self.assertTrue('config' in resp.json()) resp = requests.get(url, cookies=user2_cookies) self.assertEqual(200, resp.status_code) self.assertTrue(project in resp.json()) self.assertTrue('config' in resp.json()) resp = requests.get(url, cookies=user2_cookies) # Validate the same behavior with project including a '/' project = 'p/%s' % create_random_str() self.create_project(project, config.USER_2) url = "https://%s%s" % (config.GATEWAY_HOST, "/manage/project/") # Wait 15 seconds for managesf cache invalidation import time time.sleep(15) resp = requests.get(url, cookies=user2_cookies) self.assertEqual(200, resp.status_code) self.assertTrue(project in resp.json()) 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_api_key_auth_with_sfmanager(self): """Test the api key auth workflow""" user2_cookies = dict( auth_pubtkt=config.USERS[config.USER_2]['auth_cookie']) url = "https://%s%s" % (config.GATEWAY_HOST, "/auth/apikey/") create_key = requests.post(url, cookies=user2_cookies) self.assertEqual(201, create_key.status_code) key = create_key.json().get('api_key') # call a simple command that needs authentication cmd = "sfmanager --url %s --auth-server-url " \ "%s --api-key %s sf_user list" % (config.GATEWAY_URL, config.GATEWAY_URL, key) users = self.msu.exe(cmd) self.assertTrue(config.USER_2 in users, "'%s' returned %s" % (cmd, users))