Coverage for website/registrations/tests/test_forms.py: 100.00%
288 statements
« prev ^ index » next coverage.py v7.6.7, created at 2025-08-14 10:31 +0000
1from django.conf import settings
2from django.test import TestCase, override_settings
3from django.utils import timezone
5from freezegun import freeze_time
7from members.models import Member, Membership
8from registrations import forms
9from registrations.models import Entry, Reference, Renewal
12class MemberRegistrationFormTest(TestCase):
13 def setUp(self):
14 self.data = {
15 "first_name": "John",
16 "last_name": "Doe",
17 "email": "johndoe@example.com",
18 "programme": "computingscience",
19 "student_number": "s1234567",
20 "starting_year": 2014,
21 "address_street": "Heyendaalseweg 135",
22 "address_street2": "",
23 "address_postal_code": "6525AJ",
24 "address_city": "Nijmegen",
25 "address_country": "NL",
26 "phone_number": "06 12345678",
27 "birthday": timezone.now().replace(year=1990, day=1),
28 "language": "en",
29 "length": Entry.MEMBERSHIP_YEAR,
30 "membership_type": Membership.MEMBER,
31 "privacy_policy": 1,
32 }
34 def test_privacy_policy_checked(self):
35 with self.subTest("Form is valid"):
36 form = forms.MemberRegistrationForm(self.data)
37 self.assertTrue(form.is_valid(), msg=dict(form.errors))
38 self.assertEqual(form.cleaned_data["phone_number"], "0612345678")
39 with self.subTest("Form is not valid"):
40 self.data["privacy_policy"] = 0
41 form = forms.MemberRegistrationForm(self.data)
42 self.assertFalse(form.is_valid(), msg=dict(form.errors))
44 def test_has_privacy_policy_field(self):
45 form = forms.MemberRegistrationForm(self.data)
46 self.assertTrue(form.fields["privacy_policy"] is not None)
48 def test_price_calculation(self):
49 with self.subTest(length=Entry.MEMBERSHIP_YEAR):
50 self.data["length"] = Entry.MEMBERSHIP_YEAR
51 form = forms.MemberRegistrationForm(self.data)
52 form.is_valid()
53 registration = form.save()
54 self.assertEqual(
55 registration.contribution,
56 settings.MEMBERSHIP_PRICES[Entry.MEMBERSHIP_YEAR],
57 )
58 registration.delete()
59 with self.subTest(length=Entry.MEMBERSHIP_STUDY):
60 self.data["length"] = Entry.MEMBERSHIP_STUDY
61 form = forms.MemberRegistrationForm(self.data)
62 form.is_valid()
63 registration = form.save()
64 self.assertEqual(
65 registration.contribution,
66 settings.MEMBERSHIP_PRICES[Entry.MEMBERSHIP_STUDY],
67 )
68 registration.delete()
71class BenefactorRegistrationFormTest(TestCase):
72 def setUp(self):
73 self.data = {
74 "first_name": "John",
75 "last_name": "Doe",
76 "email": "johndoe@example.com",
77 "programme": "computingscience",
78 "student_number": "s1234567",
79 "starting_year": 2014,
80 "address_street": "Heyendaalseweg 135",
81 "address_street2": "",
82 "address_postal_code": "6525AJ",
83 "address_city": "Nijmegen",
84 "address_country": "NL",
85 "phone_number": "06123456789",
86 "birthday": timezone.now().replace(year=1990, day=1),
87 "language": "en",
88 "length": Entry.MEMBERSHIP_YEAR,
89 "membership_type": Membership.BENEFACTOR,
90 "privacy_policy": 1,
91 "icis_employee": 1,
92 "contribution": 8,
93 }
95 def test_privacy_policy_checked(self):
96 with self.subTest("Form is valid"):
97 form = forms.BenefactorRegistrationForm(self.data)
98 self.assertTrue(form.is_valid(), msg=dict(form.errors))
99 with self.subTest("Form is not valid"):
100 self.data["privacy_policy"] = 0
101 form = forms.BenefactorRegistrationForm(self.data)
102 self.assertFalse(form.is_valid(), msg=dict(form.errors))
104 def test_has_privacy_policy_field(self):
105 form = forms.BenefactorRegistrationForm(self.data)
106 self.assertTrue(form.fields["privacy_policy"] is not None)
108 def test_price_calculation(self):
109 form = forms.BenefactorRegistrationForm(self.data)
110 form.is_valid()
111 registration = form.save()
112 self.assertEqual(registration.contribution, 8)
115@override_settings(SUSPEND_SIGNALS=True)
116class RenewalFormTest(TestCase):
117 fixtures = ["members.json"]
119 def setUp(self):
120 self.member = Member.objects.filter(last_name="Wiggers").first()
121 self.member.membership_set.all().delete()
122 self.data = {
123 "member": self.member.pk,
124 "length": Entry.MEMBERSHIP_STUDY,
125 "contribution": 8,
126 "membership_type": Membership.MEMBER,
127 "privacy_policy": 1,
128 }
130 def test_is_valid(self):
131 with self.subTest("Form is valid"):
132 form = forms.RenewalForm(self.data)
133 self.assertTrue(form.is_valid(), msg=dict(form.errors))
134 with self.subTest("Form is not valid"):
135 self.data["privacy_policy"] = 0
136 form = forms.RenewalForm(self.data)
137 self.assertFalse(form.is_valid(), msg=dict(form.errors))
138 with self.subTest("User is minimized"):
139 profile = self.member.profile
140 profile.student_number = None
141 profile.phone_number = None
142 profile.address_street = None
143 profile.address_street2 = None
144 profile.address_postal_code = None
145 profile.address_city = None
146 profile.address_country = None
147 profile.birthday = None
148 profile.emergency_contact_phone_number = None
149 profile.emergency_contact = None
150 profile.is_minimized = True
151 profile.save()
152 self.assertFalse(forms.RenewalForm(self.data).is_valid())
154 def test_has_privacy_policy_field(self):
155 form = forms.RenewalForm(self.data)
156 self.assertTrue(form.fields["privacy_policy"] is not None)
158 def test_price_calculation(self):
159 membership = Membership.objects.create(
160 user=self.member,
161 type=Membership.MEMBER,
162 since="2023-09-01",
163 until="2024-08-31",
164 )
166 with self.subTest("Member, membership upgrade discount"):
167 with freeze_time("2024-08-20"):
168 self.data["length"] = Entry.MEMBERSHIP_STUDY
169 self.data["membership_type"] = Membership.MEMBER
170 form = forms.RenewalForm(self.data)
171 self.assertTrue(form.is_valid())
172 renewal = form.save()
173 self.assertEqual(
174 renewal.contribution,
175 settings.MEMBERSHIP_PRICES[Entry.MEMBERSHIP_STUDY]
176 - settings.MEMBERSHIP_PRICES[Entry.MEMBERSHIP_YEAR],
177 )
178 renewal.delete()
180 with self.subTest("Member, membership upgrade discount (last year)"):
181 with freeze_time("2024-10-20"):
182 # The user had a membership last year, but still should get a discount.
183 self.data["length"] = Entry.MEMBERSHIP_STUDY
184 self.data["membership_type"] = Membership.MEMBER
185 form = forms.RenewalForm(self.data)
186 self.assertTrue(form.is_valid())
187 renewal = form.save()
188 self.assertEqual(
189 renewal.contribution,
190 settings.MEMBERSHIP_PRICES[Entry.MEMBERSHIP_STUDY]
191 - settings.MEMBERSHIP_PRICES[Entry.MEMBERSHIP_YEAR],
192 )
193 renewal.delete()
195 with self.subTest("Member, new year membership before expiry"):
196 with freeze_time("2024-08-20"):
197 self.data["length"] = Entry.MEMBERSHIP_YEAR
198 self.data["membership_type"] = Membership.MEMBER
199 form = forms.RenewalForm(self.data)
200 self.assertTrue(form.is_valid())
201 renewal = form.save()
202 self.assertEqual(
203 renewal.contribution,
204 settings.MEMBERSHIP_PRICES[Entry.MEMBERSHIP_YEAR],
205 )
206 renewal.delete()
208 with self.subTest("Member, new year membership after expiry"):
209 with freeze_time("2024-09-10"):
210 self.data["length"] = Entry.MEMBERSHIP_YEAR
211 self.data["membership_type"] = Membership.MEMBER
212 form = forms.RenewalForm(self.data)
213 self.assertTrue(form.is_valid())
214 renewal = form.save()
215 self.assertEqual(
216 renewal.contribution,
217 settings.MEMBERSHIP_PRICES[Entry.MEMBERSHIP_YEAR],
218 )
219 renewal.delete()
221 with self.subTest("Member, study membership after more than a year"):
222 with freeze_time("2025-09-10"):
223 # The membership discount applies up to 1 year after the user last had a membership.
224 self.data["length"] = Entry.MEMBERSHIP_STUDY
225 self.data["membership_type"] = Membership.MEMBER
226 form = forms.RenewalForm(self.data)
227 self.assertTrue(form.is_valid())
228 renewal = form.save()
229 self.assertEqual(
230 renewal.contribution,
231 settings.MEMBERSHIP_PRICES[Entry.MEMBERSHIP_STUDY],
232 )
233 renewal.delete()
235 with self.subTest("Member, new benefactor membership before expiry"):
236 with freeze_time("2024-08-20"):
237 self.data["length"] = Entry.MEMBERSHIP_YEAR
238 self.data["membership_type"] = Membership.BENEFACTOR
239 form = forms.RenewalForm(self.data)
240 self.assertTrue(form.is_valid())
241 renewal = form.save()
242 self.assertEqual(renewal.contribution, 8)
243 renewal.delete()
245 with self.subTest("Member, new benefactor membership before expiry"):
246 with freeze_time("2024-09-10"):
247 self.data["length"] = Entry.MEMBERSHIP_YEAR
248 self.data["membership_type"] = Membership.BENEFACTOR
249 form = forms.RenewalForm(self.data)
250 self.assertTrue(form.is_valid())
251 renewal = form.save()
252 self.assertEqual(renewal.contribution, 8)
253 renewal.delete()
255 membership.type = Membership.BENEFACTOR
256 membership.save()
258 with self.subTest("Benefactor, year benefactor membership before expiry"):
259 with freeze_time("2024-08-20"):
260 self.data["length"] = Entry.MEMBERSHIP_YEAR
261 self.data["membership_type"] = Membership.BENEFACTOR
262 form = forms.RenewalForm(self.data)
263 self.assertTrue(form.is_valid())
264 renewal = form.save()
265 self.assertEqual(renewal.contribution, 8)
266 renewal.delete()
268 with self.subTest("Benefactor, year benefactor membership after expiry"):
269 with freeze_time("2024-09-10"):
270 self.data["length"] = Entry.MEMBERSHIP_YEAR
271 self.data["membership_type"] = Membership.BENEFACTOR
272 form = forms.RenewalForm(self.data)
273 self.assertTrue(form.is_valid())
274 renewal = form.save()
275 self.assertEqual(renewal.contribution, 8)
276 renewal.delete()
278 with self.subTest("Benefactor, year member membership before expiry"):
279 with freeze_time("2024-08-20"):
280 self.data["length"] = Entry.MEMBERSHIP_YEAR
281 self.data["membership_type"] = Membership.MEMBER
282 form = forms.RenewalForm(self.data)
283 self.assertTrue(form.is_valid())
284 renewal = form.save()
285 self.assertEqual(
286 renewal.contribution,
287 settings.MEMBERSHIP_PRICES[Entry.MEMBERSHIP_YEAR],
288 )
289 renewal.delete()
291 with self.subTest("Benefactor, year member membership after expiry"):
292 with freeze_time("2024-09-10"):
293 self.data["length"] = Entry.MEMBERSHIP_YEAR
294 self.data["membership_type"] = Membership.MEMBER
295 form = forms.RenewalForm(self.data)
296 self.assertTrue(form.is_valid())
297 renewal = form.save()
298 self.assertEqual(
299 renewal.contribution,
300 settings.MEMBERSHIP_PRICES[Entry.MEMBERSHIP_YEAR],
301 )
302 renewal.delete()
304 with self.subTest("Benefactor, study membership before expiry"):
305 with freeze_time("2024-08-20"):
306 self.data["length"] = Entry.MEMBERSHIP_STUDY
307 self.data["membership_type"] = Membership.MEMBER
308 form = forms.RenewalForm(self.data)
309 self.assertTrue(form.is_valid())
310 renewal = form.save()
311 self.assertEqual(
312 renewal.contribution,
313 settings.MEMBERSHIP_PRICES[Entry.MEMBERSHIP_STUDY],
314 )
315 renewal.delete()
317 with self.subTest("Benefactor, study membership after expiry"):
318 with freeze_time("2024-09-10"):
319 self.data["length"] = Entry.MEMBERSHIP_STUDY
320 self.data["membership_type"] = Membership.MEMBER
321 form = forms.RenewalForm(self.data)
322 self.assertTrue(form.is_valid())
323 renewal = form.save()
324 self.assertEqual(
325 renewal.contribution,
326 settings.MEMBERSHIP_PRICES[Entry.MEMBERSHIP_STUDY],
327 )
328 renewal.delete()
330 def test_study_long_membership_cannot_be_renewed(self):
331 membership = Membership.objects.create(
332 user=self.member,
333 type=Membership.MEMBER,
334 since="2023-09-01",
335 until="2024-08-31",
336 study_long=True,
337 )
338 self.member.latest_membership = membership
339 self.member.save()
341 form = forms.RenewalForm(self.data)
342 self.assertFalse(form.is_valid())
343 self.assertEqual(
344 form.errors,
345 {"__all__": ["It's not possible to renew a study long membership."]},
346 )
349class NewYearFormTest(TestCase):
350 fixtures = ["members.json"]
352 def setUp(self):
353 self.member = Member.objects.filter(last_name="Wiggers").first()
354 self.data = {
355 "privacy_policy": 1,
356 "extension": 1,
357 }
359 def test_is_valid(self):
360 with self.subTest("Form is valid"):
361 form = forms.NewYearForm(self.data)
362 self.assertTrue(form.is_valid(), msg=dict(form.errors))
363 with self.subTest("Form is not valid"):
364 self.data["extension"] = 0
365 form = forms.NewYearForm(self.data)
366 self.assertFalse(form.is_valid(), msg=dict(form.errors))
367 with self.subTest("Form is not valid"):
368 self.data["privacy_policy"] = 0
369 form = forms.NewYearForm(self.data)
370 self.assertFalse(form.is_valid(), msg=dict(form.errors))
371 with self.subTest("User doesn't have study_long"):
372 self.member.latest_membership.study_long = False
373 self.assertFalse(forms.NewYearForm(self.data).is_valid())
374 with self.subTest("User is minimized"):
375 profile = self.member.profile
376 profile.student_number = None
377 profile.phone_number = None
378 profile.address_street = None
379 profile.address_street2 = None
380 profile.address_postal_code = None
381 profile.address_city = None
382 profile.address_country = None
383 profile.birthday = None
384 profile.emergency_contact_phone_number = None
385 profile.emergency_contact = None
386 profile.is_minimized = True
387 profile.save()
388 self.assertFalse(forms.NewYearForm(self.data).is_valid())
391@override_settings(SUSPEND_SIGNALS=True)
392class ReferenceFormTest(TestCase):
393 fixtures = ["members.json"]
395 def setUp(self):
396 self.member = Member.objects.filter(last_name="Wiggers").first()
397 self.member.membership_set.all().delete()
398 self.entry = Renewal.objects.create(
399 member=self.member, length=Entry.MEMBERSHIP_YEAR
400 )
401 self.data = {"member": self.member.pk, "entry": self.entry.pk}
403 @freeze_time("2018-08-01")
404 def test_clean(self):
405 with self.subTest("Form is valid"):
406 form = forms.ReferenceForm(self.data)
407 self.assertTrue(form.is_valid())
408 with self.subTest("Form throws error about benefactor type"):
409 m = Membership.objects.create(
410 type=Membership.BENEFACTOR,
411 user=self.member,
412 since="2017-09-01",
413 until="2018-08-31",
414 )
415 form = forms.ReferenceForm(self.data)
416 self.assertFalse(form.is_valid())
417 self.assertEqual(
418 form.errors, {"__all__": ["Benefactors cannot give references."]}
419 )
420 m.delete()
421 with self.subTest("Form throws error about membership end"):
422 m = Membership.objects.create(
423 type=Membership.MEMBER,
424 user=self.member,
425 since="2017-09-01",
426 until="2018-08-31",
427 )
428 form = forms.ReferenceForm(self.data)
429 self.assertFalse(form.is_valid())
430 self.assertEqual(
431 form.errors,
432 {
433 "__all__": [
434 "It's not possible to give references for "
435 "memberships that start after your own "
436 "membership's end."
437 ]
438 },
439 )
440 m.delete()
441 with self.subTest("Form is valid with membership for current year"):
442 with freeze_time("2018-09-01"):
443 m = Membership.objects.create(
444 type=Membership.MEMBER,
445 user=self.member,
446 since="2018-09-01",
447 until="2019-08-31",
448 )
449 form = forms.ReferenceForm(self.data)
450 self.assertTrue(form.is_valid())
451 m.delete()
452 with self.subTest("Form throws error about uniqueness"):
453 Reference.objects.create(member=self.member, entry=self.entry)
454 form = forms.ReferenceForm(self.data)
455 self.assertFalse(form.is_valid())
456 self.assertEqual(
457 form.errors,
458 {"__all__": ["You've already given a reference for this person."]},
459 )