test_ita_workflow.py 50 KB

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