"""Offline production-entry tests: no credentials, site calls, or cloud writes.""" import ast import logging import itertools from dataclasses import replace from contextlib import ExitStack from datetime import datetime from pathlib import Path from io import StringIO from contextlib import redirect_stdout from types import MethodType, SimpleNamespace from unittest import TestCase from unittest.mock import Mock, patch from plugins import ita_workflow as workflow from plugins import ita_calendar_session as preparation from plugins.ita_booking_final import FinalOutcomeUnknown, SubmissionSignal, VerifiedSubmission from plugins.ita_plugin import ItaPlugin from plugins import ita_otp from plugins import ita_turnstile from plugins.ita_protocol import OtpMailConfig from test import test_ita_calendar_book_flow as flow from test.test_debug_ita_calendar_gate import booking_preflight_snapshot from test import test_ita_final_attribution as attribution from vs_types import AvailabilityStatus, BizLogicError, PermissionDeniedError, VSBookResult, VSPlgConfig, VSQueryResult class PreparationTests(TestCase): def setUp(self): _, self.route, _ = flow.prepared_plugin(flow.FlowPage()) self.path = f"/Services/Booking/{self.route.service_id}" self.page = SimpleNamespace(url="https://prenotami.esteri.it" + self.path, tab_id="fixture-tab", wait=Mock(), set=Mock()) self.otp_present = False self.clicks = [] self.page.run_js = Mock(side_effect=lambda _: booking_preflight_snapshot( otpValuePresent=self.otp_present, otpDisabled=self.otp_present)) otp_input = Mock() otp_input.input.side_effect = lambda *a, **k: setattr(self, "otp_present", True) otp_input.run_js.return_value = True otp_input.selector = "#otp-input" controls = {"#otp-input": otp_input, "#otp-send": SimpleNamespace(selector="#otp-send"), "#btnAvanti": SimpleNamespace(selector="#btnAvanti")} self.page.ele = Mock(side_effect=lambda selector, **kwargs: controls[selector]) self.plugin = SimpleNamespace( page=self.page, session_create_time=1, free_config={"otp_mode": "manual"}, config=SimpleNamespace(account=SimpleNamespace(username="fixture@example.test")), mouse=SimpleNamespace(human_click_ele=lambda ele: self.clicks.append(ele.selector)), _booking_path=lambda route: self.path, _log=Mock(), _record_calendar_query_prepared_route=Mock(), _record_calendar_book_prepared_route=Mock(), ) self.plugin._book_final_configuration_valid = MethodType(ItaPlugin._book_final_configuration_valid, self.plugin) self.stack = ExitStack() self.addCleanup(self.stack.close) self.tty = self.stack.enter_context(patch.object(workflow.sys.stdin, "isatty", return_value=True)) self.reader = self.stack.enter_context(patch.object(preparation, "_read_manual_otp", return_value="123456")) self.listener = self.stack.enter_context(patch.object(workflow, "listen_once", side_effect=self.listen)) self.stack.enter_context(patch.object(workflow, "guard_calendar")) self.stack.enter_context(patch.object(workflow, "wait_for_calendar_service", return_value="9001")) def listen(self, page, *, target, method, timeout, action): action() if target == self.path: page.url = "https://prenotami.esteri.it/BookingCalendar?selectedService=Example" return SimpleNamespace(tab_id=page.tab_id, is_failed=False, method=method, url="https://prenotami.esteri.it" + target + ("?ServiceID=9001" if method == "GET" else ""), response=SimpleNamespace(status=200, raw_body='"SENT"', url=page.url)) def test_native_preparation_sends_once_writes_once_and_records_query_role(self): workflow.prepare_calendar(self.plugin, self.route, role="query") self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"]) self.assertEqual(self.listener.call_count, 2) self.reader.assert_called_once() self.plugin._record_calendar_query_prepared_route.assert_called_once_with(self.route) self.plugin._record_calendar_book_prepared_route.assert_not_called() self.assertEqual(self.page.run_js.call_count, 2) self.assertIn("form-boundary", self.page.run_js.call_args.args[0]) def test_book_role_does_not_mark_query_prepared(self): workflow.prepare_calendar(self.plugin, self.route, role="book") self.plugin._record_calendar_book_prepared_route.assert_called_once_with(self.route) self.plugin._record_calendar_query_prepared_route.assert_not_called() def test_no_terminal_stops_before_otp_or_form_changes(self): self.tty.return_value = False with self.assertRaises(PermissionDeniedError): workflow.prepare_calendar(self.plugin, self.route, role="query") self.listener.assert_not_called() self.page.run_js.assert_not_called() def test_wrong_otp_readback_prevents_avanti_and_repeated_otp(self): self.page.ele("#otp-input").run_js.return_value = False with self.assertRaisesRegex(preparation.CalendarGateError, "verification failed"): workflow.prepare_calendar(self.plugin, self.route, role="book") with self.assertRaises(PermissionDeniedError): workflow.prepare_calendar(self.plugin, self.route, role="book") self.assertEqual(self.clicks, ["#otp-send", "#otp-input"]) self.assertEqual(self.listener.call_count, 1) def test_wrong_tab_response_never_reads_otp_or_submits_form(self): self.listener.side_effect = None self.listener.return_value = SimpleNamespace(tab_id="foreign", is_failed=False) with self.assertRaises(preparation.CalendarGateError): workflow.prepare_calendar(self.plugin, self.route, role="query") self.reader.assert_not_called() self.plugin._record_calendar_query_prepared_route.assert_not_called() class CloudPreparationTests(TestCase): """Reuse the manual site's fixture, replacing only the OTP provider.""" listen = PreparationTests.listen def setUp(self): PreparationTests.setUp(self) self.plugin.free_config["otp_mode"] = "cloud" self.route = replace(self.route, mail=OtpMailConfig("mailbox@example.test")) self.tty.return_value = False self.stack.enter_context(patch.object(ita_otp.vs_log_macros, "_active_logger", logging.Logger("offline-otp", logging.INFO))) self.fetch = self.stack.enter_context(patch.object(workflow, "fetch_otp_from_cloud", return_value="001234")) self.utc = self.stack.enter_context(patch.object(workflow, "utc_sent_at", return_value="2026-08-31 01:02:03")) def test_automatic_preparation_without_tty_reuses_native_controls_and_readback(self): observed = [] def fetch(mail, **kwargs): observed.extend(self.clicks) return "001234" self.fetch.side_effect = fetch output = StringIO() with redirect_stdout(output): workflow.prepare_calendar(self.plugin, self.route, role="book") self.assertEqual(observed, ["#otp-send"]) self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"]) self.fetch.assert_called_once_with(self.route.mail, recipient="fixture@example.test", sent_at="2026-08-31 01:02:03") self.page.ele("#otp-input").input.assert_called_once_with("001234", clear=True) self.reader.assert_not_called() self.assertNotIn("001234", output.getvalue() + str(self.plugin._log.call_args_list)) self.plugin._record_calendar_book_prepared_route.assert_called_once_with(self.route) self.plugin._record_calendar_query_prepared_route.assert_not_called() def test_send_timestamp_is_captured_before_native_send(self): def click(ele): if ele.selector == "#otp-send": self.utc.assert_called_once() self.clicks.append(ele.selector) self.plugin.mouse.human_click_ele = click workflow.prepare_calendar(self.plugin, self.route, role="book") def test_mail_failure_has_no_avanti_no_manual_fallback_no_same_session_resend(self): self.fetch.side_effect = preparation.CalendarGateError("Italy OTP mailbox read failed") with self.assertRaises(preparation.CalendarGateError): workflow.prepare_calendar(self.plugin, self.route, role="book") with self.assertRaises(PermissionDeniedError): workflow.prepare_calendar(self.plugin, self.route, role="book") self.assertEqual(self.clicks, ["#otp-send"]) self.fetch.assert_called_once() self.reader.assert_not_called() def test_late_response_is_discarded_before_dom_write(self): with patch.object(workflow, "monotonic", side_effect=[0, 1, 300]): with self.assertRaisesRegex(preparation.CalendarGateError, "window expired"): workflow.prepare_calendar(self.plugin, self.route, role="book") self.assertEqual(self.clicks, ["#otp-send"]) def test_expiration_during_preflight_prevents_avanti(self): with patch.object(workflow, "monotonic", side_effect=[0, 1, 2, 300]): with self.assertRaisesRegex(preparation.CalendarGateError, "window expired"): workflow.prepare_calendar(self.plugin, self.route, role="book") self.assertEqual(self.clicks, ["#otp-send", "#otp-input"]) def test_account_change_during_read_discards_code(self): def changed(*args, **kwargs): self.plugin.config.account.username = "other@example.test" return "001234" self.fetch.side_effect = changed with self.assertRaises(preparation.CalendarGateError): workflow.prepare_calendar(self.plugin, self.route, role="book") self.assertEqual(self.clicks, ["#otp-send"]) def test_cloud_dom_write_failure_is_redacted_and_stops_avanti(self): self.page.ele("#otp-input").input.side_effect = RuntimeError("private typed 001234") with self.assertRaisesRegex(preparation.CalendarGateError, "DOM write verification failed") as caught: workflow.prepare_calendar(self.plugin, self.route, role="book") self.assertNotIn("001234", str(caught.exception)) self.assertEqual(self.clicks, ["#otp-send", "#otp-input"]) def test_wrong_cloud_role_or_invalid_final_flag(self): with self.assertRaises(PermissionDeniedError): workflow.prepare_calendar(self.plugin, self.route, role="query") self.plugin.free_config["final_submit_enabled"] = 1 with self.assertRaises(PermissionDeniedError): workflow.prepare_calendar(self.plugin, self.route, role="book") self.listener.assert_not_called() self.fetch.assert_not_called() def test_missing_mail_and_debug_logger_stop_before_any_site_action(self): with self.assertRaises(preparation.CalendarGateError): workflow.prepare_calendar(self.plugin, replace(self.route, mail=None), role="book") ita_otp.vs_log_macros._active_logger.setLevel(logging.DEBUG) with self.assertRaises(preparation.CalendarGateError): workflow.prepare_calendar(self.plugin, self.route, role="book") self.listener.assert_not_called() self.page.run_js.assert_not_called() class CloudFinalPreparationTests(CloudPreparationTests): """Run the same OTP/session/expiry/privacy cases with final explicitly on.""" def setUp(self): super().setUp() self.plugin.free_config["final_submit_enabled"] = True def test_preparation_does_not_itself_submit_final(self): with patch.object(workflow, "submit_final") as submit: workflow.prepare_calendar(self.plugin, self.route, role="book") submit.assert_not_called() self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"]) class CloudQueryPreparationTests(TestCase): """Use the same preparation, mail adapter and fixtures as applicant Book.""" listen = PreparationTests.listen def setUp(self): CloudPreparationTests.setUp(self) self.plugin.free_config.update(query_mode="calendar", final_submit_enabled=False) def prepare(self): workflow.prepare_calendar(self.plugin, self.route, role="query") def query_plugin(self, results): self.plugin.query = MethodType(ItaPlugin.query, self.plugin) self.plugin._resolve_route = Mock(return_value=self.route) self.plugin._query_once = Mock(side_effect=results) self.plugin._clear_calendar_query_state = Mock() return self.plugin def test_public_query_prepares_once_with_shared_mail_adapter_and_no_terminal(self): strong = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available, earliest_date=datetime(2026, 10, 13)) plugin = self.query_plugin([VSQueryResult(success=True), strong, strong]) client = Mock() client.fetch_mail_content.return_value = "OTP Code:001234" self.fetch.side_effect = lambda *args, **kwargs: ita_otp.fetch_otp_from_cloud( *args, **kwargs, api=client) output = StringIO() with patch.object(workflow, "submit_final") as final, redirect_stdout(output): self.assertIs(plugin.query(Mock()), strong) self.assertIs(plugin.query(Mock()), strong) client.fetch_mail_content.assert_called_once_with( email=self.route.mail.authorization_email, sender="noreply-prenotami@esteri.it", recipient=plugin.config.account.username, subject_keywords="OTP Code", body_keywords="OTP Code:", sent_date="2026-08-31 01:02:03", expiry=300, only_text=True) client.fetch_mail_content_from_top.assert_not_called() self.assertEqual(plugin._query_once.call_count, 3) self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"]) self.assertEqual(self.listener.call_count, 2) self.reader.assert_not_called() final.assert_not_called() self.plugin._record_calendar_query_prepared_route.assert_called_once_with(self.route) self.plugin._record_calendar_book_prepared_route.assert_not_called() self.assertNotIn("001234", output.getvalue() + str(plugin._log.call_args_list)) def test_account_mailbox_query_uses_the_new_pool_account_without_fixed_address(self): self.route = replace(self.route, mail=OtpMailConfig(authorization_source="account")) self.plugin.config.account.username = "new-pool-account@example.test" strong = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available, earliest_date=datetime(2026, 10, 13)) plugin = self.query_plugin([VSQueryResult(success=True), strong, strong]) client = Mock() client.fetch_mail_content.return_value = "OTP Code:001234" self.fetch.side_effect = lambda *args, **kwargs: ita_otp.fetch_otp_from_cloud(*args, **kwargs, api=client) with patch.object(workflow, "submit_final") as final, redirect_stdout(StringIO()): self.assertIs(plugin.query(Mock()), strong) self.assertIs(plugin.query(Mock()), strong) client.fetch_mail_content.assert_called_once() self.assertEqual(client.fetch_mail_content.call_args.kwargs["email"], "new-pool-account@example.test") self.assertEqual(client.fetch_mail_content.call_args.kwargs["recipient"], "new-pool-account@example.test") self.assertIsNone(self.route.mail.authorization_email) self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"]) self.reader.assert_not_called() final.assert_not_called() def test_negative_entry_never_sends_otp_or_reads_mail(self): negative = VSQueryResult(success=False) plugin = self.query_plugin([negative]) self.assertIs(plugin.query(Mock()), negative) self.page.run_js.assert_not_called() self.listener.assert_not_called() self.fetch.assert_not_called() self.reader.assert_not_called() def test_mail_failure_never_resends_or_falls_back_to_manual_in_same_session(self): self.fetch.side_effect = preparation.CalendarGateError("Italy OTP mailbox read failed") with redirect_stdout(StringIO()): with self.assertRaises(preparation.CalendarGateError): self.prepare() with self.assertRaises(PermissionDeniedError): self.prepare() self.fetch.assert_called_once() self.reader.assert_not_called() self.assertEqual(self.clicks, ["#otp-send"]) self.plugin._record_calendar_query_prepared_route.assert_not_called() def test_expired_mail_is_not_written(self): with patch.object(workflow, "monotonic", side_effect=[0, 1, 300]), redirect_stdout(StringIO()): with self.assertRaisesRegex(preparation.CalendarGateError, "window expired"): self.prepare() self.assertEqual(self.clicks, ["#otp-send"]) self.reader.assert_not_called() def test_account_change_during_mail_read_prevents_code_write(self): def changed(*args, **kwargs): self.plugin.config.account.username = "other@example.test" return "001234" self.fetch.side_effect = changed with redirect_stdout(StringIO()), self.assertRaises(preparation.CalendarGateError): self.prepare() self.assertEqual(self.clicks, ["#otp-send"]) self.reader.assert_not_called() def test_ambiguous_mail_rejected_by_existing_parser_before_avanti(self): client = Mock() client.fetch_mail_content.return_value = "OTP Code:001234 OTP Code:654321" self.fetch.side_effect = lambda *args, **kwargs: ita_otp.fetch_otp_from_cloud( *args, **kwargs, api=client) with redirect_stdout(StringIO()), self.assertRaisesRegex(preparation.CalendarGateError, "mail rejected"): self.prepare() self.assertEqual(self.clicks, ["#otp-send"]) self.reader.assert_not_called() client.fetch_mail_content_from_top.assert_not_called() def test_missing_mail_configuration_stops_before_site_actions(self): self.route = replace(self.route, mail=None) with self.assertRaisesRegex(preparation.CalendarGateError, "configuration is missing"): self.prepare() self.page.run_js.assert_not_called() self.listener.assert_not_called() self.fetch.assert_not_called() def test_query_cannot_enable_final_submission_or_use_book_preparation(self): for values, role in (({}, "book"), ({"final_submit_enabled": True}, "query")): with self.subTest(role=role): self.plugin.free_config.update(values) with self.assertRaises(PermissionDeniedError): workflow.prepare_calendar(self.plugin, self.route, role=role) self.page.run_js.assert_not_called() self.listener.assert_not_called() self.fetch.assert_not_called() class RecoveryWorkflowTests(TestCase): listen = PreparationTests.listen def setUp(self): PreparationTests.setUp(self) self.token_ready = False self.page.run_js.side_effect = lambda _: booking_preflight_snapshot( turnstileTokenPresent=self.token_ready, otpValuePresent=self.otp_present, otpDisabled=self.otp_present) self.helper = Mock() self.helper.click_verification_button.return_value = False self.factory = self.stack.enter_context(patch.object(ita_turnstile, 'CloudflareBypasser', return_value=self.helper)) self.stack.enter_context(patch.object(preparation.time, 'sleep')) def assert_preparation_recovers(self, role): def clicked(**kwargs): self.assertEqual(self.clicks, []) self.token_ready = True return True self.helper.click_verification_button.side_effect = clicked times = itertools.chain([0, 0, 5, 6], itertools.count(7)) output = StringIO() with patch.object(preparation.time, 'monotonic', side_effect=lambda: next(times)), redirect_stdout(output): workflow.prepare_calendar(self.plugin, self.route, role=role) self.helper.click_verification_button.assert_called_once_with(is_dfs=False) self.assertEqual(self.clicks, ['#otp-send', '#otp-input', '#btnAvanti']) self.reader.assert_called_once() self.assertEqual(self.listener.call_count, 2) self.assertIn('"state": "ready"', output.getvalue()) self.factory.assert_called_once_with(self.page, log=False) self.helper.bypass.assert_not_called() def test_book_interaction_is_followed_by_real_readback_before_one_otp(self): self.assert_preparation_recovers('book') self.plugin._record_calendar_book_prepared_route.assert_called_once_with(self.route) self.plugin._record_calendar_query_prepared_route.assert_not_called() def test_query_reuses_book_recovery_then_records_only_query_preparation(self): self.assert_preparation_recovers('query') self.plugin._record_calendar_query_prepared_route.assert_called_once_with(self.route) self.plugin._record_calendar_book_prepared_route.assert_not_called() def test_query_three_clicks_without_token_cannot_release_otp(self): self.helper.click_verification_button.return_value = True with patch.object(preparation.time, 'monotonic', side_effect=[0, 0, 5, 15, 25, 35, 121]), \ redirect_stdout(StringIO()), self.assertRaisesRegex(preparation.CalendarGateError, 'turnstile_token_pending'): workflow.prepare_calendar(self.plugin, self.route, role='query') self.assertEqual(self.helper.click_verification_button.call_count, 3) self.listener.assert_not_called() self.reader.assert_not_called() self.assertEqual(self.clicks, []) self.plugin._record_calendar_query_prepared_route.assert_not_called() def test_query_stages_share_one_recovery_budget(self): # The third click yields a real token. Expiry after sending OTP must not # create a fresh recovery budget or allow AVANTI without a new token. def clicked(**kwargs): if self.helper.click_verification_button.call_count == 3: self.token_ready = True return True self.helper.click_verification_button.side_effect = clicked def click(ele): self.clicks.append(ele.selector) if ele.selector == '#otp-send': self.token_ready = False self.plugin.mouse.human_click_ele = click ticks = [0, 0, 5, 15, 25, 26, 27, 27, 32, 42, 52, 148] with patch.object(preparation.time, 'monotonic', side_effect=ticks), \ redirect_stdout(StringIO()), self.assertRaisesRegex(preparation.CalendarGateError, 'turnstile_token_pending'): workflow.prepare_calendar(self.plugin, self.route, role='query') self.factory.assert_called_once_with(self.page, log=False) self.assertEqual(self.helper.click_verification_button.call_count, 3) self.assertEqual(self.clicks, ['#otp-send', '#otp-input']) self.assertEqual(self.listener.call_count, 1) self.plugin._record_calendar_query_prepared_route.assert_not_called() def test_query_ready_widget_does_not_invoke_helper(self): self.token_ready = True with redirect_stdout(StringIO()): workflow.prepare_calendar(self.plugin, self.route, role='query') self.factory.assert_not_called() self.assertEqual(self.clicks, ['#otp-send', '#otp-input', '#btnAvanti']) def test_prepared_query_skips_recovery_and_all_preparation_actions(self): self.page.url = 'https://prenotami.esteri.it/BookingCalendar' with patch.object(workflow, 'ItalyTurnstileRecovery') as recovery: self.assertIsNone(workflow.prepare_query_if_needed(self.plugin, Mock())) recovery.assert_not_called() self.factory.assert_not_called() self.listener.assert_not_called() self.page.run_js.assert_not_called() def test_book_timeout_is_diagnostic_and_sends_no_otp(self): output = StringIO() with patch.object(preparation.time, 'monotonic', side_effect=[0, 0, 5, 121]), \ redirect_stdout(output), self.assertRaisesRegex(preparation.CalendarGateError, 'turnstile_token_pending'): workflow.prepare_calendar(self.plugin, self.route, role='book') self.listener.assert_not_called() self.reader.assert_not_called() self.assertEqual(self.clicks, []) self.assertIn('"outcome": "timeout"', output.getvalue()) self.helper.bypass.assert_not_called() def test_cloud_book_timeout_never_calls_mail_api(self): self.plugin.free_config['otp_mode'] = 'cloud' self.route = replace(self.route, mail=OtpMailConfig('mailbox@example.test')) with patch.object(preparation.time, 'monotonic', side_effect=[0, 0, 5, 121]), \ patch.object(workflow, 'fetch_otp_from_cloud') as fetch, \ patch.object(ita_otp.vs_log_macros, '_active_logger', logging.Logger('offline-cf', logging.INFO)), \ redirect_stdout(StringIO()), self.assertRaises(preparation.CalendarGateError): workflow.prepare_calendar(self.plugin, self.route, role='book') fetch.assert_not_called() self.listener.assert_not_called() self.reader.assert_not_called() class ProductionEntryTests(TestCase): def setUp(self): self.plugin, self.route, self.trigger = flow.prepared_plugin(flow.FlowPage()) self.plugin.free_config["otp_mode"] = "manual" self.inputs = {"username": self.plugin.config.account.username} self.plugin.is_healthy = True self.plugin._log = Mock() self.addCleanup(setattr, self.plugin, "_cleanup_attempted", True) def test_prepared_book_reuses_real_calendar_adapter_and_defaults_to_prefinal(self): with patch.object(workflow, "submit_final") as submit, patch.object(workflow, "prepare_calendar") as prepare: result = self.plugin.book(self.trigger, self.inputs) self.assertFalse(result.success) self.assertIsNotNone(self.plugin.last_booking_precommit) self.assertEqual(result.label, "calendar-ready-before-final") self.assertEqual(self.plugin.page.guard_final_count, 0) submit.assert_not_called() prepare.assert_not_called() def test_cloud_book_reuses_selection_without_enabling_final(self): self.plugin.free_config["otp_mode"] = "cloud" with patch.object(workflow, "submit_final") as submit: result = self.plugin.book(self.trigger, self.inputs) self.assertEqual(result.label, "calendar-ready-before-final") self.assertIsNotNone(self.plugin.last_booking_precommit) self.assertFalse(result.success) submit.assert_not_called() def test_cloud_final_uses_the_existing_submitter_after_fresh_selection(self): self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True) confirmed = VSBookResult(success=True, book_date="2026-10-13", book_time="09:26") with patch.object(workflow, "submit_final", return_value=confirmed) as submit: result = self.plugin.book(self.trigger, self.inputs) self.assertIs(result, confirmed) self.assertIsNotNone(self.plugin.last_booking_precommit) submit.assert_called_once_with(self.plugin, self.route) def test_invalid_final_flag_is_rejected_before_site_actions(self): self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled="true") with patch.object(workflow, "submit_final") as submit, \ patch.object(workflow, "prepare_calendar") as prepare, self.assertRaises(PermissionDeniedError): self.plugin.book(self.trigger, self.inputs) submit.assert_not_called() prepare.assert_not_called() def test_cloud_final_no_inventory_never_submits(self): self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True) self.plugin.page = flow.FlowPage([flow.month(m, {}) for m in ("2026-10", "2026-11", "2026-12")]) self.plugin._record_calendar_book_prepared_route(self.route) with patch.object(workflow, "submit_final") as submit, flow.browser_navigation(self.plugin.page): result = self.plugin.book(self.trigger, self.inputs) self.assertFalse(result.success) submit.assert_not_called() def test_enabled_book_returns_standard_result_after_real_slot_selection(self): self.plugin.free_config["final_submit_enabled"] = True confirmed = VSBookResult(success=True, book_date="2026-10-13", book_time="09:26") with patch.object(workflow, "submit_final", return_value=confirmed) as submit: result = self.plugin.book(self.trigger, self.inputs) self.assertIs(result, confirmed) self.assertIsNotNone(self.plugin.last_booking_precommit) submit.assert_called_once_with(self.plugin, self.route) def test_one_public_book_call_prepares_and_selects_from_dashboard(self): plugin = self.plugin plugin.page.url = "https://prenotami.esteri.it/UserArea" plugin._calendar_book_prepared_context = None plugin._inspect_booking_form_structure = Mock() def entry(apt): plugin.page.url = "https://prenotami.esteri.it" + plugin._booking_path(self.route) return VSQueryResult(success=True) plugin.query.side_effect = entry def prepare(p, route, *, role): self.assertEqual(role, "book") p.page.url = "https://prenotami.esteri.it/BookingCalendar" p._record_calendar_book_prepared_route(route) with patch.object(workflow, "prepare_calendar", side_effect=prepare) as prep: result = plugin.book(self.trigger, self.inputs) prep.assert_called_once() plugin.query.assert_called_once() self.assertEqual(result.label, "calendar-ready-before-final") self.assertIsNotNone(plugin.last_booking_precommit) def test_final_config_requires_explicit_supported_applicant_mode(self): for values, accepted in (({}, True), ({"otp_mode": "manual"}, True), ({"otp_mode": "cloud"}, True), ({"otp_mode": "cloud", "final_submit_enabled": True}, True), ({"otp_mode": "cloud", "query_mode": "calendar"}, True), ({"otp_mode": "cloud", "query_mode": "calendar", "final_submit_enabled": True}, False), ({"otp_mode": "cloud", "final_submit_enabled": "true"}, False), ({"otp_mode": "cloud", "final_submit_enabled": 1}, False), ({"otp_mode": "manual", "final_submit_enabled": True}, True), ({"final_submit_enabled": True}, False), ({"otp_mode": "manual", "final_submit_enabled": 1}, False), ({"otp_mode": "manual", "final_submit_enabled": True, "query_mode": "calendar"}, False)): with self.subTest(values=values): config = VSPlgConfig(free_config=values) if accepted: self.plugin.set_config(config) else: with self.assertRaises(BizLogicError): self.plugin.set_config(config) def test_no_inventory_never_calls_final(self): self.plugin.page = flow.FlowPage([flow.month(m, {}) for m in ("2026-10", "2026-11", "2026-12")]) self.plugin._record_calendar_book_prepared_route(self.route) with patch.object(workflow, "submit_final") as submit, flow.browser_navigation(self.plugin.page): result = self.plugin.book(self.trigger, self.inputs) self.assertFalse(result.success) submit.assert_not_called() def test_query_or_another_applicant_cannot_book(self): for query_key, username in ((self.route.routing_key, self.inputs["username"]), (None, "other@example.test")): self.plugin._calendar_query_route_key = query_key with self.assertRaises(BizLogicError), patch.object(workflow, "submit_final") as submit: self.plugin.book(self.trigger, {"username": username}) submit.assert_not_called() def test_unknown_attempt_cannot_rescan_or_submit_again(self): self.plugin._production_final_attempt = SimpleNamespace(state="unknown") with self.assertRaises(FinalOutcomeUnknown), patch.object(workflow, "submit_final") as submit: self.plugin.book(self.trigger, self.inputs) submit.assert_not_called() self.assertEqual(self.plugin.page.refreshes, 0) def test_cloud_unknown_attempt_is_not_retried(self): self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True) self.plugin._production_final_attempt = SimpleNamespace(state="unknown") with patch.object(workflow, "submit_final") as submit, \ patch.object(workflow, "prepare_calendar") as prepare, self.assertRaises(FinalOutcomeUnknown): self.plugin.book(self.trigger, self.inputs) submit.assert_not_called() prepare.assert_not_called() self.assertEqual(self.plugin.page.refreshes, 0) def test_cloud_final_rejects_query_session_and_other_applicant(self): self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True) for query_key, username in ((self.route.routing_key, self.inputs["username"]), (None, "other@example.test")): self.plugin._calendar_query_route_key = query_key with patch.object(workflow, "submit_final") as submit, self.assertRaises(BizLogicError): self.plugin.book(self.trigger, {"username": username}) submit.assert_not_called() def test_cloud_confirmed_result_does_not_create_second_booking(self): self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True) self.test_confirmed_result_can_be_reported_again_without_another_booking() def test_confirmed_result_can_be_reported_again_without_another_booking(self): result = VSBookResult(success=True, book_date="2026-10-13", book_time="09:26") self.plugin._production_final_attempt = SimpleNamespace(state="confirmed", target=SimpleNamespace( applicant=self.inputs["username"], routing_key=self.route.routing_key)) self.plugin._production_book_result = result self.assertIs(self.plugin.book(self.trigger, self.inputs), result) self.assertEqual(self.plugin.page.refreshes, 0) def test_query_from_dashboard_prepares_once_and_never_returns_weak_positive(self): plugin = self.plugin plugin.query = MethodType(ItaPlugin.query, plugin) plugin.free_config["query_mode"] = "calendar" plugin.page.url = "https://prenotami.esteri.it/UserArea" plugin._calendar_book_prepared_context = None strong = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available, earliest_date=datetime(2026, 10, 13), apt_type=self.trigger.apt_type) plugin._query_once = Mock(side_effect=lambda apt, **kwargs: ( VSQueryResult(success=True) if kwargs else strong)) def prepare(p, route, *, role): self.assertEqual(role, "query") p.page.url = "https://prenotami.esteri.it/BookingCalendar" with patch.object(workflow, "prepare_calendar", side_effect=prepare) as prep: self.assertIs(plugin.query(self.trigger.apt_type), strong) self.assertIs(plugin.query(self.trigger.apt_type), strong) self.assertEqual(prep.call_count, 1) self.assertEqual(plugin._query_once.call_count, 3) def test_entry_no_availability_does_not_send_otp(self): self.plugin.page.url = "https://prenotami.esteri.it/UserArea" negative = VSQueryResult(success=False) self.plugin._query_once = Mock(return_value=negative) with patch.object(workflow, "prepare_calendar") as prep: self.assertIs(workflow.prepare_query_if_needed(self.plugin, self.trigger.apt_type), negative) prep.assert_not_called() def test_production_modules_never_import_debug_tools(self): root = Path(__file__).resolve().parents[1] for filename in ("ita_workflow.py", "ita_calendar_session.py"): tree = ast.parse((root / "plugins" / filename).read_text()) imports = [n.module for n in ast.walk(tree) if isinstance(n, ast.ImportFrom)] self.assertFalse(any(name and name.startswith("tools") for name in imports)) class FinalCompositionTests(TestCase): def setUp(self): attribution.AttributionTests.setUp(self) self.plugin._log = Mock() self.audit = Mock() self.before = {k: 0 for k in ("otpRequests", "avantiPosts", "availabilityRequests", "finalRequests", "timeSlotRequests")} self.after = {**self.before, "finalRequests": 1} self.audit.settled_snapshot.side_effect = [self.before, self.after] def add_confirmed(self): attribution.AttributionTests.add_confirmed(self) def run_final(self): def native_factory(page, target, current): native = Mock(side_effect=lambda: (self.add_confirmed(), SubmissionSignal.UNKNOWN)[1]) native.submitted_selection = VerifiedSubmission(target) return native with patch.object(workflow.preparation, "CalendarRequestAudit", return_value=self.audit), \ patch.object(workflow, "NativeFinalSubmitter", side_effect=native_factory) as factory: result = workflow.submit_final(self.plugin, self.route) self.assertEqual(factory.call_count, 1) return result def test_real_read_port_and_core_return_success_with_assigned_time(self): result = self.run_final() self.assertTrue(result.success) self.assertEqual(result.book_time, "09:26") self.assertEqual(self.plugin._production_final_attempt.state, "confirmed") self.assertIs(self.plugin._production_book_result, result) self.audit.stop.assert_called_once() def test_missing_request_audit_leaves_unknown_attempt_not_false_result(self): self.after["finalRequests"] = 0 with self.assertRaises(FinalOutcomeUnknown): self.run_final() self.assertEqual(self.plugin._production_final_attempt.state, "unknown") self.audit.stop.assert_called_once() def test_audit_cleanup_failure_does_not_erase_confirmed_result(self): self.audit.stop.side_effect = RuntimeError("fixture") self.assertTrue(self.run_final().success) self.plugin._log.assert_called_once() class CloudFinalCompositionTests(FinalCompositionTests): """Cloud mode shares the real read-port, receipt attribution and no-retry core.""" def setUp(self): super().setUp() self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True) class RealFinalAuditTests(TestCase): """Real audit ownership + production final core, synthetic CDP/receipts.""" def setUp(self): from test.test_debug_ita_production_query_gate import FakeAuditPage attribution.AttributionTests.setUp(self) self.plugin._log = Mock() transport = FakeAuditPage() self.main.driver = transport.driver self.main.run_cdp = transport.run_cdp self.transport = transport self.audit = preparation.CalendarRequestAudit(self.main, include_time_slots=True) self.audit.start = Mock(wraps=self.audit.start) self.audit.stop = Mock(wraps=self.audit.stop) self.addCleanup(self.audit.stop) clock = itertools.count(0, 0.1) self.enterContext(patch.object(preparation, "time", SimpleNamespace( monotonic=lambda: next(clock), sleep=lambda _seconds: None))) self.on_submit = lambda: transport.emit("/BookingCalendar/InsertNewBooking") self.native = Mock(side_effect=self.dispatch) def native_factory(page, target, current): self.assertIs(page, self.main) self.native.submitted_selection = VerifiedSubmission(target) return self.native self.factory = self.enterContext(patch.object(workflow, "NativeFinalSubmitter", side_effect=native_factory)) def dispatch(self): self.on_submit() attribution.AttributionTests.add_confirmed(self) return SubmissionSignal.UNKNOWN def borrow(self): return workflow.submit_final(self.plugin, self.route, request_audit=self.audit) def test_shared_audit_counts_one_submit_and_remains_owned_by_caller(self): self.audit.start() callback = self.main.driver.immediate_event_handlers[self.audit.EVENT] self.assertTrue(self.borrow().success) self.native.assert_called_once() self.audit.start.assert_called_once() self.audit.stop.assert_not_called() self.audit.require_active_on(self.main) self.assertIs(self.main.driver.immediate_event_handlers[self.audit.EVENT], callback) self.assertEqual(self.audit.snapshot()["finalRequests"], 1) self.assertEqual(self.transport.commands.count("Network.enable"), 1) def test_standalone_production_still_owns_start_and_stop(self): with patch.object(preparation, "CalendarRequestAudit", return_value=self.audit) as factory: self.assertTrue(workflow.submit_final(self.plugin, self.route).success) factory.assert_called_once_with(self.main, include_time_slots=True) self.audit.start.assert_called_once() self.audit.stop.assert_called_once() self.assertEqual(self.main.driver.immediate_event_handlers, {}) def test_nested_registration_without_explicit_borrow_still_refused(self): self.audit.start() with self.assertRaisesRegex(preparation.CalendarGateError, "existing callback"): workflow.submit_final(self.plugin, self.route) self.factory.assert_not_called() self.audit.require_active_on(self.main) self.browser.new_tab.assert_not_called() def test_existing_reservation_blocks_without_stopping_borrowed_audit(self): from plugins.ita_booking_final import FinalBookingError self.audit.start() attribution.AttributionTests.add_confirmed(self) with self.assertRaises(FinalBookingError): self.borrow() self.factory.assert_not_called() self.audit.stop.assert_not_called() self.audit.require_active_on(self.main) self.assertEqual(self.audit.snapshot()["finalRequests"], 0) def test_wrong_page_driver_stopped_or_disconnected_audit_never_submits(self): self.audit.start() for target, attribute, replacement in ( (self.audit, "page", self.transport), (self.main, "driver", object()), (self.audit, "_started", False), (self.audit.driver, "is_running", False)): with self.subTest(attribute=attribute), patch.object(target, attribute, replacement): with self.assertRaises(preparation.CalendarGateError): self.borrow() self.factory.assert_not_called() self.browser.new_tab.assert_not_called() self.audit.stop.assert_not_called() def test_replaced_callback_is_not_overwritten_or_accepted_as_proof(self): self.audit.start() for handlers in (self.audit.driver.event_handlers, self.audit.driver.immediate_event_handlers): foreign = Mock() with patch.dict(handlers, {self.audit.EVENT: foreign}): with self.assertRaisesRegex(preparation.CalendarGateError, "callback changed"): self.borrow() self.assertIs(handlers[self.audit.EVENT], foreign) self.factory.assert_not_called() self.audit.stop.assert_not_called() def test_borrowed_audit_must_cover_time_slots(self): self.audit.start() with patch.dict(self.audit._counts, {"finalRequests": 0}, clear=True): with self.assertRaisesRegex(preparation.CalendarGateError, "include time slots"): self.borrow() self.factory.assert_not_called() self.browser.new_tab.assert_not_called() def test_callback_lost_during_submission_cannot_confirm_from_stale_counters(self): self.audit.start() foreign = Mock() handlers = self.audit.driver.immediate_event_handlers def lose_callback(): self.transport.emit("/BookingCalendar/InsertNewBooking") handlers[self.audit.EVENT] = foreign self.on_submit = lose_callback with patch.dict(handlers): with self.assertRaises(FinalOutcomeUnknown): self.borrow() self.assertIs(handlers[self.audit.EVENT], foreign) self.assertEqual(self.plugin._production_final_attempt.state, "unknown") self.audit.stop.assert_not_called() self.native.assert_called_once() self.audit.require_active_on(self.main) def test_missing_duplicate_or_mixed_requests_do_not_become_success(self): for requests in ([], ["/BookingCalendar/InsertNewBooking"] * 2, ["/BookingCalendar/InsertNewBooking", "/BookingCalendar/RetrieveTimeSlots"]): with self.subTest(requests=requests): before_listing = self.browser.raw self.audit.start() self.on_submit = lambda: [self.transport.emit(path) for path in requests] try: with self.assertRaises(FinalOutcomeUnknown): self.borrow() self.assertEqual(self.plugin._production_final_attempt.state, "unknown") self.audit.require_active_on(self.main) finally: self.audit.stop() self.browser.raw = before_listing self.assertEqual(self.native.call_count, 3) class BookerReuseTests(TestCase): def setUp(self): # Reuse existing offline Redis import fixture; never open Redis/cloud. from test.test_ita_plugin import OrderBookerGCO from threading import RLock self.booker = OrderBookerGCO.__new__(OrderBookerGCO) self.booker.m_lock = RLock() self.booker.m_task_data_cache = {"fixture": {"status": "running", "order_id": "order", "user_inputs": {}}} self.booker._log = Mock() self.booker._remove_task = Mock() self.booker._push_success_notification = Mock() self.booker.redis_client = Mock() self.booker.m_tracker_key = "fixture" self.task = SimpleNamespace(task_ref="fixture", book_allowed=True, instance=Mock()) self.api = Mock() api_patch = patch.dict(self.booker._execute_book_job.__func__.__globals__, VSCloudApi=self.api) api_patch.start() self.addCleanup(api_patch.stop) def test_standard_success_still_uses_existing_reporting(self): result = VSBookResult(success=True, book_date="2026-10-13", book_time="09:26") self.task.instance.book.return_value = result self.booker._execute_book_job(self.task, VSQueryResult()) self.booker._push_success_notification.assert_called_once_with("fixture", "order", result) def test_unknown_pauses_using_existing_api_and_next_signal_does_nothing(self): self.task.instance.book.side_effect = FinalOutcomeUnknown() self.booker._execute_book_job(self.task, VSQueryResult()) self.booker._execute_book_job(self.task, VSQueryResult()) self.api.Instance.return_value.update_vas_task.assert_called_once_with("fixture", {"status": "pause"}) self.assertFalse(self.task.book_allowed) self.task.instance.book.assert_called_once() self.booker._push_success_notification.assert_not_called() def test_pause_failure_keeps_task_blocked_locally(self): self.task.instance.book.side_effect = FinalOutcomeUnknown() self.api.Instance.return_value.update_vas_task.side_effect = RuntimeError("fixture") self.booker._execute_book_job(self.task, VSQueryResult()) self.booker._execute_book_job(self.task, VSQueryResult()) self.assertFalse(self.task.book_allowed) self.task.instance.book.assert_called_once() self.booker._remove_task.assert_not_called() class QueryCliTests(TestCase): def test_workflow_flag_reuses_route_builder_and_calls_standard_query(self): from tools import debug_ita_query as cli from test.test_debug_ita_calendar_gate import gate_env plugin = Mock() plugin.query.return_value = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available, earliest_date=datetime(2026, 10, 13)) stdout = StringIO() with patch.object(cli, "ItaPlugin", return_value=plugin), \ patch.object(cli, "resolve_chrome_path", return_value=Path("/offline/chrome")), \ patch.object(cli, "_get_query_credentials", return_value=("query@example.test", "fixture")), \ patch.object(cli, "_prepare_query_profile", return_value=Path("/offline/profile")), \ redirect_stdout(stdout): code = cli.run_query_once(gate_env(), non_interactive=False, production_workflow=True) self.assertEqual(code, 0) config = plugin.set_config.call_args.args[0] self.assertEqual(config.free_config["query_mode"], "calendar") self.assertEqual(config.free_config["otp_mode"], "manual") self.assertIs(config.free_config["final_submit_enabled"], False) plugin.query.assert_called_once() plugin.book.assert_not_called() plugin.cleanup.assert_called_once() self.assertIn("ITA_QUERY_WORKFLOW_RESULT=", stdout.getvalue()) def test_headless_workflow_rejected_before_credentials(self): from tools import debug_ita_query as cli with patch.object(cli, "_get_query_credentials") as credentials: with self.assertRaises(cli.DebugConfigurationError): cli.run_query_once({}, non_interactive=True, production_workflow=True) credentials.assert_not_called()