def test_shouldNotifyUserWhenHeIsSubscribedToQueue(self):
branch = self._config.get_branches()[0]
self._merge_dispatcher.subscribe(self._first_user_id, branch)
self._notifier.reset_mock()
self._merge_dispatcher.merge(self._second_user_id, branch)
self._merge_dispatcher.merge(self._third_user_id, branch)
self._notifier.notify.assert_any_call(
self._model.get_user(self._first_user_id),
NotifierActions.starts_merge,
Notifier.ActionData(self._model.get_user(self._second_user_id),
branch))
self._notifier.notify.assert_any_call(
self._model.get_user(self._first_user_id),
NotifierActions.joins_queue,
Notifier.ActionData(self._model.get_user(self._third_user_id),
branch))
def test_shouldSendMessageIfSomeoneStartedMergeFixInYourQueue(self):
self._presentation_model.notify(
self._whom_user, NotifierActions.starts_fix,
Notifier.MergeFixActionData(self._action_user, self._branch, None))
message = str.format(Messages.ACTION_MESSAGE_STARTS_FIX,
self._action_user.get_name(), self._branch)
self._message_sender.send.assert_called_once_with(
self._whom_user_id, message)
def test_shouldSendMessageIfUserFinishedMerge(self):
self._presentation_model.notify(
self._whom_user, NotifierActions.done_merge,
Notifier.ActionData(self._action_user, self._branch))
message = self.generate_message(self._action_user, self._branch,
NotifierActions.done_merge)
self._message_sender.send.assert_called_once_with(
self._whom_user_id, message)
def test_shouldSendMessageIfMergeStartedBySameUserAsSender(self):
self._presentation_model.notify(
self._whom_user, NotifierActions.starts_merge,
Notifier.ActionData(self._whom_user, self._branch))
message = str.format(Messages.ACTION_MESSAGE_STARTED_MERGE,
self._branch)
self._message_sender.send.assert_called_once_with(
self._whom_user_id, message)
def test_shouldSendMessageIfUserReadyToMerge(self):
self._presentation_model.notify(
self._whom_user, NotifierActions.ready_to_merge,
Notifier.ActionData(self._whom_user, self._branch))
message = str.format(Messages.ACTION_MESSAGE_YOUR_MERGE_TURN,
self._branch)
self._message_sender.request_merge_confirmation.assert_called_once_with(
self._whom_user_id, message, self._branch)
def test_shouldSendMessageIfYouWasPushedAwayByMergeFix(self):
self._presentation_model.notify(
self._whom_user, NotifierActions.starts_fix,
Notifier.MergeFixActionData(self._action_user, self._branch,
self._whom_user))
message = str.format(Messages.ACTION_MESSAGE_PUSH_BACK,
self._action_user.get_name(), self._branch)
self._message_sender.send.assert_called_once_with(
self._whom_user_id, message)
def test_shouldNotifyWhenUserJoinsQueue(self):
branch = self._config.get_branches()[0]
self._merge_dispatcher.merge(self._first_user_id, branch)
self._notifier.reset_mock()
self._merge_dispatcher.merge(self._second_user_id, branch)
self._notifier.notify.assert_any_call(
self._model.get_user(self._first_user_id),
NotifierActions.joins_queue,
Notifier.ActionData(self._model.get_user(self._second_user_id),
branch))
def test_shouldSendMessageIfYouKickedYourself(self):
self._presentation_model.notify(
self._whom_user, NotifierActions.kicks_himself,
Notifier.KickActionData(self._whom_user, self._branch,
self._whom_user))
message = str.format(
"You've kicked yourself from branch <b>{}</b>. Tell me, are you alright? Next "
"time use /cancel command, it much more effective.", self._branch)
self._message_sender.send.assert_called_once_with(
self._whom_user_id, message)
def test_shouldSendMessageIfSomeoneKickedHimself(self):
self._presentation_model.notify(
self._whom_user, NotifierActions.kicks_himself,
Notifier.KickActionData(self._action_user, self._branch,
self._action_user))
message = str.format(
"<i>{0}</i> has kicked himself from branch <b>{1}</b>. What a strange way for suicide.",
self._action_user.get_name(), self._branch)
self._message_sender.send.assert_called_once_with(
self._whom_user_id, message)
def test_shouldSendMessageIfSomeoneKickedYou(self):
self._presentation_model.notify(
self._whom_user, NotifierActions.kicks_user,
Notifier.KickActionData(self._action_user, self._branch,
self._whom_user))
message = str.format(
"<i>{0}</i> has kicked you from branch <b>{1}</b>. Nothing personal, only business.",
self._action_user.get_name(), self._branch)
self._message_sender.send.assert_called_once_with(
self._whom_user_id, message)
def test_shouldNotifyWhenUserExitsQueue(self):
branch = self._config.get_branches()[0]
self._merge_dispatcher.merge(self._first_user_id, branch)
self._merge_dispatcher.merge(self._second_user_id, branch)
self._notifier.reset_mock()
self._merge_dispatcher.cancel(self._second_user_id, branch)
self._notifier.notify.assert_called_once_with(
self._model.get_user(self._first_user_id),
NotifierActions.exits_queue,
Notifier.ActionData(self._model.get_user(self._second_user_id),
branch))
def test_shouldSendMessageIfSomeoneKickedUser(self):
self._presentation_model.notify(
self._whom_user, NotifierActions.kicks_user,
Notifier.KickActionData(self._action_user, self._branch,
self._kicked_user))
message = str.format(
"<i>{0}</i> has kicked {1} from branch <b>{2}</b>. Even I shocked by this cruelty.",
self._action_user.get_name(), self._kicked_user.get_name(),
self._branch)
self._message_sender.send.assert_called_once_with(
self._whom_user_id, message)
def test_shouldNotifyActiveUserWhenHeIsPutBackToQueue(self):
branch = self._config.get_branches()[0]
self._merge_dispatcher.merge(self._first_user_id, branch)
self._notifier.reset_mock()
self._merge_dispatcher.fix(self._second_user_id, branch)
self._notifier.notify.assert_any_call(
self._model.get_user(self._first_user_id),
NotifierActions.starts_fix,
Notifier.MergeFixActionData(
self._model.get_user(self._second_user_id), branch,
self._model.get_user(self._first_user_id)))
def test_shouldNotifyWhenNextUserFromQueueReadyToMergeAfterDone(self):
branch = self._config.get_branches()[0]
self._merge_dispatcher.merge(self._first_user_id, branch)
self._merge_dispatcher.merge(self._second_user_id, branch)
self._merge_dispatcher.merge(self._third_user_id, branch)
self._notifier.reset_mock()
self._merge_dispatcher.done(self._first_user_id, branch)
self._notifier.notify.assert_any_call(
self._model.get_user(self._second_user_id),
NotifierActions.ready_to_merge,
Notifier.ActionData(self._model.get_user(self._second_user_id),
branch))
def test_shouldNotifyIfUserStartsMergeWhenHeIsNext(self):
branch = self._config.get_branches()[0]
self._merge_dispatcher.merge(self._first_user_id, branch)
self._merge_dispatcher.merge(self._second_user_id, branch)
self._merge_dispatcher.merge(self._third_user_id, branch)
self._merge_dispatcher.cancel(self._first_user_id, branch)
self._merge_dispatcher.confirm_merge(self._second_user_id, branch)
self._notifier.notify.assert_any_call(
self._model.get_user(self._third_user_id),
NotifierActions.starts_merge,
Notifier.ActionData(self._model.get_user(self._second_user_id),
branch))
def test_shouldNotifyUsersWhenSomeoneStartsFix(self):
branch = self._config.get_branches()[0]
self._merge_dispatcher.merge(self._first_user_id, branch)
self._merge_dispatcher.merge(self._second_user_id, branch)
self._notifier.reset_mock()
self._merge_dispatcher.fix(self._third_user_id, branch)
self._notifier.notify.assert_any_call(
self._model.get_user(self._first_user_id),
NotifierActions.starts_fix,
Notifier.MergeFixActionData(
self._model.get_user(self._third_user_id), branch,
self._model.get_user(self._first_user_id)))
def test_shouldNotifyOnPrepareWhenNoActiveUserBurUserInQueue(self):
branch = self._config.get_branches()[0]
self._merge_dispatcher.merge(self._first_user_id, branch)
self._merge_dispatcher.merge(self._second_user_id, branch)
self._merge_dispatcher.merge(self._third_user_id, branch)
self._merge_dispatcher.done(self._first_user_id, branch)
self._notifier.reset_mock()
self._merge_dispatcher.prepare()
self._notifier.notify.assert_any_call(
self._model.get_user(self._second_user_id),
NotifierActions.ready_to_merge,
Notifier.ActionData(self._model.get_user(self._second_user_id),
branch))
def test_shouldNotifyWhenUserExitsQueueAndNoActiveUser(self):
branch = self._config.get_branches()[0]
self._merge_dispatcher.merge(self._first_user_id, branch)
self._merge_dispatcher.merge(self._second_user_id, branch)
self._merge_dispatcher.merge(self._third_user_id, branch)
self._merge_dispatcher.cancel(self._first_user_id, branch)
self._notifier.reset_mock()
self._merge_dispatcher.cancel(self._second_user_id, branch)
self._notifier.notify.assert_any_call(
self._model.get_user(self._third_user_id),
NotifierActions.ready_to_merge,
Notifier.ActionData(self._model.get_user(self._third_user_id),
branch))
def test_shouldNotifyUsersWhenUserKicksHimself(self):
branch = self._config.get_branches()[0]
self._merge_dispatcher.merge(self._first_user_id, branch)
self._merge_dispatcher.merge(self._second_user_id, branch)
self._merge_dispatcher.kick(self._first_user_id, self._first_user_id,
branch)
action_data = Notifier.KickActionData(
self._model.get_user(self._first_user_id), branch,
self._model.get_user(self._first_user_id))
self._notifier.notify.assert_any_call(
self._model.get_user(self._first_user_id),
NotifierActions.kicks_himself, action_data)
self._notifier.notify.assert_any_call(
self._model.get_user(self._second_user_id),
NotifierActions.kicks_himself, action_data)
def test_shouldNotSendMessageIfSameUserAsSenderFinishedMerge(self):
self._presentation_model.notify(
self._whom_user, NotifierActions.done_merge,
Notifier.ActionData(self._whom_user, self._branch))
self._message_sender.send.assert_not_called()
def test_shouldNotSendMessageIfSameUserAsSenderExitsQueue(self):
self._presentation_model.notify(
self._whom_user, NotifierActions.exits_queue,
Notifier.ActionData(self._whom_user, self._branch))
self._message_sender.send.assert_not_called()
def test_shouldNotSendMessageIfUserReadyToMerge(self):
self._presentation_model.notify(
self._whom_user, NotifierActions.ready_to_merge,
Notifier.ActionData(self._action_user, self._branch))
self._message_sender.send.assert_not_called()
def test_baseClassShouldRaiseNotImplementedException(self):
notifier = Notifier()
with self.assertRaises(NotImplementedError):
notifier.notify(User("Jack Daniels", 123),
NotifierActions.starts_merge, None)
