You cannot select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1090 lines
48 KiB
Python
1090 lines
48 KiB
Python
from http import HTTPStatus
|
|
|
|
from django.core.files.uploadedfile import SimpleUploadedFile
|
|
from django.contrib.auth import models as authmodels
|
|
from django.contrib.admin.sites import AdminSite
|
|
from django.contrib.messages import get_messages
|
|
from django.contrib.auth.models import User
|
|
from django.utils.translation import gettext_lazy as _
|
|
from django.test import TestCase, Client, RequestFactory
|
|
from django.utils import timezone, translation
|
|
from django.conf import settings
|
|
from django.urls import reverse
|
|
from unittest import skip, mock
|
|
from .models import Member, Group, PermissionMember, PermissionGroup, Freizeit, GEMEINSCHAFTS_TOUR, MUSKELKRAFT_ANREISE,\
|
|
MemberNoteList, NewMemberOnList, confirm_mail_by_key, EmergencyContact, MemberWaitingList,\
|
|
RegistrationPassword, MemberUnconfirmedProxy, InvitationToGroup, DIVERSE, MALE, FEMALE
|
|
from .admin import MemberWaitingListAdmin, MemberAdmin, FreizeitAdmin
|
|
from mailer.models import EmailAddress
|
|
|
|
from django.db import connection
|
|
from django.db.migrations.executor import MigrationExecutor
|
|
import random
|
|
import datetime
|
|
from dateutil.relativedelta import relativedelta
|
|
import math
|
|
|
|
|
|
REGISTRATION_DATA = {
|
|
'prename': 'Peter',
|
|
'lastname': 'Wulter',
|
|
'street': 'Street 123',
|
|
'plz': '12345 EJ',
|
|
'town': 'Town 1',
|
|
'phone_number': '+49 123456',
|
|
'birth_date': '2010-05-17',
|
|
'gender': '2',
|
|
'email': settings.TEST_MAIL,
|
|
'alternative_email': settings.TEST_MAIL,
|
|
}
|
|
WAITER_DATA = {
|
|
'prename': 'Peter',
|
|
'lastname': 'Wulter',
|
|
'birth_date': '1999-02-16',
|
|
'gender': '0',
|
|
'email': settings.TEST_MAIL,
|
|
'application_text': 'hoho',
|
|
}
|
|
EMERGENCY_CONTACT_DATA = {
|
|
'emergencycontact_set-TOTAL_FORMS': '1',
|
|
'emergencycontact_set-INITIAL_FORMS': '0',
|
|
'emergencycontact_set-MIN_NUM_FORMS': '1',
|
|
'emergencycontact_set-MAX_NUM_FORMS': '1000',
|
|
'emergencycontact_set-0-prename': 'Papa',
|
|
'emergencycontact_set-0-lastname': 'Wulter',
|
|
'emergencycontact_set-0-email': settings.TEST_MAIL,
|
|
'emergencycontact_set-0-phone_number': '-49 124125',
|
|
'emergencycontact_set-0-id': '',
|
|
'emergencycontact_set-0-DELETE': '',
|
|
'emergencycontact_set-0-member': '',
|
|
}
|
|
|
|
|
|
def create_custom_user(username, groups, prename, lastname):
|
|
user = User.objects.create_user(
|
|
username=username, password='secret'
|
|
)
|
|
member = Member.objects.create(prename=prename, lastname=lastname, birth_date=timezone.localdate(), email=settings.TEST_MAIL, gender=DIVERSE)
|
|
member.user = user
|
|
member.save()
|
|
user.is_staff = True
|
|
user.save()
|
|
|
|
for group in groups:
|
|
g = authmodels.Group.objects.get(name=group)
|
|
user.groups.add(g)
|
|
return user
|
|
|
|
|
|
class BasicMemberTestCase(TestCase):
|
|
def setUp(self):
|
|
self.jl = Group.objects.create(name="Jugendleiter")
|
|
self.alp = Group.objects.create(name="Alpenfuechse")
|
|
self.spiel = Group.objects.create(name="Spielkinder")
|
|
|
|
self.fritz = Member.objects.create(prename="Fritz", lastname="Wulter", birth_date=timezone.now().date(),
|
|
email=settings.TEST_MAIL, gender=DIVERSE)
|
|
self.fritz.group.add(self.jl)
|
|
self.fritz.group.add(self.alp)
|
|
self.fritz.save()
|
|
|
|
em = EmailAddress.objects.create(name='foobar')
|
|
self.alp.contact_email = em
|
|
self.alp.save()
|
|
|
|
self.peter = Member.objects.create(prename="Peter", lastname="Wulter",
|
|
birth_date=timezone.now().date(),
|
|
email=settings.TEST_MAIL, gender=MALE)
|
|
self.peter.group.add(self.jl)
|
|
self.peter.group.add(self.alp)
|
|
self.peter.save()
|
|
|
|
self.lara = Member.objects.create(prename="Lara", lastname="Wallis", birth_date=timezone.now().date(),
|
|
email=settings.TEST_MAIL, gender=DIVERSE)
|
|
self.lara.group.add(self.alp)
|
|
self.lara.save()
|
|
self.fridolin = Member.objects.create(prename="Fridolin", lastname="Spargel", birth_date=timezone.now().date(),
|
|
email=settings.TEST_MAIL, gender=MALE)
|
|
self.fridolin.group.add(self.alp)
|
|
self.fridolin.group.add(self.spiel)
|
|
self.fridolin.save()
|
|
|
|
self.lise = Member.objects.create(prename="Lise", lastname="Lotte", birth_date=timezone.now().date(),
|
|
email=settings.TEST_MAIL, gender=FEMALE)
|
|
|
|
|
|
class MemberTestCase(BasicMemberTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
|
|
p1 = PermissionMember.objects.create(member=self.fritz)
|
|
p1.view_members.add(self.lara)
|
|
p1.change_members.add(self.lara)
|
|
p1.view_groups.add(self.spiel)
|
|
|
|
self.ja = Group.objects.create(name="Jugendausschuss")
|
|
self.peter = Member.objects.create(prename="Peter", lastname="Keks", birth_date=timezone.now().date(),
|
|
email=settings.TEST_MAIL, gender=MALE)
|
|
self.anna = Member.objects.create(prename="Anna", lastname="Keks", birth_date=timezone.now().date(),
|
|
email=settings.TEST_MAIL, gender=FEMALE)
|
|
self.lisa = Member.objects.create(prename="Lisa", lastname="Keks", birth_date=timezone.now().date(),
|
|
email=settings.TEST_MAIL, gender=DIVERSE)
|
|
self.peter.group.add(self.ja)
|
|
self.anna.group.add(self.ja)
|
|
self.lisa.group.add(self.ja)
|
|
|
|
p2 = PermissionGroup.objects.create(group=self.ja)
|
|
p2.list_groups.add(self.ja)
|
|
|
|
def test_may(self):
|
|
self.assertTrue(self.fritz.may_view(self.lara))
|
|
self.assertTrue(self.fritz.may_change(self.lara))
|
|
self.assertTrue(self.fritz.may_view(self.fridolin))
|
|
self.assertFalse(self.fritz.may_change(self.fridolin))
|
|
|
|
# every member should be able to list, view and change themselves
|
|
for member in Member.objects.all():
|
|
self.assertTrue(member.may_list(member))
|
|
self.assertTrue(member.may_view(member))
|
|
self.assertTrue(member.may_change(member))
|
|
|
|
# every member of Jugendausschuss should be able to view every other member of Jugendausschuss
|
|
for member in self.ja.member_set.all():
|
|
for other in self.ja.member_set.all():
|
|
self.assertTrue(member.may_list(other))
|
|
if member != other:
|
|
self.assertFalse(member.may_view(other))
|
|
self.assertFalse(member.may_change(other))
|
|
|
|
def test_filter_queryset(self):
|
|
# lise may only list herself
|
|
self.assertEqual(set(self.lise.filter_queryset_by_permissions(model=Member)), set([self.lise]))
|
|
|
|
for member in Member.objects.all():
|
|
# passing the empty queryset as starting queryset, should give the empty queryset back
|
|
self.assertEqual(member.filter_queryset_by_permissions(Member.objects.none(), model=Member).count(), 0)
|
|
# passing all objects as start queryset should give the same result as not giving any start queryset
|
|
self.assertEqual(set(member.filter_queryset_by_permissions(Member.objects.all(), model=Member)),
|
|
set(member.filter_queryset_by_permissions(model=Member)))
|
|
|
|
|
|
def test_compare_filter_queryset_may_list(self):
|
|
# filter_queryset and filtering manually by may_list should be the same
|
|
for member in Member.objects.all():
|
|
s1 = set(member.filter_queryset_by_permissions(model=Member))
|
|
s2 = set(other for other in Member.objects.all() if member.may_list(other))
|
|
self.assertEqual(s1, s2)
|
|
|
|
|
|
class PDFTestCase(TestCase):
|
|
def setUp(self):
|
|
self.ex = Freizeit.objects.create(name='Wild trip', kilometers_traveled=120,
|
|
tour_type=GEMEINSCHAFTS_TOUR,
|
|
tour_approach=MUSKELKRAFT_ANREISE,
|
|
difficulty=1)
|
|
self.note = MemberNoteList.objects.create(title='Cool list')
|
|
|
|
for i in range(7):
|
|
m = Member.objects.create(prename='Lise {}'.format(i),
|
|
lastname='Walter',
|
|
birth_date=timezone.now().date(),
|
|
email=settings.TEST_MAIL, gender=FEMALE)
|
|
NewMemberOnList.objects.create(member=m, comments='a' * i, memberlist=self.ex)
|
|
NewMemberOnList.objects.create(member=m, comments='a' * i, memberlist=self.note)
|
|
|
|
User.objects.create_superuser(
|
|
username='superuser', password='secret'
|
|
)
|
|
standard = create_custom_user('standard', ['Standard'], 'Paul', 'Wulter')
|
|
|
|
def _test_pdf(self, name, model='freizeit', invalid=False, username='superuser'):
|
|
c = Client()
|
|
c.login(username=username, password='secret')
|
|
|
|
pk = self.ex.pk if model == 'freizeit' else self.note.pk
|
|
url = reverse('admin:members_%s_action' % model, args=(pk,))
|
|
response = c.post(url, {name: 'hoho'})
|
|
if not invalid:
|
|
self.assertEqual(response.status_code, 200, 'Response code is not 200.')
|
|
self.assertEqual(response.headers['Content-Type'], 'application/pdf', 'Response content type is not pdf.')
|
|
else:
|
|
self.assertEqual(response.status_code, 302, 'Response code is not 302.')
|
|
|
|
def test_crisis_intervention_list(self):
|
|
self._test_pdf('crisis_intervention_list')
|
|
self._test_pdf('crisis_intervention_list', username='standard', invalid=True)
|
|
|
|
def test_notes_list(self):
|
|
self._test_pdf('notes_list')
|
|
self._test_pdf('notes_list', username='standard', invalid=True)
|
|
|
|
# TODO: Since generating a seminar report requires more input now, this test rightly
|
|
# fails. Replace this test with one that fills the POST form and generates a pdf.
|
|
@skip("Currently rightly fails, because expected behaviour changed.")
|
|
def test_sjr_application(self):
|
|
self._test_pdf('sjr_application')
|
|
self._test_pdf('sjr_application', username='standard', invalid=True)
|
|
|
|
# TODO: Since generating a seminar report requires more input now, this test rightly
|
|
# fails. Replace this test with one that fills the POST form and generates a pdf.
|
|
@skip("Currently rightly fails, because expected behaviour changed.")
|
|
def test_seminar_report(self):
|
|
self._test_pdf('seminar_report')
|
|
self._test_pdf('seminar_report', username='standard', invalid=True)
|
|
|
|
def test_membernote_summary(self):
|
|
self._test_pdf('summary', model='membernotelist')
|
|
self._test_pdf('summary', model='membernotelist', username='standard', invalid=True)
|
|
|
|
def test_wrong_action_freizeit(self):
|
|
return self._test_pdf('asdf', invalid=True)
|
|
|
|
def test_wrong_action_membernotelist(self):
|
|
return self._test_pdf('asdf', invalid=True, model='membernotelist')
|
|
|
|
|
|
class AdminTestCase(TestCase):
|
|
def setUp(self, model, admin):
|
|
self.factory = RequestFactory()
|
|
self.model = model
|
|
if model is not None and admin is not None:
|
|
self.admin = admin(model, AdminSite())
|
|
superuser = User.objects.create_superuser(
|
|
username='superuser', password='secret'
|
|
)
|
|
standard = create_custom_user('standard', ['Standard'], 'Paul', 'Wulter')
|
|
trainer = create_custom_user('trainer', ['Standard', 'Trainings'], 'Lise', 'Lotte')
|
|
treasurer = create_custom_user('treasurer', ['Standard', 'Finance'], 'Lara', 'Litte')
|
|
materialwarden = create_custom_user('materialwarden', ['Standard', 'Material'], 'Loro', 'Lutte')
|
|
|
|
paul = standard.member
|
|
|
|
staff = Group.objects.create(name='Jugendleiter')
|
|
cool_kids = Group.objects.create(name='cool kids')
|
|
super_kids = Group.objects.create(name='super kids')
|
|
|
|
p1 = PermissionMember.objects.create(member=paul)
|
|
p1.view_groups.add(cool_kids)
|
|
p1.list_groups.add(super_kids)
|
|
p1.list_groups.add(cool_kids)
|
|
|
|
for i in range(3):
|
|
m = Member.objects.create(prename='Fritz {}'.format(i), lastname='Walter', birth_date=timezone.now().date(),
|
|
email=settings.TEST_MAIL, gender=MALE)
|
|
m.group.add(cool_kids)
|
|
m.save()
|
|
for i in range(7):
|
|
m = Member.objects.create(prename='Lise {}'.format(i), lastname='Walter', birth_date=timezone.now().date(),
|
|
email=settings.TEST_MAIL, gender=FEMALE)
|
|
m.group.add(super_kids)
|
|
m.save()
|
|
for i in range(5):
|
|
m = Member.objects.create(prename='Lulla {}'.format(i), lastname='Hulla', birth_date=timezone.now().date(),
|
|
email=settings.TEST_MAIL, gender=DIVERSE)
|
|
m.group.add(staff)
|
|
m.save()
|
|
m = Member.objects.create(prename='Peter', lastname='Hulla', birth_date=timezone.now().date(),
|
|
email=settings.TEST_MAIL, gender=MALE)
|
|
m.group.add(staff)
|
|
p1.list_members.add(m)
|
|
|
|
def _login(self, name):
|
|
c = Client()
|
|
res = c.login(username=name, password='secret')
|
|
# make sure we logged in
|
|
assert res
|
|
return c
|
|
|
|
|
|
class PermissionTestCase(AdminTestCase):
|
|
def setUp(self):
|
|
super().setUp(model=None, admin=None)
|
|
|
|
def test_standard_permissions(self):
|
|
u = User.objects.get(username='standard')
|
|
self.assertTrue(u.has_perm('members.view_member'))
|
|
|
|
def test_queryset_standard(self):
|
|
u = User.objects.get(username='standard')
|
|
queryset = u.member.filter_queryset_by_permissions(model=Member)
|
|
super_kids = Group.objects.get(name='super kids')
|
|
super_kid = super_kids.member_set.first()
|
|
self.assertTrue(super_kid in queryset, 'super kid is not in queryset for Paul.')
|
|
|
|
def test_queryset_trainer(self):
|
|
u = User.objects.get(username='trainer')
|
|
queryset = u.member.filter_queryset_by_permissions(model=Member)
|
|
self.assertEqual(set(queryset), {u.member}, 'Filtering trainer queryset yields more the trainer.')
|
|
|
|
|
|
class MemberAdminTestCase(AdminTestCase):
|
|
def setUp(self):
|
|
super().setUp(model=Member, admin=MemberAdmin)
|
|
cool_kids = Group.objects.get(name='cool kids')
|
|
super_kids = Group.objects.get(name='super kids')
|
|
mega_kids = Group.objects.create(name='mega kids')
|
|
|
|
for i in range(1):
|
|
m = Member.objects.create(prename='Peter {}'.format(i), lastname='Walter', birth_date=timezone.now().date(),
|
|
email=settings.TEST_MAIL, gender=MALE)
|
|
m.group.add(mega_kids)
|
|
m.save()
|
|
|
|
def test_changelist(self):
|
|
c = self._login('superuser')
|
|
|
|
url = reverse('admin:members_member_changelist')
|
|
response = c.get(url)
|
|
self.assertEqual(response.status_code, 200, 'Response code is not 200.')
|
|
|
|
def test_change(self):
|
|
c = self._login('superuser')
|
|
|
|
mega_kids = Group.objects.get(name='mega kids')
|
|
mega_kid = mega_kids.member_set.first()
|
|
url = reverse('admin:members_member_change', args=(mega_kid.pk,))
|
|
response = c.get(url)
|
|
self.assertEqual(response.status_code, 200, 'Response code is not 200.')
|
|
|
|
# if member does not exist, expect redirect
|
|
url = reverse('admin:members_member_change', args=(71233,))
|
|
response = c.get(url)
|
|
self.assertEqual(response.status_code, 302, 'Response code is not 302.')
|
|
|
|
def test_changelist_standard(self):
|
|
c = self._login('standard')
|
|
|
|
url = reverse('admin:members_member_changelist')
|
|
response = c.get(url)
|
|
self.assertEqual(response.status_code, 200, 'Response code is not 200.')
|
|
|
|
results = response.context['results']
|
|
for result in results:
|
|
name_or_link_field = result[1]
|
|
group_field = result[4]
|
|
self.assertFalse('mega kids' in group_field, 'Standard can list a mega kid.')
|
|
if 'cool kids' in group_field:
|
|
self.assertTrue('href' in name_or_link_field)
|
|
elif 'super kids' in group_field:
|
|
self.assertFalse('href' in name_or_link_field)
|
|
|
|
|
|
def test_changelist_trainer(self):
|
|
c = self._login('trainer')
|
|
|
|
url = reverse('admin:members_member_changelist')
|
|
response = c.get(url)
|
|
# should not redirect
|
|
self.assertEqual(response.status_code, 200, 'Response code is not 200.')
|
|
|
|
# trainers can view everyone, so there should be links in every row
|
|
results = response.context['results']
|
|
for result in results:
|
|
name_or_link_field = result[1]
|
|
group_field = result[4]
|
|
self.assertTrue('href' in name_or_link_field)
|
|
|
|
|
|
def test_changelist_materialwarden(self):
|
|
u = User.objects.get(username='materialwarden')
|
|
c = self._login('materialwarden')
|
|
|
|
url = reverse('admin:members_member_changelist')
|
|
response = c.get(url)
|
|
# should not redirect
|
|
self.assertEqual(response.status_code, 200, 'Response code is not 200.')
|
|
|
|
# materialwarden people can list everyone, but only view themselves by default
|
|
results = response.context['results']
|
|
for result in results:
|
|
name_or_link_field = result[1]
|
|
group_field = result[4]
|
|
self.assertFalse('href' in name_or_link_field and str(u.member.pk) not in name_or_link_field)
|
|
|
|
# now set member to None
|
|
m = u.member
|
|
m.user = None
|
|
m.save()
|
|
|
|
response = c.get(url)
|
|
# should not redirect
|
|
self.assertEqual(response.status_code, 200, 'Response code is not 200.')
|
|
|
|
# since materialwarden has no member associated, no one should be viewable
|
|
results = response.context['results']
|
|
for result in results:
|
|
name_or_link_field = result[1]
|
|
group_field = result[4]
|
|
self.assertFalse('href' in name_or_link_field)
|
|
|
|
|
|
def test_change_standard(self):
|
|
u = User.objects.get(username='standard')
|
|
self.assertTrue(hasattr(u, 'member'))
|
|
c = self._login('standard')
|
|
|
|
cool_kids = Group.objects.get(name='cool kids')
|
|
cool_kid = cool_kids.member_set.first()
|
|
|
|
self.assertTrue(u.has_perm('members.view_obj_member', cool_kid))
|
|
self.assertFalse(u.has_perm('members.change_obj_member', cool_kid))
|
|
self.assertFalse(u.has_perm('members.delete_obj_member', cool_kid))
|
|
self.assertTrue(hasattr(u, 'member'))
|
|
url = reverse('admin:members_member_change', args=(cool_kid.pk,))
|
|
response = c.get(url, follow=True)
|
|
|
|
super_kids = Group.objects.get(name='super kids')
|
|
super_kid = super_kids.member_set.first()
|
|
url = reverse('admin:members_member_change', args=(super_kid.pk,))
|
|
response = c.get(url, follow=True)
|
|
final = response.redirect_chain[-1][0]
|
|
final_target = reverse('admin:members_member_changelist')
|
|
self.assertEqual(response.status_code, 200, 'Response code is not 200.')
|
|
self.assertEqual(final, final_target, 'Did redirect to wrong url.')
|
|
|
|
|
|
class FreizeitTestCase(BasicMemberTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.ex = Freizeit.objects.create(name='Wild trip', kilometers_traveled=120,
|
|
tour_type=GEMEINSCHAFTS_TOUR,
|
|
tour_approach=MUSKELKRAFT_ANREISE,
|
|
difficulty=1)
|
|
|
|
def _setup_test_ljp_participant_count(self, n_yl, n_correct_age, n_too_old):
|
|
for i in range(n_yl):
|
|
# a 50 years old
|
|
m = Member.objects.create(prename='Peter {}'.format(i),
|
|
lastname='Wulter',
|
|
birth_date=datetime.datetime.today() - relativedelta(years=50),
|
|
email=settings.TEST_MAIL,
|
|
gender=FEMALE)
|
|
self.ex.jugendleiter.add(m)
|
|
for i in range(n_correct_age):
|
|
# a 10 years old
|
|
m = Member.objects.create(prename='Lise {}'.format(i),
|
|
lastname='Walter',
|
|
birth_date=datetime.datetime.today() - relativedelta(years=10),
|
|
email=settings.TEST_MAIL,
|
|
gender=FEMALE)
|
|
NewMemberOnList.objects.create(member=m, comments='a', memberlist=self.ex)
|
|
for i in range(n_too_old):
|
|
# a 27 years old
|
|
m = Member.objects.create(prename='Lise {}'.format(i),
|
|
lastname='Walter',
|
|
birth_date=datetime.datetime.today() - relativedelta(years=27),
|
|
email=settings.TEST_MAIL,
|
|
gender=FEMALE)
|
|
NewMemberOnList.objects.create(member=m, comments='a', memberlist=self.ex)
|
|
|
|
def _cleanup_excursion(self):
|
|
# delete all members on excursion for clean up
|
|
NewMemberOnList.objects.all().delete()
|
|
self.ex.jugendleiter.all().delete()
|
|
|
|
def _test_theoretic_ljp_participant_count_proportion(self, n_yl, n_correct_age, n_too_old):
|
|
self._setup_test_ljp_participant_count(n_yl, n_correct_age, n_too_old)
|
|
self.assertGreaterEqual(self.ex.theoretic_ljp_participant_count, n_yl,
|
|
'An excursion with {n_yl} youth leaders and {n_correct_age} participants in the correct age range should have at least {n} participants.'.format(n_yl=n_yl, n_correct_age=n_correct_age, n=n_yl + n_correct_age))
|
|
self.assertLessEqual(self.ex.theoretic_ljp_participant_count, n_yl + n_correct_age + n_too_old,
|
|
'An excursion with a total number of youth leaders and participants of {n} should have not more than {n} participants'.format(n=n_yl + n_correct_age + n_too_old))
|
|
|
|
n_parts_only = self.ex.theoretic_ljp_participant_count - n_yl
|
|
self.assertLessEqual(n_parts_only - n_correct_age, 1/5 * n_parts_only,
|
|
'An excursion with {n_parts_only} non-youth-leaders, of which {n_correct_age} have the correct age, the number of participants violating the age range must not exceed 20% of the total participants, i.e. {d}'.format(n_parts_only=n_parts_only, n_correct_age=n_correct_age, d=1/5 * n_parts_only))
|
|
|
|
self.assertEqual(n_parts_only - n_correct_age, min(math.floor(1/5 * n_parts_only), n_too_old),
|
|
'An excursion with {n_parts_only} non-youth-leaders, of which {n_correct_age} have the correct age, the number of participants violating the age range must be equal to the minimum of {n_too_old} and the smallest integer less than 20% of the total participants, i.e. {d}'.format(n_parts_only=n_parts_only, n_correct_age=n_correct_age, d=math.floor(1/5 * n_parts_only), n_too_old=n_too_old))
|
|
|
|
# cleanup
|
|
self._cleanup_excursion()
|
|
|
|
def _test_ljp_participant_count_proportion(self, n_yl, n_correct_age, n_too_old):
|
|
self._setup_test_ljp_participant_count(n_yl, n_correct_age, n_too_old)
|
|
if n_yl + n_correct_age + n_too_old < 5:
|
|
self.assertEqual(self.ex.ljp_participant_count, 0)
|
|
else:
|
|
self.assertEqual(self.ex.ljp_participant_count, self.ex.theoretic_ljp_participant_count)
|
|
|
|
# cleanup
|
|
self._cleanup_excursion()
|
|
|
|
def test_theoretic_ljp_participant_count(self):
|
|
self._test_theoretic_ljp_participant_count_proportion(2, 0, 0)
|
|
for i in range(10):
|
|
self._test_theoretic_ljp_participant_count_proportion(2, 10 - i, i)
|
|
|
|
def test_ljp_participant_count(self):
|
|
self._test_ljp_participant_count_proportion(2, 1, 1)
|
|
self._test_ljp_participant_count_proportion(2, 5, 1)
|
|
|
|
class FreizeitAdminTestCase(AdminTestCase):
|
|
def setUp(self):
|
|
super().setUp(model=Freizeit, admin=FreizeitAdmin)
|
|
ex = Freizeit.objects.create(name='Wild trip', kilometers_traveled=120,
|
|
tour_type=GEMEINSCHAFTS_TOUR,
|
|
tour_approach=MUSKELKRAFT_ANREISE,
|
|
difficulty=1)
|
|
|
|
for i in range(7):
|
|
m = Member.objects.create(prename='Lise {}'.format(i), lastname='Walter', birth_date=timezone.now().date(),
|
|
email=settings.TEST_MAIL, gender=FEMALE)
|
|
NewMemberOnList.objects.create(member=m, comments='a' * i, memberlist=ex)
|
|
|
|
def test_changelist(self):
|
|
c = self._login('superuser')
|
|
|
|
url = reverse('admin:members_freizeit_changelist')
|
|
response = c.get(url)
|
|
self.assertEqual(response.status_code, 200, 'Response code is not 200.')
|
|
|
|
def test_change(self):
|
|
c = self._login('superuser')
|
|
|
|
ex = Freizeit.objects.get(name='Wild trip')
|
|
url = reverse('admin:members_freizeit_change', args=(ex.pk,))
|
|
response = c.get(url)
|
|
self.assertEqual(response.status_code, 200, 'Response code is not 200.')
|
|
|
|
# if excursion does not exist, expect redirect
|
|
url = reverse('admin:members_freizeit_change', args=(71233,))
|
|
response = c.get(url)
|
|
self.assertEqual(response.status_code, 302, 'Response code is not 302.')
|
|
|
|
def test_add(self):
|
|
c = self._login('standard')
|
|
|
|
url = reverse('admin:members_freizeit_add')
|
|
response = c.get(url)
|
|
self.assertEqual(response.status_code, 200, 'Response code is not 200.')
|
|
|
|
@skip("The filtering is currently (intentionally) disabled.")
|
|
def test_add_queryset_filter(self):
|
|
"""Test if queryset on `jugendleiter` field is properly filtered by permissions."""
|
|
u = User.objects.get(username='standard')
|
|
c = self._login('standard')
|
|
|
|
url = reverse('admin:members_freizeit_add')
|
|
|
|
request = self.factory.get(url)
|
|
request.user = u
|
|
|
|
field = Freizeit._meta.get_field('jugendleiter')
|
|
queryset = self.admin.formfield_for_manytomany(field, request).queryset
|
|
self.assertQuerysetEqual(queryset, u.member.filter_queryset_by_permissions(model=Member),
|
|
msg='Field queryset does not match filtered queryset from models.',
|
|
ordered=False)
|
|
|
|
u.member.user = None
|
|
queryset = self.admin.formfield_for_manytomany(field, request).queryset
|
|
self.assertQuerysetEqual(queryset, Member.objects.none())
|
|
|
|
c = self._login('materialwarden')
|
|
response = c.get(url)
|
|
self.assertEqual(response.status_code, 200, 'Response code is not 200.')
|
|
|
|
u = User.objects.get(username='materialwarden')
|
|
|
|
request.user = u
|
|
field = Freizeit._meta.get_field('jugendleiter')
|
|
queryset = self.admin.formfield_for_manytomany(field, request).queryset
|
|
# material warden can list everyone
|
|
self.assertQuerysetEqual(queryset, Member.objects.all(),
|
|
msg='Field queryset does not match all members.',
|
|
ordered=False)
|
|
|
|
queryset = self.admin.formfield_for_manytomany(field, None).queryset
|
|
self.assertQuerysetEqual(queryset, Member.objects.none())
|
|
|
|
|
|
class MemberWaitingListAdminTestCase(AdminTestCase):
|
|
def setUp(self):
|
|
super().setUp(model=MemberWaitingList, admin=MemberWaitingListAdmin)
|
|
for i in range(10):
|
|
day = random.randint(1, 28)
|
|
month = random.randint(1, 12)
|
|
year = random.randint(1900, timezone.now().year - 1)
|
|
ex = MemberWaitingList.objects.create(prename='Peter {}'.format(i),
|
|
lastname='Puter',
|
|
birth_date=datetime.date(year, month, day),
|
|
email=settings.TEST_MAIL,
|
|
gender=FEMALE)
|
|
|
|
def test_age_eq_birth_date_delta(self):
|
|
u = User.objects.get(username='superuser')
|
|
url = reverse('admin:members_memberwaitinglist_changelist')
|
|
request = self.factory.get(url)
|
|
request.user = u
|
|
queryset = self.admin.get_queryset(request)
|
|
today = timezone.now().date()
|
|
|
|
for m in queryset:
|
|
self.assertEqual(m.birth_date_delta, m.age(),
|
|
msg='Queryset based age calculation differs from python based age calculation for birth date {birth_date} compared to {today}.'.format(birth_date=m.birth_date, today=today))
|
|
|
|
|
|
class MailConfirmationTestCase(BasicMemberTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.father = EmergencyContact.objects.create(prename='Olaf', lastname='Old',
|
|
email=settings.TEST_MAIL, member=self.fritz)
|
|
self.father.save()
|
|
|
|
def test_contact_confirmation(self):
|
|
# request mail confirmation of father
|
|
requested_confirmation = self.father.request_mail_confirmation()
|
|
self.assertTrue(requested_confirmation,
|
|
msg='Requesting mail confirmation should return true, if rerequest is false.')
|
|
# father's mail should not be confirmed
|
|
self.assertFalse(self.father.confirmed_mail,
|
|
msg='Mail should not be confirmed after requesting confirmation.')
|
|
|
|
key = self.father.confirm_mail_key
|
|
# key should not be empty
|
|
self.assertFalse(key == "", msg='Mail confirmation key should not be blank after requesting confirmation.')
|
|
|
|
# now confirm mail by using the generated key
|
|
res = self.father.confirm_mail(key)
|
|
|
|
# father's mail should now be confirmed
|
|
self.assertTrue(self.father.confirmed_mail, msg='After confirming by key, the mail should be confirmed.')
|
|
|
|
@skip("Currently, emergency contact email addresses are not required to be confirmed.")
|
|
def test_emergency_contact_confirmation(self):
|
|
# request mail confirmation of fritz, should also ask for confirmation of father
|
|
requested_confirmation = self.fritz.request_mail_confirmation()
|
|
self.assertTrue(requested_confirmation,
|
|
msg='Requesting mail confirmation should return true, if rerequest is false.')
|
|
|
|
for em in self.fritz.emergencycontact_set.all():
|
|
# emergency contact mail should not be confirmed
|
|
self.assertFalse(em.confirmed_mail,
|
|
msg='Mail should not be confirmed after requesting confirmation.')
|
|
key = em.confirm_mail_key
|
|
self.assertFalse(key == "",
|
|
msg='Mail confirmation key should not be blank after requesting confirmation.')
|
|
|
|
# now confirm mail by using the generated key
|
|
res = confirm_mail_by_key(key)
|
|
|
|
for em in self.fritz.emergencycontact_set.all():
|
|
self.assertTrue(em.confirmed_mail,
|
|
msg='Mail of every emergency contact should be confirmed after manually confirming.')
|
|
|
|
|
|
class RegisterWaitingListViewTestCase(BasicMemberTestCase):
|
|
def test_register_waiting_list_get(self):
|
|
url = reverse('members:register_waiting_list')
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
|
|
def test_register_waiting_list_post(self):
|
|
url = reverse('members:register_waiting_list')
|
|
response = self.client.post(url, data=dict(WAITER_DATA, save=''))
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _("Your registration for the waiting list was successful."))
|
|
|
|
def test_register_waiting_list_post_invalid(self):
|
|
url = reverse('members:register_waiting_list')
|
|
response = self.client.post(url, data={
|
|
'save': '',
|
|
})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _("This field is required."))
|
|
|
|
# this is required to bump the test coverage, but this is probably dead code
|
|
response = self.client.post(url, data={})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
|
|
|
|
class RegisterViewTestCase(BasicMemberTestCase):
|
|
REGISTRATION_PASSWORD = "foobar"
|
|
|
|
def setUp(self):
|
|
super().setUp()
|
|
RegistrationPassword.objects.create(group=self.alp,
|
|
password=RegisterViewTestCase.REGISTRATION_PASSWORD)
|
|
|
|
def test_register_password_get(self):
|
|
url = reverse('members:register')
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
|
|
def test_register_password_post(self):
|
|
url = reverse('members:register')
|
|
response = self.client.post(url, data={
|
|
'password': RegisterViewTestCase.REGISTRATION_PASSWORD,
|
|
})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
|
|
def test_register_password_post_save(self):
|
|
url = reverse('members:register')
|
|
response = self.client.post(url, data=dict(
|
|
REGISTRATION_DATA,
|
|
**EMERGENCY_CONTACT_DATA,
|
|
password=RegisterViewTestCase.REGISTRATION_PASSWORD,
|
|
save='',
|
|
))
|
|
self.assertEqual(response.status_code, HTTPStatus.FOUND)
|
|
reg = MemberUnconfirmedProxy.objects.get(prename='Peter', lastname='Wulter', town='Town 1')
|
|
self.assertEqual(reg.street, 'Street 123')
|
|
|
|
def test_register_password_post_incomplete(self):
|
|
url = reverse('members:register')
|
|
response = self.client.post(url, data={
|
|
'password': RegisterViewTestCase.REGISTRATION_PASSWORD,
|
|
'save': '',
|
|
})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
|
|
def test_register_password_post_missing_emergency_contact(self):
|
|
url = reverse('members:register')
|
|
response = self.client.post(url, data=dict(
|
|
REGISTRATION_DATA,
|
|
password=RegisterViewTestCase.REGISTRATION_PASSWORD,
|
|
save='',
|
|
))
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
|
|
def test_register_password_post_invalid(self):
|
|
url = reverse('members:register')
|
|
response = self.client.post(url, data={
|
|
'password': RegisterViewTestCase.REGISTRATION_PASSWORD + "_",
|
|
})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _("The entered password is wrong."))
|
|
|
|
|
|
class UploadRegistrationFormViewTestCase(BasicMemberTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.reg = MemberUnconfirmedProxy.objects.create(**REGISTRATION_DATA)
|
|
self.reg.create_from_registration(None, self.alp)
|
|
|
|
def test_upload_registration_form_get(self):
|
|
url = self.reg.get_upload_registration_form_link()
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('If you are not an adult yet, please let someone responsible for you sign the agreement.'))
|
|
|
|
def test_upload_registration_form_get_invalid(self):
|
|
url = reverse('members:upload_registration_form')
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('The supplied key for uploading a registration form is invalid.'))
|
|
|
|
url = reverse('members:upload_registration_form') + '?key=foobar'
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('The supplied key for uploading a registration form is invalid.'))
|
|
|
|
def test_upload_registration_form_post_no_key(self):
|
|
url = reverse('members:upload_registration_form')
|
|
# no key
|
|
response = self.client.post(url, data={})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('The supplied key for uploading a registration form is invalid.'))
|
|
# invalid key
|
|
response = self.client.post(url, data={'key': 'foobar'})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('The supplied key for uploading a registration form is invalid.'))
|
|
|
|
def test_upload_registration_form_post_incomplete(self):
|
|
url = reverse('members:upload_registration_form')
|
|
response = self.client.post(url, data={
|
|
'key': self.reg.upload_registration_form_key,
|
|
})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _("This field is required."))
|
|
|
|
def test_upload_registration_form_post(self):
|
|
url = reverse('members:upload_registration_form')
|
|
file = SimpleUploadedFile("form.pdf", b"file_content", content_type="application/pdf")
|
|
response = self.client.post(url, data={
|
|
'key': self.reg.upload_registration_form_key,
|
|
'registration_form': file,
|
|
})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response,
|
|
_("Thank you for uploading the registration form. Our team will process your registration shortly."))
|
|
|
|
class DownloadRegistrationFormViewTestCase(BasicMemberTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.reg = MemberUnconfirmedProxy.objects.create(**REGISTRATION_DATA)
|
|
self.reg.create_from_registration(None, self.alp)
|
|
|
|
def test_download_registration_form_get_invalid(self):
|
|
url = reverse('members:download_registration_form')
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
# this is how it is implemented, but it is questionable if this is the correct behaviour
|
|
self.assertContains(response, _('The supplied key for uploading a registration form is invalid.'))
|
|
|
|
response = self.client.get(url, data={'key': 'foobar'})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
# this is how it is implemented, but it is questionable if this is the correct behaviour
|
|
self.assertContains(response, _('The supplied key for uploading a registration form is invalid.'))
|
|
|
|
def test_download_registration_form_get(self):
|
|
url = reverse('members:download_registration_form')
|
|
response = self.client.get(url, data={'key': self.reg.upload_registration_form_key})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertEqual(response.headers['Content-Type'], 'application/pdf')
|
|
|
|
|
|
class RegistrationFromWaiterViewTestCase(BasicMemberTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.waiter = MemberWaitingList.objects.create(**WAITER_DATA)
|
|
self.waiter.invite_to_group(self.alp)
|
|
self.invitation = InvitationToGroup.objects.get(group=self.alp, waiter=self.waiter)
|
|
|
|
def test_register_post_waiter_key_invalid(self):
|
|
url = reverse('members:register')
|
|
response = self.client.post(url, data={
|
|
'waiter_key': 'foobar',
|
|
})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('Something went wrong while processing your registration.'))
|
|
|
|
def test_register_post(self):
|
|
url = reverse('members:register')
|
|
response = self.client.post(url, data=dict(
|
|
REGISTRATION_DATA,
|
|
**EMERGENCY_CONTACT_DATA,
|
|
waiter_key=self.invitation.key,
|
|
save='',
|
|
))
|
|
self.assertEqual(response.status_code, HTTPStatus.FOUND)
|
|
|
|
def test_register_post_invalid(self):
|
|
url = reverse('members:register')
|
|
response = self.client.post(url, data=dict(
|
|
REGISTRATION_DATA,
|
|
waiter_key=self.invitation.key,
|
|
save='',
|
|
))
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
|
|
@skip("This currently throws an 'AttributeError'.")
|
|
def test_register_post_no_save(self):
|
|
url = reverse('members:register')
|
|
response = self.client.post(url, data=dict(
|
|
waiter_key=self.invitation.key,
|
|
))
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
|
|
|
|
class InvitationToGroupViewTestCase(BasicMemberTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.waiter = MemberWaitingList.objects.create(**WAITER_DATA)
|
|
self.waiter.invite_to_group(self.alp)
|
|
self.invitation = InvitationToGroup.objects.get(group=self.alp, waiter=self.waiter)
|
|
|
|
def _assert_reject_invalid(self, response):
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('This invitation is invalid or expired.'))
|
|
|
|
def test_accept_get_no_key(self):
|
|
url = reverse('members:registration')
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
|
|
def test_accept_get_invalid(self):
|
|
url = reverse('members:registration')
|
|
response = self.client.get(url, data={'key': 'foobar'})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('invalid'))
|
|
|
|
url = reverse('members:registration')
|
|
self.invitation.rejected = True
|
|
self.invitation.save()
|
|
response = self.client.get(url, data={'key': self.invitation.key})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('expired'))
|
|
|
|
def test_accept_get(self):
|
|
url = reverse('members:registration')
|
|
response = self.client.get(url, data={'key': self.invitation.key})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
|
|
def test_reject_get(self):
|
|
url = reverse('members:reject_invitation')
|
|
response = self.client.get(url, data={'key': self.invitation.key})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
|
|
def test_reject_get_invalid(self):
|
|
url = reverse('members:reject_invitation')
|
|
response = self.client.get(url, data={'key': 'foobar'})
|
|
self._assert_reject_invalid(response)
|
|
|
|
self.invitation.rejected = True
|
|
self.invitation.save()
|
|
response = self.client.get(url, data={'key': self.invitation.key})
|
|
self._assert_reject_invalid(response)
|
|
|
|
def test_reject_post_invalid(self):
|
|
url = reverse('members:reject_invitation')
|
|
response = self.client.post(url)
|
|
self._assert_reject_invalid(response)
|
|
response = self.client.post(url, data={'key': 'foobar'})
|
|
self._assert_reject_invalid(response)
|
|
response = self.client.post(url, data={'key': self.invitation.key})
|
|
self._assert_reject_invalid(response)
|
|
|
|
def test_reject_post_reject(self):
|
|
url = reverse('members:reject_invitation')
|
|
response = self.client.post(url, data={
|
|
'key': self.invitation.key,
|
|
'reject_invitation': '',
|
|
})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
|
|
def test_reject_post_leave(self):
|
|
url = reverse('members:reject_invitation')
|
|
response = self.client.post(url, data={
|
|
'key': self.invitation.key,
|
|
'leave_waitinglist': '',
|
|
})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
|
|
|
|
class ConfirmWaitingViewTestCase(BasicMemberTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.waiter = MemberWaitingList.objects.create(**WAITER_DATA)
|
|
self.waiter.ask_for_wait_confirmation()
|
|
self.key = self.waiter.generate_wait_confirmation_key()
|
|
|
|
def test_get_no_key(self):
|
|
url = reverse('members:confirm_waiting')
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, HTTPStatus.FOUND)
|
|
|
|
url = reverse('members:confirm_waiting')
|
|
response = self.client.get(url, data={'key': 'foobar'})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('The supplied link is invalid.'))
|
|
|
|
def test_get(self):
|
|
url = reverse('members:confirm_waiting')
|
|
response = self.client.get(url, data={'key': self.key})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('Waiting confirmed'))
|
|
|
|
# modify the POST data, otherwise the request is cached
|
|
response = self.client.get(url, data={'key': self.key, 'foo': 'bar'})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('Waiting confirmed'))
|
|
|
|
@skip("This currently fails, because `last_wait_confirmation` has `auto_now=True`, which is wrong.")
|
|
def test_get_expired(self):
|
|
self.waiter.last_wait_confirmation = datetime.date(1900, 1, 1)
|
|
self.waiter.save()
|
|
# after setting the last wait confirmation to an old date, the waiting status
|
|
# should be unconfirmed
|
|
self.assertFalse(self.waiter.waiting_confirmed())
|
|
|
|
url = reverse('members:confirm_waiting')
|
|
self.waiter.wait_confirmation_key_expire = timezone.now() - timezone.timedelta(days=10)
|
|
self.waiter.save()
|
|
response = self.client.get(url, data={'key': self.key})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('rejoin the waiting list'))
|
|
|
|
|
|
class MailConfirmationViewTestCase(BasicMemberTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.waiter = MemberWaitingList.objects.create(**WAITER_DATA)
|
|
self.waiter.request_mail_confirmation()
|
|
|
|
def test_get_invalid(self):
|
|
url = reverse('members:confirm_mail')
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, HTTPStatus.FOUND)
|
|
|
|
url = reverse('members:confirm_mail')
|
|
response = self.client.get(url, data={'key': 'foobar'})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _("Mail confirmation failed"))
|
|
|
|
def test_get(self):
|
|
url = reverse('members:confirm_mail')
|
|
response = self.client.get(url, {'key': self.waiter.confirm_mail_key})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _("Mail confirmed"))
|
|
|
|
class EchoViewTestCase(BasicMemberTestCase):
|
|
def setUp(self):
|
|
super().setUp()
|
|
self.key = self.fritz.generate_echo_key()
|
|
|
|
def _assert_failed(self, response):
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('Echo failed'))
|
|
|
|
def test_get_invalid(self):
|
|
url = reverse('members:echo')
|
|
response = self.client.get(url)
|
|
self.assertEqual(response.status_code, HTTPStatus.FOUND)
|
|
|
|
url = reverse('members:echo')
|
|
response = self.client.get(url, data={'key': 'foobar'})
|
|
self._assert_failed(response)
|
|
|
|
def test_get(self):
|
|
url = reverse('members:echo')
|
|
response = self.client.get(url, data={'key': self.key})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('Thanks for echoing back. Please enter the password, which you can find in the email we sent you.\n'))
|
|
|
|
def test_post_invalid(self):
|
|
url = reverse('members:echo')
|
|
# no key
|
|
response = self.client.post(url)
|
|
self._assert_failed(response)
|
|
# wrong key
|
|
response = self.client.post(url, data={'key': 'foobar', 'password': self.fritz.echo_password})
|
|
self._assert_failed(response)
|
|
# wrong password
|
|
response = self.client.post(url, data={'key': self.key, 'password': 'foobar'})
|
|
self.assertContains(response, _('The entered password is wrong.'))
|
|
# expired key
|
|
self.fritz.echo_expire = timezone.now() - timezone.timedelta(days=settings.ECHO_GRACE_PERIOD)
|
|
self.fritz.save()
|
|
response = self.client.post(url, data={'key': self.key, 'password': self.fritz.echo_password})
|
|
self._assert_failed(response)
|
|
|
|
def test_post(self):
|
|
url = reverse('members:echo')
|
|
response = self.client.post(url, data={'key': self.key, 'password': self.fritz.echo_password})
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('Thanks for echoing back. Here is your current data:'))
|
|
|
|
def test_post_save(self):
|
|
url = reverse('members:echo')
|
|
# provide data, but no emergency contacts
|
|
response = self.client.post(url, data=dict(
|
|
REGISTRATION_DATA,
|
|
key=self.key,
|
|
password=self.fritz.echo_password,
|
|
save='',
|
|
))
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('Thanks for echoing back. Here is your current data:'))
|
|
|
|
# provide everything correctly
|
|
url = reverse('members:echo')
|
|
response = self.client.post(url, data=dict(
|
|
REGISTRATION_DATA,
|
|
**EMERGENCY_CONTACT_DATA,
|
|
key=self.key,
|
|
password=self.fritz.echo_password,
|
|
save='',
|
|
))
|
|
self.assertEqual(response.status_code, HTTPStatus.OK)
|
|
self.assertContains(response, _('Your data was successfully updated.'))
|