Coverage for website/events/tests/test_models.py: 99.53%

1import datetime 

2 

3from django.core.exceptions import ValidationError 

4from django.test import TestCase, override_settings 

5from django.utils import timezone 

6 

7from activemembers.models import Committee 

8from events.models import Event, EventRegistration 

9from mailinglists.models import MailingList 

10from members.models import Member 

11 

12 

13@override_settings(SUSPEND_SIGNALS=True) 

14class EventTest(TestCase): 

15 """Tests events.""" 

16 

17 fixtures = ["members.json"] 

18 

19 @classmethod 

20 def setUpTestData(cls): 

21 cls.mailinglist = MailingList.objects.create(name="testmail") 

22 

23 cls.committee = Committee.objects.create( 

24 name="committee", 

25 contact_mailinglist=cls.mailinglist, 

26 ) 

27 

28 cls.event = Event.objects.create( 

29 title="testevent", 

30 description="desc", 

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

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

33 location="test location", 

34 map_location="test map location", 

35 price=0.00, 

36 fine=5.00, 

37 optional_registrations=False, 

38 ) 

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

40 cls.member = Member.objects.first() 

41 

42 def setUp(self): 

43 self.mailinglist.refresh_from_db() 

44 self.committee.refresh_from_db() 

45 self.event.refresh_from_db() 

46 self.member.refresh_from_db() 

47 

48 def test_clean_works(self): 

49 self.event.clean() 

50 

51 def test_end_after_start(self): 

52 self.event.start, self.event.end = self.event.end, self.event.start 

53 with self.assertRaises(ValidationError): 

54 self.event.clean() 

55 

56 def test_missing_registration_start(self): 

57 self.event.cancel_deadline = timezone.now() 

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

59 with self.assertRaises(ValidationError): 

60 self.event.clean() 

61 

62 self.event.registration_start = timezone.now() 

63 self.event.clean() 

64 

65 def test_missing_registration_end(self): 

66 self.event.cancel_deadline = timezone.now() 

67 self.event.registration_start = timezone.now() 

68 with self.assertRaises(ValidationError): 

69 self.event.clean() 

70 

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

72 self.event.clean() 

73 

74 def test_missing_cancel_deadline(self): 

75 self.event.registration_start = timezone.now() 

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

77 with self.assertRaises(ValidationError): 

78 self.event.clean() 

79 

80 self.event.cancel_deadline = timezone.now() 

81 self.event.clean() 

82 

83 def test_unnecessary_no_registration_message(self): 

84 self.event.registration_start = timezone.now() 

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

86 self.event.cancel_deadline = timezone.now() 

87 self.event.no_registration_message = "Not registered" 

88 with self.assertRaises(ValidationError): 

89 self.event.clean() 

90 

91 self.event.no_registration_message = "" 

92 self.event.clean() 

93 

94 def test_registration_end_after_registration_start(self): 

95 self.event.registration_start = timezone.now() + datetime.timedelta(hours=1) 

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

97 self.event.cancel_deadline = timezone.now() 

98 with self.assertRaises(ValidationError): 

99 self.event.clean() 

100 

101 self.event.registration_start, self.event.registration_end = ( 

102 self.event.registration_end, 

103 self.event.registration_start, 

104 ) 

105 self.event.clean() 

106 

107 def test_cancel_deadline_before_registration_start(self): 

108 self.event.registration_start = timezone.now() 

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

110 self.event.cancel_deadline = self.event.start + datetime.timedelta(hours=1) 

111 with self.assertRaises(ValidationError): 

112 self.event.clean() 

113 

114 self.event.cancel_deadline = self.event.start 

115 self.event.clean() 

116 

117 def test_reached_participants_limit(self): 

118 self.event.max_participants = 1 

119 self.assertFalse(self.event.reached_participants_limit()) 

120 

121 def test_not_reached_participants_limit(self): 

122 self.event.max_participants = 1 

123 EventRegistration.objects.create(event=self.event, member=self.member) 

124 self.assertTrue(self.event.reached_participants_limit()) 

125 

126 def test_registration_fine_required(self): 

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

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

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

130 self.event.clean() 

131 self.event.fine = 0 

132 

133 with self.assertRaises(ValidationError): 

134 self.event.clean() 

135 

136 def test_registration_allowed(self): 

137 # Open 

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

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

140 self.event.cancel_deadline = timezone.now() + datetime.timedelta(hours=1) 

141 self.assertTrue(self.event.registration_allowed) 

142 

143 # No cancel 

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

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

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

147 self.assertTrue(self.event.registration_allowed) 

148 

149 # Not yet open 

150 self.event.registration_start = timezone.now() + datetime.timedelta(hours=1) 

151 self.event.registration_end = timezone.now() + datetime.timedelta(hours=2) 

152 self.event.cancel_deadline = timezone.now() + datetime.timedelta(hours=1) 

153 self.assertFalse(self.event.registration_allowed) 

154 

155 # Cancel only 

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

157 self.event.registration_end = timezone.now() - datetime.timedelta(hours=1) 

158 self.event.cancel_deadline = timezone.now() + datetime.timedelta(hours=1) 

159 self.assertFalse(self.event.registration_allowed) 

160 

161 # Registration is closed 

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

163 self.event.registration_end = timezone.now() - datetime.timedelta(hours=1) 

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

165 self.assertFalse(self.event.registration_allowed) 

166 

167 # Registration not needed 

168 self.event.registration_start = None 

169 self.event.registration_end = None 

170 self.event.cancel_deadline = None 

171 self.assertFalse(self.event.registration_allowed) 

172 

173 def test_cancellation_allowed(self): 

174 with self.subTest("Open"): 

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

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

177 self.event.cancel_deadline = timezone.now() + datetime.timedelta(hours=1) 

178 self.assertTrue(self.event.cancellation_allowed) 

179 

180 with self.subTest("No cancel"): 

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

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

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

184 # Allow since cancellation after deadline is possible 

185 self.assertTrue(self.event.cancellation_allowed) 

186 

187 with self.subTest("Not yet open (now < registration start)"): 

188 self.event.registration_start = timezone.now() + datetime.timedelta(hours=1) 

189 self.event.registration_end = timezone.now() + datetime.timedelta(hours=2) 

190 self.event.cancel_deadline = timezone.now() + datetime.timedelta(hours=1) 

191 self.assertFalse(self.event.cancellation_allowed) 

192 

193 with self.subTest("Cancel only"): 

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

195 self.event.registration_end = timezone.now() - datetime.timedelta(hours=1) 

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

197 self.assertTrue(self.event.cancellation_allowed) 

198 

199 with self.subTest("Registration is closed"): 

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

201 self.event.registration_end = timezone.now() - datetime.timedelta(hours=1) 

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

203 # Allow since cancellation after deadline is possible 

204 self.assertTrue(self.event.cancellation_allowed) 

205 

206 with self.subTest("After event start"): 

207 self.event.registration_start = timezone.now() - datetime.timedelta(hours=4) 

208 self.event.registration_end = timezone.now() - datetime.timedelta(hours=3) 

209 self.event.cancel_deadline = timezone.now() - datetime.timedelta(hours=3) 

210 self.event.start = timezone.now() 

211 self.event.end = timezone.now() + datetime.timedelta(hours=2) 

212 self.assertFalse(self.event.cancellation_allowed) 

213 

214 with self.subTest("Registration not required"): 

215 self.event.registration_start = None 

216 self.event.registration_end = None 

217 self.event.cancel_deadline = None 

218 self.assertFalse(self.event.cancellation_allowed) 

219 

220 

221@override_settings(SUSPEND_SIGNALS=True) 

222class RegistrationTest(TestCase): 

223 """Tests event registrations.""" 

224 

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

226 

227 @classmethod 

228 def setUpTestData(cls): 

229 cls.event = Event.objects.create( 

230 title="testevent", 

231 description="desc", 

232 start=timezone.now(), 

233 end=(timezone.now() + datetime.timedelta(hours=1)), 

234 location="test location", 

235 map_location="test map location", 

236 price=0.00, 

237 fine=0.00, 

238 ) 

239 cls.event.organisers.add(Committee.objects.get(pk=1)) 

240 cls.member1 = Member.objects.first() 

241 cls.member2 = Member.objects.all()[1] 

242 cls.member3 = Member.objects.all()[2] 

243 cls.r1 = EventRegistration.objects.create(event=cls.event, member=cls.member1) 

244 cls.r2 = EventRegistration.objects.create(event=cls.event, member=cls.member2) 

245 cls.r3 = EventRegistration.objects.create(event=cls.event, member=cls.member3) 

246 

247 def setUp(self): 

248 self.r1.refresh_from_db() 

249 

250 def test_is_late_registration(self): 

251 self.assertFalse(self.r1.is_late_cancellation()) 

252 

253 self.r1.date_cancelled = timezone.now() 

254 self.assertFalse(self.r1.is_late_cancellation()) 

255 

256 self.r1.event.cancel_deadline = timezone.now() + datetime.timedelta(hours=1) 

257 self.assertFalse(self.r1.is_late_cancellation()) 

258 

259 self.r1.event.cancel_deadline = timezone.now() - datetime.timedelta(hours=1) 

260 self.assertTrue(self.r1.is_late_cancellation()) 

261 

262 def test_queue_position(self): 

263 self.assertEqual(self.r1.queue_position, None) 

264 self.assertEqual(self.r2.queue_position, None) 

265 

266 self.r1.event.max_participants = 0 

267 self.r1.event.save() 

268 self.r2.event = self.r1.event 

269 self.assertEqual(self.r1.queue_position, 1) 

270 self.assertEqual(self.r2.queue_position, 2) 

271 

272 self.r1.event.max_participants = 1 

273 self.r1.event.save() 

274 self.r2.event = self.r1.event 

275 self.assertEqual(self.r1.queue_position, None) 

276 self.assertEqual(self.r2.queue_position, 1) 

277 

278 def test_queue_cancel(self): 

279 self.r1.event.max_participants = 0 

280 self.r1.event.save() 

281 

282 self.r2.date_cancelled = timezone.now() 

283 self.r2.save() 

284 

285 self.assertEqual(self.r1.queue_position, 1) 

286 self.assertEqual(self.r2.queue_position, None) 

287 self.assertEqual(self.r3.queue_position, 2) 

288 

289 def test_registration_either_name_or_member(self): 

290 self.r2.delete() 

291 self.r1.clean() 

292 r2 = EventRegistration.objects.create(event=self.event, name="test name") 

293 r2.clean() 

294 with self.assertRaises(ValidationError): 

295 r3 = EventRegistration.objects.create( 

296 event=self.event, name="test name", member=self.member2 

297 ) 

298 r3.clean() 

299 

300 def test_would_cancel_after_deadline(self): 

301 self.r1.event.registration_start = timezone.now() - datetime.timedelta(hours=1) 

302 self.r1.event.registration_end = timezone.now() - datetime.timedelta(hours=1) 

303 self.r1.event.cancel_deadline = timezone.now() - datetime.timedelta(hours=1) 

304 

305 # Test situation where the event status is REGISTRATION_CLOSED 

306 self.assertFalse(self.r1.event.registration_allowed) 

307 self.assertTrue(self.r1.would_cancel_after_deadline()) 

308 

309 self.r1.event.registration_end = timezone.now() + datetime.timedelta(hours=2) 

310 

311 # Test situation where the event status is REGISTRATION_OPEN_NO_CANCEL 

312 self.assertTrue(self.r1.event.registration_allowed) 

313 self.assertTrue(self.r1.would_cancel_after_deadline())