def test_update_collection_status(self):
""" Test the update_collection_status function. """
create_collection(self.session)
collection = model.Collection.by_name(self.session, 'F-18')
self.assertEqual(collection.status, 'Active')
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.update_collection_status,
self.session,
'F-18',
'EOL',
user=FakeFasUser(),
)
pkgdblib.update_collection_status(self.session,
'F-18',
'EOL',
user=FakeFasUserAdmin())
self.session.commit()
msg = pkgdblib.update_collection_status(self.session,
'F-18',
'EOL',
user=FakeFasUserAdmin())
self.assertEqual(msg, 'Collection "F-18" already had this status')
collection = model.Collection.by_name(self.session, 'F-18')
self.assertEqual(collection.status, 'EOL')
def test_is_pkgdb_admin(self):
""" Test the is_pkgdb_admin function of pkgdb2. """
user = FakeFasUser()
out = pkgdb2.is_pkgdb_admin(user)
self.assertEqual(out, False)
user.groups = []
out = pkgdb2.is_pkgdb_admin(user)
self.assertEqual(out, False)
user = FakeFasUser()
out = pkgdb2.is_pkgdb_admin(None)
self.assertEqual(out, False)
user = FakeFasUserAdmin()
out = pkgdb2.is_pkgdb_admin(user)
self.assertEqual(out, True)
pkgdb2.APP.config['ADMIN_GROUP'] = 'sysadmin-main'
out = pkgdb2.is_pkgdb_admin(user)
self.assertEqual(out, False)
# Reset the ADMIN_GROUP for the other tests
pkgdb2.APP.config['ADMIN_GROUP'] = ('sysadmin-main', 'sysadmin-cvs')
def test_admin_actions(self, login_func):
""" Test the admin_actions function. """
login_func.return_value = None
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get('/admin/actions/')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Actions</h1>' in output.data)
self.assertTrue(
'Restrict to package: <input type="text" name="package" />' in
output.data)
output = self.app.get(
'/admin/actions/?page=abc&limit=def&status=ghi&package=test')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Actions</h1>' in output.data)
self.assertTrue(
'Restrict to package: <input type="text" name="package" />' in
output.data)
self.assertTrue(
'class="errors">Incorrect limit provided, using default</' in
output.data)
self.assertTrue(
'<li class="errors">No package exists</li>' in output.data)
output = self.app.get('/admin/actions/?package=guake')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Actions</h1>' in output.data)
self.assertTrue(
'Restrict to package: <input type="text" name="package" />' in
output.data)
self.assertTrue(
'<th>Status</th>\n \n <th></th>\n \n </tr>\n\n</table>'
in output.data)
def test_admin(self, login_func):
""" Test the admin function. """
login_func.return_value = None
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get('/admin/')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Admin interface</h1>' in output.data)
def test_admin_actions(self, login_func):
""" Test the admin_actions function. """
login_func.return_value = None
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get('/admin/actions/')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Actions</h1>' in output.data)
self.assertTrue(
'Restrict to package: <input type="text" name="package" />'
in output.data)
output = self.app.get(
'/admin/actions/?page=abc&limit=def&status=ghi&package=test')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Actions</h1>' in output.data)
self.assertTrue(
'Restrict to package: <input type="text" name="package" />'
in output.data)
self.assertTrue(
'class="errors">Incorrect limit provided, using default</'
in output.data)
self.assertTrue(
'<li class="errors">No package exists</li>' in output.data)
output = self.app.get('/admin/actions/?package=guake')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Actions</h1>' in output.data)
self.assertTrue(
'Restrict to package: <input type="text" name="package" />'
in output.data)
self.assertTrue(
'<p>No actions found</p>' in output.data)
# Create some actions to see
create_collection(pkgdb2.SESSION)
create_package(pkgdb2.SESSION)
create_admin_actions(pkgdb2.SESSION, n=2)
# set the pagination
pkgdb2.APP.config['ITEMS_PER_PAGE'] = 1
# Check the list
output = self.app.get('/admin/actions/?status=all')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Actions</h1>' in output.data)
self.assertTrue(
'Restrict to package: <input type="text" name="package" />'
in output.data)
# 3 actions = 3 pages
self.assertTrue('<td>1 / 3</td>' in output.data)
# Reset the pagination
pkgdb2.APP.config['ITEMS_PER_PAGE'] = 50
def test_edit_collection(self):
""" Test the edit_collection function. """
create_collection(self.session)
collection = pkgdblib.search_collection(self.session, 'F-18')[0]
out = pkgdblib.edit_collection(self.session,
collection,
user=FakeFasUserAdmin())
self.assertEqual(out, None)
self.assertRaises(pkgdblib.PkgdbException, pkgdblib.edit_collection,
self.session, collection)
out = pkgdblib.edit_collection(
self.session,
collection,
clt_name='Fedora youhou!',
clt_version='Awesome 18',
clt_status='EOL',
clt_publishurl='http://.....',
clt_pendingurl='http://.....',
clt_summary='Fedora awesome release 18',
clt_description='This is a description of how cool Fedora is',
clt_branchname='f18_b',
clt_disttag='fc18',
clt_gitbranch='F-18',
user=FakeFasUserAdmin(),
)
self.assertEqual(out, 'Collection "f18_b" edited')
collections = pkgdblib.search_collection(self.session, 'F-18')
self.assertEqual(collections, [])
collection = pkgdblib.search_collection(self.session, 'f18_b')[0]
self.assertEqual(collection.name, 'Fedora youhou!')
self.assertEqual(collection.status, 'EOL')
def test_add_collection(self):
""" Test the add_collection function. """
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.add_collection,
session=self.session,
clt_name='Fedora',
clt_version='19',
clt_status='Active',
clt_publishurl=None,
clt_pendingurl=None,
clt_summary='Fedora 19 release',
clt_description='Fedora 19 collection',
clt_branchname='F-19',
clt_disttag='.fc19',
clt_gitbranch='f19',
user=FakeFasUser(),
)
self.session.rollback()
pkgdblib.add_collection(
self.session,
clt_name='Fedora',
clt_version='19',
clt_status='Active',
clt_publishurl=None,
clt_pendingurl=None,
clt_summary='Fedora 19 release',
clt_description='Fedora 19 collection',
clt_branchname='F-19',
clt_disttag='.fc19',
clt_gitbranch='f19',
user=FakeFasUserAdmin(),
)
self.session.commit()
collection = model.Collection.by_name(self.session, 'F-19')
self.assertEqual(
"Collection(u'Fedora', u'19', u'Active', u'admin', "
"publishurltemplate=None, pendingurltemplate=None, "
"summary=u'Fedora 19 release', "
"description=u'Fedora 19 collection')", collection.__repr__())
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_admin_log(self, login_func):
""" Test the admin_log function. """
login_func.return_value = None
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get('/admin/log/')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Logs</h1>' in output.data)
self.assertTrue(
'Restrict to package: <input type="text" name="package" />'
in output.data)
output = self.app.get(
'/admin/log/?page=abc&limit=def&from_date=ghi&package=test')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Logs</h1>' in output.data)
self.assertTrue(
'Restrict to package: <input type="text" name="package" />'
in output.data)
self.assertTrue(
'class="errors">Incorrect limit provided, using default</'
in output.data)
self.assertTrue(
'class="errors">Incorrect from_date provided, using default</'
in output.data)
self.assertTrue(
'<li class="errors">No package exists</li>' in output.data)
output = self.app.get('/admin/log/?from_date=2013-10-19')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Logs</h1>' in output.data)
self.assertTrue(
'Restrict to package: <input type="text" name="package" />'
in output.data)
self.assertTrue(
'<p class=\'error\'>No logs found in the database.</p>'
in output.data)
def test_update_pkg_status(self):
""" Test the update_pkg_status function. """
create_package_acl(self.session)
# Wrong package
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.update_pkg_status,
self.session,
pkg_name='test',
clt_name='F-17',
status='Deprecated',
user=FakeFasUser(),
)
self.session.rollback()
# Wrong collection
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.update_pkg_status,
self.session,
pkg_name='guake',
clt_name='F-16',
status='Orphaned',
user=FakeFasUser(),
)
self.session.rollback()
# User not allowed to deprecate the package on F-18
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.update_pkg_status,
self.session,
pkg_name='guake',
clt_name='F-18',
status='Deprecated',
user=FakeFasUser(),
)
self.session.rollback()
# Wrong status
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.update_pkg_status,
self.session,
pkg_name='guake',
clt_name='F-18',
status='Depreasdcated',
user=FakeFasUser(),
)
self.session.rollback()
# User not allowed to change status to Allowed
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.update_pkg_status,
self.session,
pkg_name='guake',
clt_name='F-18',
status='Allowed',
user=FakeFasUser(),
)
self.session.rollback()
# Admin can retire package
pkgdblib.update_pkg_status(self.session,
pkg_name='guake',
clt_name='F-18',
status='Deprecated',
user=FakeFasUserAdmin())
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, 'Deprecated')
# User can orphan package
pkgdblib.update_pkg_status(self.session,
pkg_name='guake',
clt_name='devel',
status='Orphaned',
user=FakeFasUser())
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, 'Deprecated')
self.assertEqual(pkg_acl[1].collection.branchname, 'devel')
self.assertEqual(pkg_acl[1].package.name, 'guake')
self.assertEqual(pkg_acl[1].point_of_contact, 'orphan')
self.assertEqual(pkg_acl[1].status, 'Orphaned')
# Admin must give a poc when un-orphan/un-retire a package
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.update_pkg_status,
self.session,
pkg_name='guake',
clt_name='devel',
status='Approved',
user=FakeFasUserAdmin())
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, 'Deprecated')
self.assertEqual(pkg_acl[1].collection.branchname, 'devel')
self.assertEqual(pkg_acl[1].package.name, 'guake')
self.assertEqual(pkg_acl[1].point_of_contact, 'orphan')
self.assertEqual(pkg_acl[1].status, 'Orphaned')
# Admin can un-orphan package
pkgdblib.update_pkg_status(self.session,
pkg_name='guake',
clt_name='devel',
status='Approved',
poc="pingou",
user=FakeFasUserAdmin())
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, 'Deprecated')
self.assertEqual(pkg_acl[1].collection.branchname, 'devel')
self.assertEqual(pkg_acl[1].package.name, 'guake')
self.assertEqual(pkg_acl[1].point_of_contact, 'pingou')
self.assertEqual(pkg_acl[1].status, 'Approved')
# Admin can un-retire package
pkgdblib.update_pkg_status(self.session,
pkg_name='guake',
clt_name='F-18',
status='Approved',
poc="pingou",
user=FakeFasUserAdmin())
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')
self.assertEqual(pkg_acl[1].collection.branchname, 'devel')
self.assertEqual(pkg_acl[1].package.name, 'guake')
self.assertEqual(pkg_acl[1].point_of_contact, 'pingou')
self.assertEqual(pkg_acl[1].status, 'Approved')
# Not Admin and status is not Orphaned nor Deprecated
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.update_pkg_status,
self.session,
pkg_name='guake',
clt_name='devel',
status='Removed',
user=FakeFasUser())
def test_add_package(self):
""" Test the add_package function. """
create_collection(self.session)
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.add_package,
self.session,
pkg_name='test',
pkg_summary='test package',
pkg_status='Approved',
pkg_collection='F-18',
pkg_poc='ralph',
pkg_reviewURL=None,
pkg_shouldopen=None,
pkg_upstreamURL='http://example.org',
user=FakeFasUser())
self.session.rollback()
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.add_package,
self.session,
pkg_name='test',
pkg_summary='test package',
pkg_status='Approved',
pkg_collection='F-18',
pkg_poc='group::tests',
pkg_reviewURL=None,
pkg_shouldopen=None,
pkg_upstreamURL='http://example.org',
user=FakeFasUserAdmin())
self.session.rollback()
msg = pkgdblib.add_package(self.session,
pkg_name='guake',
pkg_summary='Drop down terminal',
pkg_status='Approved',
pkg_collection='F-18',
pkg_poc='ralph',
pkg_reviewURL=None,
pkg_shouldopen=None,
pkg_upstreamURL='http://guake.org',
user=FakeFasUserAdmin())
self.assertEqual(msg, 'Package created')
self.session.commit()
packages = model.Package.all(self.session)
self.assertEqual(1, len(packages))
self.assertEqual('guake', packages[0].name)
pkgdblib.add_package(self.session,
pkg_name='geany',
pkg_summary='GTK IDE',
pkg_status='Approved',
pkg_collection='devel, F-18',
pkg_poc='ralph',
pkg_reviewURL=None,
pkg_shouldopen=None,
pkg_upstreamURL=None,
user=FakeFasUserAdmin())
self.session.commit()
packages = model.Package.all(self.session)
self.assertEqual(2, len(packages))
self.assertEqual('guake', packages[0].name)
self.assertEqual('geany', packages[1].name)
pkgdblib.add_package(self.session,
pkg_name='fedocal',
pkg_summary='web calendar for Fedora',
pkg_status='Approved',
pkg_collection='devel, F-18',
pkg_poc='group::infra-sig',
pkg_reviewURL=None,
pkg_shouldopen=None,
pkg_upstreamURL=None,
user=FakeFasUserAdmin())
self.session.commit()
packages = model.Package.all(self.session)
self.assertEqual(3, len(packages))
self.assertEqual('guake', packages[0].name)
self.assertEqual('geany', packages[1].name)
self.assertEqual('fedocal', packages[2].name)
def test_collection_new(self, login_func):
""" Test the collection_new function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/new/collection/')
self.assertEqual(output.status_code, 302)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get('/new/collection/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Create a new collection</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 = {
'clt_name': '',
'version': '',
'clt_status': '',
'branchname': '',
'dist_tag': '',
'csrf_token': csrf_token,
}
output = self.app.post('/new/collection/', data=data)
self.assertEqual(output.status_code, 200)
self.assertEqual(
output.data.count(
'<td class="errors">This field is required.</td>'
), 6)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get('/new/collection/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Create a new collection</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 = {
'clt_name': 'Fedora',
'version': '19',
'clt_status': 'Active',
'branchname': 'f19',
'dist_tag': '.fc19',
'kojiname': 'f19',
'csrf_token': csrf_token,
}
output = self.app.post('/new/collection/', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Collection "f19" created</li>'
in output.data)
def test_api_package_new(self, login_func, mock_func):
""" Test the api_package_new function. """
login_func.return_value = None
# Redirect as you are not admin
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/new/')
self.assertEqual(output.status_code, 302)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/new/')
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data, {
"error":
"Invalid input submitted",
"error_detail": [
"pkg_summary: This field is required.",
"pkg_collection: This field is required.",
"pkg_reviewURL: This field is required.",
"pkg_poc: This field is required.",
"pkg_status: Not a valid choice",
"pkg_name: This field is required."
],
"output":
"notok"
})
data = {
'pkg_name': 'gnome-terminal',
'pkg_summary': 'Terminal emulator for GNOME',
'pkg_description': 'Terminal for GNOME...',
'pkg_reviewURL': 'http://bugzilla.redhat.com/1234',
'pkg_status': '',
'pkg_shouldopen': '',
'pkg_critpath': '',
'pkg_collection': '',
'pkg_poc': '',
'pkg_upstreamURL': '',
}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/new/', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
## FIXME: this is damn ugly but there is something wrong between
## me and jenkins that needs sorting out.
self.assertTrue(
data == {
"error":
"Invalid input submitted",
"error_detail": [
"pkg_status: This field is required.",
"pkg_poc: This field is required.",
"pkg_collection: '' is not a valid choice for this "
"field", "pkg_critpath: This field is required.",
"pkg_shouldopen: This field is required."
],
"output":
"notok"
} or data == {
"error":
"Invalid input submitted",
"error_detail": [
"pkg_status: This field is required.",
"pkg_poc: This field is required.",
"pkg_collection: '' is not a valid choice for this "
"field"
],
"output":
"notok"
})
data = {
'pkg_name': 'gnome-terminal',
'pkg_summary': 'Terminal emulator for GNOME',
'pkg_description': 'Terminal for GNOME...',
'pkg_reviewURL': 'http://bugzilla.redhat.com/1234',
'pkg_status': 'Approved',
'pkg_shouldopen': True,
'pkg_collection': 'devel',
'pkg_poc': 'mclasen',
'pkg_upstreamURL': 'http://www.gnome.org/',
'pkg_critpath': False,
}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/new/', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data, {
"error":
"Invalid input submitted",
"error_detail": [
"pkg_collection: 'devel' is not a valid choice for "
"this field"
],
"output":
"notok"
})
create_collection(self.session)
data = {
'pkg_name': 'gnome-terminal',
'pkg_summary': 'Terminal emulator for GNOME',
'pkg_description': 'Terminal for GNOME...',
'pkg_reviewURL': 'http://bugzilla.redhat.com/1234',
'pkg_status': 'Approved',
'pkg_shouldopen': True,
'pkg_collection': 'devel',
'pkg_poc': 'mclasen',
'pkg_upstreamURL': 'http://www.gnome.org/',
'pkg_critpath': False,
}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/new/', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data, {
"error": "The point of contact of this package is not "
"in the packager group",
"output": "notok"
})
mock_func.get_packagers.return_value = ['mclasen']
mock_func.log.return_value = ''
data = {
'pkg_name': 'gnome-terminal',
'pkg_summary': 'Terminal emulator for GNOME',
'pkg_description': 'Terminal for GNOME...',
'pkg_reviewURL': 'http://bugzilla.redhat.com/1234',
'pkg_status': 'Approved',
'pkg_shouldopen': True,
'pkg_collection': 'devel',
'pkg_poc': 'mclasen',
'pkg_upstreamURL': 'http://www.gnome.org/',
'pkg_critpath': False,
}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/new/', data=data)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(data, {
"messages": ["Package created"],
"output": "ok"
})
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_api_package_unretire(self, login_func, mock_func):
""" Test the api_package_unretire 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/unretire/')
self.assertEqual(output.status_code, 302)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/unretire/')
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/unretire/', 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 = ''
# User is not an admin
data = {
'pkgnames': 'guake',
'branches': ['f18', 'master'],
}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/unretire/', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data,
{
"error": "You are not allowed to update the status of "
"the package: guake on branch f18 to "
"Approved.",
"output": "notok"
}
)
# Unretire the package
user = FakeFasUserAdmin()
data = {
'pkgnames': 'guake',
'branches': ['f18', 'master'],
}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/unretire/', data=data)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(
data,
{
"messages": ["", ""],
"output": "ok"
}
)
def test_api_admin_action_edit_status(self, login_func):
""" Test the api_admin_action_edit_status function. """
login_func.return_value = None
# Redirect as you are not admin
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/admin/action/status')
self.assertEqual(output.status_code, 302)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/admin/action/status')
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']), [
'id: This field is required.',
'status: Not a valid choice',
])
data = {
'id': 'foo',
'status': 'Approved',
}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/admin/action/status', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data, {
"error": "Invalid input submitted",
"error_detail": [
"id: Field must contain a number",
],
"output": "notok"
})
# Have another test create a pending Admin Action
from test_flask_ui_packages import FlaskUiPackagesTest
uitest = FlaskUiPackagesTest('test_package_request_branch')
uitest.session = self.session
uitest.app = self.app
uitest.test_package_request_branch()
# Before edit:
output = self.app.get('/api/admin/actions/')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(len(data['actions']), 1)
action = data['actions'][0]
self.assertEqual(action['action'], "request.branch")
self.assertEqual(action['id'], 1)
self.assertEqual(action['collection']['branchname'], 'el6')
self.assertEqual(action['package']['name'], 'guake')
self.assertEqual(action['user'], 'pingou')
data = {
'id': 1,
'status': 'Denied',
}
# User is not an admin
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/admin/action/status', data=data)
self.assertEqual(output.status_code, 302)
# User is an admin
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
data = {
'id': 10,
'status': 'Denied',
}
# Wrong identifier
output = self.app.post('/api/admin/action/status', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data, {
"error": "No Admin action with this identifier found",
"output": "notok"
})
data = {
'id': 1,
'status': 'Denied',
}
# Missing explanatory message for the user
output = self.app.post('/api/admin/action/status', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data, {
"error": "You must provide a message explaining why "
"when you block or deny a request",
"output": "notok"
})
#Only the person creating the request can obsolete it
data = {
'id': 1,
'status': 'Obsolete',
'message': 'Because this is a test suite',
}
output = self.app.post('/api/admin/action/status', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data, {
"error": "Only the person having made the request can "
"change its status to obsolete",
"output": "notok"
})
# All good
data = {
'id': 1,
'status': 'Denied',
'message': 'Because this is a test suite',
}
output = self.app.post('/api/admin/action/status', data=data)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(
data, {
"messages": [
"user: admin updated action: 1 of guake from "
"`Awaiting Review` to `Denied` with message: "
"Because this is a test suite"
],
"output":
"ok"
})
# After Denying:
output = self.app.get('/api/admin/actions')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(len(data['actions']), 1)
action = data['actions'][0]
self.assertEqual(action['action'], "request.branch")
self.assertEqual(action['id'], 1)
self.assertEqual(action['collection']['branchname'], 'el6')
self.assertEqual(action['package']['name'], 'guake')
self.assertEqual(action['user'], 'pingou')
self.assertEqual(action['status'], 'Denied')
# User is an admin
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
data = {
'id': 1,
'status': 'Approved',
}
output = self.app.post('/api/admin/action/status', data=data)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(
data, {
"messages": [
"user: admin updated action: 1 of guake from "
"`Denied` to `Approved`"
],
"output":
"ok"
})
# After approving:
output = self.app.get('/api/admin/actions')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(len(data['actions']), 1)
action = data['actions'][0]
self.assertEqual(action['action'], "request.branch")
self.assertEqual(action['id'], 1)
self.assertEqual(action['collection']['branchname'], 'el6')
self.assertEqual(action['package']['name'], 'guake')
self.assertEqual(action['user'], 'pingou')
self.assertEqual(action['status'], 'Approved')
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_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_admin_action_edit_status(self, login_func):
""" Test the admin_action_edit_status function. """
login_func.return_value = None
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/admin/action/1/status')
self.assertEqual(output.status_code, 302)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get('/admin/action/1/status')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No action found with this identifier.</li>'
in output.data)
# Have another test create a pending Admin Action
from test_flask_ui_packages import FlaskUiPackagesTest
uitest = FlaskUiPackagesTest('test_package_request_branch')
uitest.session = self.session
uitest.app = self.app
uitest.test_package_request_branch()
with user_set(pkgdb2.APP, user):
# Before
# No action Pending
output = self.app.get('/admin/actions/?status=Pending')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Actions</h1>' in output.data)
self.assertFalse(
'<td class="col_odd">request.branch</td>' in output.data)
self.assertFalse(
'<td class="col_odd" >Awaiting Review</td>' in output.data)
# But one action in total
output = self.app.get('/admin/actions/?status=All')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Actions</h1>' in output.data)
self.assertTrue(
'<td class="col_odd">request.branch</td>' in output.data)
self.assertEqual(
output.data.count('<td class="col_odd">request.branch</td>'),
1
)
self.assertTrue(
'<td class="col_odd" >\n Awaiting Review\n </td>'
in output.data)
# One action Awaiting Review
output = self.app.get('/admin/actions/?status=Awaiting Review')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Actions</h1>' in output.data)
self.assertTrue(
'<td class="col_odd">request.branch</td>' in output.data)
self.assertEqual(
output.data.count('<td class="col_odd">request.branch</td>'),
1
)
self.assertTrue(
'<td class="col_odd" >\n Awaiting Review\n </td>'
in output.data)
# Update
output = self.app.get('/admin/action/1/status')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Update admin action: 1</h1>' in output.data)
csrf_token = output.data.split(
'name="csrf_token" type="hidden" value="')[1].split('">')[0]
data = {
'status': 'Approved',
'csrf_token': csrf_token,
}
output = self.app.post('/admin/action/1/status', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">user: admin updated action: 1 of guake '
'from `Awaiting Review` to `Approved`</li>' in output.data)
# After
output = self.app.get('/admin/actions/')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Actions</h1>' in output.data)
self.assertFalse(
'<td class="col_odd">request.branch</td>' in output.data)
def test_api_package_new(self, login_func, mock_func):
""" Test the api_package_new function. """
login_func.return_value = None
# Redirect as you are not admin
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/new/')
self.assertEqual(output.status_code, 302)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/new/')
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']),
[
"branches: This field is required.",
"pkgname: This field is required.",
"poc: This field is required.",
"review_url: This field is required.",
"status: Not a valid choice",
"summary: This field is required.",
]
)
data = {
'pkgname': 'gnome-terminal',
'summary': 'Terminal emulator for GNOME',
'description': 'Terminal for GNOME...',
'review_url': 'http://bugzilla.redhat.com/1234',
'status': '',
'critpath': '',
'branches': '',
'poc': '',
'upstream_url': '',
}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/new/', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
## FIXME: this is damn ugly but there is something wrong between
## me and jenkins that needs sorting out.
self.assertTrue(
data ==
{
"error": "Invalid input submitted",
"error_detail": [
"status: This field is required.",
"poc: This field is required.",
"branches: '' is not a valid choice for this field",
"critpath: This field is required.",
],
"output": "notok"
}
## Me v
or data ==
{
"error": "Invalid input submitted",
"error_detail": [
"status: This field is required.",
"branches: '' is not a valid choice for this field",
"poc: This field is required.",
],
"output": "notok"
}
)
data = {
'pkgname': 'gnome-terminal',
'summary': 'Terminal emulator for GNOME',
'description': 'Terminal for GNOME...',
'review_url': 'http://bugzilla.redhat.com/1234',
'status': 'Approved',
'branches': 'master',
'poc': 'mclasen',
'upstream_url': 'http://www.gnome.org/',
'critpath': False,
}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/new/', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data,
{
"error": "Invalid input submitted",
"error_detail": [
"branches: 'master' is not a valid choice for this "
"field"
],
"output": "notok"
}
)
create_collection(self.session)
data = {
'pkgname': 'gnome-terminal',
'summary': 'Terminal emulator for GNOME',
'description': 'Terminal for GNOME...',
'review_url': 'http://bugzilla.redhat.com/1234',
'status': 'Approved',
'branches': 'master',
'poc': 'mclasen',
'upstream_url': 'http://www.gnome.org/',
'critpath': False,
}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/new/', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data,
{
"error": "User \"mclasen\" is not in the packager group",
"output": "notok"
}
)
mock_func.get_packagers.return_value = ['mclasen']
mock_func.log.return_value = ''
data = {
'pkgname': 'gnome-terminal',
'summary': 'Terminal emulator for GNOME',
'description': 'Terminal for GNOME...',
'review_url': 'http://bugzilla.redhat.com/1234',
'status': 'Approved',
'branches': 'master',
'poc': 'mclasen',
'upstream_url': 'http://www.gnome.org/',
'critpath': False,
}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/package/new/', data=data)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(
data,
{
"messages": [
"Package created"
],
"output": "ok"
}
)
def test_package_new(self, login_func, utils_module):
""" Test the package_new function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/new/package/')
self.assertEqual(output.status_code, 302)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get('/new/package/')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Create a new package</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_name': '',
'pkg_summary': '',
'pkg_description': '',
'pkg_reviewURL': '',
'pkg_status': '',
'pkg_collection': '',
'pkg_poc': '',
'pkg_upstreamURL': '',
'pkg_critpath': '',
'csrf_token': csrf_token,
}
output = self.app.post('/new/package/', data=data)
self.assertEqual(output.status_code, 200)
self.assertEqual(
output.data.count(
'<td class="errors">This field is required.</td>'), 5)
utils_module.get_packagers.return_value = ['mclasen']
utils_module.log.return_value = ''
data = {
'pkgname': 'gnome-terminal',
'summary': 'Terminal emulator for GNOME',
'description': 'Terminal for GNOME...',
'review_url': 'http://bugzilla.redhat.com/1234',
'status': 'Approved',
'branches': 'master',
'poc': 'mclasen',
'upstream_url': '',
'critpath': False,
'csrf_token': csrf_token,
}
output = self.app.post('/new/package/',
data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Package created</li>' in output.data)
self.assertTrue('<h1>Search packages</h1>' in output.data)
self.assertTrue(
'<a href="/package/gnome-terminal/">' 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_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_collection_status(self, login_func):
""" Test the api_collection_status function. """
login_func.return_value = None
# Redirect as you are not admin
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/collection/f18/status/')
self.assertEqual(output.status_code, 302)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/collection/f18/status/')
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']), [
"branch: This field is required.",
"clt_status: Not a valid choice",
])
data = {'branch': 'f18', 'clt_status': 'EOL'}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/collection/f19/status/', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data, {
"output": "notok",
"error": "You're trying to update the wrong collection",
})
data = {'branch': 'f18', 'clt_status': 'EOL'}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/collection/f18/status', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(data, {
"output": "notok",
"error": 'Could not find collection "f18"',
})
create_collection(self.session)
data = {'branch': 'f18', 'clt_status': 'EOL'}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/collection/f18/status', data=data)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(
data, {
"output": "ok",
"messages":
['Collection updated from "Active" to \"EOL\"'],
})
def test_collection_new(self, login_func):
""" Test the api_collection_new function. """
login_func.return_value = None
# Redirect as you are not admin
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/collection/new/')
self.assertEqual(output.status_code, 302)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/collection/new/')
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data, {
"error":
"Invalid input submitted",
"error_detail": [
"dist_tag: This field is required.",
"version: This field is required.",
"clt_status: Not a valid choice",
"kojiname: This field is required.",
"clt_name: This field is required.",
"branchname: This field is required.",
],
"output":
"notok",
})
data = {
'clt_name': 'Fedora EPEL',
'version': '6',
'branchname': 'EL-6',
'clt_status': 'ACTIVE',
'dist_tag': '.el6',
'kojiname': 'epel6'
}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/collection/new/', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data, {
"error": "Invalid input submitted",
"error_detail": ["clt_status: Not a valid choice"],
"output": "notok"
})
# Need to find out how to set flask.g.fas_user
data = {
'clt_name': 'Fedora EPEL',
'version': '6',
'branchname': 'EL-6',
'clt_status': 'Active',
'dist_tag': '.el6',
'kojiname': 'epel6'
}
with user_set(pkgdb2.APP, user):
output = self.app.post('/api/collection/new/', data=data)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(data, {
"messages": ["Collection \"EL-6\" created"],
"output": "ok"
})
def test_unorphan_package(self):
""" Test the unorphan_package function. """
create_package_acl(self.session)
# Wrong package name
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.unorphan_package,
self.session,
pkg_name='asd',
clt_name='devel',
pkg_user='******',
user=FakeFasUser())
# Wrong collection
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.unorphan_package,
self.session,
pkg_name='guake',
clt_name='asd',
pkg_user='******',
user=FakeFasUser())
# Package is not orphaned
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.unorphan_package,
self.session,
pkg_name='guake',
clt_name='devel',
pkg_user='******',
user=FakeFasUser())
# Orphan package
pkgdblib.update_pkg_poc(
self.session,
pkg_name='guake',
clt_name='devel',
user=FakeFasUserAdmin(),
pkg_poc='orphan',
)
# User cannot unorphan for someone else
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.unorphan_package,
self.session,
pkg_name='guake',
clt_name='devel',
pkg_user='******',
user=FakeFasUser())
# User must be a packager
user = FakeFasUser()
user.groups = ['cla_done']
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.unorphan_package,
self.session,
pkg_name='guake',
clt_name='devel',
pkg_user='******',
user=user)
pkg_acl = pkgdblib.get_acl_package(self.session, 'guake')
self.assertEqual(pkg_acl[1].collection.branchname, 'devel')
self.assertEqual(pkg_acl[1].package.name, 'guake')
self.assertEqual(pkg_acl[1].point_of_contact, 'orphan')
self.assertEqual(pkg_acl[1].status, 'Orphaned')
pkgdblib.unorphan_package(self.session,
pkg_name='guake',
clt_name='devel',
pkg_user='******',
user=FakeFasUser())
pkg_acl = pkgdblib.get_acl_package(self.session, 'guake')
self.assertEqual(pkg_acl[1].collection.branchname, 'devel')
self.assertEqual(pkg_acl[1].package.name, 'guake')
self.assertEqual(pkg_acl[1].point_of_contact, 'pingou')
self.assertEqual(pkg_acl[1].status, 'Approved')
def test_collection_edit(self, login_func):
""" Test the collection_edit function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/collection/master/edit')
self.assertEqual(output.status_code, 302)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get('/collection/master/edit')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Edit collection</h1>' in output.data)
self.assertTrue(
'<input id="csrf_token" name="csrf_token"' in output.data)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get('/collection/random/edit')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No collection of this name found.</li>'
in output.data)
user = FakeFasUserAdmin()
with user_set(pkgdb2.APP, user):
output = self.app.get('/collection/f17/edit')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<h1>Edit collection</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]
collections = model.Collection.by_name(self.session, 'f17')
self.assertEqual(
"Collection(u'Fedora', u'17', u'Active', owner:u'toshio')",
collections.__repr__())
self.assertEqual(collections.branchname, 'f17')
data = {
'clt_name': 'Fedora',
'version': '17',
'clt_status': 'Active',
'branchname': 'f17',
'dist_tag': '.fc17',
'kojiname': 'f17',
'csrf_token': csrf_token,
}
output = self.app.post('/collection/f17/edit', data=data,
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Collection "f17" edited</li>'
in output.data)
collections = model.Collection.by_name(self.session, 'f17')
self.assertEqual(
"Collection(u'Fedora', u'17', u'Active', owner:u'toshio')",
collections.__repr__())
self.assertEqual(collections.branchname, 'f17')
def test_set_acl_package(self):
""" Test the set_acl_package function. """
self.test_add_package()
# Not allowed to set acl on non-existant package
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.set_acl_package,
self.session,
pkg_name='test',
clt_name='F-17',
pkg_user='******',
acl='nothing',
status='Appr',
user=FakeFasUser(),
)
self.session.rollback()
# Not allowed to set non-existant collection
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.set_acl_package,
self.session,
pkg_name='guake',
clt_name='F-16',
pkg_user='******',
acl='nothing',
status='Appr',
user=FakeFasUser(),
)
self.session.rollback()
# Not allowed to set non-existant status
self.assertRaises(
IntegrityError,
pkgdblib.set_acl_package,
self.session,
pkg_name='guake',
clt_name='F-18',
acl='commit',
pkg_user='******',
status='Appro',
user=FakeFasUserAdmin(),
)
self.session.rollback()
# Not allowed to set non-existant acl
self.assertRaises(
IntegrityError,
pkgdblib.set_acl_package,
self.session,
pkg_name='guake',
clt_name='F-18',
pkg_user='******',
acl='nothing',
status='Approved',
user=FakeFasUserAdmin(),
)
self.session.rollback()
# Not allowed to set acl for yourself
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.set_acl_package,
self.session,
pkg_name='guake',
clt_name='F-18',
pkg_user='******',
acl='approveacls',
status='Approved',
user=FakeFasUser(),
)
self.session.rollback()
# Not allowed to set acl for someone else
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.set_acl_package,
self.session,
pkg_name='guake',
clt_name='F-18',
pkg_user='******',
acl='commit',
status='Approved',
user=FakeFasUser(),
)
self.session.rollback()
# Not allowed to set acl approveacl to a group
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.set_acl_package,
self.session,
pkg_name='guake',
clt_name='F-18',
pkg_user='******',
acl='approveacls',
status='Approved',
user=FakeFasUser(),
)
self.session.rollback()
# Group must ends with -sig
self.assertRaises(
pkgdblib.PkgdbException,
pkgdblib.set_acl_package,
self.session,
pkg_name='guake',
clt_name='F-18',
pkg_user='******',
acl='commit',
status='Approved',
user=FakeFasUser(),
)
self.session.rollback()
# You can ask for new ACLs
pkgdblib.set_acl_package(
self.session,
pkg_name='guake',
clt_name='F-18',
pkg_user='******',
acl='approveacls',
status='Awaiting Review',
user=FakeFasUser(),
)
# You can obsolete your own ACLs
pkgdblib.set_acl_package(
self.session,
pkg_name='guake',
clt_name='F-18',
pkg_user='******',
acl='approveacls',
status='Obsolete',
user=FakeFasUser(),
)
# You can remove your own ACLs
pkgdblib.set_acl_package(
self.session,
pkg_name='guake',
clt_name='F-18',
pkg_user='******',
acl='approveacls',
status='Removed',
user=FakeFasUser(),
)
# An admin can approve you ACLs
pkgdblib.set_acl_package(
self.session,
pkg_name='guake',
clt_name='F-18',
pkg_user='******',
acl='commit',
status='Approved',
user=FakeFasUserAdmin(),
)
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(len(pkg_acl[0].acls), 6)
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_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')