class TestGerritHooks(Base):
""" Functional tests that validate Gerrit hooks.
"""
@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.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 tearDown(self):
for issue in self.issues:
self.rm.delete_issue(issue)
for name in self.projects:
self.msu.deleteProject(name, self.u)
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_update_issue_hooks(self, comment_template, status):
""" A referenced issue in commit msg triggers the hook
"""
pname = 'p_%s' % create_random_str()
# Be sure the project does not exist
self.msu.deleteProject(pname, self.u)
# Create the project
self.create_project(pname, self.u)
# Put USER_2 as core for the project
self.gu.add_group_member(self.u2, "%s-core" % pname)
# Create an issue on the project
issue_id = self.rm.create_issue(pname, "There is a problem")
# Clone and commit something
url = "ssh://%s@%s:29418/%s" % (self.u, config.GATEWAY_HOST,
pname)
clone_dir = self.gitu.clone(url, pname)
cmt_msg = comment_template % issue_id
self.gitu.add_commit_and_publish(clone_dir, 'master', cmt_msg)
# Check issue status (Gerrit hook updates the issue to in progress)
attempt = 0
while True:
if self.rm.test_issue_status(issue_id, 'In Progress'):
break
if attempt > 10:
break
time.sleep(1)
attempt += 1
self.assertTrue(self.rm.test_issue_status(issue_id, 'In Progress'))
self._test_merging(pname, issue_id, status)
def _test_merging(self, pname, issue_id, status):
# Get the change id and merge the patch
change_ids = self.gu.get_my_changes_for_project(pname)
self.assertGreater(len(change_ids), 0)
change_id = change_ids[0]
self.gu.submit_change_note(change_id, "current", "Code-Review", "2")
self.gu.submit_change_note(change_id, "current", "Workflow", "1")
self.gu.submit_change_note(change_id, "current", "Verified", "2")
self.gu2.submit_change_note(change_id, "current", "Code-Review", "2")
self.assertTrue(self.gu.submit_patch(change_id, "current"))
# Check issue status (Gerrit hook updates the issue to in progress)
attempt = 0
while True:
if self.rm.test_issue_status(issue_id, status):
break
if attempt > 10:
break
time.sleep(1)
attempt += 1
self.assertTrue(self.rm.test_issue_status(issue_id, status))
def test_gerrit_hook(self):
"""test various commit messages triggering a hook"""
for template, final_status in TEST_MSGS:
self._test_update_issue_hooks(template, final_status)
class SFProvisioner(object):
""" This provider is only intended for testing
SF backup/restore and update. It provisions some
user datas in a SF installation based on a resourses.yaml
file. Later those data can be checked by its friend
the SFChecker.
Provisioned data should remain really simple.
"""
def __init__(self):
with open('resources.yaml', '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.msu = ManageSfUtils(config.GATEWAY_URL)
self.ggu = GerritGitUtils(config.ADMIN_USER,
config.ADMIN_PRIV_KEY_PATH,
config.USERS[config.ADMIN_USER]['email'])
self.ju = JenkinsUtils()
self.rm = RedmineUtils(
config.REDMINE_URL,
auth_cookie=config.USERS[config.ADMIN_USER]['auth_cookie'])
def create_project(self, name):
print " Creating project %s ..." % name
self.msu.createProject(name, config.ADMIN_USER)
def push_files_in_project(self, name, files):
print " Add files(%s) in a commit ..." % ",".join(files)
# TODO(fbo); use gateway host instead of gerrit host
self.url = "ssh://%s@%s:29418/%s" % (config.ADMIN_USER,
config.GATEWAY_HOST, name)
clone_dir = self.ggu.clone(self.url, name, config_review=False)
self.clone_dir = clone_dir
for f in files:
file(os.path.join(clone_dir, f), 'w').write('data')
self.ggu.git_add(clone_dir, (f,))
self.ggu.add_commit_for_all_new_additions(clone_dir)
self.ggu.direct_push_branch(clone_dir, 'master')
def create_issues_on_project(self, name, issues):
print " Create %s issue(s) for that project ..." % len(issues)
for i in issues:
issue = self.rm.create_issue(name, i['name'])
yield issue, i['review']
def create_jenkins_jobs(self, name, jobnames):
print " Create Jenkins jobs(%s) ..." % ",".join(jobnames)
for jobname in jobnames:
self.ju.create_job("%s_%s" % (name, jobname))
def create_pads(self, amount):
# TODO
pass
def create_pasties(self, amount):
# TODO
pass
def create_review(self, project, issue):
"""Very basic review creator for statistics and restore tests
purposes."""
self.ggu.config_review(self.clone_dir)
self.ggu.add_commit_in_branch(self.clone_dir,
'branch_' + issue,
commit='test\n\nBug: %s' % issue)
self.ggu.review_push_branch(self.clone_dir, 'branch_' + issue)
def provision(self):
for project in self.resources['projects']:
print "Create user datas for %s" % project['name']
self.create_project(project['name'])
self.push_files_in_project(project['name'],
[f['name'] for f in project['files']])
for i, review in self.create_issues_on_project(project['name'],
project['issues']):
if review:
print "Create review for bug %i in %s" % (i,
project['name'])
self.create_review(project['name'], str(i))
self.create_jenkins_jobs(project['name'],
[j['name'] for j in project['jobnames']])
self.create_pads(2)
self.create_pasties(2)
class SFProvisioner(object):
""" This provider is only intended for testing
SF backup/restore and update. It provisions some
user datas in a SF installation based on a resourses.yaml
file. Later those data can be checked by its friend
the SFChecker.
Provisioned data should remain really simple.
"""
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.msu = ManageSfUtils(config.GATEWAY_URL)
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 create_project(self, name):
print " Creating project %s ..." % name
self.msu.createProject(name, config.ADMIN_USER)
def push_files_in_project(self, name, files):
print " Add files(%s) in a commit ..." % ",".join(files)
# TODO(fbo); use gateway host instead of gerrit host
self.url = "ssh://%s@%s:29418/%s" % (config.ADMIN_USER,
config.GATEWAY_HOST, name)
clone_dir = self.ggu.clone(self.url, name, config_review=False)
self.clone_dir = clone_dir
for f in files:
file(os.path.join(clone_dir, f), 'w').write('data')
self.ggu.git_add(clone_dir, (f, ))
self.ggu.add_commit_for_all_new_additions(clone_dir)
self.ggu.direct_push_branch(clone_dir, 'master')
def create_issues_on_project(self, name, issues):
print " Create %s issue(s) for that project ..." % len(issues)
for i in issues:
issue = self.rm.create_issue(name, i['name'])
yield issue, i['review']
def create_jenkins_jobs(self, name, jobnames):
print " Create Jenkins jobs(%s) ..." % ",".join(jobnames)
for jobname in jobnames:
self.ju.create_job("%s_%s" % (name, jobname))
def create_pads(self, amount):
# TODO
pass
def create_pasties(self, amount):
# TODO
pass
def create_review(self, project, issue):
"""Very basic review creator for statistics and restore tests
purposes."""
self.ggu.config_review(self.clone_dir)
self.ggu.add_commit_in_branch(self.clone_dir,
'branch_' + issue,
commit='test\n\nBug: %s' % issue)
self.ggu.review_push_branch(self.clone_dir, 'branch_' + issue)
def provision(self):
for project in self.resources['projects']:
print "Create user datas for %s" % project['name']
self.create_project(project['name'])
self.push_files_in_project(project['name'],
[f['name'] for f in project['files']])
for i, review in self.create_issues_on_project(
project['name'], project['issues']):
if review:
print "Create review for bug %i in %s" % (i,
project['name'])
self.create_review(project['name'], str(i))
self.create_jenkins_jobs(project['name'],
[j['name'] for j in project['jobnames']])
self.create_pads(2)
self.create_pasties(2)
class TestGerritHooks(Base):
""" Functional tests that validate Gerrit hooks.
"""
@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.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 tearDown(self):
for issue in self.issues:
self.rm.delete_issue(issue)
for name in self.projects:
self.msu.deleteProject(name, self.u)
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_update_issue_hooks(self, comment_template, status):
""" A referenced issue in commit msg triggers the hook
"""
pname = 'p_%s' % create_random_str()
# Be sure the project does not exist
self.msu.deleteProject(pname, self.u)
# Create the project
self.create_project(pname, self.u)
# Put USER_2 as core for the project
self.gu.add_group_member(self.u2, "%s-core" % pname)
# Create an issue on the project
issue_id = self.rm.create_issue(pname, "There is a problem")
# Clone and commit something
url = "ssh://%s@%s:29418/%s" % (self.u, config.GATEWAY_HOST, pname)
clone_dir = self.gitu.clone(url, pname)
cmt_msg = comment_template % issue_id
self.gitu.add_commit_and_publish(clone_dir, 'master', cmt_msg)
# Check issue status (Gerrit hook updates the issue to in progress)
attempt = 0
while True:
if self.rm.test_issue_status(issue_id, 'In Progress'):
break
if attempt > 10:
break
time.sleep(1)
attempt += 1
self.assertTrue(self.rm.test_issue_status(issue_id, 'In Progress'))
self._test_merging(pname, issue_id, status)
def _test_merging(self, pname, issue_id, status):
# Get the change id and merge the patch
change_ids = self.gu.get_my_changes_for_project(pname)
self.assertGreater(len(change_ids), 0)
change_id = change_ids[0]
self.gu.submit_change_note(change_id, "current", "Code-Review", "2")
self.gu.submit_change_note(change_id, "current", "Workflow", "1")
self.gu.submit_change_note(change_id, "current", "Verified", "2")
self.gu2.submit_change_note(change_id, "current", "Code-Review", "2")
self.assertTrue(self.gu.submit_patch(change_id, "current"))
# Check issue status (Gerrit hook updates the issue to in progress)
attempt = 0
while True:
if self.rm.test_issue_status(issue_id, status):
break
if attempt > 10:
break
time.sleep(1)
attempt += 1
self.assertTrue(self.rm.test_issue_status(issue_id, status))
def test_gerrit_hook(self):
"""test various commit messages triggering a hook"""
for template, final_status in TEST_MSGS:
self._test_update_issue_hooks(template, final_status)
class SFProvisioner(object):
""" This provider is only intended for testing
SF backup/restore and update. It provisions some
user datas in a SF installation based on a resourses.yaml
file. Later those data can be checked by its friend
the SFChecker.
Provisioned data should remain really simple.
"""
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.msu = ManageSfUtils(config.GATEWAY_URL)
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 create_project(self, name):
print " Creating project %s ..." % name
self.msu.createProject(name, config.ADMIN_USER)
def push_files_in_project(self, name, files):
print " Add files(%s) in a commit ..." % ",".join(files)
# TODO(fbo); use gateway host instead of gerrit host
self.url = "ssh://%s@%s:29418/%s" % (config.ADMIN_USER,
config.GATEWAY_HOST, name)
clone_dir = self.ggu.clone(self.url, name, config_review=False)
self.clone_dir = clone_dir
for f in files:
file(os.path.join(clone_dir, f), 'w').write('data')
self.ggu.git_add(clone_dir, (f,))
self.ggu.add_commit_for_all_new_additions(clone_dir)
self.ggu.direct_push_branch(clone_dir, 'master')
def create_issues_on_project(self, name, issues):
print " Create %s issue(s) for that project ..." % len(issues)
for i in issues:
if is_present('SFRedmine'):
issue = self.rm.create_issue(name, i['name'])
else:
issue = random.randint(1,100)
yield issue, i['review']
def create_jenkins_jobs(self, name, jobnames):
print " Create Jenkins jobs(%s) ..." % ",".join(jobnames)
for jobname in jobnames:
self.ju.create_job("%s_%s" % (name, jobname))
def create_pads(self, amount):
# TODO
pass
def create_pasties(self, amount):
# TODO
pass
def simple_login(self, user):
"""log as user to make the user listable"""
get_cookie(user, config.USERS[user]['password'])
def create_review(self, project, issue):
"""Very basic review creator for statistics and restore tests
purposes."""
self.ggu.config_review(self.clone_dir)
self.ggu.add_commit_in_branch(self.clone_dir,
'branch_' + issue,
commit='test\n\nBug: %s' % issue)
self.ggu.review_push_branch(self.clone_dir, 'branch_' + issue)
def create_local_user(self, username, password, email):
self.msu.create_user(username, password, email)
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 provision(self):
for cmd in self.resources['commands']:
print "Execute command %s" % cmd['cmd']
print self.command(cmd['cmd'])
checksum_list = {}
for checksum in self.resources['checksum'] :
print "Compute checksum for file %s" % checksum['file']
checksum_list[checksum['file']] = self.compute_checksum(
checksum['file'])
yaml.dump(checksum_list, file('/tmp/pc_checksums.yaml', 'w'))
for user in self.resources['local_users']:
print "Create local user %s" % user['username']
self.create_local_user(user['username'],
user['password'],
user['email'])
for u in self.resources['users']:
print "log in as %s" % u['name']
self.simple_login(u['name'])
for project in self.resources['projects']:
print "Create user datas for %s" % project['name']
self.create_project(project['name'])
self.push_files_in_project(project['name'],
[f['name'] for f in project['files']])
for i, review in self.create_issues_on_project(project['name'],
project['issues']):
if review:
print "Create review for bug %i in %s" % (i,
project['name'])
self.create_review(project['name'], str(i))
self.create_jenkins_jobs(project['name'],
[j['name'] for j in project['jobnames']])
self.create_pads(2)
self.create_pasties(2)