def create_release(self, version):
"""
Create and return a :class:`Release` with the given version.
Args:
version (basestring): A string of the version of the release, such as 27.
Returns:
bodhi.server.models.Release: A new release.
"""
release = models.Release(
name=u'F{}'.format(version),
long_name=u'Fedora {}'.format(version),
id_prefix=u'FEDORA',
version=u'{}'.format(version.replace('M', '')),
dist_tag=u'f{}'.format(version),
stable_tag=u'f{}-updates'.format(version),
testing_tag=u'f{}-updates-testing'.format(version),
candidate_tag=u'f{}-updates-candidate'.format(version),
pending_signing_tag=u'f{}-updates-testing-signing'.format(version),
pending_testing_tag=u'f{}-updates-testing-pending'.format(version),
pending_stable_tag=u'f{}-updates-pending'.format(version),
override_tag=u'f{}-override'.format(version),
branch=u'f{}'.format(version),
state=models.ReleaseState.current)
self.db.add(release)
models.Release._all_releases = None
models.Release._tag_cache = None
self.db.flush()
return release
def create_release(self, version, create_automatic_updates=False):
"""
Create and return a :class:`Release` with the given version.
Args:
version (str): A string of the version of the release, such as 27.
Returns:
bodhi.server.models.Release: A new release.
"""
release = models.Release(
name='F{}'.format(version),
long_name='Fedora {}'.format(version),
id_prefix='FEDORA',
version='{}'.format(version.replace('M', '')),
dist_tag='f{}'.format(version),
stable_tag='f{}-updates'.format(version),
testing_tag='f{}-updates-testing'.format(version),
candidate_tag='f{}-updates-candidate'.format(version),
pending_signing_tag='f{}-updates-testing-signing'.format(version),
pending_testing_tag='f{}-updates-testing-pending'.format(version),
pending_stable_tag='f{}-updates-pending'.format(version),
override_tag='f{}-override'.format(version),
branch='f{}'.format(version),
state=models.ReleaseState.current,
create_automatic_updates=create_automatic_updates,
package_manager=models.PackageManager.unspecified,
testing_repository=None)
self.db.add(release)
models.Release.clear_all_releases_cache()
models.Release._tag_cache = None
self.db.flush()
return release
def populate(db):
"""
Create some data for tests to use.
Args:
db (sqlalchemy.orm.session.Session): The database session.
"""
user = models.User(name='guest')
db.add(user)
anonymous = models.User(name='anonymous')
db.add(anonymous)
provenpackager = models.Group(name='provenpackager')
db.add(provenpackager)
packager = models.Group(name='packager')
db.add(packager)
user.groups.append(packager)
release = models.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=models.ReleaseState.current,
create_automatic_updates=True,
package_manager=models.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 = models.UpdateType.bugfix
update.severity = models.UpdateSeverity.medium
bug = models.Bug(bug_id=12345)
db.add(bug)
update.bugs.append(bug)
comment = models.Comment(karma=1, text="wow. amaze.")
db.add(comment)
comment.user = user
update.comments.append(comment)
comment = models.Comment(karma=0, text="srsly. pretty good.")
comment.user = anonymous
db.add(comment)
update.comments.append(comment)
db.add(update)
db.commit()
def setUp(self):
"""
Set up an archived release with an Update so we can test the filtering.
"""
super(TestFilterReleases, self).setUp()
self.user = self.db.query(models.User).all()[0]
archived_release = models.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',
state=models.ReleaseState.archived)
self.db.add(archived_release)
# Let's add an obscure package called bodhi to the release.
pkg = self.db.query(models.RpmPackage).filter_by(name=u'bodhi').one()
build = models.RpmBuild(nvr=u'bodhi-2.3.2-1.fc22',
release=archived_release,
package=pkg)
self.db.add(build)
# And an Update with the RpmBuild.
self.archived_release_update = models.Update(
title=u'bodhi-2.3.2-1.fc22',
builds=[build],
user=self.user,
request=models.UpdateRequest.stable,
notes=u'Useful details!',
release=archived_release,
date_submitted=datetime(2016, 10, 28),
requirements=u'',
stable_karma=3,
unstable_karma=-3,
type=models.UpdateType.bugfix)
self.db.add(self.archived_release_update)
self.db.commit()
test_config = base.original_config.copy()
test_config['mash_dir'] = '/mashdir/'
mock_config = mock.patch.dict('bodhi.server.push.config', test_config)
mock_config.start()
self.addCleanup(mock_config.stop)
def test_defaults_to_filtering_correct_releases(self):
"""
Ensure that _filter_releases() filters out archived and disabled releases by default.
"""
# To make sure the filter is skipping and including the right stuff, let's add a disabled
# release and a pending release. Builds from the disabled one should be exlcuded and the
# pending one should be included.
disabled_release = models.Release(
name=u'F21', long_name=u'Fedora 21',
id_prefix=u'FEDORA', version=u'21',
dist_tag=u'f21', stable_tag=u'f21-updates',
testing_tag=u'f21-updates-testing',
candidate_tag=u'f21-updates-candidate',
pending_signing_tag=u'f21-updates-testing-signing',
pending_testing_tag=u'f21-updates-testing-pending',
pending_stable_tag=u'f21-updates-pending',
override_tag=u'f21-override',
branch=u'f21', state=models.ReleaseState.disabled)
pending_release = models.Release(
name=u'F25', long_name=u'Fedora 25',
id_prefix=u'FEDORA', version=u'25',
dist_tag=u'f25', stable_tag=u'f25-updates',
testing_tag=u'f25-updates-testing',
candidate_tag=u'f25-updates-candidate',
pending_signing_tag=u'f25-updates-testing-signing',
pending_testing_tag=u'f25-updates-testing-pending',
pending_stable_tag=u'f25-updates-pending',
override_tag=u'f25-override',
branch=u'f25', state=models.ReleaseState.pending)
self.db.add(disabled_release)
self.db.add(pending_release)
# Let's add the bodhi package to both releases.
pkg = self.db.query(models.RpmPackage).filter_by(name=u'bodhi').one()
disabled_build = models.RpmBuild(nvr=u'bodhi-2.3.2-1.fc21', release=disabled_release,
package=pkg)
pending_build = models.RpmBuild(nvr=u'bodhi-2.3.2-1.fc25', release=pending_release,
package=pkg)
self.db.add(disabled_build)
self.db.add(pending_build)
# Now let's create updates for both packages.
disabled_release_update = models.Update(
title=u'bodhi-2.3.2-1.fc21', builds=[disabled_build], user=self.user,
request=models.UpdateRequest.stable, notes=u'Useful details!', release=disabled_release,
date_submitted=datetime(2016, 10, 28), requirements=u'', stable_karma=3,
unstable_karma=-3, type=models.UpdateType.bugfix)
pending_release_update = models.Update(
title=u'bodhi-2.3.2-1.fc25', builds=[pending_build], user=self.user,
request=models.UpdateRequest.stable, notes=u'Useful details!', release=pending_release,
date_submitted=datetime(2016, 10, 28), requirements=u'', stable_karma=3,
unstable_karma=-3, type=models.UpdateType.bugfix)
self.db.add(disabled_release_update)
self.db.add(pending_release_update)
self.db.commit()
query = self.db.query(models.Update)
query = push._filter_releases(self.db, query)
# Make sure the archived update didn't get in this business
self.assertEqual(set([u.release.state for u in query]),
set([models.ReleaseState.current, models.ReleaseState.pending]))
def test_releases_flag(self, publish, mock_init):
"""
Assert correct operation from the --releases flag.
"""
f25 = models.Release(
name=u'F25', long_name=u'Fedora 25',
id_prefix=u'FEDORA', version=u'25',
dist_tag=u'f25', stable_tag=u'f25-updates',
testing_tag=u'f25-updates-testing',
candidate_tag=u'f25-updates-candidate',
pending_signing_tag=u'f25-updates-testing-signing',
pending_testing_tag=u'f25-updates-testing-pending',
pending_stable_tag=u'f25-updates-pending',
override_tag=u'f25-override',
branch=u'f25', state=models.ReleaseState.current)
f26 = models.Release(
name=u'F26', long_name=u'Fedora 26',
id_prefix=u'FEDORA', version=u'26',
dist_tag=u'f26', stable_tag=u'f26-updates',
testing_tag=u'f26-updates-testing',
candidate_tag=u'f26-updates-candidate',
pending_signing_tag=u'f26-updates-testing-signing',
pending_testing_tag=u'f26-updates-testing-pending',
pending_stable_tag=u'f26-updates-pending',
override_tag=u'f26-override',
branch=u'f26', state=models.ReleaseState.current)
self.db.add(f25)
self.db.add(f26)
self.db.commit()
# Let's make an update for each release
python_nose = self.create_update([u'python-nose-1.3.7-11.fc25'], u'F25')
# Let's make nose a security update to test that its compose gets sorted first.
python_nose.type = models.UpdateType.security
python_paste_deploy = self.create_update([u'python-paste-deploy-1.5.2-8.fc26'], u'F26')
python_nose.builds[0].signed = True
python_paste_deploy.builds[0].signed = True
self.db.commit()
cli = CliRunner()
with mock.patch('bodhi.server.push.transactional_session_maker',
return_value=base.TransactionalSessionMaker(self.Session)):
# We will specify that we want F25 and F26, which should exclude the F17 updates we've
# been pushing in all the other tests. We'll leave the F off of 26 and lowercase the f
# on 25 to make sure it's flexible.
result = cli.invoke(push.push, ['--username', 'bowlofeggs', '--releases', 'f25,26'],
input='y')
self.assertEqual(result.exit_code, 0)
mock_init.assert_called_once_with(active=True, cert_prefix=u'shell')
self.assertEqual(result.output, TEST_RELEASES_FLAG_EXPECTED_OUTPUT)
f25_python_nose = self.db.query(models.Update).filter_by(
title=u'python-nose-1.3.7-11.fc25').one()
f26_python_paste_deploy = self.db.query(models.Update).filter_by(
title=u'python-paste-deploy-1.5.2-8.fc26').one()
publish.assert_called_once_with(
topic='masher.start',
msg={
'composes': [f25_python_nose.compose.__json__(),
f26_python_paste_deploy.compose.__json__()],
'resume': False, 'agent': 'bowlofeggs', 'api_version': 2},
force=True)
# The Fedora 17 updates should not have been locked.
f17_python_nose = self.db.query(models.Update).filter_by(
title=u'python-nose-1.3.7-11.fc17').one()
f17_python_paste_deploy = self.db.query(models.Update).filter_by(
title=u'python-paste-deploy-1.5.2-8.fc17').one()
self.assertFalse(f17_python_nose.locked)
self.assertIsNone(f17_python_nose.date_locked)
self.assertIsNone(f17_python_nose.compose)
self.assertFalse(f17_python_paste_deploy.locked)
self.assertIsNone(f17_python_paste_deploy.date_locked)
self.assertIsNone(f17_python_paste_deploy.compose)
# The new updates should both be locked.
self.assertTrue(f25_python_nose.locked)
self.assertTrue(f25_python_nose.date_locked <= datetime.utcnow())
self.assertTrue(f26_python_paste_deploy.locked)
self.assertTrue(f26_python_paste_deploy.date_locked <= datetime.utcnow())
# The new updates should also be associated with the new Composes.
self.assertEqual(f25_python_nose.compose.release.id, f25.id)
self.assertEqual(f25_python_nose.compose.request, models.UpdateRequest.testing)
self.assertEqual(f26_python_paste_deploy.compose.release.id, f26.id)
self.assertEqual(f26_python_paste_deploy.compose.request, models.UpdateRequest.testing)
