def test_package_request_new(self, login_func, mock_func):
""" Test the package_request_new function. """
login_func.return_value = None
mock_func.return_value = ['pingou', 'toshio']
create_package_acl(self.session)
data = {
'pkgname': 'gnome-terminal',
'summary': 'terminal for GNOME',
'description': 'desc',
'review_url': 'https://bz.rh.c/123',
'status': 'Approved',
'critpath': False,
'poc': 'pingou',
'upstream_url': 'http://gnome.org',
'branches': 'master',
'namespace': 'rpms',
}
user = FakeFasUser()
user.username = '******'
data['branches'] = 'epel7'
with user_set(pkgdb2.APP, user):
# Branch EPEL7 does not exist
output = self.app.post(
'/request/package/', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td class="errors">'epel7' is not a valid choice'
in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data['csrf_token'] = csrf_token
data['branches'] = 'master'
# All good
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/request/package/',
follow_redirects=True, data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">user: pingou request package: '
'gnome-terminal on branch master</li>' in output.data)
def test_comaintain_package(self, login_func):
""" Test the comaintain_package function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get(
'/acl/guake/comaintain/', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">You are already a co-maintainer on '
'F-18</li>' in output.data)
self.assertFalse(
'<li class="message">ACLs updated</li>' in output.data)
output = self.app.get(
'/acl/random/comaintain/', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>'
in output.data)
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get(
'/acl/guake/comaintain/', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">ACLs updated</li>' in output.data)
output = self.app.get(
'/acl/random/comaintain/', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>'
in output.data)
user = FakeFasUser()
user.groups = ['gitr2spec']
with user_set(pkgdb2.APP, user):
output = self.app.get(
'/acl/guake/comaintain/', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">You must be a packager</li>'
in output.data)
def test_comaintain_package(self, login_func):
""" Test the comaintain_package function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/guake/comaintain/',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">You are already a co-maintainer on '
'F-18</li>' in output.data)
self.assertFalse(
'<li class="message">ACLs updated</li>' in output.data)
output = self.app.get('/acl/random/comaintain/',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>' in
output.data)
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/guake/comaintain/',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">ACLs updated</li>' in output.data)
output = self.app.get('/acl/random/comaintain/',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>' in
output.data)
user = FakeFasUser()
user.groups = ['gitr2spec']
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/guake/comaintain/',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<li class="errors">You must be a packager</li>' in
output.data)
def test_package_orphan(self, login_func, mock_func):
""" Test the package_orphan function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/devel/orphan',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">You are not allowed to change the point '
'of contact.</li>' in output.data)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/devel/orphan',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: devel</li>' in output.data)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/devel/orphan',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: devel</li>' in output.data)
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/random/devel/orphan',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>' in
output.data)
def test_package_orphan(self, login_func, mock_func):
""" Test the package_orphan function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get(
'/package/guake/devel/orphan', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">You are not allowed to change the point '
'of contact.</li>' in output.data)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get(
'/package/guake/devel/orphan', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: devel</li>' in output.data)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get(
'/package/guake/devel/orphan', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: devel</li>' in output.data)
with user_set(pkgdb2.APP, user):
output = self.app.get(
'/package/random/devel/orphan', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>'
in output.data)
def test_package_unretire(self, login_func, utils_module):
""" Test the package_unretire function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/orphan')
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
# Oprhan and retire guake on F18
data = {
'branches': ['f18'],
'csrf_token': csrf_token,
}
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/orphan',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: f18</li>' in output.data)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/retire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">This package has been retired on '
'branch: f18</li>' in output.data)
# Start testing unretire
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/random/unretire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>' in
output.data)
output = self.app.post('/package/random/unretire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>' in
output.data)
output = self.app.post('/package/guake/unretire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">User "admin" is not in the '
'packager group</li>' in output.data)
utils_module.get_packagers.return_value = ['pingou', 'toshio']
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/unretire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td><select id="branches" multiple name="branches">'
'<option value="f18">f18</option></select></td>' in
output.data)
output = self.app.post('/package/guake/unretire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Admins have been asked to un-retire '
'branch: f18</li>' in output.data)
output = self.app.post('/package/guake/unretire/0',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">Could not save the request for branch: '
'f18, has it already been requested?</li>' in output.data)
def test_package_orphan(self, login_func, utils_module):
""" Test the package_orphan function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/orphan')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<title> Select branches | PkgDB </title>' in output.data)
output = self.app.get('/package/guake/orphan/0')
self.assertEqual(output.status_code, 200)
self.assertFalse(
'<title> Select branches | PkgDB </title>' in output.data)
output = self.app.post('/package/guake/orphan',
follow_redirects=True,
data={'branches': ['master']})
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="errors">'master' is not a valid choice for '
'this field</td>' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': ['master'],
'csrf_token': csrf_token,
}
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/orphan',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: master</li>' in output.data)
# You cannot orphan twice the same package, the branch is no
# longer available
output = self.app.post('/package/guake/orphan',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td class="errors">'master' is not a valid choice '
'for this field</td>' in output.data)
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/random/orphan',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>' in
output.data)
def test_package_give_acls(self, login_func, mock_func):
""" Test the package_give_acls function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
mock_func.return_value = ['pingou', 'ralph', 'kevin']
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/guake/give/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Give ACLs on package: guake</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
self.assertTrue(
'<option value="approveacls">approveacls' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'acl': 'watchbugzilla',
'user': '******',
'acl_status': 'Approved',
'csrf_token': csrf_token,
}
output = self.app.post('/acl/guake/give/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<li class="message">ACLs updated</li>' in
output.data)
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/foo/give/', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>'
in output.data)
self.assertTrue('<h1>Search packages</h1>' in output.data)
output = self.app.get('/acl/guake/give/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Give ACLs on package: guake</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
self.assertTrue(
'<option value="approveacls">approveacls' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'acl': 'commit',
'user': '******',
'acl_status': 'Approved',
'csrf_token': csrf_token,
}
output = self.app.post('/acl/guake/give/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="error">You are not allowed to update ACLs of someone '
'else.</li>' in output.data)
def test_update_acl(self, login_func, mock_func):
""" Test the update_acl function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
mock_func.return_value = ['pingou', 'ralph', 'kevin']
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get(
'/package/guake/acl/commit/', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertEqual(
output.data.count('<td class="users">'), 1)
# Fails `toshio` is not a packager
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get(
'/package/guake/acl/commit/', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'</a> > Edit Commit Access</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
self.assertTrue(
'<option value="Approved">Approved' in output.data)
self.assertEqual(
output.data.count('class="username">'), 1)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branch': 'master',
'acls': '',
'user': '******',
'csrf_token': csrf_token,
}
output = self.app.post(
'/package/guake/acl/commit/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">User "toshio" is not in the '
'packager group</li>' in output.data)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
# Invalid package name
output = self.app.get(
'/package/foobar/acl/commit/', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>'
in output.data)
# Invalid ACL name
output = self.app.get(
'/package/guake/acl/foobar/', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">Invalid ACL to update.</li>'
in output.data)
# GET works
output = self.app.get(
'/package/guake/acl/commit/', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'</a> > Edit Commit Access</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
self.assertTrue(
'<option value="Approved">Approved' in output.data)
self.assertEqual(
output.data.count('class="username">'), 2)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'acl': 'commit',
'acl_status': 'Approved',
'csrf_token': csrf_token,
}
# No user provided, so we don't know for who to update the ACLs
output = self.app.post(
'/package/guake/acl/commit/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">Invalid input submitted</li>'
in output.data)
mock_func.return_value = ['pingou', 'ralph', 'toshio']
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
# Get works
output = self.app.get(
'/package/guake/acl/commit/', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'</a> > Edit Commit Access</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
self.assertTrue(
'<option value="Approved">Approved' in output.data)
self.assertEqual(
output.data.count('class="username">'), 1)
# Only 2 approved ACLs
output = self.app.get(
'/package/guake/', follow_redirects=True)
self.assertEqual(output.data.count('title="ACL Approved"'), 2)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branch': 'master',
'acls': '',
'user': '******',
'csrf_token': csrf_token,
}
# Toshio drops his ACL request on master
output = self.app.post(
'/package/guake/acl/commit/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">toshio's commit ACL updated on '
'master</li>' in output.data)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
data = {
'branch': 'master',
'acls': 'foobar',
'user': '******',
'csrf_token': csrf_token,
}
# Invalid ACL status provided
output = self.app.post(
'/package/guake/acl/commit/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">Invalid ACL: foobar</li>' in output.data)
data = {
'branch': 'master',
'acls': 'Awaiting Review',
'user': '******',
'csrf_token': csrf_token,
}
# Toshio is no longer requesting, thus is not in the list of
# users and thus makes the request invalid
output = self.app.post(
'/package/guake/acl/commit/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h4>Package Administrator(s)</h4>' in output.data)
self.assertTrue(
'<li class="error">Invalid user: toshio</li>' in output.data)
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
# Toshio asks for commit on master
data = {
'branch': 'master',
'acls': 'Awaiting Review',
'user': '******',
'csrf_token': csrf_token,
}
output = self.app.post(
'/package/guake/acl/commit/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">toshio's commit ACL updated on '
'master</li>' in output.data)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
# Invalid branch
data = {
'branch': 'foo',
'acls': '',
'user': '******',
'csrf_token': csrf_token,
}
output = self.app.post(
'/package/guake/acl/commit/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Nothing to update' in output.data)
# Nothing to change
data = {
'branch': 'master',
'acls': 'Awaiting Review',
'user': '******',
'csrf_token': csrf_token,
}
output = self.app.post(
'/package/guake/acl/commit/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Nothing to update' in output.data)
# Nothing to change (2)
data = {
'branch': 'f18',
'acls': '',
'user': '******',
'csrf_token': csrf_token,
}
output = self.app.post(
'/package/guake/acl/commit/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Nothing to update' in output.data)
# package admin cannot remove the user's ACL
data = {
'branch': 'master',
'acls': '',
'user': '******',
'csrf_token': csrf_token,
}
output = self.app.post(
'/package/guake/acl/commit/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">Only the user can remove his/her '
'ACL</li>' in output.data)
# package admin grants commit to Toshio on master
data = {
'branch': 'master',
'acls': 'Approved',
'user': '******',
'csrf_token': csrf_token,
}
output = self.app.post(
'/package/guake/acl/commit/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">toshio's commit ACL updated on '
'master</li>' in output.data)
# One more approved ACL
self.assertTrue(output.data.count('title="ACL Approved"'), 3)
def test_upload_results_loggedin(self):
''' Test the app.upload_results function. '''
folder = os.path.dirname(os.path.abspath(__file__))
filename = '1.log'
full_path = os.path.join(folder, filename)
user = FakeFasUser()
with user_set(app.APP, user):
output = self.app.get('/upload/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td><input id="test_result" name="test_result" '
'type="file"></td>' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
# Valid upload via the UI
stream = open(full_path)
data = {
'test_result': stream,
'username': '******',
'csrf_token': csrf_token,
}
output = self.app.post('/upload/', data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Upload successful!</li>' in output.data)
# Valid upload authenticated and via the anonymous API
stream = open(full_path)
data = {
'test_result': stream,
'username': '******',
}
output = self.app.post('/upload/anonymous', data=data)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(data, {'message': 'Upload successful!'})
# Invalid file upload
full_path = os.path.join(folder, 'invalid.log')
stream = open(full_path)
data = {
'test_result': stream,
'username': '******',
'csrf_token': csrf_token,
}
output = self.app.post('/upload/', data=data)
self.assertEqual(output.status_code, 302)
# Invalid file upload
full_path = os.path.join(folder, 'invalid.log')
stream = open(full_path)
data = {
'test_result': stream,
'username': '******',
'csrf_token': csrf_token,
}
output = self.app.post('/upload/', data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Could not parse these results</li>'
in output.data)
# Invalid username
user = FakeFasUser()
user.username = '******'
with user_set(app.APP, user):
full_path = os.path.join(folder, 'invalid.log')
stream = open(full_path)
data = {
'test_result': stream,
'username': '******',
'csrf_token': csrf_token,
}
output = self.app.post('/upload/', data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">The `kerneltest` username is reserved, '
'you are not allowed to use it</li>' in output.data)
def test_comaintain_package(self, bz_mail_func, login_func, mock_func):
""" Test the comaintain_package function. """
login_func.return_value = None
bz_mail_func.return_value = 1
create_package_acl(self.session)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/rpms/guake/comaintain/',
follow_redirects=True)
self.assertEqual(output.status_code, 405)
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/rpms/guake/')
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {'csrf_token': csrf_token}
output = self.app.post('/acl/rpms/guake/comaintain/',
data=data,
follow_redirects=True)
self.assertTrue(
'<li class="error">You are already a co-maintainer on '
'f18</li>' in output.data)
self.assertFalse(
'<li class="message">ACLs updated</li>' in output.data)
output = self.app.post('/acl/rpms/random/comaintain/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>' in
output.data)
user = FakeFasUser()
mock_func.return_value = ['pingou', 'ralph', 'kevin']
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post('/acl/rpms/guake/comaintain/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">ACLs updated</li>' in output.data)
# Nothing to update the second time
output = self.app.post('/acl/rpms/guake/comaintain/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Nothing to update</li>' in output.data)
output = self.app.post('/acl/rpms/random/comaintain/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>' in
output.data)
user = FakeFasUser()
user.groups = ['gitr2spec']
with user_set(pkgdb2.APP, user):
output = self.app.post('/acl/rpms/guake/comaintain/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<li class="errors">You must be a packager</li>' in
output.data)
def test_acl_update(self, bz_mail_func, login_func, pkger_func):
""" Test the api_acl_update function. """
login_func.return_value = None
bz_mail_func.return_value = 1
output = self.app.post('/api/package/acl')
self.assertEqual(output.status_code, 301)
user = FakeFasUser()
with user_set(APP, user):
output = self.app.post('/api/package/acl/')
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(sorted(data), ['error', 'error_detail', 'output'])
self.assertEqual(data['error'], "Invalid input submitted")
self.assertEqual(data['output'], "notok")
self.assertEqual(sorted(data['error_detail']), [
"acl: This field is required.",
"acl_status: Not a valid choice",
"branches: This field is required.",
"pkgname: This field is required.",
"user: This field is required.",
])
create_package_acl(self.session)
data = {
'namespace': 'rpms',
'pkgname': 'guake',
'branches': 'master',
'acl': 'commit',
'acl_status': 'Approved',
'user': '******',
}
# Check if it works authenticated
user = FakeFasUser()
pkger_func.return_value = ['pingou', 'ralph', 'toshio']
with user_set(APP, user):
exp = {
"messages": [
"user: pingou set for toshio acl: commit of package: "
"guake from: Awaiting Review to: Approved on branch: "
"master"
],
"output":
"ok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
# Test that auto-approved ACL gets automatically Approved
data = {
'namespace': 'rpms',
'pkgname': 'guake',
'branches': 'master',
'acl': 'watchcommits',
'acl_status': 'Awaiting Review',
'user': '******',
}
exp = {
"messages": [
"user: pingou set for toshio acl: watchcommits of "
"package: guake from: to: Approved on branch: "
"master"
],
"output":
"ok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
# Check if it fails normally
user.username = '******'
data = {
'namespace': 'rpms',
'pkgname': 'guake',
'branches': 'master',
'acl': 'commit',
'acl_status': 'Approved',
'user': '******',
}
with user_set(APP, user):
exp = {
"error": "You are not allowed to update ACLs of someone else.",
"output": "notok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 500)
self.assertEqual(json_out, exp)
data = {
'namespace': 'rpms',
'pkgname': 'guake',
'branches': 'master',
'acl': 'commit',
'acl_status': 'Awaiting Review',
'user': '******',
}
user = FakeFasUser()
with user_set(APP, user):
# Revert it back to Awaiting Review
exp = {
"messages": [
"user: pingou set for toshio acl: commit of package: "
"guake from: Approved to: Awaiting Review on branch: "
"master"
],
"output":
"ok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
data = {
'namespace': 'rpms',
'pkgname': 'guake',
'branches': 'master',
'acl': 'commit',
'acl_status': 'Approved',
'user': '******',
}
# Check if it works for admins
user = FakeFasUserAdmin()
with user_set(APP, user):
exp = {
"messages": [
"user: admin set for toshio acl: commit of package: "
"guake from: Awaiting Review to: Approved on branch: "
"master"
],
"output":
"ok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
exp = {
"messages":
["Nothing to update on branch: master for acl: commit"],
"output": "ok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
def test_package_give(self, login_func, mock_func):
""" Test the package_give function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'pkg_branch': '',
'pkg_poc': '',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give', data=data)
self.assertEqual(output.status_code, 200)
self.assertEqual(
output.data.count(
'<td class="errors">This field is required.</td>'), 1)
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'pkg_branch': 'devel',
'pkg_poc': 'limb',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">The point of contact of this package '
'is not in the packager group</li>' in output.data)
mock_func.get_packagers.return_value = ['spot']
mock_func.log.return_value = ''
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'pkg_branch': 'devel',
'pkg_poc': 'spot',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1 property="doap:name">guake</h1>' in output.data)
self.assertTrue('<a href="/packager/spot/">' in output.data)
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/random/give')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>' in
output.data)
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'pkg_branch': 'devel',
'pkg_poc': 'spot',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<td><select id="pkg_branch" multiple '
'name="pkg_branch">'
'</select></td>' in output.data)
def test_api_package_retire(self, login_func, mock_func):
""" Test the api_package_retire function. """
login_func.return_value = None
# Redirect as you are not a packager
user = FakeFasUser()
user.groups = []
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/retire/')
self.assertEqual(output.status_code, 302)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/retire/')
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data,
{
"error": "Invalid input submitted",
"error_detail": [
"pkgnames: This field is required.",
"branches: This field is required.",
],
"output": "notok"
}
)
data = {
'pkgnames': 'guake',
'branches': ['f18', 'master'],
'poc': 'test',
}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/retire/', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data,
{
"error": "No package found by this name",
"output": "notok"
}
)
create_package_acl(self.session)
mock_func.log.return_value = ''
data = {
'pkgnames': 'guake',
'branches': ['f18', 'master'],
'poc': 'test',
}
# User is not an admin
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/retire/', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data,
{
"error": "You are not allowed to retire the package: "
"guake on branch f18.",
"output": "notok"
}
)
data = {
'pkgnames': 'guake',
'branches': ['master'],
'poc': 'test',
}
# User is not the poc
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/retire/', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data,
{
"error": "You are not allowed to retire this package.",
"output": "notok"
}
)
# Retire the package
user = FakeFasUserAdmin()
data = {
'pkgnames': 'guake',
'branches': ['f18', 'master'],
}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/retire/', data=data)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(
data,
{
"messages": ["", ""],
"output": "ok"
}
)
def test_package_give(self, login_func, mock_func):
""" Test the package_give function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'pkg_branch': '',
'pkg_poc': '',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give', data=data)
self.assertEqual(output.status_code, 200)
self.assertEqual(
output.data.count(
'<td class="errors">This field is required.</td>'
), 1)
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'pkg_branch': 'devel',
'pkg_poc': 'limb',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">The point of contact of this package '
'is not in the packager group</li>'
in output.data)
mock_func.get_packagers.return_value = ['spot']
mock_func.log.return_value = ''
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'pkg_branch': 'devel',
'pkg_poc': 'spot',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1 property="doap:name">guake</h1>'
in output.data)
self.assertTrue('<a href="/packager/spot/">' in output.data)
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/random/give')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>'
in output.data)
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'pkg_branch': 'devel',
'pkg_poc': 'spot',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td><select id="pkg_branch" multiple ''name="pkg_branch">'
'</select></td>' in output.data)
def test_unwatch_package(self, bz_mail_func, login_func, mock_func):
""" Test the unwatch_package function. """
login_func.return_value = None
bz_mail_func.return_value = 1
create_package_acl(self.session)
user = FakeFasUser()
mock_func.return_value = ['pingou', 'ralph', 'kevin']
with user_set(pkgdb2.APP, user):
output = self.app.get(
'/acl/rpms/guake/unwatch/', follow_redirects=True)
self.assertEqual(output.status_code, 405)
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/rpms/guake/')
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {'csrf_token': csrf_token}
output = self.app.post(
'/acl/rpms/guake/unwatch/', data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">You cannot remove `Watch*` ACLs from '
'the Point of Contact.</li>' in output.data)
output = self.app.post(
'/acl/rpms/random/unwatch/', data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>'
in output.data)
# Give watchbugzilla to ralph on guake/master
guake_pkg = model.Package.by_name(self.session, 'rpms', 'guake')
devel_collec = model.Collection.by_name(self.session, 'master')
pklist_guake_devel = model.PackageListing.by_pkgid_collectionid(
self.session, guake_pkg.id, devel_collec.id)
packager = model.PackageListingAcl(
fas_name='ralph',
packagelisting_id=pklist_guake_devel.id,
acl='watchbugzilla',
status='Approved',
)
self.session.add(packager)
self.session.commit()
# Drop watch* for ralph
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/rpms/guake/')
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {'csrf_token': csrf_token}
output = self.app.post(
'/acl/rpms/guake/unwatch/', data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">ACLs updated</li>' in output.data)
output = self.app.post(
'/acl/rpms/random/unwatch/', data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>'
in output.data)
def test_package_give_group(self, login_func, mock_func):
""" Test the package_give function to a group. """
login_func.return_value = None
create_package_acl(self.session)
mock_func.get_packagers.return_value = ['spot']
group = FakeFasGroupValid()
group.name = 'gtk-sig'
mock_func.get_fas_group.return_value = group
mock_func.log.return_value = ''
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/rpms/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'poc': 'spot',
'csrf_token': csrf_token,
}
output = self.app.post('/package/rpms/guake/give',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'rpms/<span property="doap:name">guake</span>' in output.data)
self.assertEqual(output.data.count('<a href="/packager/spot/">'),
2)
user.username = '******'
user.groups.append('gtk-sig')
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/rpms/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'poc': 'group::gtk-sig',
'csrf_token': csrf_token,
}
output = self.app.post('/package/rpms/guake/give',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertEqual(output.data.count('<a href="/packager/spot/">'),
2)
self.assertEqual(
output.data.count('<a href="/packager/group::gtk-sig/">'), 1)
output = self.app.get('/package/rpms/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<td><select id="branches" multiple name="branches">'
'</select></td>' in output.data)
def test_api_monitor_package(self, login_func, mock_func):
""" Test the api_package_critpath function. """
login_func.return_value = None
user = FakeFasUser()
# No package
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/guake/monitor/1')
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
sorted(data),
['error', 'output']
)
self.assertEqual(
data['error'], "No package found by this name")
self.assertEqual(
data['output'], "notok")
create_package_acl(self.session)
create_package_critpath(self.session)
# User is not a packager
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/guake/monitor/1')
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
sorted(data),
['error', 'output']
)
self.assertEqual(
data['error'],
"You are not allowed to update the monitor flag on this "
"package")
self.assertEqual(
data['output'], "notok")
# Works
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/guake/monitor/1')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(
sorted(data),
['messages', 'output']
)
self.assertEqual(
data['messages'], "Monitoring status of guake set to True")
self.assertEqual(
data['output'], "ok")
output = self.app.post('/api/package/guake/monitor/1')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(
sorted(data),
['messages', 'output']
)
self.assertEqual(
data['messages'], "Monitoring status un-changed")
self.assertEqual(
data['output'], "ok")
# User is not a packager but is admin
user = FakeFasUserAdmin()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/guake/monitor/False')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(
sorted(data),
['messages', 'output']
)
self.assertEqual(
data['messages'], "Monitoring status of guake set to False")
self.assertEqual(
data['output'], "ok")
def test_delete_package(self, login_func, utils_module):
""" Test the delete_package function. """
login_func.return_value = None
utils_module.get_packagers.return_value = ['pingou', 'toshio']
create_package_acl(self.session)
data = {}
# User is not an admin
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/delete',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">You are not an administrator of pkgdb'
'</li>' in output.data)
# User is an admin but no csrf
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/delete',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">Invalid input</li>' in output.data)
output = self.app.get('/package/guake/')
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'csrf_token': csrf_token,
}
# User is not an admin but csrf
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/delete',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">You are not an administrator of pkgdb'
'</li>' in output.data)
# Check before deleting
output = self.app.get('/packages/')
self.assertEqual(output.status_code, 200)
self.assertTrue('<p>4 packages found</p>' in output.data)
# User is an admin with csrf
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/delete',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue('<li class="message">Package guake deleted</li>' in
output.data)
self.assertTrue('<p>3 packages found</p>' in output.data)
output = self.app.post('/package/random/delete',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>' in
output.data)
def test_package_retire(self, login_func, mock_func):
""" Test the package_retire function. """
login_func.return_value = None
create_package_acl(self.session)
data = {
'branches': ['foobar'],
}
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/retire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="errors">Only Admins are allowed to retire package '
'here, you should use `fedpkg retire`.</li>' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': ['master'],
'csrf_token': csrf_token,
}
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/orphan', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: master</li>' in output.data)
data['branches'] = ['f18']
output = self.app.post(
'/package/guake/orphan', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: f18</li>' in output.data)
data = {
'branches': ['master'],
'csrf_token': csrf_token,
}
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/retire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="errors">Only Admins are allowed to retire package '
'here, you should use `fedpkg retire`.</li>' in output.data)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/retire')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<title> Select branches | PkgDB </title>' in output.data)
output = self.app.get('/package/guake/retire/0')
self.assertEqual(output.status_code, 200)
self.assertFalse(
'<title> Select branches | PkgDB </title>' in output.data)
data['branches'] = ['foobar']
output = self.app.post(
'/package/guake/retire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td class="errors">'foobar' is not a valid choice '
'for this field</td>' in output.data)
data['branches'] = ['f18']
output = self.app.post(
'/package/guake/retire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">This package has been retired on '
'branch: f18</li>' in output.data)
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/random/retire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>'
in output.data)
def test_package_request_edit(self, login_func, mock_func):
""" Test the package_request_edit function. """
login_func.return_value = None
mock_func.get_packagers.return_value = ['pingou', 'toshio']
mock_func.log.return_value = 'foo bar'
create_package_acl(self.session)
data = {
'branches': ['epel7'],
}
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/foobar/requests/1',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No action found with this identifier.</li>'
in output.data)
create_admin_actions(self.session)
# Package name / Admin Action do not match
output = self.app.post('/package/foobar/requests/1',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">The specified action (id:1) is not '
'related to the specified package: foobar.</li>' in
output.data)
# User not allowed to view request
output = self.app.post('/package/guake/requests/1',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">Only package adminitrators (`approveacls`)'
' and the requester can review pending branch requests</li>' in
output.data)
# Before the edit
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/requests/1')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Update request: 1</h1>' in output.data)
self.assertTrue('<option selected value="Pending">' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'status': 'Awaiting Review',
'csrf_token': csrf_token,
}
# User cannot approve their own request
output = self.app.post('/package/guake/requests/1',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td class="errors">Not a valid choice</td>' in output.data)
data = {
'status': 'Obsolete',
'csrf_token': csrf_token,
}
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
# Admin cannot obsolete a request that is not their
output = self.app.post('/package/guake/requests/1',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td class="errors">Not a valid choice</td>' in output.data)
data['status'] = 'Awaiting Review'
# All good
output = self.app.post('/package/guake/requests/1',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue('<li class="message">foo bar</li>' in output.data)
def test_update_pkg_poc(self):
""" Test the update_pkg_poc function. """
self.test_add_package()
# Package must exists
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.update_pkg_poc,
self.session,
pkg_name='test',
clt_name='F-17',
user=FakeFasUser(),
pkg_poc='toshio',
)
self.session.rollback()
# Collection must exists
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.update_pkg_poc,
self.session,
pkg_name='guake',
clt_name='F-16',
user=FakeFasUser(),
pkg_poc='toshio',
)
self.session.rollback()
# User must be the actual Point of Contact (or an admin of course,
# or part of the group)
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.update_pkg_poc,
self.session,
pkg_name='guake',
clt_name='F-18',
user=FakeFasUser(),
pkg_poc='toshio',
)
self.session.rollback()
# Groups must end with -sig
user = FakeFasUser()
user.username = '******'
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.update_pkg_poc,
self.session,
pkg_name='guake',
clt_name='F-18',
user=user,
pkg_poc='group::perl',
)
self.session.rollback()
# Change PoC to a group
pkgdblib.update_pkg_poc(
self.session,
pkg_name='guake',
clt_name='F-18',
user=user,
pkg_poc='group::perl-sig',
)
pkg_acl = pkgdblib.get_acl_package(self.session, 'guake')
self.assertEqual(pkg_acl[0].collection.branchname, 'F-18')
self.assertEqual(pkg_acl[0].package.name, 'guake')
self.assertEqual(pkg_acl[0].point_of_contact, 'group::perl-sig')
# User must be in the group it gives the PoC to
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.update_pkg_poc,
self.session,
pkg_name='guake',
clt_name='F-18',
user=user,
pkg_poc='ralph',
)
self.session.rollback()
user.groups.append('perl-sig')
pkgdblib.update_pkg_poc(
self.session,
pkg_name='guake',
clt_name='F-18',
user=user,
pkg_poc='ralph',
)
pkg_acl = pkgdblib.get_acl_package(self.session, 'guake')
self.assertEqual(pkg_acl[0].collection.branchname, 'F-18')
self.assertEqual(pkg_acl[0].package.name, 'guake')
self.assertEqual(pkg_acl[0].point_of_contact, 'ralph')
# PoC can change PoC
user = FakeFasUser()
user.username = '******'
pkgdblib.update_pkg_poc(
self.session,
pkg_name='guake',
clt_name='F-18',
user=user,
pkg_poc='toshio',
)
pkg_acl = pkgdblib.get_acl_package(self.session, 'guake')
self.assertEqual(pkg_acl[0].collection.branchname, 'F-18')
self.assertEqual(pkg_acl[0].package.name, 'guake')
self.assertEqual(pkg_acl[0].point_of_contact, 'toshio')
# Admin can change PoC
pkgdblib.update_pkg_poc(
self.session,
pkg_name='guake',
clt_name='F-18',
user=FakeFasUserAdmin(),
pkg_poc='kevin',
)
pkg_acl = pkgdblib.get_acl_package(self.session, 'guake')
self.assertEqual(pkg_acl[0].collection.branchname, 'F-18')
self.assertEqual(pkg_acl[0].package.name, 'guake')
self.assertEqual(pkg_acl[0].point_of_contact, 'kevin')
# Orphan -> status changed to Orphaned
user = FakeFasUser()
user.username = '******'
pkgdblib.update_pkg_poc(
self.session,
pkg_name='guake',
clt_name='F-18',
user=user,
pkg_poc='orphan',
)
pkg_acl = pkgdblib.get_acl_package(self.session, 'guake')
self.assertEqual(pkg_acl[0].collection.branchname, 'F-18')
self.assertEqual(pkg_acl[0].package.name, 'guake')
self.assertEqual(pkg_acl[0].point_of_contact, 'orphan')
self.assertEqual(pkg_acl[0].status, 'Orphaned')
# Take orphaned package -> status changed to Approved
pkgdblib.update_pkg_poc(
self.session,
pkg_name='guake',
clt_name='F-18',
user=FakeFasUser(),
pkg_poc=FakeFasUser().username,
)
pkg_acl = pkgdblib.get_acl_package(self.session, 'guake')
self.assertEqual(pkg_acl[0].collection.branchname, 'F-18')
self.assertEqual(pkg_acl[0].package.name, 'guake')
self.assertEqual(pkg_acl[0].point_of_contact, 'pingou')
self.assertEqual(pkg_acl[0].status, 'Approved')
def test_giveup_acl(self, bz_mail_func, login_func, mock_func):
""" Test the giveup_acl function. """
login_func.return_value = None
bz_mail_func.return_value = 1
create_package_acl(self.session)
user = FakeFasUser()
mock_func.return_value = ['pingou', 'ralph', 'kevin', 'dodji']
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/rpms/guake/giveup/approveacls/',
follow_redirects=True)
self.assertEqual(output.status_code, 405)
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/rpms/guake/')
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {'csrf_token': csrf_token}
output = self.app.post(
'/acl/docker/offlineimap/giveup/approveacls/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No active branches found for you for '
'the ACL: approveacls</li>' in output.data)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/rpms/guake/')
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {'csrf_token': csrf_token}
print 'give up'
output = self.app.post('/acl/rpms/guake/giveup/approveacls/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Your ACL approveacls is obsoleted on '
'branch f18 of package guake</li>' in output.data)
self.assertTrue(
'<li class="message">Your ACL approveacls is obsoleted on '
'branch master of package guake</li>' in output.data)
#print output.data
self.assertEqual(output.data.count('<a class="pending"'), 1)
output = self.app.post('/acl/rpms/guake/giveup/foobar/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">Invalid ACL provided foobar.</li>' in
output.data)
output = self.app.post('/acl/rpms/barfoo/giveup/commit/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>' in
output.data)
user.username = '******'
user.groups = []
with user_set(pkgdb2.APP, user):
output = self.app.post('/acl/rpms/guake/giveup/commit/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertFalse(
'<li class="error">User "toshio" is not in the '
'packager group</li>' in output.data)
def test_giveup_acl(self, login_func, mock_func):
""" Test the giveup_acl function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
mock_func.return_value = ['pingou', 'ralph', 'kevin', 'dodji']
with user_set(pkgdb2.APP, user):
output = self.app.get(
'/acl/guake/giveup/approveacls/', follow_redirects=True)
self.assertEqual(output.status_code, 405)
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/')
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {'csrf_token': csrf_token}
output = self.app.post(
'/acl/offlineimap/giveup/approveacls/',
data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No active branches found for you for '
'the ACL: approveacls</li>' in output.data)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/')
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {'csrf_token': csrf_token}
output = self.app.post(
'/acl/guake/giveup/approveacls/',
data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Your ACL approveacls is obsoleted on '
'branch f18 of package guake</li>' in output.data)
self.assertTrue(
'<li class="message">Your ACL approveacls is obsoleted on '
'branch master of package guake</li>' in output.data)
self.assertEqual(
output.data.count('<a class="pending"'), 1)
output = self.app.post(
'/acl/guake/giveup/foobar/',
data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">Invalid ACL provided foobar.</li>'
in output.data)
output = self.app.post(
'/acl/barfoo/giveup/commit/',
data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>'
in output.data)
user.username = '******'
user.groups = []
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/acl/guake/giveup/commit/',
data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">User "toshio" is not in the '
'packager group</li>' in output.data)
def test_request_acl(self, bz_mail_func, login_func, mock_func):
""" Test the request_acl function. """
login_func.return_value = None
bz_mail_func.return_value = 1
create_package_acl(self.session)
user = FakeFasUser()
mock_func.return_value = ['pingou', 'ralph', 'kevin']
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/rpms/guake/request/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Request ACLs on package: guake</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
self.assertTrue(
'<option value="approveacls">approveacls' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'acl': 'watchbugzilla',
'csrf_token': csrf_token,
}
output = self.app.post('/acl/rpms/guake/request/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">ACLs updated</li>' in output.data)
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/rpms/guake/request/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Request ACLs on package: guake</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
self.assertTrue(
'<option value="approveacls">approveacls' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'acl': 'watchbugzilla',
'csrf_token': csrf_token,
}
output = self.app.post('/acl/rpms/guake/request/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">ACLs updated</li>' in output.data)
data = {
'branches': 'master',
'acl': 'commit',
'csrf_token': csrf_token,
}
output = self.app.post('/acl/rpms/guake/request/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="error">User "Toshio" is not in the packager'
' group</' in output.data)
user = FakeFasUser()
user.groups = ['gitr2spec']
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/rpms/guake/request/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Request ACLs on package: guake</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
self.assertTrue(
'<option value="approveacls">approveacls' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'acl': 'commit',
'csrf_token': csrf_token,
}
output = self.app.post('/acl/rpms/guake/request/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">ACLs updated</li>' in output.data)
self.assertTrue(
'<li class="errors">You must be a packager to apply to the '
'ACL: commit on master</li>' in output.data)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/rpms/test/request/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>' in
output.data)
data = {
'branches': 'master',
'acl': 'commit',
'csrf_token': csrf_token,
}
output = self.app.post('/acl/rpms/test/request/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>' in
output.data)
def test_update_pkg_poc(self):
""" Test the update_pkg_poc function. """
self.test_add_package()
# Package must exists
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.update_pkg_poc,
self.session,
pkg_name='test',
clt_name='F-17',
user=FakeFasUser(),
pkg_poc='toshio',
)
self.session.rollback()
# Collection must exists
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.update_pkg_poc,
self.session,
pkg_name='guake',
clt_name='F-16',
user=FakeFasUser(),
pkg_poc='toshio',
)
self.session.rollback()
# User must be the actual Point of Contact (or an admin of course,
# or part of the group)
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.update_pkg_poc,
self.session,
pkg_name='guake',
clt_name='F-18',
user=FakeFasUser(),
pkg_poc='toshio',
)
self.session.rollback()
# Groups must end with -sig
user = FakeFasUser()
user.username = '******'
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.update_pkg_poc,
self.session,
pkg_name='guake',
clt_name='F-18',
user=user,
pkg_poc='group::perl',
)
self.session.rollback()
# Change PoC to a group
pkgdblib.update_pkg_poc(
self.session,
pkg_name='guake',
clt_name='F-18',
user=user,
pkg_poc='group::perl-sig',
)
pkg_acl = pkgdblib.get_acl_package(self.session, 'guake')
self.assertEqual(pkg_acl[0].collection.branchname, 'F-18')
self.assertEqual(pkg_acl[0].package.name, 'guake')
self.assertEqual(pkg_acl[0].point_of_contact, 'group::perl-sig')
# User must be in the group it gives the PoC to
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.update_pkg_poc,
self.session,
pkg_name='guake',
clt_name='F-18',
user=user,
pkg_poc='ralph',
)
self.session.rollback()
user.groups.append('perl-sig')
pkgdblib.update_pkg_poc(
self.session,
pkg_name='guake',
clt_name='F-18',
user=user,
pkg_poc='ralph',
)
pkg_acl = pkgdblib.get_acl_package(self.session, 'guake')
self.assertEqual(pkg_acl[0].collection.branchname, 'F-18')
self.assertEqual(pkg_acl[0].package.name, 'guake')
self.assertEqual(pkg_acl[0].point_of_contact, 'ralph')
# PoC can change PoC
user = FakeFasUser()
user.username = '******'
pkgdblib.update_pkg_poc(self.session,
pkg_name='guake',
clt_name='F-18',
user=user,
pkg_poc='toshio',
)
pkg_acl = pkgdblib.get_acl_package(self.session, 'guake')
self.assertEqual(pkg_acl[0].collection.branchname, 'F-18')
self.assertEqual(pkg_acl[0].package.name, 'guake')
self.assertEqual(pkg_acl[0].point_of_contact, 'toshio')
# Admin can change PoC
pkgdblib.update_pkg_poc(self.session,
pkg_name='guake',
clt_name='F-18',
user=FakeFasUserAdmin(),
pkg_poc='kevin',
)
pkg_acl = pkgdblib.get_acl_package(self.session, 'guake')
self.assertEqual(pkg_acl[0].collection.branchname, 'F-18')
self.assertEqual(pkg_acl[0].package.name, 'guake')
self.assertEqual(pkg_acl[0].point_of_contact, 'kevin')
# Orphan -> status changed to Orphaned
user = FakeFasUser()
user.username = '******'
pkgdblib.update_pkg_poc(self.session,
pkg_name='guake',
clt_name='F-18',
user=user,
pkg_poc='orphan',
)
pkg_acl = pkgdblib.get_acl_package(self.session, 'guake')
self.assertEqual(pkg_acl[0].collection.branchname, 'F-18')
self.assertEqual(pkg_acl[0].package.name, 'guake')
self.assertEqual(pkg_acl[0].point_of_contact, 'orphan')
self.assertEqual(pkg_acl[0].status, 'Orphaned')
# Take orphaned package -> status changed to Approved
pkgdblib.update_pkg_poc(self.session,
pkg_name='guake',
clt_name='F-18',
user=FakeFasUser(),
pkg_poc=FakeFasUser().username,
)
pkg_acl = pkgdblib.get_acl_package(self.session, 'guake')
self.assertEqual(pkg_acl[0].collection.branchname, 'F-18')
self.assertEqual(pkg_acl[0].package.name, 'guake')
self.assertEqual(pkg_acl[0].point_of_contact, 'pingou')
self.assertEqual(pkg_acl[0].status, 'Approved')
def test_acl_update(self, bz_mail_func, login_func, pkger_func):
""" Test the api_acl_update function. """
login_func.return_value = None
bz_mail_func.return_value = 1
output = self.app.post('/api/package/acl')
self.assertEqual(output.status_code, 301)
user = FakeFasUser()
with user_set(APP, user):
output = self.app.post('/api/package/acl/')
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
sorted(data),
['error', 'error_detail', 'output']
)
self.assertEqual(
data['error'], "Invalid input submitted")
self.assertEqual(
data['output'], "notok")
self.assertEqual(
sorted(data['error_detail']),
[
"acl: This field is required.",
"acl_status: Not a valid choice",
"branches: This field is required.",
"pkgname: This field is required.",
"user: This field is required.",
]
)
create_package_acl(self.session)
data = {
'pkgname': 'guake',
'branches': 'master',
'acl': 'commit',
'acl_status': 'Approved',
'user': '******',
}
# Check if it works authenticated
user = FakeFasUser()
pkger_func.return_value = ['pingou', 'ralph', 'toshio']
with user_set(APP, user):
exp = {
"messages": [
"user: pingou set for toshio acl: commit of package: "
"guake from: Awaiting Review to: Approved on branch: "
"master"
],
"output": "ok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
# Test that auto-approved ACL gets automatically Approved
data = {
'pkgname': 'guake',
'branches': 'master',
'acl': 'watchcommits',
'acl_status': 'Awaiting Review',
'user': '******',
}
exp = {
"messages": [
"user: pingou set for toshio acl: watchcommits of "
"package: guake from: to: Approved on branch: "
"master"
],
"output": "ok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
# Check if it fails normally
user.username = '******'
data = {
'pkgname': 'guake',
'branches': 'master',
'acl': 'commit',
'acl_status': 'Approved',
'user': '******',
}
with user_set(APP, user):
exp = {
"error": "You are not allowed to update ACLs of someone else.",
"output": "notok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 500)
self.assertEqual(json_out, exp)
data = {
'pkgname': 'guake',
'branches': 'master',
'acl': 'commit',
'acl_status': 'Awaiting Review',
'user': '******',
}
user = FakeFasUser()
with user_set(APP, user):
# Revert it back to Awaiting Review
exp = {
"messages": [
"user: pingou set for toshio acl: commit of package: "
"guake from: Approved to: Awaiting Review on branch: "
"master"
],
"output": "ok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
data = {
'pkgname': 'guake',
'branches': 'master',
'acl': 'commit',
'acl_status': 'Approved',
'user': '******',
}
# Check if it works for admins
user = FakeFasUserAdmin()
with user_set(APP, user):
exp = {
"messages": [
"user: admin set for toshio acl: commit of package: "
"guake from: Awaiting Review to: Approved on branch: "
"master"
],
"output": "ok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
exp = {
"messages": [
"Nothing to update on branch: master for acl: commit"
],
"output": "ok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
def test_acl_update(self, login_func):
""" Test the api_acl_update function. """
login_func.return_value = None
output = self.app.post('/api/package/acl')
self.assertEqual(output.status_code, 301)
user = FakeFasUser()
with user_set(APP, user):
output = self.app.post('/api/package/acl/')
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data, {
"output":
"notok",
"error_detail": [
"pkg_acl: Not a valid choice",
"pkg_name: This field is required.",
"acl_status: Not a valid choice",
"pkg_user: This field is required.",
"pkg_branch: This field is required."
],
"error":
"Invalid input submitted",
})
create_package_acl(self.session)
data = {
'pkg_name': 'guake',
'pkg_branch': 'devel',
'pkg_acl': 'commit',
'acl_status': 'Approved',
'pkg_user': '******',
}
# Check if it works authenticated
user = FakeFasUser()
with user_set(APP, user):
exp = {
"messages": [
"user: pingou set acl: commit of package: guake from: "
"Awaiting Review to: Approved on branch: devel"
],
"output":
"ok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
# Check if it fails normally
user.username = '******'
with user_set(APP, user):
exp = {
"error": "You are not allowed to update ACLs of someone else.",
"output": "notok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 500)
self.assertEqual(json_out, exp)
# Check if it works for admins
user = FakeFasUserAdmin()
with user_set(APP, user):
exp = {
"messages": [
"user: admin set acl: commit of package: guake from: "
"Approved to: Approved on branch: devel"
],
"output":
"ok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
def test_request_acl_all_branch(self, login_func, mock_func):
""" Test the request_acl_all_branch function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
mock_func.return_value = ['pingou', 'ralph', 'kevin']
with user_set(pkgdb2.APP, user):
output = self.app.get(
'/acl/guake/request/approveacls/', follow_redirects=True)
self.assertEqual(output.status_code, 405)
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/')
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {'csrf_token': csrf_token}
output = self.app.post(
'/acl/guake/request/approveacls/',
data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="message">ACL approveacls requested on branch f18</li>'
in output.data)
self.assertTrue(
'class="message">ACL approveacls requested on branch master</l'
in output.data)
self.assertEqual(
output.data.count('<a class="pending"'), 2)
output = self.app.post(
'/acl/guake/request/foobar/',
data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">Invalid ACL provided foobar.</li>'
in output.data)
output = self.app.post(
'/acl/barfoo/request/commit/',
data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>'
in output.data)
user.username = '******'
user.groups = []
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/acl/guake/request/commit/',
data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">You must be a packager to apply to the '
'ACL: commit on guake</li>'
in output.data)
output = self.app.post(
'/acl/guake/request/watchcommits/',
data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">ACL watchcommits requested on branch '
'f18</li>' in output.data)
self.assertTrue(
'<li class="message">ACL watchcommits requested on branch '
'master</li>' in output.data)
def test_package_retire(self, login_func, mock_func):
""" Test the package_retire function. """
login_func.return_value = None
create_package_acl(self.session)
data = {
'branches': ['foobar'],
}
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/retire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="errors">Only Admins are allowed to retire package '
'here, you should use `fedpkg retire`.</li>' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': ['master'],
'csrf_token': csrf_token,
}
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/orphan',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: master</li>' in output.data)
data['branches'] = ['f18']
output = self.app.post('/package/guake/orphan',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: f18</li>' in output.data)
data = {
'branches': ['master'],
'csrf_token': csrf_token,
}
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/retire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="errors">Only Admins are allowed to retire package '
'here, you should use `fedpkg retire`.</li>' in output.data)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/retire')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<title> Select branches | PkgDB </title>' in output.data)
output = self.app.get('/package/guake/retire/0')
self.assertEqual(output.status_code, 200)
self.assertFalse(
'<title> Select branches | PkgDB </title>' in output.data)
data['branches'] = ['foobar']
output = self.app.post('/package/guake/retire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td class="errors">'foobar' is not a valid choice '
'for this field</td>' in output.data)
data['branches'] = ['f18']
output = self.app.post('/package/guake/retire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">This package has been retired on '
'branch: f18</li>' in output.data)
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/random/retire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>' in
output.data)
def test_comaintain_package(self, login_func, mock_func):
""" Test the comaintain_package function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get(
'/acl/guake/comaintain/', follow_redirects=True)
self.assertEqual(output.status_code, 405)
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/')
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {'csrf_token': csrf_token}
output = self.app.post(
'/acl/guake/comaintain/',
data=data, follow_redirects=True)
self.assertTrue(
'<li class="error">You are already a co-maintainer on '
'f18</li>' in output.data)
self.assertFalse(
'<li class="message">ACLs updated</li>' in output.data)
output = self.app.post(
'/acl/random/comaintain/',
data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>'
in output.data)
user = FakeFasUser()
mock_func.return_value = ['pingou', 'ralph', 'kevin']
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/acl/guake/comaintain/',
data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">ACLs updated</li>' in output.data)
# Nothing to update the second time
output = self.app.post(
'/acl/guake/comaintain/',
data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Nothing to update</li>' in output.data)
output = self.app.post(
'/acl/random/comaintain/',
data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>'
in output.data)
user = FakeFasUser()
user.groups = ['gitr2spec']
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/acl/guake/comaintain/',
data=data, follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">You must be a packager</li>'
in output.data)
def test_package_give(self, login_func, utils_module):
""" Test the package_give function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<title> Give package | PkgDB </title>' in output.data)
output = self.app.get('/package/guake/give/0')
self.assertEqual(output.status_code, 200)
self.assertFalse(
'<title> Give package | PkgDB </title>' in output.data)
self.assertTrue(
'<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': '',
'poc': '',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give', data=data)
self.assertEqual(output.status_code, 200)
self.assertEqual(
output.data.count(
'<td class="errors">This field is required.</td>'
), 1)
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'poc': 'limb',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="error">User "limb" is not in the packager '
'group</' in output.data)
utils_module.get_packagers.return_value = ['spot']
utils_module.log.return_value = ''
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'poc': 'spot',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1 class="inline" property="doap:name">guake</h1>'
in output.data)
self.assertTrue('<a href="/packager/spot/">' in output.data)
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/random/give')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>'
in output.data)
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'poc': 'spot',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td><select id="branches" multiple ''name="branches">'
'</select></td>' in output.data)
def test_request_acl(self, login_func, mock_func):
""" Test the request_acl function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
mock_func.return_value = ['pingou', 'ralph', 'kevin']
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/guake/request/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Request ACLs on package: guake</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
self.assertTrue(
'<option value="approveacls">approveacls' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'acl': 'watchbugzilla',
'csrf_token': csrf_token,
}
output = self.app.post('/acl/guake/request/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<li class="message">ACLs updated</li>' in
output.data)
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/guake/request/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Request ACLs on package: guake</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
self.assertTrue(
'<option value="approveacls">approveacls' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'acl': 'watchbugzilla',
'csrf_token': csrf_token,
}
output = self.app.post('/acl/guake/request/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<li class="message">ACLs updated</li>' in
output.data)
data = {
'branches': 'master',
'acl': 'commit',
'csrf_token': csrf_token,
}
output = self.app.post('/acl/guake/request/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="error">User "Toshio" is not in the packager'
' group</' in output.data)
user = FakeFasUser()
user.groups = ['gitr2spec']
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/guake/request/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Request ACLs on package: guake</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
self.assertTrue(
'<option value="approveacls">approveacls' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'acl': 'commit',
'csrf_token': csrf_token,
}
output = self.app.post('/acl/guake/request/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">ACLs updated</li>' in output.data)
self.assertTrue(
'<li class="errors">You must be a packager to apply to the '
'ACL: commit on master</li>' in output.data)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/test/request/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>'
in output.data)
data = {
'branches': 'master',
'acl': 'commit',
'csrf_token': csrf_token,
}
output = self.app.post('/acl/test/request/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>'
in output.data)
def test_package_orphan(self, login_func, utils_module):
""" Test the package_orphan function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/orphan')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<title> Select branches | PkgDB </title>' in output.data)
output = self.app.get('/package/guake/orphan/0')
self.assertEqual(output.status_code, 200)
self.assertFalse(
'<title> Select branches | PkgDB </title>' in output.data)
output = self.app.post(
'/package/guake/orphan', follow_redirects=True,
data={'branches': ['master']})
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="errors">'master' is not a valid choice for '
'this field</td>' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': ['master'],
'csrf_token': csrf_token,
}
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/orphan', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: master</li>' in output.data)
# You cannot orphan twice the same package, the branch is no
# longer available
output = self.app.post(
'/package/guake/orphan', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td class="errors">'master' is not a valid choice '
'for this field</td>' in output.data)
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/random/orphan', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>'
in output.data)
def test_package_give(self, login_func, utils_module):
""" Test the package_give function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<title> Give package | PkgDB </title>' in output.data)
output = self.app.get('/package/guake/give/0')
self.assertEqual(output.status_code, 200)
self.assertFalse(
'<title> Give package | PkgDB </title>' in output.data)
self.assertTrue('<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': '',
'poc': '',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give', data=data)
self.assertEqual(output.status_code, 200)
self.assertEqual(
output.data.count(
'<td class="errors">This field is required.</td>'), 1)
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'poc': 'limb',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="error">User "limb" is not in the packager '
'group</' in output.data)
utils_module.get_packagers.return_value = ['spot']
utils_module.log.return_value = ''
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'poc': 'spot',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1 class="inline" property="doap:name">guake</h1>' in
output.data)
self.assertTrue('<a href="/packager/spot/">' in output.data)
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/random/give')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>' in
output.data)
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'poc': 'spot',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<td><select id="branches" multiple '
'name="branches">'
'</select></td>' in output.data)
def test_package_retire(self, login_func, utils_module):
""" Test the package_retire function. """
login_func.return_value = None
create_package_acl(self.session)
# Check at the very beginning
output = self.app.get('/package/guake/')
self.assertEqual(output.data.count('Obsolete'), 0)
self.assertEqual(output.data.count('Awaiting Review'), 3)
data = {
'branches': ['foobar'],
}
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/retire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="errors">Only Admins are allowed to retire package '
'here, you should use `fedpkg retire`.</li>' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': ['master'],
'csrf_token': csrf_token,
}
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/orphan', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: master</li>' in output.data)
data['branches'] = ['f18']
output = self.app.post(
'/package/guake/orphan', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: f18</li>' in output.data)
# Check after orphaning
# Orphaning already drops the ACLs of the person doing the action
output = self.app.get('/package/guake/')
self.assertEqual(output.data.count('Obsolete'), 8)
self.assertEqual(output.data.count('Awaiting Review'), 3)
data = {
'branches': ['master'],
'csrf_token': csrf_token,
}
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/retire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="errors">Only Admins are allowed to retire package '
'here, you should use `fedpkg retire`.</li>' in output.data)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/retire')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<title> Select branches | PkgDB </title>' in output.data)
output = self.app.get('/package/guake/retire/0')
self.assertEqual(output.status_code, 200)
self.assertFalse(
'<title> Select branches | PkgDB </title>' in output.data)
data['branches'] = ['foobar']
output = self.app.post(
'/package/guake/retire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td class="errors">'foobar' is not a valid choice '
'for this field</td>' in output.data)
# Retire F18 that has been orphaned before
data['branches'] = ['f18']
output = self.app.post(
'/package/guake/retire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">This package has been retired on '
'branch: f18</li>' in output.data)
# Package retired, clear all the ACLs on branch f18
output = self.app.get('/package/guake/')
self.assertEqual(output.data.count('Obsolete'), 8)
self.assertEqual(output.data.count('Awaiting Review'), 3)
# Retire branch master
data['branches'] = ['master']
output = self.app.post(
'/package/guake/retire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">This package has been retired on '
'branch: master</li>' in output.data)
# Package retired, clear all the ACLs on master
output = self.app.get('/package/guake/')
self.assertEqual(output.data.count('Obsolete'), 12)
self.assertEqual(output.data.count('Awaiting Review'), 0)
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/random/retire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>'
in output.data)
def test_package_retire(self, login_func, utils_module):
""" Test the package_retire function. """
login_func.return_value = None
create_package_acl(self.session)
# Check at the very beginning
output = self.app.get('/package/guake/')
self.assertEqual(output.data.count('Obsolete'), 0)
self.assertEqual(output.data.count('Awaiting Review'), 3)
data = {
'branches': ['foobar'],
}
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/retire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="errors">Only Admins are allowed to retire package '
'here, you should use `fedpkg retire`.</li>' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': ['master'],
'csrf_token': csrf_token,
}
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/orphan',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: master</li>' in output.data)
data['branches'] = ['f18']
output = self.app.post('/package/guake/orphan',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: f18</li>' in output.data)
# Check after orphaning
# Orphaning already drops the ACLs of the person doing the action
output = self.app.get('/package/guake/')
self.assertEqual(output.data.count('Obsolete'), 8)
self.assertEqual(output.data.count('Awaiting Review'), 3)
data = {
'branches': ['master'],
'csrf_token': csrf_token,
}
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/retire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="errors">Only Admins are allowed to retire package '
'here, you should use `fedpkg retire`.</li>' in output.data)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/retire')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<title> Select branches | PkgDB </title>' in output.data)
output = self.app.get('/package/guake/retire/0')
self.assertEqual(output.status_code, 200)
self.assertFalse(
'<title> Select branches | PkgDB </title>' in output.data)
data['branches'] = ['foobar']
output = self.app.post('/package/guake/retire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td class="errors">'foobar' is not a valid choice '
'for this field</td>' in output.data)
# Retire F18 that has been orphaned before
data['branches'] = ['f18']
output = self.app.post('/package/guake/retire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">This package has been retired on '
'branch: f18</li>' in output.data)
# Package retired, clear all the ACLs on branch f18
output = self.app.get('/package/guake/')
self.assertEqual(output.data.count('Obsolete'), 8)
self.assertEqual(output.data.count('Awaiting Review'), 3)
# Retire branch master
data['branches'] = ['master']
output = self.app.post('/package/guake/retire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">This package has been retired on '
'branch: master</li>' in output.data)
# Package retired, clear all the ACLs on master
output = self.app.get('/package/guake/')
self.assertEqual(output.data.count('Obsolete'), 12)
self.assertEqual(output.data.count('Awaiting Review'), 0)
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/random/retire',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>' in
output.data)
def test_package_unretire(self, login_func, utils_module):
""" Test the package_unretire function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/orphan')
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
# Oprhan and retire guake on F18
data = {
'branches': ['f18'],
'csrf_token': csrf_token,
}
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/orphan', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: f18</li>' in output.data)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/retire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">This package has been retired on '
'branch: f18</li>' in output.data)
# Start testing unretire
with user_set(pkgdb2.APP, user):
output = self.app.get(
'/package/random/unretire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>'
in output.data)
output = self.app.post(
'/package/random/unretire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>'
in output.data)
output = self.app.post(
'/package/guake/unretire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">User "admin" is not in the '
'packager group</li>' in output.data)
utils_module.get_packagers.return_value = ['pingou', 'toshio']
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get(
'/package/guake/unretire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td><select id="branches" multiple name="branches">'
'<option value="f18">f18</option></select></td>'
in output.data)
output = self.app.post(
'/package/guake/unretire', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Admins have been asked to un-retire '
'branch: f18</li>' in output.data)
output = self.app.post(
'/package/guake/unretire/0', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">Could not save the request for branch: '
'f18, has it already been requested?</li>' in output.data)
def test_package_take(self, login_func, utils_module):
""" Test the package_take function. """
login_func.return_value = None
utils_module.get_packagers.return_value = ['pingou', 'toshio']
create_package_acl(self.session)
data = {
'branches': ['master'],
}
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/take',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue('<li class="error">No branches orphaned found</li>'
in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': ['master'],
'csrf_token': csrf_token,
}
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/orphan',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: master</li>' in output.data)
data = {
'branches': ['foo'],
}
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/take',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td class="errors">'foo' is not a valid choice '
'for this field</td>' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': ['master'],
'csrf_token': csrf_token,
}
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/take')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<title> Select branches | PkgDB </title>' in output.data)
output = self.app.get('/package/guake/take/0')
self.assertEqual(output.status_code, 200)
self.assertFalse(
'<title> Select branches | PkgDB </title>' in output.data)
output = self.app.post('/package/guake/take',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You have taken the package guake on '
'branch master</li>' in output.data)
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/random/take',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>' in
output.data)
def test_package_take(self, login_func, utils_module):
""" Test the package_take function. """
login_func.return_value = None
utils_module.get_packagers.return_value = ['pingou', 'toshio']
create_package_acl(self.session)
data = {
'branches': ['master'],
}
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/take', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No branches orphaned found</li>'
in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': ['master'],
'csrf_token': csrf_token,
}
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/orphan', follow_redirects=True, data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You are no longer point of contact on '
'branch: master</li>' in output.data)
data = {
'branches': ['foo'],
}
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/take', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td class="errors">'foo' is not a valid choice '
'for this field</td>' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': ['master'],
'csrf_token': csrf_token,
}
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/take')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<title> Select branches | PkgDB </title>' in output.data)
output = self.app.get('/package/guake/take/0')
self.assertEqual(output.status_code, 200)
self.assertFalse(
'<title> Select branches | PkgDB </title>' in output.data)
output = self.app.post(
'/package/guake/take', follow_redirects=True, data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">You have taken the package guake on '
'branch master</li>' in output.data)
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/random/take', follow_redirects=True, data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>'
in output.data)
def test_package_request_branch(self, login_func, mock_func):
""" Test the package_request_branch function. """
login_func.return_value = None
mock_func.get_packagers.return_value = ['pingou', 'toshio']
create_package_acl(self.session)
data = {
'branches': ['epel7'],
}
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/foobar/request_branch',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>' in
output.data)
output = self.app.post('/package/guake/request_branch',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td class="errors">'epel7' is not a valid choice '
'for this field</td>' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': ['el6'],
'csrf_token': csrf_token,
}
# Missing one input
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/request_branch',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td class="errors">Not a valid choice</td>' in output.data)
data = {
'branches': ['el6'],
'from_branch': 'master',
'csrf_token': csrf_token,
}
# Input correct but user is not allowed
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/request_branch/0',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">User "kevin" is not in the '
'packager group</li>' in output.data)
data = {
'branches': ['el6'],
'from_branch': 'master',
'csrf_token': csrf_token,
}
# All good
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post('/package/guake/request_branch',
follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Branch el6 requested for user pingou</' in
output.data)
def test_delete_package(self, login_func, utils_module):
""" Test the delete_package function. """
login_func.return_value = None
utils_module.get_packagers.return_value = ['pingou', 'toshio']
create_package_acl(self.session)
data = {}
# User is not an admin
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/delete', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">You are not an administrator of pkgdb'
'</li>' in output.data)
# User is an admin but no csrf
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/delete', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">Invalid input</li>' in output.data)
output = self.app.get('/package/guake/')
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'csrf_token': csrf_token,
}
# User is not an admin but csrf
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/delete', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">You are not an administrator of pkgdb'
'</li>' in output.data)
# Check before deleting
output = self.app.get('/packages/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<p>4 packages found</p>' in output.data)
# User is an admin with csrf
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/delete', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Package guake deleted</li>'
in output.data)
self.assertTrue(
'<p>3 packages found</p>' in output.data)
output = self.app.post(
'/package/random/delete', follow_redirects=True, data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>'
in output.data)
def test_acl_reassign(self, login_func, mock_func):
""" Test the api_acl_reassign function. """
login_func.return_value = None
output = self.app.post('/api/package/acl/reassign')
self.assertEqual(output.status_code, 301)
user = FakeFasUser()
with user_set(APP, user):
output = self.app.post('/api/package/acl/reassign/')
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(data, {
"output": "notok",
"error": "Invalid input submitted",
})
create_package_acl(self.session)
data = {
'pkgnames': ['guake', 'geany'],
'branches': 'master',
'namespace': 'rpms',
'poc': 'toshio',
}
# Fails is user is not a packager.
user = FakeFasUser()
with user_set(APP, user):
exp = {
"error": "User \"toshio\" is not in the packager group",
"output": "notok"
}
output = self.app.post('/api/package/acl/reassign/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 500)
self.assertEqual(json_out, exp)
mock_func.get_packagers.return_value = ['pingou', 'ralph', 'toshio']
mock_func.log.return_value = ''
# Fails for geany is user is a packager but not in the group that
# is the current poc - works for guake
with user_set(APP, user):
exp = {
"error": "You are not part of the group \"gtk-sig\", you "
"are not allowed to change the point of contact.",
"messages": [""],
"output": "ok"
}
output = self.app.post('/api/package/acl/reassign/', data=data)
json_out = json.loads(output.data)
print output.data
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
# Works
data = {
'pkgnames': ['geany'],
'branches': 'master',
'namespace': 'rpms',
'poc': 'toshio',
}
user.groups.append('gtk-sig')
with user_set(APP, user):
exp = {"messages": [''], "output": "ok"}
output = self.app.post('/api/package/acl/reassign/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
# Check if it fails normally
user.username = '******'
with user_set(APP, user):
exp = {
"error": "You are not allowed to change the point of contact.",
"output": "notok"
}
output = self.app.post('/api/package/acl/reassign/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 500)
self.assertEqual(json_out, exp)
def test_package_request_branch(self, login_func, mock_func):
""" Test the package_request_branch function. """
login_func.return_value = None
mock_func.get_packagers.return_value = ['pingou', 'toshio']
create_package_acl(self.session)
data = {
'branches': ['epel7'],
}
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/foobar/request_branch', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>'
in output.data)
output = self.app.post(
'/package/guake/request_branch', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td class="errors">'epel7' is not a valid choice '
'for this field</td>' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': ['el6'],
'csrf_token': csrf_token,
}
# Input correct but user is not allowed
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/request_branch/0',
follow_redirects=True, data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">User "kevin" is not in the '
'packager group</li>' in output.data)
data = {
'branches': ['el6'],
'csrf_token': csrf_token,
}
# All good
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/guake/request_branch',
follow_redirects=True, data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Branch el6 requested for user pingou</'
in output.data)
# Check the request authenticated
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/requests/1')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Update request: 1</h1>' in output.data)
self.assertTrue(
'As current admin of the package you have the possibility'
in output.data)
self.assertTrue(
'<form action="/package/requests/1"' in output.data)
# Check the request un-authenticated
with user_set(pkgdb2.APP, None):
output = self.app.get('/package/requests/1')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Request: 1</h1>' in output.data)
self.assertFalse(
'As current admin of the package you have the possibility'
in output.data)
self.assertFalse(
'<form action="/package/requests/1"' in output.data)
def test_request_acl_all_branch(self, bz_mail_func, login_func, mock_func):
""" Test the request_acl_all_branch function. """
login_func.return_value = None
bz_mail_func.return_value = 1
create_package_acl(self.session)
user = FakeFasUser()
mock_func.return_value = ['pingou', 'ralph', 'kevin']
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/rpms/guake/request/approveacls/',
follow_redirects=True)
self.assertEqual(output.status_code, 405)
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/rpms/guake/')
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {'csrf_token': csrf_token}
output = self.app.post('/acl/rpms/guake/request/approveacls/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="message">ACL approveacls requested on branch f18</li>'
in output.data)
self.assertTrue(
'class="message">ACL approveacls requested on branch master</l'
in output.data)
self.assertEqual(output.data.count('<a class="pending"'), 2)
output = self.app.post('/acl/rpms/guake/request/foobar/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">Invalid ACL provided foobar.</li>' in
output.data)
output = self.app.post('/acl/rpms/barfoo/request/commit/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>' in
output.data)
user.username = '******'
user.groups = []
with user_set(pkgdb2.APP, user):
output = self.app.post('/acl/rpms/guake/request/commit/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">You must be a packager to apply to the '
'ACL: commit on guake</li>' in output.data)
output = self.app.post('/acl/rpms/guake/request/watchcommits/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">ACL watchcommits requested on branch '
'f18</li>' in output.data)
self.assertTrue(
'<li class="message">ACL watchcommits requested on branch '
'master</li>' in output.data)
def test_package_request_edit(self, login_func, mock_func):
""" Test the package_request_edit function. """
login_func.return_value = None
mock_func.get_packagers.return_value = ['pingou', 'toshio']
mock_func.log.return_value = 'foo bar'
create_package_acl(self.session)
data = {
'branches': ['epel7'],
}
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.post(
'/package/requests/1', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No action found with this identifier.</li>'
in output.data)
create_admin_actions(self.session)
# User not allowed to view request
output = self.app.post(
'/package/requests/1', follow_redirects=True,
data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">Only package adminitrators (`approveacls`)'
' and the requester can review pending branch requests</li>'
in output.data)
# Before the edit
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/requests/1')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Update request: 1</h1>' in output.data)
self.assertTrue(
'<option selected value="Pending">' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'status': 'Awaiting Review',
'csrf_token': csrf_token,
}
# User cannot approve their own request
output = self.app.post(
'/package/requests/1',
follow_redirects=True, data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td class="errors">Not a valid choice</td>' in output.data)
data = {
'status': 'Obsolete',
'csrf_token': csrf_token,
}
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
# Admin cannot obsolete a request that is not their
output = self.app.post(
'/package/requests/1',
follow_redirects=True, data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<td class="errors">Not a valid choice</td>' in output.data)
data['status'] = 'Awaiting Review'
# All good
output = self.app.post(
'/package/requests/1',
follow_redirects=True, data=data)
self.assertEqual(output.status_code, 200)
self.assertTrue('<li class="message">foo bar</li>'in output.data)
def test_unwatch_package(self, bz_mail_func, login_func, mock_func):
""" Test the unwatch_package function. """
login_func.return_value = None
bz_mail_func.return_value = 1
create_package_acl(self.session)
user = FakeFasUser()
mock_func.return_value = ['pingou', 'ralph', 'kevin']
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/rpms/guake/unwatch/',
follow_redirects=True)
self.assertEqual(output.status_code, 405)
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/rpms/guake/')
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {'csrf_token': csrf_token}
output = self.app.post('/acl/rpms/guake/unwatch/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">You cannot remove `Watch*` ACLs from '
'the Point of Contact.</li>' in output.data)
output = self.app.post('/acl/rpms/random/unwatch/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>' in
output.data)
# Give watchbugzilla to ralph on guake/master
guake_pkg = model.Package.by_name(self.session, 'rpms', 'guake')
devel_collec = model.Collection.by_name(self.session, 'master')
pklist_guake_devel = model.PackageListing.by_pkgid_collectionid(
self.session, guake_pkg.id, devel_collec.id)
packager = model.PackageListingAcl(
fas_name='ralph',
packagelisting_id=pklist_guake_devel.id,
acl='watchbugzilla',
status='Approved',
)
self.session.add(packager)
self.session.commit()
# Drop watch* for ralph
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/rpms/guake/')
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {'csrf_token': csrf_token}
output = self.app.post('/acl/rpms/guake/unwatch/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">ACLs updated</li>' in output.data)
output = self.app.post('/acl/rpms/random/unwatch/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>' in
output.data)
def test_package_give_group(self, login_func, mock_func):
""" Test the package_give function to a group. """
login_func.return_value = None
create_package_acl(self.session)
mock_func.get_packagers.return_value = ['spot']
group = FakeFasGroupValid()
group.name = 'gtk-sig'
mock_func.get_fas_group.return_value = group
mock_func.log.return_value = ''
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'poc': 'spot',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1 class="inline" property="doap:name">guake</h1>'
in output.data)
self.assertEqual(
output.data.count('<a href="/packager/spot/">'), 2)
user.username = '******'
user.groups.append('gtk-sig')
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'poc': 'group::gtk-sig',
'csrf_token': csrf_token,
}
output = self.app.post('/package/guake/give', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertEqual(
output.data.count('<a href="/packager/spot/">'), 2)
self.assertEqual(
output.data.count('<a href="/packager/group::gtk-sig/">'),
1)
output = self.app.get('/package/guake/give')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Give Point of Contact of package: guake</h1>'
in output.data)
self.assertTrue(
'<td><select id="branches" multiple name="branches">'
'</select></td>'
in output.data)
def test_update_acl(self, login_func, mock_func, bz_email):
""" Test the update_acl function. """
login_func.return_value = None
bz_email.return_value = True
create_package_acl(self.session)
user = FakeFasUser()
mock_func.return_value = ['pingou', 'ralph', 'kevin']
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/rpms/guake/acl/commit/',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertEqual(output.data.count('<td class="users">'), 1)
# Fails `toshio` is not a packager
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/package/rpms/guake/acl/commit/',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('</a> > Edit Commit Access</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
self.assertTrue('<option value="Approved">Approved' in output.data)
self.assertEqual(output.data.count('class="username">'), 1)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branch': 'master',
'acls': '',
'user': '******',
'csrf_token': csrf_token,
}
output = self.app.post('/package/rpms/guake/acl/commit/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">User "toshio" is not in the '
'packager group</li>' in output.data)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
# Invalid package name
output = self.app.get('/package/rpms/foobar/acl/commit/',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>' in
output.data)
# Invalid ACL name
output = self.app.get('/package/rpms/guake/acl/foobar/',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<li class="errors">Invalid ACL to update.</li>' in
output.data)
# GET works
output = self.app.get('/package/rpms/guake/acl/commit/',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('</a> > Edit Commit Access</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
self.assertTrue('<option value="Approved">Approved' in output.data)
self.assertEqual(output.data.count('class="username">'), 2)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branches': 'master',
'acl': 'commit',
'acl_status': 'Approved',
'csrf_token': csrf_token,
}
# No user provided, so we don't know for who to update the ACLs
output = self.app.post('/package/rpms/guake/acl/commit/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<li class="error">Invalid input submitted</li>' in
output.data)
mock_func.return_value = ['pingou', 'ralph', 'toshio']
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
# Get works
output = self.app.get('/package/rpms/guake/acl/commit/',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('</a> > Edit Commit Access</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
self.assertTrue('<option value="Approved">Approved' in output.data)
self.assertEqual(output.data.count('class="username">'), 1)
# Only 2 approved ACLs
output = self.app.get('/package/rpms/guake/',
follow_redirects=True)
self.assertEqual(output.data.count('title="ACL Approved"'), 2)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'branch': 'master',
'acls': '',
'user': '******',
'csrf_token': csrf_token,
}
# Toshio drops his ACL request on master
output = self.app.post('/package/rpms/guake/acl/commit/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">toshio's commit ACL updated on '
'master</li>' in output.data)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
data = {
'branch': 'master',
'acls': 'foobar',
'user': '******',
'csrf_token': csrf_token,
}
# Invalid ACL status provided
output = self.app.post('/package/rpms/guake/acl/commit/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">Invalid ACL: foobar</li>' in output.data)
data = {
'branch': 'master',
'acls': 'Awaiting Review',
'user': '******',
'csrf_token': csrf_token,
}
# Toshio is no longer requesting, thus is not in the list of
# users and thus makes the request invalid
output = self.app.post('/package/rpms/guake/acl/commit/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h4 title="`approveacls` ACL">Package Administrator(s)</h4>'
in output.data)
self.assertTrue(
'<li class="error">Invalid user: toshio</li>' in output.data)
user = FakeFasUser()
user.username = '******'
with user_set(pkgdb2.APP, user):
# Toshio asks for commit on master
data = {
'branch': 'master',
'acls': 'Awaiting Review',
'user': '******',
'csrf_token': csrf_token,
}
output = self.app.post('/package/rpms/guake/acl/commit/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">toshio's commit ACL updated on '
'master</li>' in output.data)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
# Invalid branch
data = {
'branch': 'foo',
'acls': '',
'user': '******',
'csrf_token': csrf_token,
}
output = self.app.post('/package/rpms/guake/acl/commit/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Nothing to update' in output.data)
# Nothing to change
data = {
'branch': 'master',
'acls': 'Awaiting Review',
'user': '******',
'csrf_token': csrf_token,
}
output = self.app.post('/package/rpms/guake/acl/commit/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Nothing to update' in output.data)
# Nothing to change (2)
data = {
'branch': 'f18',
'acls': '',
'user': '******',
'csrf_token': csrf_token,
}
output = self.app.post('/package/rpms/guake/acl/commit/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Nothing to update' in output.data)
# package admin cannot remove the user's ACL
data = {
'branch': 'master',
'acls': '',
'user': '******',
'csrf_token': csrf_token,
}
output = self.app.post('/package/rpms/guake/acl/commit/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">Only the user can remove his/her '
'ACL</li>' in output.data)
# package admin grants commit to Toshio on master
data = {
'branch': 'master',
'acls': 'Approved',
'user': '******',
'csrf_token': csrf_token,
}
output = self.app.post('/package/rpms/guake/acl/commit/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">toshio's commit ACL updated on '
'master</li>' in output.data)
# One more approved ACL
self.assertTrue(output.data.count('title="ACL Approved"'), 3)
def test_acl_reassign(self, login_func, mock_func):
""" Test the api_acl_reassign function. """
login_func.return_value = None
output = self.app.post('/api/package/acl/reassign')
self.assertEqual(output.status_code, 301)
user = FakeFasUser()
with user_set(APP, user):
output = self.app.post('/api/package/acl/reassign/')
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(data, {
"output": "notok",
"error": "Invalid input submitted",
})
create_package_acl(self.session)
data = {
'pkgnames': ['guake', 'geany'],
'branches': 'master',
'poc': 'toshio',
}
# Fails is user is not a packager.
user = FakeFasUser()
with user_set(APP, user):
exp = {
"error": "User \"toshio\" is not in the packager group",
"output": "notok"
}
output = self.app.post('/api/package/acl/reassign/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 500)
self.assertEqual(json_out, exp)
mock_func.get_packagers.return_value = ['pingou', 'ralph', 'toshio']
mock_func.log.return_value = ''
# Fails for geany is user is a packager but not in the group that
# is the current poc - works for guake
with user_set(APP, user):
exp = {
"error": "You are not part of the group \"gtk-sig\", you "
"are not allowed to change the point of contact.",
"messages": [""],
"output": "ok"
}
output = self.app.post('/api/package/acl/reassign/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
# Works
data = {
'pkgnames': ['geany'],
'branches': 'master',
'poc': 'toshio',
}
user.groups.append('gtk-sig')
with user_set(APP, user):
exp = {"messages": [''], "output": "ok"}
output = self.app.post('/api/package/acl/reassign/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
# Check if it fails normally
user.username = '******'
with user_set(APP, user):
exp = {
"error": "You are not allowed to change the point of contact.",
"output": "notok"
}
output = self.app.post('/api/package/acl/reassign/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 500)
self.assertEqual(json_out, exp)
def test_package_give_acls(self, bz_mail_func, login_func, mock_func):
""" Test the package_give_acls function. """
login_func.return_value = None
bz_mail_func.return_value = 1
create_package_acl(self.session)
user = FakeFasUser()
mock_func.return_value = ['pingou', 'ralph', 'kevin']
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/rpms/guake/give/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Give ACLs on package: guake</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
self.assertTrue(
'<option value="approveacls">approveacls' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'namespace': 'rpms',
'branches': 'master',
'acl': 'watchbugzilla',
'user': '******',
'acl_status': 'Approved',
'csrf_token': csrf_token,
}
output = self.app.post('/acl/rpms/guake/give/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">ACLs updated</li>' in output.data)
# Add test for giving ACLs without providing the namespace in
# the form (in which case it relies on the one in the URL)
data = {
'branches': 'master',
'acl': 'watchcommits',
'user': '******',
'acl_status': 'Approved',
'csrf_token': csrf_token,
}
output = self.app.post('/acl/rpms/guake/give/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">ACLs updated</li>' in output.data)
user.username = '******'
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/rpms/foo/give/', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="error">No package found by this name</li>' in
output.data)
self.assertTrue('<h1>Search packages (rpms) </h1>' in output.data)
output = self.app.get('/acl/rpms/guake/give/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Give ACLs on package: guake</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
self.assertTrue(
'<option value="approveacls">approveacls' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'namespace': 'rpms',
'branches': 'master',
'acl': 'commit',
'user': '******',
'acl_status': 'Approved',
'csrf_token': csrf_token,
}
output = self.app.post('/acl/rpms/guake/give/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'class="error">You are not allowed to update ACLs of someone '
'else.</li>' in output.data)
def test_acl_update(self, login_func):
""" Test the api_acl_update function. """
login_func.return_value=None
output = self.app.post('/api/package/acl')
self.assertEqual(output.status_code, 301)
user = FakeFasUser()
with user_set(APP, user):
output = self.app.post('/api/package/acl/')
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data,
{
"output": "notok",
"error_detail": [
"pkg_acl: Not a valid choice",
"pkg_name: This field is required.",
"acl_status: Not a valid choice",
"pkg_user: This field is required.",
"pkg_branch: This field is required."
],
"error": "Invalid input submitted",
}
)
create_package_acl(self.session)
data = {
'pkg_name': 'guake',
'pkg_branch': 'devel',
'pkg_acl': 'commit',
'acl_status': 'Approved',
'pkg_user': '******',
}
# Check if it works authenticated
user = FakeFasUser()
with user_set(APP, user):
exp = {
"messages": [
"user: pingou set acl: commit of package: guake from: "
"Awaiting Review to: Approved on branch: devel"
],
"output": "ok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
# Check if it fails normally
user.username = '******'
with user_set(APP, user):
exp = {
"error": "You are not allowed to update ACLs of someone else.",
"output": "notok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 500)
self.assertEqual(json_out, exp)
# Check if it works for admins
user = FakeFasUserAdmin()
with user_set(APP, user):
exp = {
"messages": [
"user: admin set acl: commit of package: guake from: "
"Approved to: Approved on branch: devel"
],
"output": "ok"
}
output = self.app.post('/api/package/acl/', data=data)
json_out = json.loads(output.data)
self.assertEqual(output.status_code, 200)
self.assertEqual(json_out, exp)
