def __given_second_list_modifier_returns_no_jid_handles(self):
UnExpectedJidHandles = []
UnExpectedJidHandles.append(JidHandle('someUserName', 'someCrazyJid'))
UnExpectedJidHandles.append(
JidHandle('someOtherUserName', 'someOtherJid'))
with Spy() as FirstFilter:
FirstFilter.getJidHandleGroupResult(any(), any(), any()) >> Result(
[JidHandleGroup(UnExpectedJidHandles)])
with Spy() as SecondFilter:
SecondFilter.getJidHandleGroupResult(any(), any(),
any()) >> Result([])
with Spy() as ThirdFilter:
ThirdFilter.getJidHandleGroupResult(any(), any(), any()) >> Result(
[JidHandleGroup(UnExpectedJidHandles)])
with Spy() as MockedConfig:
MockedConfig.getOrderedRecipientListModifiers() >> [
FirstFilter, SecondFilter, ThirdFilter
]
MockedConfig.getJidHandleGroups() >> [
JidHandleGroup(UnExpectedJidHandles)
]
self.__MyConfig = MockedConfig
def __weShouldForwardPendingMessages(self, messageBody):
for JidHandleGroup in self.__JidHandleGroups:
if JidHandleGroup.getGroupIdentifierString(
) and JidHandleGroup.getGroupIdentifierString() in messageBody:
return True
return False
def test_returns_first_jid_handle_retrieved_from_config_when_there_are_multiple(
self):
JidHandles = self.__given_multiple_jid_handles_in_configuration()
Filter = FirstRecipientFilter(self.__MyConfig)
ActualResult = Filter.getJidHandleGroupResult(
[JidHandleGroup(JidHandles)], None, '')
ExpectedJidHandles = [JidHandles[0]]
self.assertEquals([JidHandleGroup(ExpectedJidHandles)],
ActualResult.getJidHandleGroups())
def __given_multiple_jid_handles_in_configuration_with_no_list_modifiers(
self):
ExpectedJidHandles = []
ExpectedJidHandles.append(JidHandle('someUserName', 'someCrazyJid'))
ExpectedJidHandles.append(
JidHandle('someOtherUserName', 'someOtherJid'))
with Spy() as MockedConfig:
MockedConfig.getJidHandleGroups() >> [
JidHandleGroup(ExpectedJidHandles)
]
MockedConfig.getOrderedRecipientListModifiers() >> []
self.__MyConfig = MockedConfig
return [JidHandleGroup(ExpectedJidHandles)]
def test_getJidHandleGroups_returns_expected_jid_handles_from_same_file(
self):
ExpectedJidHandleGroups = []
ExpectedJidHandleGroups.append(
JidHandleGroup([self.__given_test_setup_is_correct()]))
ExpectedJidHandleGroups.append(
JidHandleGroup(
self.
__given_jid_handle_group_file_location_exists_with_multiple_handles(
)))
MyConfig = self._getConfig()
ActualJidHandleGroups = MyConfig.getJidHandleGroups()
self.assertEquals(ExpectedJidHandleGroups, ActualJidHandleGroups)
def __sendRequestConfirmedMessage(self, sender):
messageBody = self._MessageBuilder.getRequestConfirmedMessageBody(
self._RecipientChooser.getJidHandleFromJid(sender))
RequesterHandles = self.__Filter.getRequesterJidHandles()
RequesterConfirmationMessage = Message(
[JidHandleGroup(RequesterHandles)], messageBody)
self._ItBot.sendMessage(RequesterConfirmationMessage)
def __sendHelpDeskUserCouldNotForwardToGroupMessage(self, sender):
messageBody = self._MessageBuilder.getHelpdeskUserCouldNotForwardToGroupMessageBody(
)
SenderJidHandle = [JidHandle('', sender)]
CouldNotForwardMessage = Message([JidHandleGroup(SenderJidHandle)],
messageBody)
self._ItBot.sendMessage(CouldNotForwardMessage)
def __sendHelpDeskUserConfirmationMessage(self, sender):
messageBody = self._MessageBuilder.getHelpdeskUserConfirmationMessageBody(
)
SenderJidHandle = [JidHandle('', sender)]
HelpDeskUserConfirmationMessage = Message(
[JidHandleGroup(SenderJidHandle)], messageBody)
self._ItBot.sendMessage(HelpDeskUserConfirmationMessage)
def __notifyRequestersMessagesHaveBeenEmailed(self):
messageBody = self._MessageBuilder.getNobodyAvailableMessageBody()
Requesters = self.__Filter.getRequesterJidHandles()
RequesterMessage = Message([JidHandleGroup(Requesters)], messageBody)
self._ItBot.sendMessage(RequesterMessage)
def __given_presence_will_be_confirmed(self, mockMessageBuilder=False):
if mockMessageBuilder:
builderMock = Spy()
with Stub() as RecipientFilter:
RecipientFilter.presenceConfirmed()
RecipientFilter.getRequesterJidHandles() >> []
self.__RecipientFilter = RecipientFilter
else:
builderMock = Stub()
with builderMock as MessageBuilder:
MessageBuilder.presenceConfirmed()
MessageBuilder.getRequestConfirmedMessageBody(any()) >> 'something'
MessageBuilder.getHelpdeskUserConfirmationMessageBody(
) >> 'something else'
self.__MessageBuilder = MessageBuilder
with Spy() as RecipientChooser:
JidHandles = [JidHandle.JidHandle('', self.__sender)]
RecipientChooser.getJidHandleGroupResult(any(), any()) >> Result(
[JidHandleGroup(JidHandles)])
RecipientChooser.getJidHandleFromJid(any())
RecipientChooser.getRecipientListModifierByClass(
any()) >> self.__RecipientFilter
self.__RecipientChooser = RecipientChooser
self.__and_we_have_a_pending_confirmation_request()
def test_returns_all_available_jid_handles(self):
self.__given_all_jid_handles_are_available()
Result = self.__getResult()
self.assertEquals([JidHandleGroup(self.__JidHandles)],
Result.getJidHandleGroups())
def test_returns_no_jid_handles_if_none_passed(self):
Setting = self.__givenDailySettingWithTodaysDateNumberBeing(1)
self.__JidHandleGroups = [JidHandleGroup([])]
SortedJidHandles = self._getSortedJidHandles(Setting)
self.assertEquals([], SortedJidHandles)
def __sendForwardedMessageBackToSender(self, sender):
messageBody = self._MessageBuilder.getMessageForwardedMessageBody()
SenderJidHandle = [JidHandle('', sender)]
MessageForwardedMessage = Message([JidHandleGroup(SenderJidHandle)],
messageBody)
self._ItBot.sendMessage(MessageForwardedMessage)
def test_returns_first_jid_handle_if_it_is_available_and_second_is_not(
self):
self.__given_first_jid_handle_is_available_and_second_is_not()
ExpectedJidHandleGroup = [JidHandleGroup([self.__JidHandles[0]])]
Result = self.__getResult()
self.assertEquals(ExpectedJidHandleGroup, Result.getJidHandleGroups())
def test_returns_second_available_jid_handle_when_first_jid_handle_is_unavailable(
self):
self.__given_second_jid_handle_is_available_and_first_is_not()
Result = self.__getResult()
self.assertEquals([JidHandleGroup([self.__JidHandles[1]])],
Result.getJidHandleGroups())
def _sendConfirmationMessage(self, sender):
confirmationMessageBody = self._MessageBuilder.getImmediateSenderConfirmationMessageBody(
)
ConfirmationMessage = Message.Message(
[JidHandleGroup([JidHandle.JidHandle('', sender)])],
confirmationMessageBody)
self._ItBot.sendMessage(ConfirmationMessage)
def __given_recipient_filter_returns_requester(self):
JidHandles = [JidHandle.JidHandle('', '*****@*****.**')]
self.__ExpectedJidHandleGroups = [JidHandleGroup(JidHandles)]
with Spy() as RecipientFilter:
RecipientFilter.getRequesterJidHandles() >> JidHandles
self.__RecipientFilter = RecipientFilter
def __notifyPreviousRequestedRecipient(self, PreviousRequestedRecipient,
NextRequestedRecipient):
messageBody = self._MessageBuilder.getTimedOutNotificationMessageBody(
NextRequestedRecipient)
NotificationMessage = Message(
[JidHandleGroup(PreviousRequestedRecipient)], messageBody)
self._ItBot.sendMessage(NotificationMessage)
def __given_recipient_chooser_returns_a_jid_handle(self):
ExpectedRecipientJidHandles = [
JidHandle.JidHandle("someUserName", "*****@*****.**")
]
self.__ExpectedJidHandleGroups = [
JidHandleGroup(ExpectedRecipientJidHandles)
]
self.__getMockedRecipientChooser(self.__ExpectedJidHandleGroups)
def __given_pending_request_exists_and_has_timed_out(self):
with Spy() as PresenceConfirmationManager:
PresenceConfirmationManager.hasPendingRequest() >> True
PresenceConfirmationManager.hasTimedOut() >> True
PresenceConfirmationManager.startNewRequest()
self.__PresenceConfirmationManager = PresenceConfirmationManager
PreviousRequestedRecipient = [
JidHandle('somePreviousJid', '*****@*****.**')
]
JidHandles = [JidHandle('someJid', '*****@*****.**')]
JidHandleGroups = [JidHandleGroup(JidHandles)]
with Spy() as RecipientChooser:
RecipientChooser.getJidHandleGroupResult(
any(), any()) >> Result(JidHandleGroups)
RecipientChooser.getCurrentRequestedRecipient(
) >> PreviousRequestedRecipient
self.__RecipientChooser = RecipientChooser
relayMessageBody = 'Some Message Body'
notificationMessageBody = 'Hey snoozer your message has been forwarded'
with Stub() as MessageBuilder:
MessageBuilder.getTimedOutNotificationMessageBody(
any()) >> notificationMessageBody
MessageBuilder.getPendingMessagesForRequestedRecipient(
) >> relayMessageBody
self.__MessageBuilder = MessageBuilder
self.__ExpectedForwardedMessage = Message(JidHandleGroups,
relayMessageBody)
self.__ExpectedNotificationMessage = Message(
[JidHandleGroup(PreviousRequestedRecipient)],
notificationMessageBody)
self.__ExpectedRequesterNotificationMessage = Message(
[JidHandleGroup(PreviousRequestedRecipient)],
notificationMessageBody)
with Spy() as ItBot:
pass
self.__ItBot = ItBot
def __given_sender_is_current_requested_recipient(self):
with Stub() as RecipientChooser:
JidHandles = [JidHandle.JidHandle('', self.__sender)]
RecipientChooser.getJidHandleGroupResult(any(), any()) >> Result(
[JidHandleGroup(JidHandles)])
RecipientChooser.getJidHandleFromJid(any())
RecipientChooser.getRecipientListModifierByClass(
any()) >> self.__RecipientFilter
self.__RecipientChooser = RecipientChooser
def __given_multiple_recipients_passed(self):
ExpectedJidHandle = [
JidHandle.JidHandle('someExpectedjid', '*****@*****.**')
]
self.__PassedJidHandleGroups.append(
JidHandleGroup([
self.__CurrentRequestedRecipient[0],
JidHandle.JidHandle('someOtherjid', '*****@*****.**'),
ExpectedJidHandle[0]
]))
return ExpectedJidHandle
def __given_pending_request_exists_and_has_timed_out_and_nobody_is_available(
self):
with Spy() as PresenceConfirmationManager:
PresenceConfirmationManager.hasPendingRequest() >> True
PresenceConfirmationManager.hasTimedOut() >> True
self.__PresenceConfirmationManager = PresenceConfirmationManager
PreviousRequestedRecipient = [
JidHandle('somePreviousJid', '*****@*****.**')
]
RequesterJidHandles = [
JidHandle('someRequesterJid', '*****@*****.**')
]
with Spy() as Filter:
Filter.getRequesterJidHandles() >> RequesterJidHandles
Filter.getCurrentRequestedRecipient() >> PreviousRequestedRecipient
JidHandles = [JidHandle('someJid', '*****@*****.**')]
JidHandleGroups = [JidHandleGroup(JidHandles)]
with Spy() as RecipientChooser:
RecipientChooser.getJidHandleGroupResult(
any(), any()) >> Result(resultCode=Result.NOBODY_AVAILABLE)
RecipientChooser.getRecipientListModifierByClass(any()) >> Filter
self.__RecipientChooser = RecipientChooser
nobodyAvailableMessageBody = 'Nobody here son!'
with Spy() as MessageBuilder:
MessageBuilder.getNobodyAvailableMessageBody(
) >> nobodyAvailableMessageBody
self.__MessageBuilder = MessageBuilder
self.__ExpectedRequesterNotificationMessage = Message(
[JidHandleGroup(RequesterJidHandles)], nobodyAvailableMessageBody)
with Spy() as ItBot:
pass
self.__ItBot = ItBot
def test_does_not_send_a_confirmation_message_if_the_requester_has_already_received_one_this_request(
self):
self.__given_requester_has_already_received_confirmation_message()
BotEventCoordinator = self.__getBotEventCoordinator()
BotEventCoordinator.handleMessageReceived(self.__sender,
'some message')
JidHandles = [JidHandle.JidHandle('', self.__sender)]
ConfirmationMessage = Message.Message([JidHandleGroup(JidHandles)],
self.__immediateSenderConfMsg)
verify(
self.__ItBot).sendMessage(ConfirmationMessage).called(times == 0)
def __given_multiple_jid_handles_in_configuration(self):
ExpectedJidHandles = []
ExpectedJidHandles.append(
JidHandle.JidHandle('someUserName', 'someCrazyJid'))
ExpectedJidHandles.append(
JidHandle.JidHandle('someOtherUserName', 'someOtherJid'))
with Spy() as MockedConfig:
MockedConfig.getJidHandleGroups() >> [
JidHandleGroup(ExpectedJidHandles)
]
self.__MyConfig = MockedConfig
return ExpectedJidHandles
def test_returns_all_jid_handles_passed_when_sender_is_not_in_list(self):
JidHandleGroups = [
JidHandleGroup([
self._getJidHandle(),
self._getJidHandle(),
self._getJidHandle()
])
]
Filter = self.__getFilter()
Result = Filter.getJidHandleGroupResult(JidHandleGroups, '', '')
self.assertEquals(JidHandleGroups, Result.getJidHandleGroups())
def setRequestedRecipientToPassedGroupIdentifier(self, messageBody, JidHandleGroups): for JidHandleGroup in JidHandleGroups: if (JidHandleGroup.getGroupIdentifierString() in messageBody): MyRecipientChooser = RecipientChooser(self.__MyConfig, [JidHandleGroup]) Result = MyRecipientChooser.getJidHandleGroupResult(None, messageBody) if Result.hasJidHandles(): for JidHandle in Result.getJidHandleGroups()[0].getJidHandles(): if JidHandle not in self.__IgnoredRecipients: self.__RequestedRecipient = Result.getJidHandleGroups()[0].getJidHandles() self.__RequestedJidHandleGroup = JidHandleGroup self.__timeOutLastConfirmedRecipient() return True return False
def __given_sender_is_different_requested_recipient(self):
with Spy() as RecipientFilter:
RecipientFilter.getRequesterJidHandles() >> []
RecipientFilter.addRequester(any())
RecipientFilter.alreadyMessagedRequester(any()) >> False
self.__RecipientFilter = RecipientFilter
with Stub(proxy=self.__RecipientChooser) as RecipientChooser:
JidHandles = [JidHandle.JidHandle('', '*****@*****.**')]
RecipientChooser.getJidHandleGroupResult(any(), any()) >> Result(
[JidHandleGroup(JidHandles)])
RecipientChooser.getRecipientListModifierByClass(
any()) >> self.__RecipientFilter
self.__RecipientChooser = RecipientChooser
def __given_first_list_modifier_returns_dont_send_message_result(self):
with Spy() as FirstFilter:
FirstFilter.getJidHandleGroupResult(any(), any(), any()) >> Result(
resultCode=Result.DONT_SEND_ANY_MESSAGE)
UnExpectedJidHandles = []
UnExpectedJidHandles.append(JidHandle('someUserName', 'someCrazyJid'))
UnExpectedJidHandles.append(
JidHandle('someOtherUserName', 'someOtherJid'))
with Spy() as SecondFilter:
SecondFilter.getJidHandleGroupResult(
any(), any(), any()) >> Result(UnExpectedJidHandles)
with Spy() as MockedConfig:
MockedConfig.getOrderedRecipientListModifiers() >> [
FirstFilter, SecondFilter
]
MockedConfig.getJidHandleGroups() >> [
JidHandleGroup([]),
JidHandleGroup(UnExpectedJidHandles)
]
self.__MyConfig = MockedConfig
def test_returns_all_jid_handles_minus_the_sender(self):
senderHandle = self._getJidHandle()
JidHandleGroups = [
JidHandleGroup(
[senderHandle,
self._getJidHandle(),
self._getJidHandle()])
]
ExpectedJidHandleGroups = JidHandleGroups[::]
ExpectedJidHandleGroups[0].getJidHandles().pop(0)
Filter = self.__getFilter()
Result = Filter.getJidHandleGroupResult(JidHandleGroups,
senderHandle.getJid(), '')
self.assertEquals(ExpectedJidHandleGroups, Result.getJidHandleGroups())
def currentRequestedUserHasTimedOut(self): if not (self.__noAvailableUsers): if (self.__RequestedRecipient): self.__IgnoredRecipients.append(self.__RequestedRecipient[0]) self.__timeOutLastConfirmedRecipient() JidHandleGroups = self.__getOrderedJidHandleGroups() for JidHandleGroup in JidHandleGroups: for JidHandle in JidHandleGroup.getJidHandles(): if (JidHandle not in self.__IgnoredRecipients): self.__RequestedRecipient = [JidHandle] return self.__RequestedRecipient = [] self.__RequestedJidHandleGroup = None self.__noAvailableUsers = True
def __given_message_builder_returns_a_sender_confirmation_and_relay_message_body(
self):
expectedMessageBody = "Successfully forwarded."
with Spy() as MockedMessageBuilder:
MockedMessageBuilder.getImmediateSenderConfirmationMessageBody(
) >> expectedMessageBody
MockedMessageBuilder.getRelayMessageBody(
self.__sender, 'some message') >> 'some message'
self.__MessageBuilder = MockedMessageBuilder
self.__ExpectedRelayMessage = Message.Message(
self.__ExpectedJidHandleGroups, 'some message')
self.__ExpectedMessage._Message__RecipientJidHandleGroups = [
JidHandleGroup([JidHandle.JidHandle('', self.__sender)])
]
self.__ExpectedMessage._Message__messageBody = expectedMessageBody
def __weShouldForwardPendingMessages(self, messageBody): for JidHandleGroup in self.__JidHandleGroups: if JidHandleGroup.getGroupIdentifierString() and JidHandleGroup.getGroupIdentifierString() in messageBody: return True return False
