"""Offline production-entry tests: no credentials, site calls, or cloud writes.""" import ast 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_plugin as workflow from plugins import ita_plugin as preparation from plugins.ita_plugin import ItaPlugin from plugins.ita_plugin import fetch_otp_from_cloud as real_fetch_otp_from_cloud from plugins import ita_plugin as ita_turnstile from plugins.ita_plugin import OtpMailConfig from test.ita import test_ita_calendar_book_flow as flow from test.ita.test_debug_ita_calendar_gate import booking_preflight_snapshot 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, otpSendEnabled=not 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_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_prepared_route.assert_called_once_with(self.route, role="query") 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_prepared_route.assert_called_once_with(self.route, role="book") 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_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.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_prepared_route.assert_called_once_with(self.route, role="book") 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_stops_avanti(self): self.page.ele("#otp-input").input.side_effect = RuntimeError("private typed 001234") with self.assertRaisesRegex(preparation.CalendarGateError, "DOM write failed"): workflow.prepare_calendar(self.plugin, self.route, role="book") 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_stops_before_any_site_action(self): with self.assertRaises(preparation.CalendarGateError): workflow.prepare_calendar(self.plugin, replace(self.route, mail=None), 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._prepared_calendar = None self.plugin._resolve_route = Mock(return_value=self.route) self.plugin._enter_service = Mock(return_value=results[0]) self.plugin._query_once = Mock(side_effect=results[1:]) self.plugin._reset_calendar_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: real_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() plugin._enter_service.assert_called_once() self.assertEqual(plugin._query_once.call_count, 2) 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_prepared_route.assert_called_once_with(self.route, role="query") 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: real_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_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: real_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( turnstileReady=self.token_ready, otpValuePresent=self.otp_present, otpSendEnabled=not 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.assertGreaterEqual(self.page.run_js.call_count, 3) self.assertNotIn('ITA_BOOK_PREFLIGHT_DIAGNOSTIC=', 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_prepared_route.assert_called_once_with(self.route, role="book") def test_query_reuses_book_recovery_then_records_only_query_preparation(self): self.assert_preparation_recovers('query') self.plugin._record_calendar_prepared_route.assert_called_once_with(self.route, role="query") 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_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_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, 'turnstile_recovery') 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_stops_before_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('ITA_BOOK_WAITING_FOR_FORM:', output.getvalue()) self.assertNotIn('ITA_BOOK_PREFLIGHT_DIAGNOSTIC=', 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, \ 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() 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.assertEqual(result.label, "calendar-ready-before-final") self.assertEqual(self.plugin.page.clicks, 1) 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.assertEqual(self.plugin.page.clicks, 1) 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.assertIs(submit.call_args.args[0], self.plugin) self.assertEqual(submit.call_args.args[1], self.route) self.assertIsNotNone(submit.call_args.args[2]) 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_prepared_route(self.route, role="book") 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.assertIs(submit.call_args.args[0], self.plugin) self.assertEqual(submit.call_args.args[1], self.route) self.assertIsNotNone(submit.call_args.args[2]) def test_one_public_book_call_prepares_and_selects_from_dashboard(self): plugin = self.plugin plugin.page.url = "https://prenotami.esteri.it/UserArea" plugin._prepared_calendar = None def entry(apt, **kwargs): plugin.page.url = "https://prenotami.esteri.it" + plugin._booking_path(self.route) return VSQueryResult(success=True) plugin._enter_service = Mock(side_effect=entry) def prepare(p, route, *, role): self.assertEqual(role, "book") p.page.url = "https://prenotami.esteri.it/BookingCalendar" p._record_calendar_prepared_route(route, role="book") with patch.object(workflow, "prepare_calendar", side_effect=prepare) as prep: result = plugin.book(self.trigger, self.inputs) prep.assert_called_once() plugin._enter_service.assert_called_once_with(self.trigger.apt_type, route=self.route) plugin.query.assert_not_called() self.assertEqual(result.label, "calendar-ready-before-final") self.assertEqual(plugin.page.clicks, 1) 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_prepared_route(self.route, role="book") 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): context = self.plugin._prepared_calendar for query_key, username in ((self.route.routing_key, self.inputs["username"]), (None, "other@example.test")): self.plugin._prepared_calendar = replace(context, role="query" if query_key else "book") with self.assertRaises(BizLogicError), patch.object(workflow, "submit_final") as submit: self.plugin.book(self.trigger, {"username": username}) submit.assert_not_called() def test_cloud_final_rejects_query_session_and_other_applicant(self): self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True) context = self.plugin._prepared_calendar for query_key, username in ((self.route.routing_key, self.inputs["username"]), (None, "other@example.test")): self.plugin._prepared_calendar = replace(context, role="query" if query_key else "book") with patch.object(workflow, "submit_final") as submit, self.assertRaises(BizLogicError): self.plugin.book(self.trigger, {"username": username}) submit.assert_not_called() 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._prepared_calendar = None strong = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available, earliest_date=datetime(2026, 10, 13), apt_type=self.trigger.apt_type) plugin._enter_service = Mock(return_value=VSQueryResult(success=True)) plugin._query_once = Mock(return_value=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) plugin._enter_service.assert_called_once() self.assertEqual(plugin._query_once.call_count, 2) 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._enter_service = 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[2] for filename in ("ita_plugin.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 BookerReuseTests(TestCase): def setUp(self): # Reuse existing offline Redis import fixture; never open Redis/cloud. from test.ita.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_standard_failure_is_called_again_on_the_next_signal(self): self.task.instance.book.return_value = VSBookResult(success=False) 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_not_called() self.assertTrue(self.task.book_allowed) self.assertEqual(self.task.instance.book.call_count, 2) self.booker._push_success_notification.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.ita.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")), \ patch.object(cli, "_bind_query_profile", return_value=Mock()), \ 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()