import bs4
import copy
import datetime
import functools
import time
from django.conf import settings as django_settings
from django.core import management
from django.core import serializers
import django.core.mail
from django.core.urlresolvers import reverse
from django.test import TestCase
from django.test.client import Client
from askbot.tests import utils
from askbot.tests.utils import with_settings
from askbot import models
from askbot import mail
from askbot.conf import settings as askbot_settings
from askbot import const
from askbot.models.question import Thread
TO_JSON = functools.partial(serializers.serialize, 'json')
def email_alert_test(test_func):
"""decorator for test methods in
:class:`~askbot.tests.email_alert_tests.EmailAlertTests`
wraps tests with a generic sequence of testing
email alerts on updates to anything relating to
given question
"""
@functools.wraps(test_func)
def wrapped_test(test_object, *args, **kwargs):
func_name = test_func.__name__
if func_name.startswith('test_'):
test_name = func_name.replace('test_', '', 1)
#run the main codo of the test function
test_func(test_object)
#if visit_timestamp is set,
#target user will visit the question at that time
test_object.maybe_visit_question()
test_object.send_alerts()
test_object.check_results(test_name)
else:
raise ValueError('test method names must have prefix "test_"')
return wrapped_test
def setup_email_alert_tests(setup_func):
@functools.wraps(setup_func)
def wrapped_setup(test_object, *args, **kwargs):
#empty email subscription schedule
#no email is sent
test_object.notification_schedule = \
copy.deepcopy(models.EmailFeedSetting.NO_EMAIL_SCHEDULE)
#timestamp to use for the setup
#functions
test_object.setup_timestamp = datetime.datetime.now()
#timestamp to use for the question visit
#by the target user
#if this timestamp is None then there will be no visit
#otherwise question will be visited by the target user
#at that time
test_object.visit_timestamp = None
#dictionary to hols expected results for each test
#actual data@is initialized in the code just before the function
#or in the body of the subclass
test_object.expected_results = dict()
#do not follow by default (do not use q_sel type subscription)
test_object.follow_question = False
#fill out expected result for each test
test_object.expected_results['q_ask'] = {'message_count': 0, }
test_object.expected_results['q_ask_delete_answer'] = {'message_count': 0, }
test_object.expected_results['question_comment'] = {'message_count': 0, }
test_object.expected_results['question_comment_delete'] = {'message_count': 0, }
test_object.expected_results['answer_comment'] = {'message_count': 0, }
test_object.expected_results['answer_delete_comment'] = {'message_count': 0, }
test_object.expected_results['mention_in_question'] = {'message_count': 0, }
test_object.expected_results['mention_in_answer'] = {'message_count': 0, }
test_object.expected_results['question_edit'] = {'message_count': 0, }
test_object.expected_results['answer_edit'] = {'message_count': 0, }
test_object.expected_results['question_and_answer_by_target'] = {'message_count': 0, }
test_object.expected_results['q_ans'] = {'message_count': 0, }
test_object.expected_results['q_ans_new_answer'] = {'message_count': 0, }
#this function is expected to contain a difference between this
#one and the desired setup within the concrete test
setup_func(test_object)
#must call this after setting up the notification schedule
#because it is needed in setUpUsers() function
test_object.setUpUsers()
return wrapped_setup
class SubjectLineTests(TestCase):
"""Tests for the email subject line"""
def test_set_prefix(self):
"""set prefix and see if it is there
"""
askbot_settings.update('EMAIL_SUBJECT_PREFIX', 'test prefix')
subj = mail.prefix_the_subject_line('hahah')
self.assertEquals(subj, 'test prefix hahah')
def test_can_disable_prefix(self):
"""set prefix to empty string and make sure
that the subject line is not altered"""
askbot_settings.update('EMAIL_SUBJECT_PREFIX', '')
subj = mail.prefix_the_subject_line('hahah')
self.assertEquals(subj, 'hahah')
class EmailAlertTests(TestCase):
"""Base class for testing delayed Email notifications
that are triggered by the send_email_alerts
command
this class tests cases where target user has no subscriptions
that is all subscriptions off
subclasses should redefine initial data via the static
class member this class tests cases where target user has no subscriptions
that is all subscriptions off
this class also defines a few utility methods that do
not run any tests themselves
class variables:
* notification_schedule
* setup_timestamp
* visit_timestamp
* expected_results
should be set in subclasses to reuse testing code
"""
def send_alerts(self):
"""runs the send_email_alerts management command
and makes a shortcut access to the outbox
"""
#make sure tha we are not sending email for real
#this setting must be present in settings.py
assert(
django_settings.EMAIL_BACKEND == 'django.core.mail.backends.locmem.EmailBackend'
)
management.call_command('send_email_alerts')
@setup_email_alert_tests
def setUp(self):
"""generic pre-test setup method:
this function is empty - because it's intendend content is
entirely defined by the decorator
the ``setUp()`` function in any subclass must only enter differences
between the default version (defined in the decorator) and the
desired version in the "real" test
"""
pass
def setUpUsers(self):
self.other_user = utils.create_user(
username = 'other',
email = 'other@domain.com',
date_joined = self.setup_timestamp,
status = 'm'
)
self.target_user = utils.create_user(
username = 'target',
email = 'target@domain.com',
notification_schedule = self.notification_schedule,
date_joined = self.setup_timestamp,
status = 'm'
)
def post_comment(
self,
author = None,
parent_post = None,
body_text = 'dummy test comment',
timestamp = None
):
"""posts and returns a comment to parent post, uses
now timestamp if not given, dummy body_text
author is required
"""
if timestamp is None:
timestamp = self.setup_timestamp
comment = author.post_comment(
parent_post = parent_post,
body_text = body_text,
timestamp = timestamp,
)
return comment
def edit_post(
self,
author = None,
post = None,
timestamp = None,
body_text = 'edited body text',
):
"""todo: this method may also edit other stuff
like post title and tags - in the case when post is
of type question
"""
if timestamp is None:
timestamp = self.setup_timestamp
post.apply_edit(
edited_by = author,
edited_at = timestamp,
text = body_text,
comment = 'nothing serious'
)
def post_question(
self,
author = None,
timestamp = None,
title = 'test question title',
body_text = 'test question body',
tags = 'test',
):
"""post a question with dummy content
and return it
"""
if timestamp is None:
timestamp = self.setup_timestamp
self.question = author.post_question(
title = title,
body_text = body_text,
tags = tags,
timestamp = timestamp
)
if self.follow_question:
self.target_user.follow_question(self.question)
return self.question
def maybe_visit_question(self, user = None):
"""visits question on behalf of a given user and applies
a timestamp set in the class attribute ``visit_timestamp``
if ``visit_timestamp`` is None, then visit is skipped
parameter ``user`` is optional if not given, the visit will occur
on behalf of the user stored in the class attribute ``target_user``
"""
if self.visit_timestamp:
if user is None:
user = self.target_user
user.visit_post(
question = self.question,
timestamp = self.visit_timestamp
)
def post_answer(
self,
question = None,
author = None,
body_text = 'test answer body',
timestamp = None,
follow = None,#None - do nothing, True/False - follow/unfollow
):
"""post answer with dummy content and return it
"""
if timestamp is None:
timestamp = self.setup_timestamp
if follow is None:
if author.is_following_question(question):
follow = True
else:
follow = False
elif follow not in (True, False):
raise ValueError('"follow" may be only None, True or False')
return author.post_answer(
question = question,
body_text = body_text,
timestamp = timestamp,
follow = follow,
)
def check_results(self, test_key = None):
if test_key is None:
raise ValueError('test_key parameter is required')
expected = self.expected_results[test_key]
outbox = django.core.mail.outbox
error_message = 'emails_sent=%d, expected=%d, function=%s.test_%s' % (
len(outbox),
expected['message_count'],
self.__class__.__name__,
test_key,
)
#compares number of emails in the outbox and
#the expected message count for the current test
self.assertEqual(len(outbox), expected['message_count'], error_message)
if expected['message_count'] > 0:
if len(outbox) > 0:
error_message = 'expected recipient %s found %s' % \
(self.target_user.email, outbox[0].recipients()[0])
#verify that target user receives the email
self.assertEqual(
outbox[0].recipients()[0],
self.target_user.email,
error_message
)
def proto_post_answer_comment(self):
"""base method for use in some tests
"""
question = self.post_question(
author = self.other_user
)
answer = self.post_answer(
question = question,
author = self.target_user
)
comment = self.post_comment(
parent_post = answer,
author = self.other_user,
)
return comment
@email_alert_test
def test_answer_comment(self):
"""target user posts answer and other user posts a comment
to the answer
"""
self.proto_post_answer_comment()
@email_alert_test
def test_answer_delete_comment(self):
comment = self.proto_post_answer_comment()
comment.get_owner().delete_comment(comment = comment)
@email_alert_test
def test_question_edit(self):
question = self.post_question(
author = self.target_user
)
self.edit_post(
post = question,
author = self.other_user
)
self.question = question
@email_alert_test
def test_answer_edit(self):
question = self.post_question(
author = self.target_user
)
answer = self.post_answer(
question = question,
author = self.target_user
)
self.edit_post(
post = answer,
author = self.other_user
)
self.question = question
@email_alert_test
def test_question_and_answer_by_target(self):
question = self.post_question(
author = self.target_user
)
answer = self.post_answer(
question = question,
author = self.target_user
)
self.question = question
def proto_question_comment(self):
question = self.post_question(
author = self.target_user,
)
comment = self.post_comment(
author = self.other_user,
parent_post = question,
)
return comment
@email_alert_test
def test_question_comment(self):
"""target user posts question other user posts a comment
target user does or does not receive email notification
depending on the setup parameters
in the base class user does not receive a notification
"""
self.proto_question_comment()
@email_alert_test
def test_question_comment_delete(self):
"""target user posts question other user posts a comment
target user does or does not receive email notification
depending on the setup parameters
in the base class user does not receive a notification
"""
comment = self.proto_question_comment()
comment.get_owner().delete_comment(comment)
def proto_test_q_ask(self):
"""base method for tests that
have name containing q_ask - i.e. target asks other answers
answer is returned
"""
question = self.post_question(
author = self.target_user,
)
answer = self.post_answer(
question = question,
author = self.other_user,
)
return answer
@email_alert_test
def test_q_ask(self):
"""target user posts question
other user answer the question
"""
self.proto_test_q_ask()
@email_alert_test
def test_q_ask_delete_answer(self):
answer = self.proto_test_q_ask()
self.other_user.delete_post(answer)
@email_alert_test
def test_q_ans(self):
"""other user posts question
target user post answer
"""
question = self.post_question(
author = self.other_user,
)
self.post_answer(
question = question,
author = self.target_user
)
self.question = question
@email_alert_test
def test_q_ans_new_answer(self):
"""other user posts question
target user post answer and other user
posts another answer
"""
question = self.post_question(
author = self.other_user,
)
self.post_answer(
question = question,
author = self.target_user
)
self.post_answer(
question = question,
author = self.other_user
)
self.question = question
@email_alert_test
def test_mention_in_question(self):
question = self.post_question(
author = self.other_user,
body_text = 'hey @target get this'
)
self.question = question
@email_alert_test
def test_mention_in_answer(self):
question = self.post_question(
author = self.other_user,
)
self.post_answer(
question = question,
author = self.other_user,
body_text = 'hey @target check this out'
)
self.question = question
class WeeklyQAskEmailAlertTests(EmailAlertTests):
@setup_email_alert_tests
def setUp(self):
self.notification_schedule['q_ask'] = 'w'
self.setup_timestamp = datetime.datetime.now() - datetime.timedelta(14)
self.expected_results['q_ask'] = {'message_count': 1}
self.expected_results['q_ask_delete_answer'] = {'message_count': 0}
self.expected_results['question_edit'] = {'message_count': 1, }
self.expected_results['answer_edit'] = {'message_count': 1, }
#local tests
self.expected_results['question_edit_reedited_recently'] = \
{'message_count': 1}
self.expected_results['answer_edit_reedited_recently'] = \
{'message_count': 1}
@email_alert_test
def test_question_edit_reedited_recently(self):
question = self.post_question(
author = self.target_user
)
self.edit_post(
post = question,
author = self.other_user,
)
self.edit_post(
post = question,
author = self.other_user,
timestamp = datetime.datetime.now() - datetime.timedelta(1)
)
@email_alert_test
def test_answer_edit_reedited_recently(self):
question = self.post_question(
author = self.target_user
)
answer = self.post_answer(
question = question,
author = self.other_user,
)
self.edit_post(
post = answer,
author = self.other_user,
timestamp = datetime.datetime.now() - datetime.timedelta(1)
)
class WeeklyMentionsAndCommentsEmailAlertTests(EmailAlertTests):
@setup_email_alert_tests
def setUp(self):
self.notification_schedule['m_and_c'] = 'w'
self.setup_timestamp = datetime.datetime.now() - datetime.timedelta(14)
self.expected_results['question_comment'] = {'message_count': 1, }
self.expected_results['question_comment_delete'] = {'message_count': 0, }
self.expected_results['answer_comment'] = {'message_count': 1, }
self.expected_results['answer_delete_comment'] = {'message_count': 0, }
self.expected_results['mention_in_question'] = {'message_count': 1, }
self.expected_results['mention_in_answer'] = {'message_count': 1, }
class WeeklyQAnsEmailAlertTests(EmailAlertTests):
@setup_email_alert_tests
def setUp(self):
self.notification_schedule['q_ans'] = 'w'
self.setup_timestamp = datetime.datetime.now() - datetime.timedelta(14)
self.expected_results['answer_edit'] = {'message_count': 1, }
self.expected_results['q_ans_new_answer'] = {'message_count': 1, }
class InstantQAskEmailAlertTests(EmailAlertTests):
@setup_email_alert_tests
def setUp(self):
self.notification_schedule['q_ask'] = 'i'
self.setup_timestamp = datetime.datetime.now() - datetime.timedelta(1)
self.expected_results['q_ask'] = {'message_count': 1}
self.expected_results['q_ask_delete_answer'] = {'message_count': 1}
self.expected_results['question_edit'] = {'message_count': 1, }
self.expected_results['answer_edit'] = {'message_count': 1, }
class InstantWholeForumEmailAlertTests(EmailAlertTests):
@setup_email_alert_tests
def setUp(self):
self.notification_schedule['q_all'] = 'i'
self.setup_timestamp = datetime.datetime.now() - datetime.timedelta(1)
self.expected_results['q_ask'] = {'message_count': 1, }
self.expected_results['q_ask_delete_answer'] = {'message_count': 1}
self.expected_results['question_comment'] = {'message_count': 1, }
self.expected_results['question_comment_delete'] = {'message_count': 1, }
self.expected_results['answer_comment'] = {'message_count': 2, }
self.expected_results['answer_delete_comment'] = {'message_count': 2, }
self.expected_results['mention_in_question'] = {'message_count': 1, }
self.expected_results['mention_in_answer'] = {'message_count': 2, }
self.expected_results['question_edit'] = {'message_count': 1, }
self.expected_results['answer_edit'] = {'message_count': 1, }
self.expected_results['question_and_answer_by_target'] = {'message_count': 0, }
self.expected_results['q_ans'] = {'message_count': 1, }
self.expected_results['q_ans_new_answer'] = {'message_count': 2, }
def test_global_subscriber_with_zero_frequency_gets_no_email(self):
user = self.target_user
user.notification_subscriptions.update(frequency='n')
user.email_tag_filter_strategy = const.INCLUDE_ALL
user.save()
self.post_question(author=self.other_user)
outbox = django.core.mail.outbox
self.assertEqual(len(outbox), 0)
class BlankWeeklySelectedQuestionsEmailAlertTests(EmailAlertTests):
"""blank means that this is testing for the absence of email
because questions are not followed as set by default in the
parent class
"""
@setup_email_alert_tests
def setUp(self):
self.notification_schedule['q_sel'] = 'w'
self.setup_timestamp = datetime.datetime.now() - datetime.timedelta(14)
self.expected_results['q_ask'] = {'message_count': 1, }
self.expected_results['q_ask_delete_answer'] = {'message_count': 0, }
self.expected_results['question_comment'] = {'message_count': 0, }
self.expected_results['question_comment_delete'] = {'message_count': 0, }
self.expected_results['answer_comment'] = {'message_count': 0, }
self.expected_results['answer_delete_comment'] = {'message_count': 0, }
self.expected_results['mention_in_question'] = {'message_count': 0, }
self.expected_results['mention_in_answer'] = {'message_count': 0, }
self.expected_results['question_edit'] = {'message_count': 1, }
self.expected_results['answer_edit'] = {'message_count': 1, }
self.expected_results['question_and_answer_by_target'] = {'message_count': 0, }
self.expected_results['q_ans'] = {'message_count': 0, }
self.expected_results['q_ans_new_answer'] = {'message_count': 0, }
class BlankInstantSelectedQuestionsEmailAlertTests(EmailAlertTests):
"""blank means that this is testing for the absence of email
because questions are not followed as set by default in the
parent class
"""
@setup_email_alert_tests
def setUp(self):
self.notification_schedule['q_sel'] = 'i'
self.setup_timestamp = datetime.datetime.now() - datetime.timedelta(1)
self.expected_results['q_ask'] = {'message_count': 1, }
self.expected_results['q_ask_delete_answer'] = {'message_count': 1, }
self.expected_results['question_comment'] = {'message_count': 1, }
self.expected_results['question_comment_delete'] = {'message_count': 1, }
self.expected_results['answer_comment'] = {'message_count': 0, }
self.expected_results['answer_delete_comment'] = {'message_count': 0, }
self.expected_results['mention_in_question'] = {'message_count': 0, }
self.expected_results['mention_in_answer'] = {'message_count': 0, }
self.expected_results['question_edit'] = {'message_count': 1, }
self.expected_results['answer_edit'] = {'message_count': 1, }
self.expected_results['question_and_answer_by_target'] = {'message_count': 0, }
self.expected_results['q_ans'] = {'message_count': 0, }
self.expected_results['q_ans_new_answer'] = {'message_count': 0, }
class LiveWeeklySelectedQuestionsEmailAlertTests(EmailAlertTests):
"""live means that this is testing for the presence of email
as all questions are automatically followed by user here
"""
@setup_email_alert_tests
def setUp(self):
self.notification_schedule['q_sel'] = 'w'
self.setup_timestamp = datetime.datetime.now() - datetime.timedelta(14)
self.follow_question = True
self.expected_results['q_ask'] = {'message_count': 1, }
self.expected_results['q_ask_delete_answer'] = {'message_count': 0}
self.expected_results['question_comment'] = {'message_count': 0, }
self.expected_results['question_comment_delete'] = {'message_count': 0, }
self.expected_results['answer_comment'] = {'message_count': 0, }
self.expected_results['answer_delete_comment'] = {'message_count': 0, }
self.expected_results['mention_in_question'] = {'message_count': 1, }
self.expected_results['mention_in_answer'] = {'message_count': 1, }
self.expected_results['question_edit'] = {'message_count': 1, }
self.expected_results['answer_edit'] = {'message_count': 1, }
self.expected_results['question_and_answer_by_target'] = {'message_count': 0, }
self.expected_results['q_ans'] = {'message_count': 0, }
self.expected_results['q_ans_new_answer'] = {'message_count': 1, }
class LiveInstantSelectedQuestionsEmailAlertTests(EmailAlertTests):
"""live means that this is testing for the presence of email
as all questions are automatically followed by user here
"""
@setup_email_alert_tests
def setUp(self):
self.notification_schedule['q_sel'] = 'i'
#first posts yesterday
self.setup_timestamp = datetime.datetime.now() - datetime.timedelta(1)
self.follow_question = True
self.expected_results['q_ask'] = {'message_count': 1, }
self.expected_results['q_ask_delete_answer'] = {'message_count': 1}
self.expected_results['question_comment'] = {'message_count': 1, }
self.expected_results['question_comment_delete'] = {'message_count': 1, }
self.expected_results['answer_comment'] = {'message_count': 1, }
self.expected_results['answer_delete_comment'] = {'message_count': 1, }
self.expected_results['mention_in_question'] = {'message_count': 0, }
self.expected_results['mention_in_answer'] = {'message_count': 1, }
self.expected_results['question_edit'] = {'message_count': 1, }
self.expected_results['answer_edit'] = {'message_count': 1, }
self.expected_results['question_and_answer_by_target'] = {'message_count': 0, }
self.expected_results['q_ans'] = {'message_count': 0, }
self.expected_results['q_ans_new_answer'] = {'message_count': 1, }
class InstantMentionsAndCommentsEmailAlertTests(EmailAlertTests):
@setup_email_alert_tests
def setUp(self):
self.notification_schedule['m_and_c'] = 'i'
self.setup_timestamp = datetime.datetime.now() - datetime.timedelta(1)
self.expected_results['question_comment'] = {'message_count': 1, }
self.expected_results['question_comment_delete'] = {'message_count': 1, }
self.expected_results['answer_comment'] = {'message_count': 1, }
self.expected_results['answer_delete_comment'] = {'message_count': 1, }
self.expected_results['mention_in_question'] = {'message_count': 1, }
self.expected_results['mention_in_answer'] = {'message_count': 1, }
#specialized local test case
self.expected_results['question_edited_mention_stays'] = {'message_count': 1}
@email_alert_test
def test_question_edited_mention_stays(self):
question = self.post_question(
author = self.other_user,
body_text = 'hey @target check this one',
)
self.edit_post(
post = question,
author = self.other_user,
body_text = 'yoyo @target do look here'
)
class InstantQAnsEmailAlertTests(EmailAlertTests):
@setup_email_alert_tests
def setUp(self):
self.notification_schedule['q_ans'] = 'i'
self.setup_timestamp = datetime.datetime.now() - datetime.timedelta(1)
self.expected_results['answer_edit'] = {'message_count': 1, }
self.expected_results['q_ans_new_answer'] = {'message_count': 1, }
class DelayedAlertSubjectLineTests(TestCase):
def test_topics_in_subject_line(self):
threads = [
models.Thread(tagnames='one two three four five'),
models.Thread(tagnames='two three four five'),
models.Thread(tagnames='three four five'),
models.Thread(tagnames='four five'),
models.Thread(tagnames='five'),
]
subject = Thread.objects.get_tag_summary_from_threads(threads)
self.assertEqual('"five", "four", "three", "two" and "one"', subject)
threads += [
models.Thread(tagnames='six'),
models.Thread(tagnames='six'),
models.Thread(tagnames='six'),
models.Thread(tagnames='six'),
models.Thread(tagnames='six'),
models.Thread(tagnames='six'),
]
subject = Thread.objects.get_tag_summary_from_threads(threads)
self.assertEqual('"six", "five", "four", "three", "two" and more', subject)
class FeedbackTests(utils.AskbotTestCase):
def setUp(self):
self.create_user(username = 'user1', status='m')
self.create_user(username = 'user2', status='m')
u3 = self.create_user(username = 'user3')
u3.is_superuser = True
u3.save()
def assert_feedback_works(self):
outbox = django.core.mail.outbox
self.assertEqual(len(outbox), 1)
#todo: change groups to django groups
#then replace to 4 back to 3 in the line below
self.assertEqual(len(outbox[0].recipients()), 3)
def test_feedback_post_form(self):
client = Client()
data = {
'email': 'evgeny.fadeev@gmail.com',
'text': 'hi this is a test case',
'subject': 'subject line'
}
response = client.post(reverse('feedback'), data)
self.assertEquals(response.status_code, 200)
self.assertEquals(response.templates[0].name, 'feedback.html')
def test_mail_moderators(self):
"""tests askbot.mail_moderators()
"""
mail.mail_moderators('subject', 'text')
self.assert_feedback_works()
class TagFollowedInstantWholeForumEmailAlertTests(utils.AskbotTestCase):
def setUp(self):
self.user1 = self.create_user(
username = 'user1',
notification_schedule = {'q_all': 'i'},
status = 'm'
)
self.user2 = self.create_user(
username = 'user2',
status = 'm'
)
def test_wildcard_catches_new_tag(self):
"""users asks a question with a brand new tag
and other user subscribes to it by wildcard
"""
askbot_settings.update('USE_WILDCARD_TAGS', True)
self.user1.email_tag_filter_strategy = const.INCLUDE_INTERESTING
self.user1.save()
self.user1.mark_tags(
wildcards = ('some*',),
reason = 'good',
action = 'add'
)
self.user2.post_question(
title = 'some title',
body_text = 'some text for the question',
tags = 'something'
)
outbox = django.core.mail.outbox
self.assertEqual(len(outbox), 1)
self.assertEqual(len(outbox[0].recipients()), 1)
self.assertTrue(
self.user1.email in outbox[0].recipients()
)
@with_settings(SUBSCRIBED_TAG_SELECTOR_ENABLED=False)
def test_tag_based_subscription_on_new_question_works1(self):
"""someone subscribes for an pre-existing tag
then another user asks a question with that tag
and the subcriber receives an alert
"""
models.Tag(
name = 'something',
created_by = self.user1
).save()
self.user1.email_tag_filter_strategy = const.INCLUDE_INTERESTING
self.user1.save()
self.user1.mark_tags(
tagnames = ('something',),
reason = 'good',
action = 'add'
)
self.user2.post_question(
title = 'some title',
body_text = 'some text for the question',
tags = 'something'
)
outbox = django.core.mail.outbox
self.assertEqual(len(outbox), 1)
self.assertEqual(len(outbox[0].recipients()), 1)
self.assertTrue(
self.user1.email in outbox[0].recipients()
)
@with_settings(SUBSCRIBED_TAG_SELECTOR_ENABLED=True)
def test_tag_based_subscription_on_new_question_works1(self):
"""someone subscribes for an pre-existing tag
then another user asks a question with that tag
and the subcriber receives an alert
"""
models.Tag(
name = 'something',
created_by = self.user1
).save()
self.user1.email_tag_filter_strategy = const.INCLUDE_SUBSCRIBED
self.user1.save()
self.user1.mark_tags(
tagnames = ('something',),
reason = 'subscribed',
action = 'add'
)
self.user2.post_question(
title = 'some title',
body_text = 'some text for the question',
tags = 'something'
)
outbox = django.core.mail.outbox
self.assertEqual(len(outbox), 1)
self.assertEqual(len(outbox[0].recipients()), 1)
self.assertTrue(
self.user1.email in outbox[0].recipients()
)
class EmailReminderTestCase(utils.AskbotTestCase):
#subclass must define these (example below)
#enable_setting_name = 'ENABLE_UNANSWERED_REMINDERS'
#frequency_setting_name = 'UNANSWERED_REMINDER_FREQUENCY'
#days_before_setting_name = 'DAYS_BEFORE_SENDING_UNANSWERED_REMINDER'
#max_reminder_setting_name = 'MAX_UNANSWERED_REMINDERS'
def setUp(self):
self.u1 = self.create_user(username = 'user1')
self.u2 = self.create_user(username = 'user2')
askbot_settings.update(self.enable_setting_name, True)
askbot_settings.update(self.max_reminder_setting_name, 5)
askbot_settings.update(self.frequency_setting_name, 1)
askbot_settings.update(self.days_before_setting_name, 2)
self.wait_days = getattr(askbot_settings, self.days_before_setting_name)
self.recurrence_days = getattr(askbot_settings, self.frequency_setting_name)
self.max_emails = getattr(askbot_settings, self.max_reminder_setting_name)
def assert_have_emails(self, email_count = None):
management.call_command(self.command_name)
outbox = django.core.mail.outbox
self.assertEqual(len(outbox), email_count)
def do_post(self, timestamp):
self.question = self.post_question(
user = self.u1,
timestamp = timestamp
)
class AcceptAnswerReminderTests(EmailReminderTestCase):
"""only two test cases here, because the algorithm here
is the same as for unanswered questons,
except here we are dealing with the questions that have
or do not have an accepted answer
"""
enable_setting_name = 'ENABLE_ACCEPT_ANSWER_REMINDERS'
frequency_setting_name = 'ACCEPT_ANSWER_REMINDER_FREQUENCY'
days_before_setting_name = 'DAYS_BEFORE_SENDING_ACCEPT_ANSWER_REMINDER'
max_reminder_setting_name = 'MAX_ACCEPT_ANSWER_REMINDERS'
command_name = 'send_accept_answer_reminders'
def do_post(self, timestamp):
super(AcceptAnswerReminderTests, self).do_post(timestamp)
self.answer = self.post_answer(
question = self.question,
user = self.u2,
timestamp = timestamp
)
def test_reminder_positive_wait(self):
"""a positive test - user must receive a reminder
"""
days_ago = self.wait_days
timestamp = datetime.datetime.now() - datetime.timedelta(days_ago, 3600)
self.do_post(timestamp)
self.assert_have_emails(1)
def test_reminder_negative_wait(self):
"""negative test - the answer is accepted already"""
days_ago = self.wait_days
timestamp = datetime.datetime.now() - datetime.timedelta(days_ago, 3600)
self.do_post(timestamp)
self.u1.accept_best_answer(
answer = self.answer,
)
self.assert_have_emails(0)
class UnansweredReminderTests(EmailReminderTestCase):
enable_setting_name = 'ENABLE_UNANSWERED_REMINDERS'
frequency_setting_name = 'UNANSWERED_REMINDER_FREQUENCY'
days_before_setting_name = 'DAYS_BEFORE_SENDING_UNANSWERED_REMINDER'
max_reminder_setting_name = 'MAX_UNANSWERED_REMINDERS'
command_name = 'send_unanswered_question_reminders'
def test_reminder_positive_wait(self):
"""a positive test - user must receive a reminder
"""
days_ago = self.wait_days
timestamp = datetime.datetime.now() - datetime.timedelta(days_ago, 3600)
self.do_post(timestamp)
self.assert_have_emails(1)
def test_reminder_negative_wait(self):
"""a positive test - user must receive a reminder
"""
days_ago = self.wait_days - 1
timestamp = datetime.datetime.now() - datetime.timedelta(days_ago, 3600)
self.do_post(timestamp)
self.assert_have_emails(0)
def test_reminder_cutoff_positive(self):
"""send a reminder a slightly before the last reminder
date passes"""
days_ago = self.wait_days + (self.max_emails - 1)*self.recurrence_days - 1
timestamp = datetime.datetime.now() - datetime.timedelta(days_ago, 3600)
self.do_post(timestamp)
#todo: change groups to django groups
#then replace to 2 back to 1 in the line below
self.assert_have_emails(1)
def test_reminder_cutoff_negative(self):
"""no reminder after the time for the last reminder passes
"""
days_ago = self.wait_days + (self.max_emails - 1)*self.recurrence_days
timestamp = datetime.datetime.now() - datetime.timedelta(days_ago, 3600)
self.do_post(timestamp)
self.assert_have_emails(0)
class EmailFeedSettingTests(utils.AskbotTestCase):
def setUp(self):
self.user = self.create_user('user')
def get_user_feeds(self):
return models.EmailFeedSetting.objects.filter(subscriber = self.user)
def test_add_missings_subscriptions_noop(self):
data_before = TO_JSON(self.get_user_feeds())
self.user.add_missing_askbot_subscriptions()
data_after = TO_JSON(self.get_user_feeds())
self.assertEquals(data_before, data_after)
def test_add_missing_q_all_subscription(self):
feed = self.get_user_feeds().filter(feed_type = 'q_all')
feed.delete()
count_before = self.get_user_feeds().count()
self.user.add_missing_askbot_subscriptions()
count_after = self.get_user_feeds().count()
self.assertEquals(count_after - count_before, 1)
feed = self.get_user_feeds().filter(feed_type = 'q_all')[0]
self.assertEquals(
feed.frequency,
askbot_settings.DEFAULT_NOTIFICATION_DELIVERY_SCHEDULE_Q_ALL
)
def test_missing_subscriptions_added_automatically(self):
new_user = models.User.objects.create_user('new', 'new@example.com')
feeds_before = self.get_user_feeds()
#verify that feed settigs are created automatically
#when user is just created
self.assertTrue(feeds_before.count() != 0)
data_before = TO_JSON(feeds_before)
new_user.add_missing_askbot_subscriptions()
data_after = TO_JSON(self.get_user_feeds())
self.assertEquals(data_before, data_after)
class EmailAlertTestsWithGroupsEnabled(utils.AskbotTestCase):
def setUp(self):
self.backup = askbot_settings.GROUPS_ENABLED
askbot_settings.update('GROUPS_ENABLED', True)
def tearDown(self):
askbot_settings.update('GROUPS_ENABLED', self.backup)
@with_settings(MIN_REP_TO_TRIGGER_EMAIL=1)
def test_notification_for_global_group_works(self):
sender = self.create_user('sender')
recipient = self.create_user(
'recipient',
notification_schedule=models.EmailFeedSetting.MAX_EMAIL_SCHEDULE
)
self.post_question(user=sender)
outbox = django.core.mail.outbox
self.assertEqual(len(outbox), 1)
self.assertEqual(outbox[0].recipients(), [recipient.email])
class PostApprovalTests(utils.AskbotTestCase):
"""test notifications sent to authors when their posts
are approved or published"""
def setUp(self):
self.reply_by_email = askbot_settings.REPLY_BY_EMAIL
askbot_settings.update('REPLY_BY_EMAIL', True)
self.enable_content_moderation = \
askbot_settings.ENABLE_CONTENT_MODERATION
askbot_settings.update('ENABLE_CONTENT_MODERATION', True)
self.self_notify_when = \
askbot_settings.SELF_NOTIFY_EMAILED_POST_AUTHOR_WHEN
when = const.FOR_FIRST_REVISION
askbot_settings.update('SELF_NOTIFY_EMAILED_POST_AUTHOR_WHEN', when)
assert(
django_settings.EMAIL_BACKEND == 'django.core.mail.backends.locmem.EmailBackend'
)
def tearDown(self):
askbot_settings.update(
'REPLY_BY_EMAIL', self.reply_by_email
)
askbot_settings.update(
'ENABLE_CONTENT_MODERATION',
self.enable_content_moderation
)
askbot_settings.update(
'SELF_NOTIFY_EMAILED_POST_AUTHOR_WHEN',
self.self_notify_when
)
def test_emailed_question_answerable_approval_notification(self):
self.u1 = self.create_user('user1', status = 'a')#regular user
question = self.post_question(user = self.u1, by_email = True)
outbox = django.core.mail.outbox
#here we should get just the notification of the post
#being placed on the moderation queue
self.assertEquals(len(outbox), 1)
self.assertEquals(outbox[0].recipients(), [self.u1.email])
def test_moderated_question_answerable_approval_notification(self):
u1 = self.create_user('user1', status = 'a')
question = self.post_question(user = u1, by_email = True)
self.assertEquals(question.approved, False)
u2 = self.create_user('admin', status = 'd')
self.assertEquals(question.revisions.count(), 1)
u2.approve_post_revision(question.get_latest_revision())
outbox = django.core.mail.outbox
self.assertEquals(len(outbox), 2)
#moderation notification
self.assertEquals(outbox[0].recipients(), [u1.email,])
#self.assertEquals(outbox[1].recipients(), [u1.email,])#approval
class AbsolutizeUrlsInEmailsTests(utils.AskbotTestCase):
@with_settings(
MIN_REP_TO_TRIGGER_EMAIL=1,
APP_URL='http://example.com/',
MIN_REP_TO_INSERT_LINK=1
)
def test_urls_are_absolute(self):
u1 = self.create_user('u1')
max_email = models.EmailFeedSetting.MAX_EMAIL_SCHEDULE
u2 = self.create_user('u2', notification_schedule=max_email)
text = 'home' + \
''
question = self.post_question(user=u1, body_text=text)
outbox = django.core.mail.outbox
html_message = outbox[0].alternatives[0][0]
content_type = outbox[0].alternatives[0][1]
self.assertEqual(content_type, 'text/html')
soup = bs4.BeautifulSoup(html_message)
links = soup.find_all('a')
url_bits = {}
for link in links:
url_bits[link.attrs['href'][:4]] = 1
self.assertEqual(len(url_bits.keys()), 1)
self.assertEqual(url_bits.keys()[0], 'http')
images = soup.find_all('img')
url_bits = {}
for img in images:
url_bits[img.attrs['src'][:4]] = 1
self.assertEqual(len(url_bits.keys()), 1)
self.assertEqual(url_bits.keys()[0], 'http')
class MailMessagesTests(utils.AskbotTestCase):
def test_ask_for_signature(self):
from askbot.mail import messages
user = self.create_user('user')
message = messages.ask_for_signature(user, footer_code = 'nothing')
self.assertTrue(user.username in message)