def test_basic(self): transactional_message = Message(options={u'transactional': True}, **self.msg_kwargs) for key in self.msg_kwargs: self.assertEqual(getattr(transactional_message, key), self.msg_kwargs.get(key)) self.assertIsNotNone(transactional_message.uuid) assert transactional_message.options.get(u'transactional') # pylint: disable=no-member normal_message = Message(**self.msg_kwargs) assert not dict(normal_message.options)
def test_log_level(self, log_level, expect_log_warn, expect_log_debug): logging.getLogger().setLevel(logging.INFO) self.msg_kwargs[u'log_level'] = log_level message = Message(**self.msg_kwargs) logger = message.get_message_specific_logger(LOG) with patch(u'logging.Logger.callHandlers') as mock_log: logger.warning(u'Test warning statement') self.assertEqual(mock_log.called, expect_log_warn) with patch(u'logging.Logger.callHandlers') as mock_log: logger.debug(u'Test debug statement') self.assertEqual(mock_log.called, expect_log_debug)
def test_ace_send_happy_path(self): patch_policies(self, [StubPolicy([ChannelType.PUSH])]) mock_channel = Mock( channel_type=ChannelType.EMAIL, action_links=[], tracker_image_sources=[], ) recipient = Recipient(username=u'testuser') msg = Message( app_label=u'testapp', name=u'testmessage', recipient=recipient, ) channel_map = ChannelMap([ [u'sailthru_email', mock_channel], ]) with patch(u'edx_ace.channel.channels', return_value=channel_map): ace.send(msg) mock_channel.deliver.assert_called_once_with( msg, RenderedEmail( from_name=u'template from_name.txt', subject=u'template subject.txt', # The new lines are needed because the template has some tags, which means leftover newlines body_html=u'template body.html\n\n\n\n\n', head_html=u'template head.html\n', body=u'template body.txt', ), )
def _course_update_schedule_send(site_id, msg_str): site = Site.objects.get(pk=site_id) if not ScheduleConfig.current(site).deliver_course_update: return msg = Message.from_string(msg_str) ace.send(msg)
def test_happy_path(self): channel = FileEmailChannel() rendered_message = RenderedEmail( from_name=u'Robot', head_html=u'<img src="https://tracker/.img" />', subject=u'\n Hello from \r\nRobot ! \n', body=u'Just trying to see what is like to talk to a human!', body_html=u""" <p>Just trying to see what is like to talk to a human!</p> <hr /> """, ) with NamedTemporaryFile('r+') as f: message = Message( app_label=u'testapp', name=u'testmessage', options={ u'from_address': u'*****@*****.**', PATH_OVERRIDE_KEY: f.name, }, recipient=Recipient(username=u'Robot', email_address=u'*****@*****.**'), ) channel.deliver(message, rendered_message) contents = f.read() assert u'subject: Hello from' in contents assert u'to: [email protected]' in contents assert u'body: Just trying to see what' in contents assert u'talk to a human!</p>' in contents
def _deserialize_field(cls, field_name, field_value): u""" Deserialize a single encoded field value for this message. Arguments: field_name (str): The name of the field being decoded. field_value: The value of field being deserialized. """ # We have to import these here to avoid a circular dependency since these classes use this mixin. from edx_ace.recipient import Recipient from edx_ace.message import Message if field_value is None: return None if field_name == u'expiration_time': return date.deserialize(field_value) elif field_name in (u'uuid', u'send_uuid'): return UUID(field_value) # TODO(later): should this be more dynamic? elif field_name == u'message': return Message(**field_value) elif field_name == u'recipient': return Recipient(**field_value) else: return field_value
def test_ace_send_happy_path(self, _mock_get_template): patch_policies(self, [StubPolicy([ChannelType.PUSH])]) mock_channel = Mock( name=u'test_channel', channel_type=ChannelType.EMAIL ) patch_channels(self, [mock_channel]) recipient = Recipient(username=u'testuser') msg = Message( app_label=u'testapp', name=u'testmessage', recipient=recipient, ) ace.send(msg) mock_channel.deliver.assert_called_once_with( msg, RenderedEmail( from_name=TEMPLATES[u'testapp/edx_ace/testmessage/email/from_name.txt'].render(), subject=TEMPLATES[u'testapp/edx_ace/testmessage/email/subject.txt'].render(), body_html=TEMPLATES[u'testapp/edx_ace/testmessage/email/body.html'].render(), head_html=TEMPLATES[u'testapp/edx_ace/testmessage/email/head.html'].render(), body=TEMPLATES[u'testapp/edx_ace/testmessage/email/body.txt'].render(), ), )
def _upgrade_reminder_schedule_send(site_id, msg_str): site = Site.objects.get(pk=site_id) if not ScheduleConfig.current(site).deliver_upgrade_reminder: return msg = Message.from_string(msg_str) ace.send(msg)
def _recurring_nudge_schedule_send(site_id, msg_str): site = Site.objects.get(pk=site_id) if not ScheduleConfig.current(site).deliver_recurring_nudge: LOG.debug('Recurring Nudge: Message delivery disabled for site %s', site.domain) return msg = Message.from_string(msg_str) LOG.debug('Recurring Nudge: Sending message = %s', msg_str) ace.send(msg)
def test_ace_send_unsupported_channel(self, *_args): recipient = Recipient(username=u'testuser') msg = Message( app_label=u'testapp', name=u'testmessage', recipient=recipient, ) ace.send(msg) # UnsupportedChannelError shouldn't throw UnsupportedChannelError
def test_default_channel(self): channel_map = ChannelMap([ ['sailthru', SailthruEmailChannel], ]) message = Message(options={u'transactional': True}, **self.msg_kwargs) with patch(u'edx_ace.channel.channels', return_value=channel_map): channel = get_channel_for_message(ChannelType.EMAIL, message) assert channel is SailthruEmailChannel
def test_get_channel_for_message(self): channel_map = ChannelMap([ [u'file_email', FileEmailChannel], [u'sailthru_email', SailthruEmailChannel], ]) transactional_msg = Message(options={u'transactional': True}, **self.msg_kwargs) info_msg = Message(options={}, **self.msg_kwargs) with patch(u'edx_ace.channel.channels', return_value=channel_map): assert get_channel_for_message( ChannelType.EMAIL, transactional_msg) is FileEmailChannel assert get_channel_for_message(ChannelType.EMAIL, info_msg) is SailthruEmailChannel with self.assertRaises(UnsupportedChannelError): assert get_channel_for_message(ChannelType.PUSH, transactional_msg)
def create_test_message(self): return Message( app_label='foo', name='bar', recipient=Recipient( username=self.student.username, email_address=self.student.email, ), context={'course_ids': [str(self.course.id)]}, )
def test_with_no_from_address_with_default(self): message = Message( app_label='testapp', name='testmessage', options={}, recipient=Recipient(lms_user_id=123, email_address='*****@*****.**'), ) self.channel.deliver(message, self.mock_rendered_message) assert len(mail.outbox) == 1, 'Should have one email'
def _get_rendered_message(self): channel = DjangoEmailChannel() message = Message( app_label='testapp', name='testmessage', options={}, recipient=Recipient(lms_user_id=123, email_address='*****@*****.**'), ) return render(channel, message)
def test_with_no_from_address_without_default(self): message = Message( app_label='testapp', name='testmessage', options={}, recipient=Recipient(lms_user_id=123, email_address='*****@*****.**'), ) with self.assertRaises(FatalChannelDeliveryError): self.channel.deliver(message, self.mock_rendered_message)
def _schedule_send(msg_str, site_id, delivery_config_var, log_prefix): # lint-amnesty, pylint: disable=missing-function-docstring site = Site.objects.select_related('configuration').get(pk=site_id) if _is_delivery_enabled(site, delivery_config_var, log_prefix): msg = Message.from_string(msg_str) user = User.objects.get(id=msg.recipient.lms_user_id) with emulate_http_request(site=site, user=user): _annonate_send_task_for_monitoring(msg) LOG.debug('%s: Sending message = %s', log_prefix, msg_str) ace.send(msg) _track_message_sent(site, user, msg)
def _schedule_send(msg_str, site_id, delivery_config_var, log_prefix): site = Site.objects.select_related('configuration').get(pk=site_id) if _is_delivery_enabled(site, delivery_config_var, log_prefix): msg = Message.from_string(msg_str) user = User.objects.get(username=msg.recipient.username) with emulate_http_request(site=site, user=user): _annonate_send_task_for_monitoring(msg) LOG.debug('%s: Sending message = %s', log_prefix, msg_str) ace.send(msg) _track_message_sent(site, user, msg)
def _schedule_send(msg_str, site_id, delivery_config_var, log_prefix): site = Site.objects.select_related('configuration').get(pk=site_id) if _is_delivery_enabled(site, delivery_config_var, log_prefix): msg = Message.from_string(msg_str) user = User.objects.get(username=msg.recipient.username) with emulate_http_request(site=site, user=user): _annonate_send_task_for_monitoring(msg) LOG.debug(u'%s: Sending message = %s', log_prefix, msg_str) ace.send(msg) _track_message_sent(site, user, msg)
def test_no_recipient_email_address(self): message = Message( app_label='testapp', name='testmessage', options={}, recipient=Recipient(lms_user_id=123), ) rendered_email = render(self.channel, message) with self.assertRaisesRegex(InvalidMessageError, 'No email address'): deliver(self.channel, rendered_email, message)
def send_ace_message(goal): """ Send an email reminding users to stay on track for their learning goal in this course Arguments: goal (CourseGoal): Goal object """ user = goal.user try: course = CourseOverview.get_from_id(goal.course_key) except CourseOverview.DoesNotExist: log.error("Goal Reminder course not found.") course_name = course.display_name site = Site.objects.get_current() message_context = get_base_template_context(site) course_home_url = reverse(course_home_url_name(course.id), args=[str(course.id)]) course_home_absolute_url_parts = ("https", site.name, course_home_url, '', '', '') course_home_absolute_url = six.moves.urllib.parse.urlunparse( course_home_absolute_url_parts) goals_unsubscribe_url = reverse('course-home:unsubscribe-from-course-goal', kwargs={'token': goal.unsubscribe_token}) message_context.update({ 'email': user.email, 'platform_name': configuration_helpers.get_value('PLATFORM_NAME', settings.PLATFORM_NAME), 'course_name': course_name, 'days_per_week': goal.days_per_week, 'course_url': course_home_absolute_url, 'goals_unsubscribe_url': goals_unsubscribe_url, 'unsubscribe_url': None, # We don't want to include the default unsubscribe link }) msg = Message(name="goalreminder", app_label="course_goals", recipient=Recipient(user.id, user.email), language=get_user_preference(user, LANGUAGE_KEY), context=message_context) with emulate_http_request(site, user): ace.send(msg)
def _recurring_nudge_schedule_send(site_id, msg_str): site = Site.objects.get(pk=site_id) if not ScheduleConfig.current(site).deliver_recurring_nudge: LOG.debug('Recurring Nudge: Message delivery disabled for site %s', site.domain) return msg = Message.from_string(msg_str) # A unique identifier for this batch of messages being sent. set_custom_metric('send_uuid', msg.send_uuid) # A unique identifier for this particular message. set_custom_metric('uuid', msg.uuid) LOG.debug('Recurring Nudge: Sending message = %s', msg_str) ace.send(msg)
def setUp(self): super(TestDelivery, self).setUp() self.mock_channel = Mock(name=u'test_channel', channel_type=ChannelType.EMAIL) patch_channels(self, [self.mock_channel]) self.recipient = Recipient(username=str(sentinel.username)) self.message = Message( app_label=str(sentinel.app_label), name=str(sentinel.name), recipient=self.recipient, ) self.current_time = datetime.datetime.utcnow().replace(tzinfo=tzutc())
def test_render_email_with_sailthru(self): message = Message( app_label=u'testapp', name=u'testmessage', options={}, recipient=Recipient(username=u'Robot', email_address=u'*****@*****.**'), ) rendered_email = render(self.channel, message) assert u'{beacon_src}' in rendered_email.body_html assert u'{view_url}' in rendered_email.body_html assert u'{optout_confirm_url}' in rendered_email.body_html
def _send_message_task(self, schedule, offset, target_day): """ Calls the task for sending a message to the given schedule and for the given offset and target_day. Returns the message that would have been sent. """ sent_messages = [] with patch.object(self.task, 'async_send_task') as mock_schedule_send: mock_schedule_send.apply_async = lambda args, *_a, **_kw: sent_messages.append(args[1]) self.task().apply(kwargs=dict( site_id=self.site_config.site.id, target_day_str=serialize(target_day), day_offset=offset, bin_num=self._calculate_bin_for_user(schedule.enrollment.user), )) self.assertEqual(len(sent_messages), 1) return Message.from_string(sent_messages[0])
def send_calendar_sync_email(self, msg_string, from_address=None): """ Sending calendar sync email to the user. """ msg = Message.from_string(msg_string) max_retries = settings.RETRY_CALENDAR_SYNC_EMAIL_MAX_ATTEMPTS retries = self.request.retries if from_address is None: from_address = configuration_helpers.get_value( 'ACTIVATION_EMAIL_FROM_ADDRESS') or ( configuration_helpers.get_value('email_from_address', settings.DEFAULT_FROM_EMAIL)) msg.options['from_address'] = from_address dest_addr = msg.recipient.email_address site = Site.objects.get_current() user = User.objects.get(username=msg.recipient.username) try: with emulate_http_request(site=site, user=user): ace.send(msg) # Log that the Activation Email has been sent to user without an exception log.info( "Calendar Sync Email has been sent to User {user_email}".format( user_email=dest_addr)) except RecoverableChannelDeliveryError: log.info( 'Retrying sending email to user {dest_addr}, attempt # {attempt} of {max_attempts}' .format(dest_addr=dest_addr, attempt=retries, max_attempts=max_retries)) try: self.retry(countdown=settings.RETRY_ACTIVATION_EMAIL_TIMEOUT, max_retries=max_retries) except MaxRetriesExceededError: log.error( 'Unable to send calendar sync email to user from "%s" to "%s"', from_address, dest_addr, exc_info=True) except Exception: log.exception( 'Unable to send calendar sync email to user from "%s" to "%s"', from_address, dest_addr, ) raise Exception
def test_on_behalf_option_with_sailthru(self, message_options, expected_options): """ Tests sailthru send API is called with on_behalf option """ message = Message( app_label=u'testapp', name=u'testmessage', options=message_options, recipient=Recipient(username=u'Robot', email_address=u'*****@*****.**'), ) rendered_email = render(self.channel, message) with patch('edx_ace.channel.sailthru.SailthruClient.send') as mock_send: deliver(self.channel, rendered_email, message) self.assertEqual(mock_send.call_args_list[0][1]['options'], expected_options)
def setUp(self): super(TestDelivery, self).setUp() self.mock_channel = Mock(name=u'test_channel', channel_type=ChannelType.EMAIL) self.recipient = Recipient(username=str(sentinel.username)) self.message = Message( app_label=str(sentinel.app_label), name=str(sentinel.name), options={ u'from_address': u'*****@*****.**', }, recipient=self.recipient, ) self.current_time = datetime.datetime.utcnow().replace(tzinfo=tzutc())
def _schedule_send(msg_str, site_id, delivery_config_var, log_prefix): site = Site.objects.get(pk=site_id) if _is_delivery_enabled(site, delivery_config_var, log_prefix): msg = Message.from_string(msg_str) user = User.objects.get(username=msg.recipient.username) middleware_classes = [ CurrentRequestUserMiddleware, CurrentSiteThemeMiddleware, ] with emulate_http_request(site=site, user=user, middleware_classes=middleware_classes): _annonate_send_task_for_monitoring(msg) LOG.debug('%s: Sending message = %s', log_prefix, msg_str) ace.send(msg)
def send_activation_email(self, msg_string, from_address=None): """ Sending an activation email to the user. """ msg = Message.from_string(msg_string) max_retries = settings.RETRY_ACTIVATION_EMAIL_MAX_ATTEMPTS retries = self.request.retries if from_address is None: from_address = configuration_helpers.get_value('ACTIVATION_EMAIL_FROM_ADDRESS') or ( configuration_helpers.get_value('email_from_address', settings.DEFAULT_FROM_EMAIL) ) msg.options['from_address'] = from_address dest_addr = msg.recipient.email_address try: ace.send(msg) # Log that the Activation Email has been sent to user without an exception log.info("Activation Email has been sent to User {user_email}".format( user_email=dest_addr )) except RecoverableChannelDeliveryError: log.info('Retrying sending email to user {dest_addr}, attempt # {attempt} of {max_attempts}'.format( dest_addr=dest_addr, attempt=retries, max_attempts=max_retries )) try: self.retry(countdown=settings.RETRY_ACTIVATION_EMAIL_TIMEOUT, max_retries=max_retries) except MaxRetriesExceededError: log.error( 'Unable to send activation email to user from "%s" to "%s"', from_address, dest_addr, exc_info=True ) except Exception: # pylint: disable=bare-except log.exception( 'Unable to send activation email to user from "%s" to "%s"', from_address, dest_addr, exc_info=True ) raise Exception
def send_activation_email(self, msg_string, from_address=None): """ Sending an activation email to the user. """ msg = Message.from_string(msg_string) max_retries = settings.RETRY_ACTIVATION_EMAIL_MAX_ATTEMPTS retries = self.request.retries if from_address is None: from_address = configuration_helpers.get_value( 'ACTIVATION_EMAIL_FROM_ADDRESS') or ( configuration_helpers.get_value('email_from_address', settings.DEFAULT_FROM_EMAIL)) msg.options['from_address'] = from_address dest_addr = msg.recipient.email_address site = Site.objects.get_current() user = User.objects.get(id=msg.recipient.lms_user_id) try: with emulate_http_request(site=site, user=user): ace.send(msg) except RecoverableChannelDeliveryError: log.info( 'Retrying sending email to user {dest_addr}, attempt # {attempt} of {max_attempts}' .format(dest_addr=dest_addr, attempt=retries, max_attempts=max_retries)) try: self.retry(countdown=settings.RETRY_ACTIVATION_EMAIL_TIMEOUT, max_retries=max_retries) except MaxRetriesExceededError: log.error( 'Unable to send activation email to user from "%s" to "%s"', from_address, dest_addr, exc_info=True) except Exception: log.exception( 'Unable to send activation email to user from "%s" to "%s"', from_address, dest_addr, ) raise Exception # lint-amnesty, pylint: disable=raise-missing-from
def _contains_upsell_attribute(self, msg_attr): msg = Message.from_string(msg_attr) tmp = msg.context["show_upsell"] return msg.context["show_upsell"]
def _contains_upsell(self, message_str): message = Message.from_string(message_str) return message.context["show_upsell"]
def _schedule_send(msg_str, site_id, delivery_config_var, log_prefix): if _is_delivery_enabled(site_id, delivery_config_var, log_prefix): msg = Message.from_string(msg_str) _annonate_send_task_for_monitoring(msg) LOG.debug('%s: Sending message = %s', log_prefix, msg_str) ace.send(msg)