test_ita_protocol.py 18 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491
  1. import copy
  2. import json
  3. import unittest
  4. from datetime import date, time
  5. from plugins.ita_plugin import (
  6. MAX_LOOKAHEAD_MONTHS,
  7. MAX_PROTOCOL_ITEMS,
  8. MAX_PROTOCOL_PAYLOAD_CHARS,
  9. CalendarDay,
  10. ItaCapability,
  11. ItaProtocolError,
  12. SlotCandidate,
  13. available_calendar_days,
  14. available_slot_candidates,
  15. decode_double_json_array,
  16. month_starts,
  17. parse_calendar_availability,
  18. parse_time_slots,
  19. resolve_route_config,
  20. )
  21. def double_json(items):
  22. return json.dumps(json.dumps(items, separators=(",", ":")))
  23. def availability_item(day, slots_free, slots_remaining):
  24. return {
  25. "DateLibere": day,
  26. "SlotLiberi": slots_free,
  27. "SlotRimanenti": slots_remaining,
  28. }
  29. def time_value(hours, minutes, *, seconds=0, milliseconds=0):
  30. return {
  31. "Hours": hours,
  32. "Minutes": minutes,
  33. "Seconds": seconds,
  34. "Milliseconds": milliseconds,
  35. }
  36. def slot_item(
  37. day,
  38. start,
  39. end,
  40. slots_free,
  41. slots_remaining,
  42. daily_id,
  43. ):
  44. return {
  45. "Data": day,
  46. "OrarioInizioFascia": time_value(*start),
  47. "OrarioFineFascia": time_value(*end),
  48. "SlotLiberi": slots_free,
  49. "SlotRimanenti": slots_remaining,
  50. "IDCalendarioServizioGiornaliero": daily_id,
  51. }
  52. def live_route():
  53. return {
  54. "service_id": 100,
  55. "capability": "single_schengen_tourism",
  56. "calendar_scan": {"lookahead_months": 3},
  57. "form": {
  58. "booking_type_control_id": "booking-type",
  59. "booking_type_value": "single",
  60. "booking_type_labels": ["Label One", "Label Two"],
  61. "purpose_control_id": "purpose",
  62. "purpose_value": "tourism",
  63. "purpose_labels": ["Purpose One", "Purpose Two"],
  64. },
  65. }
  66. class ProtocolTestCase(unittest.TestCase):
  67. def assert_protocol_error(self, code, action):
  68. with self.assertRaises(ItaProtocolError) as raised:
  69. action()
  70. self.assertEqual(raised.exception.code, code)
  71. class RouteConfigTests(ProtocolTestCase):
  72. def test_resolves_vfs_bls_style_live_route_without_locale_logic(self):
  73. routing_key = "slot.sample.it.tourist"
  74. result = resolve_route_config({routing_key: live_route()}, routing_key)
  75. self.assertEqual(result.routing_key, routing_key)
  76. self.assertEqual(result.service_id, 100)
  77. self.assertIs(result.capability, ItaCapability.SINGLE_SCHENGEN_TOURISM)
  78. self.assertEqual(result.lookahead_months, 3)
  79. self.assertEqual(result.booking_type.value, "single")
  80. self.assertEqual(result.booking_type.labels, ("Label One", "Label Two"))
  81. self.assertEqual(result.purpose.value, "tourism")
  82. def test_resolves_minimal_services_probe_route(self):
  83. routing_key = "slot.sample.it.probe"
  84. result = resolve_route_config(
  85. {
  86. routing_key: {
  87. "service_id": 101,
  88. "capability": "services_probe_only",
  89. }
  90. },
  91. routing_key,
  92. )
  93. self.assertIs(result.capability, ItaCapability.SERVICES_PROBE_ONLY)
  94. self.assertEqual(result.lookahead_months, 0)
  95. self.assertIsNone(result.booking_type)
  96. self.assertIsNone(result.purpose)
  97. def test_rejects_missing_route(self):
  98. self.assert_protocol_error(
  99. "route_missing",
  100. lambda: resolve_route_config({}, "slot.sample.it.tourist"),
  101. )
  102. def test_rejects_invalid_service_ids(self):
  103. for invalid in (0, -1, True, "100", None):
  104. with self.subTest(invalid=invalid):
  105. route = live_route()
  106. route["service_id"] = invalid
  107. self.assert_protocol_error(
  108. "positive_integer_required",
  109. lambda route=route: resolve_route_config(
  110. {"route": route},
  111. "route",
  112. ),
  113. )
  114. def test_rejects_unknown_or_missing_capability(self):
  115. for invalid in (None, "", "guessed_live"):
  116. with self.subTest(invalid=invalid):
  117. route = live_route()
  118. route["capability"] = invalid
  119. expected = (
  120. "capability_unsupported"
  121. if invalid == "guessed_live"
  122. else "string_required"
  123. )
  124. self.assert_protocol_error(
  125. expected,
  126. lambda route=route: resolve_route_config(
  127. {"route": route},
  128. "route",
  129. ),
  130. )
  131. def test_live_route_requires_calendar_and_form_contracts(self):
  132. variants = []
  133. no_calendar = live_route()
  134. no_calendar.pop("calendar_scan")
  135. variants.append(no_calendar)
  136. no_form = live_route()
  137. no_form.pop("form")
  138. variants.append(no_form)
  139. for route in variants:
  140. with self.subTest(keys=sorted(route)):
  141. self.assert_protocol_error(
  142. "mapping_required",
  143. lambda route=route: resolve_route_config(
  144. {"route": route},
  145. "route",
  146. ),
  147. )
  148. def test_live_route_rejects_invalid_lookahead(self):
  149. for invalid, expected in (
  150. (0, "positive_integer_required"),
  151. (True, "positive_integer_required"),
  152. (MAX_LOOKAHEAD_MONTHS + 1, "lookahead_too_large"),
  153. ):
  154. with self.subTest(invalid=invalid):
  155. route = live_route()
  156. route["calendar_scan"]["lookahead_months"] = invalid
  157. self.assert_protocol_error(
  158. expected,
  159. lambda route=route: resolve_route_config(
  160. {"route": route},
  161. "route",
  162. ),
  163. )
  164. def test_live_route_rejects_missing_empty_or_duplicate_labels(self):
  165. for labels, expected in (
  166. (None, "labels_required"),
  167. ([], "labels_required"),
  168. (["Same", "Same"], "labels_duplicate"),
  169. (["Valid", ""], "string_required"),
  170. ):
  171. with self.subTest(labels=labels):
  172. route = live_route()
  173. route["form"]["purpose_labels"] = labels
  174. self.assert_protocol_error(
  175. expected,
  176. lambda route=route: resolve_route_config(
  177. {"route": route},
  178. "route",
  179. ),
  180. )
  181. class DoubleJsonTests(ProtocolTestCase):
  182. def test_decodes_exactly_two_json_layers(self):
  183. items = ({"value": 1}, {"value": 2})
  184. self.assertEqual(decode_double_json_array(double_json(items)), items)
  185. self.assertEqual(decode_double_json_array(double_json([])), ())
  186. def test_inner_json_and_payload_limit_keep_distinct_error_categories(self):
  187. self.assert_protocol_error(
  188. "inner_json_invalid", lambda: decode_double_json_array(json.dumps("not-json")),
  189. )
  190. self.assert_protocol_error(
  191. "payload_too_large",
  192. lambda: decode_double_json_array(" " * (MAX_PROTOCOL_PAYLOAD_CHARS + 1)),
  193. )
  194. def test_rejects_bad_single_triple_and_non_array_payloads(self):
  195. cases = (
  196. ("not-json", "outer_json_invalid"),
  197. (json.dumps([{"value": 1}]), "payload_layer_count"),
  198. (json.dumps(json.dumps(json.dumps([]))), "payload_layer_count"),
  199. (json.dumps(json.dumps({"value": 1})), "payload_layer_count"),
  200. (json.dumps(json.dumps([1])), "item_type"),
  201. )
  202. for payload, expected in cases:
  203. with self.subTest(expected=expected):
  204. self.assert_protocol_error(
  205. expected,
  206. lambda payload=payload: decode_double_json_array(payload),
  207. )
  208. def test_rejects_non_string_and_item_limit(self):
  209. for invalid in (None, b"[]", ""):
  210. with self.subTest(invalid=invalid):
  211. self.assert_protocol_error(
  212. "payload_type",
  213. lambda invalid=invalid: decode_double_json_array(invalid),
  214. )
  215. oversized = [{} for _ in range(MAX_PROTOCOL_ITEMS + 1)]
  216. self.assert_protocol_error(
  217. "item_limit_exceeded",
  218. lambda: decode_double_json_array(double_json(oversized)),
  219. )
  220. self.assert_protocol_error(
  221. "max_items_invalid",
  222. lambda: decode_double_json_array(double_json([]), max_items=True),
  223. )
  224. class CalendarAvailabilityTests(ProtocolTestCase):
  225. def setUp(self):
  226. self.items = [
  227. availability_item("09/10/2026 00:00:00", 1, 0),
  228. availability_item("31/08/2026 00:00:00", 0, -1),
  229. availability_item("12/10/2026 00:00:00", 8, 7),
  230. ]
  231. def test_parses_e43_positive_and_negative_days_and_sorts(self):
  232. days = parse_calendar_availability(double_json(self.items))
  233. self.assertEqual(
  234. tuple(item.day for item in days),
  235. (date(2026, 8, 31), date(2026, 10, 9), date(2026, 10, 12)),
  236. )
  237. self.assertFalse(days[0].is_available)
  238. self.assertTrue(days[1].is_available)
  239. self.assertEqual((days[1].slots_free, days[1].slots_remaining), (1, 0))
  240. def test_does_not_stop_after_an_earlier_negative_month(self):
  241. days = parse_calendar_availability(double_json(self.items))
  242. positives = available_calendar_days(days)
  243. self.assertEqual(
  244. tuple(item.day for item in positives),
  245. (date(2026, 10, 9), date(2026, 10, 12)),
  246. )
  247. def test_filters_inclusive_date_boundaries_and_sorts(self):
  248. days = parse_calendar_availability(double_json(self.items))
  249. positives = available_calendar_days(
  250. tuple(reversed(days)),
  251. start_day=date(2026, 10, 9),
  252. end_day=date(2026, 10, 9),
  253. )
  254. self.assertEqual(tuple(item.day for item in positives), (date(2026, 10, 9),))
  255. def test_rejects_duplicate_invalid_and_conflicting_days(self):
  256. duplicate = self.items + [self.items[0].copy()]
  257. self.assert_protocol_error(
  258. "duplicate_calendar_day",
  259. lambda: parse_calendar_availability(double_json(duplicate)),
  260. )
  261. invalid_dates = (
  262. "9/10/2026 00:00:00",
  263. "31/02/2026 00:00:00",
  264. "09/10/2026 01:00:00",
  265. )
  266. for invalid in invalid_dates:
  267. with self.subTest(invalid=invalid):
  268. item = availability_item(invalid, 1, 0)
  269. self.assert_protocol_error(
  270. "date_format" if invalid != "31/02/2026 00:00:00" else "date_invalid",
  271. lambda item=item: parse_calendar_availability(double_json([item])),
  272. )
  273. for counters in ((0, 0), (1, -1), (-1, -2), (0, 1)):
  274. with self.subTest(counters=counters):
  275. item = availability_item(
  276. "09/10/2026 00:00:00",
  277. *counters,
  278. )
  279. self.assert_protocol_error(
  280. "inventory_conflict",
  281. lambda item=item: parse_calendar_availability(double_json([item])),
  282. )
  283. def test_rejects_missing_or_non_integer_counters(self):
  284. missing = availability_item("09/10/2026 00:00:00", 1, 0)
  285. missing.pop("SlotLiberi")
  286. self.assert_protocol_error(
  287. "field_missing",
  288. lambda: parse_calendar_availability(double_json([missing])),
  289. )
  290. for invalid in (True, "1", 1.0, None):
  291. with self.subTest(invalid=invalid):
  292. item = availability_item("09/10/2026 00:00:00", invalid, 0)
  293. self.assert_protocol_error(
  294. "integer_required",
  295. lambda item=item: parse_calendar_availability(double_json([item])),
  296. )
  297. def test_month_starts_cross_year_and_validate_bounds(self):
  298. self.assertEqual(
  299. month_starts(date(2026, 11, 20), 3),
  300. (date(2026, 11, 1), date(2026, 12, 1), date(2027, 1, 1)),
  301. )
  302. self.assert_protocol_error(
  303. "positive_integer_required",
  304. lambda: month_starts(date(2026, 1, 1), 0),
  305. )
  306. self.assert_protocol_error(
  307. "lookahead_too_large",
  308. lambda: month_starts(
  309. date(2026, 1, 1),
  310. MAX_LOOKAHEAD_MONTHS + 1,
  311. ),
  312. )
  313. self.assert_protocol_error(
  314. "date_range_invalid",
  315. lambda: available_calendar_days(
  316. (),
  317. start_day=date(2026, 2, 1),
  318. end_day=date(2026, 1, 1),
  319. ),
  320. )
  321. class TimeSlotTests(ProtocolTestCase):
  322. def setUp(self):
  323. self.items = [
  324. slot_item("09/10/2026 00:00:00", (9, 15), (10, 0), 0, -1, 101),
  325. slot_item("09/10/2026 00:00:00", (10, 5), (11, 5), 1, 0, 102),
  326. slot_item("09/10/2026 00:00:00", (11, 15), (12, 40), 0, -1, 103),
  327. ]
  328. def test_parses_e43_slots_without_exposing_runtime_id_in_repr(self):
  329. slots = parse_time_slots(double_json(self.items))
  330. self.assertEqual(len(slots), 3)
  331. self.assertFalse(slots[0].is_available)
  332. self.assertTrue(slots[1].is_available)
  333. self.assertEqual(slots[1].time_label, "10:05 - 11:05")
  334. self.assertEqual((slots[1].slots_free, slots[1].slots_remaining), (1, 0))
  335. self.assertNotIn(slots[1].daily_calendar_id, repr(slots[1]))
  336. def test_filters_and_sorts_by_day_then_time_not_capacity(self):
  337. items = [
  338. slot_item("12/10/2026 00:00:00", (9, 0), (10, 0), 4, 3, 201),
  339. slot_item("09/10/2026 00:00:00", (10, 5), (11, 5), 1, 0, 202),
  340. slot_item("09/10/2026 00:00:00", (11, 15), (12, 0), 8, 7, 203),
  341. ]
  342. candidates = available_slot_candidates(
  343. tuple(reversed(parse_time_slots(double_json(items)))),
  344. start_day=date(2026, 10, 9),
  345. end_day=date(2026, 10, 12),
  346. )
  347. self.assertEqual(
  348. tuple((item.day, item.slots_free, item.start_time) for item in candidates),
  349. (
  350. (date(2026, 10, 9), 1, time(10, 5)),
  351. (date(2026, 10, 9), 8, time(11, 15)),
  352. (date(2026, 10, 12), 4, time(9, 0)),
  353. ),
  354. )
  355. def test_time_components_keep_missing_and_wrong_type_field_locations(self):
  356. for key, value, expected in (
  357. ("Hours", None, "field_missing"),
  358. ("Minutes", True, "integer_required"),
  359. ("Seconds", "0", "integer_required"),
  360. ("Milliseconds", False, "integer_required"),
  361. ):
  362. with self.subTest(key=key):
  363. item = copy.deepcopy(self.items[1])
  364. if value is None:
  365. del item["OrarioInizioFascia"][key]
  366. else:
  367. item["OrarioInizioFascia"][key] = value
  368. with self.assertRaises(ItaProtocolError) as caught:
  369. parse_time_slots(double_json([item]))
  370. self.assertEqual(caught.exception.code, expected)
  371. self.assertEqual(caught.exception.path, f"time_slots[0].OrarioInizioFascia.{key}")
  372. def test_rejects_missing_invalid_or_conflicting_slot_fields(self):
  373. missing = self.items[1].copy()
  374. missing.pop("IDCalendarioServizioGiornaliero")
  375. self.assert_protocol_error(
  376. "field_missing",
  377. lambda: parse_time_slots(double_json([missing])),
  378. )
  379. invalid_cases = []
  380. end_before_start = copy.deepcopy(self.items[1])
  381. end_before_start["OrarioFineFascia"] = time_value(9, 0)
  382. invalid_cases.append((end_before_start, "time_range_invalid"))
  383. invalid_hour = copy.deepcopy(self.items[1])
  384. invalid_hour["OrarioInizioFascia"] = time_value(24, 0)
  385. invalid_cases.append((invalid_hour, "time_invalid"))
  386. invalid_precision = copy.deepcopy(self.items[1])
  387. invalid_precision["OrarioInizioFascia"] = time_value(10, 5, seconds=1)
  388. invalid_cases.append((invalid_precision, "time_precision"))
  389. invalid_counter = copy.deepcopy(self.items[1])
  390. invalid_counter["SlotLiberi"] = True
  391. invalid_cases.append((invalid_counter, "integer_required"))
  392. conflict = copy.deepcopy(self.items[1])
  393. conflict["SlotLiberi"] = 0
  394. conflict["SlotRimanenti"] = 0
  395. invalid_cases.append((conflict, "inventory_conflict"))
  396. invalid_id = copy.deepcopy(self.items[1])
  397. invalid_id["IDCalendarioServizioGiornaliero"] = 0
  398. invalid_cases.append((invalid_id, "positive_integer_required"))
  399. for item, expected in invalid_cases:
  400. with self.subTest(expected=expected):
  401. self.assert_protocol_error(
  402. expected,
  403. lambda item=item: parse_time_slots(double_json([item])),
  404. )
  405. def test_rejects_duplicate_time_ranges_and_daily_ids(self):
  406. duplicate_range = [self.items[1], copy.deepcopy(self.items[1])]
  407. duplicate_range[1]["IDCalendarioServizioGiornaliero"] = 104
  408. self.assert_protocol_error(
  409. "duplicate_time_range",
  410. lambda: parse_time_slots(double_json(duplicate_range)),
  411. )
  412. duplicate_id = [self.items[0], self.items[1]]
  413. duplicate_id[1] = copy.deepcopy(duplicate_id[1])
  414. duplicate_id[1]["IDCalendarioServizioGiornaliero"] = 101
  415. self.assert_protocol_error(
  416. "duplicate_daily_id",
  417. lambda: parse_time_slots(double_json(duplicate_id)),
  418. )
  419. def test_inventory_objects_expose_derived_availability(self):
  420. positive = CalendarDay(date(2026, 10, 9), 1, 0)
  421. self.assertTrue(positive.is_available)
  422. with self.assertRaises(TypeError):
  423. CalendarDay(
  424. day=date(2026, 10, 9),
  425. slots_free=1,
  426. slots_remaining=0,
  427. is_available=False,
  428. )
  429. if __name__ == "__main__":
  430. unittest.main()