Coverage for website/registrations/tests/test_admin.py: 98.63%

1from unittest import mock 

2 

3from django.contrib.admin import AdminSite 

4from django.contrib.auth.models import Permission 

5from django.http import HttpRequest 

6from django.test import TestCase, override_settings 

7from django.utils import timezone 

8 

9from members.models import Member 

10from members.models.membership import Membership 

11from payments.widgets import PaymentWidget 

12from registrations import admin, payables 

13from registrations.models import Entry, Reference, Registration, Renewal 

14 

15 

16def _get_mock_request(perms=None): 

17 if perms is None: 17 ↛ 18line 17 didn't jump to line 18 because the condition on line 17 was never true

18 perms = [] 

19 

20 mock_request = HttpRequest() 

21 mock_request.META = mock.Mock(return_value={}) 

22 mock_request.user = mock.MagicMock() 

23 mock_request.user.pk = 1 

24 mock_request.user.is_superuser = False 

25 mock_request.user.user_permissions = perms 

26 mock_request.user.has_perm = lambda x: x in perms 

27 mock_request._messages = mock.Mock() 

28 return mock_request 

29 

30 

31@override_settings(SUSPEND_SIGNALS=True) 

32class RegistrationAdminTest(TestCase): 

33 fixtures = ["members.json"] 

34 

35 def setUp(self): 

36 self.site = AdminSite() 

37 self.admin = admin.RegistrationAdmin(Registration, admin_site=self.site) 

38 payables.register() 

39 

40 def test_get_readonly_fields(self): 

41 request = _get_mock_request([]) 

42 

43 fields = self.admin.get_readonly_fields(request) 

44 self.assertEqual(fields, ["status", "created_at", "updated_at", "payment"]) 

45 

46 fields = self.admin.get_readonly_fields( 

47 request, Registration(status=Entry.STATUS_CONFIRM) 

48 ) 

49 self.assertEqual(fields, ["status", "created_at", "updated_at", "payment"]) 

50 

51 fields = self.admin.get_readonly_fields( 

52 request, Registration(status=Entry.STATUS_REJECTED) 

53 ) 

54 self.assertCountEqual( 

55 fields, 

56 [ 

57 "created_at", 

58 "updated_at", 

59 "status", 

60 "length", 

61 "membership_type", 

62 "remarks", 

63 "entry_ptr", 

64 "username", 

65 "first_name", 

66 "last_name", 

67 "birthday", 

68 "email", 

69 "phone_number", 

70 "student_number", 

71 "programme", 

72 "starting_year", 

73 "address_street", 

74 "address_street2", 

75 "address_postal_code", 

76 "address_city", 

77 "address_country", 

78 "membership", 

79 "optin_mailinglist", 

80 "optin_birthday", 

81 "contribution", 

82 "direct_debit", 

83 "initials", 

84 "iban", 

85 "bic", 

86 "signature", 

87 "optin_thabloid", 

88 ], 

89 ) 

90 

91 fields = self.admin.get_readonly_fields( 

92 request, Registration(status=Entry.STATUS_ACCEPTED) 

93 ) 

94 self.assertCountEqual( 

95 fields, 

96 [ 

97 "created_at", 

98 "updated_at", 

99 "status", 

100 "length", 

101 "membership_type", 

102 "remarks", 

103 "entry_ptr", 

104 "username", 

105 "first_name", 

106 "last_name", 

107 "birthday", 

108 "email", 

109 "phone_number", 

110 "student_number", 

111 "programme", 

112 "starting_year", 

113 "address_street", 

114 "address_street2", 

115 "address_postal_code", 

116 "address_city", 

117 "address_country", 

118 "membership", 

119 "optin_mailinglist", 

120 "optin_birthday", 

121 "contribution", 

122 "direct_debit", 

123 "initials", 

124 "iban", 

125 "bic", 

126 "signature", 

127 "optin_thabloid", 

128 ], 

129 ) 

130 

131 fields = self.admin.get_readonly_fields( 

132 request, Registration(status=Entry.STATUS_COMPLETED) 

133 ) 

134 self.assertCountEqual( 

135 fields, 

136 [ 

137 "created_at", 

138 "updated_at", 

139 "status", 

140 "length", 

141 "membership_type", 

142 "remarks", 

143 "entry_ptr", 

144 "username", 

145 "first_name", 

146 "last_name", 

147 "birthday", 

148 "email", 

149 "phone_number", 

150 "student_number", 

151 "programme", 

152 "starting_year", 

153 "address_street", 

154 "address_street2", 

155 "address_postal_code", 

156 "address_city", 

157 "address_country", 

158 "membership", 

159 "optin_mailinglist", 

160 "optin_birthday", 

161 "contribution", 

162 "direct_debit", 

163 "initials", 

164 "iban", 

165 "bic", 

166 "signature", 

167 "optin_thabloid", 

168 ], 

169 ) 

170 

171 def test_name(self): 

172 reg = Registration( 

173 first_name="John", 

174 last_name="Doe", 

175 ) 

176 self.assertEqual(self.admin.name(reg), reg.get_full_name()) 

177 

178 def test_reference_count(self): 

179 reg = Registration.objects.create( 

180 length=Entry.MEMBERSHIP_YEAR, 

181 first_name="John", 

182 last_name="Doe", 

183 birthday=timezone.now(), 

184 ) 

185 self.assertEqual(self.admin.reference_count(reg), 0) 

186 Reference.objects.create(entry=reg, member=Member.objects.get(pk=1)) 

187 Reference.objects.create(entry=reg, member=Member.objects.get(pk=2)) 

188 self.assertEqual(self.admin.reference_count(reg), 2) 

189 

190 def test_formfield_for_dbfield(self): 

191 with self.subTest("Payment field"): 

192 field = self.admin.formfield_for_dbfield( 

193 Registration._meta.get_field("payment"), request=None 

194 ) 

195 self.assertIsInstance(field.widget, PaymentWidget) 

196 with self.subTest("Other field"): 

197 field = self.admin.formfield_for_dbfield( 

198 Registration._meta.get_field("first_name"), request=None 

199 ) 

200 self.assertNotIsInstance(field.widget, PaymentWidget) 

201 self.assertIsNotNone(field.widget) 

202 

203 def test_save_model(self): 

204 reg = Registration( 

205 length=Entry.MEMBERSHIP_YEAR, 

206 status=Registration.STATUS_REVIEW, 

207 birthday=timezone.now(), 

208 ) 

209 

210 with self.subTest("Status review saves"): 

211 reg.first_name = "Test1" 

212 self.admin.save_model({}, reg, None, True) 

213 self.assertTrue(Registration.objects.filter(first_name="Test1").exists()) 

214 

215 with self.subTest("Status accepted, no save"): 

216 reg.first_name = "Test2" 

217 reg.status = Registration.STATUS_ACCEPTED 

218 self.admin.save_model({}, reg, None, True) 

219 self.assertFalse(Registration.objects.filter(first_name="Test2").exists()) 

220 

221 with self.subTest("Status reject, no save"): 

222 reg.first_name = "Test2" 

223 reg.status = Registration.STATUS_REJECTED 

224 self.admin.save_model({}, reg, None, True) 

225 self.assertFalse(Registration.objects.filter(first_name="Test2").exists()) 

226 

227 with self.subTest("Status completed, no save"): 

228 reg.first_name = "Test2" 

229 reg.status = Registration.STATUS_COMPLETED 

230 self.admin.save_model({}, reg, None, True) 

231 self.assertFalse(Registration.objects.filter(first_name="Test2").exists()) 

232 

233 def test_bulk_actions_permissions(self): 

234 admin = Member.objects.get(pk=1) 

235 self.client.force_login(Member.objects.get(pk=1)) 

236 Registration.objects.create( 

237 length=Entry.MEMBERSHIP_YEAR, 

238 status=Entry.STATUS_REVIEW, 

239 birthday=timezone.now(), 

240 ) 

241 

242 Renewal.objects.create( 

243 length=Entry.MEMBERSHIP_YEAR, 

244 status=Entry.STATUS_REVIEW, 

245 member=Member.objects.get(pk=2), 

246 ) 

247 

248 response = self.client.get("/admin/registrations/registration/") 

249 self.assertContains(response, "Accept selected registrations") 

250 self.assertContains(response, "Reject selected registrations") 

251 

252 admin.is_superuser = False 

253 admin.is_staff = True 

254 admin.save() 

255 

256 admin.user_permissions.add(Permission.objects.get(codename="view_registration")) 

257 

258 response = self.client.get("/admin/registrations/registration/") 

259 self.assertNotContains(response, "Accept selected registrations") 

260 self.assertNotContains(response, "Accept selected registrations") 

261 

262 admin.user_permissions.add(Permission.objects.get(codename="review_entries")) 

263 

264 response = self.client.get("/admin/registrations/registration/") 

265 self.assertContains(response, "Accept selected registrations") 

266 self.assertContains(response, "Reject selected registrations") 

267 

268 def test_can_open_registration_change_view(self): 

269 # Just a sanity check and to get coverage. 

270 self.client.force_login(Member.objects.get(pk=1)) 

271 

272 registration = Registration.objects.create( 

273 first_name="John", 

274 last_name="Doe", 

275 email="johndoe@example.com", 

276 programme="computingscience", 

277 student_number="s1234567", 

278 starting_year=2014, 

279 address_street="Heyendaalseweg 135", 

280 address_street2="", 

281 address_postal_code="6525AJ", 

282 address_city="Nijmegen", 

283 address_country="NL", 

284 phone_number="06123456789", 

285 birthday=timezone.now().replace(year=1990, day=1).date(), 

286 length=Entry.MEMBERSHIP_YEAR, 

287 contribution=7.5, 

288 membership_type=Membership.MEMBER, 

289 status=Entry.STATUS_CONFIRM, 

290 ) 

291 response = self.client.get( 

292 f"/admin/registrations/registration/{registration.pk}/change/" 

293 ) 

294 self.assertEqual(response.status_code, 200) 

295 

296 

297class RenewalAdminTest(TestCase): 

298 fixtures = ["members.json"] 

299 

300 def setUp(self): 

301 self.site = AdminSite() 

302 self.admin = admin.RenewalAdmin(Renewal, admin_site=self.site) 

303 

304 def test_get_readonly_fields(self): 

305 request = _get_mock_request([]) 

306 

307 fields = self.admin.get_readonly_fields(request) 

308 self.assertEqual(fields, ["status", "created_at", "updated_at", "payment"]) 

309 

310 fields = self.admin.get_readonly_fields( 

311 request, Renewal(status=Entry.STATUS_CONFIRM) 

312 ) 

313 self.assertEqual( 

314 fields, ["status", "created_at", "updated_at", "payment", "member"] 

315 ) 

316 

317 fields = self.admin.get_readonly_fields( 

318 request, Renewal(status=Entry.STATUS_REJECTED) 

319 ) 

320 self.assertCountEqual( 

321 fields, 

322 [ 

323 "created_at", 

324 "updated_at", 

325 "status", 

326 "length", 

327 "membership_type", 

328 "remarks", 

329 "entry_ptr", 

330 "member", 

331 "membership", 

332 "contribution", 

333 ], 

334 ) 

335 

336 fields = self.admin.get_readonly_fields( 

337 request, Renewal(status=Entry.STATUS_ACCEPTED) 

338 ) 

339 self.assertCountEqual( 

340 fields, 

341 [ 

342 "created_at", 

343 "updated_at", 

344 "status", 

345 "length", 

346 "membership_type", 

347 "remarks", 

348 "entry_ptr", 

349 "member", 

350 "membership", 

351 "contribution", 

352 ], 

353 ) 

354 

355 def test_name(self): 

356 renewal = Renewal( 

357 member=Member( 

358 first_name="John", 

359 last_name="Doe", 

360 ) 

361 ) 

362 self.assertEqual(self.admin.name(renewal), renewal.member.get_full_name()) 

363 

364 def test_email(self): 

365 renewal = Renewal(member=Member(email="test@example.org")) 

366 self.assertEqual(self.admin.email(renewal), "test@example.org") 

367 

368 def test_bulk_actions_permissions(self): 

369 admin = Member.objects.get(pk=1) 

370 self.client.force_login(Member.objects.get(pk=1)) 

371 

372 Registration.objects.create( 

373 length=Entry.MEMBERSHIP_YEAR, 

374 status=Entry.STATUS_REVIEW, 

375 birthday=timezone.now(), 

376 ) 

377 

378 Renewal.objects.create( 

379 length=Entry.MEMBERSHIP_YEAR, 

380 status=Entry.STATUS_REVIEW, 

381 member=Member.objects.get(pk=2), 

382 ) 

383 

384 response = self.client.get("/admin/registrations/renewal/") 

385 self.assertContains(response, "Accept selected renewals") 

386 self.assertContains(response, "Reject selected renewals") 

387 

388 admin.is_superuser = False 

389 admin.is_staff = True 

390 admin.save() 

391 

392 admin.user_permissions.add(Permission.objects.get(codename="view_renewal")) 

393 

394 response = self.client.get("/admin/registrations/renewal/") 

395 self.assertNotContains(response, "Accept selected renewals") 

396 self.assertNotContains(response, "Accept selected renewals") 

397 

398 admin.user_permissions.add(Permission.objects.get(codename="review_entries")) 

399 

400 response = self.client.get("/admin/registrations/renewal/") 

401 self.assertContains(response, "Accept selected renewals") 

402 self.assertContains(response, "Reject selected renewals")