1from django.test import TestCase 

2from datetime import datetime, timedelta, time 

3from django.utils import timezone 

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

5from policorp.tests import aux 

6import json 

7 

8class TestAvailability(TestCase): 

9 

10 def test_get_availability_all(self): 

11 """ GIVEN 1 availability; WHEN requesting all availabilities; THEN 1 availability should be returned """ 

12 

13 loc_name = "Buenos Aires" 

14 l1 = Location.objects.create_location(loc_name) 

15 task_name = "Device Installation" 

16 t1 = Task.objects.create_task(task_name, 30) 

17 a1 = Availability.objects.create_availability(datetime.now(timezone.utc), l1, t1) 

18 self.assertEqual(len(Availability.objects.get_all()), 1) 

19 

20 def test_get_availability_all_ordered_by_date_ascendant_1(self): 

21 """ GIVEN 3 availabilities; WHEN requesting all availabilities; THEN 3 availabilities should be returned in ascendant order by schedule date """ 

22 

23 loc_name = "Buenos Aires" 

24 l1 = Location.objects.create_location(loc_name) 

25 task_name = "Device Installation" 

26 t1 = Task.objects.create_task(task_name, 30) 

27 now = datetime.now(timezone.utc) 

28 a3 = Availability.objects.create_availability(now + timedelta(days = 3), l1, t1) 

29 a1 = Availability.objects.create_availability(now + timedelta(days = 1), l1, t1) 

30 a2 = Availability.objects.create_availability(now + timedelta(days = 2), l1, t1) 

31 self.assertEqual(len(Availability.objects.get_all()), 3) 

32 self.assertEqual(Availability.objects.get_all()[0], a1) 

33 self.assertEqual(Availability.objects.get_all()[1], a2) 

34 self.assertEqual(Availability.objects.get_all()[2], a3) 

35 

36 def test_get_availability_all_ordered_by_date_ascendant_2(self): 

37 """ GIVEN 3 availabilities, 1 booked; WHEN requesting all availabilities; THEN 2 availabilities should be returned in ascendant order by schedule date """ 

38 

39 loc_name = "Buenos Aires" 

40 l1 = Location.objects.create_location(loc_name) 

41 task_name = "Device Installation" 

42 t1 = Task.objects.create_task(task_name, 30) 

43 now = datetime.now(timezone.utc) 

44 a3 = Availability.objects.create_availability(now + timedelta(days = 3), l1, t1) 

45 a1 = Availability.objects.create_availability(now + timedelta(days = 1), l1, t1) 

46 a2 = Availability.objects.create_availability(now + timedelta(days = 2), l1, t1) 

47 a2.book() 

48 self.assertEqual(len(Availability.objects.get_all()), 2) 

49 self.assertIn(a1, Availability.objects.get_all()) 

50 self.assertIn(a3, Availability.objects.get_all()) 

51 self.assertTrue(Availability.objects.get_all()[0].when < Availability.objects.get_all()[1].when) 

52 

53 def test_get_availability_all_with_location(self): 

54 """GIVEN 1 availability at Buenos Aires, tomorrow; WHEN requesting all availabilities; THEN 1 availability should be returned at Buenos Aires, tomorrow""" 

55 

56 now = datetime.now(timezone.utc) 

57 tomorrow = now + timedelta(days = 1) 

58 loc_name = "Buenos Aires" 

59 l1 = Location.objects.create_location(loc_name) 

60 task_name = "Device Installation" 

61 t1 = Task.objects.create_task(task_name, 30) 

62 a1 = Availability.objects.create_availability(tomorrow, l1, t1) 

63 self.assertEqual(len(Availability.objects.get_all()), 1) 

64 availability = Availability.objects.get_all()[0] 

65 self.assertEqual(availability.when, tomorrow) 

66 self.assertEqual(availability.where.name, loc_name) 

67 

68 def test_get_availability_all_by_task(self): 

69 """ GIVEN 1 availability at Cordoba, tomorrow, for "Device Installation", WHEN requesting all availabilities for "Device Installation", THEN 1 availability should be returned at Cordoba, tomorrow for "Device Installation" """ 

70 

71 now = datetime.now(timezone.utc) 

72 tomorrow = now + timedelta(days = 1) 

73 loc_name = "Cordoba" 

74 l1 = Location.objects.create_location(loc_name) 

75 task_name = "Device Installation" 

76 t1 = Task.objects.create_task(task_name, 30) 

77 a1 = Availability.objects.create_availability(tomorrow, l1, t1) 

78 self.assertEqual(len(Availability.objects.get_all_by_task(task_name)), 1) 

79 availability = Availability.objects.get_all_by_task(task_name)[0] 

80 self.assertEqual(availability.when, tomorrow) 

81 self.assertEqual(availability.where.name, loc_name) 

82 self.assertEqual(availability.what.name, task_name) 

83 

84 def test_get_availability_all_by_task_ordered_by_date_ascendant_1(self): 

85 """ GIVEN 3 availabilities, 1 for Device Installation, 2 for Repair; WHEN requesting all availabilities for "Repair"; THEN 2 availabilities should be returned in ascendant order by schedule date for task "Repair" """ 

86 

87 loc_name = "Buenos Aires" 

88 l1 = Location.objects.create_location(loc_name) 

89 install = Task.objects.create_task("Device Installation", 30) 

90 repair = Task.objects.create_task("Repair", 30) 

91 now = datetime.now(timezone.utc) 

92 a3 = Availability.objects.create_availability(now + timedelta(days = 3), l1, install) 

93 a2 = Availability.objects.create_availability(now + timedelta(days = 2), l1, repair) 

94 a1 = Availability.objects.create_availability(now + timedelta(days = 1), l1, repair) 

95 self.assertEqual(len(Availability.objects.get_all_by_task(repair.name)), 2) 

96 self.assertIn(a1, Availability.objects.get_all_by_task(repair.name)) 

97 self.assertIn(a2, Availability.objects.get_all_by_task(repair.name)) 

98 self.assertTrue(Availability.objects.get_all_by_task(repair.name)[0].when < Availability.objects.get_all_by_task(repair.name)[1].when) 

99 self.assertEqual(Availability.objects.get_all_by_task(repair.name)[0].what, repair) 

100 self.assertEqual(Availability.objects.get_all_by_task(repair.name)[1].what, repair) 

101 

102 def test_get_availability_all_by_task_ordered_by_date_ascendant_2(self): 

103 """ GIVEN 3 availabilities, 1 for Device Installation, 2 for Repair; WHEN requesting all availabilities for "Repair"; THEN 2 availabilities should be returned in ascendant order by schedule date for task "Repair" """ 

104 

105 loc_name = "Buenos Aires" 

106 l1 = Location.objects.create_location(loc_name) 

107 install = Task.objects.create_task("Device Installation", 30) 

108 repair = Task.objects.create_task("Repair", 30) 

109 now = datetime.now(timezone.utc) 

110 a3 = Availability.objects.create_availability(now + timedelta(days = 3), l1, install) 

111 a2 = Availability.objects.create_availability(now + timedelta(days = 1), l1, repair) 

112 a1 = Availability.objects.create_availability(now + timedelta(days = 2), l1, repair) 

113 self.assertEqual(len(Availability.objects.get_all_by_task(repair.name)), 2) 

114 self.assertIn(a1, Availability.objects.get_all_by_task(repair.name)) 

115 self.assertIn(a2, Availability.objects.get_all_by_task(repair.name)) 

116 self.assertTrue(Availability.objects.get_all_by_task(repair.name)[0].when < Availability.objects.get_all_by_task(repair.name)[1].when) 

117 self.assertEqual(Availability.objects.get_all_by_task(repair.name)[0].what, repair) 

118 self.assertEqual(Availability.objects.get_all_by_task(repair.name)[1].what, repair) 

119 

120 def test_get_availability_all_by_task_ordered_by_date_ascendant_3(self): 

121 """ GIVEN 3 availabilities, 1 for Device Installation, 2 for Repair, 1 Repair is boooked; WHEN requesting all availabilities for "Repair"; THEN 1 availabilities should be returned in ascendant order by schedule date for task "Repair" """ 

122 

123 loc_name = "Buenos Aires" 

124 l1 = Location.objects.create_location(loc_name) 

125 install = Task.objects.create_task("Device Installation", 30) 

126 repair = Task.objects.create_task("Repair", 30) 

127 now = datetime.now(timezone.utc) 

128 a3 = Availability.objects.create_availability(now + timedelta(days = 3), l1, install) 

129 a2 = Availability.objects.create_availability(now + timedelta(days = 2), l1, repair) 

130 a1 = Availability.objects.create_availability(now + timedelta(days = 1), l1, repair) 

131 a1.book() 

132 self.assertEqual(len(Availability.objects.get_all_by_task(repair.name)), 1) 

133 self.assertEqual(Availability.objects.get_all_by_task(repair.name)[0], a2) 

134 self.assertEqual(Availability.objects.get_all_by_task(repair.name)[0].what, repair) 

135 

136 def test_availability_serialize(self): 

137 loc_name = "Córdoba" 

138 l1 = Location.objects.create_location(loc_name) 

139 task_name = "Device Installation" 

140 t1 = Task.objects.create_task(task_name, 30) 

141 now = datetime.now(timezone.utc) 

142 a1 = Availability.objects.create_availability(now + timedelta(days = 3), l1, t1) 

143 

144 expected = {'id': 1, 'when': (now + timedelta(days = 3)).isoformat(), 'where': l1.json(), 'what': t1.json()} 

145 self.assertEqual(a1.json()["when"], (now + timedelta(days = 3)).isoformat()) 

146 self.assertJSONEqual(json.dumps(a1.json()["where"]), json.dumps(l1.json())) 

147 self.assertJSONEqual(json.dumps(a1.json()["what"]), json.dumps(t1.json())) 

148 

149 def test_availability_booked_initially_false(self): 

150 """ New availability should be not booked by default """ 

151 loc_name = "Córdoba" 

152 l1 = Location.objects.create_location(loc_name) 

153 task_name = "Device Installation" 

154 t1 = Task.objects.create_task(task_name, 30) 

155 now = datetime.now(timezone.utc) 

156 a1 = Availability.objects.create_availability(now + timedelta(days = 3), l1, t1) 

157 

158 self.assertFalse(a1.booked) 

159 

160 def test_availability_book(self): 

161 """ Given an availabiliy, when booked, then it is marked as booked """ 

162 loc_name = "Córdoba" 

163 l1 = Location.objects.create_location(loc_name) 

164 task_name = "Device Installation" 

165 t1 = Task.objects.create_task(task_name, 30) 

166 now = datetime.now(timezone.utc) 

167 a1 = Availability.objects.create_availability(now + timedelta(days = 3), l1, t1) 

168 a1.book() 

169 

170 self.assertTrue(a1.booked) 

171 

172 def test_availability_free(self): 

173 """ GIVEN a booked availabiliy; WHEN freed; THEN it is marked as not booked """ 

174 loc_name = "Córdoba" 

175 l1 = Location.objects.create_location(loc_name) 

176 task_name = "Device Installation" 

177 t1 = Task.objects.create_task(task_name, 30) 

178 now = datetime.now(timezone.utc) 

179 a1 = Availability.objects.create_availability(now + timedelta(days = 3), l1, t1) 

180 a1.book() 

181 self.assertTrue(a1.booked) 

182 a1.free() 

183 self.assertFalse(a1.booked) 

184 

185 def test_get_availability_next_by_task_and_date(self): 

186 """ GIVEN 1 availability at Cordoba, tomorrow, for "Device Installation"; WHEN requesting next availabilities for "Device Installation" for tomorrow, THEN 1 availability should be returned at Cordoba, tomorrow for "Device Installation" """ 

187 

188 now = datetime.now(timezone.utc) 

189 tomorrow = now + timedelta(days = 1) 

190 loc_name = "Cordoba" 

191 l1 = Location.objects.create_location(loc_name) 

192 task_name = "Device Installation" 

193 t1 = Task.objects.create_task(task_name, 30) 

194 a1 = Availability.objects.create_availability(tomorrow, l1, t1) 

195 result = Availability.objects.get_next_by_task_and_date(task_name, tomorrow) 

196 self.assertEqual(len(result), 1) 

197 availability = result[0] 

198 self.assertEqual(availability.when, tomorrow) 

199 self.assertEqual(availability.where.name, loc_name) 

200 self.assertEqual(availability.what.name, task_name) 

201 

202 def test_get_availability_next_by_task_and_date_no_availabilities_at_date(self): 

203 """ GIVEN 1 availability at Cordoba, tomorrow + 1, for "Device Installation"; WHEN requesting next availabilities for "Device Installation" for today, THEN 0 availability should be returned """ 

204 

205 now = datetime.now(timezone.utc) 

206 tomorrow = now + timedelta(days = 1) 

207 loc_name = "Cordoba" 

208 l1 = Location.objects.create_location(loc_name) 

209 task_name = "Device Installation" 

210 t1 = Task.objects.create_task(task_name, 30) 

211 a1 = Availability.objects.create_availability(tomorrow + timedelta(days = 1), l1, t1) 

212 result = Availability.objects.get_next_by_task_and_date(task_name, tomorrow) 

213 self.assertEqual(len(result), 0) 

214 

215 def test_get_availability_next_by_task_and_date_no_more_availabilities_today(self): 

216 """ GIVEN 1 availability at Cordoba, now - 30min, for "Device Installation"; WHEN requesting next availabilities for "Device Installation" for today, THEN 0 availability should be returned """ 

217 

218 now = datetime.now(timezone.utc) 

219 loc_name = "Cordoba" 

220 l1 = Location.objects.create_location(loc_name) 

221 task_name = "Device Installation" 

222 t1 = Task.objects.create_task(task_name, 60) 

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

224 result = Availability.objects.get_next_by_task_and_date(task_name, now) 

225 self.assertEqual(len(result), 0) 

226 

227 def test_get_availability_next_by_task_and_date_1_availability_today(self): 

228 """ GIVEN 1 availability at Cordoba, now + 30min, for "Device Installation"; WHEN requesting next availabilities for "Device Installation" for today, THEN 1 availability should be returned """ 

229 

230 now = datetime.now(timezone.utc) 

231 loc_name = "Cordoba" 

232 l1 = Location.objects.create_location(loc_name) 

233 task_name = "Device Installation" 

234 t1 = Task.objects.create_task(task_name, 60) 

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

236 result = Availability.objects.get_next_by_task_and_date(task_name, now) 

237 self.assertEqual(len(result), 1) 

238 availability = result[0] 

239 self.assertEqual(availability.when, now + timedelta(minutes = 30)) 

240 self.assertEqual(availability.where.name, loc_name) 

241 self.assertEqual(availability.what.name, task_name) 

242 

243 def test_get_availability_next_by_task_and_date_2_availability_today_ordered_ascending(self): 

244 """ GIVEN 2 availabilities at Cordoba, now + 30min and now + 60min, for "Device Installation"; WHEN requesting next availabilities for "Device Installation" for today, THEN 2 availabilities should be returned """ 

245 

246 now = datetime.now(timezone.utc) 

247 loc_name = "Cordoba" 

248 l1 = Location.objects.create_location(loc_name) 

249 task_name = "Device Installation" 

250 t1 = Task.objects.create_task(task_name, 60) 

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

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

253 result = Availability.objects.get_next_by_task_and_date(task_name, now) 

254 self.assertEqual(len(result), 2) 

255 availability = result[0] 

256 self.assertEqual(availability.when, now + timedelta(minutes = 30)) 

257 self.assertEqual(availability.where.name, loc_name) 

258 self.assertEqual(availability.what.name, task_name) 

259 availability = result[1] 

260 self.assertEqual(availability.when, now + timedelta(minutes = 60)) 

261 self.assertEqual(availability.where.name, loc_name) 

262 self.assertEqual(availability.what.name, task_name) 

263 

264 def test_get_availability_next_by_task_and_date_1_availability_today2(self): 

265 """ GIVEN 2 availabilities at Cordoba, now + 30min and now - 60min, for "Device Installation"; WHEN requesting next availabilities for "Device Installation" for today, THEN 1 availability should be returned for now + 30min""" 

266 

267 now = datetime.now(timezone.utc) 

268 loc_name = "Cordoba" 

269 l1 = Location.objects.create_location(loc_name) 

270 task_name = "Device Installation" 

271 t1 = Task.objects.create_task(task_name, 60) 

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

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

274 result = Availability.objects.get_next_by_task_and_date(task_name, now) 

275 self.assertEqual(len(result), 1) 

276 availability = result[0] 

277 self.assertEqual(availability.when, now + timedelta(minutes = 30)) 

278 self.assertEqual(availability.where.name, loc_name) 

279 self.assertEqual(availability.what.name, task_name) 

280 

281 def test_get_availability_next_by_task_and_date_none(self): 

282 """ GIVEN 2 availabilities at Cordoba, [day after tomorrow at 12:30] and [day after tomorrow at 11:00]; WHEN requesting next availabilities for "Device Installation" without a date; THEN 2 availabilites should be returned """ 

283 

284 afterTomorrow = datetime.now(timezone.utc) + timedelta(days=2) 

285 time1 = time(hour=11, minute=00, tzinfo=timezone.utc) 

286 time2 = time(hour=12, minute=30, tzinfo=timezone.utc) 

287 loc_name = "Cordoba" 

288 l1 = Location.objects.create_location(loc_name) 

289 task_name = "Device Installation" 

290 t1 = Task.objects.create_task(task_name, 60) 

291 a1 = Availability.objects.create_availability(datetime.combine(afterTomorrow, time1), l1, t1) 

292 a2 = Availability.objects.create_availability(datetime.combine(afterTomorrow, time2), l1, t1) 

293 result = Availability.objects.get_next_by_task_and_date(task_name, None) 

294 self.assertEqual(len(result), 2) 

295 availability = result[0] 

296 self.assertEqual(availability.when, datetime.combine(afterTomorrow, time1)) 

297 self.assertEqual(availability.where.name, loc_name) 

298 self.assertEqual(availability.what.name, task_name) 

299 availability = result[1] 

300 self.assertEqual(availability.when, datetime.combine(afterTomorrow, time2)) 

301 self.assertEqual(availability.where.name, loc_name) 

302 self.assertEqual(availability.what.name, task_name) 

303 

304 def test_get_availability_next_by_task_and_date_none_2(self): 

305 """ GIVEN 2 availabilities at Cordoba, [yesterday + 30min] and [day after tomorrow - 60min]; WHEN requesting next availabilities for "Device Installation" without a date; THEN 1 availability should be returned (day after tomorrow)""" 

306 

307 now = datetime.now(timezone.utc) 

308 loc_name = "Cordoba" 

309 l1 = Location.objects.create_location(loc_name) 

310 task_name = "Device Installation" 

311 t1 = Task.objects.create_task(task_name, 60) 

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

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

314 result = Availability.objects.get_next_by_task_and_date(task_name, None) 

315 self.assertEqual(len(result), 1) 

316 availability = result[0] 

317 self.assertEqual(availability.when, now + timedelta(days=2, minutes = -60)) 

318 self.assertEqual(availability.where.name, loc_name) 

319 self.assertEqual(availability.what.name, task_name) 

320 

321 def test_get_availability_next_by_task_and_date_none_3(self): 

322 """ GIVEN 2 availabilities at Cordoba, [now - 60min]; WHEN requesting next availabilities for "Device Installation" without a date; THEN 0 availabilities should be returned """ 

323 

324 now = datetime.now(timezone.utc) 

325 loc_name = "Cordoba" 

326 l1 = Location.objects.create_location(loc_name) 

327 task_name = "Device Installation" 

328 t1 = Task.objects.create_task(task_name, 60) 

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

330 result = Availability.objects.get_next_by_task_and_date(task_name, None) 

331 self.assertEqual(len(result), 0) 

332 

333 def test_get_availability_next_by_task_and_date_none_4(self): 

334 """ GIVEN 1 availability at Cordoba, [now + 60min]; WHEN requesting next availabilities for "Device Installation" without a date; THEN 1 availability should be returned """ 

335 

336 now = datetime.now(timezone.utc) 

337 loc_name = "Cordoba" 

338 l1 = Location.objects.create_location(loc_name) 

339 task_name = "Device Installation" 

340 t1 = Task.objects.create_task(task_name, 60) 

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

342 result = Availability.objects.get_next_by_task_and_date(task_name, None) 

343 self.assertEqual(len(result), 1) 

344 availability = result[0] 

345 self.assertEqual(availability.when, now + timedelta(minutes = 60)) 

346 self.assertEqual(availability.where.name, loc_name) 

347 self.assertEqual(availability.what.name, task_name) 

348 

349 def test_get_availability_next_by_task_and_date_none_5(self): 

350 """ GIVEN 2 availabilities at Cordoba, [now - 30min] and [now + 60min]; WHEN requesting next availabilities for "Device Installation" without a date; THEN 1 availability should be returned [now + 60min] """ 

351 

352 now = datetime.now(timezone.utc) 

353 loc_name = "Cordoba" 

354 l1 = Location.objects.create_location(loc_name) 

355 task_name = "Device Installation" 

356 t1 = Task.objects.create_task(task_name, 60) 

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

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

359 result = Availability.objects.get_next_by_task_and_date(task_name, None) 

360 self.assertEqual(len(result), 1) 

361 availability = result[0] 

362 self.assertEqual(availability.when, now + timedelta(minutes = 60)) 

363 self.assertEqual(availability.where.name, loc_name) 

364 self.assertEqual(availability.what.name, task_name) 

365 

366 def test_get_availability_next_by_task_and_date_none_6(self): 

367 """ GIVEN 2 availabilities at Cordoba, [now - 30min] and [tomorrow + 60min]; WHEN requesting next availabilities for "Device Installation" without a date; THEN 1 availability should be returned tomorrow + 60min] """ 

368 

369 now = datetime.now(timezone.utc) 

370 loc_name = "Cordoba" 

371 l1 = Location.objects.create_location(loc_name) 

372 task_name = "Device Installation" 

373 t1 = Task.objects.create_task(task_name, 60) 

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

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

376 result = Availability.objects.get_next_by_task_and_date(task_name, None) 

377 self.assertEqual(len(result), 1) 

378 availability = result[0] 

379 self.assertEqual(availability.when, now + timedelta(days=1, minutes = 60)) 

380 self.assertEqual(availability.where.name, loc_name) 

381 self.assertEqual(availability.what.name, task_name) 

382 

383 def test_get_availability_next_by_task_and_date_none_7(self): 

384 """ GIVEN 3 availabilities at Cordoba, [now - 30min],[tomorrow + 60min],[day after tomorrow + 60min]; WHEN requesting next availabilities for "Device Installation" without a date; THEN 1 availability should be returned tomorrow + 60min] """ 

385 

386 now = datetime.now(timezone.utc) 

387 l1 = Location.objects.create_location("Cordoba") 

388 t1 = Task.objects.create_task("Device Installation", 60) 

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

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

391 a2 = Availability.objects.create_availability(now + timedelta(days=2, minutes = 60), l1, t1) 

392 result = Availability.objects.get_next_by_task_and_date(t1.name, None) 

393 self.assertEqual(len(result), 1) 

394 availability = result[0] 

395 self.assertEqual(availability.when, now + timedelta(days=1, minutes = 60)) 

396 self.assertEqual(availability.where.name, l1.name) 

397 self.assertEqual(availability.what.name, t1.name) 

398 

399 def test_get_availability_all_by_location_and_date_tomorrow(self): 

400 """ GIVEN 1 availability at Cordoba, tomorrow, for "Device Installation", WHEN requesting all availabilities for "Device Installation" for tomorrow at Córdoba, THEN 1 availability should be returned at Cordoba, tomorrow for "Device Installation" """ 

401 

402 now = datetime.now(timezone.utc) 

403 tomorrow = now + timedelta(days = 1) 

404 l1 = Location.objects.create_location("Cordoba") 

405 t1 = Task.objects.create_task("Device Installation", 30) 

406 a1 = Availability.objects.create_availability(tomorrow, l1, t1) 

407 availabilities = Availability.objects.get_all_by_location_and_date(l1, tomorrow) 

408 self.assertEqual(len(availabilities), 1) 

409 availability = availabilities[0] 

410 self.assertEqual(availability.when, tomorrow) 

411 self.assertEqual(availability.where.name, l1.name) 

412 self.assertEqual(availability.what.name, t1.name) 

413 

414 def test_get_availability_all_by_location_and_date_anotherdate(self): 

415 """ GIVEN 1 availability at Cordoba, tomorrow, for "Device Installation", WHEN requesting all availabilities for "Device Installation" for today at Córdoba, THEN 0 availabilities should be returned """ 

416 

417 now = datetime.now(timezone.utc) 

418 tomorrow = now + timedelta(days = 1) 

419 loc_name = "Cordoba" 

420 l1 = Location.objects.create_location(loc_name) 

421 task_name = "Device Installation" 

422 t1 = Task.objects.create_task(task_name, 30) 

423 a1 = Availability.objects.create_availability(tomorrow, l1, t1) 

424 availabilities = Availability.objects.get_all_by_location_and_date(l1, now) 

425 self.assertEqual(len(availabilities), 0) 

426 

427 def test_get_availability_all_by_location_and_date_tomorrow_elsewhere(self): 

428 """ GIVEN 1 availability at Cordoba, tomorrow, for "Device Installation", WHEN requesting all availabilities for "Device Installation" for today at Córdoba, THEN 0 availabilities should be returned """ 

429 

430 now = datetime.now(timezone.utc) 

431 tomorrow = now + timedelta(days = 1) 

432 l1 = Location.objects.create_location("Cordoba") 

433 l2 = Location.objects.create_location("Rosario") 

434 t1 = Task.objects.create_task("Device Installation", 30) 

435 a1 = Availability.objects.create_availability(tomorrow, l2, t1) 

436 availabilities = Availability.objects.get_all_by_location_and_date(l1, tomorrow) 

437 self.assertEqual(len(availabilities), 0)