| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689 |
- """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()
|