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_basic_encryption(self):
e = Factory.rand_str()
historical_event = HistoricalEvent.objects.create()
historical_event.event_data = e
historical_event.save()
historical_event = None
historical_event = HistoricalEvent.objects.all()[0]
self.assertEquals(historical_event.event_data, e)
e = "😀💌❤️"
historical_event = HistoricalEvent.objects.create()
historical_event.event_data = e
historical_event.save()
historical_event = None
historical_event = HistoricalEvent.objects.all()[0]
self.assertEquals(historical_event.event_data, e)
e = Factory.rand_text()
historical_event = HistoricalEvent.objects.create()
historical_event.event_data = e
historical_event.save()
historical_event = None
historical_event = HistoricalEvent.objects.all()[0]
self.assertEquals(historical_event.event_data, e)
e = Factory.rand_email()
historical_event = HistoricalEvent.objects.create()
historical_event.event_data = e
historical_event.save()
historical_event = None
historical_event = HistoricalEvent.objects.all()[0]
self.assertEquals(historical_event.event_data, e)
def test_import_ignores_banned_people(self):
self.assertEquals(Person.objects.count(), 0)
self.assertEquals(Subscription.objects.count(), 0)
banned_person = Factory.person()
banned_person.ban()
self.assertEquals(Person.objects.count(), 1)
self.assertEquals(Subscription.objects.count(), 0)
import_source = Factory.rand_str()
email = banned_person.email
subscribed_at = Factory.rand_datetime()
subscription_url = Factory.rand_url()
double_opted_in = Factory.rand_bool()
self.newsletter.import_subscriber(
import_source=import_source,
email=email,
subscribed_at=subscribed_at,
subscription_url=subscription_url,
double_opted_in=double_opted_in,
newsletter_name=self.newsletter.internal_name,
overwrite=True,
)
self.assertEquals(Person.objects.count(), 1)
self.assertEquals(Newsletter.objects.count(), 1)
self.assertEquals(Subscription.objects.count(), 0)
def bestimator_experiment(request, slug):
if "bestid" not in request.GET:
now = timezone.now()
bestid = "%s%s" % (now.time(),
Factory.rand_str(length=10, include_emoji=False))
bestid = bestid.encode('utf-8').hex()
return redirect("%s?bestid=%s" % (
reverse("products:bestimator_experiment", args=(slug, )),
bestid,
))
else:
bestid = request.GET["bestid"]
date = datetime.datetime.today()
experiment = BestimatorExperiment.objects.get(slug=slug)
answer_objs = BestimatorAnswer.objects.filter(
experiment_choice__experiment=experiment,
session_hash=bestid,
)
if answer_objs.count() > 0:
answers = {}
for a in answer_objs:
answers[a.experiment_choice.slug] = a
return locals()
def today(request):
# TODO: Make this redirect to today's day.
consumer_str = Factory.rand_str(length=20, include_emoji=False)
if request.user.is_authenticated:
me = get_me(request)
else:
return redirect(reverse('clubhouse:home'))
date = datetime.datetime.today()
return locals()
def test_basic_encryption(self):
e = Factory.rand_str(include_emoji=False)
self.assertEquals(e, decrypt(encrypt(e)))
e = "😀💌❤️"
self.assertEquals(e, decrypt(encrypt(e)))
e = Factory.rand_text()
self.assertEquals(e, decrypt(encrypt(e)))
e = Factory.rand_email()
self.assertEquals(e, decrypt(encrypt(e)))
def test_stores_event_in_archive(self):
s = Factory.subscription()
p = s.person
self.assertEquals(HistoricalEvent.objects.count(), 0)
reason = Factory.rand_str()
p.ban(reason)
self.assertEquals(HistoricalEvent.objects.count(), 1)
h = HistoricalEvent.objects.all()[0]
self.assertEquals(h.event_type, "ban")
self.assertEquals(h.event_creator_type, "test")
self.assertEquals(h.event_creator_pk, 1)
self.assertEquals(h.event_creator_data, {
"person": p.get_data_dict(),
"reason": reason,
})
def day(request, hashid):
consumer_str = Factory.rand_str(length=20, include_emoji=False)
o = Organization.get()
day = JourneyDay.objects.get(hashid=hashid)
me = get_me(request)
if day.journey.productpurchase.purchase.person != me:
return redirect(reverse('logout'))
data_store_url = "/ws/journey/%s/%s" % (
day.journey.hashid,
day.hashid,
)
person_store_url = "/ws/p/%s" % (me.hashid, )
return TemplateResponse(
request, 'products/%s/day-%s.html' % (
day.journey.productpurchase.product.slug,
day.day_number,
), locals())
def test_import_with_no_newsletter_creates_person_but_not_subscription(
self):
self.assertEquals(Person.objects.count(), 0)
self.assertEquals(Subscription.objects.count(), 0)
import_source = Factory.rand_str()
email = Factory.rand_email()
subscribed_at = Factory.rand_datetime()
subscription_url = Factory.rand_url()
double_opted_in = Factory.rand_bool()
self.newsletter.import_subscriber(
import_source=import_source,
email=email,
subscribed_at=subscribed_at,
subscription_url=subscription_url,
double_opted_in=double_opted_in,
)
self.assertEquals(Person.objects.count(), 1)
self.assertEquals(Newsletter.objects.count(), 1)
self.assertEquals(Subscription.objects.count(), 0)
def one_click_sign_in_link(self, url):
from utils.factory import Factory
return quote_plus(
encrypt("%s|%s|%s" % (Factory.rand_str(
include_emoji=False, length=5), self.hashid, url)))
def test_import_imports_trolls_but_marks_them(self):
self.assertEquals(Person.objects.count(), 0)
self.assertEquals(Subscription.objects.count(), 0)
troll = Factory.person()
troll.mark_troll()
self.assertEquals(Person.objects.count(), 1)
import_source = Factory.rand_str()
email = troll.email
subscribed_at = Factory.rand_datetime()
subscription_url = Factory.rand_url()
double_opted_in = Factory.rand_bool()
import_time = timezone.now()
self.newsletter.import_subscriber(
import_source=import_source,
email=email,
subscribed_at=subscribed_at,
subscription_url=subscription_url,
double_opted_in=double_opted_in,
newsletter_name=self.newsletter.internal_name,
overwrite=True,
)
self.assertEquals(Person.objects.count(), 1)
self.assertEquals(Newsletter.objects.count(), 1)
self.assertEquals(Subscription.objects.count(), 1)
p = Person.objects.all()[0]
s = Subscription.objects.all()[0]
# Check person
self.assertEquals(p.first_name, None)
self.assertEquals(p.last_name, None)
self.assertEquals(p.email, email)
self.assertEquals(p.hashed_first_name, lookup_hash(None))
self.assertEquals(p.hashed_last_name, lookup_hash(None))
self.assertEquals(p.hashed_email, lookup_hash(email))
self.assertEquals(p.email_verified, double_opted_in)
self.assertEquals(p.time_zone, None)
self.assertEquals(p.was_imported, True)
self.assertBasicallyEqualTimes(p.was_imported_at, import_time)
self.assertEquals(p.import_source, import_source)
self.assertEquals(p.marked_troll, True)
self.assertBasicallyEqualTimes(p.marked_troll_at, import_time)
self.assertEquals(p.banned, False)
self.assertEquals(p.banned_at, None)
self.assertEquals(p.hard_bounced, False)
self.assertEquals(p.hard_bounced_at, None)
self.assertEquals(p.hard_bounced_reason, None)
self.assertEquals(p.hard_bounced_message, None)
self.assertEquals(p.never_contact_set, False)
self.assertEquals(p.never_contact_set_at, None)
self.assertEquals(p.personal_contact, False)
# Check subscription
self.assertEquals(s.person, p)
self.assertEquals(s.newsletter, self.newsletter)
self.assertBasicallyEqualTimes(s.subscribed_at, import_time)
self.assertEquals(s.subscription_url, subscription_url)
self.assertEquals(s.subscribed_from_ip, None)
self.assertEquals(s.was_imported, True)
self.assertBasicallyEqualTimes(s.was_imported_at, import_time)
self.assertEquals(s.import_source, import_source)
self.assertEquals(s.double_opted_in, double_opted_in)
self.assertEquals(s.double_opted_in_at, None)
self.assertEquals(s.has_set_never_unsubscribe, False)
self.assertEquals(s.unsubscribed, False)
self.assertEquals(s.unsubscribed_at, None)
def test_import_overwrites_if_told_to(self):
s = None
p = None
self.assertEquals(Person.objects.count(), 0)
self.assertEquals(Subscription.objects.count(), 0)
first_import_source = Factory.rand_str()
email = Factory.rand_email()
first_subscribed_at = Factory.rand_datetime()
first_subscription_url = Factory.rand_url()
first_double_opted_in = Factory.rand_bool()
first_double_opted_in_at = Factory.rand_datetime()
first_first_name = Factory.rand_name()
first_last_name = Factory.rand_name()
first_subscription_ip = Factory.rand_ip()
first_time_zone = Factory.rand_timezone()
self.newsletter.import_subscriber(
import_source=first_import_source,
email=email,
subscribed_at=first_subscribed_at,
subscription_url=first_subscription_url,
double_opted_in=first_double_opted_in,
double_opted_in_at=first_double_opted_in_at,
first_name=first_first_name,
last_name=first_last_name,
subscription_ip=first_subscription_ip,
time_zone=first_time_zone,
newsletter_name=self.newsletter.internal_name,
)
second_import_source = Factory.rand_str()
second_subscribed_at = Factory.rand_datetime()
second_subscription_url = Factory.rand_url()
second_double_opted_in = Factory.rand_bool()
second_double_opted_in_at = Factory.rand_datetime()
second_second_name = Factory.rand_name()
second_last_name = Factory.rand_name()
second_subscription_ip = Factory.rand_ip()
second_time_zone = Factory.rand_timezone()
second_import_time = timezone.now() # noqa
self.newsletter.import_subscriber(
import_source=second_import_source,
email=email,
subscribed_at=second_subscribed_at,
subscription_url=second_subscription_url,
double_opted_in=second_double_opted_in,
double_opted_in_at=second_double_opted_in_at,
first_name=second_second_name,
last_name=second_last_name,
subscription_ip=second_subscription_ip,
time_zone=second_time_zone,
newsletter_name=self.newsletter.internal_name,
overwrite=True,
)
self.assertEquals(Person.objects.count(), 1)
self.assertEquals(Newsletter.objects.count(), 1)
self.assertEquals(Subscription.objects.count(), 1)
p = Person.objects.all()[0]
s = Subscription.objects.all()[0]
# Check person
self.assertEquals(p.first_name, second_second_name)
self.assertEquals(p.last_name, second_last_name)
self.assertEquals(p.email, email)
self.assertEquals(p.hashed_first_name, lookup_hash(second_second_name))
self.assertEquals(p.hashed_last_name, lookup_hash(second_last_name))
self.assertEquals(p.hashed_email, lookup_hash(email))
self.assertEquals(p.email_verified, second_double_opted_in)
self.assertEquals(p.time_zone, second_time_zone)
self.assertEquals(p.was_imported, True)
self.assertBasicallyEqualTimes(p.was_imported_at, second_import_time)
self.assertEquals(p.import_source, second_import_source)
self.assertEquals(p.marked_troll, False)
self.assertEquals(p.marked_troll_at, None)
self.assertEquals(p.banned, False)
self.assertEquals(p.banned_at, None)
self.assertEquals(p.hard_bounced, False)
self.assertEquals(p.hard_bounced_at, None)
self.assertEquals(p.hard_bounced_reason, None)
self.assertEquals(p.hard_bounced_message, None)
self.assertEquals(p.never_contact_set, False)
self.assertEquals(p.never_contact_set_at, None)
self.assertEquals(p.personal_contact, False)
# Check subscription
self.assertEquals(s.person, p)
self.assertEquals(s.newsletter, self.newsletter)
self.assertBasicallyEqualTimes(s.subscribed_at, second_import_time)
self.assertEquals(s.subscription_url, second_subscription_url)
self.assertEquals(s.subscribed_from_ip, second_subscription_ip)
self.assertEquals(s.was_imported, True)
self.assertBasicallyEqualTimes(s.was_imported_at, second_import_time)
self.assertEquals(s.import_source, second_import_source)
self.assertEquals(s.double_opted_in, second_double_opted_in)
self.assertBasicallyEqualTimes(s.double_opted_in_at,
second_double_opted_in_at)
self.assertEquals(s.has_set_never_unsubscribe, False)
self.assertEquals(s.unsubscribed, False)
self.assertEquals(s.unsubscribed_at, None)
def test_reset_flow(self):
new_password = Factory.rand_str(length=20, include_emoji=False)
resp = self.get(
reverse('admin_password_reset'),
# reverse('password_reset_confirm')
follow=True,
)
self.assertTrue(b"id_email" in resp.content)
resp = self.post(reverse('admin_password_reset'), {
'email': self.person.email,
},
follow=True)
self.assertTrue(b"A link is on its way" in resp.content)
self.assertEquals(len(mail.outbox), 1)
message = mail.outbox[0]
body = message.body
self.assertIn("/password-reset/", body)
reset_index = body.find("/password-reset/") + len("/password-reset/")
uid_index_ends = body.find("/", reset_index)
token_index_ends = body.find("/", uid_index_ends + 1)
uid = body[reset_index:uid_index_ends]
token = body[uid_index_ends + 1:token_index_ends]
reset_url = "/accounts/password-reset/%s/%s" % (
uid,
token,
)
resp = self.get(
# reverse('password_reset_confirm', args=(uid, token,)),
reset_url,
follow=True,
)
self.assertIn(b"your new password", resp.content)
resp = self.post(
"/accounts/password-reset/%s/set-password/" % uid,
{
"new_password1": new_password,
"new_password2": new_password,
# "csrfmiddlewaretoken": csrf_token,
# "next": "/products/",
},
follow=True,
)
self.assertIn(b"Your new password has been saved.", resp.content)
resp = self.post(
"/accounts/login/",
{
"username": self.person.email,
"password": new_password,
"next": "/products/"
},
follow=True,
)
self.assertIn(b"logout_link", resp.content)
def setUp(self, *args, **kwargs):
self.person = Factory.person()
self.pw = Factory.rand_str(include_emoji=False)
self.person.set_password(self.pw)
super(TestResetPassword, self).setUp(*args, **kwargs)
