test_ita_workflow.py 50 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930
  1. """Offline production-entry tests: no credentials, site calls, or cloud writes."""
  2. import ast
  3. import logging
  4. import itertools
  5. from dataclasses import replace
  6. from contextlib import ExitStack
  7. from datetime import datetime
  8. from pathlib import Path
  9. from io import StringIO
  10. from contextlib import redirect_stdout
  11. from types import MethodType, SimpleNamespace
  12. from unittest import TestCase
  13. from unittest.mock import Mock, patch
  14. from plugins import ita_plugin as workflow
  15. from plugins import ita_plugin as preparation
  16. from plugins.ita_plugin import FinalOutcomeUnknown, SubmissionSignal, VerifiedSubmission
  17. from plugins.ita_plugin import ItaPlugin
  18. from plugins import ita_plugin as ita_otp
  19. from plugins.ita_plugin import fetch_otp_from_cloud as real_fetch_otp_from_cloud
  20. from plugins import ita_plugin as ita_turnstile
  21. from plugins.ita_plugin import OtpMailConfig
  22. from test import test_ita_calendar_book_flow as flow
  23. from test.test_debug_ita_calendar_gate import booking_preflight_snapshot
  24. from test import test_ita_final_attribution as attribution
  25. from vs_types import AvailabilityStatus, BizLogicError, PermissionDeniedError, VSBookResult, VSPlgConfig, VSQueryResult
  26. class PreparationTests(TestCase):
  27. def setUp(self):
  28. _, self.route, _ = flow.prepared_plugin(flow.FlowPage())
  29. self.path = f"/Services/Booking/{self.route.service_id}"
  30. self.page = SimpleNamespace(url="https://prenotami.esteri.it" + self.path,
  31. tab_id="fixture-tab", wait=Mock(), set=Mock())
  32. self.otp_present = False
  33. self.clicks = []
  34. self.page.run_js = Mock(side_effect=lambda _: booking_preflight_snapshot(
  35. otpValuePresent=self.otp_present, otpDisabled=self.otp_present))
  36. otp_input = Mock()
  37. otp_input.input.side_effect = lambda *a, **k: setattr(self, "otp_present", True)
  38. otp_input.run_js.return_value = True
  39. otp_input.selector = "#otp-input"
  40. controls = {"#otp-input": otp_input, "#otp-send": SimpleNamespace(selector="#otp-send"),
  41. "#btnAvanti": SimpleNamespace(selector="#btnAvanti")}
  42. self.page.ele = Mock(side_effect=lambda selector, **kwargs: controls[selector])
  43. self.plugin = SimpleNamespace(
  44. page=self.page, session_create_time=1, free_config={"otp_mode": "manual"},
  45. config=SimpleNamespace(account=SimpleNamespace(username="fixture@example.test")),
  46. mouse=SimpleNamespace(human_click_ele=lambda ele: self.clicks.append(ele.selector)),
  47. _booking_path=lambda route: self.path, _log=Mock(),
  48. _record_calendar_query_prepared_route=Mock(), _record_calendar_book_prepared_route=Mock(),
  49. )
  50. self.plugin._book_final_configuration_valid = MethodType(ItaPlugin._book_final_configuration_valid, self.plugin)
  51. self.stack = ExitStack()
  52. self.addCleanup(self.stack.close)
  53. self.tty = self.stack.enter_context(patch.object(workflow.sys.stdin, "isatty", return_value=True))
  54. self.reader = self.stack.enter_context(patch.object(preparation, "_read_manual_otp", return_value="123456"))
  55. self.listener = self.stack.enter_context(patch.object(workflow, "listen_once", side_effect=self.listen))
  56. self.stack.enter_context(patch.object(workflow, "guard_calendar"))
  57. self.stack.enter_context(patch.object(workflow, "wait_for_calendar_service", return_value="9001"))
  58. def listen(self, page, *, target, method, timeout, action):
  59. action()
  60. if target == self.path:
  61. page.url = "https://prenotami.esteri.it/BookingCalendar?selectedService=Example"
  62. return SimpleNamespace(tab_id=page.tab_id, is_failed=False, method=method,
  63. url="https://prenotami.esteri.it" + target + ("?ServiceID=9001" if method == "GET" else ""),
  64. response=SimpleNamespace(status=200, raw_body='"SENT"', url=page.url))
  65. def test_native_preparation_sends_once_writes_once_and_records_query_role(self):
  66. workflow.prepare_calendar(self.plugin, self.route, role="query")
  67. self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"])
  68. self.assertEqual(self.listener.call_count, 2)
  69. self.reader.assert_called_once()
  70. self.plugin._record_calendar_query_prepared_route.assert_called_once_with(self.route)
  71. self.plugin._record_calendar_book_prepared_route.assert_not_called()
  72. self.assertEqual(self.page.run_js.call_count, 2)
  73. self.assertIn("form-boundary", self.page.run_js.call_args.args[0])
  74. def test_book_role_does_not_mark_query_prepared(self):
  75. workflow.prepare_calendar(self.plugin, self.route, role="book")
  76. self.plugin._record_calendar_book_prepared_route.assert_called_once_with(self.route)
  77. self.plugin._record_calendar_query_prepared_route.assert_not_called()
  78. def test_no_terminal_stops_before_otp_or_form_changes(self):
  79. self.tty.return_value = False
  80. with self.assertRaises(PermissionDeniedError):
  81. workflow.prepare_calendar(self.plugin, self.route, role="query")
  82. self.listener.assert_not_called()
  83. self.page.run_js.assert_not_called()
  84. def test_wrong_otp_readback_prevents_avanti_and_repeated_otp(self):
  85. self.page.ele("#otp-input").run_js.return_value = False
  86. with self.assertRaisesRegex(preparation.CalendarGateError, "verification failed"):
  87. workflow.prepare_calendar(self.plugin, self.route, role="book")
  88. with self.assertRaises(PermissionDeniedError):
  89. workflow.prepare_calendar(self.plugin, self.route, role="book")
  90. self.assertEqual(self.clicks, ["#otp-send", "#otp-input"])
  91. self.assertEqual(self.listener.call_count, 1)
  92. def test_wrong_tab_response_never_reads_otp_or_submits_form(self):
  93. self.listener.side_effect = None
  94. self.listener.return_value = SimpleNamespace(tab_id="foreign", is_failed=False)
  95. with self.assertRaises(preparation.CalendarGateError):
  96. workflow.prepare_calendar(self.plugin, self.route, role="query")
  97. self.reader.assert_not_called()
  98. self.plugin._record_calendar_query_prepared_route.assert_not_called()
  99. class CloudPreparationTests(TestCase):
  100. """Reuse the manual site's fixture, replacing only the OTP provider."""
  101. listen = PreparationTests.listen
  102. def setUp(self):
  103. PreparationTests.setUp(self)
  104. self.plugin.free_config["otp_mode"] = "cloud"
  105. self.route = replace(self.route, mail=OtpMailConfig("mailbox@example.test"))
  106. self.tty.return_value = False
  107. self.stack.enter_context(patch.object(ita_otp.vs_log_macros, "_active_logger",
  108. logging.Logger("offline-otp", logging.INFO)))
  109. self.fetch = self.stack.enter_context(patch.object(workflow, "fetch_otp_from_cloud",
  110. return_value="001234"))
  111. self.utc = self.stack.enter_context(patch.object(workflow, "utc_sent_at",
  112. return_value="2026-08-31 01:02:03"))
  113. def test_automatic_preparation_without_tty_reuses_native_controls_and_readback(self):
  114. observed = []
  115. def fetch(mail, **kwargs):
  116. observed.extend(self.clicks)
  117. return "001234"
  118. self.fetch.side_effect = fetch
  119. output = StringIO()
  120. with redirect_stdout(output):
  121. workflow.prepare_calendar(self.plugin, self.route, role="book")
  122. self.assertEqual(observed, ["#otp-send"])
  123. self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"])
  124. self.fetch.assert_called_once_with(self.route.mail, recipient="fixture@example.test",
  125. sent_at="2026-08-31 01:02:03")
  126. self.page.ele("#otp-input").input.assert_called_once_with("001234", clear=True)
  127. self.reader.assert_not_called()
  128. self.assertNotIn("001234", output.getvalue() + str(self.plugin._log.call_args_list))
  129. self.plugin._record_calendar_book_prepared_route.assert_called_once_with(self.route)
  130. self.plugin._record_calendar_query_prepared_route.assert_not_called()
  131. def test_send_timestamp_is_captured_before_native_send(self):
  132. def click(ele):
  133. if ele.selector == "#otp-send":
  134. self.utc.assert_called_once()
  135. self.clicks.append(ele.selector)
  136. self.plugin.mouse.human_click_ele = click
  137. workflow.prepare_calendar(self.plugin, self.route, role="book")
  138. def test_mail_failure_has_no_avanti_no_manual_fallback_no_same_session_resend(self):
  139. self.fetch.side_effect = preparation.CalendarGateError("Italy OTP mailbox read failed")
  140. with self.assertRaises(preparation.CalendarGateError):
  141. workflow.prepare_calendar(self.plugin, self.route, role="book")
  142. with self.assertRaises(PermissionDeniedError):
  143. workflow.prepare_calendar(self.plugin, self.route, role="book")
  144. self.assertEqual(self.clicks, ["#otp-send"])
  145. self.fetch.assert_called_once()
  146. self.reader.assert_not_called()
  147. def test_late_response_is_discarded_before_dom_write(self):
  148. with patch.object(workflow, "monotonic", side_effect=[0, 1, 300]):
  149. with self.assertRaisesRegex(preparation.CalendarGateError, "window expired"):
  150. workflow.prepare_calendar(self.plugin, self.route, role="book")
  151. self.assertEqual(self.clicks, ["#otp-send"])
  152. def test_expiration_during_preflight_prevents_avanti(self):
  153. with patch.object(workflow, "monotonic", side_effect=[0, 1, 2, 300]):
  154. with self.assertRaisesRegex(preparation.CalendarGateError, "window expired"):
  155. workflow.prepare_calendar(self.plugin, self.route, role="book")
  156. self.assertEqual(self.clicks, ["#otp-send", "#otp-input"])
  157. def test_account_change_during_read_discards_code(self):
  158. def changed(*args, **kwargs):
  159. self.plugin.config.account.username = "other@example.test"
  160. return "001234"
  161. self.fetch.side_effect = changed
  162. with self.assertRaises(preparation.CalendarGateError):
  163. workflow.prepare_calendar(self.plugin, self.route, role="book")
  164. self.assertEqual(self.clicks, ["#otp-send"])
  165. def test_cloud_dom_write_failure_is_redacted_and_stops_avanti(self):
  166. self.page.ele("#otp-input").input.side_effect = RuntimeError("private typed 001234")
  167. with self.assertRaisesRegex(preparation.CalendarGateError, "DOM write verification failed") as caught:
  168. workflow.prepare_calendar(self.plugin, self.route, role="book")
  169. self.assertNotIn("001234", str(caught.exception))
  170. self.assertEqual(self.clicks, ["#otp-send", "#otp-input"])
  171. def test_wrong_cloud_role_or_invalid_final_flag(self):
  172. with self.assertRaises(PermissionDeniedError):
  173. workflow.prepare_calendar(self.plugin, self.route, role="query")
  174. self.plugin.free_config["final_submit_enabled"] = 1
  175. with self.assertRaises(PermissionDeniedError):
  176. workflow.prepare_calendar(self.plugin, self.route, role="book")
  177. self.listener.assert_not_called()
  178. self.fetch.assert_not_called()
  179. def test_missing_mail_and_debug_logger_stop_before_any_site_action(self):
  180. with self.assertRaises(preparation.CalendarGateError):
  181. workflow.prepare_calendar(self.plugin, replace(self.route, mail=None), role="book")
  182. ita_otp.vs_log_macros._active_logger.setLevel(logging.DEBUG)
  183. with self.assertRaises(preparation.CalendarGateError):
  184. workflow.prepare_calendar(self.plugin, self.route, role="book")
  185. self.listener.assert_not_called()
  186. self.page.run_js.assert_not_called()
  187. class CloudFinalPreparationTests(CloudPreparationTests):
  188. """Run the same OTP/session/expiry/privacy cases with final explicitly on."""
  189. def setUp(self):
  190. super().setUp()
  191. self.plugin.free_config["final_submit_enabled"] = True
  192. def test_preparation_does_not_itself_submit_final(self):
  193. with patch.object(workflow, "submit_final") as submit:
  194. workflow.prepare_calendar(self.plugin, self.route, role="book")
  195. submit.assert_not_called()
  196. self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"])
  197. class CloudQueryPreparationTests(TestCase):
  198. """Use the same preparation, mail adapter and fixtures as applicant Book."""
  199. listen = PreparationTests.listen
  200. def setUp(self):
  201. CloudPreparationTests.setUp(self)
  202. self.plugin.free_config.update(query_mode="calendar", final_submit_enabled=False)
  203. def prepare(self):
  204. workflow.prepare_calendar(self.plugin, self.route, role="query")
  205. def query_plugin(self, results):
  206. self.plugin.query = MethodType(ItaPlugin.query, self.plugin)
  207. self.plugin._resolve_route = Mock(return_value=self.route)
  208. self.plugin._query_once = Mock(side_effect=results)
  209. self.plugin._clear_calendar_query_state = Mock()
  210. return self.plugin
  211. def test_public_query_prepares_once_with_shared_mail_adapter_and_no_terminal(self):
  212. strong = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available,
  213. earliest_date=datetime(2026, 10, 13))
  214. plugin = self.query_plugin([VSQueryResult(success=True), strong, strong])
  215. client = Mock()
  216. client.fetch_mail_content.return_value = "OTP Code:001234"
  217. self.fetch.side_effect = lambda *args, **kwargs: real_fetch_otp_from_cloud(
  218. *args, **kwargs, api=client)
  219. output = StringIO()
  220. with patch.object(workflow, "submit_final") as final, redirect_stdout(output):
  221. self.assertIs(plugin.query(Mock()), strong)
  222. self.assertIs(plugin.query(Mock()), strong)
  223. client.fetch_mail_content.assert_called_once_with(
  224. email=self.route.mail.authorization_email, sender="noreply-prenotami@esteri.it",
  225. recipient=plugin.config.account.username, subject_keywords="OTP Code",
  226. body_keywords="OTP Code:", sent_date="2026-08-31 01:02:03", expiry=300, only_text=True)
  227. client.fetch_mail_content_from_top.assert_not_called()
  228. self.assertEqual(plugin._query_once.call_count, 3)
  229. self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"])
  230. self.assertEqual(self.listener.call_count, 2)
  231. self.reader.assert_not_called()
  232. final.assert_not_called()
  233. self.plugin._record_calendar_query_prepared_route.assert_called_once_with(self.route)
  234. self.plugin._record_calendar_book_prepared_route.assert_not_called()
  235. self.assertNotIn("001234", output.getvalue() + str(plugin._log.call_args_list))
  236. def test_account_mailbox_query_uses_the_new_pool_account_without_fixed_address(self):
  237. self.route = replace(self.route, mail=OtpMailConfig(authorization_source="account"))
  238. self.plugin.config.account.username = "new-pool-account@example.test"
  239. strong = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available,
  240. earliest_date=datetime(2026, 10, 13))
  241. plugin = self.query_plugin([VSQueryResult(success=True), strong, strong])
  242. client = Mock()
  243. client.fetch_mail_content.return_value = "OTP Code:001234"
  244. self.fetch.side_effect = lambda *args, **kwargs: real_fetch_otp_from_cloud(*args, **kwargs, api=client)
  245. with patch.object(workflow, "submit_final") as final, redirect_stdout(StringIO()):
  246. self.assertIs(plugin.query(Mock()), strong)
  247. self.assertIs(plugin.query(Mock()), strong)
  248. client.fetch_mail_content.assert_called_once()
  249. self.assertEqual(client.fetch_mail_content.call_args.kwargs["email"], "new-pool-account@example.test")
  250. self.assertEqual(client.fetch_mail_content.call_args.kwargs["recipient"], "new-pool-account@example.test")
  251. self.assertIsNone(self.route.mail.authorization_email)
  252. self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"])
  253. self.reader.assert_not_called()
  254. final.assert_not_called()
  255. def test_negative_entry_never_sends_otp_or_reads_mail(self):
  256. negative = VSQueryResult(success=False)
  257. plugin = self.query_plugin([negative])
  258. self.assertIs(plugin.query(Mock()), negative)
  259. self.page.run_js.assert_not_called()
  260. self.listener.assert_not_called()
  261. self.fetch.assert_not_called()
  262. self.reader.assert_not_called()
  263. def test_mail_failure_never_resends_or_falls_back_to_manual_in_same_session(self):
  264. self.fetch.side_effect = preparation.CalendarGateError("Italy OTP mailbox read failed")
  265. with redirect_stdout(StringIO()):
  266. with self.assertRaises(preparation.CalendarGateError):
  267. self.prepare()
  268. with self.assertRaises(PermissionDeniedError):
  269. self.prepare()
  270. self.fetch.assert_called_once()
  271. self.reader.assert_not_called()
  272. self.assertEqual(self.clicks, ["#otp-send"])
  273. self.plugin._record_calendar_query_prepared_route.assert_not_called()
  274. def test_expired_mail_is_not_written(self):
  275. with patch.object(workflow, "monotonic", side_effect=[0, 1, 300]), redirect_stdout(StringIO()):
  276. with self.assertRaisesRegex(preparation.CalendarGateError, "window expired"):
  277. self.prepare()
  278. self.assertEqual(self.clicks, ["#otp-send"])
  279. self.reader.assert_not_called()
  280. def test_account_change_during_mail_read_prevents_code_write(self):
  281. def changed(*args, **kwargs):
  282. self.plugin.config.account.username = "other@example.test"
  283. return "001234"
  284. self.fetch.side_effect = changed
  285. with redirect_stdout(StringIO()), self.assertRaises(preparation.CalendarGateError):
  286. self.prepare()
  287. self.assertEqual(self.clicks, ["#otp-send"])
  288. self.reader.assert_not_called()
  289. def test_ambiguous_mail_rejected_by_existing_parser_before_avanti(self):
  290. client = Mock()
  291. client.fetch_mail_content.return_value = "OTP Code:001234 OTP Code:654321"
  292. self.fetch.side_effect = lambda *args, **kwargs: real_fetch_otp_from_cloud(
  293. *args, **kwargs, api=client)
  294. with redirect_stdout(StringIO()), self.assertRaisesRegex(preparation.CalendarGateError, "mail rejected"):
  295. self.prepare()
  296. self.assertEqual(self.clicks, ["#otp-send"])
  297. self.reader.assert_not_called()
  298. client.fetch_mail_content_from_top.assert_not_called()
  299. def test_missing_mail_configuration_stops_before_site_actions(self):
  300. self.route = replace(self.route, mail=None)
  301. with self.assertRaisesRegex(preparation.CalendarGateError, "configuration is missing"):
  302. self.prepare()
  303. self.page.run_js.assert_not_called()
  304. self.listener.assert_not_called()
  305. self.fetch.assert_not_called()
  306. def test_query_cannot_enable_final_submission_or_use_book_preparation(self):
  307. for values, role in (({}, "book"), ({"final_submit_enabled": True}, "query")):
  308. with self.subTest(role=role):
  309. self.plugin.free_config.update(values)
  310. with self.assertRaises(PermissionDeniedError):
  311. workflow.prepare_calendar(self.plugin, self.route, role=role)
  312. self.page.run_js.assert_not_called()
  313. self.listener.assert_not_called()
  314. self.fetch.assert_not_called()
  315. class RecoveryWorkflowTests(TestCase):
  316. listen = PreparationTests.listen
  317. def setUp(self):
  318. PreparationTests.setUp(self)
  319. self.token_ready = False
  320. self.page.run_js.side_effect = lambda _: booking_preflight_snapshot(
  321. turnstileTokenPresent=self.token_ready,
  322. otpValuePresent=self.otp_present, otpDisabled=self.otp_present)
  323. self.helper = Mock()
  324. self.helper.click_verification_button.return_value = False
  325. self.factory = self.stack.enter_context(patch.object(ita_turnstile, 'CloudflareBypasser',
  326. return_value=self.helper))
  327. self.stack.enter_context(patch.object(preparation.time, 'sleep'))
  328. def assert_preparation_recovers(self, role):
  329. def clicked(**kwargs):
  330. self.assertEqual(self.clicks, [])
  331. self.token_ready = True
  332. return True
  333. self.helper.click_verification_button.side_effect = clicked
  334. times = itertools.chain([0, 0, 5, 6], itertools.count(7))
  335. output = StringIO()
  336. with patch.object(preparation.time, 'monotonic', side_effect=lambda: next(times)), redirect_stdout(output):
  337. workflow.prepare_calendar(self.plugin, self.route, role=role)
  338. self.helper.click_verification_button.assert_called_once_with(is_dfs=False)
  339. self.assertEqual(self.clicks, ['#otp-send', '#otp-input', '#btnAvanti'])
  340. self.reader.assert_called_once()
  341. self.assertEqual(self.listener.call_count, 2)
  342. self.assertIn('"state": "ready"', output.getvalue())
  343. self.factory.assert_called_once_with(self.page, log=False)
  344. self.helper.bypass.assert_not_called()
  345. def test_book_interaction_is_followed_by_real_readback_before_one_otp(self):
  346. self.assert_preparation_recovers('book')
  347. self.plugin._record_calendar_book_prepared_route.assert_called_once_with(self.route)
  348. self.plugin._record_calendar_query_prepared_route.assert_not_called()
  349. def test_query_reuses_book_recovery_then_records_only_query_preparation(self):
  350. self.assert_preparation_recovers('query')
  351. self.plugin._record_calendar_query_prepared_route.assert_called_once_with(self.route)
  352. self.plugin._record_calendar_book_prepared_route.assert_not_called()
  353. def test_query_three_clicks_without_token_cannot_release_otp(self):
  354. self.helper.click_verification_button.return_value = True
  355. with patch.object(preparation.time, 'monotonic', side_effect=[0, 0, 5, 15, 25, 35, 121]), \
  356. redirect_stdout(StringIO()), self.assertRaisesRegex(preparation.CalendarGateError, 'turnstile_token_pending'):
  357. workflow.prepare_calendar(self.plugin, self.route, role='query')
  358. self.assertEqual(self.helper.click_verification_button.call_count, 3)
  359. self.listener.assert_not_called()
  360. self.reader.assert_not_called()
  361. self.assertEqual(self.clicks, [])
  362. self.plugin._record_calendar_query_prepared_route.assert_not_called()
  363. def test_query_stages_share_one_recovery_budget(self):
  364. # The third click yields a real token. Expiry after sending OTP must not
  365. # create a fresh recovery budget or allow AVANTI without a new token.
  366. def clicked(**kwargs):
  367. if self.helper.click_verification_button.call_count == 3:
  368. self.token_ready = True
  369. return True
  370. self.helper.click_verification_button.side_effect = clicked
  371. def click(ele):
  372. self.clicks.append(ele.selector)
  373. if ele.selector == '#otp-send':
  374. self.token_ready = False
  375. self.plugin.mouse.human_click_ele = click
  376. ticks = [0, 0, 5, 15, 25, 26, 27, 27, 32, 42, 52, 148]
  377. with patch.object(preparation.time, 'monotonic', side_effect=ticks), \
  378. redirect_stdout(StringIO()), self.assertRaisesRegex(preparation.CalendarGateError, 'turnstile_token_pending'):
  379. workflow.prepare_calendar(self.plugin, self.route, role='query')
  380. self.factory.assert_called_once_with(self.page, log=False)
  381. self.assertEqual(self.helper.click_verification_button.call_count, 3)
  382. self.assertEqual(self.clicks, ['#otp-send', '#otp-input'])
  383. self.assertEqual(self.listener.call_count, 1)
  384. self.plugin._record_calendar_query_prepared_route.assert_not_called()
  385. def test_query_ready_widget_does_not_invoke_helper(self):
  386. self.token_ready = True
  387. with redirect_stdout(StringIO()):
  388. workflow.prepare_calendar(self.plugin, self.route, role='query')
  389. self.factory.assert_not_called()
  390. self.assertEqual(self.clicks, ['#otp-send', '#otp-input', '#btnAvanti'])
  391. def test_prepared_query_skips_recovery_and_all_preparation_actions(self):
  392. self.page.url = 'https://prenotami.esteri.it/BookingCalendar'
  393. with patch.object(workflow, 'ItalyTurnstileRecovery') as recovery:
  394. self.assertIsNone(workflow.prepare_query_if_needed(self.plugin, Mock()))
  395. recovery.assert_not_called()
  396. self.factory.assert_not_called()
  397. self.listener.assert_not_called()
  398. self.page.run_js.assert_not_called()
  399. def test_book_timeout_is_diagnostic_and_sends_no_otp(self):
  400. output = StringIO()
  401. with patch.object(preparation.time, 'monotonic', side_effect=[0, 0, 5, 121]), \
  402. redirect_stdout(output), self.assertRaisesRegex(preparation.CalendarGateError, 'turnstile_token_pending'):
  403. workflow.prepare_calendar(self.plugin, self.route, role='book')
  404. self.listener.assert_not_called()
  405. self.reader.assert_not_called()
  406. self.assertEqual(self.clicks, [])
  407. self.assertIn('"outcome": "timeout"', output.getvalue())
  408. self.helper.bypass.assert_not_called()
  409. def test_cloud_book_timeout_never_calls_mail_api(self):
  410. self.plugin.free_config['otp_mode'] = 'cloud'
  411. self.route = replace(self.route, mail=OtpMailConfig('mailbox@example.test'))
  412. with patch.object(preparation.time, 'monotonic', side_effect=[0, 0, 5, 121]), \
  413. patch.object(workflow, 'fetch_otp_from_cloud') as fetch, \
  414. patch.object(ita_otp.vs_log_macros, '_active_logger', logging.Logger('offline-cf', logging.INFO)), \
  415. redirect_stdout(StringIO()), self.assertRaises(preparation.CalendarGateError):
  416. workflow.prepare_calendar(self.plugin, self.route, role='book')
  417. fetch.assert_not_called()
  418. self.listener.assert_not_called()
  419. self.reader.assert_not_called()
  420. class ProductionEntryTests(TestCase):
  421. def setUp(self):
  422. self.plugin, self.route, self.trigger = flow.prepared_plugin(flow.FlowPage())
  423. self.plugin.free_config["otp_mode"] = "manual"
  424. self.inputs = {"username": self.plugin.config.account.username}
  425. self.plugin.is_healthy = True
  426. self.plugin._log = Mock()
  427. self.addCleanup(setattr, self.plugin, "_cleanup_attempted", True)
  428. def test_prepared_book_reuses_real_calendar_adapter_and_defaults_to_prefinal(self):
  429. with patch.object(workflow, "submit_final") as submit, patch.object(workflow, "prepare_calendar") as prepare:
  430. result = self.plugin.book(self.trigger, self.inputs)
  431. self.assertFalse(result.success)
  432. self.assertIsNotNone(self.plugin.last_booking_precommit)
  433. self.assertEqual(result.label, "calendar-ready-before-final")
  434. self.assertEqual(self.plugin.page.guard_final_count, 0)
  435. submit.assert_not_called()
  436. prepare.assert_not_called()
  437. def test_cloud_book_reuses_selection_without_enabling_final(self):
  438. self.plugin.free_config["otp_mode"] = "cloud"
  439. with patch.object(workflow, "submit_final") as submit:
  440. result = self.plugin.book(self.trigger, self.inputs)
  441. self.assertEqual(result.label, "calendar-ready-before-final")
  442. self.assertIsNotNone(self.plugin.last_booking_precommit)
  443. self.assertFalse(result.success)
  444. submit.assert_not_called()
  445. def test_cloud_final_uses_the_existing_submitter_after_fresh_selection(self):
  446. self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True)
  447. confirmed = VSBookResult(success=True, book_date="2026-10-13", book_time="09:26")
  448. with patch.object(workflow, "submit_final", return_value=confirmed) as submit:
  449. result = self.plugin.book(self.trigger, self.inputs)
  450. self.assertIs(result, confirmed)
  451. self.assertIsNotNone(self.plugin.last_booking_precommit)
  452. submit.assert_called_once_with(self.plugin, self.route)
  453. def test_invalid_final_flag_is_rejected_before_site_actions(self):
  454. self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled="true")
  455. with patch.object(workflow, "submit_final") as submit, \
  456. patch.object(workflow, "prepare_calendar") as prepare, self.assertRaises(PermissionDeniedError):
  457. self.plugin.book(self.trigger, self.inputs)
  458. submit.assert_not_called()
  459. prepare.assert_not_called()
  460. def test_cloud_final_no_inventory_never_submits(self):
  461. self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True)
  462. self.plugin.page = flow.FlowPage([flow.month(m, {}) for m in ("2026-10", "2026-11", "2026-12")])
  463. self.plugin._record_calendar_book_prepared_route(self.route)
  464. with patch.object(workflow, "submit_final") as submit, flow.browser_navigation(self.plugin.page):
  465. result = self.plugin.book(self.trigger, self.inputs)
  466. self.assertFalse(result.success)
  467. submit.assert_not_called()
  468. def test_enabled_book_returns_standard_result_after_real_slot_selection(self):
  469. self.plugin.free_config["final_submit_enabled"] = True
  470. confirmed = VSBookResult(success=True, book_date="2026-10-13", book_time="09:26")
  471. with patch.object(workflow, "submit_final", return_value=confirmed) as submit:
  472. result = self.plugin.book(self.trigger, self.inputs)
  473. self.assertIs(result, confirmed)
  474. self.assertIsNotNone(self.plugin.last_booking_precommit)
  475. submit.assert_called_once_with(self.plugin, self.route)
  476. def test_one_public_book_call_prepares_and_selects_from_dashboard(self):
  477. plugin = self.plugin
  478. plugin.page.url = "https://prenotami.esteri.it/UserArea"
  479. plugin._calendar_book_prepared_context = None
  480. plugin._inspect_booking_form_structure = Mock()
  481. def entry(apt):
  482. plugin.page.url = "https://prenotami.esteri.it" + plugin._booking_path(self.route)
  483. return VSQueryResult(success=True)
  484. plugin.query.side_effect = entry
  485. def prepare(p, route, *, role):
  486. self.assertEqual(role, "book")
  487. p.page.url = "https://prenotami.esteri.it/BookingCalendar"
  488. p._record_calendar_book_prepared_route(route)
  489. with patch.object(workflow, "prepare_calendar", side_effect=prepare) as prep:
  490. result = plugin.book(self.trigger, self.inputs)
  491. prep.assert_called_once()
  492. plugin.query.assert_called_once()
  493. self.assertEqual(result.label, "calendar-ready-before-final")
  494. self.assertIsNotNone(plugin.last_booking_precommit)
  495. def test_final_config_requires_explicit_supported_applicant_mode(self):
  496. for values, accepted in (({}, True), ({"otp_mode": "manual"}, True),
  497. ({"otp_mode": "cloud"}, True),
  498. ({"otp_mode": "cloud", "final_submit_enabled": True}, True),
  499. ({"otp_mode": "cloud", "query_mode": "calendar"}, True),
  500. ({"otp_mode": "cloud", "query_mode": "calendar", "final_submit_enabled": True}, False),
  501. ({"otp_mode": "cloud", "final_submit_enabled": "true"}, False),
  502. ({"otp_mode": "cloud", "final_submit_enabled": 1}, False),
  503. ({"otp_mode": "manual", "final_submit_enabled": True}, True),
  504. ({"final_submit_enabled": True}, False),
  505. ({"otp_mode": "manual", "final_submit_enabled": 1}, False),
  506. ({"otp_mode": "manual", "final_submit_enabled": True, "query_mode": "calendar"}, False)):
  507. with self.subTest(values=values):
  508. config = VSPlgConfig(free_config=values)
  509. if accepted:
  510. self.plugin.set_config(config)
  511. else:
  512. with self.assertRaises(BizLogicError):
  513. self.plugin.set_config(config)
  514. def test_no_inventory_never_calls_final(self):
  515. self.plugin.page = flow.FlowPage([flow.month(m, {}) for m in ("2026-10", "2026-11", "2026-12")])
  516. self.plugin._record_calendar_book_prepared_route(self.route)
  517. with patch.object(workflow, "submit_final") as submit, flow.browser_navigation(self.plugin.page):
  518. result = self.plugin.book(self.trigger, self.inputs)
  519. self.assertFalse(result.success)
  520. submit.assert_not_called()
  521. def test_query_or_another_applicant_cannot_book(self):
  522. for query_key, username in ((self.route.routing_key, self.inputs["username"]), (None, "other@example.test")):
  523. self.plugin._calendar_query_route_key = query_key
  524. with self.assertRaises(BizLogicError), patch.object(workflow, "submit_final") as submit:
  525. self.plugin.book(self.trigger, {"username": username})
  526. submit.assert_not_called()
  527. def test_unknown_attempt_cannot_rescan_or_submit_again(self):
  528. self.plugin._production_final_attempt = SimpleNamespace(state="unknown")
  529. with self.assertRaises(FinalOutcomeUnknown), patch.object(workflow, "submit_final") as submit:
  530. self.plugin.book(self.trigger, self.inputs)
  531. submit.assert_not_called()
  532. self.assertEqual(self.plugin.page.refreshes, 0)
  533. def test_cloud_unknown_attempt_is_not_retried(self):
  534. self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True)
  535. self.plugin._production_final_attempt = SimpleNamespace(state="unknown")
  536. with patch.object(workflow, "submit_final") as submit, \
  537. patch.object(workflow, "prepare_calendar") as prepare, self.assertRaises(FinalOutcomeUnknown):
  538. self.plugin.book(self.trigger, self.inputs)
  539. submit.assert_not_called()
  540. prepare.assert_not_called()
  541. self.assertEqual(self.plugin.page.refreshes, 0)
  542. def test_cloud_final_rejects_query_session_and_other_applicant(self):
  543. self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True)
  544. for query_key, username in ((self.route.routing_key, self.inputs["username"]), (None, "other@example.test")):
  545. self.plugin._calendar_query_route_key = query_key
  546. with patch.object(workflow, "submit_final") as submit, self.assertRaises(BizLogicError):
  547. self.plugin.book(self.trigger, {"username": username})
  548. submit.assert_not_called()
  549. def test_cloud_confirmed_result_does_not_create_second_booking(self):
  550. self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True)
  551. self.test_confirmed_result_can_be_reported_again_without_another_booking()
  552. def test_confirmed_result_can_be_reported_again_without_another_booking(self):
  553. result = VSBookResult(success=True, book_date="2026-10-13", book_time="09:26")
  554. self.plugin._production_final_attempt = SimpleNamespace(state="confirmed", target=SimpleNamespace(
  555. applicant=self.inputs["username"], routing_key=self.route.routing_key))
  556. self.plugin._production_book_result = result
  557. self.assertIs(self.plugin.book(self.trigger, self.inputs), result)
  558. self.assertEqual(self.plugin.page.refreshes, 0)
  559. def test_query_from_dashboard_prepares_once_and_never_returns_weak_positive(self):
  560. plugin = self.plugin
  561. plugin.query = MethodType(ItaPlugin.query, plugin)
  562. plugin.free_config["query_mode"] = "calendar"
  563. plugin.page.url = "https://prenotami.esteri.it/UserArea"
  564. plugin._calendar_book_prepared_context = None
  565. strong = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available,
  566. earliest_date=datetime(2026, 10, 13), apt_type=self.trigger.apt_type)
  567. plugin._query_once = Mock(side_effect=lambda apt, **kwargs: (
  568. VSQueryResult(success=True) if kwargs else strong))
  569. def prepare(p, route, *, role):
  570. self.assertEqual(role, "query")
  571. p.page.url = "https://prenotami.esteri.it/BookingCalendar"
  572. with patch.object(workflow, "prepare_calendar", side_effect=prepare) as prep:
  573. self.assertIs(plugin.query(self.trigger.apt_type), strong)
  574. self.assertIs(plugin.query(self.trigger.apt_type), strong)
  575. self.assertEqual(prep.call_count, 1)
  576. self.assertEqual(plugin._query_once.call_count, 3)
  577. def test_entry_no_availability_does_not_send_otp(self):
  578. self.plugin.page.url = "https://prenotami.esteri.it/UserArea"
  579. negative = VSQueryResult(success=False)
  580. self.plugin._query_once = Mock(return_value=negative)
  581. with patch.object(workflow, "prepare_calendar") as prep:
  582. self.assertIs(workflow.prepare_query_if_needed(self.plugin, self.trigger.apt_type), negative)
  583. prep.assert_not_called()
  584. def test_production_modules_never_import_debug_tools(self):
  585. root = Path(__file__).resolve().parents[1]
  586. for filename in ("ita_plugin.py",):
  587. tree = ast.parse((root / "plugins" / filename).read_text())
  588. imports = [n.module for n in ast.walk(tree) if isinstance(n, ast.ImportFrom)]
  589. self.assertFalse(any(name and name.startswith("tools") for name in imports))
  590. class FinalCompositionTests(TestCase):
  591. def setUp(self):
  592. attribution.AttributionTests.setUp(self)
  593. self.plugin._log = Mock()
  594. self.audit = Mock()
  595. self.before = {k: 0 for k in ("otpRequests", "avantiPosts", "availabilityRequests", "finalRequests", "timeSlotRequests")}
  596. self.after = {**self.before, "finalRequests": 1}
  597. self.audit.settled_snapshot.side_effect = [self.before, self.after]
  598. def add_confirmed(self):
  599. attribution.AttributionTests.add_confirmed(self)
  600. def run_final(self):
  601. def native_factory(page, target, current):
  602. native = Mock(side_effect=lambda: (self.add_confirmed(), SubmissionSignal.UNKNOWN)[1])
  603. native.submitted_selection = VerifiedSubmission(target)
  604. return native
  605. with patch.object(workflow, "CalendarRequestAudit", return_value=self.audit), \
  606. patch.object(workflow, "NativeFinalSubmitter", side_effect=native_factory) as factory:
  607. result = workflow.submit_final(self.plugin, self.route)
  608. self.assertEqual(factory.call_count, 1)
  609. return result
  610. def test_real_read_port_and_core_return_success_with_assigned_time(self):
  611. result = self.run_final()
  612. self.assertTrue(result.success)
  613. self.assertEqual(result.book_time, "09:26")
  614. self.assertEqual(self.plugin._production_final_attempt.state, "confirmed")
  615. self.assertIs(self.plugin._production_book_result, result)
  616. self.audit.stop.assert_called_once()
  617. def test_missing_request_audit_leaves_unknown_attempt_not_false_result(self):
  618. self.after["finalRequests"] = 0
  619. with self.assertRaises(FinalOutcomeUnknown):
  620. self.run_final()
  621. self.assertEqual(self.plugin._production_final_attempt.state, "unknown")
  622. self.audit.stop.assert_called_once()
  623. def test_audit_cleanup_failure_does_not_erase_confirmed_result(self):
  624. self.audit.stop.side_effect = RuntimeError("fixture")
  625. self.assertTrue(self.run_final().success)
  626. self.plugin._log.assert_called_once()
  627. class CloudFinalCompositionTests(FinalCompositionTests):
  628. """Cloud mode shares the real read-port, receipt attribution and no-retry core."""
  629. def setUp(self):
  630. super().setUp()
  631. self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True)
  632. class RealFinalAuditTests(TestCase):
  633. """Real audit ownership + production final core, synthetic CDP/receipts."""
  634. def setUp(self):
  635. from test.test_debug_ita_production_query_gate import FakeAuditPage
  636. attribution.AttributionTests.setUp(self)
  637. self.plugin._log = Mock()
  638. transport = FakeAuditPage()
  639. self.main.driver = transport.driver
  640. self.main.run_cdp = transport.run_cdp
  641. self.transport = transport
  642. self.audit = preparation.CalendarRequestAudit(self.main, include_time_slots=True)
  643. self.audit.start = Mock(wraps=self.audit.start)
  644. self.audit.stop = Mock(wraps=self.audit.stop)
  645. self.addCleanup(self.audit.stop)
  646. clock = itertools.count(0, 0.1)
  647. self.enterContext(patch.object(preparation, "time", SimpleNamespace(
  648. monotonic=lambda: next(clock), sleep=lambda _seconds: None)))
  649. self.on_submit = lambda: transport.emit("/BookingCalendar/InsertNewBooking")
  650. self.native = Mock(side_effect=self.dispatch)
  651. def native_factory(page, target, current):
  652. self.assertIs(page, self.main)
  653. self.native.submitted_selection = VerifiedSubmission(target)
  654. return self.native
  655. self.factory = self.enterContext(patch.object(workflow, "NativeFinalSubmitter", side_effect=native_factory))
  656. def dispatch(self):
  657. self.on_submit()
  658. attribution.AttributionTests.add_confirmed(self)
  659. return SubmissionSignal.UNKNOWN
  660. def borrow(self):
  661. return workflow.submit_final(self.plugin, self.route, request_audit=self.audit)
  662. def test_shared_audit_counts_one_submit_and_remains_owned_by_caller(self):
  663. self.audit.start()
  664. callback = self.main.driver.immediate_event_handlers[self.audit.EVENT]
  665. self.assertTrue(self.borrow().success)
  666. self.native.assert_called_once()
  667. self.audit.start.assert_called_once()
  668. self.audit.stop.assert_not_called()
  669. self.audit.require_active_on(self.main)
  670. self.assertIs(self.main.driver.immediate_event_handlers[self.audit.EVENT], callback)
  671. self.assertEqual(self.audit.snapshot()["finalRequests"], 1)
  672. self.assertEqual(self.transport.commands.count("Network.enable"), 1)
  673. def test_standalone_production_still_owns_start_and_stop(self):
  674. with patch.object(preparation, "CalendarRequestAudit", return_value=self.audit) as factory:
  675. self.assertTrue(workflow.submit_final(self.plugin, self.route).success)
  676. factory.assert_called_once_with(self.main, include_time_slots=True)
  677. self.audit.start.assert_called_once()
  678. self.audit.stop.assert_called_once()
  679. self.assertEqual(self.main.driver.immediate_event_handlers, {})
  680. def test_nested_registration_without_explicit_borrow_still_refused(self):
  681. self.audit.start()
  682. with self.assertRaisesRegex(preparation.CalendarGateError, "existing callback"):
  683. workflow.submit_final(self.plugin, self.route)
  684. self.factory.assert_not_called()
  685. self.audit.require_active_on(self.main)
  686. self.browser.new_tab.assert_not_called()
  687. def test_existing_reservation_blocks_without_stopping_borrowed_audit(self):
  688. from plugins.ita_plugin import FinalBookingError
  689. self.audit.start()
  690. attribution.AttributionTests.add_confirmed(self)
  691. with self.assertRaises(FinalBookingError):
  692. self.borrow()
  693. self.factory.assert_not_called()
  694. self.audit.stop.assert_not_called()
  695. self.audit.require_active_on(self.main)
  696. self.assertEqual(self.audit.snapshot()["finalRequests"], 0)
  697. def test_wrong_page_driver_stopped_or_disconnected_audit_never_submits(self):
  698. self.audit.start()
  699. for target, attribute, replacement in (
  700. (self.audit, "page", self.transport),
  701. (self.main, "driver", object()),
  702. (self.audit, "_started", False),
  703. (self.audit.driver, "is_running", False)):
  704. with self.subTest(attribute=attribute), patch.object(target, attribute, replacement):
  705. with self.assertRaises(preparation.CalendarGateError):
  706. self.borrow()
  707. self.factory.assert_not_called()
  708. self.browser.new_tab.assert_not_called()
  709. self.audit.stop.assert_not_called()
  710. def test_replaced_callback_is_not_overwritten_or_accepted_as_proof(self):
  711. self.audit.start()
  712. for handlers in (self.audit.driver.event_handlers, self.audit.driver.immediate_event_handlers):
  713. foreign = Mock()
  714. with patch.dict(handlers, {self.audit.EVENT: foreign}):
  715. with self.assertRaisesRegex(preparation.CalendarGateError, "callback changed"):
  716. self.borrow()
  717. self.assertIs(handlers[self.audit.EVENT], foreign)
  718. self.factory.assert_not_called()
  719. self.audit.stop.assert_not_called()
  720. def test_borrowed_audit_must_cover_time_slots(self):
  721. self.audit.start()
  722. with patch.dict(self.audit._counts, {"finalRequests": 0}, clear=True):
  723. with self.assertRaisesRegex(preparation.CalendarGateError, "include time slots"):
  724. self.borrow()
  725. self.factory.assert_not_called()
  726. self.browser.new_tab.assert_not_called()
  727. def test_callback_lost_during_submission_cannot_confirm_from_stale_counters(self):
  728. self.audit.start()
  729. foreign = Mock()
  730. handlers = self.audit.driver.immediate_event_handlers
  731. def lose_callback():
  732. self.transport.emit("/BookingCalendar/InsertNewBooking")
  733. handlers[self.audit.EVENT] = foreign
  734. self.on_submit = lose_callback
  735. with patch.dict(handlers):
  736. with self.assertRaises(FinalOutcomeUnknown):
  737. self.borrow()
  738. self.assertIs(handlers[self.audit.EVENT], foreign)
  739. self.assertEqual(self.plugin._production_final_attempt.state, "unknown")
  740. self.audit.stop.assert_not_called()
  741. self.native.assert_called_once()
  742. self.audit.require_active_on(self.main)
  743. def test_missing_duplicate_or_mixed_requests_do_not_become_success(self):
  744. for requests in ([], ["/BookingCalendar/InsertNewBooking"] * 2,
  745. ["/BookingCalendar/InsertNewBooking", "/BookingCalendar/RetrieveTimeSlots"]):
  746. with self.subTest(requests=requests):
  747. before_listing = self.browser.raw
  748. self.audit.start()
  749. self.on_submit = lambda: [self.transport.emit(path) for path in requests]
  750. try:
  751. with self.assertRaises(FinalOutcomeUnknown):
  752. self.borrow()
  753. self.assertEqual(self.plugin._production_final_attempt.state, "unknown")
  754. self.audit.require_active_on(self.main)
  755. finally:
  756. self.audit.stop()
  757. self.browser.raw = before_listing
  758. self.assertEqual(self.native.call_count, 3)
  759. class BookerReuseTests(TestCase):
  760. def setUp(self):
  761. # Reuse existing offline Redis import fixture; never open Redis/cloud.
  762. from test.test_ita_plugin import OrderBookerGCO
  763. from threading import RLock
  764. self.booker = OrderBookerGCO.__new__(OrderBookerGCO)
  765. self.booker.m_lock = RLock()
  766. self.booker.m_task_data_cache = {"fixture": {"status": "running", "order_id": "order", "user_inputs": {}}}
  767. self.booker._log = Mock()
  768. self.booker._remove_task = Mock()
  769. self.booker._push_success_notification = Mock()
  770. self.booker.redis_client = Mock()
  771. self.booker.m_tracker_key = "fixture"
  772. self.task = SimpleNamespace(task_ref="fixture", book_allowed=True, instance=Mock())
  773. self.api = Mock()
  774. api_patch = patch.dict(self.booker._execute_book_job.__func__.__globals__, VSCloudApi=self.api)
  775. api_patch.start()
  776. self.addCleanup(api_patch.stop)
  777. def test_standard_success_still_uses_existing_reporting(self):
  778. result = VSBookResult(success=True, book_date="2026-10-13", book_time="09:26")
  779. self.task.instance.book.return_value = result
  780. self.booker._execute_book_job(self.task, VSQueryResult())
  781. self.booker._push_success_notification.assert_called_once_with("fixture", "order", result)
  782. def test_unknown_pauses_using_existing_api_and_next_signal_does_nothing(self):
  783. self.task.instance.book.side_effect = FinalOutcomeUnknown()
  784. self.booker._execute_book_job(self.task, VSQueryResult())
  785. self.booker._execute_book_job(self.task, VSQueryResult())
  786. self.api.Instance.return_value.update_vas_task.assert_called_once_with("fixture", {"status": "pause"})
  787. self.assertFalse(self.task.book_allowed)
  788. self.task.instance.book.assert_called_once()
  789. self.booker._push_success_notification.assert_not_called()
  790. def test_pause_failure_keeps_task_blocked_locally(self):
  791. self.task.instance.book.side_effect = FinalOutcomeUnknown()
  792. self.api.Instance.return_value.update_vas_task.side_effect = RuntimeError("fixture")
  793. self.booker._execute_book_job(self.task, VSQueryResult())
  794. self.booker._execute_book_job(self.task, VSQueryResult())
  795. self.assertFalse(self.task.book_allowed)
  796. self.task.instance.book.assert_called_once()
  797. self.booker._remove_task.assert_not_called()
  798. class QueryCliTests(TestCase):
  799. def test_workflow_flag_reuses_route_builder_and_calls_standard_query(self):
  800. from tools import debug_ita_query as cli
  801. from test.test_debug_ita_calendar_gate import gate_env
  802. plugin = Mock()
  803. plugin.query.return_value = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available,
  804. earliest_date=datetime(2026, 10, 13))
  805. stdout = StringIO()
  806. with patch.object(cli, "ItaPlugin", return_value=plugin), \
  807. patch.object(cli, "resolve_chrome_path", return_value=Path("/offline/chrome")), \
  808. patch.object(cli, "_get_query_credentials", return_value=("query@example.test", "fixture")), \
  809. patch.object(cli, "_prepare_query_profile", return_value=Path("/offline/profile")), \
  810. redirect_stdout(stdout):
  811. code = cli.run_query_once(gate_env(), non_interactive=False, production_workflow=True)
  812. self.assertEqual(code, 0)
  813. config = plugin.set_config.call_args.args[0]
  814. self.assertEqual(config.free_config["query_mode"], "calendar")
  815. self.assertEqual(config.free_config["otp_mode"], "manual")
  816. self.assertIs(config.free_config["final_submit_enabled"], False)
  817. plugin.query.assert_called_once()
  818. plugin.book.assert_not_called()
  819. plugin.cleanup.assert_called_once()
  820. self.assertIn("ITA_QUERY_WORKFLOW_RESULT=", stdout.getvalue())
  821. def test_headless_workflow_rejected_before_credentials(self):
  822. from tools import debug_ita_query as cli
  823. with patch.object(cli, "_get_query_credentials") as credentials:
  824. with self.assertRaises(cli.DebugConfigurationError):
  825. cli.run_query_once({}, non_interactive=True, production_workflow=True)
  826. credentials.assert_not_called()