def test_non_autokarma_update_without_mandatory_days_in_testing(self): """ If the Update's release doesn't have a mandatory days in testing, main() should ignore it (and should not comment on the update at all, even if it does reach karma levels.) """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.request = None update.stable_karma = 1 update.status = models.UpdateStatus.testing update.comment(self.db, u'testing', author=u'hunter2', anonymous=False, karma=1) self.db.commit() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): approve_testing.main(['nosetests', 'some_config.ini']) # The bodhi user shouldn't exist, since it shouldn't have made any comments self.assertEqual(self.db.query(models.User).filter_by(name=u'bodhi').count(), 0) # There are three comments, but none from the non-existing bodhi user. self.assertEqual(self.db.query(models.Comment).count(), 3) usernames = [ c.user.name for c in self.db.query(models.Comment).order_by(models.Comment.timestamp).all()] self.assertEqual(usernames, [u'guest', u'anonymous', u'hunter2'])
def test_non_autokarma_update_with_unmet_karma_requirement_after_time_met(self): """ A non-autokarma update without enough karma that reaches mandatory days in testing should get a comment from Bodhi that the update can be pushed to stable. See https://github.com/fedora-infra/bodhi/issues/1094 """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.request = None update.stable_karma = 10 update.status = models.UpdateStatus.testing update.date_testing = datetime.utcnow() - timedelta(days=7) update.comment(self.db, u'testing', author=u'hunter2', anonymous=False, karma=1) with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): approve_testing.main(['nosetests', 'some_config.ini']) bodhi = self.db.query(models.User).filter_by(name=u'bodhi').one() comment_q = self.db.query(models.Comment).filter_by(update_id=update.id, user_id=bodhi.id) self.assertEqual(comment_q.count(), 1) self.assertEqual( comment_q[0].text, config.get('testing_approval_msg') % update.release.mandatory_days_in_testing)
def test_autokarma_update_meeting_time_requirements_gets_one_comment(self): """ Ensure that an update that meets the required time in testing gets only one comment from Bodhi to that effect, even on subsequent runs of main(). """ update = self.db.query(models.Update).all()[0] update.autokarma = True update.request = None update.stable_karma = 10 update.status = models.UpdateStatus.testing update.date_testing = datetime.utcnow() - timedelta(days=7) with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): approve_testing.main(['nosetests', 'some_config.ini']) # Now we will run main() again, but this time we expect Bodhi not to add any # further comments. approve_testing.main(['nosetests', 'some_config.ini']) bodhi = self.db.query(models.User).filter_by(name=u'bodhi').one() comment_q = self.db.query(models.Comment).filter_by(update_id=update.id, user_id=bodhi.id) self.assertEqual(comment_q.count(), 1) self.assertEqual( comment_q[0].text, config.get('testing_approval_msg') % update.release.mandatory_days_in_testing)
def test_non_autokarma_update_meeting_karma_requirements_gets_one_comment(self): """ Ensure that a non-autokarma update that meets the required karma threshold gets only one comment from Bodhi to that effect, even on subsequent runs of main(). There was an issue[0] where Bodhi wasn't correctly detecting that it has already commented on updates, and would repeatedly comment that non-autokarma updates could be pushed. This test ensures that issue stays fixed. [0] https://github.com/fedora-infra/bodhi/issues/1009 """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.request = None update.stable_karma = 1 update.status = models.UpdateStatus.testing update.comment(self.db, u'testing', author=u'hunter2', anonymous=False, karma=1) with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): approve_testing.main(['nosetests', 'some_config.ini']) # Now we will run main() again, but this time we expect Bodhi not to add any # further comments. approve_testing.main(['nosetests', 'some_config.ini']) bodhi = self.db.query(models.User).filter_by(name=u'bodhi').one() comment_q = self.db.query(models.Comment).filter_by(update_id=update.id, user_id=bodhi.id) self.assertEqual(comment_q.count(), 1) self.assertEqual(comment_q[0].text, config.get('testing_approval_msg_based_on_karma'))
def test_non_autokarma_critpath_update_not_meeting_time_requirements_gets_no_comment(self): """ Ensure that a non-autokarma critical path update that does not meet the required time in testing does not get any comment from bodhi saying it can be pushed to stable. There was an issue[0] where Bodhi was incorrectly detecting that the update could be pushed and was commenting to that effect. This test ensures that issue stays fixed. [0] https://github.com/fedora-infra/bodhi/issues/1009 """ update = self.db.query(models.Update).all()[0] update.autokarma = False # Make this update a critpath update to force meets_testing_requirements into a different # code path. update.critpath = True update.request = None update.stable_karma = 1 update.status = models.UpdateStatus.testing update.comment(self.db, u'testing', author=u'hunter2', anonymous=False, karma=1) with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): approve_testing.main(['nosetests', 'some_config.ini']) # Now we will run main() again, but this time we expect Bodhi not to add any # further comments. approve_testing.main(['nosetests', 'some_config.ini']) # The bodhi user shouldn't exist, since it shouldn't have made any comments self.assertEqual(self.db.query(models.User).filter_by(name=u'bodhi').count(), 0) # There are three comments, but none from the non-existing bodhi user. self.assertEqual(self.db.query(models.Comment).count(), 3) usernames = [ c.user.name for c in self.db.query(models.Comment).order_by(models.Comment.timestamp).all()] self.assertEqual(usernames, [u'guest', u'anonymous', u'hunter2'])
def test_exception_handler(self, stdout, exit, remove, comment): """The Exception handler prints the Exception, rolls back and closes the db, and exits.""" update = self.db.query(models.Update).all()[0] update.date_testing = datetime.utcnow() - timedelta(days=15) update.request = None update.status = models.UpdateStatus.testing self.db.flush() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with patch.object(self.db, 'commit'): with patch.object(self.db, 'rollback'): approve_testing.main(['nosetests', 'some_config.ini']) self.assertEqual(self.db.commit.call_count, 0) self.db.rollback.assert_called_once_with() exit.assert_called_once_with(1) comment.assert_called_once_with( self.db, ('This update has reached 7 days in testing and can be pushed to stable now if the ' 'maintainer wishes'), author=u'bodhi') self.assertEqual(stdout.getvalue(), 'bodhi-2.0-1.fc17 now meets testing requirements\nThe DB died lol\n') remove.assert_called_once_with()
def test_subsequent_comments_after_initial_push_comment(self): """ If a user edits an update after Bodhi comments a testing_approval_msg, Bodhi should send an additional testing_approval_msg when the revised update is eligible to be pushed to stable. See https://github.com/fedora-infra/bodhi/issues/1310 """ update = self.db.query(models.Update).all()[0] update.request = None update.status = models.UpdateStatus.testing update.date_testing = datetime.utcnow() - timedelta(days=14) self.db.flush() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): approve_testing.main(['nosetests', 'some_config.ini']) update.comment(self.db, u"Removed build", 0, u'bodhi') approve_testing.main(['nosetests', 'some_config.ini']) bodhi = self.db.query(models.User).filter_by(name=u'bodhi').one() cmnts = self.db.query(models.Comment).filter_by(update_id=update.id, user_id=bodhi.id) # There are 3 comments: testing_approval_msg, build change, testing_approval_msg self.assertEqual(cmnts.count(), 3) self.assertEqual( cmnts[0].text, config.get('testing_approval_msg') % update.release.mandatory_days_in_testing) self.assertEqual(cmnts[1].text, 'Removed build') self.assertEqual( cmnts[2].text, config.get('testing_approval_msg') % update.release.mandatory_days_in_testing)
def test_non_autokarma_update_with_unmet_karma_requirement(self): """ A non-autokarma update without enough karma should not get comments from Bodhi. """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.request = None update.stable_karma = 10 update.status = models.UpdateStatus.testing with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with fml_testing.mock_sends(): approve_testing.main(['nosetests', 'some_config.ini']) # The update should have one positive karma and no negative karmas assert update._composite_karma == (1, 0) # The bodhi user shouldn't exist, since it shouldn't have made any comments assert self.db.query(models.User).filter_by(name='bodhi').count() == 0 # There are two comments, but none from the non-existing bodhi user. assert self.db.query(models.Comment).count() == 2 usernames = [ c.user.name for c in self.db.query(models.Comment).order_by( models.Comment.timestamp).all() ] assert usernames == ['guest', 'anonymous']
def test_update_conflicting_build_not_pushed(self, build_creation_time): """ Ensure that an update that have conflicting builds will not get pushed. """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.autotime = True update.request = None update.stable_karma = 1 update.stable_days = 7 update.date_testing = datetime.utcnow() - timedelta(days=8) update.status = models.UpdateStatus.testing update.release.composed_by_bodhi = False update.from_tag = 'f17-build-side-1234' # Clear pending messages self.db.info['messages'] = [] self.db.commit() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with fml_testing.mock_sends(api.Message): approve_testing.main(['nosetests', 'some_config.ini']) assert update.status == models.UpdateStatus.pending bodhi = self.db.query(models.User).filter_by(name='bodhi').one() cmnts = self.db.query(models.Comment).filter_by(update_id=update.id, user_id=bodhi.id) assert cmnts.count() == 2 assert cmnts[0].text == config.get('testing_approval_msg') assert cmnts[1].text == "This update cannot be pushed to stable. "\ "These builds bodhi-2.0-1.fc17 have a more recent build in koji's "\ f"{update.release.stable_tag} tag."
def test_autotime_update_zero_day_in_testing_meeting_test_requirements_gets_pushed( self): """ Ensure that an autotime update with 0 mandatory_days_in_testing that meets the test requirements gets pushed to stable. """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.autotime = True update.request = None update.stable_karma = 10 update.stable_days = 0 update.date_testing = datetime.utcnow() - timedelta(days=0) update.status = models.UpdateStatus.testing # Clear pending messages self.db.info['messages'] = [] self.db.commit() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with fml_testing.mock_sends(api.Message, api.Message): approve_testing.main(['nosetests', 'some_config.ini']) assert update.request == models.UpdateRequest.stable assert update.status == models.UpdateStatus.testing assert update.date_stable is None
def test_autotime_update_no_autokarma_met_karma_requirements_get_comments( self): """ Ensure that an autotime update which met the karma requirements but has autokarma off get a comment to let the packager know that he can push the update to stable. """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.autotime = True update.request = None update.stable_karma = 1 update.stable_days = 10 update.date_testing = datetime.utcnow() - timedelta(days=0) update.status = models.UpdateStatus.testing # Clear pending messages self.db.info['messages'] = [] update.comment(self.db, u'Works great', author=u'luke', karma=1) with fml_testing.mock_sends(api.Message): self.db.commit() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with fml_testing.mock_sends(api.Message): approve_testing.main(['nosetests', 'some_config.ini']) assert update.request is None bodhi = self.db.query(models.User).filter_by(name='bodhi').one() cmnts = self.db.query(models.Comment).filter_by(update_id=update.id, user_id=bodhi.id) assert cmnts.count() == 1 assert cmnts[0].text == config.get('testing_approval_msg')
def test_autotime_update_zero_day_in_testing_fail_gating_is_not_pushed( self): """ Ensure that an autotime update with 0 mandatory days in testing that failed gating does not get pushed to stable. """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.autotime = True update.request = None update.stable_karma = 10 update.stable_days = 0 update.test_gating_status = models.TestGatingStatus.failed update.date_testing = datetime.utcnow() - timedelta(days=0) update.status = models.UpdateStatus.testing # Clear pending messages self.db.info['messages'] = [] self.db.commit() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): approve_testing.main(['nosetests', 'some_config.ini']) assert update.request is None
def test_non_autokarma_update_without_mandatory_days_in_testing(self): """ If the Update's release doesn't have a mandatory days in testing, main() should ignore it (and should not comment on the update at all, even if it does reach karma levels.) """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.autotime = False update.request = None update.stable_karma = 1 update.status = models.UpdateStatus.testing with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): approve_testing.main(['nosetests', 'some_config.ini']) # The update should have one positive karma and no negative karmas assert update._composite_karma == (1, 0) # The bodhi user shouldn't exist, since it shouldn't have made any comments assert self.db.query(models.User).filter_by(name='bodhi').count() == 0 # There are two comments, but none from the non-existing bodhi user. assert self.db.query(models.Comment).count() == 2 usernames = [ c.user.name for c in self.db.query(models.Comment).order_by( models.Comment.timestamp).all() ] assert usernames == ['guest', 'anonymous']
def test_log_level_is_left_alone(self, exit): """Ensure calling main() here leaves the global log level alone. This is because having it changed can play havoc on other tests that examine logging output.""" class SentinelInt(int): """A child class of int which is suited as a sentinel value. The important difference to int is that SentinelInt doesn't use singleton objects for low values: >>> 5 is 5 True >>> SentinelInt(5) is SentinelInt(5) False """ saved_log_level = logging.root.level sentinel = logging.root.level = SentinelInt(logging.WARNING) with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): approve_testing.main( ['nosetests', 'some_config.ini', 'testnoses']) assert logging.root.level is sentinel logging.root.level = saved_log_level
def test_autokarma_update_without_mandatory_days_in_testing(self): """ If the Update's release doesn't have a mandatory days in testing, main() should ignore it (and should not comment on the update at all, even if it does reach karma levels.) """ update = self.db.query(models.Update).all()[0] update.autokarma = True update.autotime = False update.request = None update.status = models.UpdateStatus.testing # Clear pending messages self.db.info['messages'] = [] update.date_testing = datetime.utcnow() - timedelta(days=7) # Let's delete all the comments to make our assertion at the end of this simpler. for c in update.comments: self.db.delete(c) with fml_testing.mock_sends(): self.db.commit() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with fml_testing.mock_sends(): approve_testing.main(['nosetests', 'some_config.ini']) # The bodhi user shouldn't exist, since it shouldn't have made any comments assert self.db.query(models.User).filter_by(name='bodhi').count() == 0 assert self.db.query(models.Comment).count() == 0
def test_non_autokarma_update_with_unmet_karma_requirement_after_time_met( self): """ A non-autokarma update without enough karma that reaches mandatory days in testing should get a comment from Bodhi that the update can be pushed to stable. See https://github.com/fedora-infra/bodhi/issues/1094 """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.autotime = False update.request = None update.stable_karma = 10 update.status = models.UpdateStatus.testing update.date_testing = datetime.utcnow() - timedelta(days=7) self.db.flush() # Clear pending messages self.db.info['messages'] = [] with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with fml_testing.mock_sends(api.Message): approve_testing.main(['nosetests', 'some_config.ini']) # The update should have one positive karma and no negative karmas assert update._composite_karma == (1, 0) bodhi = self.db.query(models.User).filter_by(name='bodhi').one() comment_q = self.db.query(models.Comment).filter_by( update_id=update.id, user_id=bodhi.id) assert comment_q.count() == 1 assert comment_q[0].text == config.get('testing_approval_msg')
def test_autotime_update_with_autokarma_met_karma_and_time_requirements_get_pushed( self): """ Ensure that an autotime update which met the karma and time requirements and has autokarma and autotime enable gets pushed. """ update = self.db.query(models.Update).all()[0] update.autokarma = True update.autotime = True update.request = None update.stable_karma = 1 update.stable_days = 0 update.date_testing = datetime.utcnow() - timedelta(days=0) update.status = models.UpdateStatus.testing # Clear pending messages self.db.info['messages'] = [] update.comment(self.db, u'Works great', author=u'luke', karma=1) with fml_testing.mock_sends(api.Message, api.Message, api.Message): self.db.commit() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): approve_testing.main(['nosetests', 'some_config.ini']) assert update.request == models.UpdateRequest.stable bodhi = self.db.query(models.User).filter_by(name='bodhi').one() cmnts = self.db.query(models.Comment).filter_by(update_id=update.id, user_id=bodhi.id) assert cmnts.count() == 1 assert cmnts[ 0].text == 'This update has been submitted for stable by bodhi. '
def test_non_autokarma_update_with_unmet_karma_requirement(self): """ A non-autokarma update without enough karma should not get comments from Bodhi. """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.request = None update.stable_karma = 10 update.status = models.UpdateStatus.testing update.comment(self.db, 'testing', author='hunter2', karma=1) with fml_testing.mock_sends(api.Message): self.db.commit() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with fml_testing.mock_sends(): approve_testing.main(['nosetests', 'some_config.ini']) # The bodhi user shouldn't exist, since it shouldn't have made any comments self.assertEqual( self.db.query(models.User).filter_by(name='bodhi').count(), 0) # There are three comments, but none from the non-existing bodhi user. self.assertEqual(self.db.query(models.Comment).count(), 3) usernames = [ c.user.name for c in self.db.query(models.Comment).order_by( models.Comment.timestamp).all() ] self.assertEqual(usernames, ['guest', 'anonymous', 'hunter2'])
def test_autotime_update_no_autokarma_negative_karma_not_pushed(self): """ Ensure that an autotime update which negative karma does not get pushed. """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.autotime = True update.request = None update.stable_karma = 1 update.stable_days = 0 update.date_testing = datetime.utcnow() - timedelta(days=8) update.status = models.UpdateStatus.testing # Clear pending messages self.db.info['messages'] = [] update.comment(self.db, u'Broken', author=u'luke', karma=-1) with fml_testing.mock_sends(api.Message): self.db.commit() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with fml_testing.mock_sends(api.Message): approve_testing.main(['nosetests', 'some_config.ini']) assert update.request is None assert update.autotime == False
def test_exception_handler(self, stdout, exit, remove, comment, composed_by_bodhi): """The Exception handler prints the Exception, rolls back and closes the db, and exits.""" update = self.db.query(models.Update).all()[0] update.date_testing = datetime.utcnow() - timedelta(days=15) update.request = None update.status = models.UpdateStatus.testing update.release.composed_by_bodhi = composed_by_bodhi self.db.flush() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with patch.object(self.db, 'commit'): with patch.object(self.db, 'rollback'): approve_testing.main(['nosetests', 'some_config.ini']) assert self.db.commit.call_count == 0 self.db.rollback.assert_called_once_with() exit.assert_called_once_with(1) comment.assert_called_once_with( self.db, ('This update can be pushed to stable now if the maintainer wishes' ), author='bodhi', email_notification=composed_by_bodhi, ) assert stdout.getvalue() == f'{update.alias} now meets testing requirements' \ '\nThe DB died lol\n' remove.assert_called_once_with()
def test_autokarma_update_not_meeting_testing_requirements(self): """ If an autokarma update has not met the testing requirements, bodhi should not comment on the update. """ update = self.db.query(models.Update).all()[0] update.autokarma = True update.request = None update.status = models.UpdateStatus.testing # Clear pending messages self.db.info['messages'] = [] # 6 days isn't enough time to meet the testing requirements. update.date_testing = datetime.utcnow() - timedelta(days=6) # Let's delete all the comments to make our assertion at the end of this simpler. for c in update.comments: self.db.delete(c) with fml_testing.mock_sends(): self.db.commit() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with fml_testing.mock_sends(): approve_testing.main(['nosetests', 'some_config.ini']) # The bodhi user shouldn't exist, since it shouldn't have made any comments assert self.db.query(models.User).filter_by(name='bodhi').count() == 0 assert self.db.query(models.Comment).count() == 0
def test_subsequent_comments_after_initial_push_comment(self): """ If a user edits an update after Bodhi comments a testing_approval_msg, Bodhi should send an additional testing_approval_msg when the revised update is eligible to be pushed to stable. See https://github.com/fedora-infra/bodhi/issues/1310 """ update = self.db.query(models.Update).all()[0] update.request = None update.status = models.UpdateStatus.testing update.date_testing = datetime.utcnow() - timedelta(days=14) update.autotime = False self.db.flush() # Clear pending messages self.db.info['messages'] = [] with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with fml_testing.mock_sends(api.Message): approve_testing.main(['nosetests', 'some_config.ini']) update.comment(self.db, "Removed build", 0, 'bodhi') with fml_testing.mock_sends(api.Message): approve_testing.main(['nosetests', 'some_config.ini']) bodhi = self.db.query(models.User).filter_by(name='bodhi').one() cmnts = self.db.query(models.Comment).filter_by(update_id=update.id, user_id=bodhi.id) # There are 3 comments: testing_approval_msg, build change, testing_approval_msg assert cmnts.count() == 3 assert cmnts[0].text == config.get('testing_approval_msg') assert cmnts[1].text == 'Removed build' assert cmnts[2].text == config.get('testing_approval_msg')
def test_autotime_update_zero_day_in_testing_no_gated_gets_pushed_to_rawhide( self, mail, remove_tag, add_tag, from_side_tag): """ Ensure that an autotime update with 0 mandatory_days_in_testing that meets the test requirements gets pushed to stable in rawhide. Test for normal updates and such from a side tags, where it and its auxiliary tags need to be removed. """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.autotime = True update.request = None update.release.composed_by_bodhi = False update.stable_karma = 10 update.stable_days = 0 update.date_testing = datetime.utcnow() - timedelta(days=0) update.status = models.UpdateStatus.testing update.from_tag = from_side_tag # Clear pending messages self.db.info['messages'] = [] self.db.commit() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with fml_testing.mock_sends(api.Message): approve_testing.main(['nosetests', 'some_config.ini']) assert update.request is None assert update.date_stable is not None assert update.status == models.UpdateStatus.stable assert update.pushed assert update.date_pushed is not None if not from_side_tag: # First pass, it adds f17=updates-pending, then since we're pushing # to stable directly, it adds f17-updates (the stable tag) then # removes f17-updates-testing-pending and f17-updates-pending assert remove_tag.call_args_list == \ [call('f17-updates-testing-pending'), call('f17-updates-pending'), call('f17-updates-signing-pending'), call('f17-updates-candidate')] assert add_tag.call_args_list == \ [call('f17-updates')] else: assert remove_tag.call_args_list == \ [call(f'{from_side_tag}-signing-pending'), call(f'{from_side_tag}-testing-pending'), call(from_side_tag)] assert add_tag.call_args_list == \ [call('f17-updates')] assert mail.send.call_count == 1
def test_usage(self, stdout, exit): """ Assert that the usage message is returned to the user if not exactly 2 arguments are given """ with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): approve_testing.main(['nosetests', 'some_config.ini', 'testnoses']) self.assertEqual( stdout.getvalue(), 'usage: nosetests <config_uri>\n(example: "nosetests development.ini")\n') exit.assert_called_once_with(1)
def test_exception_handler_on_the_second_update(self, stdout, exit, remove, comment, composed_by_bodhi): """ Ensure, that when the Exception is raised, all previous transactions are commited, the Exception handler prints the Exception, rolls back and closes the db, and exits. """ update = self.db.query(models.Update).all()[0] update.autotime = False update.date_testing = datetime.utcnow() - timedelta(days=15) update.request = None update.release.composed_by_bodhi = composed_by_bodhi update.status = models.UpdateStatus.testing update2 = self.create_update(['bodhi2-2.0-1.fc17']) update2.autotime = False update2.date_testing = datetime.utcnow() - timedelta(days=15) update2.request = None update2.status = models.UpdateStatus.testing self.db.flush() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with patch.object(self.db, 'commit'): with patch.object(self.db, 'rollback'): approve_testing.main(['nosetests', 'some_config.ini']) assert self.db.commit.call_count == 1 self.db.rollback.assert_called_once_with() exit.assert_called_once_with(1) comment_expected_call = call( self.db, ('This update can be pushed to stable now if the maintainer wishes' ), author='bodhi', email_notification=composed_by_bodhi, ) assert comment.call_args_list == [ comment_expected_call, comment_expected_call ] assert stdout.getvalue() == \ (f'{update2.alias} now meets testing requirements\n' f'{update.alias} now meets testing requirements\nThe DB died lol\n') remove.assert_called_once_with()
def test_non_autokarma_critpath_update_meeting_time_requirements_gets_one_comment( self): """ Ensure that a critpath update that meets the required time in testing (14 days) gets a comment from Bodhi indicating that the update has met the required time in testing. There was an issue[0] where Bodhi was indicating that the update had been in testing for only 7 days, when the update had been in testing for 14 days. [0] https://github.com/fedora-infra/bodhi/issues/1361 """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.request = None update.stable_karma = 10 update.critpath = True update.status = models.UpdateStatus.testing update.date_testing = datetime.utcnow() - timedelta(days=14) with fml_testing.mock_sends(): self.db.commit() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with fml_testing.mock_sends(api.Message): approve_testing.main(['nosetests', 'some_config.ini']) # Now we will run main() again, but this time we expect Bodhi not to add any # further comments. with fml_testing.mock_sends(): approve_testing.main(['nosetests', 'some_config.ini']) update = self.db.query(models.Update).all()[0] self.assertEqual(update.critpath, True) self.assertEqual(update.mandatory_days_in_testing, 14) bodhi = self.db.query(models.User).filter_by(name='bodhi').one() comment_q = self.db.query(models.Comment).filter_by( update_id=update.id, user_id=bodhi.id) self.assertEqual(comment_q.count(), 1) self.assertEqual( comment_q[0].text, config.get('testing_approval_msg') % update.mandatory_days_in_testing) self.assertEqual(update.release.mandatory_days_in_testing, 7) self.assertEqual(update.mandatory_days_in_testing, 14)
def test_non_autokarma_critpath_update_meeting_karma_requirements_gets_one_comment( self): """ Ensure that a non-autokarma critical path update that meets the required karma threshold and required time in testing gets only one comment from Bodhi to that effect, even on subsequent runs of main(). There was an issue[0] where Bodhi wasn't correctly detecting when it should add these comments, and with detecting that it has already commented on critical path updates, and would repeatedly comment that these updates could be pushed. This test ensures that issue stays fixed. [0] https://github.com/fedora-infra/bodhi/issues/1009 """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.autotime = False # Make this update a critpath update to force meets_testing_requirements into a different # code path. update.critpath = True # It's been in testing long enough to get the comment from bodhi that it can be pushed. update.date_testing = datetime.utcnow() - timedelta(days=15) update.request = None update.stable_karma = 1 update.status = models.UpdateStatus.testing # Clear pending messages self.db.info['messages'] = [] update.comment(self.db, 'testing', author='hunter2', karma=1) with fml_testing.mock_sends(api.Message): self.db.commit() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with fml_testing.mock_sends(api.Message): approve_testing.main(['nosetests', 'some_config.ini']) # Now we will run main() again, but this time we expect Bodhi not to add any # further comments. approve_testing.main(['nosetests', 'some_config.ini']) bodhi = self.db.query(models.User).filter_by(name='bodhi').one() comment_q = self.db.query(models.Comment).filter_by( update_id=update.id, user_id=bodhi.id) assert comment_q.count() == 1 assert comment_q[0].text == config.get('testing_approval_msg')
def test_autokarma_update_meeting_time_requirements_gets_one_comment( self, mail): """ Ensure that an update that meets the required time in testing gets only one comment from Bodhi to that effect, even on subsequent runs of main(). """ update = self.db.query(models.Update).all()[0] update.autokarma = True update.autotime = False update.request = None update.stable_karma = 10 update.status = models.UpdateStatus.testing # Clear pending messages self.db.info['messages'] = [] update.date_testing = datetime.utcnow() - timedelta(days=7) with fml_testing.mock_sends(): self.db.commit() expected_message = update_schemas.UpdateRequirementsMetStableV1.from_dict( {'update': update}) with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with fml_testing.mock_sends(expected_message): approve_testing.main(['nosetests', 'some_config.ini']) # The approve testing script changes the update, so let's put the changed # update into our expected message body. expected_message.body[ 'update'] = models.Update.query.first().__json__() # Now we will run main() again, but this time we expect Bodhi not to add any # further comments. with fml_testing.mock_sends(): approve_testing.main(['nosetests', 'some_config.ini']) bodhi = self.db.query(models.User).filter_by(name='bodhi').one() comment_q = self.db.query(models.Comment).filter_by( update_id=update.id, user_id=bodhi.id) assert comment_q.count() == 1 assert comment_q[0].text == config.get('testing_approval_msg') assert mail.send.call_count == 1
def test_autotime_update_does_not_meet_test_requirements(self): """ Ensure that an autotime update that does not meet the test requirements does not pushed to stable. """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.autotime = True update.request = None update.stable_days = update.mandatory_days_in_testing update.stable_karma = 10 update.date_testing = datetime.utcnow() - timedelta(days=1) update.status = models.UpdateStatus.testing # Clear pending messages self.db.info['messages'] = [] self.db.commit() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): approve_testing.main(['nosetests', 'some_config.ini']) assert update.request is None
def test_autotime_update_does_no_mandatory_days_in_testing(self): """ Ensure that an autotime update that does not have mandatory days in testing does get pushed to stable. """ update = self.db.query(models.Update).all()[0] update.autokarma = False update.autotime = True update.request = None update.stable_karma = 10 update.date_testing = datetime.utcnow() update.status = models.UpdateStatus.testing # Clear pending messages self.db.info['messages'] = [] self.db.commit() with patch('bodhi.server.scripts.approve_testing.initialize_db'): with patch('bodhi.server.scripts.approve_testing.get_appsettings', return_value=''): with fml_testing.mock_sends(api.Message, api.Message): approve_testing.main(['nosetests', 'some_config.ini']) assert update.request == models.UpdateRequest.stable