def test_resume_empty_compose(self, publish):
"""
Test correct operation when the --resume flag is given but one of the Composes has no
updates.
"""
cli = CliRunner()
# Let's mark ejabberd as locked and already in a push. Since we are resuming and since we
# will decline pushing the first time we are asked, it should be the only package that gets
# included.
ejabberd = self.create_update([u'ejabberd-16.09-4.fc17'])
ejabberd.builds[0].signed = True
ejabberd.locked = True
compose = models.Compose(release=ejabberd.release,
request=ejabberd.request)
self.db.add(compose)
# This compose has no updates, so bodhi-push should delete it.
compose = models.Compose(release=ejabberd.release,
request=models.UpdateRequest.stable)
self.db.add(compose)
self.db.commit()
with mock.patch('bodhi.server.push.transactional_session_maker',
return_value=base.TransactionalSessionMaker(
self.Session)):
result = cli.invoke(push.push,
['--username', 'bowlofeggs', '--resume'],
input='y\ny')
self.assertEqual(result.exit_code, 0)
self.assertEqual(result.output, TEST_RESUME_EMPTY_COMPOSE)
ejabberd = self.db.query(
models.Update).filter_by(title=u'ejabberd-16.09-4.fc17').one()
python_nose = self.db.query(
models.Update).filter_by(title=u'python-nose-1.3.7-11.fc17').one()
python_paste_deploy = self.db.query(models.Update).filter_by(
title=u'python-paste-deploy-1.5.2-8.fc17').one()
publish.assert_called_once_with(
topic='masher.start',
msg={
'composes': [ejabberd.compose.__json__(composer=True)],
'resume': True,
'agent': 'bowlofeggs',
'api_version': 2
},
force=True)
# ejabberd should still be locked.
self.assertTrue(ejabberd.locked)
self.assertTrue(ejabberd.date_locked <= datetime.utcnow())
self.assertEqual(ejabberd.compose.release, ejabberd.release)
self.assertEqual(ejabberd.compose.request, ejabberd.request)
# These should be left alone.
for u in [python_nose, python_paste_deploy]:
self.assertFalse(u.locked)
self.assertIsNone(u.date_locked)
self.assertIsNone(u.compose)
# The empty compose should have been deleted.
self.assertEqual(
self.db.query(models.Compose).filter_by(
release_id=ejabberd.release.id,
request=models.UpdateRequest.stable).count(), 0)
def test_monitor_with_composes(self):
"""Ensure correct output from the monitor function."""
runner = testing.CliRunner()
update = models.Update.query.one()
update.locked = True
update.status = models.UpdateStatus.pending
update.request = models.UpdateRequest.testing
compose_1 = models.Compose(
release=update.release, request=update.request, state=models.ComposeState.notifying,
checkpoints=json.dumps({'check_1': True, 'check_2': True}))
ejabberd = self.create_update([u'ejabberd-16.09-4.fc17'])
ejabberd.locked = True
ejabberd.status = models.UpdateStatus.testing
ejabberd.request = models.UpdateRequest.stable
ejabberd.type = models.UpdateType.security
compose_2 = models.Compose(
release=ejabberd.release, request=ejabberd.request, state=models.ComposeState.failed,
error_message=u'y r u so mean nfs')
self.db.add(compose_1)
self.db.add(compose_2)
self.db.flush()
r = runner.invoke(monitor_composes.monitor)
self.assertEqual(r.exit_code, 0)
EXPECTED_OUTPUT = (
'Locked updates: 2\n\n<Compose: F17 stable>\n\tstate: <failed>\n\tstate_date: {}\n\t'
'security: True\n\terror_message: y r u so mean nfs\n\tcheckpoints: \n\t'
'len(updates): 1\n\n<Compose: F17 testing>\n\tstate: <notifying>\n\tstate_date: {}\n\t'
'security: False\n\tcheckpoints: check_2, check_1\n\tlen(updates): 1\n\n')
self.assertEqual(r.output,
EXPECTED_OUTPUT.format(compose_2.state_date, compose_1.state_date))
def test_resume_human_says_no(self, publish):
"""
Test correct operation when the --resume flag is given but the human says they don't want to
resume one of the lockfiles.
"""
cli = CliRunner()
# Let's mark ejabberd as locked and already in a push. Since we are resuming and since we
# will decline pushing the first time we are asked, it should be the only package that gets
# included.
ejabberd = self.create_update([u'ejabberd-16.09-4.fc17'])
ejabberd.builds[0].signed = True
ejabberd.locked = True
compose = models.Compose(release=ejabberd.release,
request=ejabberd.request)
self.db.add(compose)
python_nose = self.db.query(
models.Update).filter_by(title=u'python-nose-1.3.7-11.fc17').one()
python_nose.locked = True
python_nose.request = models.UpdateRequest.stable
compose = models.Compose(release=python_nose.release,
request=python_nose.request)
self.db.add(compose)
self.db.commit()
with mock.patch('bodhi.server.push.transactional_session_maker',
return_value=base.TransactionalSessionMaker(
self.Session)):
result = cli.invoke(push.push,
['--username', 'bowlofeggs', '--resume'],
input='y\nn\ny')
self.assertEqual(result.exit_code, 0)
self.assertEqual(result.output,
TEST_RESUME_HUMAN_SAYS_NO_EXPECTED_OUTPUT)
ejabberd = self.db.query(
models.Update).filter_by(title=u'ejabberd-16.09-4.fc17').one()
python_nose = self.db.query(
models.Update).filter_by(title=u'python-nose-1.3.7-11.fc17').one()
python_paste_deploy = self.db.query(models.Update).filter_by(
title=u'python-paste-deploy-1.5.2-8.fc17').one()
publish.assert_called_once_with(
topic='masher.start',
msg={
'composes': [ejabberd.compose.__json__(composer=True)],
'resume': True,
'agent': 'bowlofeggs',
'api_version': 2
},
force=True)
# These should still be locked.
for u in [ejabberd, python_nose]:
self.assertTrue(u.locked)
self.assertTrue(u.date_locked <= datetime.utcnow())
self.assertEqual(u.compose.release, u.release)
self.assertEqual(u.compose.request, u.request)
# paste_deploy should have been left alone
self.assertFalse(python_paste_deploy.locked)
self.assertIsNone(python_paste_deploy.date_locked)
self.assertIsNone(python_paste_deploy.compose)
def test_with_compose_json(self):
"""Assert correct behavior for the json interface when there is a compose."""
update = models.Update.query.first()
compose = models.Compose(release=update.release, request=update.request)
self.db.add(compose)
self.db.flush()
response = self.app.get('/composes/', status=200, headers={'Accept': 'application/json'})
self.assertEqual(response.json, {'composes': [compose.__json__()]})
def test_default_accept(self):
"""Test that an Accept header of */* gets the default JSON response."""
update = models.Update.query.first()
compose = models.Compose(release=update.release, request=update.request)
self.db.add(compose)
self.db.flush()
response = self.app.get('/composes/', status=200, headers={'Accept': '*/*'})
self.assertEqual(response.json, {'composes': [compose.__json__()]})
def test_resume_flag(self, publish, mock_init):
"""
Test correct operation when the --resume flag is given.
"""
cli = CliRunner()
# Let's mark ejabberd as locked and already in a push. Since we are resuming, it should be
# the only package that gets included.
ejabberd = self.create_update([u'ejabberd-16.09-4.fc17'])
ejabberd.builds[0].signed = True
ejabberd.locked = True
compose = models.Compose(release=ejabberd.release,
request=ejabberd.request)
self.db.add(compose)
self.db.commit()
with mock.patch('bodhi.server.push.transactional_session_maker',
return_value=base.TransactionalSessionMaker(
self.Session)):
result = cli.invoke(push.push,
['--username', 'bowlofeggs', '--resume'],
input='y\ny')
self.assertEqual(result.exit_code, 0)
mock_init.assert_called_once_with(active=True, cert_prefix=u'shell')
self.assertEqual(result.output, TEST_RESUME_FLAG_EXPECTED_OUTPUT)
ejabberd = self.db.query(
models.Update).filter_by(title=u'ejabberd-16.09-4.fc17').one()
python_nose = self.db.query(
models.Update).filter_by(title=u'python-nose-1.3.7-11.fc17').one()
python_paste_deploy = self.db.query(models.Update).filter_by(
title=u'python-paste-deploy-1.5.2-8.fc17').one()
publish.assert_called_once_with(topic='masher.start',
msg={
'composes':
[ejabberd.compose.__json__()],
'resume':
True,
'agent':
'bowlofeggs',
'api_version':
2
},
force=True)
# ejabberd should be locked still
self.assertTrue(ejabberd.locked)
self.assertTrue(ejabberd.date_locked <= datetime.utcnow())
self.assertEqual(ejabberd.compose.release, ejabberd.release)
self.assertEqual(ejabberd.compose.request, ejabberd.request)
# The other packages should have been left alone
for u in [python_nose, python_paste_deploy]:
self.assertFalse(u.locked)
self.assertIsNone(u.date_locked)
self.assertIsNone(u.compose)
def test_locked_updates(self, publish, mock_init):
"""
Test correct operation when there are some locked updates.
"""
cli = CliRunner()
# Let's mark ejabberd as locked and already in a push. bodhi-push should prompt the user to
# resume this compose rather than starting a new one.
ejabberd = self.create_update([u'ejabberd-16.09-4.fc17'])
ejabberd.builds[0].signed = True
ejabberd.locked = True
compose = models.Compose(release=ejabberd.release,
request=ejabberd.request,
state=models.ComposeState.failed,
error_message=u'y r u so mean nfs')
self.db.add(compose)
self.db.commit()
with mock.patch('bodhi.server.push.transactional_session_maker',
return_value=base.TransactionalSessionMaker(
self.Session)):
result = cli.invoke(push.push, ['--username', 'bowlofeggs'],
input='y\ny')
self.assertEqual(result.exit_code, 0)
mock_init.assert_called_once_with(active=True, cert_prefix=u'shell')
self.assertEqual(result.output, TEST_LOCKED_UPDATES_EXPECTED_OUTPUT)
publish.assert_called_once_with(topic='masher.start',
msg={
'composes':
[ejabberd.compose.__json__()],
'resume':
True,
'agent':
'bowlofeggs',
'api_version':
2
},
force=True)
ejabberd = self.db.query(
models.Update).filter_by(title=u'ejabberd-16.09-4.fc17').one()
self.assertTrue(ejabberd.locked)
self.assertTrue(ejabberd.date_locked <= datetime.utcnow())
self.assertEqual(ejabberd.compose.release, ejabberd.release)
self.assertEqual(ejabberd.compose.request, ejabberd.request)
self.assertEqual(ejabberd.compose.state, models.ComposeState.requested)
self.assertEqual(ejabberd.compose.error_message, '')
python_nose = self.db.query(
models.Update).filter_by(title=u'python-nose-1.3.7-11.fc17').one()
python_paste_deploy = self.db.query(models.Update).filter_by(
title=u'python-paste-deploy-1.5.2-8.fc17').one()
for u in [python_nose, python_paste_deploy]:
self.assertFalse(u.locked)
self.assertIsNone(u.date_locked)
def test_with_compose_json(self):
"""Assert correct behavior from the json renderer when there is a compose."""
update = models.Update.query.first()
update.locked = True
compose = models.Compose(release=update.release, request=update.request)
self.db.add(compose)
self.db.flush()
response = self.app.get(
'/composes/{}/{}'.format(compose.release.name, compose.request.value),
status=200, headers={'Accept': 'application/json'})
self.assertEqual(response.json, {'compose': compose.__json__()})
def test_with_compose_html(self):
"""Assert correct behavior for the html interface when there is a compose."""
update = models.Update.query.first()
compose = models.Compose(release=update.release, request=update.request)
self.db.add(compose)
self.db.flush()
response = self.app.get('/composes/', status=200, headers={'Accept': 'text/html'})
# The Composes header should still appear in the page
assert '<h3 class="font-weight-bold m-0">Composes</h3>' in response
assert '/composes/{}/{}'.format(compose.release.name, compose.request.value) in response
assert compose.state.description in response
def test_with_compose(self):
"""Assert correct behavior when there is a compose."""
update = models.Update.query.first()
compose = models.Compose(release=update.release, request=update.request)
self.db.add(compose)
self.db.flush()
response = self.app.get('/composes/', status=200, headers={'Accept': 'text/html'})
# The Composes header should still appear in the page
self.assertTrue('<h1>Composes</h1>' in response)
self.assertTrue(
'/composes/{}/{}'.format(compose.release.name, compose.request.value) in response)
self.assertTrue(compose.state.description in response)
def test_with_compose(self):
"""Assert correct behavior when there is a compose."""
update = models.Update.query.first()
update.locked = True
compose = models.Compose(release=update.release, request=update.request)
self.db.add(compose)
self.db.flush()
response = self.app.get(
'/composes/{}/{}'.format(compose.release.name, compose.request.value),
status=200, headers={'Accept': 'text/html'})
self.assertTrue(compose.state.description in response)
self.assertTrue('{} {}'.format(compose.release.name, compose.request.value) in response)
self.assertTrue(update.beautify_title(amp=True, nvr=True) in response)
