"""Offline gate tests with the production receipt parsers and passive audit.""" import copy import json import os 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.ita_plugin import DETAIL_READ_SCRIPT, LIST_READ_SCRIPT, DATE_DIAGNOSTIC_SCRIPT, ReservationReadError from test.test_ita_reservation import detail, listing, confirmed_detail, confirmed_listing from test.test_debug_ita_production_query_gate import FakeDriver from tools import debug_ita_reservation as gate class ReceiptPage: def __init__(self): self.url = "https://prenotami.esteri.it/UserArea" self.tab_id = "synthetic-tab" self.driver = FakeDriver() self.before = listing() self.after = copy.deepcopy(self.before) self.receipt = detail() self.urls = [] self.diagnostic_reads = 0 self.on_get = lambda: None self.run_cdp = Mock(return_value={}) self.ele = Mock(return_value=True) def get(self, url, *, retry, timeout): assert retry == 0 and timeout == 30 self.url = url self.urls.append(url) self.on_get() return True def run_js(self, script): if script == LIST_READ_SCRIPT: return copy.deepcopy(self.after if len(self.urls) == 3 else self.before) if script == DETAIL_READ_SCRIPT: return copy.deepcopy(self.receipt) if script == DATE_DIAGNOSTIC_SCRIPT: self.diagnostic_reads += 1 text = self.before["tables"][0]["rows"][0]["date"] return {"path": "/Reservation", "samples": [{"text": text, "rendered": text, "parts": [{"kind": "text", "text": text, "hidden": False}], "partsTruncated": False}], "rowsTruncated": False} raise AssertionError("Only receipt reads are allowed") def emit(self, path, method="GET"): callback = self.driver.immediate_event_handlers[gate.CalendarRequestAudit.EVENT] callback(request={"url": "https://prenotami.esteri.it" + path, "method": method}) def fake_plugin(): plugin = SimpleNamespace(page=ReceiptPage(), session_create_time=1, _persistent_profile_path=None) plugin.set_log = Mock() def set_config(config): plugin.config = config plugin.free_config = config.free_config plugin.set_config = Mock(side_effect=set_config) plugin.create_session = Mock(side_effect=lambda: setattr( plugin.page, "url", "https://prenotami.esteri.it/UserArea")) plugin.cleanup = Mock() plugin.query = Mock(side_effect=AssertionError("Query forbidden")) plugin.book = Mock(side_effect=AssertionError("Book forbidden")) return plugin class ReceiptGateTests(unittest.TestCase): def setUp(self): self.stack = ExitStack() self.addCleanup(self.stack.close) self.plugin = fake_plugin() self.factory = self.stack.enter_context(patch.object(gate, "ItaPlugin", return_value=self.plugin)) self.credentials = self.stack.enter_context(patch.object( gate, "_get_credentials", return_value=("applicant@example.invalid", "SECRET-PASSWORD"))) self.stack.enter_context(patch.object(gate, "resolve_chrome_path", return_value=Path("/synthetic/chrome"))) # Reuse real request classification; only shorten the audit's settled window. self.stack.enter_context(patch.object(gate.CalendarRequestAudit, "settled_snapshot", gate.CalendarRequestAudit.snapshot)) self.stack.enter_context(patch("plugins.ita_plugin.time.sleep")) def run_gate(self, *, execute=True, env=None, **kwargs): output = StringIO() with redirect_stdout(output): code = gate.run_receipt_gate(env or {}, execute=execute, **kwargs) text = output.getvalue() rows = [line for line in text.splitlines() if line.startswith("ITA_RECEIPT_GATE_RESULT=")] result = json.loads(rows[-1].split("=", 1)[1]) if rows else None for secret in ("SECRET-PASSWORD", "applicant@example.invalid", "SYNTHETIC-REFERENCE", "synthetic-link"): self.assertNotIn(secret, text) self.plugin.query.assert_not_called() self.plugin.book.assert_not_called() return code, result, text def test_preflight_has_no_credentials_browser_or_network(self): code, result, text = self.run_gate(execute=False) self.assertEqual(code, 0) self.assertIsNone(result) self.assertIn("external_requests=0 credentials_read=false browser_created=false", text) self.factory.assert_not_called() self.credentials.assert_not_called() def test_only_explicit_boolean_enables_run(self): for value in (1, "true", None): code, result, _ = self.run_gate(execute=value) self.assertEqual(code, 1) self.assertEqual(result["reason"], "invalid_execution_flag") self.factory.assert_not_called() def test_success_reads_real_parsers_and_cleans_only_owned_browser(self): code, result, _ = self.run_gate() self.assertEqual(code, 0) self.assertTrue(result["passed"]) self.assertTrue(result["cancelledDetailMatched"]) self.assertTrue(result["listUnchanged"]) self.assertEqual(result["reservationCountBefore"], 1) self.assertEqual(result["reservationCountAfter"], 1) self.assertEqual(result["postLoginBusinessRequests"], dict.fromkeys(gate.COUNTERS, 0)) self.assertEqual(self.plugin.page.urls, [gate.LIST_URL, listing()["tables"][0]["rows"][0]["detailUrl"], gate.LIST_URL]) self.plugin.cleanup.assert_called_once() self.assertEqual(self.plugin.page.driver.immediate_event_handlers, {}) def confirmed_setup(self): page = self.plugin.page page.before = confirmed_listing() page.after = copy.deepcopy(page.before) page.receipt = confirmed_detail() return dict(expect_confirmed=True, expected_date="2026-09-03", expected_time="09:26", expected_service="Visti Nazionali e Schengen") def test_existing_confirmed_receipt_is_verified_without_claiming_prior_attempt(self): args = self.confirmed_setup() code, result, text = self.run_gate(**args) self.assertEqual(code, 0, text) self.assertTrue(result["existingReservationConfirmed"]) self.assertTrue(result["confirmedDetailMatched"]) self.assertFalse(result["cancelledDetailMatched"]) self.assertFalse(result["bookingAttemptAttributed"]) self.assertTrue(result["listUnchanged"]) self.assertEqual(result["reservationCountBefore"], 2) self.assertEqual(result["reservationCountAfter"], 2) self.assertEqual(result["confirmedReceipt"]["state"], "active") self.assertEqual(result["confirmedReceipt"]["assignedTime"], "09:26") self.assertEqual(result["postLoginBusinessRequests"], dict.fromkeys(gate.COUNTERS, 0)) self.assertEqual(self.plugin.page.urls, [gate.LIST_URL, confirmed_listing()["tables"][0]["rows"][1]["detailUrl"], gate.LIST_URL]) self.assertNotIn("CONFIRMED-SYNTHETIC", text) self.plugin.cleanup.assert_called_once() def test_confirmed_preflight_remains_local(self): args = self.confirmed_setup() code, _, _ = self.run_gate(execute=False, **args) self.assertEqual(code, 0) self.credentials.assert_not_called() self.factory.assert_not_called() def test_invalid_expectations_fail_before_credentials(self): for key, value in (("expected_date", None), ("expected_date", "20260903"), ("expected_date", "2026-02-30"), ("expected_time", "09:15 - 10:00"), ("expected_time", "9:26"), ("expected_service", ""), ("expected_service", "name\n"), ("expected_service", "a" * 257)): with self.subTest(key=key, value=value): args = self.confirmed_setup() args[key] = value code, result, _ = self.run_gate(**args) self.assertEqual(code, 1) self.assertEqual(result["reason"], "confirmed_expectations_invalid") self.credentials.assert_not_called() self.factory.assert_not_called() def test_expectations_without_mode_and_non_bool_mode_are_rejected(self): self.assertEqual(self.run_gate(expected_date="2026-09-03")[1]["reason"], "confirmed_expectations_without_mode") self.assertEqual(self.run_gate(expect_confirmed=1)[1]["reason"], "invalid_execution_flag") self.credentials.assert_not_called() def test_wrong_date_time_or_display_service_does_not_verify_another_receipt(self): for key, value in (("expected_date", "2026-09-04"), ("expected_time", "09:15"), ("expected_service", "Different service")): with self.subTest(key=key): args = self.confirmed_setup() self.plugin.page.urls.clear() args[key] = value code, result, _ = self.run_gate(**args) self.assertEqual(code, 1) self.assertEqual(result["reason"], "confirmed_sample_missing") self.assertFalse(result["existingReservationConfirmed"]) self.assertEqual(self.plugin.page.urls, [gate.LIST_URL]) def test_multiple_matching_confirmed_receipts_do_not_pick_first(self): args = self.confirmed_setup() table = self.plugin.page.before["tables"][0] table["rows"].append({**table["rows"][1], "reference": "ANOTHER", "detailUrl": "https://prenotami.esteri.it/ReservationDetail/Index/another"}) table["count"] = 3 table["info"].update(recordsTotal=3, recordsDisplay=3, end=3) code, result, _ = self.run_gate(**args) self.assertEqual(code, 1) self.assertEqual(result["reason"], "confirmed_sample_ambiguous") self.assertEqual(self.plugin.page.urls, [gate.LIST_URL]) def test_confirmed_detail_requires_code_identity_fields_and_single_booking(self): cases = (("statusCode", "3"), ("Codice Prenotazione", "WRONG"), ("Ora", "09:27"), ("Servizio Erogato", "Wrong"), ("Servizio Consolare", "Wrong"), ("Data", "4 settembre 2026"), ("Stato", "Annullata"), ("Tipo Prenotazione", "Prenotazione Multipla")) for key, value in cases: with self.subTest(key=key): args = self.confirmed_setup() self.plugin.page.urls.clear() if key == "statusCode": self.plugin.page.receipt[key] = value else: self.plugin.page.receipt["fields"][key] = value code, result, _ = self.run_gate(**args) self.assertEqual(code, 1) self.assertEqual(result["reason"], "confirmed_detail_mismatch") self.assertFalse(result["existingReservationConfirmed"]) def test_confirmed_history_changes_and_business_requests_still_reject(self): args = self.confirmed_setup() self.plugin.page.after["tables"][0]["rows"][0]["time"] = "10:26" result = self.run_gate(**args)[1] self.assertEqual(result["reason"], "listing_changed") self.assertFalse(result["existingReservationConfirmed"]) args = self.confirmed_setup() self.plugin.page.urls.clear() self.plugin.page.on_get = lambda: self.plugin.page.emit("/BookingCalendar/InsertNewBooking", "POST") result = self.run_gate(**args)[1] self.assertEqual(result["reason"], "unexpected_business_request") self.assertFalse(result["existingReservationConfirmed"]) def test_confirmed_cli_forwards_explicit_expectations_without_enabling_run(self): with patch.object(gate, "run_receipt_gate", return_value=0) as runner: gate.main(["--expect-confirmed", "--expected-date", "2026-09-03", "--expected-time", "09:26", "--expected-service", "Visti Nazionali e Schengen"]) self.assertFalse(runner.call_args.kwargs["execute"]) self.assertTrue(runner.call_args.kwargs["expect_confirmed"]) self.assertEqual(runner.call_args.kwargs["expected_time"], "09:26") def test_inherited_query_debug_and_profile_settings_are_ignored(self): env = {"ITA_DEBUG": "1", "ITA_SERVICE_ID": "bad", "ITA_ACCOUNT_ID": "bad", "ITA_QUERY_ACCOUNT_FILE": "/private/account.json", "ITA_USERNAME": "QUERY-USER", "ITA_PASSWORD": "QUERY-PASSWORD", "ITA_BOOK_USERNAME": "USER", "ITA_BOOK_PASSWORD": "PASSWORD", "ITA_QCAL_MODE": "calendar_soak"} self.assertEqual(self.run_gate(env=env)[0], 0) self.credentials.assert_called_once_with( {"ITA_USERNAME": "USER", "ITA_PASSWORD": "PASSWORD"}, non_interactive=False) self.assertFalse(self.plugin.config.debug) self.assertEqual(self.plugin.config.account.id, 0) self.assertEqual(self.plugin.free_config, {"query_mode": gate.SERVICES_PROBE_QUERY_MODE, "final_submit_enabled": False}) def test_missing_cancelled_sample_does_not_open_a_detail(self): self.plugin.page.before["tables"][0]["rows"][0]["status"] = "Confermata" code, result, _ = self.run_gate() self.assertEqual(code, 1) self.assertEqual(result["reason"], "cancelled_sample_missing") self.assertEqual(self.plugin.page.urls, [gate.LIST_URL]) def test_empty_list_never_manufactures_a_sample(self): table = self.plugin.page.before["tables"][0] table.update(count=0, rows=[]) table["info"].update(recordsTotal=0, recordsDisplay=0, end=0, pages=0) code, result, _ = self.run_gate() self.assertEqual(code, 1) self.assertEqual(result["reservationCountBefore"], 0) self.assertEqual(result["reason"], "cancelled_sample_missing") self.assertEqual(self.plugin.page.urls, [gate.LIST_URL]) def test_multirow_list_order_change_is_not_a_reservation_change(self): table = self.plugin.page.before["tables"][0] row = {**table["rows"][0], "reference": "SECOND", "detailUrl": "https://prenotami.esteri.it/ReservationDetail/Index/second"} table["rows"].append(row) table.update(count=2) table["info"].update(recordsTotal=2, recordsDisplay=2, end=2) self.plugin.page.after = copy.deepcopy(self.plugin.page.before) self.plugin.page.after["tables"][0]["rows"].reverse() code, result, _ = self.run_gate() self.assertEqual(code, 0) self.assertEqual(result["reservationCountAfter"], 2) self.assertEqual(len(self.plugin.page.urls), 3) # Only one detail read. def test_navigation_failure_and_auth_redirect_do_not_pass(self): with patch.object(self.plugin.page, "get", return_value=False): self.assertEqual(self.run_gate()[1]["reason"], "navigation_failed") self.plugin.page.on_get = lambda: setattr(self.plugin.page, "url", "https://iam.esteri.it/signin/") self.assertEqual(self.run_gate()[1]["reason"], "navigation_rejected") def test_missing_login_markers_stops_before_audit_and_navigation(self): self.plugin.page.ele.return_value = False self.assertEqual(self.run_gate()[1]["reason"], "login_unverified") self.assertEqual(self.plugin.page.urls, []) def test_late_business_request_during_final_audit_rejects_success(self): calls = 0 def snapshot(audit): nonlocal calls calls += 1 if calls == 4: self.plugin.page.emit("/BookingCalendar/GenerateOTP") return audit.snapshot() with patch.object(gate.CalendarRequestAudit, "settled_snapshot", snapshot): code, result, _ = self.run_gate() self.assertEqual(code, 1) self.assertFalse(result["passed"]) self.assertFalse(result["auditVerified"]) self.assertEqual(result["reason"], "unexpected_business_request") def test_preflight_configuration_error_is_sanitized(self): with patch.object(gate, "resolve_chrome_path", side_effect=gate.DebugConfigurationError("SECRET-PASSWORD")): code, result, _ = self.run_gate(execute=False) self.assertEqual(code, 1) self.assertEqual(result["reason"], "configuration_rejected") self.credentials.assert_not_called() self.factory.assert_not_called() def test_each_mismatched_detail_field_is_rejected(self): for key, value in (("Servizio Consolare", "Other"), ("Servizio Erogato", "Other"), ("Codice Prenotazione", "OTHER"), ("Data", "14 ottobre 2026"), ("Ora", "10:26"), ("Stato", "Confermata"), ("Tipo Prenotazione", "Prenotazione Multipla")): with self.subTest(key=key): self.plugin.page.urls.clear() self.plugin.page.receipt = detail() self.plugin.page.receipt["fields"][key] = value code, result, _ = self.run_gate() self.assertEqual(code, 1) self.assertEqual(result["reason"], "cancelled_detail_mismatch") def test_cancelled_status_code_must_also_match(self): self.plugin.page.receipt["statusCode"] = "2" self.assertEqual(self.run_gate()[1]["reason"], "cancelled_detail_mismatch") def test_list_change_cannot_pass(self): self.plugin.page.after["tables"][0]["rows"][0]["time"] = "10:26" code, result, _ = self.run_gate() self.assertEqual(code, 1) self.assertFalse(result["passed"]) self.assertEqual(result["reason"], "listing_changed") def test_cross_origin_detail_link_not_followed(self): self.plugin.page.before["tables"][0]["rows"][0]["detailUrl"] = "https://evil.invalid/secret" self.assertEqual(self.run_gate()[0], 1) self.assertEqual(self.plugin.page.urls, [gate.LIST_URL]) def test_session_context_change_is_rejected(self): for attribute, value in (("session_create_time", 2), ("_persistent_profile_path", "/private")): with self.subTest(attribute=attribute): original = getattr(self.plugin, attribute) self.plugin.page.on_get = lambda: setattr(self.plugin, attribute, value) self.assertEqual(self.run_gate()[1]["reason"], "context_changed") setattr(self.plugin, attribute, original) def test_tab_change_is_rejected(self): self.plugin.page.on_get = lambda: setattr(self.plugin.page, "tab_id", "OTHER-TAB") self.assertEqual(self.run_gate()[1]["reason"], "context_changed") def test_account_change_is_rejected(self): self.plugin.page.on_get = lambda: setattr(self.plugin.config.account, "username", "OTHER") self.assertEqual(self.run_gate()[1]["reason"], "context_changed") def test_each_forbidden_business_request_is_detected(self): for path, method in (("/BookingCalendar/GenerateOTP", "GET"), ("/Services/Booking/9001", "POST"), ("/BookingCalendar/InsertNewBooking", "POST"), ("/BookingCalendar/RetrieveCalendarAvailability", "POST"), ("/BookingCalendar/RetrieveTimeSlots", "POST")): with self.subTest(path=path): self.plugin.page.urls.clear() self.plugin.page.on_get = lambda: self.plugin.page.emit(path, method) code, result, _ = self.run_gate() self.assertEqual(code, 1) self.assertEqual(result["reason"], "unexpected_business_request") self.assertGreater(sum(result["postLoginBusinessRequests"].values()), 0) def test_ordinary_get_and_telemetry_are_not_claimed_absent(self): def ordinary_requests(): self.plugin.page.emit("/Reservation") self.plugin.page.emit("/synthetic-telemetry", "POST") self.plugin.page.on_get = ordinary_requests self.assertEqual(self.run_gate()[0], 0) def test_disconnected_audit_fails(self): self.plugin.page.on_get = lambda: setattr(self.plugin.page.driver, "is_running", False) code, result, _ = self.run_gate() self.assertEqual(code, 1) self.assertEqual(result["reason"], "audit_unavailable") self.assertIsNone(result["postLoginBusinessRequests"]) def test_audit_cannot_replace_another_callback(self): self.plugin.page.driver.immediate_event_handlers[gate.CalendarRequestAudit.EVENT] = object() self.assertEqual(self.run_gate()[0], 1) self.assertEqual(self.plugin.page.urls, []) def test_cleanup_and_stop_errors_never_pass(self): self.plugin.cleanup.side_effect = RuntimeError("SECRET-PASSWORD") code, result, _ = self.run_gate() self.assertEqual(code, 3) self.assertFalse(result["passed"]) self.assertEqual(result["reason"], "cleanup_failed") self.plugin.cleanup.side_effect = None self.plugin.page.urls.clear() with patch.object(gate.CalendarRequestAudit, "stop", side_effect=RuntimeError("SECRET-PASSWORD")): code, result, _ = self.run_gate() self.assertEqual(code, 1) self.assertFalse(result["passed"]) self.assertEqual(result["reason"], "audit_stop_failed") def test_login_error_and_interrupt_are_sanitized_and_cleanup_runs(self): for error, expected in ((RuntimeError("SECRET-PASSWORD"), 1), (KeyboardInterrupt(), 130)): self.plugin.create_session.side_effect = error self.plugin.cleanup.reset_mock() self.assertEqual(self.run_gate()[0], expected) self.plugin.cleanup.assert_called_once() self.assertEqual(self.plugin.page.urls, []) def test_parser_exception_reason_is_allowlisted(self): with patch.object(gate, "read_reservation_listing", side_effect=ReservationReadError("SECRET-PASSWORD")): self.assertEqual(self.run_gate()[1]["reason"], "receipt_read_rejected") def test_unrecognized_list_date_adds_diagnostic_but_never_passes(self): self.plugin.page.before["tables"][0]["rows"][0]["date"] = "2026-10-13" code, result, _ = self.run_gate() self.assertEqual(code, 1) self.assertEqual(result["reason"], "date_unrecognized") self.assertEqual(result["stage"], "list_before") self.assertTrue(result["dateDiagnostic"]["available"]) self.assertEqual(result["dateDiagnostic"]["samples"][0]["text"]["shape"], "DDDD-DD-DD") self.assertEqual(self.plugin.page.diagnostic_reads, 1) self.assertEqual(self.plugin.page.urls, [gate.LIST_URL]) self.assertTrue(result["auditVerified"]) self.plugin.cleanup.assert_called_once() def test_failed_date_diagnostic_keeps_original_failure_and_cleanup(self): self.plugin.page.before["tables"][0]["rows"][0]["date"] = "2026-10-13" with patch.object(gate, "read_reservation_date_diagnostic", side_effect=RuntimeError("SECRET-PASSWORD")): code, result, _ = self.run_gate() self.assertEqual(code, 1) self.assertEqual(result["reason"], "date_unrecognized") self.assertEqual(result["dateDiagnostic"], {"available": False}) self.plugin.cleanup.assert_called_once() def test_success_and_detail_failure_do_not_trigger_list_diagnostic(self): self.assertEqual(self.run_gate()[0], 0) self.assertEqual(self.plugin.page.diagnostic_reads, 0) self.plugin.page.receipt["fields"]["Data"] = "2026-10-13" self.plugin.page.urls.clear() result = self.run_gate()[1] self.assertEqual(result["reason"], "date_unrecognized") self.assertEqual(result["stage"], "cancelled_detail") self.assertIsNone(result["dateDiagnostic"]) self.assertEqual(self.plugin.page.diagnostic_reads, 0) def test_browser_environment_restored(self): with patch.dict(os.environ, {"CHROME_BIN": "/original/chrome"}): self.assertEqual(self.run_gate()[0], 0) self.assertEqual(os.environ["CHROME_BIN"], "/original/chrome") def test_cli_default_and_preflight_do_not_execute(self): for argv in ([], ["--preflight"]): with patch.object(gate, "run_receipt_gate", return_value=0) as runner: self.assertEqual(gate.main(argv), 0) self.assertFalse(runner.call_args.kwargs["execute"]) with patch.object(gate, "run_receipt_gate", return_value=0) as runner: gate.main(["--run", "--non-interactive"]) self.assertTrue(runner.call_args.kwargs["execute"]) self.assertTrue(runner.call_args.kwargs["non_interactive"]) if __name__ == "__main__": unittest.main()