Coverage for website/events/tests/test_services.py: 100.00%

1from datetime import datetime, timedelta 

2from unittest import mock 

3 

4from django.contrib.auth.models import AnonymousUser, Permission 

5from django.http import HttpRequest 

6from django.test import TestCase, override_settings 

7from django.utils import timezone 

8 

9from freezegun import freeze_time 

10 

11from activemembers.models import Committee, MemberGroupMembership 

12from events import services 

13from events.exceptions import RegistrationError 

14from events.models import Event, EventRegistration, RegistrationInformationField 

15from members.models import Member 

16 

17 

18@freeze_time("2017-01-01") 

19@override_settings(SUSPEND_SIGNALS=True) 

20class ServicesTest(TestCase): 

21 fixtures = ["members.json", "member_groups.json"] 

22 

23 @classmethod 

24 def setUpTestData(cls): 

25 cls.committee = Committee.objects.get(pk=1) 

26 cls.event = Event.objects.create( 

27 pk=1, 

28 title="testevent", 

29 description="desc", 

30 published=True, 

31 start=(timezone.now() + timedelta(hours=1)), 

32 end=(timezone.now() + timedelta(hours=2)), 

33 location="test location", 

34 map_location="test map location", 

35 price=0.00, 

36 fine=0.00, 

37 ) 

38 cls.event.organisers.add(cls.committee) 

39 cls.member = Member.objects.filter(last_name="Wiggers").first() 

40 cls.member.is_superuser = False 

41 cls.member.save() 

42 

43 cls.perm_change_event = Permission.objects.get( 

44 content_type__model="event", codename="change_event" 

45 ) 

46 cls.perm_override_organiser = Permission.objects.get( 

47 content_type__model="event", codename="override_organiser" 

48 ) 

49 

50 def setUp(self): 

51 self.committee.refresh_from_db() 

52 self.event.refresh_from_db() 

53 self.member.refresh_from_db() 

54 

55 def _toggle_event_change_perm(self, enable): 

56 # Refetch member to empty permissions cache 

57 self.member = Member.objects.get(pk=self.member.pk) 

58 if enable: 

59 self.member.user_permissions.add(self.perm_change_event) 

60 else: 

61 self.member.user_permissions.remove(self.perm_change_event) 

62 

63 def _toggle_override_organiser_perm(self, enable): 

64 # Refetch member to empty permissions cache 

65 self.member = Member.objects.get(pk=self.member.pk) 

66 if enable: 

67 self.member.user_permissions.add(self.perm_override_organiser) 

68 else: 

69 self.member.user_permissions.remove(self.perm_override_organiser) 

70 

71 def test_is_user_registered(self): 

72 self.assertEqual(None, services.is_user_registered(AnonymousUser(), self.event)) 

73 self.event.registration_start = timezone.now() - timedelta(hours=1) 

74 self.event.registration_end = timezone.now() 

75 self.assertEqual(None, services.is_user_registered(AnonymousUser(), self.event)) 

76 self.assertFalse(services.is_user_registered(self.member, self.event)) 

77 EventRegistration.objects.create( 

78 event=self.event, member=self.member, date_cancelled=None 

79 ) 

80 

81 self.assertTrue(services.is_user_registered(self.member, self.event)) 

82 

83 def test_event_permissions(self): 

84 self.event.registration_start = timezone.now() - timedelta(hours=1) 

85 self.event.registration_end = timezone.now() + timedelta(hours=1) 

86 

87 self.assertEqual( 

88 { 

89 "create_registration": False, 

90 "create_registration_when_open": False, 

91 "cancel_registration": False, 

92 "update_registration": False, 

93 "manage_event": False, 

94 }, 

95 services.event_permissions(AnonymousUser(), self.event), 

96 ) 

97 

98 self.member.profile.event_permissions = "nothing" 

99 

100 self.assertEqual( 

101 { 

102 "create_registration": False, 

103 "create_registration_when_open": False, 

104 "cancel_registration": False, 

105 "update_registration": False, 

106 "manage_event": False, 

107 }, 

108 services.event_permissions(self.member, self.event), 

109 ) 

110 

111 self.member.profile.event_permissions = "all" 

112 

113 self.assertEqual( 

114 { 

115 "create_registration": True, 

116 "create_registration_when_open": False, 

117 "cancel_registration": False, 

118 "update_registration": False, 

119 "manage_event": False, 

120 }, 

121 services.event_permissions(self.member, self.event), 

122 ) 

123 

124 reg = EventRegistration.objects.create( 

125 event=self.event, member=self.member, date_cancelled=None 

126 ) 

127 

128 self.assertEqual( 

129 { 

130 "create_registration": False, 

131 "create_registration_when_open": False, 

132 "cancel_registration": True, 

133 "update_registration": False, 

134 "manage_event": False, 

135 }, 

136 services.event_permissions(self.member, self.event), 

137 ) 

138 

139 RegistrationInformationField.objects.create( 

140 event=self.event, 

141 type=RegistrationInformationField.BOOLEAN_FIELD, 

142 name="test", 

143 required=False, 

144 ) 

145 

146 self.assertEqual( 

147 { 

148 "create_registration": False, 

149 "create_registration_when_open": False, 

150 "cancel_registration": True, 

151 "update_registration": True, 

152 "manage_event": False, 

153 }, 

154 services.event_permissions(self.member, self.event), 

155 ) 

156 

157 reg.date_cancelled = timezone.now() 

158 reg.save() 

159 

160 self.assertEqual( 

161 { 

162 "create_registration": True, 

163 "create_registration_when_open": False, 

164 "cancel_registration": False, 

165 "update_registration": False, 

166 "manage_event": False, 

167 }, 

168 services.event_permissions(self.member, self.event), 

169 ) 

170 

171 def test_is_organiser(self): 

172 self.assertFalse(services.is_organiser(AnonymousUser(), self.event)) 

173 

174 self.assertFalse(services.is_organiser(self.member, self.event)) 

175 self.member.is_superuser = True 

176 self.assertTrue(services.is_organiser(self.member, self.event)) 

177 self.member.is_superuser = False 

178 

179 self._toggle_override_organiser_perm(True) 

180 self.assertTrue(services.is_organiser(self.member, self.event)) 

181 self._toggle_override_organiser_perm(False) 

182 

183 self._toggle_event_change_perm(True) 

184 self.assertFalse(services.is_organiser(self.member, self.event)) 

185 membership = MemberGroupMembership.objects.create( 

186 member=self.member, group=self.committee 

187 ) 

188 self.assertTrue(services.is_organiser(self.member, self.event)) 

189 self.assertFalse(services.is_organiser(self.member, None)) 

190 self._toggle_event_change_perm(False) 

191 membership.delete() 

192 

193 @mock.patch("events.services.event_permissions") 

194 def test_create_registration(self, perms_mock): 

195 self.event.registration_start = timezone.now() - timedelta(hours=2) 

196 self.event.registration_end = timezone.now() + timedelta(hours=1) 

197 

198 perms_mock.return_value = { 

199 "create_registration": False, 

200 "cancel_registration": False, 

201 "update_registration": False, 

202 } 

203 

204 with self.assertRaises(RegistrationError): 

205 services.create_registration(AnonymousUser(), self.event) 

206 

207 perms_mock.return_value["create_registration"] = True 

208 

209 reg = services.create_registration(self.member, self.event) 

210 self.assertEqual(reg.event, self.event) 

211 self.assertEqual(reg.member, self.member) 

212 self.assertEqual(reg.date_cancelled, None) 

213 

214 reg.date_cancelled = timezone.make_aware(datetime(2017, 9, 1)) 

215 reg.save() 

216 

217 reg = services.create_registration(self.member, self.event) 

218 self.assertEqual(reg.event, self.event) 

219 self.assertEqual(reg.member, self.member) 

220 self.assertEqual(reg.date_cancelled, None) 

221 

222 self.event.cancel_deadline = timezone.now() - timedelta(hours=1) 

223 self.event.save() 

224 

225 reg.date_cancelled = timezone.now() 

226 reg.save() 

227 

228 with self.assertRaises(RegistrationError): 

229 services.create_registration(self.member, self.event) 

230 

231 reg.date_cancelled = None 

232 reg.save() 

233 

234 services.create_registration(self.member, self.event) 

235 

236 perms_mock.return_value["create_registration"] = False 

237 perms_mock.return_value["cancel_registration"] = True 

238 

239 with self.assertRaises(RegistrationError): 

240 services.create_registration(self.member, self.event) 

241 

242 @mock.patch("events.emails.notify_organiser") 

243 @mock.patch("events.emails.notify_first_waiting") 

244 @mock.patch("events.services.event_permissions") 

245 def test_cancel_registration( 

246 self, perms_mock, notify_first_mock, notify_organiser_mock 

247 ): 

248 self.event.registration_start = timezone.now() - timedelta(hours=2) 

249 self.event.registration_end = timezone.now() + timedelta(hours=1) 

250 self.event.max_participants = 1 

251 self.event.save() 

252 

253 perms_mock.return_value = { 

254 "create_registration": False, 

255 "cancel_registration": False, 

256 "update_registration": False, 

257 } 

258 

259 with self.assertRaises(RegistrationError): 

260 services.cancel_registration(self.member, self.event) 

261 

262 registration = EventRegistration.objects.create( 

263 event=self.event, 

264 member=self.member, 

265 ) 

266 

267 with self.assertRaises(RegistrationError): 

268 services.cancel_registration(self.member, self.event) 

269 

270 perms_mock.return_value["cancel_registration"] = True 

271 

272 services.cancel_registration(self.member, self.event) 

273 notify_first_mock.assert_not_called() 

274 

275 registration.date_cancelled = None 

276 registration.save() 

277 registration2 = EventRegistration.objects.create( 

278 event=self.event, member=Member.objects.filter(username="testuser2").first() 

279 ) 

280 services.cancel_registration(self.member, self.event) 

281 notify_first_mock.assert_called_once_with(self.event, registration2) 

282 

283 self.event.send_cancel_email = True 

284 self.event.save() 

285 

286 services.cancel_registration(self.member, self.event) 

287 

288 self.event.cancel_deadline = timezone.make_aware(datetime(2017, 1, 1)) 

289 self.event.save() 

290 

291 services.cancel_registration(self.member, self.event) 

292 notify_organiser_mock.assert_called_once_with(self.event, registration) 

293 

294 registration.refresh_from_db() 

295 self.assertIsNotNone(registration.date_cancelled) 

296 registration.date_cancelled = None 

297 registration.save() 

298 

299 EventRegistration.objects.create( 

300 event=self.event, 

301 member=Member.objects.filter(username="testuser").first(), 

302 date=timezone.make_aware(datetime(2017, 9, 1)), 

303 ) 

304 

305 services.cancel_registration(self.member, self.event) 

306 

307 @mock.patch("events.services.event_permissions") 

308 def test_update_registration_user(self, perms_mock): 

309 self.event.registration_start = timezone.now() - timedelta(hours=2) 

310 self.event.registration_end = timezone.now() + timedelta(hours=1) 

311 

312 perms_mock.return_value = { 

313 "create_registration": False, 

314 "cancel_registration": False, 

315 "update_registration": False, 

316 } 

317 

318 with self.assertRaises(RegistrationError): 

319 services.update_registration(self.member, self.event, field_values=None) 

320 

321 registration = EventRegistration.objects.create( 

322 event=self.event, 

323 member=self.member, 

324 ) 

325 

326 services.update_registration(self.member, self.event, field_values=None) 

327 

328 perms_mock.return_value["update_registration"] = True 

329 

330 field1 = RegistrationInformationField.objects.create( 

331 type=RegistrationInformationField.INTEGER_FIELD, 

332 event=self.event, 

333 required=False, 

334 ) 

335 

336 field2 = RegistrationInformationField.objects.create( 

337 type=RegistrationInformationField.BOOLEAN_FIELD, 

338 event=self.event, 

339 required=False, 

340 ) 

341 

342 field3 = RegistrationInformationField.objects.create( 

343 type=RegistrationInformationField.TEXT_FIELD, 

344 event=self.event, 

345 required=False, 

346 ) 

347 

348 fields = [ 

349 (f"info_field_{field1.id}", None), 

350 (f"info_field_{field2.id}", None), 

351 (f"info_field_{field3.id}", None), 

352 ] 

353 

354 services.update_registration(self.member, self.event, field_values=fields) 

355 

356 self.assertEqual(field1.get_value_for(registration), 0) 

357 self.assertEqual(field2.get_value_for(registration), False) 

358 self.assertEqual(field3.get_value_for(registration), "") 

359 

360 fields = [ 

361 (f"info_field_{field1.id}", 2), 

362 (f"info_field_{field2.id}", True), 

363 (f"info_field_{field3.id}", "text"), 

364 ] 

365 

366 services.update_registration(self.member, self.event, field_values=fields) 

367 

368 self.assertEqual(field1.get_value_for(registration), 2) 

369 self.assertEqual(field2.get_value_for(registration), True) 

370 self.assertEqual(field3.get_value_for(registration), "text") 

371 

372 field1.delete() 

373 field2.delete() 

374 field3.delete() 

375 

376 @mock.patch("events.services.event_permissions") 

377 def test_update_registration_guest(self, perms_mock): 

378 self.event.registration_start = timezone.now() - timedelta(hours=2) 

379 self.event.registration_end = timezone.now() + timedelta(hours=1) 

380 

381 perms_mock.return_value = { 

382 "create_registration": False, 

383 "cancel_registration": False, 

384 "update_registration": False, 

385 } 

386 

387 with self.assertRaises(RegistrationError): 

388 services.update_registration(self.member, self.event, field_values=None) 

389 

390 registration = EventRegistration.objects.create( 

391 event=self.event, 

392 name="test", 

393 ) 

394 

395 services.update_registration(event=self.event, name="test", field_values=None) 

396 

397 perms_mock.return_value["update_registration"] = True 

398 

399 field1 = RegistrationInformationField.objects.create( 

400 type=RegistrationInformationField.INTEGER_FIELD, 

401 event=self.event, 

402 required=False, 

403 ) 

404 

405 field2 = RegistrationInformationField.objects.create( 

406 type=RegistrationInformationField.BOOLEAN_FIELD, 

407 event=self.event, 

408 required=False, 

409 ) 

410 

411 field3 = RegistrationInformationField.objects.create( 

412 type=RegistrationInformationField.TEXT_FIELD, 

413 event=self.event, 

414 required=False, 

415 ) 

416 

417 fields = [ 

418 (f"info_field_{field1.id}", None), 

419 (f"info_field_{field2.id}", None), 

420 (f"info_field_{field3.id}", None), 

421 ] 

422 

423 services.update_registration(name="test", event=self.event, field_values=fields) 

424 

425 self.assertEqual(field1.get_value_for(registration), 0) 

426 self.assertEqual(field2.get_value_for(registration), False) 

427 self.assertEqual(field3.get_value_for(registration), "") 

428 

429 fields = [ 

430 (f"info_field_{field1.id}", 2), 

431 (f"info_field_{field2.id}", True), 

432 (f"info_field_{field3.id}", "text"), 

433 ] 

434 

435 services.update_registration(name="test", event=self.event, field_values=fields) 

436 

437 self.assertEqual(field1.get_value_for(registration), 2) 

438 self.assertEqual(field2.get_value_for(registration), True) 

439 self.assertEqual(field3.get_value_for(registration), "text") 

440 

441 field1.delete() 

442 field2.delete() 

443 field3.delete() 

444 

445 @mock.patch("events.services.event_permissions") 

446 def test_registration_fields(self, perms_mock): 

447 perms_mock.return_value = { 

448 "create_registration": False, 

449 "cancel_registration": False, 

450 "update_registration": False, 

451 } 

452 

453 mock_request = HttpRequest() 

454 mock_request.member = self.member 

455 

456 with self.assertRaises(RegistrationError): 

457 services.registration_fields(mock_request, self.member, self.event) 

458 

459 registration = EventRegistration.objects.create( 

460 event=self.event, 

461 member=self.member, 

462 ) 

463 

464 with self.assertRaises(RegistrationError): 

465 services.registration_fields(mock_request, self.member, self.event) 

466 with self.assertRaises(RegistrationError): 

467 services.registration_fields(mock_request, registration=registration) 

468 

469 perms_mock.return_value["update_registration"] = True 

470 

471 RegistrationInformationField.objects.create( 

472 id=1, 

473 name="1", 

474 type=RegistrationInformationField.INTEGER_FIELD, 

475 event=self.event, 

476 required=False, 

477 ) 

478 

479 RegistrationInformationField.objects.create( 

480 id=2, 

481 name="2", 

482 type=RegistrationInformationField.BOOLEAN_FIELD, 

483 event=self.event, 

484 required=True, 

485 ) 

486 

487 RegistrationInformationField.objects.create( 

488 id=3, 

489 name="3", 

490 type=RegistrationInformationField.TEXT_FIELD, 

491 event=self.event, 

492 required=False, 

493 ) 

494 # set order 

495 self.event.set_registrationinformationfield_order([1, 2, 3]) 

496 

497 fields_list = [ 

498 services.registration_fields(mock_request, self.member, self.event), 

499 services.registration_fields(mock_request, registration=registration), 

500 ] 

501 

502 for fields in fields_list: 

503 self.assertEqual( 

504 fields["info_field_1"], 

505 { 

506 "type": "integer", 

507 "label": "1", 

508 "description": None, 

509 "value": None, 

510 "required": False, 

511 }, 

512 ) 

513 

514 self.assertEqual( 

515 fields["info_field_2"], 

516 { 

517 "type": "boolean", 

518 "label": "2", 

519 "description": None, 

520 "value": None, 

521 "required": True, 

522 }, 

523 ) 

524 

525 self.assertEqual( 

526 fields["info_field_3"], 

527 { 

528 "type": "text", 

529 "label": "3", 

530 "description": None, 

531 "value": None, 

532 "required": False, 

533 }, 

534 ) 

535 

536 self.assertEqual(len(fields), 3) 

537 # Test that the ordering is correct 

538 labels = [field["label"] for field in fields.values()] 

539 self.assertEqual(labels, sorted(labels))