def get_client(self, cookie=None): if not cookie: try: basic = HTTPBasicAuth(self.conf['admin_user'], 'password') msg = '[%s] using direct basic auth to connect to gerrit' logger.debug(msg % self.service_name) g = GerritUtils(self.conf['url'] + 'api', auth=basic) return g except Exception as e: # if we can't get the admin credentials from the config, # let's not panic msg = ('[%s] simple auth raised error: %s, ' 'going with SF cauth-based authentication') logger.debug(msg % (self.service_name, e)) # Use an admin cookie if int(time.time()) - globals()['ADMIN_COOKIE_DATE'] > \ globals()['COOKIE_VALIDITY']: cookie = get_cookie(self._full_conf.auth['host'], self._full_conf.admin['name'], self._full_conf.admin['http_password']) globals()['ADMIN_COOKIE'] = cookie globals()['ADMIN_COOKIE_DATE'] = int(time.time()) else: cookie = globals()['ADMIN_COOKIE'] return GerritUtils(self.conf['url'], auth_cookie=cookie)
def setUp(self): super(TestProjectTestsWorkflow, self).setUp() self.projects = [] self.dirs_to_delete = [] self.un = config.ADMIN_USER self.gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[self.un]['auth_cookie']) self.gu2 = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.USER_2]['auth_cookie']) self.ju = JenkinsUtils() self.gu.add_pubkey(config.USERS[self.un]["pubkey"]) priv_key_path = set_private_key(config.USERS[self.un]["privkey"]) self.gitu_admin = GerritGitUtils(self.un, priv_key_path, config.USERS[self.un]['email']) # Clone the config repo and keep job/zuul config content self.config_clone_dir = self.clone_as_admin("config") self.original_zuul_projects = file(os.path.join( self.config_clone_dir, "zuul/projects.yaml")).read() self.original_project = file(os.path.join( self.config_clone_dir, "jobs/projects.yaml")).read() self.need_restore_config_repo = False # Put USER_2 as core for config project self.gu.add_group_member(config.USER_2, "config-core")
def setUp(self): self.projects = [] self.dirs_to_delete = [] self.un = config.ADMIN_USER self.gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[self.un]['auth_cookie']) self.gu2 = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.USER_2]['auth_cookie']) self.ju = JenkinsUtils() self.gu.add_pubkey(config.USERS[self.un]["pubkey"]) priv_key_path = set_private_key(config.USERS[self.un]["privkey"]) self.gitu_admin = GerritGitUtils(self.un, priv_key_path, config.USERS[self.un]['email']) # Clone the config repo and make change to it # in order to test the new sample_project self.config_clone_dir = self.clone_as_admin("config") self.original_layout = file(os.path.join( self.config_clone_dir, "zuul/layout.yaml")).read() self.original_zuul_projects = file(os.path.join( self.config_clone_dir, "zuul/projects.yaml")).read() self.original_project = file(os.path.join( self.config_clone_dir, "jobs/projects.yaml")).read() # Put USER_2 as core for config project self.gu.add_group_member(config.USER_2, "config-core")
def setUp(self): self.msu = ManageSfUtils(config.GATEWAY_URL) self.un = config.ADMIN_USER self.gu = GerritUtils(config.GATEWAY_URL, auth_cookie=config.USERS[self.un]['auth_cookie']) self.gu2 = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.USER_2]['auth_cookie']) self.k_idx = self.gu2.add_pubkey(config.USERS[config.USER_2]["pubkey"]) priv_key_path = set_private_key(config.USERS[self.un]["privkey"]) self.gitu_admin = GerritGitUtils(self.un, priv_key_path, config.USERS[self.un]['email']) # Configuration to access mirror repo present in managesf self.managesf_repo_path = "ssh://%s@%s/home/gerrit/git/" % ( config.GERRIT_USER, config.GATEWAY_HOST) # prepare environment for git clone on mirror repo self.mt = Tool() self.mt_tempdir = tempfile.mkdtemp() priv_key = file(config.GERRIT_SERVICE_PRIV_KEY_PATH, 'r').read() priv_key_path = os.path.join(self.mt_tempdir, 'user.priv') file(priv_key_path, 'w').write(priv_key) os.chmod(priv_key_path, stat.S_IREAD | stat.S_IWRITE) ssh_wrapper = "ssh -o StrictHostKeyChecking=no -i %s \"$@\"" % ( priv_key_path) wrapper_path = os.path.join(self.mt_tempdir, 'ssh_wrapper.sh') file(wrapper_path, 'w').write(ssh_wrapper) os.chmod(wrapper_path, stat.S_IRWXU) self.mt.env['GIT_SSH'] = wrapper_path self.pname = 'test-replication'
def setUpClass(cls): cls.msu = ManageSfUtils(config.GATEWAY_URL) cls.rm = get_issue_tracker_utils( auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) cls.gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie'])
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_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 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 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 setUp(self): self.projects = [] self.dirs_to_delete = [] self.issues = [] self.u = config.ADMIN_USER self.u2 = config.USER_2 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[self.u]['auth_cookie']) self.gu2 = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[self.u2]['auth_cookie']) self.gu.add_pubkey(config.USERS[self.u]["pubkey"]) priv_key_path = set_private_key(config.USERS[self.u]["privkey"]) self.gitu = GerritGitUtils(self.u, priv_key_path, config.USERS[self.u]['email'])
def setUp(self): super(TestManageSF, self).setUp() self.projects = [] self.dirs_to_delete = [] self.ru = ResourcesUtils() self.msu = ManageSfUtils(config.GATEWAY_URL) self.gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie'])
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 test_plugins_installed(self): """ Test if plugins are present """ gu = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie']) plugins = gu.list_plugins() self.assertIn('download-commands', plugins) self.assertIn('avatars-gravatar', plugins) self.assertIn('reviewers-by-blame', plugins)
def setUp(self): super(TestProjectReplication, self).setUp() self.ru = ResourcesUtils() self.un = config.ADMIN_USER self.ju = JenkinsUtils() self.gu = GerritUtils(config.GATEWAY_URL, auth_cookie=config.USERS[self.un]['auth_cookie']) self.gu2 = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.USER_2]['auth_cookie']) self.k_idx = self.gu2.add_pubkey(config.USERS[config.USER_2]["pubkey"]) priv_key_path = set_private_key(config.USERS[self.un]["privkey"]) self.gitu_admin = GerritGitUtils(self.un, priv_key_path, config.USERS[self.un]['email']) # Prepare environment for git clone on mirror repo self.mt = Tool() self.mt_tempdir = tempfile.mkdtemp() # Copy the service private key in a flat file priv_key = file(config.SERVICE_PRIV_KEY_PATH, 'r').read() priv_key_path = os.path.join(self.mt_tempdir, 'user.priv') file(priv_key_path, 'w').write(priv_key) os.chmod(priv_key_path, stat.S_IREAD | stat.S_IWRITE) # Prepare the ssh wrapper script ssh_wrapper = "ssh -o StrictHostKeyChecking=no -i %s \"$@\"" % ( priv_key_path) wrapper_path = os.path.join(self.mt_tempdir, 'ssh_wrapper.sh') file(wrapper_path, 'w').write(ssh_wrapper) os.chmod(wrapper_path, stat.S_IRWXU) # Set the wrapper as GIT_SSH env variable self.mt.env['GIT_SSH'] = wrapper_path self.config_clone_dir = None # Project we are going to configure the replication for self.pname = 'test/replication' # Remove artifacts of previous run if any self.delete_config_section(self.un, self.pname) self.delete_mirror_repo(self.pname)
def test_gerrit_api_accessible(self): """ Test if Gerrit API is accessible on gateway hosts """ m = ManageSfUtils(config.GATEWAY_URL) url = config.GATEWAY_URL + "/api/" a = GerritUtils(url) a.g.url = "%s/" % a.g.url.rstrip('a/') self.assertRaises(HTTPError, a.get_account, config.USER_1) api_passwd = m.create_gerrit_api_password(config.USER_1) auth = HTTPBasicAuth(config.USER_1, api_passwd) a = GerritUtils(url, auth=auth) self.assertTrue(a.get_account(config.USER_1)) m.delete_gerrit_api_password(config.USER_1) a = GerritUtils(url, auth=auth) self.assertRaises(HTTPError, a.get_account, config.USER_1) a = GerritUtils(url) a.g.url = "%s/" % a.g.url.rstrip('a/') self.assertRaises(HTTPError, a.get_account, 'john')
def setUp(self): super(TestRepoxplorer, 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 __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.stb_client = SFStoryboard( config.GATEWAY_URL + "/storyboard_api", config.USERS[config.ADMIN_USER]['auth_cookie'])
def setUp(self): super(TestGerritHooks, self).setUp() self.projects = [] self.dirs_to_delete = [] self.issues = [] self.u = config.ADMIN_USER 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[self.u]['auth_cookie']) self.gu.add_pubkey(config.USERS[self.u]["pubkey"]) priv_key_path = set_private_key(config.USERS[self.u]["privkey"]) self.gitu = GerritGitUtils(self.u, priv_key_path, config.USERS[self.u]['email'])
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 test_check_add_automatic_reviewers(self): """ Test if reviewers-by-blame plugin works """ data = "this\nis\na\ncouple\nof\nlines" change_id, gu, k1_index, pname = self._prepare_review_submit_testing( ('file', data)) # Merge the change gu.submit_change_note(change_id, "current", "Code-Review", "2") gu.submit_change_note(change_id, "current", "Verified", "2") gu.submit_change_note(change_id, "current", "Workflow", "1") self.assertTrue(gu.submit_patch(change_id, "current")) gu2 = GerritUtils( config.GATEWAY_URL, auth_cookie=config.USERS[config.USER_2]['auth_cookie']) # Change the file we have commited with Admin user k2_index = gu2.add_pubkey(config.USERS[config.USER_2]["pubkey"]) priv_key_path = set_private_key(config.USERS[config.USER_2]["privkey"]) gitu2 = 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_dir = gitu2.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)) gitu2.add_commit_and_publish(clone_dir, "master", "Test commit", fnames=["file"]) # Get the change id change_ids = gu2.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 for retry in xrange(3): if len(gu2.get_reviewers(change_id)) > 0: break time.sleep(1) reviewers = gu2.get_reviewers(change_id) self.assertEqual(len(reviewers), 1) self.assertEqual(reviewers[0], config.ADMIN_USER) gu.del_pubkey(k1_index) gu2.del_pubkey(k2_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 _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_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)
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)