import copy import json import unittest from datetime import date, time from plugins.ita_plugin import ( MAX_LOOKAHEAD_MONTHS, MAX_PROTOCOL_ITEMS, MAX_PROTOCOL_PAYLOAD_CHARS, CalendarDay, ItaCapability, ItaProtocolError, SlotCandidate, 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.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.assertEqual(result.lookahead_months, 0) 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_inner_json_and_payload_limit_keep_distinct_error_categories(self): self.assert_protocol_error( "inner_json_invalid", lambda: decode_double_json_array(json.dumps("not-json")), ) self.assert_protocol_error( "payload_too_large", lambda: decode_double_json_array(" " * (MAX_PROTOCOL_PAYLOAD_CHARS + 1)), ) 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.assertFalse(days[0].is_available) self.assertTrue(days[1].is_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_then_time_not_capacity(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), 1, time(10, 5)), (date(2026, 10, 9), 8, time(11, 15)), (date(2026, 10, 12), 4, time(9, 0)), ), ) def test_time_components_keep_missing_and_wrong_type_field_locations(self): for key, value, expected in ( ("Hours", None, "field_missing"), ("Minutes", True, "integer_required"), ("Seconds", "0", "integer_required"), ("Milliseconds", False, "integer_required"), ): with self.subTest(key=key): item = copy.deepcopy(self.items[1]) if value is None: del item["OrarioInizioFascia"][key] else: item["OrarioInizioFascia"][key] = value with self.assertRaises(ItaProtocolError) as caught: parse_time_slots(double_json([item])) self.assertEqual(caught.exception.code, expected) self.assertEqual(caught.exception.path, f"time_slots[0].OrarioInizioFascia.{key}") 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_inventory_objects_expose_derived_availability(self): positive = CalendarDay(date(2026, 10, 9), 1, 0) self.assertTrue(positive.is_available) with self.assertRaises(TypeError): CalendarDay( day=date(2026, 10, 9), slots_free=1, slots_remaining=0, is_available=False, ) if __name__ == "__main__": unittest.main()