Coverage for website/pushnotifications/tests/test_events.py: 100.00%

1from django.test import TestCase 

2from django.utils import timezone 

3 

4from events import payables 

5from events.models import Event, EventRegistration 

6from members.models import Member, Membership, Profile 

7 

8 

9class TestEventNotifications(TestCase): 

10 @classmethod 

11 def setUpTestData(cls): 

12 cls.time = timezone.now() 

13 cls.member = Member.objects.create(username="user1") 

14 Profile.objects.create(user=cls.member) 

15 Membership.objects.create( 

16 user=cls.member, type=Membership.MEMBER, since="2000-01-01" 

17 ) 

18 

19 cls.member2 = Member.objects.create(username="user2") 

20 Profile.objects.create(user=cls.member2) 

21 Membership.objects.create( 

22 user=cls.member2, type=Membership.MEMBER, since="2000-01-01" 

23 ) 

24 

25 cls.not_current_member = Member.objects.create(username="user3") 

26 Profile.objects.create(user=cls.not_current_member) 

27 

28 def setUp(self): 

29 payables.register() 

30 

31 def test_create_event_and_update_registrations_start_reminder(self): 

32 """Creating an event schedules a start reminder for the right users.""" 

33 with self.subTest("past event"): 

34 event = Event.objects.create( 

35 title="Test event", 

36 start=self.time - timezone.timedelta(days=2), 

37 end=self.time - timezone.timedelta(days=1), 

38 published=True, 

39 ) 

40 

41 self.assertFalse(hasattr(event, "start_reminder")) 

42 

43 with self.subTest("registration not required, published=False"): 

44 event = Event.objects.create( 

45 title="Test event", 

46 start=self.time + timezone.timedelta(days=1), 

47 end=self.time + timezone.timedelta(days=2), 

48 ) 

49 

50 self.assertFalse(hasattr(event, "start_reminder")) 

51 

52 with self.subTest("registration required, published=False"): 

53 event = Event.objects.create( 

54 title="Test event", 

55 start=self.time + timezone.timedelta(days=1), 

56 end=self.time + timezone.timedelta(days=2), 

57 registration_start=self.time - timezone.timedelta(days=1), 

58 registration_end=self.time, 

59 ) 

60 

61 self.assertFalse(hasattr(event, "start_reminder")) 

62 

63 with self.subTest("registration not required, published=True"): 

64 event = Event.objects.create( 

65 title="Test event", 

66 start=self.time + timezone.timedelta(days=1), 

67 end=self.time + timezone.timedelta(days=2), 

68 published=True, 

69 ) 

70 

71 self.assertIsNotNone(event.start_reminder) 

72 self.assertIn(self.member, event.start_reminder.users.all()) 

73 self.assertIn(self.member2, event.start_reminder.users.all()) 

74 self.assertNotIn(self.not_current_member, event.start_reminder.users.all()) 

75 

76 registration = EventRegistration.objects.create( 

77 event=event, member=self.member, date=self.time 

78 ) 

79 

80 self.assertIn(self.member, event.start_reminder.users.all()) 

81 

82 registration.date_cancelled = timezone.now() 

83 registration.save() 

84 

85 self.assertIn(self.member, event.start_reminder.users.all()) 

86 

87 registration2 = EventRegistration.objects.create( 

88 event=event, member=self.member2, date=self.time 

89 ) 

90 registration2.delete() 

91 

92 self.assertIn(self.member2, event.start_reminder.users.all()) 

93 

94 with self.subTest("registration required, published=True"): 

95 event = Event.objects.create( 

96 title="Test event", 

97 start=self.time + timezone.timedelta(days=1), 

98 end=self.time + timezone.timedelta(days=2), 

99 registration_start=self.time - timezone.timedelta(days=1), 

100 registration_end=self.time, 

101 published=True, 

102 ) 

103 

104 self.assertIsNotNone(event.start_reminder) 

105 self.assertNotIn(self.member, event.start_reminder.users.all()) 

106 self.assertNotIn(self.member2, event.start_reminder.users.all()) 

107 self.assertNotIn(self.not_current_member, event.start_reminder.users.all()) 

108 

109 registration = EventRegistration.objects.create( 

110 event=event, member=self.member, date=self.time 

111 ) 

112 

113 self.assertIn(self.member, event.start_reminder.users.all()) 

114 

115 registration.date_cancelled = timezone.now() 

116 registration.save() 

117 

118 self.assertNotIn(self.member, event.start_reminder.users.all()) 

119 

120 registration.date_cancelled = None 

121 registration.save() 

122 

123 self.assertIn(self.member, event.start_reminder.users.all()) 

124 

125 registration.delete() 

126 

127 self.assertNotIn(self.member2, event.start_reminder.users.all()) 

128 

129 def test_update_event_start_reminder(self): 

130 """Updating an event creates, deletes or updates the start reminder correctly.""" 

131 event = Event.objects.create( 

132 title="Test event", 

133 start=self.time + timezone.timedelta(days=1), 

134 end=self.time + timezone.timedelta(days=2), 

135 published=True, 

136 ) 

137 

138 self.assertIsNotNone(event.start_reminder) 

139 

140 event.published = False 

141 event.save() 

142 

143 self.assertFalse(hasattr(event, "start_reminder")) 

144 

145 event.published = True 

146 event.save() 

147 

148 self.assertIsNotNone(event.start_reminder) 

149 

150 event.start = self.time - timezone.timedelta(days=1) 

151 event.save() 

152 

153 self.assertFalse(hasattr(event, "start_reminder")) 

154 

155 def test_create_event_registration_reminder(self): 

156 """Creating an event that requires registration schedules registration reminder.""" 

157 with self.subTest("past registration period"): 

158 event = Event.objects.create( 

159 title="Test event", 

160 start=self.time + timezone.timedelta(days=2), 

161 end=self.time + timezone.timedelta(days=3), 

162 registration_start=self.time - timezone.timedelta(days=2), 

163 registration_end=self.time - timezone.timedelta(days=1), 

164 published=True, 

165 ) 

166 

167 self.assertFalse(hasattr(event, "registration_reminder")) 

168 

169 with self.subTest("registration required, published=True"): 

170 event = Event.objects.create( 

171 title="Test event", 

172 start=self.time + timezone.timedelta(days=2), 

173 end=self.time + timezone.timedelta(days=3), 

174 registration_start=self.time + timezone.timedelta(days=1), 

175 registration_end=self.time + timezone.timedelta(days=2), 

176 published=True, 

177 ) 

178 

179 self.assertIsNotNone(event.registration_reminder) 

180 self.assertIn(self.member, event.registration_reminder.users.all()) 

181 self.assertIn(self.member2, event.registration_reminder.users.all()) 

182 self.assertNotIn( 

183 self.not_current_member, event.registration_reminder.users.all() 

184 ) 

185 

186 with self.subTest("registration required, published=False"): 

187 event = Event.objects.create( 

188 title="Test event", 

189 start=self.time + timezone.timedelta(days=2), 

190 end=self.time + timezone.timedelta(days=3), 

191 registration_start=self.time + timezone.timedelta(days=1), 

192 registration_end=self.time + timezone.timedelta(days=2), 

193 ) 

194 

195 self.assertFalse(hasattr(event, "registration_reminder")) 

196 

197 with self.subTest("registration not required, published=True"): 

198 event = Event.objects.create( 

199 title="Test event", 

200 start=self.time + timezone.timedelta(days=2), 

201 end=self.time + timezone.timedelta(days=3), 

202 published=True, 

203 ) 

204 

205 self.assertFalse(hasattr(event, "registration_reminder")) 

206 

207 def test_update_event_registration_reminder(self): 

208 """Updating an event creates, deletes or updates the registration reminder correctly.""" 

209 event = Event.objects.create( 

210 title="Test event", 

211 start=self.time + timezone.timedelta(days=2), 

212 end=self.time + timezone.timedelta(days=3), 

213 registration_start=self.time + timezone.timedelta(days=1), 

214 registration_end=self.time + timezone.timedelta(days=2), 

215 published=True, 

216 ) 

217 

218 self.assertIsNotNone(event.registration_reminder) 

219 

220 event.published = False 

221 event.save() 

222 

223 self.assertFalse(hasattr(event, "registration_reminder")) 

224 

225 event.published = True 

226 event.save() 

227 

228 self.assertIsNotNone(event.registration_reminder) 

229 

230 event.registration_start = self.time - timezone.timedelta(days=1) 

231 event.save() 

232 

233 self.assertFalse(hasattr(event, "registration_reminder"))