import ast import io import tempfile import unittest from contextlib import ExitStack, redirect_stderr, redirect_stdout from pathlib import Path from unittest.mock import Mock, patch from plugins.ita_plugin import ( BOOKING_CALENDAR_PREFINAL_STOP_LABEL, BOOKING_FORM_DISCOVERY_STOP_LABEL, BOOKING_RECHECK_NONE_AVAILABLE_LABEL, ) from tools.debug_ita_book import ( _assert_distinct_local_accounts, run_book_recheck_once, ) from tools.debug_ita_session import DebugConfigurationError from vs_types import AvailabilityStatus, BizLogicError, VSAccount, VSBookResult class FakeBookDebugElement: def __init__(self, text): self.text = text class FakeBookDebugPage: def __init__(self): self.url = "https://prenotami.esteri.it/UserArea?state=sensitive-state" self.popup_text = "" self.form_structure = None def run_js(self, script): return self.form_structure def ele(self, selector, timeout=None): del timeout if selector == ".jconfirm-content" and self.popup_text: return FakeBookDebugElement(self.popup_text) return None class FakeBookDebugPlugin: behavior = "none-available" last_instance = None def __init__(self, group_id): self.group_id = group_id self.page = FakeBookDebugPage() self.create_session_calls = 0 self.book_calls = 0 self.cleanup_called = False self.last_trigger = None self.events = [] FakeBookDebugPlugin.last_instance = self def set_log(self, logger): self.logger = logger def set_config(self, config): self.config = config def create_session(self): self.create_session_calls += 1 self.events.append("create-session") def book(self, trigger, user_inputs=None): del user_inputs self.last_trigger = trigger self.book_calls += 1 self.events.append("book") if self.behavior == "booking-form": self.page.form_structure = { "path": "/Services/Booking/1321", "form": { "method": "POST", "action_path": "/Services/Booking/1321", "secret": "must-not-appear", }, "field_count": 1, "fields": [ { "tag": "input", "type": "hidden", "id": "RequestToken", "name": "__RequestVerificationToken", "required": False, "value": "private@example.test", } ], "button_count": 1, "buttons": [ { "tag": "button", "type": "submit", "id": "btnAvanti", "name": None, "text": "Avanti", "value": "server-secret", } ], } return VSBookResult( success=False, label=BOOKING_FORM_DISCOVERY_STOP_LABEL, ) if self.behavior == "unexpected-success": return VSBookResult(success=True) if self.behavior == "unexpected-error": self.page.popup_text = "Account private@example.test ref 12345678" raise RuntimeError( "failed at https://iam.esteri.it/signin/" "?state=sensitive-state&code_challenge=sensitive-challenge" ) return VSBookResult( success=False, label=BOOKING_RECHECK_NONE_AVAILABLE_LABEL, ) def cleanup(self): self.cleanup_called = True self.events.append("cleanup") class DebugItaBookSafetyTests(unittest.TestCase): def setUp(self): FakeBookDebugPlugin.behavior = "none-available" FakeBookDebugPlugin.last_instance = None @staticmethod def _run(*, arm=False, input_side_effect=None): stdout = io.StringIO() stderr = io.StringIO() env = { "ITA_USERNAME": "offline-test@example.test", "ITA_PASSWORD": "offline-password", } if input_side_effect is None: input_side_effect = lambda _prompt: ( FakeBookDebugPlugin.last_instance.events.append("release") ) with ( patch( "tools.debug_ita_book.resolve_chrome_path", return_value=Path("/test/chrome"), ), patch("tools.debug_ita_book.ItaPlugin", FakeBookDebugPlugin), patch.dict("tools.debug_ita_book.os.environ", {}, clear=False), patch( "builtins.input", side_effect=input_side_effect, ) as input_mock, redirect_stdout(stdout), redirect_stderr(stderr), ): exit_code = run_book_recheck_once( env, non_interactive=True, arm=arm, ) return exit_code, stdout.getvalue(), stderr.getvalue(), input_mock def test_no_slot_recheck_calls_book_once_and_cleans_up(self): exit_code, stdout, stderr, _input_mock = self._run() plugin = FakeBookDebugPlugin.last_instance self.assertEqual(exit_code, 0) self.assertEqual(plugin.create_session_calls, 1) self.assertEqual(plugin.book_calls, 1) self.assertTrue(plugin.last_trigger.success) self.assertEqual( plugin.last_trigger.availability_status, AvailabilityStatus.NoneAvailable, ) self.assertTrue(plugin.cleanup_called) self.assertIn("book_attempt=1", stdout) self.assertIn("ITA_BOOK_RECHECK_NONE_AVAILABLE service_id=1321", stdout) self.assertIn("ITA_BOOK_CLEANUP_OK", stdout) self.assertEqual(stderr, "") def test_booking_form_is_reported_without_values_or_submission(self): FakeBookDebugPlugin.behavior = "booking-form" exit_code, stdout, stderr, _input_mock = self._run() plugin = FakeBookDebugPlugin.last_instance self.assertEqual(exit_code, 4) self.assertEqual(plugin.book_calls, 1) self.assertTrue(plugin.cleanup_called) self.assertIn("ITA_BOOKING_FORM_STRUCTURE=", stdout) self.assertIn('"action_path": "/Services/Booking/1321"', stdout) self.assertIn("stage=before-avanti submit_attempts=0", stdout) self.assertNotIn("private@example.test", stdout) self.assertNotIn("server-secret", stdout) self.assertNotIn("must-not-appear", stdout) self.assertEqual(stderr, "") def test_unexpected_success_stops_safely(self): FakeBookDebugPlugin.behavior = "unexpected-success" exit_code, stdout, _stderr, _input_mock = self._run() self.assertEqual(exit_code, 4) self.assertIn("reason=unexpected-success-before-avanti", stdout) def test_unexpected_error_is_sanitized_and_not_retried(self): FakeBookDebugPlugin.behavior = "unexpected-error" exit_code, stdout, stderr, _input_mock = self._run() plugin = FakeBookDebugPlugin.last_instance self.assertEqual(exit_code, 1) self.assertEqual(plugin.book_calls, 1) self.assertTrue(plugin.cleanup_called) self.assertNotIn("sensitive-state", stdout) self.assertNotIn("sensitive-challenge", stdout) self.assertNotIn("private@example.test", stdout) self.assertNotIn("12345678", stdout) self.assertEqual(stderr, "") def test_arm_waits_after_login_and_before_the_single_book_call(self): exit_code, stdout, stderr, input_mock = self._run(arm=True) plugin = FakeBookDebugPlugin.last_instance self.assertEqual(exit_code, 0) self.assertEqual( plugin.events, ["create-session", "release", "book", "cleanup"], ) input_mock.assert_called_once() self.assertIn( "ITA_BOOK_ARMED service_id=1321 " "routing_key=slot.dub.it.tourist stage=user-area", stdout, ) self.assertEqual(stderr, "") def test_ctrl_c_cancels_armed_mode_without_book_or_traceback(self): exit_code, stdout, stderr, input_mock = self._run( arm=True, input_side_effect=KeyboardInterrupt, ) plugin = FakeBookDebugPlugin.last_instance self.assertEqual(exit_code, 130) self.assertEqual(plugin.book_calls, 0) self.assertEqual(plugin.events, ["create-session", "cleanup"]) input_mock.assert_called_once() self.assertIn( "ITA_BOOK_ARM_CANCELLED service_id=1321 " "routing_key=slot.dub.it.tourist book_attempts=0", stdout, ) self.assertIn("ITA_BOOK_CLEANUP_OK", stdout) self.assertNotIn("Traceback", stdout) self.assertEqual(stderr, "") def test_local_signal_wait_claims_once_before_the_single_book_call(self): claimed = [] def claim(): claimed.append("claim") return object() stdout = io.StringIO() stderr = io.StringIO() env = { "ITA_USERNAME": "book-user@example.test", "ITA_PASSWORD": "offline-password", } with ( patch( "tools.debug_ita_book.resolve_chrome_path", return_value=Path("/test/chrome"), ), patch("tools.debug_ita_book._assert_distinct_local_accounts"), patch("tools.debug_ita_book.ItaPlugin", FakeBookDebugPlugin), patch.dict("tools.debug_ita_book.os.environ", {}, clear=False), redirect_stdout(stdout), redirect_stderr(stderr), ): exit_code = run_book_recheck_once( env, non_interactive=True, wait_for_local_signal=True, signal_timeout=1, signal_claimer=claim, monotonic=lambda: 0.0, sleep=lambda _seconds: None, ) plugin = FakeBookDebugPlugin.last_instance self.assertEqual(exit_code, 0) self.assertEqual(claimed, ["claim"]) self.assertEqual(plugin.events, ["create-session", "book", "cleanup"]) self.assertEqual(plugin.book_calls, 1) self.assertEqual(plugin.config.account.username, "book-user@example.test") self.assertEqual(plugin.config.account.password, "offline-password") self.assertNotIn( "persistent_browser_profile_path", plugin.config.free_config, ) self.assertIn("ITA_BOOK_SIGNAL_CLAIMED", stdout.getvalue()) self.assertEqual(stderr.getvalue(), "") def test_local_signal_timeout_never_calls_book(self): clock = iter([0.0, 0.0, 2.0]) stdout = io.StringIO() stderr = io.StringIO() env = { "ITA_USERNAME": "book-user@example.test", "ITA_PASSWORD": "offline-password", } with ( patch( "tools.debug_ita_book.resolve_chrome_path", return_value=Path("/test/chrome"), ), patch("tools.debug_ita_book._assert_distinct_local_accounts"), patch("tools.debug_ita_book.ItaPlugin", FakeBookDebugPlugin), patch.dict("tools.debug_ita_book.os.environ", {}, clear=False), redirect_stdout(stdout), redirect_stderr(stderr), ): exit_code = run_book_recheck_once( env, non_interactive=True, wait_for_local_signal=True, signal_timeout=1, signal_claimer=lambda: None, monotonic=lambda: next(clock), sleep=lambda _seconds: None, ) plugin = FakeBookDebugPlugin.last_instance self.assertEqual(exit_code, 5) self.assertEqual(plugin.book_calls, 0) self.assertIn("ITA_BOOK_SIGNAL_WAIT_TIMEOUT", stdout.getvalue()) self.assertIn("book_attempts=0", stdout.getvalue()) self.assertEqual(stderr.getvalue(), "") def test_automatic_handoff_rejects_the_same_query_and_book_account(self): with tempfile.TemporaryDirectory() as temp_dir: account_path = Path(temp_dir) / "query-account.json" account_path.touch() with ( patch("tools.debug_ita_book.ITA_QUERY_ACCOUNT_FILE", account_path), patch( "tools.debug_ita_book.load_local_account", return_value=VSAccount( username="same@example.test", password="query-secret", ), ), self.assertRaisesRegex( DebugConfigurationError, "different Query and Book accounts", ), ): _assert_distinct_local_accounts("SAME@example.test") def test_role_check_accepts_different_query_and_book_accounts(self): with tempfile.TemporaryDirectory() as temp_dir: account_path = Path(temp_dir) / "query-account.json" account_path.touch() with ( patch("tools.debug_ita_book.ITA_QUERY_ACCOUNT_FILE", account_path), patch( "tools.debug_ita_book.load_local_account", return_value=VSAccount( username="query@example.test", password="query-secret", ), ) as query_loader, ): _assert_distinct_local_accounts("book@example.test") query_loader.assert_called_once_with(account_path) def test_entrypoint_has_one_book_call_and_no_query_call(self): source_path = ( Path(__file__).resolve().parents[2] / "tools" / "debug_ita_book.py" ) tree = ast.parse(source_path.read_text(encoding="utf-8")) book_calls = [] query_calls = [] for node in ast.walk(tree): if not isinstance(node, ast.Call): continue if not isinstance(node.func, ast.Attribute): continue if node.func.attr == "book": book_calls.append(node) if node.func.attr == "query": query_calls.append(node) self.assertEqual(len(book_calls), 1) self.assertEqual(query_calls, []) class DebugItaBookWorkflowTests(unittest.TestCase): """Exercise the CLI contract with synthetic adapters, never a real browser.""" def setUp(self): from tools import debug_ita_book as cli from tools import debug_ita_calendar_gate as audit_module from tools import debug_ita_book_gate as book_gate from plugins import ita_plugin as calendar from test.ita.test_debug_ita_calendar_gate import gate_env from test.ita.test_ita_booking_final import target self.cli = cli self.env = {**gate_env(), "ITA_USERNAME": "query@example.test", "ITA_PASSWORD": "query-secret"} self.plugin = Mock() self.approval = target().approval self.plugin.book.return_value = VSBookResult(success=False, label=BOOKING_CALENDAR_PREFINAL_STOP_LABEL) self.counts = {"otpRequests": 1, "avantiPosts": 1, "availabilityRequests": 3, "timeSlotRequests": 3, "finalRequests": 0} self.audit = Mock() self.audit.settled_snapshot.side_effect = lambda: dict(self.counts) self.stack = ExitStack() self.addCleanup(self.stack.close) self.stack.enter_context(patch.object(cli, "ItaPlugin", return_value=self.plugin)) self.stack.enter_context(patch.object(cli, "resolve_chrome_path", return_value=Path("/offline/chrome"))) self.credentials = self.stack.enter_context(patch.object(cli, "_get_credentials", return_value=("applicant@example.test", "applicant-secret"))) self.stack.enter_context(patch.object(audit_module, "CalendarRequestAudit", return_value=self.audit)) self.stack.enter_context(patch.object( book_gate, "book_with_approval", side_effect=lambda plugin, trigger, user_inputs: ( plugin.book(trigger, user_inputs=user_inputs), self.approval ), )) self.stack.enter_context(patch.object(calendar, "read_calendar_service", return_value="9001")) self.readback = self.stack.enter_context(patch.object(calendar, "verify_precommit_selection")) def run_workflow(self, **kwargs): output = io.StringIO() with redirect_stdout(output): code = self.cli.run_book_recheck_once(self.env, non_interactive=False, production_workflow=True, **kwargs) return code, output.getvalue() def test_auto_otp_reuses_one_public_book_call_and_keeps_final_disabled(self): self.env["ITA_OTP_AUTHORIZATION_EMAIL"] = "mailbox@example.test" code, output = self.run_workflow(auto_otp=True) self.assertEqual(code, 0) config = self.plugin.set_config.call_args.args[0] self.assertEqual(config.free_config["otp_mode"], "cloud") self.assertIs(config.free_config["final_submit_enabled"], False) route_config = next(iter(config.free_config["apt_configs"].values())) self.assertEqual(route_config["mail"], {"authorization_email": "mailbox@example.test"}) self.plugin.book.assert_called_once() self.assertNotIn("mailbox@example.test", output) self.assertIn("mode=cloud", output) def test_auto_otp_requires_explicit_mailbox_before_session(self): with self.assertRaises(self.cli.DebugConfigurationError): self.run_workflow(auto_otp=True) self.plugin.create_session.assert_not_called() def test_verify_receipts_reuses_existing_gate_after_selection_without_final(self): baseline = {"verified": True, "recordCount": 0, "calendarSelectionPreserved": True, "businessRequests": {k: 0 for k in self.counts}, "finalSubmissionEnabled": False} self.env["ITA_OTP_AUTHORIZATION_EMAIL"] = "mailbox@example.test" with patch("tools.debug_ita_book_gate._verify_receipt_baseline", return_value=baseline) as verify: code, output = self.run_workflow(auto_otp=True, verify_receipts=True) self.assertEqual(code, 0) verify.assert_called_once_with(self.plugin, self.plugin._resolve_route.return_value) self.plugin.book.assert_called_once() self.assertIs(self.plugin.set_config.call_args.args[0].free_config["final_submit_enabled"], False) self.assertIn("ITA_BOOK_WORKFLOW_RECEIPT_BASELINE=", output) self.assertIn('"calendarSelectionPreserved": true', output) self.assertIn('"finalRequests": 0', output) def test_receipt_failure_is_not_passed_or_retried(self): from plugins.ita_plugin import FinalBookingError self.stack.enter_context(patch.object(self.cli, "_print_failure_context")) with patch("tools.debug_ita_book_gate._verify_receipt_baseline", side_effect=FinalBookingError("Italy receipt baseline rejected")) as verify: code, output = self.run_workflow(verify_receipts=True) self.assertEqual(code, 1) verify.assert_called_once() self.plugin.book.assert_called_once() self.assertNotIn("ITA_BOOK_WORKFLOW_RESULT=", output) self.plugin.cleanup.assert_called_once() def test_receipt_read_business_request_change_fails(self): def unexpected(*args): self.counts["otpRequests"] += 1 return {} self.stack.enter_context(patch.object(self.cli, "_print_failure_context")) with patch("tools.debug_ita_book_gate._verify_receipt_baseline", side_effect=unexpected): code, output = self.run_workflow(verify_receipts=True) self.assertEqual(code, 1) self.assertNotIn("ITA_BOOK_WORKFLOW_RECEIPT_BASELINE=", output) self.plugin.book.assert_called_once() def test_no_candidate_skips_receipt_read_and_does_not_claim_pass(self): self.plugin.book.return_value = VSBookResult(success=False, label=BOOKING_RECHECK_NONE_AVAILABLE_LABEL) with patch("tools.debug_ita_book_gate._verify_receipt_baseline") as verify: code, output = self.run_workflow(verify_receipts=True) self.assertEqual(code, 2) verify.assert_not_called() self.assertNotIn("ITA_BOOK_WORKFLOW_RECEIPT_BASELINE=", output) def test_receipt_flag_requires_workflow_and_defaults_off(self): self.assertFalse(self.cli.parse_args([]).verify_receipts) self.assertTrue(self.cli.parse_args(["--production-workflow", "--verify-receipts"]).verify_receipts) with self.assertRaises(self.cli.DebugConfigurationError): self.cli.run_book_recheck_once(self.env, non_interactive=False, verify_receipts=True) self.credentials.assert_not_called() self.plugin.create_session.assert_not_called() def test_main_routes_both_opt_in_flags_and_rejects_receipts_alone(self): with patch.object(self.cli, "run_book_recheck_once", return_value=0) as run: self.assertEqual(self.cli.main(["--production-workflow", "--auto-otp", "--verify-receipts"]), 0) self.assertIs(run.call_args.kwargs["verify_receipts"], True) self.assertIs(run.call_args.kwargs["auto_otp"], True) with patch.object(self.cli, "run_book_recheck_once") as run, redirect_stderr(io.StringIO()): self.assertEqual(self.cli.main(["--verify-receipts"]), 2) run.assert_not_called() def test_auto_flag_without_workflow_rejected_before_login(self): with self.assertRaises(self.cli.DebugConfigurationError): self.cli.run_book_recheck_once(self.env, non_interactive=False, auto_otp=True) self.credentials.assert_not_called() self.plugin.create_session.assert_not_called() self.assertTrue(self.cli.parse_args(["--production-workflow", "--auto-otp"]).auto_otp) def test_one_public_book_call_with_applicant_identity_and_final_disabled(self): code, output = self.run_workflow() self.assertEqual(code, 0) config = self.plugin.set_config.call_args.args[0] self.assertEqual(config.account.username, "applicant@example.test") self.assertEqual(config.free_config["otp_mode"], "manual") self.assertEqual(config.free_config["query_mode"], "services_probe") self.assertIs(config.free_config["final_submit_enabled"], False) self.assertNotIn("persistent_browser_profile_path", config.free_config) self.credentials.assert_called_once_with({"ITA_USERNAME": "", "ITA_PASSWORD": ""}, non_interactive=False) self.plugin.book.assert_called_once() self.assertEqual(self.plugin.book.call_args.kwargs["user_inputs"], {"username": "applicant@example.test"}) self.plugin.query.assert_not_called() self.readback.assert_called_once() self.audit.start.assert_called_once() self.audit.stop.assert_called_once() self.plugin.cleanup.assert_called_once() self.assertIn('"selectionVerified": true', output) self.assertIn('"finalRequests": 0', output) self.assertIn("ITA_BOOK_CLEANUP_OK", output) self.assertNotIn("applicant-secret", output) self.assertNotIn("query-secret", output) def test_book_specific_environment_is_used_not_general_query_credentials(self): self.env.update(ITA_BOOK_USERNAME="book@example.test", ITA_BOOK_PASSWORD="book-secret") self.run_workflow() self.credentials.assert_called_once_with( {"ITA_USERNAME": "book@example.test", "ITA_PASSWORD": "book-secret"}, non_interactive=False) def test_no_candidate_does_not_claim_positive_acceptance(self): self.plugin.book.return_value = VSBookResult(success=False, label=BOOKING_RECHECK_NONE_AVAILABLE_LABEL) code, output = self.run_workflow() self.assertEqual(code, 2) self.assertIn('"selectionVerified": false', output) self.readback.assert_not_called() self.plugin.cleanup.assert_called_once() def test_selection_readback_failure_is_not_a_pass(self): self.readback.side_effect = BizLogicError("synthetic readback mismatch") self.stack.enter_context(patch.object(self.cli, "_print_failure_context")) code, output = self.run_workflow() self.assertEqual(code, 1) self.assertNotIn("ITA_BOOK_WORKFLOW_RESULT=", output) self.plugin.cleanup.assert_called_once() def test_unexpected_final_request_fails_and_never_retries(self): self.counts["finalRequests"] = 1 self.stack.enter_context(patch.object(self.cli, "_print_failure_context")) code, output = self.run_workflow() self.assertEqual(code, 1) self.assertNotIn("ITA_BOOK_WORKFLOW_RESULT=", output) self.plugin.book.assert_called_once() self.plugin.cleanup.assert_called_once() def test_late_audit_failure_invalidates_exit_code(self): self.audit.settled_snapshot.side_effect = [self.counts, RuntimeError("audit lost")] code, output = self.run_workflow() self.assertEqual(code, 1) self.assertIn("ITA_BOOK_WORKFLOW_AUDIT_FAILED", output) self.audit.stop.assert_called_once() self.plugin.cleanup.assert_called_once() def test_cleanup_failure_invalidates_exit_code(self): self.plugin.cleanup.side_effect = RuntimeError("cleanup failed") with redirect_stderr(io.StringIO()): code, _ = self.run_workflow() self.assertEqual(code, 3) def test_legacy_flags_rejected_before_credentials(self): for kwargs in ({"non_interactive": True}, {"arm": True}, {"wait_for_local_signal": True}): with self.subTest(kwargs=kwargs), self.assertRaises(DebugConfigurationError): self.cli.run_book_recheck_once(self.env, production_workflow=True, **{"non_interactive": False, **kwargs}) self.credentials.assert_not_called() self.plugin.create_session.assert_not_called() def test_cli_flag_defaults_off(self): self.assertFalse(self.cli.parse_args([]).production_workflow) self.assertTrue(self.cli.parse_args(["--production-workflow"]).production_workflow) if __name__ == "__main__": unittest.main()