def test_collection_status(self):
""" Test the api_collection_status function. """
output = self.app.post('/api/collection/F-18/status/')
self.assertEqual(output.status_code, 500)
self.assertEqual(output.data,
'{\n "output": "notok",\n '
'"error_detail": [\n '
'"collection_status: Not a valid choice",\n '
'"collection_branchname: This field is required."'
'\n ],\n "error": "Invalid input submitted"\n}')
data = {'collection_branchname': 'F-18',
'collection_status' : 'EOL'}
output = self.app.post('/api/collection/F-19/status/', data=data)
self.assertEqual(output.status_code, 500)
self.assertEqual(output.data,
'{\n "output": "notok",\n '
'"error": "You\'re trying to update the wrong '
'collection"\n}')
data = {'collection_branchname': 'F-18',
'collection_status' : 'EOL'}
output = self.app.post('/api/collection/F-18/status', data=data)
self.assertEqual(output.status_code, 500)
self.assertEqual(output.data,
'{\n "output": "notok",\n '
'"error": "You are now allowed to edit collections"\n}')
create_collection(self.session)
def test_api_repr(self):
""" Test the api_repr function of Collection. """
create_collection(self.session)
collection = model.Collection.by_name(self.session, 'F-18')
collection = collection.api_repr(1)
self.assertEqual(collection.keys(), ['pendingurltemplate',
'publishurltemplate', 'version', 'name'])
def test_to_json(self):
""" Test the to_json function of Collection. """
create_collection(self.session)
collection = model.Collection.by_name(self.session, 'F-18')
collection = collection.to_json()
self.assertEqual(set(collection.keys()),
set(['branchname', 'version', 'name', 'status']))
def test_collection_list(self):
""" Test the api_collection_list function. """
output = self.app.get('/api/collections/F-*')
self.assertEqual(output.status_code, 200)
output = self.app.get('/api/collections/F-*/')
self.assertEqual(output.status_code, 200)
self.assertEqual(output.data, '{\n "collections": []\n}')
output = self.app.get('/api/collections/F-*/')
self.assertEqual(output.status_code, 200)
self.assertEqual(output.data, '{\n "collections": []\n}')
create_collection(self.session)
output = self.app.get('/api/collections/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output.keys(), ['collections'])
self.assertEqual(len(output['collections']), 4)
self.assertEqual(set(output['collections'][0].keys()),
set(['branchname', 'version', 'name', 'status']))
output = self.app.get('/api/collections/F-*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output.keys(), ['collections'])
self.assertEqual(set(output['collections'][0].keys()),
set(['branchname', 'version', 'name', 'status']))
self.assertEqual(len(output['collections']), 2)
self.assertEqual(output['collections'][0]['name'], 'Fedora')
self.assertEqual(output['collections'][0]['version'], '17')
def test_search(self):
""" Test the search function of Collection. """
create_collection(self.session)
collections = model.Collection.search(self.session, 'EPEL%')
self.assertEqual(len(collections), 0)
collections = model.Collection.search(self.session, 'F-%', 'Active')
self.assertEqual("Collection(u'Fedora', u'17', u'Active', u'toshio', "
"publishurltemplate=None, pendingurltemplate=None,"
" summary=u'Fedora 17 release', description=None)",
collections[0].__repr__())
collections = model.Collection.search(self.session, 'F-%')
self.assertEqual(2, len(collections))
cnt = model.Collection.search(self.session, 'F-%', count=True)
self.assertEqual(2, cnt)
collections = model.Collection.search(
session=self.session,
clt_name='F-%',
offset=1)
self.assertEqual(1, len(collections))
collections = model.Collection.search(
session=self.session,
clt_name='F-%',
limit=1)
self.assertEqual(1, len(collections))
def test_search(self):
""" Test the search function of Collection. """
create_collection(self.session)
collections = model.Collection.search(self.session, 'EPEL%')
self.assertEqual(len(collections), 0)
collections = model.Collection.search(self.session, 'f%', 'Active')
self.assertEqual("Collection(u'Fedora', u'17', u'Active', "
"owner:u'toshio')",
collections[0].__repr__())
collections = model.Collection.search(self.session, 'f%')
self.assertEqual(2, len(collections))
cnt = model.Collection.search(self.session, 'f%', count=True)
self.assertEqual(2, cnt)
collections = model.Collection.search(
session=self.session,
clt_name='f%',
offset=1)
self.assertEqual(1, len(collections))
collections = model.Collection.search(
session=self.session,
clt_name='f%',
limit=1)
self.assertEqual(1, len(collections))
def test_collection_status(self):
""" Test the api_collection_status function. """
output = self.app.post('/api/collection/F-18/status/')
self.assertEqual(output.status_code, 500)
self.assertEqual(
output.data, '{\n "output": "notok",\n '
'"error_detail": [\n '
'"collection_status: Not a valid choice",\n '
'"collection_branchname: This field is required."'
'\n ],\n "error": "Invalid input submitted"\n}')
data = {'collection_branchname': 'F-18', 'collection_status': 'EOL'}
output = self.app.post('/api/collection/F-19/status/', data=data)
self.assertEqual(output.status_code, 500)
self.assertEqual(
output.data, '{\n "output": "notok",\n '
'"error": "You\'re trying to update the wrong '
'collection"\n}')
data = {'collection_branchname': 'F-18', 'collection_status': 'EOL'}
output = self.app.post('/api/collection/F-18/status', data=data)
self.assertEqual(output.status_code, 500)
self.assertEqual(
output.data, '{\n "output": "notok",\n '
'"error": "You are now allowed to edit collections"\n}')
create_collection(self.session)
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_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_search(self):
""" Test the search function of Collection. """
create_collection(self.session)
collections = model.Collection.search(self.session, 'EPEL%')
self.assertEqual(len(collections), 0)
collections = model.Collection.search(self.session, 'F-%', 'Active')
self.assertEqual(
"Collection(u'Fedora', u'17', u'Active', u'toshio', "
"publishurltemplate=None, pendingurltemplate=None,"
" summary=u'Fedora 17 release', description=None)",
collections[0].__repr__())
collections = model.Collection.search(self.session, 'F-%')
self.assertEqual(2, len(collections))
cnt = model.Collection.search(self.session, 'F-%', count=True)
self.assertEqual(2, cnt)
collections = model.Collection.search(session=self.session,
clt_name='F-%',
offset=1)
self.assertEqual(1, len(collections))
collections = model.Collection.search(session=self.session,
clt_name='F-%',
limit=1)
self.assertEqual(1, len(collections))
def test_api_repr(self):
""" Test the api_repr function of Collection. """
create_collection(self.session)
collection = model.Collection.by_name(self.session, 'F-18')
collection = collection.api_repr(1)
self.assertEqual(
collection.keys(),
['pendingurltemplate', 'publishurltemplate', 'version', 'name'])
def test_to_json(self):
""" Test the to_json function of Collection. """
create_collection(self.session)
collection = model.Collection.by_name(self.session, 'F-18')
collection = collection.to_json()
self.assertEqual(
set(collection.keys()), set(['branchname', 'version',
'name', 'status']))
def test_repr_collection(self):
""" Test the __repr__ function of Collection. """
create_collection(self.session)
collections = model.Collection.all(self.session)
self.assertEqual(collections[0].branchname, 'el6')
self.assertEqual("Collection(u'Fedora', u'17', u'Active', "
"owner:u'toshio')",
collections[1].__repr__())
self.assertEqual(collections[2].branchname, 'F-18')
def test_repr_collection(self):
""" Test the __repr__ function of Collection. """
create_collection(self.session)
collections = model.Collection.all(self.session)
self.assertEqual(collections[0].branchname, 'el6')
self.assertEqual(
"Collection(u'Fedora', u'17', u'Active', "
"owner:u'toshio')", collections[1].__repr__())
self.assertEqual(collections[2].branchname, 'F-18')
def test_repr_collection(self):
""" Test the __repr__ function of Collection. """
create_collection(self.session)
collections = model.Collection.all(self.session)
self.assertEqual("Collection(u'Fedora', u'17', u'Active', u'toshio', "
"publishurltemplate=None, pendingurltemplate=None,"
" summary=u'Fedora 17 release', description=None)",
collections[0].__repr__())
self.assertEqual(collections[0].branchname, 'F-17')
self.assertEqual(collections[1].branchname, 'F-18')
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_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)
# 2 actions = 2 pages
self.assertTrue('<td>1 / 2</td>' in output.data)
# Reset the pagination
pkgdb2.APP.config['ITEMS_PER_PAGE'] = 50
def test_repr_collection(self):
""" Test the __repr__ function of Collection. """
create_collection(self.session)
collections = model.Collection.all(self.session)
self.assertEqual(
"Collection(u'Fedora', u'17', u'Active', u'toshio', "
"publishurltemplate=None, pendingurltemplate=None,"
" summary=u'Fedora 17 release', description=None)",
collections[0].__repr__())
self.assertEqual(collections[0].branchname, 'F-17')
self.assertEqual(collections[1].branchname, 'F-18')
def test_to_json(self):
""" Test the to_json function of Collection. """
create_collection(self.session)
collection = model.Collection.by_name(self.session, 'f18')
collection = collection.to_json()
self.assertEqual(
sorted(collection.keys()),
sorted([
'allow_retire', 'branchname', 'date_created', 'date_updated',
'dist_tag', 'koji_name', 'name', 'status', 'version' ]
)
)
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_list(self):
""" Test the api_collection_list function. """
output = self.app.get('/api/collections/f*')
self.assertEqual(output.status_code, 200)
output = self.app.get('/api/collections/f*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output, {"collections": [], "output": "ok"})
output = self.app.get('/api/collections/f*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output, {"collections": [], "output": "ok"})
create_collection(self.session)
output = self.app.get('/api/collections/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()), ['collections', 'output'])
self.assertEqual(len(output['collections']), 5)
self.assertEqual(
set(output['collections'][0].keys()),
set([
'branchname', 'version', 'name', 'status', 'dist_tag',
'koji_name'
]))
output = self.app.get('/api/collections/f*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()), ['collections', 'output'])
self.assertEqual(
set(output['collections'][0].keys()),
set([
'branchname', 'version', 'name', 'status', 'dist_tag',
'koji_name'
]))
self.assertEqual(len(output['collections']), 2)
self.assertEqual(output['collections'][0]['name'], 'Fedora')
self.assertEqual(output['collections'][0]['version'], '17')
output = self.app.get('/api/collections/f*/?clt_status=EOL')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()), ['collections', 'output'])
self.assertEqual(output['collections'], [])
def test_collection_list(self):
""" Test the api_collection_list function. """
output = self.app.get('/api/collections/f*')
self.assertEqual(output.status_code, 200)
output = self.app.get('/api/collections/f*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output,
{"collections": [], "output": "ok"})
output = self.app.get('/api/collections/f*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output,
{"collections": [], "output": "ok"})
create_collection(self.session)
output = self.app.get('/api/collections/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()),
['collections', 'output'])
self.assertEqual(len(output['collections']), 5)
self.assertEqual(set(output['collections'][0].keys()),
set(['branchname', 'version', 'name', 'status',
'dist_tag', 'koji_name']))
output = self.app.get('/api/collections/f*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()),
['collections', 'output'])
self.assertEqual(set(output['collections'][0].keys()),
set(['branchname', 'version', 'name', 'status',
'dist_tag', 'koji_name']))
self.assertEqual(len(output['collections']), 2)
self.assertEqual(output['collections'][0]['name'], 'Fedora')
self.assertEqual(output['collections'][0]['version'], '17')
output = self.app.get('/api/collections/f*/?clt_status=EOL')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()),
['collections', 'output'])
self.assertEqual(output['collections'], [])
def test_collection_list(self):
""" Test the api_collection_list function. """
output = self.app.get("/api/collections/f*")
self.assertEqual(output.status_code, 200)
output = self.app.get("/api/collections/f*/")
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output, {"collections": [], "output": "ok"})
output = self.app.get("/api/collections/f*/")
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output, {"collections": [], "output": "ok"})
create_collection(self.session)
output = self.app.get("/api/collections/")
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()), ["collections", "output"])
self.assertEqual(len(output["collections"]), 5)
self.assertEqual(
set(output["collections"][0].keys()),
set(["branchname", "version", "name", "status", "dist_tag", "koji_name"]),
)
output = self.app.get("/api/collections/f*/")
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()), ["collections", "output"])
self.assertEqual(
set(output["collections"][0].keys()),
set(["branchname", "version", "name", "status", "dist_tag", "koji_name"]),
)
self.assertEqual(len(output["collections"]), 2)
self.assertEqual(output["collections"][0]["name"], "Fedora")
self.assertEqual(output["collections"][0]["version"], "17")
output = self.app.get("/api/collections/f*/?clt_status=EOL")
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()), ["collections", "output"])
self.assertEqual(output["collections"], [])
def test_search_collection(self):
""" Test the search_collection function. """
create_collection(self.session)
collections = pkgdblib.search_collection(self.session, 'EPEL*')
self.assertEqual(len(collections), 0)
collections = pkgdblib.search_collection(self.session, 'F-*',
status='EOL')
self.assertEqual(len(collections), 0)
collections = pkgdblib.search_collection(self.session, 'F-*')
self.assertEqual(len(collections), 2)
self.assertEqual("Collection(u'Fedora', u'17', u'Active', u'toshio', "
"publishurltemplate=None, pendingurltemplate=None,"
" summary=u'Fedora 17 release', description=None)",
collections[0].__repr__())
collections = pkgdblib.search_collection(
self.session,
'F-*',
limit=1)
self.assertEqual(len(collections), 1)
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.search_collection,
self.session,
'F-*',
limit='a'
)
collections = pkgdblib.search_collection(
self.session,
'F-*',
limit=1,
page=2)
self.assertEqual(len(collections), 1)
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.search_collection,
self.session,
'F-*',
page='a'
)
def test_search_collection(self):
""" Test the search_collection function. """
create_collection(self.session)
collections = pkgdblib.search_collection(self.session, 'EPEL*')
self.assertEqual(len(collections), 0)
collections = pkgdblib.search_collection(self.session,
'F-*',
status='EOL')
self.assertEqual(len(collections), 0)
collections = pkgdblib.search_collection(self.session, 'F-*')
self.assertEqual(len(collections), 2)
self.assertEqual(
"Collection(u'Fedora', u'17', u'Active', u'toshio', "
"publishurltemplate=None, pendingurltemplate=None,"
" summary=u'Fedora 17 release', description=None)",
collections[0].__repr__())
collections = pkgdblib.search_collection(self.session, 'F-*', limit=1)
self.assertEqual(len(collections), 1)
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.search_collection,
self.session,
'F-*',
limit='a')
collections = pkgdblib.search_collection(self.session,
'F-*',
limit=1,
page=2)
self.assertEqual(len(collections), 1)
self.assertRaises(pkgdblib.PkgdbException,
pkgdblib.search_collection,
self.session,
'F-*',
page='a')
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_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_collection_list(self):
""" Test the api_collection_list function. """
output = self.app.get('/api/collections/F-*')
self.assertEqual(output.status_code, 200)
output = self.app.get('/api/collections/F-*/')
self.assertEqual(output.status_code, 200)
self.assertEqual(output.data,
'{\n "collections": []\n}')
output = self.app.get('/api/collections/F-*/')
self.assertEqual(output.status_code, 200)
self.assertEqual(output.data,
'{\n "collections": []\n}')
create_collection(self.session)
output = self.app.get('/api/collections/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output.keys(),
['collections'])
self.assertEqual(len(output['collections']), 4)
self.assertEqual(output['collections'][0].keys(),
['pendingurltemplate', 'publishurltemplate',
'version', 'name'])
output = self.app.get('/api/collections/F-*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output.keys(),
['collections'])
self.assertEqual(output['collections'][0].keys(),
['pendingurltemplate', 'publishurltemplate',
'version', 'name'])
self.assertEqual(len(output['collections']), 2)
self.assertEqual(output['collections'][0]['name'], 'Fedora')
self.assertEqual(output['collections'][0]['version'], '17')
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_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_init_collection(self):
""" Test the __init__ function of Collection. """
create_collection(self.session)
self.assertEqual(5, len(model.Collection.all(self.session)))
def test_collection_list(self):
""" Test the api_collection_list function. """
output = self.app.get('/api/collections/f*')
self.assertEqual(output.status_code, 200)
output = self.app.get('/api/collections/f*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output,
{"collections": [], "output": "ok"})
output = self.app.get('/api/collections/f*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output,
{"collections": [], "output": "ok"})
create_collection(self.session)
output = self.app.get('/api/collections/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()),
['collections', 'output'])
self.assertEqual(len(output['collections']), 5)
self.assertEqual(sorted(output['collections'][0].keys()),
sorted([
'allow_retire', 'branchname', 'date_created', 'date_updated',
'dist_tag', 'koji_name', 'name', 'status', 'version' ]))
output = self.app.get('/api/collections/f*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()),
['collections', 'output'])
self.assertEqual(sorted(output['collections'][0].keys()),
sorted([
'allow_retire', 'branchname', 'date_created', 'date_updated',
'dist_tag', 'koji_name', 'name', 'status', 'version' ]))
self.assertEqual(len(output['collections']), 2)
self.assertEqual(output['collections'][0]['name'], 'Fedora')
self.assertEqual(output['collections'][0]['version'], '17')
output = self.app.get('/api/collections/f*/?clt_status=EOL')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()),
['collections', 'output'])
self.assertEqual(output['collections'], [])
output = self.app.get('/api/collections/?clt_status=EOL')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()),
['collections', 'output'])
self.assertEqual(len(output['collections']), 1)
jdata = output['collections'][0]
jdata['date_created'] = 'date_created'
jdata['date_updated'] = 'date_updated'
self.assertEqual(
jdata,
{
'status': 'EOL',
'date_created': 'date_created',
'date_updated': 'date_updated',
'dist_tag': '.el4',
'koji_name': None,
'name': 'Fedora EPEL',
'allow_retire': False,
'version': '4',
'branchname': 'el4',
}
)
output = self.app.get('/api/collections/?clt_status=Active')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()),
['collections', 'output'])
self.assertEqual(len(output['collections']), 3)
output = self.app.get('/api/collections/?clt_status=Under Development')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()),
['collections', 'output'])
self.assertEqual(len(output['collections']), 1)
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_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(pkgdb.APP, user):
output = self.app.post('/api/collection/F-18/status/')
self.assertEqual(output.status_code, 302)
user = FakeFasUserAdmin()
with user_set(pkgdb.APP, user):
output = self.app.post('/api/collection/F-18/status/')
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data,
{
"output": "notok",
"error_detail": [
"collection_status: Not a valid choice",
"collection_branchname: This field is required.",
],
"error": "Invalid input submitted",
}
)
data = {'collection_branchname': 'F-18',
'collection_status' : 'EOL'}
with user_set(pkgdb.APP, user):
output = self.app.post('/api/collection/F-19/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 = {'collection_branchname': 'F-18',
'collection_status' : 'EOL'}
with user_set(pkgdb.APP, user):
output = self.app.post('/api/collection/F-18/status', data=data)
self.assertEqual(output.status_code, 500)
data = json.loads(output.data)
self.assertEqual(
data,
{
"output": "notok",
"error": 'Could not find collection "F-18"',
}
)
create_collection(self.session)
data = {'collection_branchname': 'F-18',
'collection_status' : 'EOL'}
with user_set(pkgdb.APP, user):
output = self.app.post('/api/collection/F-18/status', data=data)
self.assertEqual(output.status_code, 200)
data = json.loads(output.data)
self.assertEqual(
data,
{
"output": "ok",
"messages": ['Collection updated to \"EOL\"'],
}
)
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_orphan_group_package(self, bz_owner):
""" Test the is_pkgdb_admin function of pkgdb2. """
bz_owner.return_value = None
create_collection(self.session)
create_package(self.session)
guake_pkg = model.Package.by_name(self.session, 'guake')
fedocal_pkg = model.Package.by_name(self.session, 'fedocal')
f18_collec = model.Collection.by_name(self.session, 'f18')
devel_collec = model.Collection.by_name(self.session, 'master')
# Pkg: guake - Collection: master - Approved
pkgltg = model.PackageListing(
point_of_contact='group::infra-sig',
status='Approved',
package_id=guake_pkg.id,
collection_id=devel_collec.id,
)
self.session.add(pkgltg)
# Pkg: guake - Collection: f18 - Approved
pkgltg = model.PackageListing(
point_of_contact='pingou',
status='Approved',
package_id=guake_pkg.id,
collection_id=f18_collec.id,
)
self.session.add(pkgltg)
# Pkg: fedocal - Collection: master - Approved
pkgltg = model.PackageListing(
point_of_contact='group::infra-sig',
status='Approved',
package_id=fedocal_pkg.id,
collection_id=devel_collec.id,
)
self.session.add(pkgltg)
user = FakeFasUser()
# Orphan allowed (?)
msg = pkgdblib.update_pkg_status(
self.session, pkg_name='fedocal', pkg_branch='master',
status='Orphaned', user=user, poc='orphan')
self.assertEqual(
msg,
'user: pingou updated package: fedocal status from: Approved to '
'Orphaned on branch: master')
# Retired blocked
msg = pkgdblib.update_pkg_status(
self.session, pkg_name='guake', pkg_branch='master',
status='Retired', user=user, poc='orphan')
self.assertEqual(
msg,
'user: pingou updated package: guake status from: Approved to '
'Retired on branch: master')
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_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_list(self):
""" Test the api_collection_list function. """
output = self.app.get('/api/collections/f*')
self.assertEqual(output.status_code, 200)
output = self.app.get('/api/collections/f*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output, {"collections": [], "output": "ok"})
output = self.app.get('/api/collections/f*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(output, {"collections": [], "output": "ok"})
create_collection(self.session)
output = self.app.get('/api/collections/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()), ['collections', 'output'])
self.assertEqual(len(output['collections']), 5)
self.assertEqual(
sorted(output['collections'][0].keys()),
sorted([
'allow_retire', 'branchname', 'date_created', 'date_updated',
'dist_tag', 'koji_name', 'name', 'status', 'version'
]))
output = self.app.get('/api/collections/f*/')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()), ['collections', 'output'])
self.assertEqual(
sorted(output['collections'][0].keys()),
sorted([
'allow_retire', 'branchname', 'date_created', 'date_updated',
'dist_tag', 'koji_name', 'name', 'status', 'version'
]))
self.assertEqual(len(output['collections']), 2)
self.assertEqual(output['collections'][0]['name'], 'Fedora')
self.assertEqual(output['collections'][0]['version'], '17')
output = self.app.get('/api/collections/f*/?clt_status=EOL')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()), ['collections', 'output'])
self.assertEqual(output['collections'], [])
output = self.app.get('/api/collections/?clt_status=EOL')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()), ['collections', 'output'])
self.assertEqual(len(output['collections']), 1)
jdata = output['collections'][0]
jdata['date_created'] = 'date_created'
jdata['date_updated'] = 'date_updated'
self.assertEqual(
jdata, {
'status': 'EOL',
'date_created': 'date_created',
'date_updated': 'date_updated',
'dist_tag': '.el4',
'koji_name': None,
'name': 'Fedora EPEL',
'allow_retire': False,
'version': '4',
'branchname': 'el4',
})
output = self.app.get('/api/collections/?clt_status=Active')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()), ['collections', 'output'])
self.assertEqual(len(output['collections']), 3)
output = self.app.get('/api/collections/?clt_status=Under Development')
self.assertEqual(output.status_code, 200)
output = json.loads(output.data)
self.assertEqual(sorted(output.keys()), ['collections', 'output'])
self.assertEqual(len(output['collections']), 1)
