def test_send_verification_code(self): """ Test users/send_verification_code. """ # Create a user with a phone number, for testing. formatted_number = utils.format_phone_number(PHONE_NUMBER) User.objects.filter(phone_number=formatted_number).delete() user = users.create(phone_number=PHONE_NUMBER) # Set up a signal listener to check that the verification message is # being sent via Twilio. self.twilio_sms_sent = False # initially. self.twilio_from_phone = None # ditto. self.twilio_to_phone = None # ditto. def twilio_signal_handler(sender, **kwargs): self.twilio_sms_sent = True self.twilio_from_phone = kwargs.get("from_phone") self.twilio_to_phone = kwargs.get("to_phone") signals.twilio_sms_sent.connect(twilio_signal_handler) # Ask the user API to send the verification code. Note that we disable # Twilio so that no actual SMS is sent. with self.settings(ENABLE_TWILIO=False): users.send_verification_code(user_id=user['id']) # Check that the Twilio gateway sent the verification message. self.assertTrue(self.twilio_sms_sent) self.assertEqual(self.twilio_from_phone, settings.SYSTEM_PHONE_NUMBER) self.assertEqual(self.twilio_to_phone, formatted_number) # Run the test again, this time supplying the phone number rather than # the user ID. self.twilio_sms_sent = False with self.settings(ENABLE_TWILIO=False): users.send_verification_code(phone_number=PHONE_NUMBER) self.assertTrue(self.twilio_sms_sent) # Finally, clean everything up. signals.twilio_sms_sent.disconnect(twilio_signal_handler)
def test_stop_and_restart(self): """ Test conversations/stop and conversations/restart. Note that this is combined into a single unit test because most of the complexity is in setting up the conversation -- it makes sense to test both at once so we don't have to set up the conversation twice. """ # Create two random users for testing. username_1 = utils.random_username() password_1 = utils.random_password() username_2 = utils.random_username() password_2 = utils.random_password() user_1_id = users.create(username=username_1, password=password_1, phone_number=PHONE_NUMBER)['id'] user_2_id = users.create(username=username_2, password=password_2, phone_number=PHONE_NUMBER_2)['id'] # Calculate a verification code for the two users. with self.settings(ENABLE_TWILIO=False): users.send_verification_code(phone_number=PHONE_NUMBER) users.send_verification_code(phone_number=PHONE_NUMBER_2) # Get the underlying User objects. user_1 = User.objects.get(id=user_1_id) user_2 = User.objects.get(id=user_2_id) # Open up two sessions, one for each user. Note that this also # verifies the users' phone numbers. session_1 = users.login(phone_number=PHONE_NUMBER, verification_code=user_1.verification_code) session_2 = users.login(phone_number=PHONE_NUMBER_2, verification_code=user_2.verification_code) # Get the default topic for user 1. We'll use this as the topic for # our conversation. topic_id = topics.list(session_1)[0]['id'] topic = Topic.objects.get(id=topic_id) # Send a message from user_2 to user_1 about the topic. This creates a # conversation between the two users. with self.settings(ENABLE_TWILIO=False, ENABLE_PUBNUB=False): messages.send(session_2, topic_id=topic.id, message="Hello") # Find the Conversation and make sure it isn't stopped. conversation = conversationHandler.get(user_1.id, user_2.id, topic.id) self.assertFalse(conversation.stopped) # Set up a signal listener to check that the "stopped" message is being # sent out via Twilio to both users. self.twilio_messages = [] def twilio_signal_handler(sender, **kwargs): self.twilio_messages.append(kwargs.get("message")) signals.twilio_sms_sent.connect(twilio_signal_handler) # Now try stopping the conversation. This should send an SMS to each # party. with self.settings(ENABLE_TWILIO=False, ENABLE_PUBNUB=False): conversations.stop(session_1, topic_id=topic.id, other_user_id=user_2.id) # Check that the conversation was stopped. conversation = conversationHandler.get(user_1.id, user_2.id, topic.id) self.assertTrue(conversation.stopped) # Check that the two SMS messages were sent. self.assertEqual(len(self.twilio_messages), 2) # Now try restarting the conversation. Once again, this should send # out an SMS message to each party. self.twilio_messages = [] with self.settings(ENABLE_TWILIO=False, ENABLE_PUBNUB=False): conversations.restart(session_1, topic_id=topic.id, other_user_id=user_2.id) # Check that the conversation was restarted. conversation = conversationHandler.get(user_1.id, user_2.id, topic.id) self.assertFalse(conversation.stopped) # Check that the two SMS messages were sent. self.assertEqual(len(self.twilio_messages), 2) # Finally, clean up. signals.twilio_sms_sent.disconnect(twilio_signal_handler)