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___init___uses_bz2_for_epel(self):
"""Assert that the __init__() method sets the comp_type attribute to cr.BZ2 for EPEL."""
epel_7 = Release(id_prefix="FEDORA-EPEL", stable_tag='epel7')
md = UpdateInfoMetadata(epel_7, UpdateRequest.stable, self.db, self.tempdir)
self.assertEqual(md.comp_type, createrepo_c.BZ2)
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 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_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 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_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 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_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_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_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_enumfields(self):
"""Testing enum fields on releases."""
client = Client(schema)
release = Release(name='F22',
long_name='Fedora 22',
id_prefix='FEDORA',
version='22',
dist_tag='f22',
stable_tag='f22-updates',
testing_tag='f22-updates-testing',
candidate_tag='f22-updates-candidate',
pending_signing_tag='f22-updates-testing-signing',
pending_testing_tag='f22-updates-testing-pending',
pending_stable_tag='f22-updates-pending',
override_tag='f22-override',
branch='f22',
package_manager=PackageManager.dnf,
testing_repository='updates-testing')
self.db.add(release)
self.db.commit()
executed = client.execute(
"""{ allReleases{ state packageManager }}""")
assert executed == {
'data': {
'allReleases': [{
'packageManager': 'unspecified',
'state': 'current'
}, {
'packageManager': 'dnf',
'state': 'disabled'
}]
}
}
def test_allReleases(self):
"""Testing allReleases."""
client = Client(schema)
release = Release(name='F22',
long_name='Fedora 22',
id_prefix='FEDORA',
version='22',
dist_tag='f22',
stable_tag='f22-updates',
testing_tag='f22-updates-testing',
candidate_tag='f22-updates-candidate',
pending_signing_tag='f22-updates-testing-signing',
pending_testing_tag='f22-updates-testing-pending',
pending_stable_tag='f22-updates-pending',
override_tag='f22-override',
branch='f22',
package_manager=PackageManager.dnf,
testing_repository='updates-testing')
self.db.add(release)
self.db.commit()
executed = client.execute("""{ allReleases{ name }}""")
assert executed == {
"data": {
"allReleases": [{
"name": "F17"
}, {
"name": "F22"
}]
}
}
def save_release(request):
"""
Save a release.
This entails either creating a new release, or editing an existing one. To
edit an existing release, the release's original name must be specified in
the ``edited`` parameter.
Args:
request (pyramid.request): The current request.
Returns:
bodhi.server.models.Request: The created or edited Request.
"""
data = request.validated
edited = data.pop("edited", None)
# This has already been validated at this point, but we need to ditch
# it since the models don't care about a csrf argument.
data.pop('csrf_token', None)
try:
if edited is None:
log.info("Creating a new release: %s" % data['name'])
r = Release(**data)
else:
log.info("Editing release: %s" % edited)
r = request.db.query(Release).filter(Release.name == edited).one()
for k, v in data.items():
# We have to change updates status to obsolete
# if state of release changes to archived
if k == "state" and v == ReleaseState.archived and \
r.state != ReleaseState.archived:
updates = request.db.query(Update).filter(Update.release_id == r.id).filter(
Update.status.notin_(
[UpdateStatus.obsolete, UpdateStatus.stable, UpdateStatus.unpushed]
)
).all()
for u in updates:
u.status = UpdateStatus.obsolete
u.comment(
request.db,
'This update is marked obsolete because '
'the {} release is archived.'.format(u.release.name),
author='bodhi',
)
setattr(r, k, v)
except Exception as e:
log.exception(e)
request.errors.add('body', 'release',
'Unable to create/edit release: %s' % e)
return
request.db.add(r)
request.db.flush()
return r
def populate(db):
"""
Create some data for tests to use.
Args:
db (sqlalchemy.orm.session.Session): The database session.
"""
user = User(name='guest')
db.add(user)
anonymous = User(name='anonymous')
db.add(anonymous)
provenpackager = Group(name='provenpackager')
db.add(provenpackager)
packager = Group(name='packager')
db.add(packager)
user.groups.append(packager)
release = Release(name='F17',
long_name='Fedora 17',
id_prefix='FEDORA',
version='17',
dist_tag='f17',
stable_tag='f17-updates',
testing_tag='f17-updates-testing',
candidate_tag='f17-updates-candidate',
pending_signing_tag='f17-updates-signing-pending',
pending_testing_tag='f17-updates-testing-pending',
pending_stable_tag='f17-updates-pending',
override_tag='f17-override',
branch='f17',
state=ReleaseState.current,
create_automatic_updates=True,
package_manager=PackageManager.unspecified,
testing_repository=None)
db.add(release)
db.flush()
# This mock will help us generate a consistent update alias.
with mock.patch(target='uuid.uuid4', return_value='wat'):
update = create_update(db, ['bodhi-2.0-1.fc17'])
update.type = UpdateType.bugfix
update.severity = UpdateSeverity.medium
bug = Bug(bug_id=12345)
db.add(bug)
update.bugs.append(bug)
comment = Comment(karma=1, text="wow. amaze.")
db.add(comment)
comment.user = user
update.comments.append(comment)
comment = Comment(karma=0, text="srsly. pretty good.")
comment.user = anonymous
db.add(comment)
update.comments.append(comment)
db.add(update)
db.commit()
def populate(db):
"""
Create some data for tests to use.
Args:
db (sqlalchemy.orm.session.Session): The database session.
"""
user = User(name=u'guest')
db.add(user)
anonymous = User(name=u'anonymous')
db.add(anonymous)
provenpackager = Group(name=u'provenpackager')
db.add(provenpackager)
packager = Group(name=u'packager')
db.add(packager)
user.groups.append(packager)
release = Release(name=u'F17',
long_name=u'Fedora 17',
id_prefix=u'FEDORA',
version=u'17',
dist_tag=u'f17',
stable_tag=u'f17-updates',
testing_tag=u'f17-updates-testing',
candidate_tag=u'f17-updates-candidate',
pending_signing_tag=u'f17-updates-testing-signing',
pending_testing_tag=u'f17-updates-testing-pending',
pending_stable_tag=u'f17-updates-pending',
override_tag=u'f17-override',
branch=u'f17',
state=ReleaseState.current)
db.add(release)
db.flush()
update = create_update(db, [u'bodhi-2.0-1.fc17'])
update.type = UpdateType.bugfix
update.severity = UpdateSeverity.medium
bug = Bug(bug_id=12345)
db.add(bug)
update.bugs.append(bug)
cve = CVE(cve_id=u"CVE-1985-0110")
db.add(cve)
update.cves.append(cve)
comment = Comment(karma=1, text=u"wow. amaze.")
db.add(comment)
comment.user = user
update.comments.append(comment)
comment = Comment(karma=0, text=u"srsly. pretty good.", anonymous=True)
comment.user = anonymous
db.add(comment)
update.comments.append(comment)
with mock.patch(target='uuid.uuid4', return_value='wat'):
update.assign_alias()
db.add(update)
db.commit()
def get_releases(request):
"""
Return a defaultdict describing all Releases keyed by state.
Args:
request (pyramid.request.Request): The current web request. Unused.
Returns:
collections.defaultdict: A dictionary mapping release states to a list of JSON strings
that describe the Releases that are in those states.
"""
from bodhi.server.models import Release
return Release.all_releases()
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 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_list_overrides_by_releases_without_override(self):
self.db.add(Release(name='F42', long_name='Fedora 42',
id_prefix='FEDORA', version='42',
dist_tag='f42', stable_tag='f42-updates',
testing_tag='f42-updates-testing',
candidate_tag='f42-updates-candidate',
pending_signing_tag='f42-updates-testing-signing',
pending_testing_tag='f42-updates-testing-pending',
pending_stable_tag='f42-updates-pending',
override_tag='f42-override',
branch='f42'))
self.db.flush()
res = self.app.get('/overrides/', {'releases': 'F42'})
body = res.json_body
self.assertEqual(len(body['overrides']), 0)
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 setUp(self):
super(TestReleasesService, self).setUp()
release = Release(
name=u'F22', long_name=u'Fedora 22',
id_prefix=u'FEDORA', version=u'22',
dist_tag=u'f22', stable_tag=u'f22-updates',
testing_tag=u'f22-updates-testing',
candidate_tag=u'f22-updates-candidate',
pending_signing_tag=u'f22-updates-testing-signing',
pending_testing_tag=u'f22-updates-testing-pending',
pending_stable_tag=u'f22-updates-pending',
override_tag=u'f22-override',
branch=u'f22')
self.db.add(release)
self.db.flush()
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_new_release(self):
attrs = {
"name": "F42",
"long_name": "Fedora 42",
"version": "42",
"id_prefix": "FEDORA",
"branch": "f42",
"dist_tag": "f42",
"stable_tag": "f42-updates",
"testing_tag": "f42-updates-testing",
"candidate_tag": "f42-updates-candidate",
"pending_stable_tag": "f42-updates-pending",
"pending_signing_tag": "f42-updates-testing-signing",
"pending_testing_tag": "f42-updates-testing-pending",
"override_tag": "f42-override",
"package_manager": "dnf",
"testing_repository": "updates-testing",
"eol": date(2016, 6, 14),
"csrf_token": self.get_csrf_token(),
}
self.app.post("/releases/", attrs, status=200)
attrs.pop('csrf_token')
attrs.pop('eol')
r = self.db.query(Release).filter(Release.name == attrs["name"]).one()
for k, v in attrs.items():
if k in ['state', 'package_manager']:
assert getattr(r, k).value == v
else:
assert getattr(r, k) == v
assert r.state == ReleaseState.disabled
# Let's check Release cache content
releases = Release.all_releases()
disabled_releases = releases["disabled"]
assert disabled_releases[0]["name"] == "F42"
assert disabled_releases[1]["name"] == "F22"
assert len(disabled_releases) == 2
current_releases = releases["current"]
assert current_releases[0]["name"] == "F17"
assert len(current_releases) == 1
def setUp(self):
super(TestReleasesService, self).setUp()
release = Release(
name='F22', long_name='Fedora 22',
id_prefix='FEDORA', version='22',
dist_tag='f22', stable_tag='f22-updates',
testing_tag='f22-updates-testing',
candidate_tag='f22-updates-candidate',
pending_signing_tag='f22-updates-testing-signing',
pending_testing_tag='f22-updates-testing-pending',
pending_stable_tag='f22-updates-pending',
override_tag='f22-override',
branch='f22',
package_manager=PackageManager.dnf,
testing_repository='updates-testing')
self.db.add(release)
self.db.commit()
def save_release(request):
"""
Save a release.
This entails either creating a new release, or editing an existing one. To
edit an existing release, the release's original name must be specified in
the ``edited`` parameter.
Args:
request (pyramid.request): The current request.
Returns:
bodhi.server.models.Request: The created or edited Request.
"""
data = request.validated
edited = data.pop("edited", None)
# This has already been validated at this point, but we need to ditch
# it since the models don't care about a csrf argument.
data.pop('csrf_token', None)
try:
if edited is None:
log.info("Creating a new release: %s" % data['name'])
r = Release(**data)
else:
log.info("Editing release: %s" % edited)
r = request.db.query(Release).filter(Release.name == edited).one()
for k, v in data.items():
setattr(r, k, v)
except Exception as e:
log.exception(e)
request.errors.add('body', 'release',
'Unable to create update: %s' % e)
return
request.db.add(r)
request.db.flush()
return r
def setup_method(self, method):
super().setup_method(method)
release = Release(name='F22',
long_name='Fedora 22',
id_prefix='FEDORA',
version='22',
dist_tag='f22',
stable_tag='f22-updates',
testing_tag='f22-updates-testing',
candidate_tag='f22-updates-candidate',
pending_signing_tag='f22-updates-testing-signing',
pending_testing_tag='f22-updates-testing-pending',
pending_stable_tag='f22-updates-pending',
override_tag='f22-override',
branch='f22',
package_manager=PackageManager.dnf,
testing_repository='updates-testing',
eol=date(2016, 6, 14))
self.db.add(release)
self.db.commit()
def _determine_tag_actions(self):
tag_types, tag_rels = Release.get_tags(self.db)
# sync & async tagging batches
for i, batch in enumerate(sorted_updates(self.updates)):
for update in batch:
add_tags = []
move_tags = []
if update.status is UpdateStatus.testing:
status = 'testing'
else:
status = 'candidate'
for build in update.builds:
from_tag = None
tags = build.get_tags()
for tag in tags:
if tag in tag_types[status]:
from_tag = tag
break
else:
reason = 'Cannot find relevant tag for %s. None of %s are in %s.'
reason = reason % (build.nvr, tags, tag_types[status])
self.eject_from_mash(update, reason)
break
if self.skip_mash:
add_tags.append((update.requested_tag, build.nvr))
else:
move_tags.append((from_tag, update.requested_tag,
build.nvr))
else:
if i == 0:
self.add_tags_sync.extend(add_tags)
self.move_tags_sync.extend(move_tags)
else:
self.add_tags_async.extend(add_tags)
self.move_tags_async.extend(move_tags)
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)
