import copy import json import shutil import subprocess import tempfile import unittest from contextlib import ExitStack, redirect_stdout from io import StringIO from pathlib import Path from types import SimpleNamespace from unittest.mock import Mock, patch from plugins import ita_calendar_book as calendar_book from plugins.ita_calendar_query import AVAILABILITY_PATH, CALENDAR_PATH from plugins.ita_plugin import BOOKING_FORM_DISCOVERY_SCRIPT, ItaPlugin from test import test_debug_ita_calendar_gate as prep_fixtures from test import test_debug_ita_production_query_gate as audit_fixtures from test import test_ita_calendar_book_flow as flow_fixtures from tools import debug_ita_book_gate as gate from tools import debug_ita_calendar_gate as preparation from vs_types import AvailabilityStatus, VSBookResult, VSQueryResult ORIGIN = "https://prenotami.esteri.it" USERNAME = "applicant@example.test" PASSWORD = "private-test-pass" OTP = "012345" def gate_env(): env = prep_fixtures.gate_env() env.update(ITA_BOOK_USERNAME=USERNAME, ITA_BOOK_PASSWORD=PASSWORD) return env class GateListener(flow_fixtures.FakeListener): def stop(self): # Installed DrissionPage stop() dereferences None on a repeated stop. if not self.listening: raise AttributeError("Fixture listener already stopped") super().stop() def start(self, targets, method): # The same listener is used for preparation and the real Book scanner. if targets in (preparation.OTP_PATH, self.page.booking_path): self.starts += 1 self.target = targets self.queue.clear() self.listening = True self.page.events.append("listen-start") else: super().start(targets, method) class GateElement: def __init__(self, page, selector): self.page, self.selector = page, selector def input(self, value, *, clear): if self.selector != "#otp-input" or clear is not True: raise AssertionError("Unexpected input") self.page.otp_value = value if self.page.otp_write_matches else "" def run_js(self, script, value): if script != "return this.value === arguments[0];": raise AssertionError("Unexpected OTP readback") return self.page.otp_value == value def click(self): if self.selector == "#otp-input": return if self.selector == "#otp-send": self.page.otp_clicks += 1 packet = self.page.preparation_packet(preparation.OTP_PATH, "GET") packet.url += "?ServiceID=" + str(self.page.service_id) packet.response.raw_body = json.dumps("SENT") self.page.emit(preparation.OTP_PATH, "GET") if self.page.duplicate_otp: self.page.emit(preparation.OTP_PATH, "GET") elif self.selector == "#btnAvanti": self.page.avanti_clicks += 1 if self.page.auto_accept is not True: raise AssertionError("AVANTI confirmation was not enabled") packet = self.page.preparation_packet(self.page.booking_path, "POST") packet.response.status = self.page.avanti_status packet.response.url = ORIGIN + CALENDAR_PATH packet.response.headers = {"Location": CALENDAR_PATH + "?selectedService=fixture"} self.page.url = ORIGIN + CALENDAR_PATH self.page.emit(self.page.booking_path, "POST") if self.page.duplicate_avanti: self.page.emit(self.page.booking_path, "POST") # The original page's Calendar bootstrap is not Book's fresh scan. self.page.emit(AVAILABILITY_PATH, "POST") else: raise AssertionError("The gate must not click any other control") if self.page.preparation_mutator: self.page.preparation_mutator(packet, self.selector) self.page.listen.queue.append(packet) class GatePage(flow_fixtures.FlowPage): def __init__(self, months=None): super().__init__(months) self.url = ORIGIN + "/UserArea" self.service_id = 4937 self.booking_path = "/Services/Booking/4937" self.driver = audit_fixtures.FakeDriver() self.listen = GateListener(self) self.set = SimpleNamespace(auto_handle_alert=self.auto_handle_alert) self.auto_accept = False self.alert_settings = [] self.otp_value = "" self.otp_write_matches = True self.otp_clicks = self.avanti_clicks = 0 self.duplicate_otp = self.duplicate_avanti = False self.avanti_status = 302 self.preparation_mutator = None self.preflight_changes = {} self.preflight_hook = None self.commands = [] def auto_handle_alert(self, on_off=True, accept=True): self.auto_accept = accept if on_off else False self.alert_settings.append(self.auto_accept) def run_cdp(self, name): self.commands.append(name) return {} def emit(self, path, method="POST"): if path.endswith("InsertNewBooking"): self.guard_final_count += 1 callback = self.driver.immediate_event_handlers.get(preparation.CalendarRequestAudit.EVENT) if callback: callback(request={"url": ORIGIN + path, "method": method}) def preparation_packet(self, path, method): return SimpleNamespace( tab_id=self.tab_id, is_failed=False, url=ORIGIN + path, method=method, response=SimpleNamespace(status=200, raw_body="", url=ORIGIN + path, headers={}), ) def response_packet(self, path, body, items, day=None): self.emit(path) return super().response_packet(path, body, items, day) def ele(self, selector, timeout=None): if selector in ("#otp-send", "#otp-input", "#btnAvanti"): return GateElement(self, selector) return None def run_js(self, script, *args): if "coordinate:ita-book-gate-form-boundary" in script: if self.preflight_hook: self.preflight_hook() return prep_fixtures.booking_preflight_snapshot( pathMatches=self.url == ORIGIN + self.booking_path, otpValuePresent=bool(self.otp_value), otpDisabled=self.otp_clicks > 0, **self.preflight_changes, ) if script == BOOKING_FORM_DISCOVERY_SCRIPT: return {"path": self.booking_path, "form": {"method": "POST", "action_path": self.booking_path}, "fields": [], "buttons": []} if script == preparation.AVANTI_FAILURE_DIAGNOSTIC_SCRIPT: return {"path": self.url.removeprefix(ORIGIN), "otpValuePresent": bool(self.otp_value), "bookingFormPresent": self.url == ORIGIN + self.booking_path} return super().run_js(script, *args) def make_plugin(page): # No constructor, files, browser, real credentials, mail or external service. plugin = ItaPlugin.__new__(ItaPlugin) plugin.group_id = "offline-book-gate" plugin.logger = None plugin.page = page plugin._transient_user_data_path = "/unused/ita-book-gate-test" plugin.mouse = SimpleNamespace(human_click_ele=lambda element: element.click()) plugin.session_create_time = 0 plugin.create_session = Mock(side_effect=lambda: setattr(plugin, "session_create_time", 123.0)) plugin.cleanup = Mock() def enter(apt_type): page.url = ORIGIN + page.booking_path return VSQueryResult(success=True, apt_type=apt_type, availability_status=AvailabilityStatus.NoneAvailable) plugin.query = Mock(side_effect=enter) plugin.book = Mock(wraps=plugin.book) plugin._record_calendar_book_prepared_route = Mock(wraps=plugin._record_calendar_book_prepared_route) return plugin class BookGateFlowTests(unittest.TestCase): def run_gate(self, page=None, *, env=None, execute=True, inputs=None, configure=None, otp_reader=None, before=None, after=None, reservation_hook=None, use_local_query_account=False, verify_receipts=False, submit_once=False, final_confirm=lambda _: "no", review_reader=lambda _: ""): page = page or GatePage() plugin = make_plugin(page) # __del__ invokes cleanup again. Keep a fault-injection mock from raising # an unraisable exception after this test has already asserted its result. self.addCleanup(lambda: setattr(plugin.cleanup, "side_effect", None)) if configure: configure(plugin, page) captured = StringIO() reservation_calls = [] def reservations(_page): self.assertIs(_page, page) reservation_calls.append(True) if reservation_hook: reservation_hook(plugin, page, len(reservation_calls)) return (before if len(reservation_calls) == 1 else after) or preparation.ReservationSnapshot(0, 0) with ExitStack() as stack: factory = stack.enter_context(patch.object(gate, "ItaPlugin", return_value=plugin)) stack.enter_context(patch.object(gate, "resolve_chrome_path", return_value=Path("/fixture/Chrome"))) stack.enter_context(patch.object(preparation, "read_reservation_snapshot", side_effect=reservations)) stack.enter_context(patch.object(preparation.CalendarRequestAudit, "settled_snapshot", lambda audit: audit.snapshot())) stack.enter_context(patch.object(calendar_book, "click_next_month", side_effect=lambda _page: page.next_month())) stack.enter_context(patch.object(calendar_book.time, "sleep")) stack.enter_context(patch.dict(gate.os.environ, {}, clear=True)) stack.enter_context(redirect_stdout(captured)) code = gate.run_book_gate(env or gate_env(), execute=execute, user_inputs=inputs, otp_reader=otp_reader or (lambda: OTP), use_local_query_account=use_local_query_account, verify_receipts=verify_receipts, submit_once=submit_once, final_confirm=final_confirm, review_reader=review_reader) output = captured.getvalue() lines = [line for line in output.splitlines() if line.startswith("ITA_BOOK_GATE_RESULT=")] report = json.loads(lines[-1].split("=", 1)[1]) if lines else None return SimpleNamespace(code=code, report=report, output=output, plugin=plugin, page=page, factory=factory, reservation_calls=reservation_calls) def assert_clean(self, result): result.plugin.cleanup.assert_called_once() self.assertFalse(result.page.listen.listening) self.assertNotIn(preparation.CalendarRequestAudit.EVENT, result.page.driver.immediate_event_handlers) self.assertFalse(result.page.auto_accept) self.assertEqual(result.page.guard_final_count, 0) def test_production_failures_are_distinct_and_diagnostic_precedes_reconciliation(self): cases = ( ("Book date control was not ready before timeout", "date_control_timeout"), ("Book TimeSlots request does not match the current service", "timeslot_service_mismatch"), ("Book slot DOM did not match the response before timeout", "slot_dom_timeout"), ("Book precommit rejected (precommit_rejected)", "precommit_readback_rejected"), ) for message, reason in cases: with self.subTest(reason=reason): page = GatePage() seen = [] original = page.run_js def read(script, *args): if script == gate.BOOK_FAILURE_STATE_SCRIPT: seen.append(True) return book_failure_state() return original(script, *args) def reconcile(plugin, page, count): if count == 2: self.assertEqual(seen, [True]) page.run_js = read with patch.object(calendar_book, "_try_day", side_effect=calendar_book.CalendarBookError(message)): result = self.run_gate(page, reservation_hook=reconcile) self.assertEqual(result.code, 1, result.output) self.assertIn(f'"reason": "{reason}"', result.output) self.assertIn('"readSucceeded": true', result.output) self.assertEqual(result.report["calendarBookCalls"], 1) self.assertEqual(result.report["requests"]["finalRequests"], 0) self.assertEqual(result.report["requests"]["otpRequests"], 1) self.assertEqual(result.report["requests"]["avantiPosts"], 1) self.assertEqual(page.clicks, 0) self.assert_clean(result) def test_production_diagnostic_failure_does_not_replace_original_reason(self): # GatePage deliberately has no implementation of this diagnostic script. with patch.object(calendar_book, "_try_day", side_effect=calendar_book.CalendarBookError( "Book slot click was not acknowledged", )): result = self.run_gate() self.assertEqual(result.code, 1) self.assertIn('"reason": "slot_click_not_acknowledged"', result.output) self.assertIn('"readSucceeded": false', result.output) self.assert_clean(result) def test_full_gate_uses_real_book_and_stops_before_final(self): result = self.run_gate() self.assertEqual(result.code, 0, result.output) report = result.report self.assertIs(report["passed"], True) self.assertEqual(report["outcome"], "pre_final") self.assertEqual((report["entryBookCalls"], report["calendarBookCalls"]), (1, 1)) self.assertEqual(report["requests"], {"otpRequests": 1, "avantiPosts": 1, "availabilityRequests": 2, "finalRequests": 0}) self.assertEqual(report["bookRequestDelta"], {"otpRequests": 0, "avantiPosts": 0, "availabilityRequests": 1, "finalRequests": 0}) self.assertEqual(report["selectedDate"], "2026-10-13") self.assertEqual(report["selectedTime"], "10:05 - 11:05") self.assertIs(report["bookResultSuccess"], False) self.assertEqual(result.plugin.book.call_count, 2) self.assertEqual(result.plugin.query.call_count, 1) self.assertEqual(result.page.clicks, 1) self.assertEqual(result.page.otp_value, OTP) self.assertEqual(result.page.alert_settings, [True, False]) self.assertIsNone(result.plugin._calendar_query_route_key) self.assertEqual(result.plugin._record_calendar_book_prepared_route.call_count, 1) self.assertEqual(len(result.reservation_calls), 2) self.assert_clean(result) for secret in (USERNAME, PASSWORD, OTP, "80000113"): self.assertNotIn(secret, result.output) def test_opt_in_receipt_baseline_uses_real_read_port_and_keeps_calendar(self): from test.test_ita_final_read_port import Browser class AuditedBrowser(Browser): def open_tab(self, **kwargs): tab = super().open_tab(**kwargs) tab.driver = audit_fixtures.FakeDriver() tab.run_cdp = Mock(return_value={}) return tab browser = AuditedBrowser() def configure(plugin, page): page.browser = browser plugin.is_healthy = True inventory = preparation.ReservationSnapshot(1, 0) result = self.run_gate(configure=configure, verify_receipts=True, before=inventory, after=inventory) self.assertEqual(result.code, 0, result.output) self.assertTrue(result.report["receiptBaseline"]["verified"]) self.assertTrue(result.report["receiptBaseline"]["calendarSelectionPreserved"]) self.assertEqual(result.report["receiptBaseline"]["recordCount"], 1) self.assertTrue(all(v == 0 for v in result.report["receiptBaseline"]["businessRequests"].values())) self.assertEqual(len(browser.pages), 1) browser.pages[0].close.assert_called_once() self.assertFalse(browser.pages[0].driver.immediate_event_handlers) self.assertEqual(result.page.otp_clicks, 1) self.assertEqual(result.report["requests"]["finalRequests"], 0) self.assert_clean(result) def test_receipt_verification_remains_opt_in_and_preflight_is_local(self): with patch.object(gate, "_verify_receipt_baseline") as reader: self.assertEqual(self.run_gate().code, 0) self.assertEqual(self.run_gate(execute=False, verify_receipts=True).code, 0) reader.assert_not_called() def test_receipt_baseline_failure_does_not_pass_or_repeat_preparation(self): with patch.object(gate, "_verify_receipt_baseline", side_effect=RuntimeError("PRIVATE-RAW")): result = self.run_gate(verify_receipts=True) self.assertEqual(result.code, 1) self.assertFalse(result.report["passed"]) self.assertNotIn("PRIVATE-RAW", result.output) self.assertEqual(result.page.otp_clicks, 1) self.assertEqual(result.report["requests"]["finalRequests"], 0) self.assert_clean(result) def test_receipt_baseline_cli_flag_is_forwarded(self): with patch.object(gate, "run_book_gate", return_value=0) as runner: self.assertEqual(gate.main(["--preflight", "--verify-receipts"]), 0) self.assertIs(runner.call_args.kwargs["verify_receipts"], True) self.assertIs(runner.call_args.kwargs["execute"], False) def test_final_mode_requires_receipts_and_default_never_calls_final_adapter(self): with patch.object(gate.final_evidence, "FinalEvidenceRun") as final: self.assertEqual(self.run_gate().code, 0) result = self.run_gate(submit_once=True) self.assertEqual(result.code, 1) result.factory.assert_not_called() final.assert_not_called() def test_final_preflight_never_reads_credentials_or_creates_browser_or_fence(self): with patch.object(gate.final_evidence, "require_unused_claim") as check, \ patch.object(gate.final_evidence, "claim_once") as claim, \ patch.object(gate, "_book_credentials") as credentials: result = self.run_gate(execute=False, submit_once=True, verify_receipts=True) self.assertEqual(result.code, 0) check.assert_called_once() claim.assert_not_called() credentials.assert_not_called() result.factory.assert_not_called() def test_existing_final_fence_blocks_before_credentials(self): with patch.object(gate.final_evidence, "require_unused_claim", side_effect=RuntimeError("secret")), \ patch.object(gate, "_book_credentials") as credentials: result = self.run_gate(submit_once=True, verify_receipts=True) self.assertEqual(result.code, 1) credentials.assert_not_called() result.factory.assert_not_called() self.assertNotIn("secret", result.output) def test_final_cli_opt_in_is_forwarded(self): with patch.object(gate, "run_book_gate", return_value=0) as runner: gate.main(["--preflight", "--verify-receipts", "--submit-once"]) self.assertIs(runner.call_args.kwargs["submit_once"], True) self.assertIs(runner.call_args.kwargs["execute"], False) def test_real_final_core_wiring_and_unknown_result_keeps_fence_and_requires_review(self): from test.test_ita_final_read_port import Browser from plugins.ita_booking_final import SubmissionSignal class AuditedBrowser(Browser): def open_tab(self, **kwargs): tab = super().open_tab(**kwargs) tab.driver = audit_fixtures.FakeDriver() tab.run_cdp = Mock(return_value={}) return tab for mode in ("decline", "submit", "interrupt", "duplicate"): with self.subTest(mode=mode), tempfile.TemporaryDirectory() as folder: page = GatePage() browser = AuditedBrowser() def configure(plugin, page): page.browser = browser plugin.is_healthy = True path = Path(folder) / "final.claim" original = gate.final_evidence.FinalEvidenceRun checker = gate.final_evidence.require_unused_claim def native(): self.assertTrue(path.exists()) page.emit("/BookingCalendar/InsertNewBooking", "POST") if mode == "duplicate": page.emit("/BookingCalendar/InsertNewBooking", "POST") if mode == "interrupt": raise KeyboardInterrupt() return SubmissionSignal.UNKNOWN submit = Mock(side_effect=native) review = Mock(return_value="") inventory = preparation.ReservationSnapshot(1, 0) with patch.object(gate.final_evidence, "FinalEvidenceRun", side_effect=lambda *a, **kw: original(*a, **kw, claim_path=path)), \ patch.object(gate.final_evidence, "require_unused_claim", side_effect=lambda p=path: checker(p)), \ patch.object(gate.final_evidence, "NativeFinalSubmitter", return_value=submit): result = self.run_gate(page, configure=configure, verify_receipts=True, submit_once=True, before=inventory, after=inventory, final_confirm=(lambda _: "no") if mode == "decline" else (lambda prompt: prompt.split("'")[1]), review_reader=review) self.assertEqual(result.code, 2 if mode == "decline" else 4, result.output) self.assertFalse(result.report["passed"]) self.assertFalse(result.report["bookResultSuccess"]) self.assertEqual(result.report["requestAuditVerified"], mode != "duplicate") self.assertEqual(submit.call_count, 0 if mode == "decline" else 1) self.assertEqual(review.call_count, 0 if mode == "decline" else 1) self.assertEqual(path.exists(), mode != "decline") self.assertEqual(result.report["requests"]["otpRequests"], 1) self.assertEqual(result.report["requests"]["avantiPosts"], 1) self.assertEqual(result.report["requests"]["finalRequests"], 0 if mode == "decline" else 2 if mode == "duplicate" else 1) result.plugin.cleanup.assert_called_once() self.assertFalse(page.listen.listening) self.assertFalse(page.driver.immediate_event_handlers) self.assertTrue(all(tab.close.call_count == 1 for tab in browser.pages)) self.assertIs(result.plugin.free_config["final_submit_enabled"], False) if mode == "duplicate": self.assertIn('"stage": "final_request_audit"', result.output) for secret in (USERNAME, PASSWORD, OTP, "SYNTHETIC-REFERENCE"): self.assertNotIn(secret, result.output) def test_final_gate_exports_verified_success_and_late_failures_cannot_pass(self): from test.test_ita_final_read_port import Browser from test.test_ita_booking_final import final_packet from plugins.ita_booking_final import inspect_final_packet from plugins.ita_reservation import MONTHS_IT class AuditedBrowser(Browser): def open_tab(self, **kwargs): tab = super().open_tab(**kwargs) tab.driver = audit_fixtures.FakeDriver() tab.run_cdp = Mock(return_value={}) return tab for mode in ("success", "late_duplicate", "cleanup_failure", "reconcile_failure"): with self.subTest(mode=mode), tempfile.TemporaryDirectory() as folder: page, browser = GatePage(), AuditedBrowser() path = Path(folder) / "final.claim" original = gate.final_evidence.FinalEvidenceRun checker = gate.final_evidence.require_unused_claim def configure(plugin, page): page.browser = browser plugin.is_healthy = True if mode == "cleanup_failure": plugin.cleanup.side_effect = RuntimeError("PRIVATE") def create_run(plugin, route, **kwargs): # The real Calendar URL exposes selectedService; the older # preparation fixture omits it. Supply that observed shape. page.url += "?selectedService=Visti%20Nazionali%20e%20Schengen" return original(plugin, route, **kwargs, claim_path=path) def create_native(_page, target, _current): packet = final_packet(target) packet.response.raw_body = "unrecognized response fixture" signal, proof, reason = inspect_final_packet(packet, target) def click(): self.assertTrue(path.exists()) slot = target.approval.candidate shown_day = f"{slot.day.day} {MONTHS_IT[slot.day.month - 1]} {slot.day.year}" assigned = slot.start_time.strftime("%H:%M") table = browser.raw["tables"][0] new = {**table["rows"][0], "reference": "SYNTHETIC-NEW", "detailUrl": "https://prenotami.esteri.it/ReservationDetail/Index/synthetic-new", "date": shown_day, "time": assigned, "status": "Confermata"} table["rows"].append(new) table["count"] = 2 table["info"].update(recordsTotal=2, recordsDisplay=2, end=2) detail = copy.deepcopy(browser.receipt) detail.update(path="/ReservationDetail/Index/synthetic-new", statusCode="2") detail["fields"].update({"Codice Prenotazione": "SYNTHETIC-NEW", "Data": shown_day, "Ora": assigned, "Stato": "Confermata"}) browser.receipts[new["detailUrl"]] = detail page.emit("/BookingCalendar/InsertNewBooking", "POST") return signal native = Mock(side_effect=click) native.submitted_selection = proof native.diagnostic = {"requestMatched": True, "reason": reason} return native def review(_prompt): if mode == "late_duplicate": page.emit("/BookingCalendar/InsertNewBooking", "POST") return "" def reservation_hook(plugin, _page, count): if mode == "reconcile_failure" and count == 2: raise RuntimeError("PRIVATE") with patch.object(gate.final_evidence, "FinalEvidenceRun", side_effect=create_run), \ patch.object(gate.final_evidence, "require_unused_claim", side_effect=lambda p=path: checker(p)), \ patch.object(gate.final_evidence, "NativeFinalSubmitter", side_effect=create_native) as native: result = self.run_gate(page, configure=configure, verify_receipts=True, submit_once=True, before=preparation.ReservationSnapshot(1, 0), after=preparation.ReservationSnapshot(2, 0), final_confirm=lambda prompt: prompt.split("'")[1], review_reader=review, reservation_hook=reservation_hook) self.assertEqual(result.code, {"success": 0, "late_duplicate": 1, "cleanup_failure": 3, "reconcile_failure": 1}[mode], result.output) self.assertEqual(result.report["bookResultSuccess"], mode == "success") self.assertEqual(result.report["passed"], mode == "success") self.assertTrue(result.report["finalEvidence"]["bookingConfirmed"]) self.assertEqual(result.report["finalEvidence"]["submissionSignal"], "unknown") self.assertEqual(native.call_count, 1) self.assertTrue(path.exists()) self.assertFalse(page.driver.immediate_event_handlers) self.assertTrue(all(tab.close.call_count == 1 for tab in browser.pages)) for secret in (USERNAME, PASSWORD, OTP, "SYNTHETIC-NEW", "PRIVATE"): self.assertNotIn(secret, result.output) def test_followed_redirect_200_is_accepted(self): page = GatePage() page.avanti_status = 200 result = self.run_gate(page) self.assertEqual(result.code, 0, result.output) self.assertIn("followed_redirect_200", result.output) self.assert_clean(result) def test_config_not_geography_controls_route(self): env = gate_env() env.update(ITA_ROUTING_KEY="slot.other.it.tourist", ITA_CITY="Another City", ITA_SERVICE_ID="9001") page = GatePage() page.service_id, page.booking_path = 9001, "/Services/Booking/9001" result = self.run_gate(page, env=env) self.assertEqual(result.code, 0, result.output) self.assertEqual(result.plugin._calendar_book_prepared_context[4].service_id, 9001) def test_default_preflight_does_not_load_credentials_or_create_browser(self): for reuse in (False, True): with self.subTest(reuse=reuse), patch.object( gate, "_book_credentials", side_effect=AssertionError("No credential access") ), patch.object(gate, "load_local_account") as loader: result = self.run_gate(execute=False, use_local_query_account=reuse) self.assertEqual(result.code, 0, result.output) loader.assert_not_called() result.factory.assert_not_called() result.plugin.create_session.assert_not_called() self.assertEqual(result.reservation_calls, []) def test_local_account_reuse_still_uses_independent_prefinal_book_flow(self): with patch.object(gate, "load_local_account", return_value=SimpleNamespace( username=USERNAME, password=PASSWORD, )) as loader, patch.object(gate, "_get_credentials") as prompt: result = self.run_gate(use_local_query_account=True) loader.assert_called_once_with(gate.ITA_QUERY_ACCOUNT_FILE) prompt.assert_not_called() self.assertEqual(result.code, 0, result.output) self.assertTrue(result.report["passed"]) self.assertFalse(result.report["bookResultSuccess"]) self.assertEqual(result.report["requests"]["finalRequests"], 0) self.assertEqual(result.plugin.config.account.username, USERNAME) self.assertIsNone(result.plugin._calendar_query_route_key) self.assertIsNone(result.plugin.free_config.get(gate.PERSISTENT_BROWSER_PROFILE_KEY)) self.assertIsNone(getattr(result.plugin, "_persistent_profile_path", None)) self.assertEqual(result.plugin.book.call_count, 2) self.assertIn("source=local_query_file", result.output) for secret in (USERNAME, PASSWORD, OTP): self.assertNotIn(secret, result.output) self.assert_clean(result) def test_invalid_local_account_stops_before_browser_without_fallback(self): with patch.object(gate, "load_local_account", side_effect=gate.LocalAccountConfigurationError( f"untrusted loader detail {USERNAME} {PASSWORD}", )), patch.object(gate, "_get_credentials") as prompt: result = self.run_gate(use_local_query_account=True) self.assertEqual(result.code, 1) self.assertFalse(result.report["passed"]) result.factory.assert_not_called() result.plugin.create_session.assert_not_called() prompt.assert_not_called() self.assertEqual(result.page.otp_clicks, 0) self.assertEqual(result.page.avanti_clicks, 0) self.assertEqual(result.reservation_calls, []) self.assertIn("applicant_credentials", result.output) for secret in (USERNAME, PASSWORD, "untrusted loader detail"): self.assertNotIn(secret, result.output) def test_calendar_service_failure_retains_business_exit_and_safe_diagnostic(self): page = GatePage() page.context_count = 0 result = self.run_gate(page) self.assertEqual(result.code, 1, result.output) self.assertFalse(result.report["passed"]) self.assertEqual(result.report["calendarBookCalls"], 0) self.assertEqual(result.report["requests"], { "otpRequests": 1, "avantiPosts": 1, "availabilityRequests": 1, "finalRequests": 0, }) diagnostic = json.loads(next(line.split("=", 1)[1] for line in result.output.splitlines() if line.startswith("ITA_BOOK_GATE_CALENDAR_DIAGNOSTIC="))) self.assertEqual(diagnostic["controlCount"], 0) self.assertTrue(diagnostic["readSucceeded"]) self.assertTrue(diagnostic["afterFailure"]) self.assertIn('"reason": "calendar_service_unidentified"', result.output) self.assertNotIn("cleanup_listener", result.output) self.assertEqual(page.listen.stops, 2) # OTP and AVANTI; no third stop. self.assert_clean(result) def test_calendar_identifier_shapes_stay_rejected_without_logging_values(self): for value in ("", " ", "x" * 129, 7002, None): with self.subTest(value_type=type(value).__name__), patch.object( gate, "CALENDAR_READY_TIMEOUT_SECONDS", 0, ): page = GatePage() page.service = value result = self.run_gate(page) self.assertEqual(result.code, 1, result.output) self.assertEqual(result.report["calendarBookCalls"], 0) reason = "calendar_service_not_ready" if value == "" else "calendar_service_unidentified" self.assertIn(f'"reason": "{reason}"', result.output) diagnostic = json.loads(next(line.split("=", 1)[1] for line in result.output.splitlines() if line.startswith("ITA_BOOK_GATE_CALENDAR_DIAGNOSTIC="))) self.assertEqual(diagnostic["valueType"], type(value).__name__) self.assertEqual(diagnostic["valueLength"], len(value) if isinstance(value, str) else None) self.assertFalse(diagnostic["valueAccepted"]) self.assertNotIn("value", diagnostic) self.assertNotIn("x" * 129, result.output) self.assert_clean(result) def test_calendar_initialization_can_finish_after_document_loaded(self): page = GatePage() original_run_js = page.run_js reads = [] def delayed(script, *args): result = original_run_js(script, *args) if script == calendar_book.RUNTIME_SERVICE_SCRIPT: reads.append(True) if len(reads) == 1: return {**result, "value": ""} return result page.run_js = delayed result = self.run_gate(page) self.assertEqual(result.code, 0, result.output) self.assertGreater(len(reads), 1) self.assertEqual(result.report["calendarBookCalls"], 1) self.assertEqual(result.report["requests"]["otpRequests"], 1) self.assertEqual(result.report["requests"]["avantiPosts"], 1) self.assertEqual(result.report["requests"]["finalRequests"], 0) self.assert_clean(result) def test_diagnostic_read_failure_does_not_replace_the_primary_error(self): page = GatePage() original_run_js = page.run_js def run_js(script, *args): if script == calendar_book.RUNTIME_SERVICE_SCRIPT: raise RuntimeError(f"{USERNAME} {PASSWORD} private-response") return original_run_js(script, *args) page.run_js = run_js result = self.run_gate(page) self.assertEqual(result.code, 1, result.output) self.assertIn('"readSucceeded": false', result.output) self.assertIn('"reason": "calendar_service_unidentified"', result.output) for secret in (USERNAME, PASSWORD, "private-response"): self.assertNotIn(secret, result.output) self.assert_clean(result) def test_active_listener_cleanup_failure_is_not_silenced(self): def reservation_hook(plugin, page, count): if count == 2: page.listen.listening = True page.listen.stop = Mock(side_effect=AttributeError("active listener failed")) result = self.run_gate(reservation_hook=reservation_hook) self.assertEqual(result.code, 3) self.assertFalse(result.report["passed"]) self.assertIn("cleanup_listener", result.output) result.page.listen.stop.assert_called_once() result.plugin.cleanup.assert_called_once() self.assertNotIn(preparation.CalendarRequestAudit.EVENT, result.page.driver.immediate_event_handlers) self.assertEqual(result.page.guard_final_count, 0) def test_no_route_fallback_is_allowed(self): for name in prep_fixtures.gate_env(): with self.subTest(missing=name): env = gate_env() del env[name] result = self.run_gate(env=env) self.assertEqual(result.code, 1) result.factory.assert_not_called() def test_bad_preferences_fail_before_credentials(self): for inputs in ({"expected_start_date": "20260230"}, {"username": "query@example.test"}, {"expected_start_date": "2026-11-01", "expected_end_date": "2026-10-01"}): with self.subTest(inputs=inputs), patch.object(gate, "_book_credentials") as credentials: result = self.run_gate(inputs=inputs) self.assertEqual(result.code, 1) credentials.assert_not_called() result.factory.assert_not_called() def test_preferences_reach_real_book_without_changing_input(self): page = GatePage([flow_fixtures.month("2026-10", {13: 1, 14: 1})]) inputs = {"expected_start_date": "2026-10-14", "expected_end_date": "2026-10-14"} original = copy.deepcopy(inputs) result = self.run_gate(page, inputs=inputs) self.assertEqual(result.code, 0, result.output) self.assertEqual(result.report["selectedDate"], "2026-10-14") self.assertEqual(page.date_clicks, ["2026-10-14"]) self.assertEqual(inputs, original) def test_entry_unavailable_does_not_send_otp(self): def configure(plugin, page): plugin.query = Mock(return_value=VSQueryResult(success=False)) result = self.run_gate(configure=configure) self.assertEqual(result.code, 2, result.output) self.assertFalse(result.report["passed"]) self.assertEqual(result.report["calendarBookCalls"], 0) self.assertEqual(result.page.otp_clicks, 0) self.assert_clean(result) def test_calendar_no_inventory_is_not_a_positive_gate(self): page = GatePage([flow_fixtures.month("2026-10", {13: 0})]) result = self.run_gate(page, inputs={"expected_end_date": "2026-10-31"}) self.assertEqual(result.code, 2, result.output) self.assertFalse(result.report["selectionVerified"]) self.assertFalse(result.report["passed"]) self.assertEqual(page.clicks, 0) self.assert_clean(result) def test_form_preflight_failure_does_not_send_otp(self): page = GatePage() page.preflight_changes = {"unknownRequiredCount": 1} result = self.run_gate(page) self.assertEqual(result.code, 1) self.assertEqual(page.otp_clicks, 0) self.assert_clean(result) def test_otp_must_really_be_written_before_avanti(self): page = GatePage() page.otp_write_matches = False result = self.run_gate(page) self.assertEqual(result.code, 1) self.assertEqual((page.otp_clicks, page.avanti_clicks), (1, 0)) self.assert_clean(result) def test_bad_manual_code_never_retries_or_reaches_avanti(self): for value in ("", "123456", "123 abc", None): with self.subTest(value=value): result = self.run_gate(otp_reader=lambda: value) self.assertEqual(result.code, 1) self.assertEqual((result.page.otp_clicks, result.page.avanti_clicks), (1, 0)) self.assert_clean(result) def test_cancel_at_manual_otp_reconciles_and_cleans_without_retry(self): reader = Mock(side_effect=KeyboardInterrupt) result = self.run_gate(otp_reader=reader) self.assertEqual(result.code, 130) self.assertEqual((result.page.otp_clicks, result.page.avanti_clicks), (1, 0)) self.assertEqual(len(result.reservation_calls), 2) self.assert_clean(result) def test_eof_at_manual_otp_is_safe_cancellation(self): result = self.run_gate(otp_reader=Mock(side_effect=EOFError)) self.assertEqual(result.code, 130) self.assert_clean(result) def test_duplicate_otp_is_detected_before_reading_code(self): page = GatePage() page.duplicate_otp = True reader = Mock(return_value=OTP) result = self.run_gate(page, otp_reader=reader) self.assertEqual(result.code, 1) reader.assert_not_called() self.assertEqual(page.avanti_clicks, 0) self.assertEqual(result.report["requests"]["otpRequests"], 2) self.assert_clean(result) def test_duplicate_avanti_never_records_prepared_context(self): page = GatePage() page.duplicate_avanti = True result = self.run_gate(page) self.assertEqual(result.code, 1) result.plugin._record_calendar_book_prepared_route.assert_not_called() self.assertEqual(page.refreshes, 0) self.assert_clean(result) def test_preparation_packets_are_bound_to_tab_service_and_response(self): changes = ( lambda packet: setattr(packet, "tab_id", "old-query-tab"), lambda packet: setattr(packet, "is_failed", True), lambda packet: setattr(packet.response, "status", True), lambda packet: setattr(packet, "url", ORIGIN + preparation.OTP_PATH + "?ServiceID=9001"), lambda packet: setattr(packet.response, "raw_body", json.dumps("NOT_SENT")), ) for index, mutate in enumerate(changes): with self.subTest(index=index): page = GatePage() page.preparation_mutator = lambda packet, selector: mutate(packet) if selector == "#otp-send" else None result = self.run_gate(page) self.assertEqual(result.code, 1) self.assertEqual(page.avanti_clicks, 0) self.assert_clean(result) def test_avanti_wrong_tab_or_transition_does_not_attest_calendar(self): for variant in ("wrong-tab", "wrong-target", "bad-status", "response-form"): with self.subTest(variant=variant): page = GatePage() def mutate(packet, selector): if selector != "#btnAvanti": return if variant == "wrong-tab": packet.tab_id = "another-tab" elif variant == "wrong-target": packet.response.headers["Location"] = "https://other.example/BookingCalendar" elif variant == "bad-status": packet.response.status = 500 else: packet.response.status = 200 packet.response.url = ORIGIN + page.booking_path page.preparation_mutator = mutate result = self.run_gate(page) self.assertEqual(result.code, 1) result.plugin._record_calendar_book_prepared_route.assert_not_called() self.assertEqual(page.refreshes, 0) self.assert_clean(result) def test_avanti_timeout_does_not_repeat_and_disables_auto_accept(self): with patch.object(preparation, "_wait_for_calendar", side_effect=preparation.CalendarGateError("timeout")): result = self.run_gate() self.assertEqual(result.code, 1) self.assertEqual(result.page.avanti_clicks, 1) self.assertEqual(result.page.alert_settings, [True, False]) self.assert_clean(result) def test_account_route_tab_and_login_drift_stop_before_otp(self): mutations = ( lambda plugin, page: setattr(plugin.config.account, "username", "other@example.test"), lambda plugin, page: setattr(page, "tab_id", "other-tab"), lambda plugin, page: setattr(plugin, "session_create_time", 124.0), lambda plugin, page: plugin.free_config.update(final_submit_enabled=True), lambda plugin, page: setattr(plugin, "_calendar_query_route_key", "slot.query.it.tourist"), lambda plugin, page: plugin.free_config["apt_configs"]["slot.hkg.it.tourist"].update(service_id=9001), ) for index, mutate in enumerate(mutations): with self.subTest(index=index): def configure(plugin, page): page.preflight_hook = lambda: mutate(plugin, page) result = self.run_gate(configure=configure) self.assertEqual(result.code, 1) self.assertEqual(result.page.otp_clicks, 0) self.assert_clean(result) def test_account_change_while_reading_otp_does_not_write_code(self): state = {} def configure(plugin, page): state["plugin"] = plugin def reader(): state["plugin"].config.account.username = "another@example.test" return OTP result = self.run_gate(configure=configure, otp_reader=reader) self.assertEqual(result.code, 1) self.assertEqual(result.page.otp_value, "") self.assertEqual(result.page.avanti_clicks, 0) self.assert_clean(result) def test_existing_calendar_is_not_accepted_as_a_fresh_login(self): page = GatePage() page.url = ORIGIN + CALENDAR_PATH result = self.run_gate(page) self.assertEqual(result.code, 1) result.plugin.book.assert_not_called() self.assertEqual(page.otp_clicks, 0) def test_unexpected_book_success_is_never_reported_as_gate_success(self): def configure(plugin, page): plugin.book = Mock(return_value=VSBookResult(success=True, urn="private-reservation")) result = self.run_gate(configure=configure) self.assertEqual(result.code, 1) self.assertEqual(result.page.otp_clicks, 0) self.assertNotIn("private-reservation", result.output) self.assert_clean(result) def test_lost_selection_after_book_is_not_clicked_again(self): def configure(plugin, page): original = plugin.book def call(*args, **kwargs): result = original(*args, **kwargs) if page.url.endswith(CALENDAR_PATH): page.active = False return result plugin.book = Mock(side_effect=call) result = self.run_gate(configure=configure) self.assertEqual(result.code, 1) self.assertEqual(result.page.clicks, 1) self.assert_clean(result) def test_otp_during_book_fails_audit_without_repeating_preparation(self): page = GatePage() original = page.refresh def refresh(): original() page.emit(preparation.OTP_PATH, "GET") page.refresh = refresh result = self.run_gate(page) self.assertEqual(result.code, 1) self.assertEqual((page.otp_clicks, page.avanti_clicks), (1, 1)) self.assertFalse(result.report["passed"]) self.assert_clean(result) def test_final_request_after_avanti_is_detected_before_book(self): page = GatePage() page.preparation_mutator = lambda packet, selector: ( page.emit("/BookingCalendar/InsertNewBooking") if selector == "#btnAvanti" else None ) result = self.run_gate(page) self.assertEqual(result.code, 1) result.plugin._record_calendar_book_prepared_route.assert_not_called() self.assertEqual(page.refreshes, 0) self.assertEqual(result.report["requests"]["finalRequests"], 1) self.assertFalse(page.auto_accept) def test_reservation_change_prevents_positive_gate(self): result = self.run_gate(after=preparation.ReservationSnapshot(1, 0)) self.assertEqual(result.code, 1) self.assertFalse(result.report["passed"]) self.assert_clean(result) def test_waitlist_change_prevents_positive_gate(self): result = self.run_gate(after=preparation.ReservationSnapshot(0, 1)) self.assertEqual(result.code, 1) self.assertFalse(result.report["passed"]) def test_late_business_request_during_reconciliation_is_detected(self): def hook(plugin, page, count): if count == 2: page.emit(AVAILABILITY_PATH) result = self.run_gate(reservation_hook=hook) self.assertEqual(result.code, 1) self.assertFalse(result.report["passed"]) self.assert_clean(result) def test_failed_read_only_reconciliation_does_not_publish_passed(self): def hook(plugin, page, count): if count == 2: raise RuntimeError("private-state") result = self.run_gate(reservation_hook=hook) self.assertEqual(result.code, 1) self.assertNotIn("private-state", result.output) self.assert_clean(result) def test_cleanup_failure_has_distinct_return_code(self): def configure(plugin, page): plugin.cleanup.side_effect = RuntimeError("private browser details") result = self.run_gate(configure=configure) self.assertEqual(result.code, 3) self.assertFalse(result.report["passed"]) self.assertNotIn("private browser details", result.output) def test_provider_exception_does_not_log_credentials_code_or_body(self): def configure(plugin, page): plugin.create_session.side_effect = RuntimeError(f"{USERNAME} {PASSWORD} {OTP} BODY private") result = self.run_gate(configure=configure) self.assertEqual(result.code, 1) for secret in (USERNAME, PASSWORD, OTP, "BODY private"): self.assertNotIn(secret, result.output) result.plugin.cleanup.assert_called_once() class BookGateInputTests(unittest.TestCase): def test_cleanup_avoids_installed_sdk_duplicate_stop_failure(self): from DrissionPage._units.listener import Listener listener = Listener.__new__(Listener) listener.listening = False driver = listener._driver = Mock() listener.stop() driver.stop.assert_called_once() self.assertIsNone(listener._driver) # Prove the actual SDK failure, then exercise our guarded cleanup. with self.assertRaises(AttributeError): listener.stop() gate._stop_listener_if_active(SimpleNamespace(listen=listener)) driver.stop.assert_called_once() def test_cleanup_stops_an_active_listener(self): listener = SimpleNamespace(listening=True, stop=Mock()) gate._stop_listener_if_active(SimpleNamespace(listen=listener)) listener.stop.assert_called_once() def test_diagnostic_only_reads_the_calendar_and_never_emits_service_value(self): for path in ("/BookingCalendar", "/Services"): with self.subTest(path=path): page = SimpleNamespace(url=ORIGIN + path, run_js=Mock(return_value={ "path": path, "count": 1, "value": PASSWORD, })) captured = StringIO() with redirect_stdout(captured): gate._print_calendar_preparation_diagnostic(page) self.assertNotIn(PASSWORD, captured.getvalue()) diagnostic = json.loads(captured.getvalue().split("=", 1)[1]) if path == "/BookingCalendar": self.assertEqual(diagnostic["valueLength"], len(PASSWORD)) page.run_js.assert_called_once_with(calendar_book.RUNTIME_SERVICE_SCRIPT) else: self.assertFalse(diagnostic["pathMatches"]) page.run_js.assert_not_called() def test_preparation_reasons_only_allow_exact_known_messages(self): for message, reason in (*gate._PREPARATION_FAILURES.items(), (PASSWORD, None)): with self.subTest(reason=reason): captured = StringIO() with redirect_stdout(captured): gate._failure("calendar_preparation", gate.BizLogicError(message)) failure = json.loads(captured.getvalue().split("=", 1)[1]) self.assertEqual(failure.get("reason"), reason) self.assertNotIn(PASSWORD, captured.getvalue()) def test_credentials_project_only_book_fields(self): env = {"ITA_USERNAME": "query@example.test", "ITA_PASSWORD": "query-secret", "ITA_BOOK_USERNAME": USERNAME, "ITA_BOOK_PASSWORD": PASSWORD} with patch.object(gate, "_get_credentials", return_value=(USERNAME, PASSWORD)) as helper, \ patch.object(gate, "load_local_account") as loader, redirect_stdout(StringIO()): self.assertEqual(gate._book_credentials(env), (USERNAME, PASSWORD)) helper.assert_called_once_with({"ITA_USERNAME": USERNAME, "ITA_PASSWORD": PASSWORD}, non_interactive=False) loader.assert_not_called() def test_query_credentials_do_not_supply_fallback(self): with patch.object(gate, "_get_credentials", return_value=(USERNAME, PASSWORD)) as helper, \ patch.object(gate, "load_local_account") as loader, redirect_stdout(StringIO()): gate._book_credentials({"ITA_USERNAME": "query@example.test", "ITA_PASSWORD": "query-secret"}) helper.assert_called_once_with({"ITA_USERNAME": "", "ITA_PASSWORD": ""}, non_interactive=False) loader.assert_not_called() def test_local_account_opt_in_uses_complete_saved_pair_and_never_prompts(self): env = {"ITA_BOOK_USERNAME": "other@example.test", "ITA_BOOK_PASSWORD": "other-pass", "ITA_USERNAME": "general@example.test", "ITA_PASSWORD": "general-pass"} captured = StringIO() with patch.object(gate, "load_local_account", return_value=SimpleNamespace( username=USERNAME, password=PASSWORD, )) as loader, patch.object(gate, "_get_credentials") as prompt, redirect_stdout(captured): self.assertEqual( gate._book_credentials(env, use_local_query_account=True), (USERNAME, PASSWORD), ) loader.assert_called_once_with(gate.ITA_QUERY_ACCOUNT_FILE) prompt.assert_not_called() self.assertIn("source=local_query_file", captured.getvalue()) for secret in (USERNAME, PASSWORD, *env.values()): self.assertNotIn(secret, captured.getvalue()) def test_local_loader_errors_are_safe_and_never_switch_credentials(self): for reason in ("missing file", "unsafe permissions", "invalid JSON", "missing password"): with self.subTest(reason=reason), patch.object( gate, "load_local_account", side_effect=gate.LocalAccountConfigurationError(f"{reason} {PASSWORD}"), ), patch.object(gate, "_get_credentials") as prompt: with self.assertRaises(gate.BookGateError) as caught: gate._book_credentials(gate_env(), use_local_query_account=True) prompt.assert_not_called() self.assertNotIn(PASSWORD, str(caught.exception)) self.assertIn("config/ita_query_account.local.json", str(caught.exception)) def test_local_secrets_are_not_part_of_source_fingerprint(self): self.assertNotIn(gate.ITA_QUERY_ACCOUNT_FILE, gate.BOOK_GATE_SOURCE_PATHS) self.assertIn(gate.REPO_ROOT / "utils" / "local_account.py", gate.BOOK_GATE_SOURCE_PATHS) def test_cli_defaults_to_no_external_actions(self): with patch.object(gate, "run_book_gate", return_value=0) as runner: self.assertEqual(gate.main([]), 0) self.assertIs(runner.call_args.kwargs["execute"], False) self.assertIs(runner.call_args.kwargs["use_local_query_account"], False) def test_cli_forwards_explicit_local_account_selection(self): for mode, execute in (("--preflight", False), ("--run", True)): with self.subTest(mode=mode), patch.object(gate, "run_book_gate", return_value=0) as runner: self.assertEqual(gate.main(["--use-local-query-account", mode]), 0) self.assertIs(runner.call_args.kwargs["execute"], execute) self.assertIs(runner.call_args.kwargs["use_local_query_account"], True) def test_cli_maps_vfs_preferences_to_real_inputs(self): with patch.object(gate, "run_book_gate", return_value=0) as runner: gate.main(["--run", "--expected-start-date", "2026-10-01", "--expected-end-date", "2026-12-31"]) self.assertIs(runner.call_args.kwargs["execute"], True) self.assertEqual(runner.call_args.kwargs["user_inputs"], {"expected_start_date": "2026-10-01", "expected_end_date": "2026-12-31"}) def test_audit_rejects_non_integer_counts(self): audit = Mock() for value in (True, -1, "0", None): audit.settled_snapshot.return_value = { "otpRequests": value, "avantiPosts": 0, "availabilityRequests": 0, "finalRequests": 0, } with self.subTest(value=value), self.assertRaises(gate.BookGateError): gate._counts(audit) def test_no_query_session_loader_or_profile_setup_or_final_click_in_tool(self): source = Path(gate.__file__).read_text() # Only the explicitly read-only diagnostic may mention the final button. self.assertEqual(source.count(gate.BOOK_FAILURE_STATE_SCRIPT), 1) source = source.replace(gate.BOOK_FAILURE_STATE_SCRIPT, "") for forbidden in ("_get_query_credentials(", "_prepare_query_profile(", "prepare_ita_query_profile(", "_record_calendar_query_prepared_route(", "#btnPrenotaNoOtp", "InsertNewBooking"): self.assertNotIn(forbidden, source) self.assertIn("preparation.OneShotAction", source) self.assertIn("plugin.book(trigger", source) def book_failure_state(): result = {key: False for key in gate._BOOK_STATE_BOOLS} result.update({key: 0 for key in gate._BOOK_STATE_COUNTS}) result.update(pathMatches=True, serviceValuePresent=True, serviceControlCount=1, finalButtonCount=1, finalGuarded=True, slotStates=[]) return result class BookProductionDiagnosticTests(unittest.TestCase): def test_static_reason_messages_exist_in_the_current_producer_source(self): source = Path(calendar_book.__file__).read_text() + (gate.REPO_ROOT / "plugins/ita_plugin.py").read_text() for message in gate._PRODUCTION_BOOK_FAILURES: if message == "Book precommit rejected (precommit_rejected)": continue # Produced by the existing protocol-code formatter. with self.subTest(message=message): self.assertIn(message, source) def test_plugin_internal_failure_keeps_its_classification(self): output = StringIO() with redirect_stdout(output): gate._failure("production_book", gate.BizLogicError( "Italy Book Calendar failed before final confirmation", )) failure = json.loads(output.getvalue().split("=", 1)[1]) self.assertEqual(failure["reason"], "calendar_internal_failure") def capture_state(self, raw): page = SimpleNamespace(url=ORIGIN + CALENDAR_PATH, run_js=Mock(return_value=raw)) output = StringIO() with redirect_stdout(output): gate._print_production_book_diagnostic(page) page.run_js.assert_called_once_with(gate.BOOK_FAILURE_STATE_SCRIPT) return output.getvalue(), json.loads(output.getvalue().split("=", 1)[1]) def test_all_allowlisted_failures_publish_only_the_fixed_reason(self): for message, reason in gate._PRODUCTION_BOOK_FAILURES.items(): with self.subTest(reason=reason): output = StringIO() with redirect_stdout(output): gate._failure("production_book", gate.BizLogicError(message)) result = json.loads(output.getvalue().split("=", 1)[1]) self.assertEqual(result["reason"], reason) self.assertNotEqual(result["message"], message) def test_unknown_body_and_wrong_stage_or_exception_type_are_not_exposed(self): secret = f"Book slot DOM did not match the response before timeout {USERNAME} {PASSWORD} {OTP}" for stage, error in (("production_book", gate.BizLogicError(secret)), ("production_book", RuntimeError(secret)), ("calendar_preparation", gate.BizLogicError(secret))): with self.subTest(stage=stage, error_type=type(error).__name__): output = StringIO() with redirect_stdout(output): gate._failure(stage, error) for value in (USERNAME, PASSWORD, OTP): self.assertNotIn(value, output.getvalue()) self.assertNotIn('"reason": "slot_dom_timeout"', output.getvalue()) def test_protocol_messages_emit_a_category_without_echoing_dynamic_code(self): for label, expected in (("TimeSlots protocol", "timeslot_protocol_rejected"), ("Calendar protocol", "calendar_protocol_rejected"), ("precommit", "precommit_readback_rejected")): output = StringIO() with redirect_stdout(output): gate._failure("production_book", gate.BizLogicError(f"Book {label} rejected (synthetic_code)")) self.assertIn(f'"reason": "{expected}"', output.getvalue()) self.assertNotIn("synthetic_code", output.getvalue()) def test_valid_shape_is_reported_as_after_failure_not_original_error_state(self): state = book_failure_state() state["slotStates"] = [{**{key: False for key in gate._BOOK_SLOT_BOOLS}, "hiddenInputCount": 1}] state["slotCount"] = 1 _, result = self.capture_state(state) self.assertTrue(result["afterFailure"]) self.assertTrue(result["readSucceeded"]) self.assertEqual(result["state"], state) def test_unexpected_fields_and_types_fail_closed_without_partial_values(self): bad = [] state = book_failure_state() bad.append({**state, "serviceValue": PASSWORD}) bad.append({**state, "serviceValuePresent": PASSWORD}) bad.append({**state, "slotCount": PASSWORD}) bad.append({**state, "slotCount": True}) bad.append({**state, "slotStates": [{"body": PASSWORD}]}) bad.append({**state, "slotStates": [{}] * 13}) bad.append({**state, "timeSlotResourceEntries": -1}) for raw in bad: with self.subTest(raw_keys=tuple(raw)): output, result = self.capture_state(raw) self.assertFalse(result["readSucceeded"]) self.assertNotIn("state", result) self.assertNotIn(PASSWORD, output) def test_non_calendar_page_is_not_read(self): page = SimpleNamespace(url=ORIGIN + "/Reservation", run_js=Mock()) output = StringIO() with redirect_stdout(output): gate._print_production_book_diagnostic(page) page.run_js.assert_not_called() self.assertIn('"readSucceeded": false', output.getvalue()) @unittest.skipUnless(shutil.which("node"), "Node is required for the read-only JS fixture") def test_readonly_script_distinguishes_offscreen_and_obscured_slots(self): fixture = r""" const script = process.argv[1], mode = process.argv[2]; let measured = []; const makeSlot = (index) => ({ index, classList: {contains: value => index === 0 && value === 'notAvailableFascia'}, querySelector: () => null, querySelectorAll: () => [{get value() {throw Error('must not read slot identity');}}], getBoundingClientRect: () => { measured.push(index); const left = index === 1 ? 1100 : 10; return {left, right:left+100, top:20, bottom:60, width:100, height:40}; }, contains: () => false, get innerText() {throw Error('must not read slot text');}, click: () => {throw Error('must not click');}, }); const slots = Array.from({length:mode === 'many' ? 13 : 3}, (_, index) => makeSlot(index)); const timelineLink = {dataset:{date:'2026-10-13'}}; const document = { querySelector: selector => selector === '.selected' ? timelineLink : null, querySelectorAll: selector => { if (selector === '#idServizio') return [{value:'private-runtime-identifier'}]; if (selector === '.events a.selected') return [timelineLink]; if (selector === '.events-content li.selected') return [{dataset:{date:'2026-10-13'},querySelectorAll:()=>slots}]; if (selector === '#btnPrenotaNoOtp') return [Object.freeze({disabled:true,dataset:{coordinateFinalGuard:'enabled'}})]; if (selector === '.fascia.act') return []; throw Error('unexpected selector'); }, elementFromPoint: () => slots[0], }; const window = {innerWidth:1000, innerHeight:800, getComputedStyle:()=>({display:'block',visibility:'visible',pointerEvents:'auto',opacity:'1'})}; const location = {origin:'https://prenotami.esteri.it',pathname:'/BookingCalendar'}; const performance = {getEntriesByType:()=>[ {name:location.origin+'/BookingCalendar/RetrieveTimeSlots'}, {name:'https://other.example.test/BookingCalendar/RetrieveTimeSlots'}, {name:'not-a-url'}, ]}; const result = new Function('document','window','location','performance',script)(document,window,location,performance); console.log(JSON.stringify({result,measured})); """ for mode in ("normal", "many"): with self.subTest(mode=mode): result = subprocess.run([shutil.which("node"), "-e", fixture, gate.BOOK_FAILURE_STATE_SCRIPT, mode], text=True, capture_output=True, timeout=10) self.assertEqual(result.returncode, 0, result.stderr) self.assertNotIn("private-runtime-identifier", result.stdout) raw = json.loads(result.stdout)["result"] self.assertTrue(raw["selectedDatesMatch"]) self.assertTrue(raw["firstSelectedIsTimeline"]) self.assertTrue(raw["finalGuarded"]) self.assertEqual(raw["timeSlotResourceEntries"], 1) self.assertFalse(raw["slotStates"][1]["inViewport"]) self.assertTrue(raw["slotStates"][1]["cssVisible"]) self.assertTrue(raw["slotStates"][2]["inViewport"]) self.assertFalse(raw["slotStates"][2]["centerHit"]) self.assertEqual(len(raw["slotStates"]), 12 if mode == "many" else 3) self.assertEqual(raw["slotStatesTruncated"], mode == "many") _, accepted = self.capture_state(raw) self.assertTrue(accepted["readSucceeded"]) class BookGateFormBoundaryScriptTests(unittest.TestCase): def test_valid_boundary_uses_original_preflight_and_native_hidden_sync(self): node = shutil.which("node") if node is None: self.fail("Node is required to validate the real preparation script") config = preparation.build_calendar_gate_config(gate_env(), username=USERNAME, password=PASSWORD) route = gate.resolve_route_config(config.free_config["apt_configs"], "slot.hkg.it.tourist") script = gate._guarded_preflight_script(route, "/Services/Booking/4937") harness = r""" const location = {origin: 'https://prenotami.esteri.it', pathname: '/Services/Booking/4937', href: 'https://prenotami.esteri.it/Services/Booking/4937'}; const hidden = {value: '0'}, companions = {value: '1'}, purposeHidden = {value: '0'}; const booking = {value: '0', options: [{value: '1', textContent: 'Single booking'}], dispatchEvent: () => { hidden.value = '1'; companions.value = '0'; }}; const purpose = {value: '0', options: [{value: '42', textContent: 'Tourism'}], dispatchEvent: () => {}}; const privacy = {checked: false, click() { this.checked = true; }}; const form = {action: location.href, method: 'post', enctype: 'multipart/form-data', querySelectorAll: () => []}; const ids = {typeofbookingddl: booking, ddls_0: purpose, PrivacyCheck: privacy, hiddenTipoPrenotazione: hidden, numAccSelected: companions, hiddenSelezionato_0: purposeHidden}; const selectors = {'#bookingForm': [form], '#otp-input': [{value: ''}], '#otp-send': [{disabled: false}], '#btnAvanti': [{disabled: false}], 'input[name="cf-turnstile-response"]': [{value: 'fixture-only'}]}; const document = {getElementById: (id) => ids[id], querySelector: () => form, querySelectorAll: (selector) => selectors[selector] || []}; const output = new Function('document', 'location', 'window', SCRIPT)(document, location, {location}); if (purposeHidden.value !== '0') throw Error('Must not write purpose hidden before native AVANTI'); process.stdout.write(JSON.stringify(output)); """.replace("SCRIPT", json.dumps(script)) completed = subprocess.run([node, "-e", harness], capture_output=True, text=True, timeout=10) self.assertEqual(completed.returncode, 0, completed.stderr) preparation.validate_booking_preflight(json.loads(completed.stdout)) def test_actual_script_checks_scope_before_reused_form_mutations(self): node = shutil.which("node") if node is None: self.fail("Node is required to validate the real preparation boundary script") config = preparation.build_calendar_gate_config(gate_env(), username=USERNAME, password=PASSWORD) route = gate.resolve_route_config(config.free_config["apt_configs"], "slot.hkg.it.tourist") script = gate._guarded_preflight_script(route, "/Services/Booking/4937") harness = r""" const script = SCRIPT; const scenarios = ['wrongOrigin', 'wrongPath', 'noForm', 'twoForms', 'getForm', 'wrongAction', 'queryAction', 'changedEnctype', 'upload']; for (const scenario of scenarios) { let mutationReads = 0; const location = {origin: 'https://prenotami.esteri.it', pathname: '/Services/Booking/4937', href: 'https://prenotami.esteri.it/Services/Booking/4937'}; const form = {method: 'post', enctype: 'multipart/form-data', action: location.href, querySelectorAll: () => scenario === 'upload' ? [{}] : []}; if (scenario === 'wrongOrigin') location.origin = 'https://other.example'; if (scenario === 'wrongPath') location.pathname = '/BookingCalendar'; if (scenario === 'getForm') form.method = 'get'; if (scenario === 'wrongAction') form.action = 'https://other.example/Services/Booking/4937'; if (scenario === 'queryAction') form.action += '?changed=1'; if (scenario === 'changedEnctype') form.enctype = 'text/plain'; const document = { querySelectorAll: () => scenario === 'noForm' ? [] : scenario === 'twoForms' ? [form, form] : [form], querySelector: () => { mutationReads++; throw Error('Must stop before preflight'); } }; const result = new Function('document', 'location', script)(document, location); if (result.pathMatches !== false || mutationReads !== 0) throw Error(scenario); } process.stdout.write('FORM_BOUNDARY_OK'); """.replace("SCRIPT", json.dumps(script)) completed = subprocess.run([node, "-e", harness], capture_output=True, text=True, timeout=10) self.assertEqual(completed.returncode, 0, completed.stderr) self.assertEqual(completed.stdout, "FORM_BOUNDARY_OK") if __name__ == "__main__": unittest.main()