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