test_ita_protocol.py 23 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648
  1. import copy
  2. import json
  3. import unittest
  4. from dataclasses import replace
  5. from datetime import date, time
  6. from plugins.ita_protocol import (
  7. MAX_LOOKAHEAD_MONTHS,
  8. MAX_PROTOCOL_ITEMS,
  9. CalendarDay,
  10. DateSelectionState,
  11. InventoryState,
  12. ItaCapability,
  13. ItaProtocolError,
  14. SlotCandidate,
  15. SlotSelectionState,
  16. approve_precommit,
  17. available_calendar_days,
  18. available_slot_candidates,
  19. decode_double_json_array,
  20. month_starts,
  21. parse_calendar_availability,
  22. parse_time_slots,
  23. resolve_route_config,
  24. )
  25. def double_json(items):
  26. return json.dumps(json.dumps(items, separators=(",", ":")))
  27. def availability_item(day, slots_free, slots_remaining):
  28. return {
  29. "DateLibere": day,
  30. "SlotLiberi": slots_free,
  31. "SlotRimanenti": slots_remaining,
  32. }
  33. def time_value(hours, minutes, *, seconds=0, milliseconds=0):
  34. return {
  35. "Hours": hours,
  36. "Minutes": minutes,
  37. "Seconds": seconds,
  38. "Milliseconds": milliseconds,
  39. }
  40. def slot_item(
  41. day,
  42. start,
  43. end,
  44. slots_free,
  45. slots_remaining,
  46. daily_id,
  47. ):
  48. return {
  49. "Data": day,
  50. "OrarioInizioFascia": time_value(*start),
  51. "OrarioFineFascia": time_value(*end),
  52. "SlotLiberi": slots_free,
  53. "SlotRimanenti": slots_remaining,
  54. "IDCalendarioServizioGiornaliero": daily_id,
  55. }
  56. def live_route():
  57. return {
  58. "service_id": 100,
  59. "capability": "single_schengen_tourism",
  60. "calendar_scan": {"lookahead_months": 3},
  61. "form": {
  62. "booking_type_control_id": "booking-type",
  63. "booking_type_value": "single",
  64. "booking_type_labels": ["Label One", "Label Two"],
  65. "purpose_control_id": "purpose",
  66. "purpose_value": "tourism",
  67. "purpose_labels": ["Purpose One", "Purpose Two"],
  68. },
  69. }
  70. class ProtocolTestCase(unittest.TestCase):
  71. def assert_protocol_error(self, code, action):
  72. with self.assertRaises(ItaProtocolError) as raised:
  73. action()
  74. self.assertEqual(raised.exception.code, code)
  75. class RouteConfigTests(ProtocolTestCase):
  76. def test_resolves_vfs_bls_style_live_route_without_locale_logic(self):
  77. routing_key = "slot.sample.it.tourist"
  78. result = resolve_route_config({routing_key: live_route()}, routing_key)
  79. self.assertEqual(result.routing_key, routing_key)
  80. self.assertEqual(result.service_id, 100)
  81. self.assertIs(result.capability, ItaCapability.SINGLE_SCHENGEN_TOURISM)
  82. self.assertEqual(result.calendar_scan.lookahead_months, 3)
  83. self.assertEqual(result.booking_type.value, "single")
  84. self.assertEqual(result.booking_type.labels, ("Label One", "Label Two"))
  85. self.assertEqual(result.purpose.value, "tourism")
  86. def test_resolves_minimal_services_probe_route(self):
  87. routing_key = "slot.sample.it.probe"
  88. result = resolve_route_config(
  89. {
  90. routing_key: {
  91. "service_id": 101,
  92. "capability": "services_probe_only",
  93. }
  94. },
  95. routing_key,
  96. )
  97. self.assertIs(result.capability, ItaCapability.SERVICES_PROBE_ONLY)
  98. self.assertIsNone(result.calendar_scan)
  99. self.assertIsNone(result.booking_type)
  100. self.assertIsNone(result.purpose)
  101. def test_rejects_missing_route(self):
  102. self.assert_protocol_error(
  103. "route_missing",
  104. lambda: resolve_route_config({}, "slot.sample.it.tourist"),
  105. )
  106. def test_rejects_invalid_service_ids(self):
  107. for invalid in (0, -1, True, "100", None):
  108. with self.subTest(invalid=invalid):
  109. route = live_route()
  110. route["service_id"] = invalid
  111. self.assert_protocol_error(
  112. "positive_integer_required",
  113. lambda route=route: resolve_route_config(
  114. {"route": route},
  115. "route",
  116. ),
  117. )
  118. def test_rejects_unknown_or_missing_capability(self):
  119. for invalid in (None, "", "guessed_live"):
  120. with self.subTest(invalid=invalid):
  121. route = live_route()
  122. route["capability"] = invalid
  123. expected = (
  124. "capability_unsupported"
  125. if invalid == "guessed_live"
  126. else "string_required"
  127. )
  128. self.assert_protocol_error(
  129. expected,
  130. lambda route=route: resolve_route_config(
  131. {"route": route},
  132. "route",
  133. ),
  134. )
  135. def test_live_route_requires_calendar_and_form_contracts(self):
  136. variants = []
  137. no_calendar = live_route()
  138. no_calendar.pop("calendar_scan")
  139. variants.append(no_calendar)
  140. no_form = live_route()
  141. no_form.pop("form")
  142. variants.append(no_form)
  143. for route in variants:
  144. with self.subTest(keys=sorted(route)):
  145. self.assert_protocol_error(
  146. "mapping_required",
  147. lambda route=route: resolve_route_config(
  148. {"route": route},
  149. "route",
  150. ),
  151. )
  152. def test_live_route_rejects_invalid_lookahead(self):
  153. for invalid, expected in (
  154. (0, "positive_integer_required"),
  155. (True, "positive_integer_required"),
  156. (MAX_LOOKAHEAD_MONTHS + 1, "lookahead_too_large"),
  157. ):
  158. with self.subTest(invalid=invalid):
  159. route = live_route()
  160. route["calendar_scan"]["lookahead_months"] = invalid
  161. self.assert_protocol_error(
  162. expected,
  163. lambda route=route: resolve_route_config(
  164. {"route": route},
  165. "route",
  166. ),
  167. )
  168. def test_live_route_rejects_missing_empty_or_duplicate_labels(self):
  169. for labels, expected in (
  170. (None, "labels_required"),
  171. ([], "labels_required"),
  172. (["Same", "Same"], "labels_duplicate"),
  173. (["Valid", ""], "string_required"),
  174. ):
  175. with self.subTest(labels=labels):
  176. route = live_route()
  177. route["form"]["purpose_labels"] = labels
  178. self.assert_protocol_error(
  179. expected,
  180. lambda route=route: resolve_route_config(
  181. {"route": route},
  182. "route",
  183. ),
  184. )
  185. class DoubleJsonTests(ProtocolTestCase):
  186. def test_decodes_exactly_two_json_layers(self):
  187. items = ({"value": 1}, {"value": 2})
  188. self.assertEqual(decode_double_json_array(double_json(items)), items)
  189. self.assertEqual(decode_double_json_array(double_json([])), ())
  190. def test_rejects_bad_single_triple_and_non_array_payloads(self):
  191. cases = (
  192. ("not-json", "outer_json_invalid"),
  193. (json.dumps([{"value": 1}]), "payload_layer_count"),
  194. (json.dumps(json.dumps(json.dumps([]))), "payload_layer_count"),
  195. (json.dumps(json.dumps({"value": 1})), "payload_layer_count"),
  196. (json.dumps(json.dumps([1])), "item_type"),
  197. )
  198. for payload, expected in cases:
  199. with self.subTest(expected=expected):
  200. self.assert_protocol_error(
  201. expected,
  202. lambda payload=payload: decode_double_json_array(payload),
  203. )
  204. def test_rejects_non_string_and_item_limit(self):
  205. for invalid in (None, b"[]", ""):
  206. with self.subTest(invalid=invalid):
  207. self.assert_protocol_error(
  208. "payload_type",
  209. lambda invalid=invalid: decode_double_json_array(invalid),
  210. )
  211. oversized = [{} for _ in range(MAX_PROTOCOL_ITEMS + 1)]
  212. self.assert_protocol_error(
  213. "item_limit_exceeded",
  214. lambda: decode_double_json_array(double_json(oversized)),
  215. )
  216. self.assert_protocol_error(
  217. "max_items_invalid",
  218. lambda: decode_double_json_array(double_json([]), max_items=True),
  219. )
  220. class CalendarAvailabilityTests(ProtocolTestCase):
  221. def setUp(self):
  222. self.items = [
  223. availability_item("09/10/2026 00:00:00", 1, 0),
  224. availability_item("31/08/2026 00:00:00", 0, -1),
  225. availability_item("12/10/2026 00:00:00", 8, 7),
  226. ]
  227. def test_parses_e43_positive_and_negative_days_and_sorts(self):
  228. days = parse_calendar_availability(double_json(self.items))
  229. self.assertEqual(
  230. tuple(item.day for item in days),
  231. (date(2026, 8, 31), date(2026, 10, 9), date(2026, 10, 12)),
  232. )
  233. self.assertIs(days[0].state, InventoryState.UNAVAILABLE)
  234. self.assertIs(days[1].state, InventoryState.AVAILABLE)
  235. self.assertEqual((days[1].slots_free, days[1].slots_remaining), (1, 0))
  236. def test_does_not_stop_after_an_earlier_negative_month(self):
  237. days = parse_calendar_availability(double_json(self.items))
  238. positives = available_calendar_days(days)
  239. self.assertEqual(
  240. tuple(item.day for item in positives),
  241. (date(2026, 10, 9), date(2026, 10, 12)),
  242. )
  243. def test_filters_inclusive_date_boundaries_and_sorts(self):
  244. days = parse_calendar_availability(double_json(self.items))
  245. positives = available_calendar_days(
  246. tuple(reversed(days)),
  247. start_day=date(2026, 10, 9),
  248. end_day=date(2026, 10, 9),
  249. )
  250. self.assertEqual(tuple(item.day for item in positives), (date(2026, 10, 9),))
  251. def test_rejects_duplicate_invalid_and_conflicting_days(self):
  252. duplicate = self.items + [self.items[0].copy()]
  253. self.assert_protocol_error(
  254. "duplicate_calendar_day",
  255. lambda: parse_calendar_availability(double_json(duplicate)),
  256. )
  257. invalid_dates = (
  258. "9/10/2026 00:00:00",
  259. "31/02/2026 00:00:00",
  260. "09/10/2026 01:00:00",
  261. )
  262. for invalid in invalid_dates:
  263. with self.subTest(invalid=invalid):
  264. item = availability_item(invalid, 1, 0)
  265. self.assert_protocol_error(
  266. "date_format" if invalid != "31/02/2026 00:00:00" else "date_invalid",
  267. lambda item=item: parse_calendar_availability(double_json([item])),
  268. )
  269. for counters in ((0, 0), (1, -1), (-1, -2), (0, 1)):
  270. with self.subTest(counters=counters):
  271. item = availability_item(
  272. "09/10/2026 00:00:00",
  273. *counters,
  274. )
  275. self.assert_protocol_error(
  276. "inventory_conflict",
  277. lambda item=item: parse_calendar_availability(double_json([item])),
  278. )
  279. def test_rejects_missing_or_non_integer_counters(self):
  280. missing = availability_item("09/10/2026 00:00:00", 1, 0)
  281. missing.pop("SlotLiberi")
  282. self.assert_protocol_error(
  283. "field_missing",
  284. lambda: parse_calendar_availability(double_json([missing])),
  285. )
  286. for invalid in (True, "1", 1.0, None):
  287. with self.subTest(invalid=invalid):
  288. item = availability_item("09/10/2026 00:00:00", invalid, 0)
  289. self.assert_protocol_error(
  290. "integer_required",
  291. lambda item=item: parse_calendar_availability(double_json([item])),
  292. )
  293. def test_month_starts_cross_year_and_validate_bounds(self):
  294. self.assertEqual(
  295. month_starts(date(2026, 11, 20), 3),
  296. (date(2026, 11, 1), date(2026, 12, 1), date(2027, 1, 1)),
  297. )
  298. self.assert_protocol_error(
  299. "positive_integer_required",
  300. lambda: month_starts(date(2026, 1, 1), 0),
  301. )
  302. self.assert_protocol_error(
  303. "lookahead_too_large",
  304. lambda: month_starts(
  305. date(2026, 1, 1),
  306. MAX_LOOKAHEAD_MONTHS + 1,
  307. ),
  308. )
  309. self.assert_protocol_error(
  310. "date_range_invalid",
  311. lambda: available_calendar_days(
  312. (),
  313. start_day=date(2026, 2, 1),
  314. end_day=date(2026, 1, 1),
  315. ),
  316. )
  317. class TimeSlotTests(ProtocolTestCase):
  318. def setUp(self):
  319. self.items = [
  320. slot_item("09/10/2026 00:00:00", (9, 15), (10, 0), 0, -1, 101),
  321. slot_item("09/10/2026 00:00:00", (10, 5), (11, 5), 1, 0, 102),
  322. slot_item("09/10/2026 00:00:00", (11, 15), (12, 40), 0, -1, 103),
  323. ]
  324. def test_parses_e43_slots_without_exposing_runtime_id_in_repr(self):
  325. slots = parse_time_slots(double_json(self.items))
  326. self.assertEqual(len(slots), 3)
  327. self.assertFalse(slots[0].is_available)
  328. self.assertTrue(slots[1].is_available)
  329. self.assertEqual(slots[1].time_label, "10:05 - 11:05")
  330. self.assertEqual((slots[1].slots_free, slots[1].slots_remaining), (1, 0))
  331. self.assertNotIn(slots[1].daily_calendar_id, repr(slots[1]))
  332. def test_filters_and_sorts_by_day_capacity_then_start_time(self):
  333. items = [
  334. slot_item("12/10/2026 00:00:00", (9, 0), (10, 0), 4, 3, 201),
  335. slot_item("09/10/2026 00:00:00", (10, 5), (11, 5), 1, 0, 202),
  336. slot_item("09/10/2026 00:00:00", (11, 15), (12, 0), 8, 7, 203),
  337. ]
  338. candidates = available_slot_candidates(
  339. tuple(reversed(parse_time_slots(double_json(items)))),
  340. start_day=date(2026, 10, 9),
  341. end_day=date(2026, 10, 12),
  342. )
  343. self.assertEqual(
  344. tuple((item.day, item.slots_free, item.start_time) for item in candidates),
  345. (
  346. (date(2026, 10, 9), 8, time(11, 15)),
  347. (date(2026, 10, 9), 1, time(10, 5)),
  348. (date(2026, 10, 12), 4, time(9, 0)),
  349. ),
  350. )
  351. def test_rejects_missing_invalid_or_conflicting_slot_fields(self):
  352. missing = self.items[1].copy()
  353. missing.pop("IDCalendarioServizioGiornaliero")
  354. self.assert_protocol_error(
  355. "field_missing",
  356. lambda: parse_time_slots(double_json([missing])),
  357. )
  358. invalid_cases = []
  359. end_before_start = copy.deepcopy(self.items[1])
  360. end_before_start["OrarioFineFascia"] = time_value(9, 0)
  361. invalid_cases.append((end_before_start, "time_range_invalid"))
  362. invalid_hour = copy.deepcopy(self.items[1])
  363. invalid_hour["OrarioInizioFascia"] = time_value(24, 0)
  364. invalid_cases.append((invalid_hour, "time_invalid"))
  365. invalid_precision = copy.deepcopy(self.items[1])
  366. invalid_precision["OrarioInizioFascia"] = time_value(10, 5, seconds=1)
  367. invalid_cases.append((invalid_precision, "time_precision"))
  368. invalid_counter = copy.deepcopy(self.items[1])
  369. invalid_counter["SlotLiberi"] = True
  370. invalid_cases.append((invalid_counter, "integer_required"))
  371. conflict = copy.deepcopy(self.items[1])
  372. conflict["SlotLiberi"] = 0
  373. conflict["SlotRimanenti"] = 0
  374. invalid_cases.append((conflict, "inventory_conflict"))
  375. invalid_id = copy.deepcopy(self.items[1])
  376. invalid_id["IDCalendarioServizioGiornaliero"] = 0
  377. invalid_cases.append((invalid_id, "positive_integer_required"))
  378. for item, expected in invalid_cases:
  379. with self.subTest(expected=expected):
  380. self.assert_protocol_error(
  381. expected,
  382. lambda item=item: parse_time_slots(double_json([item])),
  383. )
  384. def test_rejects_duplicate_time_ranges_and_daily_ids(self):
  385. duplicate_range = [self.items[1], copy.deepcopy(self.items[1])]
  386. duplicate_range[1]["IDCalendarioServizioGiornaliero"] = 104
  387. self.assert_protocol_error(
  388. "duplicate_time_range",
  389. lambda: parse_time_slots(double_json(duplicate_range)),
  390. )
  391. duplicate_id = [self.items[0], self.items[1]]
  392. duplicate_id[1] = copy.deepcopy(duplicate_id[1])
  393. duplicate_id[1]["IDCalendarioServizioGiornaliero"] = 101
  394. self.assert_protocol_error(
  395. "duplicate_daily_id",
  396. lambda: parse_time_slots(double_json(duplicate_id)),
  397. )
  398. def test_value_objects_reject_inconsistent_manual_construction(self):
  399. self.assert_protocol_error(
  400. "inventory_state_mismatch",
  401. lambda: CalendarDay(
  402. day=date(2026, 10, 9),
  403. slots_free=1,
  404. slots_remaining=0,
  405. state=InventoryState.UNAVAILABLE,
  406. ),
  407. )
  408. self.assert_protocol_error(
  409. "daily_id_invalid",
  410. lambda: SlotCandidate(
  411. day=date(2026, 10, 9),
  412. start_time=time(10, 5),
  413. end_time=time(11, 5),
  414. slots_free=1,
  415. slots_remaining=0,
  416. state=InventoryState.AVAILABLE,
  417. daily_calendar_id="not-numeric",
  418. ),
  419. )
  420. class PrecommitTests(ProtocolTestCase):
  421. def setUp(self):
  422. self.day = parse_calendar_availability(
  423. double_json([availability_item("09/10/2026 00:00:00", 1, 0)])
  424. )[0]
  425. slots = parse_time_slots(
  426. double_json(
  427. [
  428. slot_item(
  429. "09/10/2026 00:00:00",
  430. (9, 15),
  431. (10, 0),
  432. 0,
  433. -1,
  434. 301,
  435. ),
  436. slot_item(
  437. "09/10/2026 00:00:00",
  438. (10, 5),
  439. (11, 5),
  440. 1,
  441. 0,
  442. 302,
  443. ),
  444. ]
  445. )
  446. )
  447. self.negative_candidate = slots[0]
  448. self.candidate = slots[1]
  449. self.date_state = DateSelectionState(
  450. planned_day=date(2026, 10, 9),
  451. matching_availability_count=1,
  452. timeline_selected_days=(date(2026, 10, 9),),
  453. content_selected_days=(date(2026, 10, 9),),
  454. day_disabled=False,
  455. day_not_available=False,
  456. day_has_positive_state=True,
  457. )
  458. self.slot_state = SlotSelectionState(
  459. active_slot_count=1,
  460. active_is_candidate=True,
  461. active_has_unavailable_class=False,
  462. active_has_red_dot=False,
  463. active_hidden_input_count=1,
  464. active_daily_id_matches_candidate=True,
  465. active_day_matches_candidate=True,
  466. active_time_matches_candidate=True,
  467. active_capacity_matches_candidate=True,
  468. )
  469. def test_e44_positive_selection_approves_precommit(self):
  470. approval = approve_precommit(
  471. self.day,
  472. self.candidate,
  473. self.date_state,
  474. self.slot_state,
  475. )
  476. self.assertIs(approval.calendar_day, self.day)
  477. self.assertIs(approval.candidate, self.candidate)
  478. self.assertNotIn(self.candidate.daily_calendar_id, repr(approval))
  479. def test_state_objects_reject_python_bool_integer_ambiguity(self):
  480. self.assert_protocol_error(
  481. "integer_required",
  482. lambda: replace(
  483. self.date_state,
  484. matching_availability_count=True,
  485. ),
  486. )
  487. self.assert_protocol_error(
  488. "integer_required",
  489. lambda: replace(
  490. self.slot_state,
  491. active_slot_count=True,
  492. ),
  493. )
  494. self.assert_protocol_error(
  495. "boolean_required",
  496. lambda: replace(
  497. self.slot_state,
  498. active_is_candidate=1,
  499. ),
  500. )
  501. self.assert_protocol_error(
  502. "date_tuple_required",
  503. lambda: replace(
  504. self.date_state,
  505. timeline_selected_days=[self.day.day],
  506. ),
  507. )
  508. def test_rejects_every_date_selection_conflict(self):
  509. wrong_day = date(2026, 10, 10)
  510. mutations = (
  511. {"planned_day": wrong_day},
  512. {"matching_availability_count": 0},
  513. {"matching_availability_count": 2},
  514. {"timeline_selected_days": ()},
  515. {"timeline_selected_days": (self.day.day, self.day.day)},
  516. {"content_selected_days": (wrong_day,)},
  517. {"day_disabled": True},
  518. {"day_not_available": True},
  519. {"day_has_positive_state": False},
  520. )
  521. for mutation in mutations:
  522. with self.subTest(mutation=mutation):
  523. self.assert_protocol_error(
  524. "precommit_rejected",
  525. lambda mutation=mutation: approve_precommit(
  526. self.day,
  527. self.candidate,
  528. replace(self.date_state, **mutation),
  529. self.slot_state,
  530. ),
  531. )
  532. def test_rejects_every_active_slot_conflict(self):
  533. mutations = (
  534. {"active_slot_count": 0},
  535. {"active_slot_count": 2},
  536. {"active_is_candidate": False},
  537. {"active_has_unavailable_class": True},
  538. {"active_has_red_dot": True},
  539. {"active_hidden_input_count": 0},
  540. {"active_hidden_input_count": 2},
  541. {"active_daily_id_matches_candidate": False},
  542. {"active_day_matches_candidate": False},
  543. {"active_time_matches_candidate": False},
  544. {"active_capacity_matches_candidate": False},
  545. )
  546. for mutation in mutations:
  547. with self.subTest(mutation=mutation):
  548. self.assert_protocol_error(
  549. "precommit_rejected",
  550. lambda mutation=mutation: approve_precommit(
  551. self.day,
  552. self.candidate,
  553. self.date_state,
  554. replace(self.slot_state, **mutation),
  555. ),
  556. )
  557. def test_rejects_negative_candidate_even_if_dom_marks_it_active(self):
  558. self.assert_protocol_error(
  559. "precommit_rejected",
  560. lambda: approve_precommit(
  561. self.day,
  562. self.negative_candidate,
  563. self.date_state,
  564. self.slot_state,
  565. ),
  566. )
  567. def test_rejects_negative_calendar_day(self):
  568. negative_day = parse_calendar_availability(
  569. double_json([availability_item("09/10/2026 00:00:00", 0, -1)])
  570. )[0]
  571. self.assert_protocol_error(
  572. "precommit_rejected",
  573. lambda: approve_precommit(
  574. negative_day,
  575. self.candidate,
  576. self.date_state,
  577. self.slot_state,
  578. ),
  579. )
  580. if __name__ == "__main__":
  581. unittest.main()