Coverage for website/registrations/tests/test_forms.py: 100.00%

1from django.conf import settings 

2from django.test import TestCase, override_settings 

3from django.utils import timezone 

4 

5from freezegun import freeze_time 

6 

7from members.models import Member, Membership 

8from registrations import forms 

9from registrations.models import Entry, Reference, Renewal 

10 

11 

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 } 

33 

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)) 

43 

44 def test_has_privacy_policy_field(self): 

45 form = forms.MemberRegistrationForm(self.data) 

46 self.assertTrue(form.fields["privacy_policy"] is not None) 

47 

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() 

69 

70 

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 } 

94 

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)) 

103 

104 def test_has_privacy_policy_field(self): 

105 form = forms.BenefactorRegistrationForm(self.data) 

106 self.assertTrue(form.fields["privacy_policy"] is not None) 

107 

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) 

113 

114 

115@override_settings(SUSPEND_SIGNALS=True) 

116class RenewalFormTest(TestCase): 

117 fixtures = ["members.json"] 

118 

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 } 

129 

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()) 

153 

154 def test_has_privacy_policy_field(self): 

155 form = forms.RenewalForm(self.data) 

156 self.assertTrue(form.fields["privacy_policy"] is not None) 

157 

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 ) 

165 

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() 

179 

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() 

194 

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() 

207 

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() 

220 

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() 

234 

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() 

244 

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() 

254 

255 membership.type = Membership.BENEFACTOR 

256 membership.save() 

257 

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() 

267 

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() 

277 

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() 

290 

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() 

303 

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() 

316 

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() 

329 with self.subTest("Length parameter missing from data"): 

330 self.data.pop("length") 

331 form = forms.RenewalForm(self.data) 

332 form.cleaned_data = self.data 

333 form.clean() 

334 self.assertEqual(self.data, form.data) 

335 

336 def test_study_long_membership_cannot_be_renewed(self): 

337 membership = Membership.objects.create( 

338 user=self.member, 

339 type=Membership.MEMBER, 

340 since="2023-09-01", 

341 until="2024-08-31", 

342 study_long=True, 

343 ) 

344 self.member.latest_membership = membership 

345 self.member.save() 

346 

347 form = forms.RenewalForm(self.data) 

348 self.assertFalse(form.is_valid()) 

349 self.assertEqual( 

350 form.errors, 

351 {"__all__": ["It's not possible to renew a study long membership."]}, 

352 ) 

353 

354 

355class NewYearFormTest(TestCase): 

356 fixtures = ["members.json"] 

357 

358 def setUp(self): 

359 self.member = Member.objects.filter(last_name="Wiggers").first() 

360 self.data = { 

361 "privacy_policy": 1, 

362 "extension": 1, 

363 } 

364 

365 def test_is_valid(self): 

366 with self.subTest("Form is valid"): 

367 form = forms.NewYearForm(self.data) 

368 self.assertTrue(form.is_valid(), msg=dict(form.errors)) 

369 with self.subTest("Form is not valid"): 

370 self.data["extension"] = 0 

371 form = forms.NewYearForm(self.data) 

372 self.assertFalse(form.is_valid(), msg=dict(form.errors)) 

373 with self.subTest("Form is not valid"): 

374 self.data["privacy_policy"] = 0 

375 form = forms.NewYearForm(self.data) 

376 self.assertFalse(form.is_valid(), msg=dict(form.errors)) 

377 with self.subTest("User doesn't have study_long"): 

378 self.member.latest_membership.study_long = False 

379 self.assertFalse(forms.NewYearForm(self.data).is_valid()) 

380 with self.subTest("User is minimized"): 

381 profile = self.member.profile 

382 profile.student_number = None 

383 profile.phone_number = None 

384 profile.address_street = None 

385 profile.address_street2 = None 

386 profile.address_postal_code = None 

387 profile.address_city = None 

388 profile.address_country = None 

389 profile.birthday = None 

390 profile.emergency_contact_phone_number = None 

391 profile.emergency_contact = None 

392 profile.is_minimized = True 

393 profile.save() 

394 self.assertFalse(forms.NewYearForm(self.data).is_valid()) 

395 

396 

397@override_settings(SUSPEND_SIGNALS=True) 

398class ReferenceFormTest(TestCase): 

399 fixtures = ["members.json"] 

400 

401 def setUp(self): 

402 self.member = Member.objects.filter(last_name="Wiggers").first() 

403 self.member.membership_set.all().delete() 

404 self.entry = Renewal.objects.create( 

405 member=self.member, length=Entry.MEMBERSHIP_YEAR 

406 ) 

407 self.data = {"member": self.member.pk, "entry": self.entry.pk} 

408 

409 @freeze_time("2018-08-01") 

410 def test_clean(self): 

411 with self.subTest("Form is valid"): 

412 form = forms.ReferenceForm(self.data) 

413 self.assertTrue(form.is_valid()) 

414 with self.subTest("Form throws error about benefactor type"): 

415 m = Membership.objects.create( 

416 type=Membership.BENEFACTOR, 

417 user=self.member, 

418 since="2017-09-01", 

419 until="2018-08-31", 

420 ) 

421 form = forms.ReferenceForm(self.data) 

422 self.assertFalse(form.is_valid()) 

423 self.assertEqual( 

424 form.errors, {"__all__": ["Benefactors cannot give references."]} 

425 ) 

426 m.delete() 

427 with self.subTest("Form throws error about membership end"): 

428 m = Membership.objects.create( 

429 type=Membership.MEMBER, 

430 user=self.member, 

431 since="2017-09-01", 

432 until="2018-08-31", 

433 ) 

434 form = forms.ReferenceForm(self.data) 

435 self.assertFalse(form.is_valid()) 

436 self.assertEqual( 

437 form.errors, 

438 { 

439 "__all__": [ 

440 "It's not possible to give references for " 

441 "memberships that start after your own " 

442 "membership's end." 

443 ] 

444 }, 

445 ) 

446 m.delete() 

447 with self.subTest("Form is valid with membership for current year"): 

448 with freeze_time("2018-09-01"): 

449 m = Membership.objects.create( 

450 type=Membership.MEMBER, 

451 user=self.member, 

452 since="2018-09-01", 

453 until="2019-08-31", 

454 ) 

455 form = forms.ReferenceForm(self.data) 

456 self.assertTrue(form.is_valid()) 

457 m.delete() 

458 with self.subTest("Form throws error about uniqueness"): 

459 Reference.objects.create(member=self.member, entry=self.entry) 

460 form = forms.ReferenceForm(self.data) 

461 self.assertFalse(form.is_valid()) 

462 self.assertEqual( 

463 form.errors, 

464 {"__all__": ["You've already given a reference for this person."]}, 

465 ) 

466 

467 @freeze_time("2018-08-15") 

468 def test_memberregistration_clean_and_reference_august_edge(self): 

469 """ 

470 Covers: 

471 - MemberRegistrationForm.clean early return when 'length' missing 

472 - ReferenceForm branch where today.month == 8 increments lecture_year 

473 and the membership.until <= date(lecture_year, 9, 1) validation triggers. 

474 """ 

475 form = forms.MemberRegistrationForm({}) 

476 form.cleaned_data = {} 

477 cleaned = form.clean() 

478 self.assertEqual(cleaned, {}) 

479 

480 from datetime import date 

481 

482 from utils.snippets import datetime_to_lectureyear 

483 

484 today = timezone.now().date() 

485 lecture_year = datetime_to_lectureyear(today) 

486 m = Membership.objects.create( 

487 type=Membership.MEMBER, 

488 user=self.member, 

489 since="2017-09-01", 

490 until=date(lecture_year, 9, 1), 

491 ) 

492 try: 

493 form = forms.ReferenceForm(self.data) 

494 self.assertFalse(form.is_valid()) 

495 self.assertEqual( 

496 form.errors, 

497 { 

498 "__all__": [ 

499 "It's not possible to give references for memberships " 

500 "that start after your own membership's end." 

501 ] 

502 }, 

503 ) 

504 finally: 

505 m.delete()