test_ita_workflow.py 38 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689
  1. """Offline production-entry tests: no credentials, site calls, or cloud writes."""
  2. import ast
  3. import itertools
  4. from dataclasses import replace
  5. from contextlib import ExitStack
  6. from datetime import datetime
  7. from pathlib import Path
  8. from io import StringIO
  9. from contextlib import redirect_stdout
  10. from types import MethodType, SimpleNamespace
  11. from unittest import TestCase
  12. from unittest.mock import Mock, patch
  13. from plugins import ita_plugin as workflow
  14. from plugins import ita_plugin as preparation
  15. from plugins.ita_plugin import ItaPlugin
  16. from plugins.ita_plugin import fetch_otp_from_cloud as real_fetch_otp_from_cloud
  17. from plugins import ita_plugin as ita_turnstile
  18. from plugins.ita_plugin import OtpMailConfig
  19. from test.ita import test_ita_calendar_book_flow as flow
  20. from test.ita.test_debug_ita_calendar_gate import booking_preflight_snapshot
  21. from vs_types import AvailabilityStatus, BizLogicError, PermissionDeniedError, VSBookResult, VSPlgConfig, VSQueryResult
  22. class PreparationTests(TestCase):
  23. def setUp(self):
  24. _, self.route, _ = flow.prepared_plugin(flow.FlowPage())
  25. self.path = f"/Services/Booking/{self.route.service_id}"
  26. self.page = SimpleNamespace(url="https://prenotami.esteri.it" + self.path,
  27. tab_id="fixture-tab", wait=Mock(), set=Mock())
  28. self.otp_present = False
  29. self.clicks = []
  30. self.page.run_js = Mock(side_effect=lambda _: booking_preflight_snapshot(
  31. otpValuePresent=self.otp_present, otpSendEnabled=not self.otp_present))
  32. otp_input = Mock()
  33. otp_input.input.side_effect = lambda *a, **k: setattr(self, "otp_present", True)
  34. otp_input.run_js.return_value = True
  35. otp_input.selector = "#otp-input"
  36. controls = {"#otp-input": otp_input, "#otp-send": SimpleNamespace(selector="#otp-send"),
  37. "#btnAvanti": SimpleNamespace(selector="#btnAvanti")}
  38. self.page.ele = Mock(side_effect=lambda selector, **kwargs: controls[selector])
  39. self.plugin = SimpleNamespace(
  40. page=self.page, session_create_time=1, free_config={"otp_mode": "manual"},
  41. config=SimpleNamespace(account=SimpleNamespace(username="fixture@example.test")),
  42. mouse=SimpleNamespace(human_click_ele=lambda ele: self.clicks.append(ele.selector)),
  43. _booking_path=lambda route: self.path, _log=Mock(),
  44. _record_calendar_prepared_route=Mock(),
  45. )
  46. self.plugin._book_final_configuration_valid = MethodType(ItaPlugin._book_final_configuration_valid, self.plugin)
  47. self.stack = ExitStack()
  48. self.addCleanup(self.stack.close)
  49. self.tty = self.stack.enter_context(patch.object(workflow.sys.stdin, "isatty", return_value=True))
  50. self.reader = self.stack.enter_context(patch.object(preparation, "_read_manual_otp", return_value="123456"))
  51. self.listener = self.stack.enter_context(patch.object(workflow, "listen_once", side_effect=self.listen))
  52. self.stack.enter_context(patch.object(workflow, "guard_calendar"))
  53. self.stack.enter_context(patch.object(workflow, "wait_for_calendar_service", return_value="9001"))
  54. def listen(self, page, *, target, method, timeout, action):
  55. action()
  56. if target == self.path:
  57. page.url = "https://prenotami.esteri.it/BookingCalendar?selectedService=Example"
  58. return SimpleNamespace(tab_id=page.tab_id, is_failed=False, method=method,
  59. url="https://prenotami.esteri.it" + target + ("?ServiceID=9001" if method == "GET" else ""),
  60. response=SimpleNamespace(status=200, raw_body='"SENT"', url=page.url))
  61. def test_native_preparation_sends_once_writes_once_and_records_query_role(self):
  62. workflow.prepare_calendar(self.plugin, self.route, role="query")
  63. self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"])
  64. self.assertEqual(self.listener.call_count, 2)
  65. self.reader.assert_called_once()
  66. self.plugin._record_calendar_prepared_route.assert_called_once_with(self.route, role="query")
  67. self.assertEqual(self.page.run_js.call_count, 2)
  68. self.assertIn("form-boundary", self.page.run_js.call_args.args[0])
  69. def test_book_role_does_not_mark_query_prepared(self):
  70. workflow.prepare_calendar(self.plugin, self.route, role="book")
  71. self.plugin._record_calendar_prepared_route.assert_called_once_with(self.route, role="book")
  72. def test_no_terminal_stops_before_otp_or_form_changes(self):
  73. self.tty.return_value = False
  74. with self.assertRaises(PermissionDeniedError):
  75. workflow.prepare_calendar(self.plugin, self.route, role="query")
  76. self.listener.assert_not_called()
  77. self.page.run_js.assert_not_called()
  78. def test_wrong_otp_readback_prevents_avanti_and_repeated_otp(self):
  79. self.page.ele("#otp-input").run_js.return_value = False
  80. with self.assertRaisesRegex(preparation.CalendarGateError, "verification failed"):
  81. workflow.prepare_calendar(self.plugin, self.route, role="book")
  82. with self.assertRaises(PermissionDeniedError):
  83. workflow.prepare_calendar(self.plugin, self.route, role="book")
  84. self.assertEqual(self.clicks, ["#otp-send", "#otp-input"])
  85. self.assertEqual(self.listener.call_count, 1)
  86. def test_wrong_tab_response_never_reads_otp_or_submits_form(self):
  87. self.listener.side_effect = None
  88. self.listener.return_value = SimpleNamespace(tab_id="foreign", is_failed=False)
  89. with self.assertRaises(preparation.CalendarGateError):
  90. workflow.prepare_calendar(self.plugin, self.route, role="query")
  91. self.reader.assert_not_called()
  92. self.plugin._record_calendar_prepared_route.assert_not_called()
  93. class CloudPreparationTests(TestCase):
  94. """Reuse the manual site's fixture, replacing only the OTP provider."""
  95. listen = PreparationTests.listen
  96. def setUp(self):
  97. PreparationTests.setUp(self)
  98. self.plugin.free_config["otp_mode"] = "cloud"
  99. self.route = replace(self.route, mail=OtpMailConfig("mailbox@example.test"))
  100. self.tty.return_value = False
  101. self.fetch = self.stack.enter_context(patch.object(workflow, "fetch_otp_from_cloud",
  102. return_value="001234"))
  103. self.utc = self.stack.enter_context(patch.object(workflow, "utc_sent_at",
  104. return_value="2026-08-31 01:02:03"))
  105. def test_automatic_preparation_without_tty_reuses_native_controls_and_readback(self):
  106. observed = []
  107. def fetch(mail, **kwargs):
  108. observed.extend(self.clicks)
  109. return "001234"
  110. self.fetch.side_effect = fetch
  111. output = StringIO()
  112. with redirect_stdout(output):
  113. workflow.prepare_calendar(self.plugin, self.route, role="book")
  114. self.assertEqual(observed, ["#otp-send"])
  115. self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"])
  116. self.fetch.assert_called_once_with(self.route.mail, recipient="fixture@example.test",
  117. sent_at="2026-08-31 01:02:03")
  118. self.page.ele("#otp-input").input.assert_called_once_with("001234", clear=True)
  119. self.reader.assert_not_called()
  120. self.assertNotIn("001234", output.getvalue() + str(self.plugin._log.call_args_list))
  121. self.plugin._record_calendar_prepared_route.assert_called_once_with(self.route, role="book")
  122. def test_send_timestamp_is_captured_before_native_send(self):
  123. def click(ele):
  124. if ele.selector == "#otp-send":
  125. self.utc.assert_called_once()
  126. self.clicks.append(ele.selector)
  127. self.plugin.mouse.human_click_ele = click
  128. workflow.prepare_calendar(self.plugin, self.route, role="book")
  129. def test_mail_failure_has_no_avanti_no_manual_fallback_no_same_session_resend(self):
  130. self.fetch.side_effect = preparation.CalendarGateError("Italy OTP mailbox read failed")
  131. with self.assertRaises(preparation.CalendarGateError):
  132. workflow.prepare_calendar(self.plugin, self.route, role="book")
  133. with self.assertRaises(PermissionDeniedError):
  134. workflow.prepare_calendar(self.plugin, self.route, role="book")
  135. self.assertEqual(self.clicks, ["#otp-send"])
  136. self.fetch.assert_called_once()
  137. self.reader.assert_not_called()
  138. def test_late_response_is_discarded_before_dom_write(self):
  139. with patch.object(workflow, "monotonic", side_effect=[0, 1, 300]):
  140. with self.assertRaisesRegex(preparation.CalendarGateError, "window expired"):
  141. workflow.prepare_calendar(self.plugin, self.route, role="book")
  142. self.assertEqual(self.clicks, ["#otp-send"])
  143. def test_expiration_during_preflight_prevents_avanti(self):
  144. with patch.object(workflow, "monotonic", side_effect=[0, 1, 2, 300]):
  145. with self.assertRaisesRegex(preparation.CalendarGateError, "window expired"):
  146. workflow.prepare_calendar(self.plugin, self.route, role="book")
  147. self.assertEqual(self.clicks, ["#otp-send", "#otp-input"])
  148. def test_account_change_during_read_discards_code(self):
  149. def changed(*args, **kwargs):
  150. self.plugin.config.account.username = "other@example.test"
  151. return "001234"
  152. self.fetch.side_effect = changed
  153. with self.assertRaises(preparation.CalendarGateError):
  154. workflow.prepare_calendar(self.plugin, self.route, role="book")
  155. self.assertEqual(self.clicks, ["#otp-send"])
  156. def test_cloud_dom_write_failure_stops_avanti(self):
  157. self.page.ele("#otp-input").input.side_effect = RuntimeError("private typed 001234")
  158. with self.assertRaisesRegex(preparation.CalendarGateError, "DOM write failed"):
  159. workflow.prepare_calendar(self.plugin, self.route, role="book")
  160. self.assertEqual(self.clicks, ["#otp-send", "#otp-input"])
  161. def test_wrong_cloud_role_or_invalid_final_flag(self):
  162. with self.assertRaises(PermissionDeniedError):
  163. workflow.prepare_calendar(self.plugin, self.route, role="query")
  164. self.plugin.free_config["final_submit_enabled"] = 1
  165. with self.assertRaises(PermissionDeniedError):
  166. workflow.prepare_calendar(self.plugin, self.route, role="book")
  167. self.listener.assert_not_called()
  168. self.fetch.assert_not_called()
  169. def test_missing_mail_stops_before_any_site_action(self):
  170. with self.assertRaises(preparation.CalendarGateError):
  171. workflow.prepare_calendar(self.plugin, replace(self.route, mail=None), role="book")
  172. self.listener.assert_not_called()
  173. self.page.run_js.assert_not_called()
  174. class CloudFinalPreparationTests(CloudPreparationTests):
  175. """Run the same OTP/session/expiry/privacy cases with final explicitly on."""
  176. def setUp(self):
  177. super().setUp()
  178. self.plugin.free_config["final_submit_enabled"] = True
  179. def test_preparation_does_not_itself_submit_final(self):
  180. with patch.object(workflow, "submit_final") as submit:
  181. workflow.prepare_calendar(self.plugin, self.route, role="book")
  182. submit.assert_not_called()
  183. self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"])
  184. class CloudQueryPreparationTests(TestCase):
  185. """Use the same preparation, mail adapter and fixtures as applicant Book."""
  186. listen = PreparationTests.listen
  187. def setUp(self):
  188. CloudPreparationTests.setUp(self)
  189. self.plugin.free_config.update(query_mode="calendar", final_submit_enabled=False)
  190. def prepare(self):
  191. workflow.prepare_calendar(self.plugin, self.route, role="query")
  192. def query_plugin(self, results):
  193. self.plugin.query = MethodType(ItaPlugin.query, self.plugin)
  194. self.plugin._prepared_calendar = None
  195. self.plugin._resolve_route = Mock(return_value=self.route)
  196. self.plugin._enter_service = Mock(return_value=results[0])
  197. self.plugin._query_once = Mock(side_effect=results[1:])
  198. self.plugin._reset_calendar_state = Mock()
  199. return self.plugin
  200. def test_public_query_prepares_once_with_shared_mail_adapter_and_no_terminal(self):
  201. strong = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available,
  202. earliest_date=datetime(2026, 10, 13))
  203. plugin = self.query_plugin([VSQueryResult(success=True), strong, strong])
  204. client = Mock()
  205. client.fetch_mail_content.return_value = "OTP Code:001234"
  206. self.fetch.side_effect = lambda *args, **kwargs: real_fetch_otp_from_cloud(
  207. *args, **kwargs, api=client)
  208. output = StringIO()
  209. with patch.object(workflow, "submit_final") as final, redirect_stdout(output):
  210. self.assertIs(plugin.query(Mock()), strong)
  211. self.assertIs(plugin.query(Mock()), strong)
  212. client.fetch_mail_content.assert_called_once_with(
  213. email=self.route.mail.authorization_email, sender="noreply-prenotami@esteri.it",
  214. recipient=plugin.config.account.username, subject_keywords="OTP Code",
  215. body_keywords="OTP Code:", sent_date="2026-08-31 01:02:03", expiry=300, only_text=True)
  216. client.fetch_mail_content_from_top.assert_not_called()
  217. plugin._enter_service.assert_called_once()
  218. self.assertEqual(plugin._query_once.call_count, 2)
  219. self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"])
  220. self.assertEqual(self.listener.call_count, 2)
  221. self.reader.assert_not_called()
  222. final.assert_not_called()
  223. self.plugin._record_calendar_prepared_route.assert_called_once_with(self.route, role="query")
  224. self.assertNotIn("001234", output.getvalue() + str(plugin._log.call_args_list))
  225. def test_account_mailbox_query_uses_the_new_pool_account_without_fixed_address(self):
  226. self.route = replace(self.route, mail=OtpMailConfig(authorization_source="account"))
  227. self.plugin.config.account.username = "new-pool-account@example.test"
  228. strong = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available,
  229. earliest_date=datetime(2026, 10, 13))
  230. plugin = self.query_plugin([VSQueryResult(success=True), strong, strong])
  231. client = Mock()
  232. client.fetch_mail_content.return_value = "OTP Code:001234"
  233. self.fetch.side_effect = lambda *args, **kwargs: real_fetch_otp_from_cloud(*args, **kwargs, api=client)
  234. with patch.object(workflow, "submit_final") as final, redirect_stdout(StringIO()):
  235. self.assertIs(plugin.query(Mock()), strong)
  236. self.assertIs(plugin.query(Mock()), strong)
  237. client.fetch_mail_content.assert_called_once()
  238. self.assertEqual(client.fetch_mail_content.call_args.kwargs["email"], "new-pool-account@example.test")
  239. self.assertEqual(client.fetch_mail_content.call_args.kwargs["recipient"], "new-pool-account@example.test")
  240. self.assertIsNone(self.route.mail.authorization_email)
  241. self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"])
  242. self.reader.assert_not_called()
  243. final.assert_not_called()
  244. def test_negative_entry_never_sends_otp_or_reads_mail(self):
  245. negative = VSQueryResult(success=False)
  246. plugin = self.query_plugin([negative])
  247. self.assertIs(plugin.query(Mock()), negative)
  248. self.page.run_js.assert_not_called()
  249. self.listener.assert_not_called()
  250. self.fetch.assert_not_called()
  251. self.reader.assert_not_called()
  252. def test_mail_failure_never_resends_or_falls_back_to_manual_in_same_session(self):
  253. self.fetch.side_effect = preparation.CalendarGateError("Italy OTP mailbox read failed")
  254. with redirect_stdout(StringIO()):
  255. with self.assertRaises(preparation.CalendarGateError):
  256. self.prepare()
  257. with self.assertRaises(PermissionDeniedError):
  258. self.prepare()
  259. self.fetch.assert_called_once()
  260. self.reader.assert_not_called()
  261. self.assertEqual(self.clicks, ["#otp-send"])
  262. self.plugin._record_calendar_prepared_route.assert_not_called()
  263. def test_expired_mail_is_not_written(self):
  264. with patch.object(workflow, "monotonic", side_effect=[0, 1, 300]), redirect_stdout(StringIO()):
  265. with self.assertRaisesRegex(preparation.CalendarGateError, "window expired"):
  266. self.prepare()
  267. self.assertEqual(self.clicks, ["#otp-send"])
  268. self.reader.assert_not_called()
  269. def test_account_change_during_mail_read_prevents_code_write(self):
  270. def changed(*args, **kwargs):
  271. self.plugin.config.account.username = "other@example.test"
  272. return "001234"
  273. self.fetch.side_effect = changed
  274. with redirect_stdout(StringIO()), self.assertRaises(preparation.CalendarGateError):
  275. self.prepare()
  276. self.assertEqual(self.clicks, ["#otp-send"])
  277. self.reader.assert_not_called()
  278. def test_ambiguous_mail_rejected_by_existing_parser_before_avanti(self):
  279. client = Mock()
  280. client.fetch_mail_content.return_value = "OTP Code:001234 OTP Code:654321"
  281. self.fetch.side_effect = lambda *args, **kwargs: real_fetch_otp_from_cloud(
  282. *args, **kwargs, api=client)
  283. with redirect_stdout(StringIO()), self.assertRaisesRegex(preparation.CalendarGateError, "mail rejected"):
  284. self.prepare()
  285. self.assertEqual(self.clicks, ["#otp-send"])
  286. self.reader.assert_not_called()
  287. client.fetch_mail_content_from_top.assert_not_called()
  288. def test_missing_mail_configuration_stops_before_site_actions(self):
  289. self.route = replace(self.route, mail=None)
  290. with self.assertRaisesRegex(preparation.CalendarGateError, "configuration is missing"):
  291. self.prepare()
  292. self.page.run_js.assert_not_called()
  293. self.listener.assert_not_called()
  294. self.fetch.assert_not_called()
  295. def test_query_cannot_enable_final_submission_or_use_book_preparation(self):
  296. for values, role in (({}, "book"), ({"final_submit_enabled": True}, "query")):
  297. with self.subTest(role=role):
  298. self.plugin.free_config.update(values)
  299. with self.assertRaises(PermissionDeniedError):
  300. workflow.prepare_calendar(self.plugin, self.route, role=role)
  301. self.page.run_js.assert_not_called()
  302. self.listener.assert_not_called()
  303. self.fetch.assert_not_called()
  304. class RecoveryWorkflowTests(TestCase):
  305. listen = PreparationTests.listen
  306. def setUp(self):
  307. PreparationTests.setUp(self)
  308. self.token_ready = False
  309. self.page.run_js.side_effect = lambda _: booking_preflight_snapshot(
  310. turnstileReady=self.token_ready, otpValuePresent=self.otp_present,
  311. otpSendEnabled=not self.otp_present)
  312. self.helper = Mock()
  313. self.helper.click_verification_button.return_value = False
  314. self.factory = self.stack.enter_context(patch.object(ita_turnstile, 'CloudflareBypasser',
  315. return_value=self.helper))
  316. self.stack.enter_context(patch.object(preparation.time, 'sleep'))
  317. def assert_preparation_recovers(self, role):
  318. def clicked(**kwargs):
  319. self.assertEqual(self.clicks, [])
  320. self.token_ready = True
  321. return True
  322. self.helper.click_verification_button.side_effect = clicked
  323. times = itertools.chain([0, 0, 5, 6], itertools.count(7))
  324. output = StringIO()
  325. with patch.object(preparation.time, 'monotonic', side_effect=lambda: next(times)), redirect_stdout(output):
  326. workflow.prepare_calendar(self.plugin, self.route, role=role)
  327. self.helper.click_verification_button.assert_called_once_with(is_dfs=False)
  328. self.assertEqual(self.clicks, ['#otp-send', '#otp-input', '#btnAvanti'])
  329. self.reader.assert_called_once()
  330. self.assertEqual(self.listener.call_count, 2)
  331. self.assertGreaterEqual(self.page.run_js.call_count, 3)
  332. self.assertNotIn('ITA_BOOK_PREFLIGHT_DIAGNOSTIC=', output.getvalue())
  333. self.factory.assert_called_once_with(self.page, log=False)
  334. self.helper.bypass.assert_not_called()
  335. def test_book_interaction_is_followed_by_real_readback_before_one_otp(self):
  336. self.assert_preparation_recovers('book')
  337. self.plugin._record_calendar_prepared_route.assert_called_once_with(self.route, role="book")
  338. def test_query_reuses_book_recovery_then_records_only_query_preparation(self):
  339. self.assert_preparation_recovers('query')
  340. self.plugin._record_calendar_prepared_route.assert_called_once_with(self.route, role="query")
  341. def test_query_three_clicks_without_token_cannot_release_otp(self):
  342. self.helper.click_verification_button.return_value = True
  343. with patch.object(preparation.time, 'monotonic', side_effect=[0, 0, 5, 15, 25, 35, 121]), \
  344. redirect_stdout(StringIO()), self.assertRaisesRegex(preparation.CalendarGateError, 'turnstile_token_pending'):
  345. workflow.prepare_calendar(self.plugin, self.route, role='query')
  346. self.assertEqual(self.helper.click_verification_button.call_count, 3)
  347. self.listener.assert_not_called()
  348. self.reader.assert_not_called()
  349. self.assertEqual(self.clicks, [])
  350. self.plugin._record_calendar_prepared_route.assert_not_called()
  351. def test_query_stages_share_one_recovery_budget(self):
  352. # The third click yields a real token. Expiry after sending OTP must not
  353. # create a fresh recovery budget or allow AVANTI without a new token.
  354. def clicked(**kwargs):
  355. if self.helper.click_verification_button.call_count == 3:
  356. self.token_ready = True
  357. return True
  358. self.helper.click_verification_button.side_effect = clicked
  359. def click(ele):
  360. self.clicks.append(ele.selector)
  361. if ele.selector == '#otp-send':
  362. self.token_ready = False
  363. self.plugin.mouse.human_click_ele = click
  364. ticks = [0, 0, 5, 15, 25, 26, 27, 27, 32, 42, 52, 148]
  365. with patch.object(preparation.time, 'monotonic', side_effect=ticks), \
  366. redirect_stdout(StringIO()), self.assertRaisesRegex(preparation.CalendarGateError, 'turnstile_token_pending'):
  367. workflow.prepare_calendar(self.plugin, self.route, role='query')
  368. self.factory.assert_called_once_with(self.page, log=False)
  369. self.assertEqual(self.helper.click_verification_button.call_count, 3)
  370. self.assertEqual(self.clicks, ['#otp-send', '#otp-input'])
  371. self.assertEqual(self.listener.call_count, 1)
  372. self.plugin._record_calendar_prepared_route.assert_not_called()
  373. def test_query_ready_widget_does_not_invoke_helper(self):
  374. self.token_ready = True
  375. with redirect_stdout(StringIO()):
  376. workflow.prepare_calendar(self.plugin, self.route, role='query')
  377. self.factory.assert_not_called()
  378. self.assertEqual(self.clicks, ['#otp-send', '#otp-input', '#btnAvanti'])
  379. def test_prepared_query_skips_recovery_and_all_preparation_actions(self):
  380. self.page.url = 'https://prenotami.esteri.it/BookingCalendar'
  381. with patch.object(workflow, 'turnstile_recovery') as recovery:
  382. self.assertIsNone(workflow.prepare_query_if_needed(self.plugin, Mock()))
  383. recovery.assert_not_called()
  384. self.factory.assert_not_called()
  385. self.listener.assert_not_called()
  386. self.page.run_js.assert_not_called()
  387. def test_book_timeout_stops_before_otp(self):
  388. output = StringIO()
  389. with patch.object(preparation.time, 'monotonic', side_effect=[0, 0, 5, 121]), \
  390. redirect_stdout(output), self.assertRaisesRegex(preparation.CalendarGateError, 'turnstile_token_pending'):
  391. workflow.prepare_calendar(self.plugin, self.route, role='book')
  392. self.listener.assert_not_called()
  393. self.reader.assert_not_called()
  394. self.assertEqual(self.clicks, [])
  395. self.assertIn('ITA_BOOK_WAITING_FOR_FORM:', output.getvalue())
  396. self.assertNotIn('ITA_BOOK_PREFLIGHT_DIAGNOSTIC=', output.getvalue())
  397. self.helper.bypass.assert_not_called()
  398. def test_cloud_book_timeout_never_calls_mail_api(self):
  399. self.plugin.free_config['otp_mode'] = 'cloud'
  400. self.route = replace(self.route, mail=OtpMailConfig('mailbox@example.test'))
  401. with patch.object(preparation.time, 'monotonic', side_effect=[0, 0, 5, 121]), \
  402. patch.object(workflow, 'fetch_otp_from_cloud') as fetch, \
  403. redirect_stdout(StringIO()), self.assertRaises(preparation.CalendarGateError):
  404. workflow.prepare_calendar(self.plugin, self.route, role='book')
  405. fetch.assert_not_called()
  406. self.listener.assert_not_called()
  407. self.reader.assert_not_called()
  408. class ProductionEntryTests(TestCase):
  409. def setUp(self):
  410. self.plugin, self.route, self.trigger = flow.prepared_plugin(flow.FlowPage())
  411. self.plugin.free_config["otp_mode"] = "manual"
  412. self.inputs = {"username": self.plugin.config.account.username}
  413. self.plugin.is_healthy = True
  414. self.plugin._log = Mock()
  415. def test_prepared_book_reuses_real_calendar_adapter_and_defaults_to_prefinal(self):
  416. with patch.object(workflow, "submit_final") as submit, patch.object(workflow, "prepare_calendar") as prepare:
  417. result = self.plugin.book(self.trigger, self.inputs)
  418. self.assertFalse(result.success)
  419. self.assertEqual(result.label, "calendar-ready-before-final")
  420. self.assertEqual(self.plugin.page.clicks, 1)
  421. self.assertEqual(self.plugin.page.guard_final_count, 0)
  422. submit.assert_not_called()
  423. prepare.assert_not_called()
  424. def test_cloud_book_reuses_selection_without_enabling_final(self):
  425. self.plugin.free_config["otp_mode"] = "cloud"
  426. with patch.object(workflow, "submit_final") as submit:
  427. result = self.plugin.book(self.trigger, self.inputs)
  428. self.assertEqual(result.label, "calendar-ready-before-final")
  429. self.assertEqual(self.plugin.page.clicks, 1)
  430. self.assertFalse(result.success)
  431. submit.assert_not_called()
  432. def test_cloud_final_uses_the_existing_submitter_after_fresh_selection(self):
  433. self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True)
  434. confirmed = VSBookResult(success=True, book_date="2026-10-13", book_time="09:26")
  435. with patch.object(workflow, "submit_final", return_value=confirmed) as submit:
  436. result = self.plugin.book(self.trigger, self.inputs)
  437. self.assertIs(result, confirmed)
  438. self.assertIs(submit.call_args.args[0], self.plugin)
  439. self.assertEqual(submit.call_args.args[1], self.route)
  440. self.assertIsNotNone(submit.call_args.args[2])
  441. def test_invalid_final_flag_is_rejected_before_site_actions(self):
  442. self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled="true")
  443. with patch.object(workflow, "submit_final") as submit, \
  444. patch.object(workflow, "prepare_calendar") as prepare, self.assertRaises(PermissionDeniedError):
  445. self.plugin.book(self.trigger, self.inputs)
  446. submit.assert_not_called()
  447. prepare.assert_not_called()
  448. def test_cloud_final_no_inventory_never_submits(self):
  449. self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True)
  450. self.plugin.page = flow.FlowPage([flow.month(m, {}) for m in ("2026-10", "2026-11", "2026-12")])
  451. self.plugin._record_calendar_prepared_route(self.route, role="book")
  452. with patch.object(workflow, "submit_final") as submit, flow.browser_navigation(self.plugin.page):
  453. result = self.plugin.book(self.trigger, self.inputs)
  454. self.assertFalse(result.success)
  455. submit.assert_not_called()
  456. def test_enabled_book_returns_standard_result_after_real_slot_selection(self):
  457. self.plugin.free_config["final_submit_enabled"] = True
  458. confirmed = VSBookResult(success=True, book_date="2026-10-13", book_time="09:26")
  459. with patch.object(workflow, "submit_final", return_value=confirmed) as submit:
  460. result = self.plugin.book(self.trigger, self.inputs)
  461. self.assertIs(result, confirmed)
  462. self.assertIs(submit.call_args.args[0], self.plugin)
  463. self.assertEqual(submit.call_args.args[1], self.route)
  464. self.assertIsNotNone(submit.call_args.args[2])
  465. def test_one_public_book_call_prepares_and_selects_from_dashboard(self):
  466. plugin = self.plugin
  467. plugin.page.url = "https://prenotami.esteri.it/UserArea"
  468. plugin._prepared_calendar = None
  469. def entry(apt, **kwargs):
  470. plugin.page.url = "https://prenotami.esteri.it" + plugin._booking_path(self.route)
  471. return VSQueryResult(success=True)
  472. plugin._enter_service = Mock(side_effect=entry)
  473. def prepare(p, route, *, role):
  474. self.assertEqual(role, "book")
  475. p.page.url = "https://prenotami.esteri.it/BookingCalendar"
  476. p._record_calendar_prepared_route(route, role="book")
  477. with patch.object(workflow, "prepare_calendar", side_effect=prepare) as prep:
  478. result = plugin.book(self.trigger, self.inputs)
  479. prep.assert_called_once()
  480. plugin._enter_service.assert_called_once_with(self.trigger.apt_type, route=self.route)
  481. plugin.query.assert_not_called()
  482. self.assertEqual(result.label, "calendar-ready-before-final")
  483. self.assertEqual(plugin.page.clicks, 1)
  484. def test_final_config_requires_explicit_supported_applicant_mode(self):
  485. for values, accepted in (({}, True), ({"otp_mode": "manual"}, True),
  486. ({"otp_mode": "cloud"}, True),
  487. ({"otp_mode": "cloud", "final_submit_enabled": True}, True),
  488. ({"otp_mode": "cloud", "query_mode": "calendar"}, True),
  489. ({"otp_mode": "cloud", "query_mode": "calendar", "final_submit_enabled": True}, False),
  490. ({"otp_mode": "cloud", "final_submit_enabled": "true"}, False),
  491. ({"otp_mode": "cloud", "final_submit_enabled": 1}, False),
  492. ({"otp_mode": "manual", "final_submit_enabled": True}, True),
  493. ({"final_submit_enabled": True}, False),
  494. ({"otp_mode": "manual", "final_submit_enabled": 1}, False),
  495. ({"otp_mode": "manual", "final_submit_enabled": True, "query_mode": "calendar"}, False)):
  496. with self.subTest(values=values):
  497. config = VSPlgConfig(free_config=values)
  498. if accepted:
  499. self.plugin.set_config(config)
  500. else:
  501. with self.assertRaises(BizLogicError):
  502. self.plugin.set_config(config)
  503. def test_no_inventory_never_calls_final(self):
  504. self.plugin.page = flow.FlowPage([flow.month(m, {}) for m in ("2026-10", "2026-11", "2026-12")])
  505. self.plugin._record_calendar_prepared_route(self.route, role="book")
  506. with patch.object(workflow, "submit_final") as submit, flow.browser_navigation(self.plugin.page):
  507. result = self.plugin.book(self.trigger, self.inputs)
  508. self.assertFalse(result.success)
  509. submit.assert_not_called()
  510. def test_query_or_another_applicant_cannot_book(self):
  511. context = self.plugin._prepared_calendar
  512. for query_key, username in ((self.route.routing_key, self.inputs["username"]), (None, "other@example.test")):
  513. self.plugin._prepared_calendar = replace(context, role="query" if query_key else "book")
  514. with self.assertRaises(BizLogicError), patch.object(workflow, "submit_final") as submit:
  515. self.plugin.book(self.trigger, {"username": username})
  516. submit.assert_not_called()
  517. def test_cloud_final_rejects_query_session_and_other_applicant(self):
  518. self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True)
  519. context = self.plugin._prepared_calendar
  520. for query_key, username in ((self.route.routing_key, self.inputs["username"]), (None, "other@example.test")):
  521. self.plugin._prepared_calendar = replace(context, role="query" if query_key else "book")
  522. with patch.object(workflow, "submit_final") as submit, self.assertRaises(BizLogicError):
  523. self.plugin.book(self.trigger, {"username": username})
  524. submit.assert_not_called()
  525. def test_query_from_dashboard_prepares_once_and_never_returns_weak_positive(self):
  526. plugin = self.plugin
  527. plugin.query = MethodType(ItaPlugin.query, plugin)
  528. plugin.free_config["query_mode"] = "calendar"
  529. plugin.page.url = "https://prenotami.esteri.it/UserArea"
  530. plugin._prepared_calendar = None
  531. strong = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available,
  532. earliest_date=datetime(2026, 10, 13), apt_type=self.trigger.apt_type)
  533. plugin._enter_service = Mock(return_value=VSQueryResult(success=True))
  534. plugin._query_once = Mock(return_value=strong)
  535. def prepare(p, route, *, role):
  536. self.assertEqual(role, "query")
  537. p.page.url = "https://prenotami.esteri.it/BookingCalendar"
  538. with patch.object(workflow, "prepare_calendar", side_effect=prepare) as prep:
  539. self.assertIs(plugin.query(self.trigger.apt_type), strong)
  540. self.assertIs(plugin.query(self.trigger.apt_type), strong)
  541. self.assertEqual(prep.call_count, 1)
  542. plugin._enter_service.assert_called_once()
  543. self.assertEqual(plugin._query_once.call_count, 2)
  544. def test_entry_no_availability_does_not_send_otp(self):
  545. self.plugin.page.url = "https://prenotami.esteri.it/UserArea"
  546. negative = VSQueryResult(success=False)
  547. self.plugin._enter_service = Mock(return_value=negative)
  548. with patch.object(workflow, "prepare_calendar") as prep:
  549. self.assertIs(workflow.prepare_query_if_needed(self.plugin, self.trigger.apt_type), negative)
  550. prep.assert_not_called()
  551. def test_production_modules_never_import_debug_tools(self):
  552. root = Path(__file__).resolve().parents[2]
  553. for filename in ("ita_plugin.py",):
  554. tree = ast.parse((root / "plugins" / filename).read_text())
  555. imports = [n.module for n in ast.walk(tree) if isinstance(n, ast.ImportFrom)]
  556. self.assertFalse(any(name and name.startswith("tools") for name in imports))
  557. class BookerReuseTests(TestCase):
  558. def setUp(self):
  559. # Reuse existing offline Redis import fixture; never open Redis/cloud.
  560. from test.ita.test_ita_plugin import OrderBookerGCO
  561. from threading import RLock
  562. self.booker = OrderBookerGCO.__new__(OrderBookerGCO)
  563. self.booker.m_lock = RLock()
  564. self.booker.m_task_data_cache = {"fixture": {"status": "running", "order_id": "order", "user_inputs": {}}}
  565. self.booker._log = Mock()
  566. self.booker._remove_task = Mock()
  567. self.booker._push_success_notification = Mock()
  568. self.booker.redis_client = Mock()
  569. self.booker.m_tracker_key = "fixture"
  570. self.task = SimpleNamespace(task_ref="fixture", book_allowed=True, instance=Mock())
  571. self.api = Mock()
  572. api_patch = patch.dict(self.booker._execute_book_job.__func__.__globals__, VSCloudApi=self.api)
  573. api_patch.start()
  574. self.addCleanup(api_patch.stop)
  575. def test_standard_success_still_uses_existing_reporting(self):
  576. result = VSBookResult(success=True, book_date="2026-10-13", book_time="09:26")
  577. self.task.instance.book.return_value = result
  578. self.booker._execute_book_job(self.task, VSQueryResult())
  579. self.booker._push_success_notification.assert_called_once_with("fixture", "order", result)
  580. def test_standard_failure_is_called_again_on_the_next_signal(self):
  581. self.task.instance.book.return_value = VSBookResult(success=False)
  582. self.booker._execute_book_job(self.task, VSQueryResult())
  583. self.booker._execute_book_job(self.task, VSQueryResult())
  584. self.api.Instance.return_value.update_vas_task.assert_not_called()
  585. self.assertTrue(self.task.book_allowed)
  586. self.assertEqual(self.task.instance.book.call_count, 2)
  587. self.booker._push_success_notification.assert_not_called()
  588. class QueryCliTests(TestCase):
  589. def test_workflow_flag_reuses_route_builder_and_calls_standard_query(self):
  590. from tools import debug_ita_query as cli
  591. from test.ita.test_debug_ita_calendar_gate import gate_env
  592. plugin = Mock()
  593. plugin.query.return_value = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available,
  594. earliest_date=datetime(2026, 10, 13))
  595. stdout = StringIO()
  596. with patch.object(cli, "ItaPlugin", return_value=plugin), \
  597. patch.object(cli, "resolve_chrome_path", return_value=Path("/offline/chrome")), \
  598. patch.object(cli, "_get_query_credentials", return_value=("query@example.test", "fixture")), \
  599. patch.object(cli, "_prepare_query_profile", return_value=Path("/offline/profile")), \
  600. patch.object(cli, "_bind_query_profile", return_value=Mock()), \
  601. redirect_stdout(stdout):
  602. code = cli.run_query_once(gate_env(), non_interactive=False, production_workflow=True)
  603. self.assertEqual(code, 0)
  604. config = plugin.set_config.call_args.args[0]
  605. self.assertEqual(config.free_config["query_mode"], "calendar")
  606. self.assertEqual(config.free_config["otp_mode"], "manual")
  607. self.assertIs(config.free_config["final_submit_enabled"], False)
  608. plugin.query.assert_called_once()
  609. plugin.book.assert_not_called()
  610. plugin.cleanup.assert_called_once()
  611. self.assertIn("ITA_QUERY_WORKFLOW_RESULT=", stdout.getvalue())
  612. def test_headless_workflow_rejected_before_credentials(self):
  613. from tools import debug_ita_query as cli
  614. with patch.object(cli, "_get_query_credentials") as credentials:
  615. with self.assertRaises(cli.DebugConfigurationError):
  616. cli.run_query_once({}, non_interactive=True, production_workflow=True)
  617. credentials.assert_not_called()