def test_post_subscribe_200(self):
email = Factory.rand_email()
name = Factory.rand_name()
subscription_url = Factory.rand_url()
response = self.post(
reverse('inkmail:subscribe', ),
{
'first_name': name,
'email': email,
'newsletter': self.newsletter.internal_name,
'subscription_url': subscription_url,
},
)
self.assertEquals(response.status_code, 200)
process_outgoing_message_queue()
self.assertEquals(len(mail.outbox), 1)
self.assertEquals(mail.outbox[0].subject,
self.newsletter.confirm_message.subject)
self.assertEquals(OutgoingMessage.objects.count(), 1)
om = OutgoingMessage.objects.all()[0]
self.assertIn(
om.render_email_string(
self.newsletter.confirm_message.body_text_unrendered),
mail.outbox[0].alternatives[0][0])
self.assertIn(
om.render_email_string(
self.newsletter.confirm_message.body_text_unrendered,
plain_text=True), mail.outbox[0].body)
self.assertEquals(len(mail.outbox[0].to), 1)
self.assertEquals(mail.outbox[0].to[0], email)
self.assertEquals(mail.outbox[0].from_email,
self.newsletter.full_from_email)
def test_get_transfer_subscribe_200(self):
email = Factory.rand_email()
name = Factory.rand_name()
response = self.get(
reverse(
'inkmail:transfer_subscription',
kwargs={
"transfer_code": self.newsletter.hashid,
},
),
{
'f': name,
'e': email,
# 'newsletter': self.newsletter.internal_name,
},
)
self.assertEquals(response.status_code, 200)
process_outgoing_message_queue()
self.assertEquals(len(mail.outbox), 1)
self.assertEquals(mail.outbox[0].subject,
self.newsletter.welcome_message.subject)
om = OutgoingMessage.objects.all()[0]
self.assertIn(
om.render_email_string(
self.newsletter.welcome_message.body_text_unrendered),
mail.outbox[0].alternatives[0][0])
self.assertIn(
om.render_email_string(
self.newsletter.welcome_message.body_text_unrendered,
plain_text=True), mail.outbox[0].body)
self.assertEquals(len(mail.outbox[0].to), 1)
self.assertEquals(mail.outbox[0].to[0], email)
self.assertEquals(mail.outbox[0].from_email,
self.newsletter.full_from_email)
def test_if_scheduled_for_future_does_not_send_until_future(self):
people = []
num_subscribers = Factory.rand_int(end=20)
for i in range(0, num_subscribers):
s = Factory.subscription(newsletter=self.newsletter)
s.double_opt_in()
people.append(s)
future_date = self.now() + datetime.timedelta(hours=1)
self.scheduled_newsletter_message = Factory.scheduled_newsletter_message(
newsletter=self.newsletter,
send_at_date=future_date,
send_at_hour=future_date.hour,
send_at_minute=future_date.minute,
use_local_time=False,
)
self.subject = self.scheduled_newsletter_message.message.subject
self.body = self.scheduled_newsletter_message.message.body_text_unrendered
queue_newsletter_message(self.scheduled_newsletter_message.hashid)
process_outgoing_message_queue()
self.assertEquals(len(mail.outbox), 0)
with freeze_time(self.now() + datetime.timedelta(hours=1)):
process_outgoing_message_queue()
self.assertEquals(len(mail.outbox), num_subscribers)
def test_clicked_confirm_a_second_time(self):
self.assertEquals(Subscription.objects.count(), 0)
email = Factory.rand_email()
name = Factory.rand_name()
subscription_url = Factory.rand_url()
response = self.post(
reverse(
'inkmail:subscribe',
),
{
'first_name': name,
'email': email,
'newsletter': self.newsletter.internal_name,
'subscription_url': subscription_url,
},
)
self.assertEquals(response.status_code, 200)
process_outgoing_message_queue()
self.assertEquals(len(mail.outbox), 1)
self.assertEquals(Subscription.objects.count(), 1)
s = Subscription.objects.all()[0]
self.assertIn(s.opt_in_link, mail.outbox[0].body)
self.get(s.opt_in_link)
s = Subscription.objects.get(pk=s.pk)
self.assertEquals(s.double_opted_in, True)
self.assertBasicallyEqualTimes(s.double_opted_in_at, self.now())
first_time = s.double_opted_in_at
# Click it again
self.get(s.opt_in_link)
s = Subscription.objects.get(pk=s.pk)
self.assertEquals(s.double_opted_in, True)
self.assertBasicallyEqualTimes(s.double_opted_in_at, first_time)
def test_invalid_opt_in_click(self):
self.assertEquals(Subscription.objects.count(), 0)
email = Factory.rand_email()
name = Factory.rand_name()
subscription_url = Factory.rand_url()
response = self.post(
reverse(
'inkmail:subscribe',
),
{
'first_name': name,
'email': email,
'newsletter': self.newsletter.internal_name,
'subscription_url': subscription_url,
},
)
self.assertEquals(response.status_code, 200)
process_outgoing_message_queue()
self.assertEquals(len(mail.outbox), 1)
self.assertEquals(Subscription.objects.count(), 1)
s = Subscription.objects.all()[0]
self.assertIn(s.opt_in_link, mail.outbox[0].body)
self.get("%s%s" % (s.opt_in_link, Factory.rand_str(length=2)))
s = Subscription.objects.get(pk=s.pk)
self.assertEquals(s.double_opted_in, False)
self.assertEquals(s.double_opted_in_at, None)
def test_unsubscribe_resubscribe_updates_all_fields(self):
self.assertEquals(len(mail.outbox), 0)
self.create_subscribed_person()
self.assertEquals(self.subscription.unsubscribed, False)
self.assertEquals(self.subscription.unsubscribed_at, None)
self.send_newsletter_message()
self.assertEquals(len(mail.outbox), 1)
m = mail.outbox[0]
self.assertEquals(OutgoingMessage.objects.count(), 1)
om = OutgoingMessage.objects.all()[0]
# Unsubscribe
self.assertIn(om.unsubscribe_link, m.body)
self.get(om.unsubscribe_link)
# Fetch updated subscription
self.subscription = Subscription.objects.get(pk=self.subscription.pk)
self.assertEquals(self.subscription.unsubscribed, True)
self.assertBasicallyEqualTimes(self.subscription.unsubscribed_at, self.now())
# Re-subscribe
name = Factory.rand_name()
subscription_url = Factory.rand_url()
response = self.post(
reverse(
'inkmail:subscribe',
),
{
'first_name': name,
'email': self.person.email,
'newsletter': self.newsletter.internal_name,
'subscription_url': subscription_url,
},
)
self.assertEquals(response.status_code, 200)
self.assertEquals(Subscription.objects.count(), 1)
self.subscription = Subscription.objects.get(pk=self.subscription.pk)
self.assertEquals(self.subscription.unsubscribed, False)
self.assertEquals(self.subscription.unsubscribed_at, None)
process_outgoing_message_queue()
self.assertEquals(len(mail.outbox), 2)
self.assertEquals(Subscription.objects.count(), 1)
s = Subscription.objects.all()[0]
self.assertIn(s.opt_in_link, mail.outbox[1].body)
# Re-double-opt-in
self.get(s.opt_in_link)
self.subscription = Subscription.objects.get(pk=self.subscription.pk)
self.assertEquals(self.subscription.unsubscribed, False)
self.assertEquals(self.subscription.unsubscribed_at, None)
process_outgoing_message_queue()
# Check fields
self.person = Person.objects.get(pk=self.person.pk)
self.assertEquals(self.person.first_name, name)
self.assertEquals(self.subscription.subscription_url, subscription_url)
def send_test_message(self):
self.test_message = Factory.message()
self.subject = self.test_message.subject
self.body_unrendered = self.test_message.body_text_unrendered
queue_message(message=self.test_message,
subscription=self.subscription)
om = OutgoingMessage.objects.get(
person=self.person,
message=self.test_message,
)
self.body = om.render_email_string(
self.test_message.body_text_unrendered)
process_outgoing_message_queue()
def send_newsletter_message(self):
self.scheduled_newsletter_message = Factory.scheduled_newsletter_message(
newsletter=self.newsletter,
send_at_date=self.now(),
send_at_hour=self.now().hour,
send_at_minute=self.now().minute,
use_local_time=False,
)
self.subject = self.scheduled_newsletter_message.message.subject
self.body_unrendered = self.scheduled_newsletter_message.message.body_text_unrendered
queue_newsletter_message.delay(
self.scheduled_newsletter_message.hashid)
process_outgoing_message_queue()
def send_test_transactional_message(self):
self.transactional_message = Factory.message(person=self.person,
transactional=True)
self.subject = self.transactional_message.subject
self.body = self.transactional_message.body_text_unrendered
self.body_unrendered = self.transactional_message.body_text_unrendered
queue_transactional_message(message=self.transactional_message,
person=self.person)
om = OutgoingMessage.objects.get(
person=self.person,
message=self.transactional_message,
)
self.body = om.render_email_string(
self.transactional_message.body_text_unrendered, plain_text=True)
process_outgoing_message_queue()
def test_if_scheduled_for_past_date_sends_immediately(self):
people = []
num_subscribers = Factory.rand_int(end=20)
for i in range(0, num_subscribers):
s = Factory.subscription(newsletter=self.newsletter)
s.double_opt_in()
people.append(s)
self.scheduled_newsletter_message = Factory.scheduled_newsletter_message(
newsletter=self.newsletter,
send_at_date=self.now() - datetime.timedelta(days=2),
send_at_hour=self.now().hour,
send_at_minute=self.now().minute,
use_local_time=False,
)
self.subject = self.scheduled_newsletter_message.message.subject
self.body = self.scheduled_newsletter_message.message.body_text_unrendered
queue_newsletter_message(self.scheduled_newsletter_message.hashid)
process_outgoing_message_queue()
self.assertEquals(len(mail.outbox), num_subscribers)
def test_unsubscribe_resubscribe_allows_messages_sent(self):
self.assertEquals(len(mail.outbox), 0)
self.create_subscribed_person()
# Double-opt-in
self.get(self.subscription.opt_in_link)
self.assertEquals(self.subscription.unsubscribed, False)
self.assertEquals(self.subscription.unsubscribed_at, None)
self.send_newsletter_message()
self.assertEquals(len(mail.outbox), 1)
m = mail.outbox[0]
self.assertEquals(OutgoingMessage.objects.count(), 1)
om = OutgoingMessage.objects.all()[0]
# Unsubscribe
self.assertIn(om.unsubscribe_link, m.body)
self.get(om.unsubscribe_link)
# Fetch updated subscription
self.subscription = Subscription.objects.get(pk=self.subscription.pk)
self.assertEquals(self.subscription.unsubscribed, True)
self.assertEquals(self.subscription.double_opted_in, True)
self.assertBasicallyEqualTimes(self.subscription.unsubscribed_at,
self.now())
self.get(om.unsubscribe_link.replace("unsubscribe", "resubscribe"))
self.subscription = Subscription.objects.get(pk=self.subscription.pk)
self.assertBasicallyEqualTimes(self.subscription.resubscribed_at,
self.now())
self.assertEquals(self.subscription.unsubscribed, False)
self.assertEquals(self.subscription.double_opted_in, True)
# Send newsletter, make sure it sent.
self.send_newsletter_message()
process_outgoing_message_queue()
self.assertEquals(len(mail.outbox), 2)
def test_unsubscribe_resubscribe_has_records_of_all_actions(self):
self.newsletter = Factory.newsletter()
self.assertEquals(HistoricalEvent.objects.count(), 0)
email = Factory.rand_email()
name = Factory.rand_name()
subscription_url = Factory.rand_url()
response = self.post(
reverse('inkmail:subscribe', ),
{
'first_name': name,
'email': email,
'newsletter': self.newsletter.internal_name,
'subscription_url': subscription_url,
},
)
self.assertEquals(response.status_code, 200)
self.assertEquals(Person.objects.count(), 1)
self.assertEquals(Subscription.objects.count(), 1)
p = Person.objects.all()[0]
s = Subscription.objects.all()[0]
self.assertEquals(HistoricalEvent.objects.count(), 1)
he = HistoricalEvent.objects.order_by("-created_at").all()[0]
self.assertEquals(he.event_type, "subscribed")
self.assertEquals(he.event_creator_type, "person")
self.assertEquals(he.event_creator_pk, p.pk)
self.assertHistoricalEventDataEquality(
he,
person=p,
event_type="subscribed",
newsletter=self.newsletter,
subscription=s,
)
# Unsubscribe
om = OutgoingMessage.objects.all()[0]
self.get(om.unsubscribe_link)
s = Subscription.objects.get(pk=s.pk)
self.assertEquals(HistoricalEvent.objects.count(), 2)
he = HistoricalEvent.objects.order_by("-created_at").all()[0]
self.assertEquals(he.event_type, "unsubscribe")
self.assertEquals(he.event_creator_type, "person")
self.assertEquals(he.event_creator_pk, p.pk)
self.assertHistoricalEventDataEquality(
he,
person=p,
event_type="unsubscribe",
subscription=s,
outgoingmessage=om,
)
# Fetch updated subscription
s = Subscription.objects.get(pk=s.pk)
# Re-subscribe
name = Factory.rand_name()
subscription_url = Factory.rand_url()
response = self.post(
reverse('inkmail:subscribe', ),
{
'first_name': name,
'email': p.email,
'newsletter': self.newsletter.internal_name,
'subscription_url': subscription_url,
},
)
self.assertEquals(response.status_code, 200)
s = Subscription.objects.get(pk=s.pk)
p = Person.objects.get(pk=p.pk)
self.assertEquals(HistoricalEvent.objects.count(), 3)
he = HistoricalEvent.objects.order_by("-created_at").all()[0]
self.assertEquals(he.event_type, "subscribed")
self.assertEquals(he.event_creator_type, "person")
self.assertEquals(he.event_creator_pk, p.pk)
self.assertHistoricalEventDataEquality(
he,
person=p,
event_type="subscribed",
newsletter=self.newsletter,
subscription=s,
)
process_outgoing_message_queue()
# Re-double-opt-in
self.get(s.opt_in_link)
s = Subscription.objects.get(pk=s.pk)
p = Person.objects.get(pk=p.pk)
self.assertEquals(HistoricalEvent.objects.count(), 4)
he = HistoricalEvent.objects.order_by("-created_at").all()[0]
self.assertEquals(he.event_type, "double-opt-in")
self.assertEquals(he.event_creator_type, "person")
self.assertEquals(he.event_creator_pk, p.pk)
self.assertHistoricalEventDataEquality(
he,
person=p,
event_type="double-opt-in",
newsletter=self.newsletter,
subscription=s,
)
def test_unsubscribe_resubscribe_non_opted_in_requires_opt_in_then_allows_messages_sent(
self):
self.assertEquals(len(mail.outbox), 0)
self.create_subscribed_person()
self.assertEquals(self.subscription.unsubscribed, False)
self.assertEquals(self.subscription.unsubscribed_at, None)
self.send_newsletter_message()
self.assertEquals(len(mail.outbox), 1)
m = mail.outbox[0]
self.assertEquals(OutgoingMessage.objects.count(), 1)
om = OutgoingMessage.objects.all()[0]
# Unsubscribe
self.assertIn(om.unsubscribe_link, m.body)
self.get(om.unsubscribe_link)
# Fetch updated subscription
self.subscription = Subscription.objects.get(pk=self.subscription.pk)
self.assertEquals(self.subscription.unsubscribed, True)
# Re-opt them out manually
self.subscription.double_opted_in = False
self.subscription.double_opted_in_at = None
self.subscription.save()
# self.assertEquals(self.subscription.double_opted_in, False)
# self.assertEquals(self.subscription.double_opted_in_at, None)
self.assertBasicallyEqualTimes(self.subscription.unsubscribed_at,
self.now())
# Re-subscribe
response = self.post(
reverse('inkmail:subscribe', ),
{
'first_name': self.person.first_name,
'email': self.person.email,
'newsletter': self.newsletter.internal_name,
'subscription_url': Factory.rand_url(),
},
)
self.assertEquals(response.status_code, 200)
self.subscription = Subscription.objects.get(pk=self.subscription.pk)
self.assertEquals(self.subscription.unsubscribed, False)
self.assertEquals(self.subscription.unsubscribed_at, None)
process_outgoing_message_queue()
self.assertEquals(len(mail.outbox), 2)
self.assertEquals(Subscription.objects.count(), 1)
s = Subscription.objects.all()[0]
self.assertIn(s.opt_in_link, mail.outbox[1].body)
# Re-double-opt-in
self.get(self.subscription.opt_in_link)
self.subscription = Subscription.objects.get(pk=self.subscription.pk)
self.assertEquals(self.subscription.unsubscribed, False)
self.assertEquals(self.subscription.unsubscribed_at, None)
self.assertEquals(self.subscription.double_opted_in, True)
self.assertBasicallyEqualTimes(self.subscription.double_opted_in_at,
self.now())
process_outgoing_message_queue()
# Welcome email re-sent
self.assertEquals(len(mail.outbox), 3)
# Send newsletter, make sure it sent.
self.send_newsletter_message()
process_outgoing_message_queue()
self.assertEquals(len(mail.outbox), 4)
