本文整理汇总了Python中pysflib.sfgerrit.GerritUtils.project_exists方法的典型用法代码示例。如果您正苦于以下问题:Python GerritUtils.project_exists方法的具体用法?Python GerritUtils.project_exists怎么用?Python GerritUtils.project_exists使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类pysflib.sfgerrit.GerritUtils
的用法示例。
在下文中一共展示了GerritUtils.project_exists方法的13个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Python代码示例。
示例1: _prepare_review_submit_testing
# 需要导入模块: from pysflib.sfgerrit import GerritUtils [as 别名]
# 或者: from pysflib.sfgerrit.GerritUtils import project_exists [as 别名]
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://%[email protected]%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
示例2: test_review_labels
# 需要导入模块: from pysflib.sfgerrit import GerritUtils [as 别名]
# 或者: from pysflib.sfgerrit.GerritUtils import project_exists [as 别名]
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://%[email protected]%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)
示例3: test_check_config_repo_exists
# 需要导入模块: from pysflib.sfgerrit import GerritUtils [as 别名]
# 或者: from pysflib.sfgerrit.GerritUtils import project_exists [as 别名]
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://%[email protected]%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")))
示例4: test_check_download_commands
# 需要导入模块: from pysflib.sfgerrit import GerritUtils [as 别名]
# 或者: from pysflib.sfgerrit.GerritUtils import project_exists [as 别名]
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://%[email protected]%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)
示例5: test_check_config_repo_exists
# 需要导入模块: from pysflib.sfgerrit import GerritUtils [as 别名]
# 或者: from pysflib.sfgerrit.GerritUtils import project_exists [as 别名]
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://%[email protected]%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")))
示例6: TestProjectMembership
# 需要导入模块: from pysflib.sfgerrit import GerritUtils [as 别名]
# 或者: from pysflib.sfgerrit.GerritUtils import project_exists [as 别名]
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
#.........这里部分代码省略.........
示例7: test_check_add_automatic_reviewers
# 需要导入模块: from pysflib.sfgerrit import GerritUtils [as 别名]
# 或者: from pysflib.sfgerrit.GerritUtils import project_exists [as 别名]
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://%[email protected]%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://%[email protected]%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)
示例8: __init__
# 需要导入模块: from pysflib.sfgerrit import GerritUtils [as 别名]
# 或者: from pysflib.sfgerrit.GerritUtils import project_exists [as 别名]
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://%[email protected]%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()
#.........这里部分代码省略.........
示例9: test_check_zuul_operations
# 需要导入模块: from pysflib.sfgerrit import GerritUtils [as 别名]
# 或者: from pysflib.sfgerrit.GerritUtils import project_exists [as 别名]
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://%[email protected]%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
#.........这里部分代码省略.........
示例10: TestManageSF
# 需要导入模块: from pysflib.sfgerrit import GerritUtils [as 别名]
# 或者: from pysflib.sfgerrit.GerritUtils import project_exists [as 别名]
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))
#.........这里部分代码省略.........
示例11: __init__
# 需要导入模块: from pysflib.sfgerrit import GerritUtils [as 别名]
# 或者: from pysflib.sfgerrit.GerritUtils import project_exists [as 别名]
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://%[email protected]%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)
示例12: TestManageSF
# 需要导入模块: from pysflib.sfgerrit import GerritUtils [as 别名]
# 或者: from pysflib.sfgerrit.GerritUtils import project_exists [as 别名]
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()
#.........这里部分代码省略.........
示例13: TestManageSF
# 需要导入模块: from pysflib.sfgerrit import GerritUtils [as 别名]
# 或者: from pysflib.sfgerrit.GerritUtils import project_exists [as 别名]
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
#.........这里部分代码省略.........