Coverage for website/pushnotifications/tests/test_pizzas.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 

7from pizzas.models import FoodEvent, FoodOrder, Product 

8from pushnotifications.models import FoodOrderReminderMessage 

9 

10 

11class TestFoodEventNotifications(TestCase): 

12 @classmethod 

13 def setUpTestData(cls): 

14 cls.time = timezone.now() 

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

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

17 Membership.objects.create( 

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

19 ) 

20 

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

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

23 Membership.objects.create( 

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

25 ) 

26 

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

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

29 

30 cls.event = Event.objects.create( 

31 title="Test event", 

32 start=cls.time + timezone.timedelta(days=1), 

33 end=cls.time + timezone.timedelta(days=2), 

34 ) 

35 

36 cls.product = Product.objects.create(name="Test product", price=10) 

37 

38 def setUp(self): 

39 payables.register() 

40 

41 def test_create_food_event_schedules_notification(self): 

42 """Creating a food event schedules a notification with the right users.""" 

43 with self.subTest("send_notification=True, registration not required"): 

44 food_event = FoodEvent.objects.create( 

45 event=self.event, 

46 send_notification=True, 

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

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

49 ) 

50 

51 self.assertIsNotNone(food_event.end_reminder) 

52 self.assertIn(self.member, food_event.end_reminder.users.all()) 

53 self.assertIn(self.member2, food_event.end_reminder.users.all()) 

54 self.assertNotIn( 

55 self.not_current_member, food_event.end_reminder.users.all() 

56 ) 

57 

58 food_event.delete() 

59 

60 with self.subTest("send_notification=False, registration not required"): 

61 food_event = FoodEvent.objects.create( 

62 event=self.event, 

63 send_notification=False, 

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

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

66 ) 

67 

68 self.assertFalse(hasattr(food_event, "end_reminder")) 

69 self.assertFalse( 

70 FoodOrderReminderMessage.objects.filter(food_event=food_event).exists() 

71 ) 

72 

73 food_event.delete() 

74 

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

76 self.event.registration_end = self.time 

77 self.event.save() 

78 

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

80 

81 with self.subTest("send_notification=True, registration required"): 

82 food_event = FoodEvent.objects.create( 

83 event=self.event, 

84 send_notification=True, 

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

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

87 ) 

88 

89 self.assertIsNotNone(food_event.end_reminder) 

90 self.assertIn(self.member, food_event.end_reminder.users.all()) 

91 self.assertNotIn(self.member2, food_event.end_reminder.users.all()) 

92 self.assertNotIn( 

93 self.not_current_member, food_event.end_reminder.users.all() 

94 ) 

95 

96 food_event.delete() 

97 

98 with self.subTest("send_notification=False, registration required"): 

99 food_event = FoodEvent.objects.create( 

100 event=self.event, 

101 send_notification=False, 

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

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

104 ) 

105 

106 self.assertFalse(hasattr(food_event, "end_reminder")) 

107 self.assertFalse( 

108 FoodOrderReminderMessage.objects.filter(food_event=food_event).exists() 

109 ) 

110 

111 food_event.delete() 

112 

113 def test_update_food_event(self): 

114 """Updating the event creates or deletes the notification.""" 

115 food_event = FoodEvent.objects.create( 

116 event=self.event, 

117 send_notification=False, 

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

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

120 ) 

121 

122 self.assertFalse(hasattr(food_event, "end_reminder")) 

123 

124 food_event.send_notification = True 

125 food_event.save() 

126 

127 self.assertIsNotNone(food_event.end_reminder) 

128 

129 food_event.send_notification = False 

130 food_event.save() 

131 

132 self.assertFalse(hasattr(food_event, "end_reminder")) 

133 

134 food_event.send_notification = True 

135 food_event.save() 

136 

137 food_event.end = self.time 

138 food_event.save() 

139 

140 self.assertFalse(hasattr(food_event, "end_reminder")) 

141 

142 def test_register_updates_message_users(self): 

143 """Registering for an event updates the notification users.""" 

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

145 self.event.registration_end = self.time 

146 self.event.save() 

147 

148 food_event = FoodEvent.objects.create( 

149 event=self.event, 

150 send_notification=True, 

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

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

153 ) 

154 

155 self.assertIsNotNone(food_event.end_reminder) 

156 self.assertNotIn(self.member2, food_event.end_reminder.users.all()) 

157 

158 registration = EventRegistration.objects.create( 

159 event=self.event, member=self.member2 

160 ) 

161 

162 self.assertIn(self.member2, food_event.end_reminder.users.all()) 

163 

164 registration.date_cancelled = timezone.now() 

165 registration.save() 

166 

167 self.assertNotIn(self.member2, food_event.end_reminder.users.all()) 

168 

169 def test_order_updates_message_users(self): 

170 """Ordering food updates the notification users.""" 

171 food_event = FoodEvent.objects.create( 

172 event=self.event, 

173 send_notification=True, 

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

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

176 ) 

177 

178 self.assertIsNotNone(food_event.end_reminder) 

179 self.assertIn(self.member, food_event.end_reminder.users.all()) 

180 

181 order = FoodOrder.objects.create( 

182 food_event=food_event, member=self.member, product=self.product 

183 ) 

184 

185 self.assertNotIn(self.member, food_event.end_reminder.users.all()) 

186 

187 order.delete() 

188 

189 self.assertIn(self.member, food_event.end_reminder.users.all())