def test_submitsubmission(self):
""" Test queue-based submission. """
# Adding a subscription after the submission has been created, it should
# not be used when submitting self.sub
new_subscr = Subscription.objects.create(
name='Other Name', email='*****@*****.**',
newsletter=self.n, subscribed=True
)
self.sub.prepared = True
self.sub.publish_date = now() - timedelta(seconds=1)
self.sub.save()
Submission.submit_queue()
# Get the object fresh from DB, as to assure no caching takes place
submission = Submission.objects.get(pk=self.sub.pk)
self.assertTrue(submission.sent)
self.assertFalse(submission.sending)
# Make sure mail is being sent out
self.assertEqual(len(mail.outbox), NUM_SUBSCRIBED)
# Make sure a submission contains the title and unsubscribe URL
self.assertEmailContains(submission.message.title)
self.assertEmailContains(submission.newsletter.unsubscribe_url())
self.assertEmailHasHeader(
'List-Unsubscribe',
'http://example.com/newsletter/test-newsletter/unsubscribe/'
)
def test_submitsubmission(self):
""" Test queue-based submission. """
# Adding a subscription after the submission has been created, it should
# not be used when submitting self.sub
new_subscr = Subscription.objects.create(name='Other Name',
email='*****@*****.**',
newsletter=self.n,
subscribed=True)
self.sub.prepared = True
self.sub.publish_date = now() - timedelta(seconds=1)
self.sub.save()
Submission.submit_queue()
# Get the object fresh from DB, as to assure no caching takes place
submission = Submission.objects.get(pk=self.sub.pk)
self.assertTrue(submission.sent)
self.assertFalse(submission.sending)
# Make sure mail is being sent out
self.assertEqual(len(mail.outbox), NUM_SUBSCRIBED)
# Make sure a submission contains the title and unsubscribe URL
self.assertEmailContains(submission.message.title)
self.assertEmailContains(submission.newsletter.unsubscribe_url())
self.assertEmailHasHeader(
'List-Unsubscribe',
'http://example.com/newsletter/test-newsletter/unsubscribe/')
def send_submissions():
"""
This method removes all blacklisted tokens.
Version: 1.0
"""
# local import of model, otherwise it won't work
from newsletter.models import Submission
Submission.submit_queue()
def test_submission_site_validation(self):
""" Test creating a submission from a message with site provided. """
callback = lambda: Submission.from_message(
self.m, Site.objects.get(domain=self.sites[0]))
self.assertRaises(ValidationError, callback)
callback = lambda: Submission.from_message(self.m, None)
self.assertRaises(ValidationError, callback)
def test_changelist(self):
""" Testing submission admin change list display. """
# Assure there's a submission
Submission.from_message(self.message)
response = self.client.get(self.changelist_url)
self.assertContains(
response, '<td class="field-admin_status_text">Not sent.</td>')
def test_nosubmit(self):
""" Assure nothing happens if not prepared. """
# Assure nothing happens
Submission.submit_queue()
self.assertFalse(self.sub.prepared)
self.assertFalse(self.sub.sent)
self.assertFalse(self.sub.sending)
def test_nosubmit(self):
""" Assure nothing happens if not prepared. """
# Assure nothing happens
Submission.submit_queue()
self.assertFalse(self.sub.prepared)
self.assertFalse(self.sub.sent)
self.assertFalse(self.sub.sending)
def test_changelist(self):
""" Testing submission admin change list display. """
# Assure there's a submission
Submission.from_message(self.message)
response = self.client.get(self.changelist_url)
self.assertContains(
response,
'<td class="field-admin_status_text">Not sent.</td>'
)
def test_delayedsumbmission(self):
""" Test delays between emails """
self.sub.prepared = True
self.sub.publish_date = now() - timedelta(seconds=1)
self.sub.save()
with self.settings(NEWSLETTER_EMAIL_DELAY=0.01):
with mock.patch('time.sleep', return_value=None) as sleep_mock:
Submission.submit_queue()
sleep_mock.assert_called_with(0.01)
def test_delayedsumbmission(self):
""" Test delays between emails """
self.sub.prepared = True
self.sub.publish_date = now() - timedelta(seconds=1)
self.sub.save()
with self.settings(NEWSLETTER_EMAIL_DELAY=0.01):
with mock.patch('time.sleep', return_value=None) as sleep_mock:
Submission.submit_queue()
sleep_mock.assert_called_with(0.01)
def send_email(self, action):
assert action in ACTIONS + ('message', ), 'Unknown action: %s' % action
if action == 'message':
# Create submission
sub = Submission.from_message(self.m)
sub.prepared = True
sub.publish_date = now() - timedelta(seconds=1)
sub.save()
# Send message email
Submission.submit_queue()
else:
self.s.send_activation_email(action)
def send_email(self, action):
assert action in ACTIONS + ('message', ), 'Unknown action: %s' % action
if action == 'message':
# Create submission
sub = Submission.from_message(self.m)
sub.prepared = True
sub.publish_date = now() - timedelta(seconds=1)
sub.save()
# Send message email
Submission.submit_queue()
else:
self.s.send_activation_email(action)
def test_duplicate_fail(self):
""" Test that a message cannot be published twice. """
# Assure there's a submission
Submission.from_message(self.message)
response = self.client.post(self.add_url, data={
'message': self.message.pk,
'publish_date_0': '2016-01-09',
'publish_date_1': '07:24',
'publish': 'on',
})
self.assertContains(
response,
"This message has already been published in some other submission."
)
def newsletter_send(request, object_id):
import os
path = PROJECT_ROOT + "/core/scripts/sendmail_v0.1.py"
newsletter = get_object_or_404(Newsletter,id=object_id)
os.system('python %s -n %s'%(path,str(object_id)))
from newsletter.models import Submission
sub = Submission(newsletter=newsletter)
sub.save()
return render_to_response('newsletter/newsletter_content.html',
{'newsletter' : newsletter},
context_instance=RequestContext(request))
def putWeekReport(report, newsletter):
# if nothing changed, nothing to report, moving on.
if report['db_changes'] == None and report['discussion'] == None and report['characteristic'] == None:
return
now = timezone.now()
mess = Message(title=newsletter.title+" - Recent Changes - "+now.strftime("%Y-%m-%d %H:%M"),slug=newsletter.slug+'_'+now.strftime("%Y%m%d%H%M%S"), newsletter=newsletter)
mess.save()
if report['db_changes'] != None:
art = Article(title="Changes on Database:", text=report['db_changes'], post=mess)
art.save()
if report['discussion'] != None:
art2 = Article(title="New Discussion:", text=report['discussion'], post=mess)
art2.save()
if report['characteristic'] != None:
art3 = Article(title="New Population Characteristic Data:", text=report['characteristic'], post=mess)
art3.save()
subm = Submission.from_message(mess)
subm.prepared = True
subm.save()
def send_email(self, action):
assert action in ACTIONS + ('message', ), 'Unknown action: %s' % action
if action == 'message':
# Create submission
sub = Submission.from_message(self.m, Site.objects.get_current())
sub.prepared = True
sub.publish_date = now() - timedelta(seconds=1)
sub.save()
# Send message email
Submission.submit_queue()
else:
for subscriber in self.n.get_subscriptions():
subscriber.send_activation_email(Site.objects.get_current(),
action)
def test_duplicate_fail(self):
""" Test that a message cannot be published twice. """
# Assure there's a submission
Submission.from_message(self.message)
response = self.client.post(self.add_url, data={
'message': self.message.pk,
'publish_date_0': '2016-01-09',
'publish_date_1': '07:24',
'publish': 'on',
})
self.assertContains(
response,
"This message has already been published in some other submission."
)
def submit(self, request, object_id):
submission = self._getobj(request, object_id)
if submission.sent or submission.prepared:
messages.info(request, _("Submission already sent."))
change_url = reverse('admin:newsletter_submission_change',
args=[object_id])
return HttpResponseRedirect(change_url)
submission.prepared = True
submission.save()
Submission.submit_queue()
messages.info(request, _("Your submission is sent."))
changelist_url = reverse('admin:newsletter_submission_changelist')
return HttpResponseRedirect(changelist_url)
def handle(self, *args, **options):
# Setup logging based on verbosity: 1 -> INFO, >1 -> DEBUG
verbosity = int(options['verbosity'])
logger = logging.getLogger('newsletter')
if verbosity == 0:
logger.setLevel(logging.WARN)
elif verbosity == 1: # default
logger.setLevel(logging.INFO)
elif verbosity > 1:
logger.setLevel(logging.DEBUG)
if verbosity > 2:
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
logger.info(_('Submitting queued newsletter mailings'))
# Call submission
Submission.submit_queue()
def handle(self, *args, **options):
# Setup logging based on verbosity: 1 -> INFO, >1 -> DEBUG
verbosity = int(options['verbosity'])
logger = logging.getLogger('newsletter')
if verbosity == 0:
logger.setLevel(logging.WARN)
elif verbosity == 1: # default
logger.setLevel(logging.INFO)
elif verbosity > 1:
logger.setLevel(logging.DEBUG)
if verbosity > 2:
logger = logging.getLogger()
logger.setLevel(logging.DEBUG)
logger.info(_('Submitting queued newsletter mailings'))
# Call submission
Submission.submit_queue()
def test_submission_subscribed(self):
""" Test a simple submission with single subscriber. """
self.s.subscribed = False
self.s.save()
sub = Submission.from_message(self.m)
subscriptions = sub.subscriptions.all()
self.assertEqual(list(subscriptions), [self.s2])
def test_submission_subscribed(self):
""" Test a simple submission with single subscriber. """
self.s.subscribed = False
self.s.save()
sub = Submission.from_message(self.m)
subscriptions = sub.subscriptions.all()
self.assertEqual(list(subscriptions), [self.s2])
def test_submission_unsubscribed(self):
""" Test submission with unsubscribed activated subscriber. """
self.s.unsubscribed = True
self.s.save()
sub = Submission.from_message(self.m)
subscriptions = sub.subscriptions.all()
self.assertEqual(list(subscriptions), [self.s2])
def test_submission_unsubscribed(self):
""" Test submission with unsubscribed activated subscriber. """
self.s.unsubscribed = True
self.s.save()
sub = Submission.from_message(self.m)
subscriptions = sub.subscriptions.all()
self.assertEqual(list(subscriptions), [self.s2])
def test_submission_from_message(self):
""" Test creating a submission from a message. """
sub = Submission.from_message(self.m)
subscriptions = sub.subscriptions.all()
self.assertEqual(set(subscriptions), {self.s, self.s2})
self.assertFalse(sub.prepared)
self.assertFalse(sub.sent)
self.assertFalse(sub.sending)
def test_submission_from_message(self):
""" Test creating a submission from a message. """
sub = Submission.from_message(self.m)
subscriptions = sub.subscriptions.all()
self.assertEqual(set(subscriptions), {self.s, self.s2})
self.assertFalse(sub.prepared)
self.assertFalse(sub.sent)
self.assertFalse(sub.sending)
def test_twosubmissions_unsubscried(self):
""" Test submission with two subscribers, one unactivated. """
s2 = Subscription(
name='Test Name 2', email='*****@*****.**',
newsletter=self.n, subscribed=False
)
s2.save()
sub = Submission.from_message(self.m)
subscriptions = sub.subscriptions.all()
self.assertEqual(list(subscriptions), [self.s])
def test_submission_from_message(self):
""" Test creating a submission from a message. """
sub = Submission.from_message(self.m, self.get_site())
unsubscribe_link = sub.extra_headers['List-Unsubscribe']
self.assertIn(self.get_site().domain, unsubscribe_link)
subscriptions = sub.subscriptions.all()
self.assertEqual(set(subscriptions), {self.s, self.s2})
self.assertFalse(sub.prepared)
self.assertFalse(sub.sent)
self.assertFalse(sub.sending)
def test_twosubmissions_unsubscried(self):
""" Test submission with two subscribers, one unactivated. """
s2 = Subscription(name='Test Name 2',
email='*****@*****.**',
newsletter=self.n,
subscribed=False)
s2.save()
sub = Submission.from_message(self.m)
subscriptions = sub.subscriptions.all()
self.assertEqual(list(subscriptions), [self.s])
def test_twosubmissions(self):
""" Test submission with two activated subscribers. """
s2 = Subscription(
name='Test Name 2', email='*****@*****.**',
newsletter=self.n, subscribed=True
)
s2.save()
sub = Submission.from_message(self.m)
subscriptions = sub.subscriptions.all()
self.assertTrue(self.s in list(subscriptions))
self.assertTrue(s2 in list(subscriptions))
def test_twosubmissions(self):
""" Test submission with two activated subscribers. """
s2 = Subscription(name='Test Name 2',
email='*****@*****.**',
newsletter=self.n,
subscribed=True)
s2.save()
sub = Submission.from_message(self.m)
subscriptions = sub.subscriptions.all()
self.assertTrue(self.s in list(subscriptions))
self.assertTrue(s2 in list(subscriptions))
def setUp(self):
""" Make sure we have a few submissions to test with. """
# Pick some newsletter
try:
self.newsletter = Newsletter.objects.all()[0]
except IndexError:
self.newsletter = None
# Create a message first
message = Message.objects.create(
title='Test message',
slug='test-message',
newsletter=self.newsletter,
)
# Make sure there's a HTML template for this newsletter,
# otherwise the archive will not function.
self.assertTrue(message.html_template)
# Create a submission
self.submission = Submission.from_message(message)
def setUp(self):
""" Make sure we have a few submissions to test with. """
# Pick some newsletter
try:
self.newsletter = Newsletter.objects.all()[0]
except IndexError:
self.newsletter = None
# Create a message first
message = Message.objects.create(
title='Test message',
slug='test-message',
newsletter=self.newsletter,
)
# Make sure there's a HTML template for this newsletter,
# otherwise the archive will not function.
self.assertTrue(message.html_template)
# Create a submission
self.submission = Submission.from_message(message)
def putWeekReport(report, newsletter):
# if nothing changed, nothing to report, moving on.
if report['db_changes'] == None and report[
'discussion'] == None and report['characteristic'] == None:
return
now = timezone.now()
mess = Message(title=newsletter.title + " - Recent Changes - " +
now.strftime("%Y-%m-%d %H:%M"),
slug=newsletter.slug + '_' + now.strftime("%Y%m%d%H%M%S"),
newsletter=newsletter)
mess.save()
if report['db_changes'] != None:
art = Article(title="Changes on Database:",
text=report['db_changes'],
post=mess)
art.save()
if report['discussion'] != None:
art2 = Article(title="New Discussion:",
text=report['discussion'],
post=mess)
art2.save()
if report['characteristic'] != None:
art3 = Article(title="New Population Characteristic Data:",
text=report['characteristic'],
post=mess)
art3.save()
subm = Submission.from_message(mess)
subm.prepared = True
subm.save()
def setUp(self):
super().setUp()
self.sub = Submission.from_message(self.m)
self.sub.save()
def send_newsletter(post_id):
post = Post.objects.get(pk=post_id)
if not post.notified:
print("send_newsletter activated")
site = Site.objects.all()[0]
newsletter = Newsletter.objects.all()[0]
submission = Submission()
message = Message()
article = Article()
article.url = "http://{}{}".format(site.domain, post.get_absolute_url())
article.title = post.title
article.sortorder = 0
message.title = post.title
message.newsletter = newsletter
message.slug = post.slug
message.save()
message.articles.add(article, bulk=False)
message.save()
article.save()
submission.newsletter = newsletter
submission.message = message
submission.save()
for s in newsletter.get_subscriptions():
submission.subscriptions.add(s)
submission.save()
submission.submit()
Submission.submit_queue()
post.notified = True
post.save()
print("send_newsletter submitted")
def setUp(self):
super(SubmitSubmissionTestCase, self).setUp()
self.sub = Submission.from_message(self.m)
self.sub.save()
def execute(self):
logger.info(_('Submitting queued newsletter mailings'))
Submission.submit_queue()
def setUp(self):
super(SubmitSubmissionTestCase, self).setUp()
self.sub = Submission.from_message(self.m)
self.sub.save()
def submit_newsletter():
Submission.submit_queue()
def handle(self, *args, **options):
self.logger = logging.getLogger(type(self).__name__)
self.logger.debug('Handle called')
self.logger.info(_('Submitting queued newsletter mailings'))
Submission.submit_queue()
