Coverage for website/sales/tests/test_views.py: 100.00%

1from unittest import mock 

2 

3from django.test import Client, TestCase 

4from django.urls import reverse 

5from django.utils import timezone 

6 

7from freezegun import freeze_time 

8 

9from members.models import Member 

10from payments.models import Payment 

11from payments.services import create_payment 

12from sales.models.order import Order, OrderItem 

13from sales.models.product import Product, ProductList 

14from sales.models.shift import Shift 

15 

16 

17@freeze_time("2019-01-01") 

18class SalesOrderPaymentView(TestCase): 

19 fixtures = [ 

20 "members.json", 

21 "bank_accounts.json", 

22 "member_groups.json", 

23 "products.json", 

24 ] 

25 

26 @classmethod 

27 def setUpTestData(cls): 

28 """Create the following test data: 

29 

30 o0: an empty order 

31 o1: an unpaid order of 2 beer 

32 o2: an order of 2 soda that doesn't need a payment 

33 o3: an unpaid order with 2 beer and 2 wine 

34 o4: a paid order with 2 wine 

35 o5: a paid order with 2 beer and 2 wine 

36 o6: an unpaid order of 2 soda that does need a payment (custom) 

37 """ 

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

39 

40 cls.beer = Product.objects.get(name="beer") 

41 cls.wine = Product.objects.get(name="wine") 

42 cls.soda = Product.objects.get(name="soda") 

43 

44 cls.normal = ProductList.objects.get( 

45 name="normal", 

46 ) 

47 cls.free = ProductList.objects.get( 

48 name="free", 

49 ) 

50 

51 cls.shift = Shift.objects.create( 

52 start=timezone.now(), 

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

54 product_list=cls.normal, 

55 ) 

56 

57 cls.o0 = Order.objects.create(shift=cls.shift) 

58 cls.o1 = Order.objects.create(shift=cls.shift) 

59 OrderItem.objects.create( 

60 order=cls.o1, 

61 product=cls.shift.product_list.product_items.get(product=cls.beer), 

62 amount=2, 

63 ) 

64 cls.o2 = Order.objects.create(shift=cls.shift) 

65 OrderItem.objects.create( 

66 order=cls.o2, 

67 product=cls.shift.product_list.product_items.get(product=cls.soda), 

68 amount=2, 

69 ) 

70 cls.o3 = Order.objects.create(shift=cls.shift) 

71 OrderItem.objects.create( 

72 order=cls.o3, 

73 product=cls.shift.product_list.product_items.get(product=cls.beer), 

74 amount=2, 

75 ) 

76 OrderItem.objects.create( 

77 order=cls.o3, 

78 product=cls.shift.product_list.product_items.get(product=cls.wine), 

79 amount=2, 

80 ) 

81 cls.o4 = Order.objects.create(shift=cls.shift) 

82 OrderItem.objects.create( 

83 order=cls.o4, 

84 product=cls.shift.product_list.product_items.get(product=cls.wine), 

85 amount=2, 

86 ) 

87 cls.o5 = Order.objects.create(shift=cls.shift) 

88 OrderItem.objects.create( 

89 order=cls.o5, 

90 product=cls.shift.product_list.product_items.get(product=cls.beer), 

91 amount=2, 

92 ) 

93 OrderItem.objects.create( 

94 order=cls.o5, 

95 product=cls.shift.product_list.product_items.get(product=cls.wine), 

96 amount=2, 

97 ) 

98 cls.o4.payment = create_payment( 

99 cls.o4, processed_by=cls.member, pay_type=Payment.CASH 

100 ) 

101 cls.o4.save() 

102 cls.o5.payment = create_payment( 

103 cls.o5, processed_by=cls.member, pay_type=Payment.CASH 

104 ) 

105 cls.o5.save() 

106 cls.o6 = Order.objects.create(shift=cls.shift) 

107 OrderItem.objects.create( 

108 order=cls.o6, 

109 product=cls.shift.product_list.product_items.get(product=cls.soda), 

110 amount=2, 

111 total=1, 

112 ) 

113 

114 def setUp(self): 

115 self.client = Client() 

116 self.client.force_login(self.member) 

117 

118 def test_not_logged_in(self): 

119 self.client.logout() 

120 

121 response = self.client.get( 

122 reverse("sales:order-pay", kwargs={"pk": self.o1.pk}), follow=True 

123 ) 

124 self.assertEqual(200, response.status_code) 

125 self.assertEqual( 

126 [ 

127 ( 

128 "/user/account/login/?next=" 

129 + reverse("sales:order-pay", kwargs={"pk": self.o1.pk}), 

130 302, 

131 ) 

132 ], 

133 response.redirect_chain, 

134 ) 

135 

136 def test_paid_order(self): 

137 response = self.client.get( 

138 reverse("sales:order-pay", kwargs={"pk": self.o4.pk}), follow=True 

139 ) 

140 self.assertEqual(200, response.status_code) 

141 self.assertEqual( 

142 [("/", 302)], 

143 response.redirect_chain, 

144 ) 

145 

146 def test_other_persons_order(self): 

147 member = Member.objects.create( 

148 username="test1", 

149 first_name="Test1", 

150 last_name="Example", 

151 email="test1@example.org", 

152 is_staff=False, 

153 is_superuser=False, 

154 ) 

155 self.o1.payer = member 

156 self.o1.save() 

157 

158 response = self.client.get( 

159 reverse("sales:order-pay", kwargs={"pk": self.o1.pk}), follow=True 

160 ) 

161 self.assertEqual(200, response.status_code) 

162 self.assertEqual( 

163 [("/", 302)], 

164 response.redirect_chain, 

165 ) 

166 

167 def test_empty_order(self): 

168 response = self.client.get( 

169 reverse("sales:order-pay", kwargs={"pk": self.o0.pk}), follow=True 

170 ) 

171 self.assertEqual(200, response.status_code) 

172 self.assertEqual( 

173 [("/", 302)], 

174 response.redirect_chain, 

175 ) 

176 

177 def test_free_order(self): 

178 response = self.client.get( 

179 reverse("sales:order-pay", kwargs={"pk": self.o2.pk}), follow=True 

180 ) 

181 self.assertEqual(200, response.status_code) 

182 self.assertEqual( 

183 [("/", 302)], 

184 response.redirect_chain, 

185 ) 

186 self.o2.refresh_from_db() 

187 self.assertEqual(self.o2.payer, self.member) 

188 

189 def test_age_restricted_order__unauthorized(self): 

190 with mock.patch("sales.services.is_adult") as is_adult: 

191 is_adult.return_value = False 

192 response = self.client.get( 

193 reverse("sales:order-pay", kwargs={"pk": self.o1.pk}), follow=True 

194 ) 

195 self.assertEqual(200, response.status_code) 

196 self.assertEqual( 

197 [("/", 302)], 

198 response.redirect_chain, 

199 ) 

200 self.o1.refresh_from_db() 

201 self.assertEqual(self.o1.payer, self.member) 

202 

203 def test_age_restricted_order__okay(self): 

204 with mock.patch("sales.services.is_adult") as is_adult: 

205 is_adult.return_value = False 

206 response = self.client.get( 

207 reverse("sales:order-pay", kwargs={"pk": self.o6.pk}), follow=False 

208 ) 

209 self.assertEqual(200, response.status_code) 

210 self.o6.refresh_from_db() 

211 self.assertEqual(self.o6.payer, self.member) 

212 

213 def test_normal(self): 

214 with mock.patch("sales.services.is_adult") as is_adult: 

215 is_adult.return_value = True 

216 response = self.client.get( 

217 reverse("sales:order-pay", kwargs={"pk": self.o1.pk}), follow=False 

218 ) 

219 self.assertEqual(200, response.status_code) 

220 self.o1.refresh_from_db() 

221 self.assertEqual(self.o1.payer, self.member)