1from django.test import TestCase, RequestFactory, tag 

2from django.urls import reverse 

3from django.contrib.auth.models import AnonymousUser 

4import json 

5import sys 

6from policorp.models import Availability, Location, Task, Booking 

7from policorp.views import * 

8from policorp.tests import aux 

9from datetime import datetime, timedelta 

10import logging 

11 

12class TestViews(TestCase): 

13 

14 fixtures = ['testsdata.json'] 

15 

16 task1 = {'id': 1, 'name': 'Device Installation', 'duration': 120} 

17 task2 = {'id': 2, 'name': 'Repair', 'duration': 60} 

18 

19 maxDiff = None 

20 

21 def setUp(self): 

22 # Every test needs access to the request factory. 

23 self.factory = RequestFactory() 

24 

25 @tag('tasks') 

26 def test_view_tasks_return_200(self): 

27 """ GIVEN ; WHEN GET /policorp/tasks ; THEN code 200 should be returned """ 

28 # Create an instance of a GET request. 

29 request = self.factory.get(reverse('policorp:tasks')) 

30 response = tasks(request) 

31 self.assertEqual(response.status_code, 200) 

32 

33 @tag('tasks') 

34 def test_view_tasks_post_not_allowed(self): 

35 """ GIVEN ; WHEN POST /policorp/tasks; THEN code 400 should be returned """ 

36 # Create an instance of a POST request. 

37 request = self.factory.post(reverse('policorp:tasks')) 

38 response = tasks(request) 

39 self.assertEqual(response.status_code, 400) 

40 

41 @tag('tasks') 

42 def test_view_tasks_return_2_tasks(self): 

43 """ GIVEN 2 tasks with name "Device Installation" and "Repair"; WHEN GET /policorp/tasks ; THEN 2 tasks should be returned in json format """ 

44 expected_data = [self.task1, self.task2] 

45 

46 # Create an instance of a GET request. 

47 request = self.factory.get(reverse('policorp:tasks')) 

48 response = tasks(request) 

49 self.assertEqual(response.status_code, 200) 

50 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_data) 

51 

52 @tag('availabilities') 

53 def test_view_availabilities_return_200(self): 

54 """ GIVEN ; WHEN GET /policorp/availabilities/1 ; THEN code 200 is returned """ 

55 # Create an instance of a GET request. 

56 request = self.factory.get(reverse('policorp:availabilities', kwargs={'taskid': 1})) 

57 response = availabilities(request, 1) 

58 self.assertEqual(response.status_code, 200) 

59 

60 @tag('availabilities') 

61 def test_view_availabilities_return_2_availabilities(self): 

62 """ GIVEN 2 availabilities for task 3; WHEN GET /policorp/availabilities/3 ; THEN 2 json availabilities are returned """ 

63 now = datetime.now(timezone.utc) 

64 l1 = Location.objects.get(pk=1) 

65 task_name = "Device Installation for Trucks" 

66 t1 = Task.objects.create_task(task_name, 120) 

67 a1 = Availability.objects.create_availability(now + timedelta(minutes = 60), l1, t1) 

68 a2 = Availability.objects.create_availability(now + timedelta(minutes = 30), l1, t1) 

69 

70 expected_json = [a2.json(), a1.json()] 

71 

72 # Create an instance of a GET request. 

73 request = self.factory.get(reverse('policorp:availabilities', kwargs={'taskid': t1.id})) 

74 response = availabilities(request, t1.id) 

75 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_json) 

76 

77 @tag('availabilities') 

78 def test_view_availabilities_return_1_availability_today(self): 

79 """ GIVEN 2 availabilities for task 3, location 1 for today, now + 30min and now - 60min; WHEN GET /policorp/availabilities/1 ; THEN availabiliy 1 json availabilities is returned, now + 30 """ 

80 now = datetime.now(timezone.utc) 

81 l1 = Location.objects.get(pk=1) 

82 task_name = "Device Installation for Trucks" 

83 t1 = Task.objects.create_task(task_name, 120) 

84 a1 = Availability.objects.create_availability(now + timedelta(minutes = 30), l1, t1) 

85 a2 = Availability.objects.create_availability(now + timedelta(minutes = -60), l1, t1) 

86 

87 expected_json = [a1.json()] 

88 

89 # Create an instance of a GET request. 

90 request = self.factory.get(reverse('policorp:availabilities', kwargs={'taskid': t1.id})) 

91 response = availabilities(request, t1.id) 

92 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_json) 

93 

94 @tag('availabilities') 

95 def test_view_availabilities_return_1_availability_tomorrow(self): 

96 """ GIVEN 2 availabilities for task 3, location 1 for today, now - 30min and tomorrow - 60min; WHEN GET /policorp/availabilities/1 ; THEN availabiliy 1 json availabilities is returned, tomorrow - 60 """ 

97 now = datetime.now(timezone.utc) 

98 l1 = Location.objects.get(pk=1) 

99 task_name = "Device Installation for Trucks" 

100 t1 = Task.objects.create_task(task_name, 120) 

101 a1 = Availability.objects.create_availability(now + timedelta(minutes = -30), l1, t1) 

102 a2 = Availability.objects.create_availability(now + timedelta(days=1,minutes = -60), l1, t1) 

103 

104 expected_json = [a2.json()] 

105 

106 # Create an instance of a GET request. 

107 request = self.factory.get(reverse('policorp:availabilities', kwargs={'taskid': t1.id})) 

108 response = availabilities(request, t1.id) 

109 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_json) 

110 

111 @tag('availabilities') 

112 def test_view_availabilities_post_not_allowed(self): 

113 """ GIVEN ; WHEN POST /policorp/availabilities/1; THEN code 400 is returned """ 

114 # Create an instance of a POST request. 

115 request = self.factory.post(reverse('policorp:availabilities', kwargs={'taskid': 1})) 

116 response = availabilities(request, 1) 

117 self.assertEqual(response.status_code, 400) 

118 

119 @tag('dailyavailabilities') 

120 def test_view_dailyavailabilities_return_200(self): 

121 """ GIVEN ; WHEN GET /policorp/dailyavailabilities/1/20200101 ; THEN code 200 is returned """ 

122 # Create an instance of a GET request. 

123 request = self.factory.get(reverse('policorp:dailyavailabilities', kwargs={'taskid': 1, 'date': '20200101'})) 

124 response = dailyavailabilities(request, 1, '20200101') 

125 self.assertEqual(response.status_code, 200) 

126 

127 @tag('dailyavailabilities') 

128 def test_view_dailyavailabilities_post_not_allowed(self): 

129 """ GIVEN ; WHEN POST /policorp/dailyavailabilities/1/20200101; THEN code 400 is returned """ 

130 # Create an instance of a POST request. 

131 request = self.factory.post(reverse('policorp:dailyavailabilities', kwargs={'taskid': 1, 'date': '20200101'})) 

132 response = dailyavailabilities(request, 1, '20200101') 

133 self.assertEqual(response.status_code, 400) 

134 

135 @tag('dailyavailabilities') 

136 def test_view_dailyavailabilities_return_1_availability_today(self): 

137 """ GIVEN 2 availabilities for task 3, location 1 for today, now + 30min and now - 60min; WHEN GET /policorp/availabilities/1/[today] ; THEN availabiliy 1 json availabilities is returned, now + 30 """ 

138 now = datetime.now(timezone.utc) 

139 l1 = Location.objects.get(pk=1) 

140 task_name = "Device Installation for Trucks" 

141 t1 = Task.objects.create_task(task_name, 120) 

142 a1 = Availability.objects.create_availability(now + timedelta(minutes = 30), l1, t1) 

143 a2 = Availability.objects.create_availability(now + timedelta(minutes = -60), l1, t1) 

144 

145 expected_json = [a1.json()] 

146 

147 # Create an instance of a GET request. 

148 datestr = now.date().isoformat().replace('-','') 

149 request = self.factory.get(reverse('policorp:dailyavailabilities', kwargs={'taskid': t1.id, 'date': datestr})) 

150 response = dailyavailabilities(request, t1.id, datestr) 

151 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_json) 

152 

153 @tag('dailyavailabilities') 

154 def test_view_dailyavailabilities_return_2_availabilities(self): 

155 """ GIVEN 2 availabilities for task 3; WHEN GET /policorp/dailyavailabilities/3/[tomorrow] ; THEN 2 json availabilities are returned """ 

156 now = datetime.now(timezone.utc) 

157 tomorrow = now + timedelta(days=1) 

158 l1 = Location.objects.get(pk=1) 

159 task_name = "Device Installation for Trucks" 

160 t1 = Task.objects.create_task(task_name, 120) 

161 a1 = Availability.objects.create_availability(tomorrow + timedelta(minutes = 60), l1, t1) 

162 a2 = Availability.objects.create_availability(tomorrow + timedelta(minutes = 30), l1, t1) 

163 

164 expected_json = [a2.json(), a1.json()] 

165 

166 # Create an instance of a GET request. 

167 datestr = tomorrow.date().isoformat().replace('-','') 

168 request = self.factory.get(reverse('policorp:dailyavailabilities', kwargs={'taskid': t1.id, 'date': datestr})) 

169 response = dailyavailabilities(request, t1.id, datestr) 

170 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_json) 

171 

172 @tag('book') 

173 def test_view_book(self): 

174 """ GIVEN ; WHEN POST /policorp/book/1 ; THEN code 201 is returned """ 

175 request = self.factory.post(reverse('policorp:book', kwargs={'availabilityid': 1})) 

176 request.user = aux.createUser("foo", "foo@example.com", "example") 

177 response = book(request, 1) 

178 self.assertEqual(response.status_code, 201) 

179 

180 @tag('book') 

181 def test_view_book_returns_booking_json(self): 

182 """ GIVEN ; WHEN POST /policorp/book/1 ; THEN code 201 is returned """ 

183 availabilityId = 1 

184 request = self.factory.post(reverse('policorp:book', kwargs={'availabilityid': availabilityId})) 

185 request.user = aux.createUser("foo", "foo@example.com", "example") 

186 response = book(request, availabilityId) 

187 

188 expected_json = Booking.objects.get(availability__id=availabilityId).json() 

189 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_json) 

190 

191 @tag('book') 

192 def test_view_book_only_post_allowed(self): 

193 """ GIVEN ; WHEN GET /policorp/book/1; THEN code 400 should be returned """ 

194 request = self.factory.get(reverse('policorp:book', kwargs={'availabilityid': 1})) 

195 request.user = AnonymousUser() 

196 response = book(request, 1) 

197 self.assertEqual(response.status_code, 400) 

198 

199 @tag('book') 

200 def test_view_book_only_logged_in_requests_allowed(self): 

201 """ GIVEN ; WHEN POST /policorp/book/1 logged out; THEN code 401 (unauthorized) should be returned """ 

202 request = self.factory.post(reverse('policorp:book', kwargs={'availabilityid': 1})) 

203 request.user = AnonymousUser() 

204 response = book(request, 1) 

205 self.assertEqual(response.status_code, 401) 

206 

207 @tag('myschedule') 

208 def test_view_myschedule_returns_200(self): 

209 """ GIVEN ; WHEN GET /myschedule ; THEN code 200 is returned """ 

210 request = self.factory.get(reverse('policorp:myschedule')) 

211 request.user = aux.createUser('foo', 'foo@example.com', 'example') 

212 response = myschedule(request) 

213 self.assertEqual(response.status_code, 200) 

214 

215 @tag('myschedule') 

216 def test_view_myschedule_post_not_allowed(self): 

217 """ GIVEN ; WHEN POST /myschedule; THEN code 400 should be returned """ 

218 # Create an instance of a POST request. 

219 request = self.factory.post(reverse('policorp:myschedule')) 

220 response = myschedule(request) 

221 self.assertEqual(response.status_code, 400) 

222 

223 @tag('myschedule') 

224 def test_view_myschedule_only_logged_in_requests_allowed(self): 

225 """ GIVEN ; WHEN GET /myschedule logged out; THEN code 401 (unauthorized) should be returned """ 

226 request = self.factory.get(reverse('policorp:myschedule')) 

227 request.user = AnonymousUser() 

228 response = myschedule(request) 

229 self.assertEqual(response.status_code, 401) 

230 

231 @tag('myschedule') 

232 def test_view_myschedule_returns_caller_bookings(self): 

233 """ GIVEN 2 bookings for user foo; WHEN GET /myschedule with user foo; THEN json with 2 bookings should be returned""" 

234 user1 = aux.createUser("foo", "foo@example.com", "example") 

235 availability1 = Availability.objects.get(pk=1) 

236 b1 = Booking.objects.book(availability1, user1) 

237 availability2 = Availability.objects.get(pk=2) 

238 b2 = Booking.objects.book(availability2, user1) 

239 request = self.factory.get(reverse('policorp:myschedule')) 

240 request.user = user1 

241 response = myschedule(request) 

242 

243 expected_json = [b1.json(), b2.json()] 

244 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_json) 

245 

246 @tag('cancelbooking') 

247 def test_view_cancelbooking(self): 

248 """ GIVEN a booking for user foo; WHEN POST /policorp/cancelbooking/1 ; THEN code 201 is returned """ 

249 user1 = aux.createUser("foo", "foo@example.com", "example") 

250 availability1 = Availability.objects.get(pk=1) 

251 b1 = Booking.objects.book(availability1, user1) 

252 request = self.factory.post(reverse('policorp:cancelbooking', kwargs={'bookingid': b1.id})) 

253 request.user = user1 

254 response = cancelbooking(request, b1.id) 

255 self.assertEqual(response.status_code, 201) 

256 

257 @tag('cancelbooking') 

258 def test_view_cancelbooking_only_post_allowed(self): 

259 """ GIVEN ; WHEN GET /policorp/cancelbooking/1; THEN code 400 should be returned """ 

260 request = self.factory.get(reverse('policorp:cancelbooking', kwargs={'bookingid': 1})) 

261 request.user = AnonymousUser() 

262 response = cancelbooking(request, 1) 

263 self.assertEqual(response.status_code, 400) 

264 

265 @tag('cancelbooking') 

266 def test_view_cancelbooking_only_logged_in_requests_allowed(self): 

267 """ GIVEN ; WHEN POST /policorp/cancelbooking/1 logged out; THEN code 401 (unauthorized) should be returned """ 

268 request = self.factory.post(reverse('policorp:cancelbooking', kwargs={'bookingid': 1})) 

269 request.user = AnonymousUser() 

270 response = cancelbooking(request, 1) 

271 self.assertEqual(response.status_code, 401) 

272 

273 @tag('cancelbooking') 

274 def test_view_cancelbooking_only_user_in_booking_allowed(self): 

275 """ GIVEN a booking for user foo; WHEN POST /policorp/cancelbooking/1 logged in with user zoe; THEN code 401 (unauthorized) should be returned """ 

276 user1 = aux.createUser("foo", "foo@example.com", "example") 

277 availability1 = Availability.objects.get(pk=1) 

278 b1 = Booking.objects.book(availability1, user1) 

279 user2 = aux.createUser("zoe", "zoe@example.com", "example") 

280 request = self.factory.post(reverse('policorp:cancelbooking', kwargs={'bookingid': b1.id})) 

281 request.user = user2 

282 response = cancelbooking(request, b1.id) 

283 self.assertEqual(response.status_code, 401) 

284 

285 @tag('cancelbooking') 

286 def test_view_cancelbooking_returns_cancelled_booking(self): 

287 """ GIVEN a booking for user foo; WHEN POST /cancelbooking with user foo; THEN json with 1 cancelled booking should be returned""" 

288 user1 = aux.createUser("foo", "foo@example.com", "example") 

289 availability1 = Availability.objects.get(pk=1) 

290 b1 = Booking.objects.book(availability1, user1) 

291 

292 request = self.factory.post(reverse('policorp:cancelbooking', kwargs={'bookingid': b1.id})) 

293 request.user = user1 

294 response = cancelbooking(request, b1.id) 

295 

296 expected_json = Booking.objects.get(pk=b1.id).json() 

297 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_json) 

298 

299 @tag('cancelbooking') 

300 def test_view_cancelbooking_location_supervisor_can_cancel_a_booking(self): 

301 """ GIVEN a booking for user foo in a location supervised by bar; WHEN POST /cancelbooking with user bar; THEN json with 1 cancelled booking should be returned""" 

302 user1 = aux.createUser("foo", "foo@example.com", "example") 

303 supervisor = User.objects.create_supervisor("bar", "bar@example.com", "example") 

304 availability1 = Availability.objects.get(pk=1) 

305 availability1.where.assign_supervisor(supervisor) 

306 b1 = Booking.objects.book(availability1, user1) 

307 

308 request = self.factory.post(reverse('policorp:cancelbooking', kwargs={'bookingid': b1.id})) 

309 request.user = supervisor 

310 response = cancelbooking(request, b1.id) 

311 

312 expected_json = Booking.objects.get(pk=b1.id).json() 

313 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_json) 

314 

315 @tag('cancelbooking') 

316 def test_view_cancelbooking_supervisor_not_supervising_location_cannot_cancel_a_booking(self): 

317 """ GIVEN a booking for user foo in a location supervised by bar; WHEN POST /cancelbooking with user bar; THEN json with 1 cancelled booking should be returned""" 

318 user1 = aux.createUser("foo", "foo@example.com", "example") 

319 supervisor = User.objects.create_supervisor("bar", "bar@example.com", "example") 

320 availability1 = Availability.objects.get(pk=1) 

321 b1 = Booking.objects.book(availability1, user1) 

322 

323 request = self.factory.post(reverse('policorp:cancelbooking', kwargs={'bookingid': b1.id})) 

324 request.user = supervisor 

325 response = cancelbooking(request, b1.id) 

326 self.assertEqual(response.status_code, 401) 

327 

328 @tag('mysupervisedlocations') 

329 def test_view_mysupervisedlocations_returns_200(self): 

330 """ GIVEN; WHEN GET /mysupervisedlocation; THEN status code 200 is returned """ 

331 request = self.factory.get(reverse('policorp:mysupervisedlocations')) 

332 request.user = User.objects.create_supervisor('foo', 'foo@example.com', 'example') 

333 response = mysupervisedlocations(request) 

334 self.assertEqual(response.status_code, 200) 

335 

336 @tag('mysupervisedlocations') 

337 def test_view_mysupervisedlocations_post_not_allowed(self): 

338 """ GIVEN ; WHEN POST /mysupervisedlocations; THEN code 400 should be returned """ 

339 # Create an instance of a POST request. 

340 request = self.factory.post(reverse('policorp:mysupervisedlocations')) 

341 response = mysupervisedlocations(request) 

342 self.assertEqual(response.status_code, 400) 

343 

344 @tag('mysupervisedlocations') 

345 def test_view_mysupervisedlocations_only_logged_in_requests_allowed(self): 

346 """ GIVEN ; WHEN GET /mysupervisedlocations logged out; THEN code 401 (unauthorized) should be returned """ 

347 request = self.factory.get(reverse('policorp:mysupervisedlocations')) 

348 request.user = AnonymousUser() 

349 response = mysupervisedlocations(request) 

350 self.assertEqual(response.status_code, 401) 

351 

352 @tag('mysupervisedlocations') 

353 def test_view_mysupervisedlocations_only_logged_in_supervisors_requests_allowed(self): 

354 """ GIVEN ; WHEN GET /mysupervisedlocations logged in with a consumer user; THEN code 401 (unauthorized) should be returned """ 

355 request = self.factory.get(reverse('policorp:mysupervisedlocations')) 

356 request.user = aux.createUser('foo', 'foo@example.com', 'example') 

357 response = mysupervisedlocations(request) 

358 self.assertEqual(response.status_code, 401) 

359 

360 @tag('mysupervisedlocations') 

361 def test_view_mysupervisedlocations_returns_locations(self): 

362 """ GIVEN user foo that supervises a location; WHEN GET /mysupervisedlocation with user foo; THEN json with that location should be returned """ 

363 user = User.objects.create_supervisor('foo', 'foo@example.com', 'example') 

364 location = Location.objects.get(pk=1) 

365 location.assign_supervisor(user) 

366 request = self.factory.get(reverse('policorp:mysupervisedlocations')) 

367 request.user = user 

368 response = mysupervisedlocations(request) 

369 

370 expected_json = [location.json()] 

371 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_json) 

372 

373 @tag('mysupervisedlocations') 

374 def test_view_mysupervisedlocations_returns_locations_2(self): 

375 """ GIVEN user foo that supervises a location and user juan that supervises another location; WHEN GET /mysupervisedlocation with user foo; THEN json with that 1 location should be returned """ 

376 user = User.objects.create_supervisor('foo', 'foo@example.com', 'example') 

377 user2 = User.objects.create_supervisor('juan', 'juan@example.com', 'example') 

378 location = Location.objects.get(pk=1) 

379 location2 = Location.objects.get(pk=2) 

380 location.assign_supervisor(user) 

381 location2.assign_supervisor(user2) 

382 request = self.factory.get(reverse('policorp:mysupervisedlocations')) 

383 request.user = user 

384 response = mysupervisedlocations(request) 

385 

386 expected_json = [location.json()] 

387 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_json) 

388 

389 @tag('mysupervisedlocations') 

390 def test_view_mysupervisedlocations_returns_locations_3(self): 

391 """ GIVEN user foo that supervises 2 locations and user juan that supervises another location; WHEN GET /mysupervisedlocation with user foo; THEN json with 2 locations should be returned """ 

392 user = User.objects.create_supervisor('foo', 'foo@example.com', 'example') 

393 user2 = User.objects.create_supervisor('juan', 'juan@example.com', 'example') 

394 location = Location.objects.get(pk=1) 

395 location2 = Location.objects.get(pk=2) 

396 location3 = Location.objects.get(pk=3) 

397 location.assign_supervisor(user) 

398 location3.assign_supervisor(user) 

399 location2.assign_supervisor(user2) 

400 request = self.factory.get(reverse('policorp:mysupervisedlocations')) 

401 request.user = user 

402 response = mysupervisedlocations(request) 

403 

404 expected_json = [location.json(), location3.json()] 

405 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_json) 

406 

407 @tag('mysupervisedlocations') 

408 def test_view_mysupervisedlocations_returns_locations_ordered(self): 

409 """ GIVEN user foo that supervises 3 locations; WHEN GET /mysupervisedlocation with user foo; THEN json with 2 locations should be returned ordered ascending by location name """ 

410 user = User.objects.create_supervisor('foo', 'foo@example.com', 'example') 

411 locationBA = Location.objects.filter(name="Buenos Aires").first() 

412 locationC = Location.objects.filter(name="Córdoba").first() 

413 locationR = Location.objects.filter(name="Rosario").first() 

414 locationC.assign_supervisor(user) 

415 locationBA.assign_supervisor(user) 

416 locationR.assign_supervisor(user) 

417 request = self.factory.get(reverse('policorp:mysupervisedlocations')) 

418 request.user = user 

419 response = mysupervisedlocations(request) 

420 

421 expected_json = [locationBA.json(), locationC.json(), locationR.json()] 

422 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_json) 

423 

424 @tag('mysupervisedlocations') 

425 def test_view_mysupervisedlocations_returns_locations_ordered_2(self): 

426 """ GIVEN user foo that supervises 3 locations; WHEN GET /mysupervisedlocation with user foo; THEN json with 2 locations should be returned ordered ascending by location name """ 

427 user = User.objects.create_supervisor('foo', 'foo@example.com', 'example') 

428 locationBA = Location.objects.filter(name="Buenos Aires").first() 

429 locationC = Location.objects.filter(name="Córdoba").first() 

430 locationR = Location.objects.filter(name="Rosario").first() 

431 locationR.assign_supervisor(user) 

432 locationC.assign_supervisor(user) 

433 locationBA.assign_supervisor(user) 

434 request = self.factory.get(reverse('policorp:mysupervisedlocations')) 

435 request.user = user 

436 response = mysupervisedlocations(request) 

437 

438 expected_json = [locationBA.json(), locationC.json(), locationR.json()] 

439 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_json) 

440 

441 @tag('locationschedule') 

442 def test_view_locationschedule_returns_200(self): 

443 """ GIVEN; WHEN GET /locationschedule/1/20210102; THEN status code 200 is returned """ 

444 request = self.factory.get(reverse('policorp:locationschedule', kwargs={'locationid': 1, 'date': '20210102'})) 

445 user = User.objects.create_supervisor('foo', 'foo@example.com', 'example') 

446 request.user = user 

447 Location.objects.get(pk=1).assign_supervisor(user) 

448 response = locationschedule(request, 1, '20210102') 

449 self.assertEqual(response.status_code, 200) 

450 

451 @tag('locationschedule') 

452 def test_view_locationschedule_post_not_allowed(self): 

453 """ GIVEN ; WHEN POST /locationschedule/1/20210102; THEN code 400 should be returned """ 

454 # Create an instance of a POST request. 

455 request = self.factory.post(reverse('policorp:locationschedule', kwargs={'locationid': 1, 'date': '20210102'})) 

456 response = locationschedule(request, 1, '20210102') 

457 self.assertEqual(response.status_code, 400) 

458 

459 @tag('locationschedule') 

460 def test_view_locationschedule_only_logged_in_requests_allowed(self): 

461 """ GIVEN ; WHEN GET /locationschedule/1/20210102 logged out; THEN code 401 (unauthorized) should be returned """ 

462 request = self.factory.get(reverse('policorp:locationschedule', kwargs={'locationid': 1, 'date': '20210102'})) 

463 request.user = AnonymousUser() 

464 response = locationschedule(request, 1, '20210102') 

465 self.assertEqual(response.status_code, 401) 

466 

467 @tag('locationschedule') 

468 def test_view_locationschedule_only_logged_in_rolepervisor_requests_allowed(self): 

469 """ GIVEN ; WHEN GET /locationschedule/1/20210102 logged in with a non supervisor user; THEN code 401 (unauthorized) should be returned """ 

470 request = self.factory.get(reverse('policorp:locationschedule', kwargs={'locationid': 1, 'date': '20210102'})) 

471 request.user = aux.createUser('foo', 'foo@example.com', 'example') 

472 response = locationschedule(request, 1, '20210102') 

473 self.assertEqual(response.status_code, 401) 

474 

475 @tag('locationschedule') 

476 def test_view_locationschedule_only_requests_for_supervised_locations_allowed(self): 

477 """ GIVEN ; WHEN GET /locationschedule/1/20210102 for a location not supervised; THEN code 401 (unauthorized) should be returned """ 

478 request = self.factory.get(reverse('policorp:locationschedule', kwargs={'locationid': 1, 'date': '20210102'})) 

479 request.user = User.objects.create_supervisor('foo', 'foo@example.com', 'example') 

480 response = locationschedule(request, 1, '20210102') 

481 self.assertEqual(response.status_code, 401) 

482 

483 @tag('locationschedule') 

484 def test_view_locationschedule_return_1_booking(self): 

485 """ GIVEN 1 booking for 2021-01-02 at location 1; WHEN requesting schedule for 2021-01-02 at location 1; 1 json object is returned """ 

486 request = self.factory.get(reverse('policorp:locationschedule', kwargs={'locationid': 1, 'date': '20210102'})) 

487 user = User.objects.create_supervisor('foo', 'foo@example.com', 'example') 

488 request.user = user 

489 location = Location.objects.get(pk=1) 

490 location.assign_supervisor(user) 

491 booking = Booking.objects.book(Availability.objects.get(pk=1), aux.createUser('bar', 'bar@example.com', 'example')) 

492 response = locationschedule(request, 1, '20210102') 

493 expected_data = { 

494 'date': '2021-01-02', 

495 'location': location.json(), 

496 'schedule': [ 

497 {"booking": Booking.objects.get(id=booking.id).json()}, 

498 ] 

499 } 

500 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_data) 

501 

502 @tag('locationschedule') 

503 def test_view_locationschedule_return_1_booking_2(self): 

504 """ GIVEN 2 booking for 2021-01-02 and 2021-01-03 at location 3; WHEN requesting schedule for 2021-01-02 at location 1; 1 json object is returned """ 

505 request = self.factory.get(reverse('policorp:locationschedule', kwargs={'locationid': 3, 'date': '20210102'})) 

506 user = User.objects.create_supervisor('foo', 'foo@example.com', 'example') 

507 request.user = user 

508 location = Location.objects.get(pk=3) 

509 location.assign_supervisor(user) 

510 booker = aux.createUser('bar', 'bar@example.com', 'example') 

511 booking3 = Booking.objects.book(Availability.objects.get(pk=3), booker) 

512 booking2 = Booking.objects.book(Availability.objects.get(pk=2), booker) 

513 response = locationschedule(request, 3, '20210102') 

514 expected_data = { 

515 'date': '2021-01-02', 

516 'location': location.json(), 

517 'schedule': [ 

518 {"booking": Booking.objects.get(id=booking3.id).json()}, 

519 ] 

520 } 

521 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_data) 

522 

523 @tag('locationschedule') 

524 def test_view_locationschedule_return_1_booking_ordered_ascending(self): 

525 """ GIVEN 3 booking for 2021-01-04 at location 2; WHEN requesting schedule for 2021-01-04 at location 2; 3 json objects are returned in ascending order """ 

526 request = self.factory.get(reverse('policorp:locationschedule', kwargs={'locationid': 2, 'date': '20210104'})) 

527 user = User.objects.create_supervisor('foo', 'foo@example.com', 'example') 

528 request.user = user 

529 location = Location.objects.get(pk=2) 

530 location.assign_supervisor(user) 

531 booker4 = aux.createUser('bar', 'bar@example.com', 'example') 

532 booker5 = aux.createUser('zoe', 'zoe@example.com', 'example') 

533 booker6 = aux.createUser('kari', 'kari@example.com', 'example') 

534 booking5 = Booking.objects.book(Availability.objects.get(pk=5), booker5) 

535 booking6 = Booking.objects.book(Availability.objects.get(pk=6), booker6) 

536 booking4 = Booking.objects.book(Availability.objects.get(pk=4), booker4) 

537 response = locationschedule(request, 2, '20210104') 

538 expected_data = [Booking.objects.get(id=booking4.id).json(), Booking.objects.get(id=booking5.id).json(), Booking.objects.get(id=booking6.id).json()] 

539 expected_data = { 

540 'date': '2021-01-04', 

541 'location': location.json(), 

542 'schedule': [ 

543 {"booking": Booking.objects.get(id=booking4.id).json()}, 

544 {"booking": Booking.objects.get(id=booking5.id).json()}, 

545 {"booking": Booking.objects.get(id=booking6.id).json()}, 

546 ] 

547 } 

548 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_data) 

549 

550 @tag('locationschedule') 

551 def test_view_locationschedule_return_full_schedule(self): 

552 """ GIVEN 3 availabilities for 2021-01-04 at location 2, 1 booked; WHEN requesting schedule for 2021-01-04 at location 2; 1 booking and 2 availabilities should be returned """ 

553 request = self.factory.get(reverse('policorp:locationschedule', kwargs={'locationid': 2, 'date': '20210104'})) 

554 user = User.objects.create_supervisor('foo', 'foo@example.com', 'example') 

555 request.user = user 

556 location = Location.objects.get(pk=2) 

557 location.assign_supervisor(user) 

558 booker4 = aux.createUser('bar', 'bar@example.com', 'example') 

559 booking4 = Booking.objects.book(Availability.objects.get(pk=4), booker4) 

560 

561 expected_data = { 

562 'date': '2021-01-04', 

563 'location': location.json(), 

564 'schedule': [ 

565 {"booking": Booking.objects.get(id=booking4.id).json()}, 

566 {"availability": Availability.objects.get(pk=5).json()}, 

567 {"availability": Availability.objects.get(pk=6).json()} 

568 ] 

569 } 

570 

571 response = locationschedule(request, 2, '20210104') 

572 logging.debug(str(response.content, encoding='utf8')) 

573 self.assertJSONEqual(str(response.content, encoding='utf8'), expected_data) 

574 

575if __name__ == "__main__": 

576 unittest.main()