def test_acl_get(self):
""" Test the api_acl_get function. """
output = self.app.get('/api/package/acl/get/guake')
self.assertEqual(output.status_code, 301)
output = self.app.get('/api/package/acl/get/guake/')
self.assertEqual(output.status_code, 500)
self.assertEqual(output.data,
'{\n "output": "notok",\n '
'"error": "No package found with name '
'\\"guake\\""\n}')
output = self.app.get('/api/package/acl/get/')
self.assertEqual(output.status_code, 500)
self.assertEqual(output.data,
'{\n "output": "notok",\n '
'"error": "No package provided"\n}')
create_package_acl(self.session)
output = self.app.get('/api/package/acl/get/guake/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output.keys(),
['acls'])
self.assertEqual(len(output['acls']), 2)
self.assertEqual(output['acls'][0]['collection']['branchname'],
'F-18')
self.assertEqual(output['acls'][0]['point_of_contact'],
'pingou')
self.assertEqual(output['acls'][1]['collection']['branchname'],
'devel')
self.assertEqual(output['acls'][1]['point_of_contact'],
'pingou')
def test_branch(self):
""" Test the branch method of PackageListing. """
create_package_acl(self.session)
pkg = model.Package.by_name(self.session, 'guake')
pkg_list = model.PackageListing.by_package_id(self.session, pkg.id)
self.assertEqual(len(pkg_list), 2)
self.assertEqual(pkg_list[0].collection.branchname, 'f18')
self.assertEqual(len(pkg_list[0].acls), 2)
self.assertEqual(pkg_list[1].collection.branchname, 'master')
self.assertEqual(len(pkg_list[1].acls), 5)
# Create a new collection
new_collection = model.Collection(
name='Fedora',
version='19',
status='Active',
owner='toshio',
branchname='f19',
dist_tag='.fc19',
)
self.session.add(new_collection)
self.session.commit()
# Branch guake from master to f19
pkg_list[1].branch(self.session, new_collection)
pkg_list = model.PackageListing.by_package_id(self.session, pkg.id)
self.assertEqual(len(pkg_list), 3)
self.assertEqual(pkg_list[0].collection.branchname, 'f18')
self.assertEqual(pkg_list[1].collection.branchname, 'master')
self.assertEqual(len(pkg_list[1].acls), 5)
self.assertEqual(pkg_list[2].collection.branchname, 'f19')
self.assertEqual(len(pkg_list[2].acls), 5)
def test_packager_list(self):
""" Test the api_packager_list function. """
output = self.app.get('/api/packager/list/pin*')
self.assertEqual(output.status_code, 301)
output = self.app.get('/api/packager/list/')
self.assertEqual(output.status_code, 500)
self.assertEqual(
output.data, '{\n "output": "notok",\n '
'"error": "Invalid request"\n}')
output = self.app.get('/api/packager/list/pin*/')
self.assertEqual(output.status_code, 200)
self.assertEqual(output.data,
'{\n "output": "ok",\n "packagers": []\n}')
create_package_acl(self.session)
output = self.app.get('/api/packager/list/pin*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output.keys(), ['output', 'packagers'])
self.assertEqual(output['output'], 'ok')
self.assertEqual(len(output['packagers']), 1)
self.assertEqual(output['packagers'][0], 'pingou')
def test_get_acl_user_package(self):
""" Test the get_acl_user_package function. """
pending_acls = pkgdblib.get_acl_user_package(self.session, 'pingou',
'guake')
self.assertEqual(pending_acls, [])
create_package_acl(self.session)
pending_acls = pkgdblib.get_acl_user_package(self.session, 'pingou',
'geany')
self.assertEqual(len(pending_acls), 0)
pending_acls = pkgdblib.get_acl_user_package(self.session, 'pingou',
'guake')
self.assertEqual(len(pending_acls), 4)
pending_acls = pkgdblib.get_acl_user_package(self.session,
'toshio',
'guake',
status='Awaiting Review')
self.assertEqual(len(pending_acls), 1)
self.assertEqual(pending_acls[0]['package'], 'guake')
self.assertEqual(pending_acls[0]['collection'], 'devel')
self.assertEqual(pending_acls[0]['acl'], 'commit')
self.assertEqual(pending_acls[0]['status'], 'Awaiting Review')
def test_get_acl_package(self):
""" Test the get_acl_package function. """
create_package_acl(self.session)
packages = model.Package.all(self.session)
self.assertEqual(3, len(packages))
self.assertEqual('guake', packages[0].name)
pkg_acl = pkgdblib.get_acl_package(self.session, 'guake')
self.assertEqual(len(pkg_acl), 2)
self.assertEqual(pkg_acl[0].collection.branchname, 'F-18')
self.assertEqual(pkg_acl[0].package.name, 'guake')
self.assertEqual(pkg_acl[0].acls[0].fas_name, 'pingou')
pkg_acl = pkgdblib.get_acl_package(self.session, 'guake', 'devel')
self.assertEqual(pkg_acl.collection.branchname, 'devel')
self.assertEqual(pkg_acl.package.name, 'guake')
self.assertEqual(pkg_acl.acls[0].fas_name, 'pingou')
# Collection does not exist
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.get_acl_package,
self.session,
'guake',
'unknown')
def test_dropcommit_package(self, bz_mail_func, login_func, mock_func):
""" Test the dropcommit_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/dropcommit/',
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/dropcommit/',
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/dropcommit/',
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_acl_get(self):
""" Test the api_acl_get function. """
output = self.app.get('/api/package/acl/get/guake')
self.assertEqual(output.status_code, 301)
output = self.app.get('/api/package/acl/get/guake/')
self.assertEqual(output.status_code, 500)
self.assertEqual(
output.data, '{\n "output": "notok",\n '
'"error": "No package found with name '
'\\"guake\\""\n}')
output = self.app.get('/api/package/acl/get/')
self.assertEqual(output.status_code, 500)
self.assertEqual(
output.data, '{\n "output": "notok",\n '
'"error": "No package provided"\n}')
create_package_acl(self.session)
output = self.app.get('/api/package/acl/get/guake/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output.keys(), ['acls'])
self.assertEqual(len(output['acls']), 2)
self.assertEqual(output['acls'][0]['collection']['branchname'], 'F-18')
self.assertEqual(output['acls'][0]['point_of_contact'], 'pingou')
self.assertEqual(output['acls'][1]['collection']['branchname'],
'devel')
self.assertEqual(output['acls'][1]['point_of_contact'], 'pingou')
def test_get_package_of_user(self):
""" Test the get_package_of_user function of Package. """
create_package_acl(self.session)
packages = model.Package.get_package_of_user(self.session,
user='******',
poc=True)
self.assertEqual(len(packages), 2)
self.assertEqual(packages[0][0].name, 'guake')
expected = set(['master', 'f18'])
branches = set([packages[0][1].branchname, packages[1][1].branchname])
self.assertEqual(branches.symmetric_difference(expected), set())
packages = model.Package.get_package_of_user(self.session,
user='******',
poc=False)
self.assertEqual(packages, [])
packages = model.Package.get_package_of_user(
self.session,
user='******',
pkg_status='Awaiting Review',
)
self.assertEqual(len(packages), 0)
def test_packager_list(self):
""" Test the api_packager_list function. """
output = self.app.get('/api/packager/list/pin*')
self.assertEqual(output.status_code, 301)
output = self.app.get('/api/packager/list/')
self.assertEqual(output.status_code, 500)
self.assertEqual(output.data,
'{\n "output": "notok",\n '
'"error": "Invalid request"\n}')
output = self.app.get('/api/packager/list/pin*/')
self.assertEqual(output.status_code, 200)
self.assertEqual(output.data,
'{\n "output": "ok",\n "packagers": []\n}')
create_package_acl(self.session)
output = self.app.get('/api/packager/list/pin*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output.keys(),
['output', 'packagers'])
self.assertEqual(output['output'], 'ok')
self.assertEqual(len(output['packagers']), 1)
self.assertEqual(output['packagers'][0], 'pingou')
def test_dropcommit_package(self, login_func, mock_func):
""" Test the dropcommit_package 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/dropcommit/', 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/dropcommit/',
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/random/dropcommit/',
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_to_json(self):
""" Test the to_json function of PersonPackageListing. """
packager = model.PackageListingAcl.get_acl_packager(
self.session, 'pingou')
self.assertEqual(0, len(packager))
create_package_acl(self.session)
packager = model.PackageListingAcl.get_acl_packager(
self.session, 'pingou')
self.assertEqual(4, len(packager))
output = packager[0].to_json()
self.assertEqual(
output, {
'status': u'Approved',
'acl': 'commit',
'fas_name': u'pingou',
'packagelist': {
'point_of_contact': u'pingou',
'collection': {
'pendingurltemplate': None,
'publishurltemplate': None,
'branchname': u'F-18',
'version': u'18',
'name': u'Fedora'
},
'package': {
'upstreamurl': u'http://guake.org',
'name': u'guake',
'reviewurl': u'https://bugzilla.redhat.com/450189',
'summary': u'Top down terminal for GNOME'
}
}
})
def test_get_package_of_user(self):
""" Test the get_package_of_user function of Package. """
create_package_acl(self.session)
packages = model.Package.get_package_of_user(
self.session, user='******', poc=True
)
self.assertEqual(len(packages), 2)
self.assertEqual(packages[0][0].name, 'guake')
expected = set(['master', 'f18'])
branches = set([packages[0][1].branchname,
packages[1][1].branchname])
self.assertEqual(branches.symmetric_difference(expected), set())
packages = model.Package.get_package_of_user(
self.session, user='******', poc=False
)
self.assertEqual(packages, [])
packages = model.Package.get_package_of_user(
self.session,
user='******',
pkg_status='Awaiting Review',
)
self.assertEqual(len(packages), 0)
def test_packager_list(self):
""" Test the api_packager_list function. """
output = self.app.get('/api/packagers/')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(data, {
"output": "ok",
"packagers": [],
})
output = self.app.get('/api/packagers/pin*/')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(data, {
"output": "ok",
"packagers": [],
})
create_package_acl(self.session)
output = self.app.get('/api/packagers/pin*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()), ['output', 'packagers'])
self.assertEqual(output['output'], 'ok')
self.assertEqual(len(output['packagers']), 1)
self.assertEqual(output['packagers'][0], 'pingou')
def test_get_critpath_packages(self):
""" Test the get_critpath_packages method of PackageListing. """
create_package_acl(self.session)
pkg_list = model.PackageListing.get_critpath_packages(self.session)
self.assertEqual(pkg_list, [])
pkg_list = model.PackageListing.get_critpath_packages(
self.session, branch='devel')
self.assertEqual(pkg_list, [])
create_package_critpath(self.session)
pkg_list = model.PackageListing.get_critpath_packages(self.session)
self.assertEqual(len(pkg_list), 2)
self.assertEqual(
pkg_list[0].point_of_contact, "kernel-maint")
self.assertEqual(
pkg_list[0].collection.branchname, "F-18")
self.assertEqual(
pkg_list[1].point_of_contact, "group::kernel-maint")
self.assertEqual(
pkg_list[1].collection.branchname, "devel")
pkg_list = model.PackageListing.get_critpath_packages(
self.session, branch='devel')
self.assertEqual(len(pkg_list), 1)
self.assertEqual(
pkg_list[0].point_of_contact, "group::kernel-maint")
self.assertEqual(
pkg_list[0].collection.branchname, "devel")
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(pkgdb.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(pkgdb.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_api_critpath_filled(self):
""" Test the api_critpath function with a filled database. """
# Fill the DB
create_package_acl(self.session)
create_package_critpath(self.session)
output = self.app.get('/api/critpath/')
self.assertEqual(output.status_code, 200)
expected = """== devel ==
* kernel
== F-18 ==
* kernel
"""
self.assertEqual(output.data, expected)
output = self.app.get('/api/critpath/?format=random')
self.assertEqual(output.status_code, 200)
self.assertEqual(output.data, expected)
output = self.app.get('/api/critpath/?format=json')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
expected = {
u'pkgs': {
u'F-18': [u"kernel"],
u'devel': [u"kernel"]
},
}
self.assertEqual(data, expected)
def test_api_monitored_filled(self):
""" Test the api_monitored function with a filled database. """
create_package_acl(self.session)
create_package_critpath(self.session)
output = self.app.get('/api/monitored/')
self.assertEqual(output.status_code, 200)
expected = "# Number of packages: 1\nkernel"
self.assertEqual(output.data, expected)
output = self.app.get('/api/monitored/?format=random')
self.assertEqual(output.status_code, 200)
self.assertEqual(output.data, expected)
output = self.app.get('/api/monitored/?format=json')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
expected = {
"total_packages": 1,
"packages": [
"kernel",
],
}
self.assertEqual(data, expected)
output = self.app.get('/api/monitored/',
environ_base={'HTTP_ACCEPT': 'application/json'})
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(data, expected)
def test_stats(self):
""" Test the stats function. """
output = self.app.get('/stats')
self.assertEqual(output.status_code, 301)
output = self.app.get('/stats/')
self.assertEqual(output.status_code, 200)
expected = """<h1>Fedora Package Database</h1>
<p>
PkgDB stores currently information about 0
active Fedora releases.
</p>"""
self.assertTrue(expected in output.data)
create_package_acl(self.session)
output = self.app.get('/stats')
self.assertEqual(output.status_code, 301)
output = self.app.get('/stats/')
self.assertEqual(output.status_code, 200)
expected = """<h1>Fedora Package Database</h1>
<p>
PkgDB stores currently information about 3
active Fedora releases.
</p>"""
self.assertTrue(expected in output.data)
def test_search(self):
""" Test the search function of Package. """
create_package_acl(self.session)
packages = model.Package.search(session=self.session, pkg_name='g%')
self.assertEqual(len(packages), 2)
self.assertEqual(packages[0].name, 'geany')
self.assertEqual(packages[1].name, 'guake')
packages = model.Package.search(session=self.session,
pkg_name='g%',
limit=1)
self.assertEqual(len(packages), 1)
self.assertEqual(packages[0].name, 'geany')
packages = model.Package.search(session=self.session,
pkg_name='g%',
offset=1)
self.assertEqual(len(packages), 1)
self.assertEqual(packages[0].name, 'guake')
packages = model.Package.search(session=self.session,
pkg_name='g%',
count=True)
self.assertEqual(packages, 2)
packages = model.Package.search(session=self.session,
pkg_name='g%',
eol=True,
limit=1)
self.assertEqual(len(packages), 1)
self.assertEqual(packages[0].name, 'geany')
def test_to_json(self):
""" Test the to_json function of PersonPackageListing. """
packager = model.PackageListingAcl.get_acl_packager(
self.session, 'pingou')
self.assertEqual(0, len(packager))
create_package_acl(self.session)
packager = model.PackageListingAcl.get_acl_packager(
self.session, 'pingou')
self.assertEqual(4, len(packager))
output = packager[0].to_json()
self.assertEqual(output,
{
'status': u'Approved',
'acl': 'commit',
'fas_name': u'pingou',
'packagelist': {
'point_of_contact': u'pingou',
'collection': {
'pendingurltemplate': None,
'publishurltemplate': None,
'branchname': u'F-18',
'version': u'18',
'name': u'Fedora'
},
'package': {
'upstreamurl': u'http://guake.org',
'name': u'guake',
'reviewurl': u'https://bugzilla.redhat.com/450189',
'summary': u'Top down terminal for GNOME'
}
}
}
)
def test_packager_list(self):
""" Test the api_packager_list function. """
output = self.app.get('/api/packagers/')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(
data,
{
"output": "ok",
"packagers": [],
}
)
output = self.app.get('/api/packagers/pin*/')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(
data,
{
"output": "ok",
"packagers": [],
}
)
create_package_acl(self.session)
output = self.app.get('/api/packagers/pin*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()),
['output', 'packagers'])
self.assertEqual(output['output'], 'ok')
self.assertEqual(len(output['packagers']), 1)
self.assertEqual(output['packagers'][0], 'pingou')
def test_stats(self):
""" Test the stats function. """
output = self.app.get('/stats')
self.assertEqual(output.status_code, 301)
output = self.app.get('/stats/')
self.assertEqual(output.status_code, 200)
expected = """<h1>Fedora Package Database</h1>
<p>
PkgDB stores currently information about 0
active Fedora releases.
</p>"""
self.assertTrue(expected in output.data)
create_package_acl(self.session)
output = self.app.get('/stats')
self.assertEqual(output.status_code, 301)
output = self.app.get('/stats/')
self.assertEqual(output.status_code, 200)
expected = """<h1>Fedora Package Database</h1>
<p>
PkgDB stores currently information about 3
active Fedora releases.
</p>"""
self.assertTrue(expected in output.data)
def test_get_critpath_packages(self):
""" Test the get_critpath_packages method of PackageListing. """
create_package_acl(self.session)
pkg_list = model.PackageListing.get_critpath_packages(self.session)
self.assertEqual(pkg_list, [])
pkg_list = model.PackageListing.get_critpath_packages(self.session,
branch='master')
self.assertEqual(pkg_list, [])
create_package_critpath(self.session)
pkg_list = model.PackageListing.get_critpath_packages(self.session)
self.assertEqual(len(pkg_list), 2)
self.assertEqual(pkg_list[0].point_of_contact, "kernel-maint")
self.assertEqual(pkg_list[0].collection.branchname, "f18")
self.assertEqual(pkg_list[1].point_of_contact, "group::kernel-maint")
self.assertEqual(pkg_list[1].collection.branchname, "master")
pkg_list = model.PackageListing.get_critpath_packages(self.session,
branch='master')
self.assertEqual(len(pkg_list), 1)
self.assertEqual(pkg_list[0].point_of_contact, "group::kernel-maint")
self.assertEqual(pkg_list[0].collection.branchname, "master")
def test_search_packagers(self):
""" Test the search_packagers function of PackageListing. """
pkg = model.PackageListing.search_packagers(self.session, 'pin%')
self.assertEqual(pkg, [])
create_package_acl(self.session)
pkg = model.PackageListing.search_packagers(self.session, 'pi%')
self.assertEqual(len(pkg), 1)
self.assertEqual(pkg[0][0], 'pingou')
pkg = model.PackageListing.search_packagers(self.session,
'pi%',
count=True)
self.assertEqual(pkg, 1)
pkg = model.PackageListing.search_packagers(self.session,
'pi%',
offset=1)
self.assertEqual(pkg, [])
pkg = model.PackageListing.search_packagers(self.session,
'pi%',
limit=1)
self.assertEqual(len(pkg), 1)
def test_api_package_info(self):
""" Test the api_package_info function. """
output = self.app.get('/api/package/guake/')
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertEqual(
data,
{
"error": "Package: guake not found",
"output": "notok"
}
)
create_package_acl(self.session)
output = self.app.get('/api/package/guake/')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(data.keys(), ['output', 'packages'])
self.assertEqual(len(data['packages']), 2)
self.assertEqual(data['output'], 'ok')
self.assertEqual(data['packages'][0]['collection']['branchname'],
'F-18')
self.assertEqual(data['packages'][0]['point_of_contact'],
'pingou')
self.assertEqual(data['packages'][0]['package']['name'],
'guake')
self.assertEqual(data['packages'][1]['collection']['branchname'],
'devel')
self.assertEqual(data['packages'][1]['point_of_contact'],
'pingou')
self.assertEqual(data['packages'][1]['package']['name'],
'guake')
output = self.app.get('/api/package/?pkg_name=guake&pkg_clt=devel')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(data.keys(), ['output', 'packages'])
self.assertEqual(len(data['packages']), 1)
self.assertEqual(data['output'], 'ok')
self.assertEqual(data['packages'][0]['collection']['branchname'],
'devel')
self.assertEqual(data['packages'][0]['point_of_contact'],
'pingou')
self.assertEqual(data['packages'][0]['package']['name'],
'guake')
output = self.app.get('/api/package/?pkg_name=guake&pkg_clt=F-19')
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data,
{
"error": "Collection F-19 is not associated with package "
"guake",
"output": "notok"
}
)
def test_api_pendingacls_filled(self):
""" Test the api_pendingacls function with a filled database. """
# Fill the DB
create_package_acl(self.session)
create_package_critpath(self.session)
output = self.app.get('/api/pendingacls/')
self.assertEqual(output.status_code, 200)
expected = """# Number of requests pending: 2
guake:master has ralph waiting for approveacls
guake:master has toshio waiting for commit"""
self.assertEqual(output.data, expected)
output = self.app.get('/api/pendingacls/?format=random')
self.assertEqual(output.status_code, 200)
self.assertEqual(output.data, expected)
output = self.app.get('/api/pendingacls/?format=json')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
expected = {
'pending_acls': [
{
'acl': 'approveacls',
'collection': 'master',
'namespace': 'rpms',
'package': 'guake',
'status': 'Awaiting Review',
'user': '******'
},
{
'acl': 'commit',
'collection': 'master',
'namespace': 'rpms',
'package': 'guake',
'status': 'Awaiting Review',
'user': '******'
}
],
'total_requests_pending': 2
}
self.assertEqual(data, expected)
output = self.app.get('/api/pendingacls/?format=json&username=pingou')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(data, expected)
output = self.app.get('/api/pendingacls/?format=json&username=toshio')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
expected = {'pending_acls': [], 'total_requests_pending': 0}
self.assertEqual(data, expected)
def test_has_acls(self):
""" Test the has_acls function. """
self.assertFalse(pkgdblib.has_acls(self.session, 'pingou',
'guake', 'devel', 'approveacl'))
create_package_acl(self.session)
self.assertTrue(pkgdblib.has_acls(self.session, 'pingou',
'guake', 'devel', 'commit'))
def test_search(self):
""" Test the search function. """
output = self.app.get('/search')
self.assertEqual(output.status_code, 301)
output = self.app.get('/search/', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Search packages</h1>' in output.data)
create_package_acl(self.session)
output = self.app.get('/search/?term=g*', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Search packages</h1>' in output.data)
self.assertTrue('<a href="/package/geany/">' in output.data)
self.assertTrue('<a href="/package/guake/">' in output.data)
output = self.app.get('/search/?term=p&type=packager',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Only one packager matching, redirecting '
'you to his/her page</li>' in output.data)
self.assertTrue('pingou</h1> (<a class="fas"' in output.data)
output = self.app.get('/search/?term=g*', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Search packages</h1>' in output.data)
self.assertTrue('<a href="/package/geany/">' in output.data)
self.assertTrue('<a href="/package/guake/">' in output.data)
output = self.app.get('/search/?term=gu*', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Only one package matching, redirecting you'
' to it</li>' in output.data)
self.assertTrue(
'<p property="doap:shortdesc">Top down terminal for GNOME</p>'
in output.data)
output = self.app.get('/search/?term=g*&type=orphaned',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Search packages</h1>' in output.data)
self.assertTrue('<p>0 packages found</p>' in output.data)
expected = '<p>See the list of <a href="/packages/">active</a>\n' \
'or <a href="/retired/">retired</a> packages</p>'
self.assertTrue(expected in output.data)
output = self.app.get('/search/?term=g*&type=retired',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Search packages</h1>' in output.data)
self.assertTrue('<p>0 packages found</p>' in output.data)
expected = '<p>See the list of <a href="/packages/">active</a>\n' \
'or <a href="/orphaned/">orphaned</a> packages</p>'
self.assertTrue(expected in output.data)
def test_search(self):
""" Test the search function. """
output = self.app.get('/search')
self.assertEqual(output.status_code, 301)
output = self.app.get('/search/', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Search packages</h1>' in output.data)
create_package_acl(self.session)
output = self.app.get('/search/?term=g*', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Search packages</h1>' in output.data)
self.assertTrue('<a href="/package/geany/">' in output.data)
self.assertTrue('<a href="/package/guake/">' in output.data)
output = self.app.get('/search/?term=p&type=packager',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Only one packager matching, redirecting '
'you to his/her page</li>' in output.data)
self.assertTrue('pingou</h1> (<a class="fas"' in output.data)
output = self.app.get('/search/?term=g*', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Search packages</h1>' in output.data)
self.assertTrue('<a href="/package/geany/">' in output.data)
self.assertTrue('<a href="/package/guake/">' in output.data)
output = self.app.get('/search/?term=gu*', follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="message">Only one package matching, redirecting you'
' to it</li>' in output.data)
self.assertTrue(
'<p property="doap:shortdesc">Top down terminal for GNOME</p>' in
output.data)
output = self.app.get('/search/?term=g*&type=orphaned',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Search packages</h1>' in output.data)
self.assertTrue('<p>0 packages found</p>' in output.data)
expected = '<p>See the list of <a href="/packages/">active</a>\n' \
'or <a href="/retired/">retired</a> packages</p>'
self.assertTrue(expected in output.data)
output = self.app.get('/search/?term=g*&type=retired',
follow_redirects=True)
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Search packages</h1>' in output.data)
self.assertTrue('<p>0 packages found</p>' in output.data)
expected = '<p>See the list of <a href="/packages/">active</a>\n' \
'or <a href="/orphaned/">orphaned</a> packages</p>'
self.assertTrue(expected in output.data)
def test_get_package_maintained(self):
""" Test the get_package_maintained function. """
create_package_acl(self.session)
pkg = pkgdblib.get_package_maintained(self.session, 'pingou')
self.assertEqual(len(pkg), 1)
self.assertEqual(pkg[0].name, 'guake')
pkg = pkgdblib.get_package_maintained(self.session, 'ralph')
self.assertEqual(pkg, [])
def test_get_package_maintained(self):
""" Test the get_package_maintained function. """
create_package_acl(self.session)
pkg = pkgdblib.get_package_maintained(self.session, 'pingou')
self.assertEqual(len(pkg), 1)
self.assertEqual(pkg[0].name, 'guake')
pkg = pkgdblib.get_package_maintained(self.session, 'ralph')
self.assertEqual(pkg, [])
def test_api_notify_filled(self):
""" Test the api_notify function with a filled database. """
# Filled DB
create_package_acl(self.session)
output = self.app.get('/api/notify/')
self.assertEqual(output.status_code, 200)
expected = """geany|group::gtk-sig
guake|pingou
"""
self.assertEqual(output.data, expected)
output = self.app.get('/api/notify/?format=random')
self.assertEqual(output.status_code, 200)
self.assertEqual(output.data, expected)
output = self.app.get('/api/notify/?format=json')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
expected = {
u'title':
u'Fedora Package Database -- Notification List',
u'packages': [
{
u'geany': [u'group::gtk-sig']
},
{
u'guake': [u'pingou']
},
],
u'name':
None,
u'version':
None,
u'eol':
False
}
self.assertEqual(data, expected)
output = self.app.get('/api/notify/?name=Fedora')
self.assertEqual(output.status_code, 200)
expected = """geany|group::gtk-sig
guake|pingou
"""
self.assertEqual(output.data, expected)
output = self.app.get('/api/notify/?name=Fedora&version=18')
self.assertEqual(output.status_code, 200)
expected = """guake|pingou
"""
self.assertEqual(output.data, expected)
def test_api_package_list(self):
""" Test the api_package_list function. """
output = self.app.get('/api/packages/guake/')
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertEqual(
data,
{
"error": "No packages found for these parameters",
"packages": [],
"output": "notok"
}
)
create_package_acl(self.session)
output = self.app.get('/api/packages/guake/')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(
data.keys(),
['output', 'packages', 'pages_total', 'page'])
self.assertEqual(len(data['packages']), 1)
self.assertEqual(data['output'], 'ok')
self.assertEqual(
data['packages'][0]['name'], 'guake')
self.assertEqual(
data['packages'][0]['status'], 'Approved')
self.assertEqual(
data['packages'][0]['summary'], 'Top down terminal for GNOME')
output = self.app.get('/api/packages/guake/?limit=abc')
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data,
{
"error": "Wrong limit provided",
"output": "notok"
}
)
output = self.app.get('/api/packages/g*/?count=True')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(
data,
{
"output": "ok",
"packages": 2,
"page": 1,
"pages_total": 1,
}
)
def test___repr__(self):
""" Test the __repr__ function of PackageListingAcl. """
create_package_acl(self.session)
packager = model.PackageListingAcl.get_acl_packager(
self.session, 'pingou')
self.assertEqual(5, len(packager))
output = packager[0][0].__repr__()
self.assertEqual(
output, "PackageListingAcl(id:1, u'pingou', "
"PackageListing:1, Acl:commit, Approved)")
def test_has_acls(self):
""" Test the has_acls function. """
self.assertFalse(
pkgdblib.has_acls(self.session, 'pingou', 'guake', 'devel',
'approveacl'))
create_package_acl(self.session)
self.assertTrue(
pkgdblib.has_acls(self.session, 'pingou', 'guake', 'devel',
'commit'))
def test_api_pendingacls_filled(self):
""" Test the api_pendingacls function with a filled database. """
# Fill the DB
create_package_acl(self.session)
create_package_critpath(self.session)
output = self.app.get('/api/pendingacls/')
self.assertEqual(output.status_code, 200)
expected = """# Number of requests pending: 2
guake:master has ralph waiting for approveacls
guake:master has toshio waiting for commit"""
self.assertEqual(output.data, expected)
output = self.app.get('/api/pendingacls/?format=random')
self.assertEqual(output.status_code, 200)
self.assertEqual(output.data, expected)
output = self.app.get('/api/pendingacls/?format=json')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
expected = {
'pending_acls': [{
'acl': 'approveacls',
'collection': 'master',
'package': 'guake',
'status': 'Awaiting Review',
'user': '******'
}, {
'acl': 'commit',
'collection': 'master',
'package': 'guake',
'status': 'Awaiting Review',
'user': '******'
}],
'total_requests_pending':
2
}
self.assertEqual(data, expected)
output = self.app.get('/api/pendingacls/?format=json&username=pingou')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(data, expected)
output = self.app.get('/api/pendingacls/?format=json&username=toshio')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
expected = {'pending_acls': [], 'total_requests_pending': 0}
self.assertEqual(data, expected)
def test___repr__(self):
""" Test the __repr__ function of PackageListingAcl. """
create_package_acl(self.session)
packager = model.PackageListingAcl.get_acl_packager(
self.session, 'pingou')
self.assertEqual(5, len(packager))
output = packager[0][0].__repr__()
self.assertEqual(
output,
"PackageListingAcl(id:1, u'pingou', "
"PackageListing:1, Acl:commit, Approved)")
def test_to_json_acls(self):
""" Test the to_json function of Package with ACLs data. """
create_package_acl(self.session)
package = model.Package.by_name(self.session, 'guake')
package = package.to_json(collection='master')
self.assertEqual(
set(package.keys()),
set(['status', 'upstream_url', 'name', 'summary', 'acls',
'creation_date', 'review_url', 'description']))
self.assertNotEqual(package['acls'], [])
def test_to_json(self):
""" Test the to_json function of PackageListingAcl. """
packager = model.PackageListingAcl.get_acl_packager(
self.session, 'pingou')
self.assertEqual(0, len(packager))
create_package_acl(self.session)
packager = model.PackageListingAcl.get_acl_packager(
self.session, 'pingou')
self.assertEqual(5, len(packager))
output = packager[0][0].to_json()
# Because matching times in tests is hard.
del output['packagelist']['package']['creation_date']
del output['packagelist']['status_change']
output['packagelist']['collection']['date_created'] = 'date_created'
output['packagelist']['collection']['date_updated'] = 'date_updated'
target = {
'status': u'Approved',
'acl': 'commit',
'fas_name': u'pingou',
'packagelist': {
'status': u'Approved',
'point_of_contact': u'pingou',
'critpath': False,
'collection': {
'branchname': u'f18',
'version': u'18',
'name': u'Fedora',
'status': u'Active',
'koji_name': None,
'dist_tag': u'.fc18',
'allow_retire': False,
'date_created': 'date_created',
'date_updated': 'date_updated',
},
'package': {
'upstream_url': u'http://guake.org',
'name': u'guake',
'namespace': u'rpms',
'status': u'Approved',
'review_url': u'https://bugzilla.redhat.com/450189',
'acls': [],
'summary': u'Top down terminal for GNOME',
'description': u'Top down terminal...',
'monitor': False,
'koschei_monitor': False,
}
}
}
self.assertEqual(output, target)
def test_to_json(self):
""" Test the to_json function of PackageListingAcl. """
packager = model.PackageListingAcl.get_acl_packager(
self.session, 'pingou')
self.assertEqual(0, len(packager))
create_package_acl(self.session)
packager = model.PackageListingAcl.get_acl_packager(
self.session, 'pingou')
self.assertEqual(5, len(packager))
output = packager[0][0].to_json()
# Because matching times in tests is hard.
del output['packagelist']['package']['creation_date']
del output['packagelist']['status_change']
output['packagelist']['collection']['date_created'] = 'date_created'
output['packagelist']['collection']['date_updated'] = 'date_updated'
target = {
'status': u'Approved',
'acl': 'commit',
'fas_name': u'pingou',
'packagelist': {
'status': u'Approved',
'point_of_contact': u'pingou',
'critpath': False,
'collection': {
'branchname': u'f18',
'version': u'18',
'name': u'Fedora',
'status': u'Active',
'koji_name': None,
'dist_tag': u'.fc18',
'allow_retire': False,
'date_created': 'date_created',
'date_updated': 'date_updated',
},
'package': {
'upstream_url': u'http://guake.org',
'name': u'guake',
'namespace': u'rpms',
'status': u'Approved',
'review_url': u'https://bugzilla.redhat.com/450189',
'acls': [],
'summary': u'Top down terminal for GNOME',
'description': u'Top down terminal...',
'monitor': False,
'koschei_monitor': False,
}
}
}
self.assertEqual(output, target)
def test_collection_info(self):
""" Test the collection_info function. """
create_package_acl(self.session)
output = self.app.get('/collection/master/')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>Fedora devel</h1>' in output.data)
output = self.app.get('/collection/random/')
self.assertEqual(output.status_code, 200)
self.assertTrue('<li class="errors">No collection of this name '
'found.</li>' in output.data)
def test_api_package_retire3(self, login_func, mock_func):
""" Test a third time the api_package_retire function. """
login_func.return_value = None
create_package_acl(self.session)
mock_func.log.return_value = ''
# Redirect as you are not a packager
user = FakeFasUser()
user.groups = []
# Add the EPEL 7 collection
collection = model.Collection(
name='Fedora EPEL',
version='7',
status='Active',
owner='kevin',
branchname='epel7',
dist_tag='.el7',
)
self.session.add(collection)
self.session.commit()
# Add guake to epel7
guake_pkg = model.Package.by_name(self.session, 'guake')
el7_collec = model.Collection.by_name(self.session, 'epel7')
pkgltg = model.PackageListing(
point_of_contact='orphan',
status='Orphaned',
package_id=guake_pkg.id,
collection_id=el7_collec.id,
)
self.session.add(pkgltg)
self.session.commit()
# Retire an orphaned package on an EPEL branch
user = FakeFasUser()
data = {
'pkgnames': 'guake',
'branches': ['epel7'],
}
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_to_json_acls(self):
""" Test the to_json function of Package with ACLs data. """
create_package_acl(self.session)
package = model.Package.by_name(self.session, 'guake')
package = package.to_json(collection='master')
self.assertEqual(
set(package.keys()),
set(['status', 'upstream_url', 'name', 'summary', 'acls',
'creation_date', 'review_url', 'description', 'monitor',
'koschei_monitor']))
self.assertNotEqual(package['acls'], [])
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_get_acl_packager(self):
""" Test the get_acl_packager function. """
acls = pkgdblib.get_acl_packager(self.session, 'pingou')
self.assertEqual(acls, [])
create_package_acl(self.session)
acls = pkgdblib.get_acl_packager(self.session, 'pingou')
self.assertEqual(len(acls), 4)
self.assertEqual(acls[0].packagelist.package.name, 'guake')
self.assertEqual(acls[0].packagelist.collection.branchname, 'F-18')
self.assertEqual(acls[1].packagelist.collection.branchname, 'F-18')
self.assertEqual(acls[2].packagelist.collection.branchname, 'devel')
self.assertEqual(acls[3].packagelist.collection.branchname, 'devel')
def test_get_acl_packager(self):
""" Test the get_acl_packager function. """
acls = pkgdblib.get_acl_packager(self.session, 'pingou')
self.assertEqual(acls, [])
create_package_acl(self.session)
acls = pkgdblib.get_acl_packager(self.session, 'pingou')
self.assertEqual(len(acls), 4)
self.assertEqual(acls[0].packagelist.package.name, 'guake')
self.assertEqual(acls[0].packagelist.collection.branchname, 'F-18')
self.assertEqual(acls[1].packagelist.collection.branchname, 'F-18')
self.assertEqual(acls[2].packagelist.collection.branchname, 'devel')
self.assertEqual(acls[3].packagelist.collection.branchname, 'devel')
def test_packager_info(self):
""" Test the packager_info function. """
create_package_acl(self.session)
output = self.app.get('/packager/pingou/')
self.assertEqual(output.status_code, 200)
self.assertTrue('pingou</h1>' in output.data)
self.assertTrue('<a href="/package/rpms/guake/">' in output.data)
output = self.app.get('/packager/random/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No packager of this name found.</li>'
in output.data)
def test_api_notify_all_filled(self):
""" Test the api_notify_all function with a filled database. """
# Filled DB
create_package_acl(self.session)
output = self.app.get('/api/notify/all')
self.assertEqual(output.status_code, 200)
expected = """core|josef
geany|group::gtk-sig,josef
guake|pingou
"""
self.assertEqual(output.data, expected)
output = self.app.get('/api/notify/all?format=random')
self.assertEqual(output.status_code, 200)
self.assertEqual(output.data, expected)
output = self.app.get('/api/notify/all?format=json')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
expected = {
u'title': u'Fedora Package Database -- Notification List',
u'packages': {
'core': [u'josef'],
'geany': [u'group::gtk-sig', 'josef'],
'guake': [u'pingou'],
},
u'name': None,
u'version': None,
u'eol': False
}
self.assertEqual(data, expected)
output = self.app.get('/api/notify/all?name=Fedora')
self.assertEqual(output.status_code, 200)
expected = """core|josef
geany|group::gtk-sig,josef
guake|pingou
"""
self.assertEqual(output.data, expected)
output = self.app.get('/api/notify/all?name=Fedora&version=18')
self.assertEqual(output.status_code, 200)
expected = """guake|pingou
"""
self.assertEqual(output.data, expected)
def test_packager_info(self):
""" Test the packager_info function. """
create_package_acl(self.session)
output = self.app.get('/packager/pingou/')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1>pingou</h1>' in output.data)
self.assertTrue('<a href="/package/guake/">' in output.data)
output = self.app.get('/packager/random/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No packager of this name found.</li>'
in output.data)
def test_pending_acl(self, login_func):
""" Test the pending_acl function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/pending/')
self.assertTrue('<table id="pending">' in output.data)
self.assertTrue(
'<a href="/package/rpms/guake/acl/commit/">' in output.data)
self.assertTrue(
'<input type="submit" value="Update"/>' in output.data)
def test_api_critpath_filled(self):
""" Test the api_critpath function with a filled database. """
# Fill the DB
create_package_acl(self.session)
create_package_critpath(self.session)
output = self.app.get('/api/critpath/')
self.assertEqual(output.status_code, 200)
expected = """== master ==
* kernel
== f18 ==
* kernel
"""
self.assertEqual(output.data, expected)
output = self.app.get('/api/critpath/?format=random')
self.assertEqual(output.status_code, 200)
self.assertEqual(output.data, expected)
output = self.app.get('/api/critpath/?format=json')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
expected = {
u'pkgs': {
u'f18': [
u"kernel"
],
u'master': [
u"kernel"
]
},
}
self.assertEqual(data, expected)
output = self.app.get('/api/critpath/?format=json&branches=master')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
expected = {
u'pkgs': {
u'master': [
u"kernel"
]
},
}
self.assertEqual(data, expected)
def test_pending_acl(self, login_func):
""" Test the pending_acl function. """
login_func.return_value = None
create_package_acl(self.session)
user = FakeFasUser()
with user_set(pkgdb2.APP, user):
output = self.app.get('/acl/pending/')
self.assertTrue('<table id="pending">' in output.data)
self.assertTrue(
'<a href="/package/guake/acl/commit/">' in output.data)
self.assertTrue(
'<input type="submit" value="Update"/>' in output.data)
def test_get_pending_acl_user(self):
""" Test the get_pending_acl_user function. """
pending_acls = pkgdblib.get_pending_acl_user(
self.session, 'pingou')
self.assertEqual(pending_acls, [])
create_package_acl(self.session)
pending_acls = pkgdblib.get_pending_acl_user(
self.session, 'pingou')
self.assertEqual(len(pending_acls), 1)
self.assertEqual(pending_acls[0]['package'], 'guake')
self.assertEqual(pending_acls[0]['collection'], 'devel')
self.assertEqual(pending_acls[0]['acl'], 'commit')
self.assertEqual(pending_acls[0]['status'], 'Awaiting Review')
def test_api_package_info(self):
""" Test the api_package_info function. """
output = self.app.get('/api/package/guake/')
self.assertEqual(output.status_code, 404)
data = json.loads(output.data)
self.assertEqual(data, {
"error": "Package: guake not found",
"output": "notok"
})
create_package_acl(self.session)
output = self.app.get('/api/package/guake/')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(data.keys(), ['output', 'packages'])
self.assertEqual(len(data['packages']), 2)
self.assertEqual(data['output'], 'ok')
self.assertEqual(data['packages'][0]['collection']['branchname'],
'F-18')
self.assertEqual(data['packages'][0]['point_of_contact'], 'pingou')
self.assertEqual(data['packages'][0]['package']['name'], 'guake')
self.assertEqual(data['packages'][1]['collection']['branchname'],
'devel')
self.assertEqual(data['packages'][1]['point_of_contact'], 'pingou')
self.assertEqual(data['packages'][1]['package']['name'], 'guake')
output = self.app.get('/api/package/?pkg_name=guake&pkg_clt=devel')
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(data.keys(), ['output', 'packages'])
self.assertEqual(len(data['packages']), 1)
self.assertEqual(data['output'], 'ok')
self.assertEqual(data['packages'][0]['collection']['branchname'],
'devel')
self.assertEqual(data['packages'][0]['point_of_contact'], 'pingou')
self.assertEqual(data['packages'][0]['package']['name'], 'guake')
output = self.app.get('/api/package/?pkg_name=guake&pkg_clt=F-19')
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data, {
"error": "Collection F-19 is not associated with package "
"guake",
"output": "notok"
})
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_info(self):
""" Test the package_info function. """
create_package_acl(self.session)
output = self.app.get('/package/geany/')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1 property="doap:name">geany</h1>' in output.data)
self.assertTrue('<h3>Fedora 18</h3>' in output.data)
self.assertTrue('<a href="/packager/pingou/">' in output.data)
self.assertTrue('<a href="/packager/group::gtk-sig/">' in output.data)
output = self.app.get('/package/random/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>'
in output.data)
def test_package_info(self):
""" Test the package_info function. """
create_package_acl(self.session)
output = self.app.get('/package/geany/')
self.assertEqual(output.status_code, 200)
self.assertTrue('<h1 property="doap:name">geany</h1>' in output.data)
self.assertTrue('<h3>Fedora 18</h3>' in output.data)
self.assertTrue('<a href="/packager/pingou/">' in output.data)
self.assertTrue('<a href="/packager/group::gtk-sig/">' in output.data)
output = self.app.get('/package/random/')
self.assertEqual(output.status_code, 200)
self.assertTrue(
'<li class="errors">No package of this name found.</li>' in
output.data)
def test_by_collectionid(self):
""" Test the by_collectionid method of PackageListing. """
create_package_acl(self.session)
# Collection 2 == F-18
pkg_list = model.PackageListing.by_collectionid(self.session, 2)
self.assertEqual(len(pkg_list), 3)
self.assertEqual(pkg_list[0].collection.branchname, 'F-18')
self.assertEqual(pkg_list[1].collection.branchname, 'F-18')
self.assertEqual(pkg_list[2].collection.branchname, 'F-18')
# Collection 3 == devel
pkg_list = model.PackageListing.by_collectionid(self.session, 3)
self.assertEqual(len(pkg_list), 3)
self.assertEqual(pkg_list[0].collection.branchname, 'devel')
self.assertEqual(pkg_list[1].collection.branchname, 'devel')
