import copy import json import unittest from dataclasses import replace from datetime import date, time from plugins.ita_protocol 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()