| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648 |
- import copy
- import json
- import unittest
- from dataclasses import replace
- from datetime import date, time
- from plugins.ita_plugin import (
- MAX_LOOKAHEAD_MONTHS,
- MAX_PROTOCOL_ITEMS,
- CalendarDay,
- DateSelectionState,
- InventoryState,
- ItaCapability,
- ItaProtocolError,
- SlotCandidate,
- SlotSelectionState,
- approve_precommit,
- available_calendar_days,
- available_slot_candidates,
- decode_double_json_array,
- month_starts,
- parse_calendar_availability,
- parse_time_slots,
- resolve_route_config,
- )
- def double_json(items):
- return json.dumps(json.dumps(items, separators=(",", ":")))
- def availability_item(day, slots_free, slots_remaining):
- return {
- "DateLibere": day,
- "SlotLiberi": slots_free,
- "SlotRimanenti": slots_remaining,
- }
- def time_value(hours, minutes, *, seconds=0, milliseconds=0):
- return {
- "Hours": hours,
- "Minutes": minutes,
- "Seconds": seconds,
- "Milliseconds": milliseconds,
- }
- def slot_item(
- day,
- start,
- end,
- slots_free,
- slots_remaining,
- daily_id,
- ):
- return {
- "Data": day,
- "OrarioInizioFascia": time_value(*start),
- "OrarioFineFascia": time_value(*end),
- "SlotLiberi": slots_free,
- "SlotRimanenti": slots_remaining,
- "IDCalendarioServizioGiornaliero": daily_id,
- }
- def live_route():
- return {
- "service_id": 100,
- "capability": "single_schengen_tourism",
- "calendar_scan": {"lookahead_months": 3},
- "form": {
- "booking_type_control_id": "booking-type",
- "booking_type_value": "single",
- "booking_type_labels": ["Label One", "Label Two"],
- "purpose_control_id": "purpose",
- "purpose_value": "tourism",
- "purpose_labels": ["Purpose One", "Purpose Two"],
- },
- }
- class ProtocolTestCase(unittest.TestCase):
- def assert_protocol_error(self, code, action):
- with self.assertRaises(ItaProtocolError) as raised:
- action()
- self.assertEqual(raised.exception.code, code)
- class RouteConfigTests(ProtocolTestCase):
- def test_resolves_vfs_bls_style_live_route_without_locale_logic(self):
- routing_key = "slot.sample.it.tourist"
- result = resolve_route_config({routing_key: live_route()}, routing_key)
- self.assertEqual(result.routing_key, routing_key)
- self.assertEqual(result.service_id, 100)
- self.assertIs(result.capability, ItaCapability.SINGLE_SCHENGEN_TOURISM)
- self.assertEqual(result.calendar_scan.lookahead_months, 3)
- self.assertEqual(result.booking_type.value, "single")
- self.assertEqual(result.booking_type.labels, ("Label One", "Label Two"))
- self.assertEqual(result.purpose.value, "tourism")
- def test_resolves_minimal_services_probe_route(self):
- routing_key = "slot.sample.it.probe"
- result = resolve_route_config(
- {
- routing_key: {
- "service_id": 101,
- "capability": "services_probe_only",
- }
- },
- routing_key,
- )
- self.assertIs(result.capability, ItaCapability.SERVICES_PROBE_ONLY)
- self.assertIsNone(result.calendar_scan)
- self.assertIsNone(result.booking_type)
- self.assertIsNone(result.purpose)
- def test_rejects_missing_route(self):
- self.assert_protocol_error(
- "route_missing",
- lambda: resolve_route_config({}, "slot.sample.it.tourist"),
- )
- def test_rejects_invalid_service_ids(self):
- for invalid in (0, -1, True, "100", None):
- with self.subTest(invalid=invalid):
- route = live_route()
- route["service_id"] = invalid
- self.assert_protocol_error(
- "positive_integer_required",
- lambda route=route: resolve_route_config(
- {"route": route},
- "route",
- ),
- )
- def test_rejects_unknown_or_missing_capability(self):
- for invalid in (None, "", "guessed_live"):
- with self.subTest(invalid=invalid):
- route = live_route()
- route["capability"] = invalid
- expected = (
- "capability_unsupported"
- if invalid == "guessed_live"
- else "string_required"
- )
- self.assert_protocol_error(
- expected,
- lambda route=route: resolve_route_config(
- {"route": route},
- "route",
- ),
- )
- def test_live_route_requires_calendar_and_form_contracts(self):
- variants = []
- no_calendar = live_route()
- no_calendar.pop("calendar_scan")
- variants.append(no_calendar)
- no_form = live_route()
- no_form.pop("form")
- variants.append(no_form)
- for route in variants:
- with self.subTest(keys=sorted(route)):
- self.assert_protocol_error(
- "mapping_required",
- lambda route=route: resolve_route_config(
- {"route": route},
- "route",
- ),
- )
- def test_live_route_rejects_invalid_lookahead(self):
- for invalid, expected in (
- (0, "positive_integer_required"),
- (True, "positive_integer_required"),
- (MAX_LOOKAHEAD_MONTHS + 1, "lookahead_too_large"),
- ):
- with self.subTest(invalid=invalid):
- route = live_route()
- route["calendar_scan"]["lookahead_months"] = invalid
- self.assert_protocol_error(
- expected,
- lambda route=route: resolve_route_config(
- {"route": route},
- "route",
- ),
- )
- def test_live_route_rejects_missing_empty_or_duplicate_labels(self):
- for labels, expected in (
- (None, "labels_required"),
- ([], "labels_required"),
- (["Same", "Same"], "labels_duplicate"),
- (["Valid", ""], "string_required"),
- ):
- with self.subTest(labels=labels):
- route = live_route()
- route["form"]["purpose_labels"] = labels
- self.assert_protocol_error(
- expected,
- lambda route=route: resolve_route_config(
- {"route": route},
- "route",
- ),
- )
- class DoubleJsonTests(ProtocolTestCase):
- def test_decodes_exactly_two_json_layers(self):
- items = ({"value": 1}, {"value": 2})
- self.assertEqual(decode_double_json_array(double_json(items)), items)
- self.assertEqual(decode_double_json_array(double_json([])), ())
- def test_rejects_bad_single_triple_and_non_array_payloads(self):
- cases = (
- ("not-json", "outer_json_invalid"),
- (json.dumps([{"value": 1}]), "payload_layer_count"),
- (json.dumps(json.dumps(json.dumps([]))), "payload_layer_count"),
- (json.dumps(json.dumps({"value": 1})), "payload_layer_count"),
- (json.dumps(json.dumps([1])), "item_type"),
- )
- for payload, expected in cases:
- with self.subTest(expected=expected):
- self.assert_protocol_error(
- expected,
- lambda payload=payload: decode_double_json_array(payload),
- )
- def test_rejects_non_string_and_item_limit(self):
- for invalid in (None, b"[]", ""):
- with self.subTest(invalid=invalid):
- self.assert_protocol_error(
- "payload_type",
- lambda invalid=invalid: decode_double_json_array(invalid),
- )
- oversized = [{} for _ in range(MAX_PROTOCOL_ITEMS + 1)]
- self.assert_protocol_error(
- "item_limit_exceeded",
- lambda: decode_double_json_array(double_json(oversized)),
- )
- self.assert_protocol_error(
- "max_items_invalid",
- lambda: decode_double_json_array(double_json([]), max_items=True),
- )
- class CalendarAvailabilityTests(ProtocolTestCase):
- def setUp(self):
- self.items = [
- availability_item("09/10/2026 00:00:00", 1, 0),
- availability_item("31/08/2026 00:00:00", 0, -1),
- availability_item("12/10/2026 00:00:00", 8, 7),
- ]
- def test_parses_e43_positive_and_negative_days_and_sorts(self):
- days = parse_calendar_availability(double_json(self.items))
- self.assertEqual(
- tuple(item.day for item in days),
- (date(2026, 8, 31), date(2026, 10, 9), date(2026, 10, 12)),
- )
- self.assertIs(days[0].state, InventoryState.UNAVAILABLE)
- self.assertIs(days[1].state, InventoryState.AVAILABLE)
- self.assertEqual((days[1].slots_free, days[1].slots_remaining), (1, 0))
- def test_does_not_stop_after_an_earlier_negative_month(self):
- days = parse_calendar_availability(double_json(self.items))
- positives = available_calendar_days(days)
- self.assertEqual(
- tuple(item.day for item in positives),
- (date(2026, 10, 9), date(2026, 10, 12)),
- )
- def test_filters_inclusive_date_boundaries_and_sorts(self):
- days = parse_calendar_availability(double_json(self.items))
- positives = available_calendar_days(
- tuple(reversed(days)),
- start_day=date(2026, 10, 9),
- end_day=date(2026, 10, 9),
- )
- self.assertEqual(tuple(item.day for item in positives), (date(2026, 10, 9),))
- def test_rejects_duplicate_invalid_and_conflicting_days(self):
- duplicate = self.items + [self.items[0].copy()]
- self.assert_protocol_error(
- "duplicate_calendar_day",
- lambda: parse_calendar_availability(double_json(duplicate)),
- )
- invalid_dates = (
- "9/10/2026 00:00:00",
- "31/02/2026 00:00:00",
- "09/10/2026 01:00:00",
- )
- for invalid in invalid_dates:
- with self.subTest(invalid=invalid):
- item = availability_item(invalid, 1, 0)
- self.assert_protocol_error(
- "date_format" if invalid != "31/02/2026 00:00:00" else "date_invalid",
- lambda item=item: parse_calendar_availability(double_json([item])),
- )
- for counters in ((0, 0), (1, -1), (-1, -2), (0, 1)):
- with self.subTest(counters=counters):
- item = availability_item(
- "09/10/2026 00:00:00",
- *counters,
- )
- self.assert_protocol_error(
- "inventory_conflict",
- lambda item=item: parse_calendar_availability(double_json([item])),
- )
- def test_rejects_missing_or_non_integer_counters(self):
- missing = availability_item("09/10/2026 00:00:00", 1, 0)
- missing.pop("SlotLiberi")
- self.assert_protocol_error(
- "field_missing",
- lambda: parse_calendar_availability(double_json([missing])),
- )
- for invalid in (True, "1", 1.0, None):
- with self.subTest(invalid=invalid):
- item = availability_item("09/10/2026 00:00:00", invalid, 0)
- self.assert_protocol_error(
- "integer_required",
- lambda item=item: parse_calendar_availability(double_json([item])),
- )
- def test_month_starts_cross_year_and_validate_bounds(self):
- self.assertEqual(
- month_starts(date(2026, 11, 20), 3),
- (date(2026, 11, 1), date(2026, 12, 1), date(2027, 1, 1)),
- )
- self.assert_protocol_error(
- "positive_integer_required",
- lambda: month_starts(date(2026, 1, 1), 0),
- )
- self.assert_protocol_error(
- "lookahead_too_large",
- lambda: month_starts(
- date(2026, 1, 1),
- MAX_LOOKAHEAD_MONTHS + 1,
- ),
- )
- self.assert_protocol_error(
- "date_range_invalid",
- lambda: available_calendar_days(
- (),
- start_day=date(2026, 2, 1),
- end_day=date(2026, 1, 1),
- ),
- )
- class TimeSlotTests(ProtocolTestCase):
- def setUp(self):
- self.items = [
- slot_item("09/10/2026 00:00:00", (9, 15), (10, 0), 0, -1, 101),
- slot_item("09/10/2026 00:00:00", (10, 5), (11, 5), 1, 0, 102),
- slot_item("09/10/2026 00:00:00", (11, 15), (12, 40), 0, -1, 103),
- ]
- def test_parses_e43_slots_without_exposing_runtime_id_in_repr(self):
- slots = parse_time_slots(double_json(self.items))
- self.assertEqual(len(slots), 3)
- self.assertFalse(slots[0].is_available)
- self.assertTrue(slots[1].is_available)
- self.assertEqual(slots[1].time_label, "10:05 - 11:05")
- self.assertEqual((slots[1].slots_free, slots[1].slots_remaining), (1, 0))
- self.assertNotIn(slots[1].daily_calendar_id, repr(slots[1]))
- def test_filters_and_sorts_by_day_capacity_then_start_time(self):
- items = [
- slot_item("12/10/2026 00:00:00", (9, 0), (10, 0), 4, 3, 201),
- slot_item("09/10/2026 00:00:00", (10, 5), (11, 5), 1, 0, 202),
- slot_item("09/10/2026 00:00:00", (11, 15), (12, 0), 8, 7, 203),
- ]
- candidates = available_slot_candidates(
- tuple(reversed(parse_time_slots(double_json(items)))),
- start_day=date(2026, 10, 9),
- end_day=date(2026, 10, 12),
- )
- self.assertEqual(
- tuple((item.day, item.slots_free, item.start_time) for item in candidates),
- (
- (date(2026, 10, 9), 8, time(11, 15)),
- (date(2026, 10, 9), 1, time(10, 5)),
- (date(2026, 10, 12), 4, time(9, 0)),
- ),
- )
- def test_rejects_missing_invalid_or_conflicting_slot_fields(self):
- missing = self.items[1].copy()
- missing.pop("IDCalendarioServizioGiornaliero")
- self.assert_protocol_error(
- "field_missing",
- lambda: parse_time_slots(double_json([missing])),
- )
- invalid_cases = []
- end_before_start = copy.deepcopy(self.items[1])
- end_before_start["OrarioFineFascia"] = time_value(9, 0)
- invalid_cases.append((end_before_start, "time_range_invalid"))
- invalid_hour = copy.deepcopy(self.items[1])
- invalid_hour["OrarioInizioFascia"] = time_value(24, 0)
- invalid_cases.append((invalid_hour, "time_invalid"))
- invalid_precision = copy.deepcopy(self.items[1])
- invalid_precision["OrarioInizioFascia"] = time_value(10, 5, seconds=1)
- invalid_cases.append((invalid_precision, "time_precision"))
- invalid_counter = copy.deepcopy(self.items[1])
- invalid_counter["SlotLiberi"] = True
- invalid_cases.append((invalid_counter, "integer_required"))
- conflict = copy.deepcopy(self.items[1])
- conflict["SlotLiberi"] = 0
- conflict["SlotRimanenti"] = 0
- invalid_cases.append((conflict, "inventory_conflict"))
- invalid_id = copy.deepcopy(self.items[1])
- invalid_id["IDCalendarioServizioGiornaliero"] = 0
- invalid_cases.append((invalid_id, "positive_integer_required"))
- for item, expected in invalid_cases:
- with self.subTest(expected=expected):
- self.assert_protocol_error(
- expected,
- lambda item=item: parse_time_slots(double_json([item])),
- )
- def test_rejects_duplicate_time_ranges_and_daily_ids(self):
- duplicate_range = [self.items[1], copy.deepcopy(self.items[1])]
- duplicate_range[1]["IDCalendarioServizioGiornaliero"] = 104
- self.assert_protocol_error(
- "duplicate_time_range",
- lambda: parse_time_slots(double_json(duplicate_range)),
- )
- duplicate_id = [self.items[0], self.items[1]]
- duplicate_id[1] = copy.deepcopy(duplicate_id[1])
- duplicate_id[1]["IDCalendarioServizioGiornaliero"] = 101
- self.assert_protocol_error(
- "duplicate_daily_id",
- lambda: parse_time_slots(double_json(duplicate_id)),
- )
- def test_value_objects_reject_inconsistent_manual_construction(self):
- self.assert_protocol_error(
- "inventory_state_mismatch",
- lambda: CalendarDay(
- day=date(2026, 10, 9),
- slots_free=1,
- slots_remaining=0,
- state=InventoryState.UNAVAILABLE,
- ),
- )
- self.assert_protocol_error(
- "daily_id_invalid",
- lambda: SlotCandidate(
- day=date(2026, 10, 9),
- start_time=time(10, 5),
- end_time=time(11, 5),
- slots_free=1,
- slots_remaining=0,
- state=InventoryState.AVAILABLE,
- daily_calendar_id="not-numeric",
- ),
- )
- class PrecommitTests(ProtocolTestCase):
- def setUp(self):
- self.day = parse_calendar_availability(
- double_json([availability_item("09/10/2026 00:00:00", 1, 0)])
- )[0]
- slots = parse_time_slots(
- double_json(
- [
- slot_item(
- "09/10/2026 00:00:00",
- (9, 15),
- (10, 0),
- 0,
- -1,
- 301,
- ),
- slot_item(
- "09/10/2026 00:00:00",
- (10, 5),
- (11, 5),
- 1,
- 0,
- 302,
- ),
- ]
- )
- )
- self.negative_candidate = slots[0]
- self.candidate = slots[1]
- self.date_state = DateSelectionState(
- planned_day=date(2026, 10, 9),
- matching_availability_count=1,
- timeline_selected_days=(date(2026, 10, 9),),
- content_selected_days=(date(2026, 10, 9),),
- day_disabled=False,
- day_not_available=False,
- day_has_positive_state=True,
- )
- self.slot_state = SlotSelectionState(
- active_slot_count=1,
- active_is_candidate=True,
- active_has_unavailable_class=False,
- active_has_red_dot=False,
- active_hidden_input_count=1,
- active_daily_id_matches_candidate=True,
- active_day_matches_candidate=True,
- active_time_matches_candidate=True,
- active_capacity_matches_candidate=True,
- )
- def test_e44_positive_selection_approves_precommit(self):
- approval = approve_precommit(
- self.day,
- self.candidate,
- self.date_state,
- self.slot_state,
- )
- self.assertIs(approval.calendar_day, self.day)
- self.assertIs(approval.candidate, self.candidate)
- self.assertNotIn(self.candidate.daily_calendar_id, repr(approval))
- def test_state_objects_reject_python_bool_integer_ambiguity(self):
- self.assert_protocol_error(
- "integer_required",
- lambda: replace(
- self.date_state,
- matching_availability_count=True,
- ),
- )
- self.assert_protocol_error(
- "integer_required",
- lambda: replace(
- self.slot_state,
- active_slot_count=True,
- ),
- )
- self.assert_protocol_error(
- "boolean_required",
- lambda: replace(
- self.slot_state,
- active_is_candidate=1,
- ),
- )
- self.assert_protocol_error(
- "date_tuple_required",
- lambda: replace(
- self.date_state,
- timeline_selected_days=[self.day.day],
- ),
- )
- def test_rejects_every_date_selection_conflict(self):
- wrong_day = date(2026, 10, 10)
- mutations = (
- {"planned_day": wrong_day},
- {"matching_availability_count": 0},
- {"matching_availability_count": 2},
- {"timeline_selected_days": ()},
- {"timeline_selected_days": (self.day.day, self.day.day)},
- {"content_selected_days": (wrong_day,)},
- {"day_disabled": True},
- {"day_not_available": True},
- {"day_has_positive_state": False},
- )
- for mutation in mutations:
- with self.subTest(mutation=mutation):
- self.assert_protocol_error(
- "precommit_rejected",
- lambda mutation=mutation: approve_precommit(
- self.day,
- self.candidate,
- replace(self.date_state, **mutation),
- self.slot_state,
- ),
- )
- def test_rejects_every_active_slot_conflict(self):
- mutations = (
- {"active_slot_count": 0},
- {"active_slot_count": 2},
- {"active_is_candidate": False},
- {"active_has_unavailable_class": True},
- {"active_has_red_dot": True},
- {"active_hidden_input_count": 0},
- {"active_hidden_input_count": 2},
- {"active_daily_id_matches_candidate": False},
- {"active_day_matches_candidate": False},
- {"active_time_matches_candidate": False},
- {"active_capacity_matches_candidate": False},
- )
- for mutation in mutations:
- with self.subTest(mutation=mutation):
- self.assert_protocol_error(
- "precommit_rejected",
- lambda mutation=mutation: approve_precommit(
- self.day,
- self.candidate,
- self.date_state,
- replace(self.slot_state, **mutation),
- ),
- )
- def test_rejects_negative_candidate_even_if_dom_marks_it_active(self):
- self.assert_protocol_error(
- "precommit_rejected",
- lambda: approve_precommit(
- self.day,
- self.negative_candidate,
- self.date_state,
- self.slot_state,
- ),
- )
- def test_rejects_negative_calendar_day(self):
- negative_day = parse_calendar_availability(
- double_json([availability_item("09/10/2026 00:00:00", 0, -1)])
- )[0]
- self.assert_protocol_error(
- "precommit_rejected",
- lambda: approve_precommit(
- negative_day,
- self.candidate,
- self.date_state,
- self.slot_state,
- ),
- )
- if __name__ == "__main__":
- unittest.main()
|