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)