def test_create_override(self):
release = Release.get('F17')
package = RpmPackage(name='not-bodhi')
self.db.add(package)
build = RpmBuild(nvr='not-bodhi-2.0-2.fc17',
package=package,
release=release)
self.db.add(build)
self.db.flush()
expiration_date = datetime.utcnow() + timedelta(days=1)
data = {
'nvr': build.nvr,
'notes': 'blah blah blah',
'expiration_date': expiration_date,
'csrf_token': self.get_csrf_token()
}
with fml_testing.mock_sends(override_schemas.BuildrootOverrideTagV1):
res = self.app.post('/overrides/', data)
o = res.json_body
assert o['build_id'] == build.id
assert o['notes'] == 'blah blah blah'
assert o['expiration_date'] == expiration_date.strftime(
"%Y-%m-%d %H:%M:%S")
assert o['expired_date'] is None
def get_update_counts(releaseid):
"""
Return counts for the various states and types of updates in the given release.
This function returns a dictionary that tabulates the counts of the various
types of Bodhi updates at the various states they can appear in. The
dictionary has the following keys, with pretty self-explanatory names:
pending_updates_total
testing_updates_total
stable_updates_total
Args:
releaseid (str): The id of the Release object you would like the counts performed on
Returns:
dict: A dictionary expressing the counts, as described above.
"""
release = Release.get(releaseid)
basequery = Update.query.filter(Update.release == release)
counts = {}
counts.update(_get_status_counts(basequery, UpdateStatus.pending))
counts.update(_get_status_counts(basequery, UpdateStatus.testing))
counts.update(_get_status_counts(basequery, UpdateStatus.stable))
return counts
def test_edit_unexisting_override(self):
release = Release.get(u'F17', self.db)
build = RpmBuild(
nvr=u'bodhi-2.0-2.fc17',
release=release,
package=RpmPackage.query.filter_by(name='bodhi').one())
self.db.add(build)
self.db.flush()
expiration_date = datetime.utcnow() + timedelta(days=1)
o = {
'nvr': build.nvr,
'notes': 'blah blah blah',
'expiration_date': expiration_date,
'edited': build.nvr,
'csrf_token': self.get_csrf_token(),
}
res = self.app.post('/overrides/', o, status=400)
errors = res.json_body['errors']
self.assertEquals(len(errors), 1)
self.assertEquals(errors[0]['name'], 'edited')
self.assertEquals(errors[0]['description'],
'No buildroot override for this build')
def test_create_duplicate_override(self):
"""When creating a duplicate override, old notes are appended."""
release = Release.get('F17')
package = RpmPackage(name='not-bodhi')
self.db.add(package)
build = RpmBuild(nvr='not-bodhi-2.0-2.fc17', package=package, release=release)
self.db.add(build)
self.db.flush()
expiration_date = datetime.utcnow() + timedelta(days=1)
data = {'nvr': build.nvr, 'notes': 'blah blah blah',
'expiration_date': expiration_date,
'csrf_token': self.get_csrf_token()}
with fml_testing.mock_sends(override_schemas.BuildrootOverrideTagV1):
res = self.app.post('/overrides/', data)
o = res.json_body
assert o['build_id'] == build.id
assert o['notes'] == 'blah blah blah'
assert o['expiration_date'] == expiration_date.strftime("%Y-%m-%d %H:%M:%S")
assert o['expired_date'] is None
# Submit it again
data['notes'] = 'new blah blah'
res = self.app.post('/overrides/', data)
o = res.json_body
new_notes = f"""new blah blah
_____________
_@guest ({datetime.utcnow().strftime('%b %d, %Y')})_
blah blah blah"""
assert o['notes'] == new_notes
def test_create_override_for_build_with_test_gating_status_failed(self):
"""
Test that Override is not created when the test gating status is failed.
"""
release = Release.get('F17')
package = RpmPackage(name='not-bodhi')
self.db.add(package)
build = RpmBuild(nvr='not-bodhi-2.0-2.fc17', package=package, release=release)
update = Update.query.first()
update.builds.append(build)
update.test_gating_status = TestGatingStatus.failed
self.db.add(build)
self.db.flush()
expiration_date = datetime.utcnow() + timedelta(days=1)
data = {'nvr': build.nvr, 'notes': 'blah blah blah',
'expiration_date': expiration_date,
'csrf_token': self.get_csrf_token()}
with fml_testing.mock_sends():
res = self.app.post('/overrides/', data, status=400)
errors = res.json_body['errors']
self.assertEqual(len(errors), 1)
self.assertEqual(errors[0]['name'], 'nvr')
self.assertEqual(errors[0]['description'],
"Cannot create a buildroot override if "
"build's test gating status is failed.")
def test_cannot_edit_override_build(self):
release = Release.get('F17')
old_nvr = 'bodhi-2.0-1.fc17'
res = self.app.get('/overrides/%s' % old_nvr,
headers={'Accept': 'application/json'})
o = res.json_body['override']
expiration_date = o['expiration_date']
old_build_id = o['build_id']
build = RpmBuild(nvr='bodhi-2.0-2.fc17', release=release,
package=RpmPackage.query.filter_by(name='bodhi').one())
self.db.add(build)
self.db.flush()
o.update({
'nvr': build.nvr,
'edited': old_nvr,
'csrf_token': self.get_csrf_token(),
})
with fml_testing.mock_sends():
res = self.app.post('/overrides/', o)
override = res.json_body
self.assertEqual(override['build_id'], old_build_id)
self.assertEqual(override['notes'], 'blah blah blah')
self.assertEqual(override['expiration_date'], expiration_date)
self.assertEqual(override['expired_date'], None)
def test_create_duplicate_override(self):
release = Release.get('F17')
package = RpmPackage(name='not-bodhi')
self.db.add(package)
build = RpmBuild(nvr='not-bodhi-2.0-2.fc17', package=package, release=release)
self.db.add(build)
self.db.flush()
expiration_date = datetime.utcnow() + timedelta(days=1)
data = {'nvr': build.nvr, 'notes': 'blah blah blah',
'expiration_date': expiration_date,
'csrf_token': self.get_csrf_token()}
with fml_testing.mock_sends(override_schemas.BuildrootOverrideTagV1):
res = self.app.post('/overrides/', data)
o = res.json_body
self.assertEqual(o['build_id'], build.id)
self.assertEqual(o['notes'], 'blah blah blah')
self.assertEqual(o['expiration_date'],
expiration_date.strftime("%Y-%m-%d %H:%M:%S"))
self.assertEqual(o['expired_date'], None)
# Submit it again
data['notes'] = 'new blah blah'
res = self.app.post('/overrides/', data)
o = res.json_body
new_notes = """blah blah blah
_@guest ({})_
_____________
new blah blah""".format(datetime.utcnow().strftime("%b %d, %Y"))
self.assertEqual(o['notes'], new_notes)
def test_create_override(self, publish):
release = Release.get('F17')
package = RpmPackage(name='not-bodhi')
self.db.add(package)
build = RpmBuild(nvr='not-bodhi-2.0-2.fc17', package=package, release=release)
self.db.add(build)
self.db.flush()
expiration_date = datetime.utcnow() + timedelta(days=1)
data = {'nvr': build.nvr, 'notes': 'blah blah blah',
'expiration_date': expiration_date,
'csrf_token': self.get_csrf_token()}
res = self.app.post('/overrides/', data)
publish.assert_called_once_with(
topic='buildroot_override.tag', msg=mock.ANY)
self.assertEqual(len(publish.call_args_list), 1)
o = res.json_body
self.assertEqual(o['build_id'], build.id)
self.assertEqual(o['notes'], 'blah blah blah')
self.assertEqual(o['expiration_date'],
expiration_date.strftime("%Y-%m-%d %H:%M:%S"))
self.assertEqual(o['expired_date'], None)
def test_list_overrides_by_multiple_usernames(self):
release = Release.get('F17')
package = RpmPackage(name='just-testing')
self.db.add(package)
build = RpmBuild(nvr='just-testing-1.0-2.fc17', package=package, release=release)
self.db.add(build)
another_user = User(name='aUser')
self.db.add(another_user)
expiration_date = datetime.utcnow() + timedelta(days=1)
override = BuildrootOverride(build=build, submitter=another_user,
notes='Crazy! 😱',
expiration_date=expiration_date)
self.db.add(override)
self.db.flush()
res = self.app.get('/overrides/', {"user": "******"})
body = res.json_body
self.assertEqual(len(body['overrides']), 2)
override_fake = body['overrides'][0]
self.assertEqual(override_fake['build']['nvr'], 'just-testing-1.0-2.fc17')
self.assertEqual(override_fake['submitter']['name'], 'aUser')
self.assertEqual(override_fake['notes'], 'Crazy! 😱')
override_orig = body['overrides'][1]
self.assertEqual(override_orig['build']['nvr'], 'bodhi-2.0-1.fc17')
self.assertEqual(override_orig['submitter']['name'], 'guest')
self.assertEqual(override_orig['notes'], 'blah blah blah')
def test_create_duplicate_override_notes_too_long(self):
"""When notes are too long, truncate the older."""
release = Release.get('F17')
package = RpmPackage(name='not-bodhi')
self.db.add(package)
build = RpmBuild(nvr='not-bodhi-2.0-2.fc17', package=package, release=release)
self.db.add(build)
self.db.flush()
expiration_date = datetime.utcnow() + timedelta(days=1)
data = {'nvr': build.nvr, 'notes': 'blah' * 500,
'expiration_date': expiration_date,
'csrf_token': self.get_csrf_token()}
with fml_testing.mock_sends(override_schemas.BuildrootOverrideTagV1):
res = self.app.post('/overrides/', data)
o = res.json_body
assert o['build_id'] == build.id
assert o['notes'] == 'blah' * 500
assert o['expiration_date'] == expiration_date.strftime("%Y-%m-%d %H:%M:%S")
assert o['expired_date'] is None
# Submit it again
data['notes'] = 'new blah blah'
res = self.app.post('/overrides/', data)
o = res.json_body
assert o['notes'].endswith('(...)\n___Notes truncated___')
assert len(o['notes']) <= 2000
def test_cannot_edit_override_build(self, publish):
release = Release.get(u'F17', self.db)
old_nvr = u'bodhi-2.0-1.fc17'
res = self.app.get('/overrides/%s' % old_nvr)
o = res.json_body['override']
expiration_date = o['expiration_date']
old_build_id = o['build_id']
build = RpmBuild(
nvr=u'bodhi-2.0-2.fc17',
release=release,
package=RpmPackage.query.filter_by(name='bodhi').one())
self.db.add(build)
self.db.flush()
o.update({
'nvr': build.nvr,
'edited': old_nvr,
'csrf_token': self.get_csrf_token(),
})
res = self.app.post('/overrides/', o)
override = res.json_body
self.assertEquals(override['build_id'], old_build_id)
self.assertEquals(override['notes'], 'blah blah blah')
self.assertEquals(override['expiration_date'], expiration_date)
self.assertEquals(override['expired_date'], None)
self.assertEquals(len(publish.call_args_list), 0)
def get_release_json(request):
"""
Return JSON for a release given by name.
Args:
request (pyramid.json): The current request.
Returns:
bodhi.server.models.Release: The matched Release.
"""
id = request.matchdict.get('name')
release = Release.get(id)
if not release:
request.errors.add('body', 'name', 'No such release')
request.errors.status = HTTPNotFound.code
return release
def test_create_override_too_long(self):
release = Release.get('F17')
package = RpmPackage(name='not-bodhi')
self.db.add(package)
build = RpmBuild(nvr='not-bodhi-2.0-2.fc17', package=package, release=release)
self.db.add(build)
self.db.flush()
expiration_date = datetime.utcnow() + timedelta(days=60)
data = {'nvr': build.nvr, 'notes': 'blah blah blah',
'expiration_date': expiration_date,
'csrf_token': self.get_csrf_token()}
self.app.post('/overrides/', data, status=400)
def test_create_override_multiple_nvr(self):
release = Release.get('F17')
package = RpmPackage(name='not-bodhi')
self.db.add(package)
build1 = RpmBuild(nvr='not-bodhi-2.0-2.fc17',
package=package,
release=release)
self.db.add(build1)
self.db.flush()
package = RpmPackage(name='another-not-bodhi')
self.db.add(package)
build2 = RpmBuild(nvr='another-not-bodhi-2.0-2.fc17',
package=package,
release=release)
self.db.add(build2)
self.db.flush()
expiration_date = datetime.utcnow() + timedelta(days=1)
data = {
'nvr': ','.join([build1.nvr, build2.nvr]),
'notes': 'blah blah blah',
'expiration_date': expiration_date,
'csrf_token': self.get_csrf_token(),
}
with fml_testing.mock_sends(override_schemas.BuildrootOverrideTagV1,
override_schemas.BuildrootOverrideTagV1):
res = self.app.post('/overrides/', data)
result = res.json_body
self.assertEqual(result['caveats'][0]['description'],
'Your override submission was split into 2.')
o1, o2 = result['overrides']
self.assertEqual(o1['build_id'], build1.id)
self.assertEqual(o1['notes'], 'blah blah blah')
self.assertEqual(o1['expiration_date'],
expiration_date.strftime("%Y-%m-%d %H:%M:%S"))
self.assertEqual(o1['expired_date'], None)
self.assertEqual(o2['build_id'], build2.id)
self.assertEqual(o2['notes'], 'blah blah blah')
self.assertEqual(o2['expiration_date'],
expiration_date.strftime("%Y-%m-%d %H:%M:%S"))
self.assertEqual(o2['expired_date'], None)
def test_create_override_multiple_nvr(self, publish):
release = Release.get(u'F17', self.db)
package = RpmPackage(name=u'not-bodhi')
self.db.add(package)
build1 = RpmBuild(nvr=u'not-bodhi-2.0-2.fc17',
package=package,
release=release)
self.db.add(build1)
self.db.flush()
package = RpmPackage(name=u'another-not-bodhi')
self.db.add(package)
build2 = RpmBuild(nvr=u'another-not-bodhi-2.0-2.fc17',
package=package,
release=release)
self.db.add(build2)
self.db.flush()
expiration_date = datetime.utcnow() + timedelta(days=1)
data = {
'nvr': ','.join([build1.nvr, build2.nvr]),
'notes': u'blah blah blah',
'expiration_date': expiration_date,
'csrf_token': self.get_csrf_token(),
}
res = self.app.post('/overrides/', data)
self.assertEquals(len(publish.call_args_list), 2)
result = res.json_body
self.assertEquals(result['caveats'][0]['description'],
'Your override submission was split into 2.')
o1, o2 = result['overrides']
self.assertEquals(o1['build_id'], build1.id)
self.assertEquals(o1['notes'], 'blah blah blah')
self.assertEquals(o1['expiration_date'],
expiration_date.strftime("%Y-%m-%d %H:%M:%S"))
self.assertEquals(o1['expired_date'], None)
self.assertEquals(o2['build_id'], build2.id)
self.assertEquals(o2['notes'], 'blah blah blah')
self.assertEquals(o2['expiration_date'],
expiration_date.strftime("%Y-%m-%d %H:%M:%S"))
self.assertEquals(o2['expired_date'], None)
def test_create_duplicate_override(self, publish):
release = Release.get(u'F17', self.db)
package = RpmPackage(name=u'not-bodhi')
self.db.add(package)
build = RpmBuild(nvr=u'not-bodhi-2.0-2.fc17',
package=package,
release=release)
self.db.add(build)
self.db.flush()
expiration_date = datetime.utcnow() + timedelta(days=1)
data = {
'nvr': build.nvr,
'notes': u'blah blah blah',
'expiration_date': expiration_date,
'csrf_token': self.get_csrf_token()
}
res = self.app.post('/overrides/', data)
publish.assert_called_once_with(topic='buildroot_override.tag',
msg=mock.ANY)
self.assertEquals(len(publish.call_args_list), 1)
o = res.json_body
self.assertEquals(o['build_id'], build.id)
self.assertEquals(o['notes'], 'blah blah blah')
self.assertEquals(o['expiration_date'],
expiration_date.strftime("%Y-%m-%d %H:%M:%S"))
self.assertEquals(o['expired_date'], None)
# Submit it again
res = self.app.post('/overrides/', data, status=400)
self.assertEquals(
res.json_body['errors'][0]['description'],
'Buildroot override for %s already exists' % build.nvr)
def get_release_html(request):
"""
Render a release given by id as HTML.
Args:
request (pyramid.Request): The current request.
Returns:
str: An HTML representation of the requested Release.
"""
id = request.matchdict.get('name')
release = Release.get(id)
if not release:
request.errors.add('body', 'name', 'No such release')
request.errors.status = HTTPNotFound.code
updates = request.db.query(Update).filter(Update.release == release).order_by(
Update.date_submitted.desc())
updates_count = request.db.query(Update.date_submitted, Update.type).filter(
Update.release == release).order_by(Update.date_submitted.desc())
date_commits = {}
dates = set()
for update in updates_count.all():
d = update.date_submitted
yearmonth = str(d.year) + '/' + str(d.month).zfill(2)
dates.add(yearmonth)
if update.type.description not in date_commits:
date_commits[update.type.description] = {}
if yearmonth in date_commits[update.type.description]:
date_commits[update.type.description][yearmonth] += 1
else:
date_commits[update.type.description][yearmonth] = 0
base_count_query = request.db.query(Update)\
.filter(Update.release == release)
num_updates_pending = base_count_query\
.filter(Update.status == UpdateStatus.pending).count()
num_updates_testing = base_count_query\
.filter(Update.status == UpdateStatus.testing).count()
num_updates_stable = base_count_query\
.filter(Update.status == UpdateStatus.stable).count()
num_updates_unpushed = base_count_query\
.filter(Update.status == UpdateStatus.unpushed).count()
num_updates_obsolete = base_count_query\
.filter(Update.status == UpdateStatus.obsolete).count()
num_updates_security = base_count_query\
.filter(Update.type == UpdateType.security).count()
num_updates_bugfix = base_count_query\
.filter(Update.type == UpdateType.bugfix).count()
num_updates_enhancement = base_count_query\
.filter(Update.type == UpdateType.enhancement).count()
num_updates_newpackage = base_count_query\
.filter(Update.type == UpdateType.newpackage).count()
num_active_overrides = request.db.query(
BuildrootOverride
).filter(
BuildrootOverride.expired_date.is_(None)
).join(
BuildrootOverride.build
).join(
Build.release
).filter(
Build.release == release
).count()
num_expired_overrides = request.db.query(
BuildrootOverride
).filter(
BuildrootOverride.expired_date.isnot(None)
).join(
BuildrootOverride.build
).join(
Build.release
).filter(
Build.release == release
).count()
num_gating_passed = base_count_query.filter(
Update.test_gating_status == TestGatingStatus.passed).count()
num_gating_ignored = base_count_query.filter(
Update.test_gating_status == TestGatingStatus.ignored).count()
return dict(release=release,
latest_updates=updates.limit(25).all(),
count=updates.count(),
date_commits=date_commits,
dates=sorted(dates),
num_updates_pending=num_updates_pending,
num_updates_testing=num_updates_testing,
num_updates_stable=num_updates_stable,
num_updates_unpushed=num_updates_unpushed,
num_updates_obsolete=num_updates_obsolete,
num_updates_security=num_updates_security,
num_updates_bugfix=num_updates_bugfix,
num_updates_enhancement=num_updates_enhancement,
num_updates_newpackage=num_updates_newpackage,
num_active_overrides=num_active_overrides,
num_expired_overrides=num_expired_overrides,
num_gating_passed=num_gating_passed,
num_gating_ignored=num_gating_ignored,
)
