1from django.test import TestCase 

2from datetime import date 

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

4from policorp.lib.schedule import Schedule 

5from policorp.tests import aux 

6import json 

7 

8class TestSchedule(TestCase): 

9 

10 maxDiff = None 

11 

12 fixtures = ['testsdata.json'] 

13 

14 def test_create_schedule_date_and_location_and_availabilities_and_bookings(self): 

15 """ A schedule should contain a date, a location, an array of availabilities and an array of bookings """ 

16 

17 l = Location.objects.create_location('Córdoba') 

18 availabilities = [ 

19 Availability.objects.get(pk=4), 

20 Availability.objects.get(pk=6) 

21 ] 

22 bookings = [ 

23 Booking.objects.book( 

24 Availability.objects.get(pk=5), 

25 aux.createUser("foo", "foo@example.com", "example") 

26 ) 

27 ] 

28 sch = Schedule(date.today(), l, availabilities, bookings) 

29 self.assertEqual(sch.date, date.today()) 

30 self.assertEqual(sch.location, l) 

31 self.assertEqual(sch.availabilities, availabilities) 

32 self.assertEqual(sch.bookings, bookings) 

33 

34 def test_get_schedule_sorted_array_1(self): 

35 """ GIVEN a schedule; WHEN it is requested; THEN it is a sorted ascending array by date """ 

36 

37 l = Location.objects.create_location('Córdoba') 

38 availabilities = [ 

39 Availability.objects.get(pk=4), 

40 Availability.objects.get(pk=6) 

41 ] 

42 bookings = [ 

43 Booking.objects.book( 

44 Availability.objects.get(pk=5), 

45 aux.createUser("foo", "foo@example.com", "example") 

46 ) 

47 ] 

48 sch = Schedule(date.today(), l, availabilities, bookings) 

49 expected_array = [ 

50 availabilities[0], 

51 bookings[0], 

52 availabilities[1] 

53 ] 

54 self.assertEqual(sch.toSortedScheduleArray(), expected_array) 

55 

56 def test_get_schedule_sorted_array_booking_first_when_equals(self): 

57 """ GIVEN a schedule; WHEN it is requested; THEN it is a sorted ascending array by date """ 

58 

59 availabilities = [ 

60 Availability.objects.get(pk=4), 

61 Availability.objects.get(pk=6) 

62 ] 

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

64 l = Location.objects.create_location('Córdoba') 

65 t = Task.objects.get(pk=2) 

66 new_availability = Availability.objects.create_availability(Availability.objects.get(pk=4).when, l, t) 

67 bookings = [ 

68 Booking.objects.book( 

69 Availability.objects.get(pk=5), 

70 user 

71 ), 

72 Booking.objects.book( 

73 new_availability, 

74 user 

75 ) 

76 ] 

77 sch = Schedule(date.today(), l, availabilities, bookings) 

78 expected_array = [ 

79 bookings[1], 

80 availabilities[0], 

81 bookings[0], 

82 availabilities[1] 

83 ] 

84 self.assertEqual(sch.toSortedScheduleArray(), expected_array) 

85 

86 def test_get_schedule_sorted_array_two_equal_availabilities(self): 

87 """ GIVEN a schedule; WHEN it is requested; THEN it is a sorted ascending array by date """ 

88 

89 l = Location.objects.create_location('Córdoba') 

90 t = Task.objects.get(pk=2) 

91 new_availability = Availability.objects.create_availability(Availability.objects.get(pk=4).when, l, t) 

92 availabilities = [ 

93 Availability.objects.get(pk=4), 

94 Availability.objects.get(pk=6), 

95 new_availability 

96 ] 

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

98 bookings = [ 

99 Booking.objects.book( 

100 Availability.objects.get(pk=5), 

101 user 

102 ) 

103 ] 

104 sch = Schedule(date.today(), l, availabilities, bookings) 

105 expected_array = [ 

106 availabilities[0], 

107 availabilities[2], 

108 bookings[0], 

109 availabilities[1] 

110 ] 

111 self.assertEqual(sch.toSortedScheduleArray(), expected_array) 

112 

113 def test_get_schedule_sorted_array_two_equal_bookings(self): 

114 """ GIVEN a schedule; WHEN it is requested; THEN it is a sorted ascending array by date """ 

115 

116 l = Location.objects.create_location('Córdoba') 

117 t = Task.objects.get(pk=2) 

118 new_availability = Availability.objects.create_availability(Availability.objects.get(pk=4).when, l, t) 

119 availabilities = [ 

120 Availability.objects.get(pk=6), 

121 Availability.objects.get(pk=5) 

122 ] 

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

124 bookings = [ 

125 Booking.objects.book( 

126 Availability.objects.get(pk=4), 

127 user 

128 ), 

129 Booking.objects.book( 

130 new_availability, 

131 user 

132 ), 

133 ] 

134 sch = Schedule(date.today(), l, availabilities, bookings) 

135 expected_array = [ 

136 bookings[0], 

137 bookings[1], 

138 availabilities[1], 

139 availabilities[0] 

140 ] 

141 self.assertEqual(sch.toSortedScheduleArray(), expected_array) 

142 

143 def test_get_schedule_sorted_array_2(self): 

144 """ GIVEN a schedule; WHEN it is requested; THEN it is a sorted ascending array by date """ 

145 

146 l = Location.objects.create_location('Córdoba') 

147 t = Task.objects.get(pk=2) 

148 new_availability = Availability.objects.create_availability(Availability.objects.get(pk=4).when, l, t) 

149 availabilities = [ 

150 Availability.objects.get(pk=5), 

151 Availability.objects.get(pk=6) 

152 

153 ] 

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

155 bookings = [ 

156 Booking.objects.book( 

157 Availability.objects.get(pk=4), 

158 user 

159 ) 

160 ] 

161 sch = Schedule(date.today(), l, availabilities, bookings) 

162 expected_array = [ 

163 bookings[0], 

164 availabilities[0], 

165 availabilities[1] 

166 ] 

167 self.assertEqual(sch.toSortedScheduleArray(), expected_array) 

168 

169 def test_get_schedule_sorted_json(self): 

170 l = Location.objects.create_location('Córdoba') 

171 t = Task.objects.get(pk=2) 

172 new_availability = Availability.objects.create_availability(Availability.objects.get(pk=4).when, l, t) 

173 availabilities = [ 

174 Availability.objects.get(pk=6), 

175 Availability.objects.get(pk=5) 

176 ] 

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

178 bookings = [ 

179 Booking.objects.book( 

180 Availability.objects.get(pk=4), 

181 user 

182 ), 

183 Booking.objects.book( 

184 new_availability, 

185 user 

186 ), 

187 ] 

188 sch = Schedule(date.today(), l, availabilities, bookings) 

189 expected_json = { 

190 'date': sch.date, 

191 'location': sch.location.json(), 

192 'schedule': [ 

193 {'booking': bookings[0].json()}, 

194 {'booking': bookings[1].json()}, 

195 {'availability': availabilities[1].json()}, 

196 {'availability': availabilities[0].json()} 

197 ] 

198 } 

199 self.assertJSONEqual(json.dumps(sch.json()), json.dumps(expected_json, cls=aux.DateTimeEncoder)) 

200 

201 def test_get_schedule_sorted_json_2(self): 

202 l = Location.objects.create_location('Córdoba') 

203 t = Task.objects.get(pk=2) 

204 new_availability = Availability.objects.create_availability(Availability.objects.get(pk=4).when, l, t) 

205 availabilities = [ 

206 Availability.objects.get(pk=5), 

207 Availability.objects.get(pk=6) 

208 

209 ] 

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

211 bookings = [ 

212 Booking.objects.book( 

213 Availability.objects.get(pk=4), 

214 user 

215 ) 

216 ] 

217 sch = Schedule(date.today(), l, availabilities, bookings) 

218 expected_json = { 

219 'date': sch.date, 

220 'location': sch.location.json(), 

221 'schedule': [ 

222 {'booking': bookings[0].json()}, 

223 {'availability': availabilities[0].json()}, 

224 {'availability': availabilities[1].json()} 

225 ] 

226 } 

227 self.assertJSONEqual(json.dumps(sch.json()), json.dumps(expected_json, cls=aux.DateTimeEncoder)) 

228 

229 

230if __name__ == "__main__": 

231 unittest.main()