test_debug_ita_book.py 26 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603
  1. import ast
  2. import io
  3. import tempfile
  4. import unittest
  5. from contextlib import ExitStack, redirect_stderr, redirect_stdout
  6. from pathlib import Path
  7. from unittest.mock import Mock, patch
  8. from plugins.ita_plugin import (
  9. BOOKING_CALENDAR_PREFINAL_STOP_LABEL,
  10. BOOKING_FORM_DISCOVERY_STOP_LABEL,
  11. BOOKING_RECHECK_NONE_AVAILABLE_LABEL,
  12. )
  13. from tools.debug_ita_book import (
  14. _assert_distinct_local_accounts,
  15. run_book_recheck_once,
  16. )
  17. from tools.debug_ita_session import DebugConfigurationError
  18. from vs_types import AvailabilityStatus, BizLogicError, VSAccount, VSBookResult
  19. class FakeBookDebugElement:
  20. def __init__(self, text):
  21. self.text = text
  22. class FakeBookDebugPage:
  23. def __init__(self):
  24. self.url = "https://prenotami.esteri.it/UserArea?state=sensitive-state"
  25. self.popup_text = ""
  26. def ele(self, selector, timeout=None):
  27. del timeout
  28. if selector == ".jconfirm-content" and self.popup_text:
  29. return FakeBookDebugElement(self.popup_text)
  30. return None
  31. class FakeBookDebugPlugin:
  32. behavior = "none-available"
  33. last_instance = None
  34. def __init__(self, group_id):
  35. self.group_id = group_id
  36. self.page = FakeBookDebugPage()
  37. self.last_booking_form_structure = None
  38. self.create_session_calls = 0
  39. self.book_calls = 0
  40. self.cleanup_called = False
  41. self.last_trigger = None
  42. self.events = []
  43. FakeBookDebugPlugin.last_instance = self
  44. def set_log(self, logger):
  45. self.logger = logger
  46. def set_config(self, config):
  47. self.config = config
  48. def create_session(self):
  49. self.create_session_calls += 1
  50. self.events.append("create-session")
  51. def book(self, trigger, user_inputs=None):
  52. del user_inputs
  53. self.last_trigger = trigger
  54. self.book_calls += 1
  55. self.events.append("book")
  56. if self.behavior == "booking-form":
  57. self.last_booking_form_structure = {
  58. "path": "/Services/Booking/1321",
  59. "form": {
  60. "method": "POST",
  61. "action_path": "/Services/Booking/1321",
  62. "secret": "must-not-appear",
  63. },
  64. "field_count": 1,
  65. "fields": [
  66. {
  67. "tag": "input",
  68. "type": "hidden",
  69. "id": "RequestToken",
  70. "name": "__RequestVerificationToken",
  71. "required": False,
  72. "value": "private@example.test",
  73. }
  74. ],
  75. "button_count": 1,
  76. "buttons": [
  77. {
  78. "tag": "button",
  79. "type": "submit",
  80. "id": "btnAvanti",
  81. "name": None,
  82. "text": "Avanti",
  83. "value": "server-secret",
  84. }
  85. ],
  86. }
  87. return VSBookResult(
  88. success=False,
  89. label=BOOKING_FORM_DISCOVERY_STOP_LABEL,
  90. )
  91. if self.behavior == "unexpected-success":
  92. return VSBookResult(success=True)
  93. if self.behavior == "unexpected-error":
  94. self.page.popup_text = "Account private@example.test ref 12345678"
  95. raise RuntimeError(
  96. "failed at https://iam.esteri.it/signin/"
  97. "?state=sensitive-state&code_challenge=sensitive-challenge"
  98. )
  99. return VSBookResult(
  100. success=False,
  101. label=BOOKING_RECHECK_NONE_AVAILABLE_LABEL,
  102. )
  103. def cleanup(self):
  104. self.cleanup_called = True
  105. self.events.append("cleanup")
  106. class DebugItaBookSafetyTests(unittest.TestCase):
  107. def setUp(self):
  108. FakeBookDebugPlugin.behavior = "none-available"
  109. FakeBookDebugPlugin.last_instance = None
  110. @staticmethod
  111. def _run(*, arm=False, input_side_effect=None):
  112. stdout = io.StringIO()
  113. stderr = io.StringIO()
  114. env = {
  115. "ITA_USERNAME": "offline-test@example.test",
  116. "ITA_PASSWORD": "offline-password",
  117. }
  118. if input_side_effect is None:
  119. input_side_effect = lambda _prompt: (
  120. FakeBookDebugPlugin.last_instance.events.append("release")
  121. )
  122. with (
  123. patch(
  124. "tools.debug_ita_book.resolve_chrome_path",
  125. return_value=Path("/test/chrome"),
  126. ),
  127. patch("tools.debug_ita_book.ItaPlugin", FakeBookDebugPlugin),
  128. patch.dict("tools.debug_ita_book.os.environ", {}, clear=False),
  129. patch(
  130. "builtins.input",
  131. side_effect=input_side_effect,
  132. ) as input_mock,
  133. redirect_stdout(stdout),
  134. redirect_stderr(stderr),
  135. ):
  136. exit_code = run_book_recheck_once(
  137. env,
  138. non_interactive=True,
  139. arm=arm,
  140. )
  141. return exit_code, stdout.getvalue(), stderr.getvalue(), input_mock
  142. def test_no_slot_recheck_calls_book_once_and_cleans_up(self):
  143. exit_code, stdout, stderr, _input_mock = self._run()
  144. plugin = FakeBookDebugPlugin.last_instance
  145. self.assertEqual(exit_code, 0)
  146. self.assertEqual(plugin.create_session_calls, 1)
  147. self.assertEqual(plugin.book_calls, 1)
  148. self.assertTrue(plugin.last_trigger.success)
  149. self.assertEqual(
  150. plugin.last_trigger.availability_status,
  151. AvailabilityStatus.NoneAvailable,
  152. )
  153. self.assertTrue(plugin.cleanup_called)
  154. self.assertIn("book_attempt=1", stdout)
  155. self.assertIn("ITA_BOOK_RECHECK_NONE_AVAILABLE service_id=1321", stdout)
  156. self.assertIn("ITA_BOOK_CLEANUP_OK", stdout)
  157. self.assertEqual(stderr, "")
  158. def test_booking_form_is_reported_without_values_or_submission(self):
  159. FakeBookDebugPlugin.behavior = "booking-form"
  160. exit_code, stdout, stderr, _input_mock = self._run()
  161. plugin = FakeBookDebugPlugin.last_instance
  162. self.assertEqual(exit_code, 4)
  163. self.assertEqual(plugin.book_calls, 1)
  164. self.assertTrue(plugin.cleanup_called)
  165. self.assertIn("ITA_BOOKING_FORM_STRUCTURE=", stdout)
  166. self.assertIn('"action_path": "/Services/Booking/1321"', stdout)
  167. self.assertIn("stage=before-avanti submit_attempts=0", stdout)
  168. self.assertNotIn("private@example.test", stdout)
  169. self.assertNotIn("server-secret", stdout)
  170. self.assertNotIn("must-not-appear", stdout)
  171. self.assertEqual(stderr, "")
  172. def test_unexpected_success_stops_safely(self):
  173. FakeBookDebugPlugin.behavior = "unexpected-success"
  174. exit_code, stdout, _stderr, _input_mock = self._run()
  175. self.assertEqual(exit_code, 4)
  176. self.assertIn("reason=unexpected-success-before-avanti", stdout)
  177. def test_unexpected_error_is_sanitized_and_not_retried(self):
  178. FakeBookDebugPlugin.behavior = "unexpected-error"
  179. exit_code, stdout, stderr, _input_mock = self._run()
  180. plugin = FakeBookDebugPlugin.last_instance
  181. self.assertEqual(exit_code, 1)
  182. self.assertEqual(plugin.book_calls, 1)
  183. self.assertTrue(plugin.cleanup_called)
  184. self.assertNotIn("sensitive-state", stdout)
  185. self.assertNotIn("sensitive-challenge", stdout)
  186. self.assertNotIn("private@example.test", stdout)
  187. self.assertNotIn("12345678", stdout)
  188. self.assertEqual(stderr, "")
  189. def test_arm_waits_after_login_and_before_the_single_book_call(self):
  190. exit_code, stdout, stderr, input_mock = self._run(arm=True)
  191. plugin = FakeBookDebugPlugin.last_instance
  192. self.assertEqual(exit_code, 0)
  193. self.assertEqual(
  194. plugin.events,
  195. ["create-session", "release", "book", "cleanup"],
  196. )
  197. input_mock.assert_called_once()
  198. self.assertIn(
  199. "ITA_BOOK_ARMED service_id=1321 "
  200. "routing_key=slot.dub.it.tourist stage=user-area",
  201. stdout,
  202. )
  203. self.assertEqual(stderr, "")
  204. def test_ctrl_c_cancels_armed_mode_without_book_or_traceback(self):
  205. exit_code, stdout, stderr, input_mock = self._run(
  206. arm=True,
  207. input_side_effect=KeyboardInterrupt,
  208. )
  209. plugin = FakeBookDebugPlugin.last_instance
  210. self.assertEqual(exit_code, 130)
  211. self.assertEqual(plugin.book_calls, 0)
  212. self.assertEqual(plugin.events, ["create-session", "cleanup"])
  213. input_mock.assert_called_once()
  214. self.assertIn(
  215. "ITA_BOOK_ARM_CANCELLED service_id=1321 "
  216. "routing_key=slot.dub.it.tourist book_attempts=0",
  217. stdout,
  218. )
  219. self.assertIn("ITA_BOOK_CLEANUP_OK", stdout)
  220. self.assertNotIn("Traceback", stdout)
  221. self.assertEqual(stderr, "")
  222. def test_local_signal_wait_claims_once_before_the_single_book_call(self):
  223. claimed = []
  224. def claim():
  225. claimed.append("claim")
  226. return object()
  227. stdout = io.StringIO()
  228. stderr = io.StringIO()
  229. env = {
  230. "ITA_USERNAME": "book-user@example.test",
  231. "ITA_PASSWORD": "offline-password",
  232. }
  233. with (
  234. patch(
  235. "tools.debug_ita_book.resolve_chrome_path",
  236. return_value=Path("/test/chrome"),
  237. ),
  238. patch("tools.debug_ita_book._assert_distinct_local_accounts"),
  239. patch("tools.debug_ita_book.ItaPlugin", FakeBookDebugPlugin),
  240. patch.dict("tools.debug_ita_book.os.environ", {}, clear=False),
  241. redirect_stdout(stdout),
  242. redirect_stderr(stderr),
  243. ):
  244. exit_code = run_book_recheck_once(
  245. env,
  246. non_interactive=True,
  247. wait_for_local_signal=True,
  248. signal_timeout=1,
  249. signal_claimer=claim,
  250. monotonic=lambda: 0.0,
  251. sleep=lambda _seconds: None,
  252. )
  253. plugin = FakeBookDebugPlugin.last_instance
  254. self.assertEqual(exit_code, 0)
  255. self.assertEqual(claimed, ["claim"])
  256. self.assertEqual(plugin.events, ["create-session", "book", "cleanup"])
  257. self.assertEqual(plugin.book_calls, 1)
  258. self.assertEqual(plugin.config.account.username, "book-user@example.test")
  259. self.assertEqual(plugin.config.account.password, "offline-password")
  260. self.assertNotIn(
  261. "persistent_browser_profile_path",
  262. plugin.config.free_config,
  263. )
  264. self.assertIn("ITA_BOOK_SIGNAL_CLAIMED", stdout.getvalue())
  265. self.assertEqual(stderr.getvalue(), "")
  266. def test_local_signal_timeout_never_calls_book(self):
  267. clock = iter([0.0, 0.0, 2.0])
  268. stdout = io.StringIO()
  269. stderr = io.StringIO()
  270. env = {
  271. "ITA_USERNAME": "book-user@example.test",
  272. "ITA_PASSWORD": "offline-password",
  273. }
  274. with (
  275. patch(
  276. "tools.debug_ita_book.resolve_chrome_path",
  277. return_value=Path("/test/chrome"),
  278. ),
  279. patch("tools.debug_ita_book._assert_distinct_local_accounts"),
  280. patch("tools.debug_ita_book.ItaPlugin", FakeBookDebugPlugin),
  281. patch.dict("tools.debug_ita_book.os.environ", {}, clear=False),
  282. redirect_stdout(stdout),
  283. redirect_stderr(stderr),
  284. ):
  285. exit_code = run_book_recheck_once(
  286. env,
  287. non_interactive=True,
  288. wait_for_local_signal=True,
  289. signal_timeout=1,
  290. signal_claimer=lambda: None,
  291. monotonic=lambda: next(clock),
  292. sleep=lambda _seconds: None,
  293. )
  294. plugin = FakeBookDebugPlugin.last_instance
  295. self.assertEqual(exit_code, 5)
  296. self.assertEqual(plugin.book_calls, 0)
  297. self.assertIn("ITA_BOOK_SIGNAL_WAIT_TIMEOUT", stdout.getvalue())
  298. self.assertIn("book_attempts=0", stdout.getvalue())
  299. self.assertEqual(stderr.getvalue(), "")
  300. def test_automatic_handoff_rejects_the_same_query_and_book_account(self):
  301. with tempfile.TemporaryDirectory() as temp_dir:
  302. account_path = Path(temp_dir) / "query-account.json"
  303. account_path.touch()
  304. with (
  305. patch("tools.debug_ita_book.ITA_QUERY_ACCOUNT_FILE", account_path),
  306. patch(
  307. "tools.debug_ita_book.load_local_account",
  308. return_value=VSAccount(
  309. username="same@example.test",
  310. password="query-secret",
  311. ),
  312. ),
  313. self.assertRaisesRegex(
  314. DebugConfigurationError,
  315. "different Query and Book accounts",
  316. ),
  317. ):
  318. _assert_distinct_local_accounts("SAME@example.test")
  319. def test_role_check_accepts_different_query_and_book_accounts(self):
  320. with tempfile.TemporaryDirectory() as temp_dir:
  321. account_path = Path(temp_dir) / "query-account.json"
  322. account_path.touch()
  323. with (
  324. patch("tools.debug_ita_book.ITA_QUERY_ACCOUNT_FILE", account_path),
  325. patch(
  326. "tools.debug_ita_book.load_local_account",
  327. return_value=VSAccount(
  328. username="query@example.test",
  329. password="query-secret",
  330. ),
  331. ) as query_loader,
  332. ):
  333. _assert_distinct_local_accounts("book@example.test")
  334. query_loader.assert_called_once_with(account_path)
  335. def test_entrypoint_has_one_book_call_and_no_query_call(self):
  336. source_path = (
  337. Path(__file__).resolve().parents[1] / "tools" / "debug_ita_book.py"
  338. )
  339. tree = ast.parse(source_path.read_text(encoding="utf-8"))
  340. book_calls = []
  341. query_calls = []
  342. for node in ast.walk(tree):
  343. if not isinstance(node, ast.Call):
  344. continue
  345. if not isinstance(node.func, ast.Attribute):
  346. continue
  347. if node.func.attr == "book":
  348. book_calls.append(node)
  349. if node.func.attr == "query":
  350. query_calls.append(node)
  351. self.assertEqual(len(book_calls), 1)
  352. self.assertEqual(query_calls, [])
  353. class DebugItaBookWorkflowTests(unittest.TestCase):
  354. """Exercise the CLI contract with synthetic adapters, never a real browser."""
  355. def setUp(self):
  356. from tools import debug_ita_book as cli
  357. from plugins import ita_calendar_book as calendar
  358. from plugins import ita_calendar_session as session
  359. from test.test_debug_ita_calendar_gate import gate_env
  360. from test.test_ita_booking_final import target
  361. self.cli = cli
  362. self.env = {**gate_env(), "ITA_USERNAME": "query@example.test", "ITA_PASSWORD": "query-secret"}
  363. self.plugin = Mock()
  364. self.plugin.last_booking_form_structure = None
  365. self.plugin.last_booking_precommit = target().approval
  366. self.plugin.book.return_value = VSBookResult(success=False, label=BOOKING_CALENDAR_PREFINAL_STOP_LABEL)
  367. self.counts = {"otpRequests": 1, "avantiPosts": 1, "availabilityRequests": 3,
  368. "timeSlotRequests": 3, "finalRequests": 0}
  369. self.audit = Mock()
  370. self.audit.settled_snapshot.side_effect = lambda: dict(self.counts)
  371. self.stack = ExitStack()
  372. self.addCleanup(self.stack.close)
  373. self.stack.enter_context(patch.object(cli, "ItaPlugin", return_value=self.plugin))
  374. self.stack.enter_context(patch.object(cli, "resolve_chrome_path", return_value=Path("/offline/chrome")))
  375. self.credentials = self.stack.enter_context(patch.object(cli, "_get_credentials",
  376. return_value=("applicant@example.test", "applicant-secret")))
  377. self.stack.enter_context(patch.object(session, "CalendarRequestAudit", return_value=self.audit))
  378. self.stack.enter_context(patch.object(calendar, "read_calendar_service", return_value="9001"))
  379. self.readback = self.stack.enter_context(patch.object(calendar, "verify_precommit_selection"))
  380. def run_workflow(self, **kwargs):
  381. output = io.StringIO()
  382. with redirect_stdout(output):
  383. code = self.cli.run_book_recheck_once(self.env, non_interactive=False,
  384. production_workflow=True, **kwargs)
  385. return code, output.getvalue()
  386. def test_auto_otp_reuses_one_public_book_call_and_keeps_final_disabled(self):
  387. self.env["ITA_OTP_AUTHORIZATION_EMAIL"] = "mailbox@example.test"
  388. code, output = self.run_workflow(auto_otp=True)
  389. self.assertEqual(code, 0)
  390. config = self.plugin.set_config.call_args.args[0]
  391. self.assertEqual(config.free_config["otp_mode"], "cloud")
  392. self.assertIs(config.free_config["final_submit_enabled"], False)
  393. route_config = next(iter(config.free_config["apt_configs"].values()))
  394. self.assertEqual(route_config["mail"], {"authorization_email": "mailbox@example.test"})
  395. self.plugin.book.assert_called_once()
  396. self.assertNotIn("mailbox@example.test", output)
  397. self.assertIn("mode=cloud", output)
  398. def test_auto_otp_requires_explicit_mailbox_before_session(self):
  399. with self.assertRaises(self.cli.DebugConfigurationError):
  400. self.run_workflow(auto_otp=True)
  401. self.plugin.create_session.assert_not_called()
  402. def test_verify_receipts_reuses_existing_gate_after_selection_without_final(self):
  403. baseline = {"verified": True, "recordCount": 0, "calendarSelectionPreserved": True,
  404. "businessRequests": {k: 0 for k in self.counts}, "finalSubmissionEnabled": False}
  405. self.env["ITA_OTP_AUTHORIZATION_EMAIL"] = "mailbox@example.test"
  406. with patch("tools.debug_ita_book_gate._verify_receipt_baseline", return_value=baseline) as verify:
  407. code, output = self.run_workflow(auto_otp=True, verify_receipts=True)
  408. self.assertEqual(code, 0)
  409. verify.assert_called_once_with(self.plugin, self.plugin._resolve_route.return_value)
  410. self.plugin.book.assert_called_once()
  411. self.assertIs(self.plugin.set_config.call_args.args[0].free_config["final_submit_enabled"], False)
  412. self.assertIn("ITA_BOOK_WORKFLOW_RECEIPT_BASELINE=", output)
  413. self.assertIn('"calendarSelectionPreserved": true', output)
  414. self.assertIn('"finalRequests": 0', output)
  415. def test_receipt_failure_is_not_passed_or_retried(self):
  416. from plugins.ita_booking_final import FinalBookingError
  417. self.stack.enter_context(patch.object(self.cli, "_print_failure_context"))
  418. with patch("tools.debug_ita_book_gate._verify_receipt_baseline",
  419. side_effect=FinalBookingError("Italy receipt baseline rejected")) as verify:
  420. code, output = self.run_workflow(verify_receipts=True)
  421. self.assertEqual(code, 1)
  422. verify.assert_called_once()
  423. self.plugin.book.assert_called_once()
  424. self.assertNotIn("ITA_BOOK_WORKFLOW_RESULT=", output)
  425. self.plugin.cleanup.assert_called_once()
  426. def test_receipt_read_business_request_change_fails(self):
  427. def unexpected(*args):
  428. self.counts["otpRequests"] += 1
  429. return {}
  430. self.stack.enter_context(patch.object(self.cli, "_print_failure_context"))
  431. with patch("tools.debug_ita_book_gate._verify_receipt_baseline", side_effect=unexpected):
  432. code, output = self.run_workflow(verify_receipts=True)
  433. self.assertEqual(code, 1)
  434. self.assertNotIn("ITA_BOOK_WORKFLOW_RECEIPT_BASELINE=", output)
  435. self.plugin.book.assert_called_once()
  436. def test_no_candidate_skips_receipt_read_and_does_not_claim_pass(self):
  437. self.plugin.book.return_value = VSBookResult(success=False, label=BOOKING_RECHECK_NONE_AVAILABLE_LABEL)
  438. with patch("tools.debug_ita_book_gate._verify_receipt_baseline") as verify:
  439. code, output = self.run_workflow(verify_receipts=True)
  440. self.assertEqual(code, 2)
  441. verify.assert_not_called()
  442. self.assertNotIn("ITA_BOOK_WORKFLOW_RECEIPT_BASELINE=", output)
  443. def test_receipt_flag_requires_workflow_and_defaults_off(self):
  444. self.assertFalse(self.cli.parse_args([]).verify_receipts)
  445. self.assertTrue(self.cli.parse_args(["--production-workflow", "--verify-receipts"]).verify_receipts)
  446. with self.assertRaises(self.cli.DebugConfigurationError):
  447. self.cli.run_book_recheck_once(self.env, non_interactive=False, verify_receipts=True)
  448. self.credentials.assert_not_called()
  449. self.plugin.create_session.assert_not_called()
  450. def test_main_routes_both_opt_in_flags_and_rejects_receipts_alone(self):
  451. with patch.object(self.cli, "run_book_recheck_once", return_value=0) as run:
  452. self.assertEqual(self.cli.main(["--production-workflow", "--auto-otp", "--verify-receipts"]), 0)
  453. self.assertIs(run.call_args.kwargs["verify_receipts"], True)
  454. self.assertIs(run.call_args.kwargs["auto_otp"], True)
  455. with patch.object(self.cli, "run_book_recheck_once") as run, redirect_stderr(io.StringIO()):
  456. self.assertEqual(self.cli.main(["--verify-receipts"]), 2)
  457. run.assert_not_called()
  458. def test_auto_flag_without_workflow_rejected_before_login(self):
  459. with self.assertRaises(self.cli.DebugConfigurationError):
  460. self.cli.run_book_recheck_once(self.env, non_interactive=False, auto_otp=True)
  461. self.credentials.assert_not_called()
  462. self.plugin.create_session.assert_not_called()
  463. self.assertTrue(self.cli.parse_args(["--production-workflow", "--auto-otp"]).auto_otp)
  464. def test_one_public_book_call_with_applicant_identity_and_final_disabled(self):
  465. code, output = self.run_workflow()
  466. self.assertEqual(code, 0)
  467. config = self.plugin.set_config.call_args.args[0]
  468. self.assertEqual(config.account.username, "applicant@example.test")
  469. self.assertEqual(config.free_config["otp_mode"], "manual")
  470. self.assertEqual(config.free_config["query_mode"], "services_probe")
  471. self.assertIs(config.free_config["final_submit_enabled"], False)
  472. self.assertNotIn("persistent_browser_profile_path", config.free_config)
  473. self.credentials.assert_called_once_with({"ITA_USERNAME": "", "ITA_PASSWORD": ""}, non_interactive=False)
  474. self.plugin.book.assert_called_once()
  475. self.assertEqual(self.plugin.book.call_args.kwargs["user_inputs"], {"username": "applicant@example.test"})
  476. self.plugin.query.assert_not_called()
  477. self.readback.assert_called_once()
  478. self.audit.start.assert_called_once()
  479. self.audit.stop.assert_called_once()
  480. self.plugin.cleanup.assert_called_once()
  481. self.assertIn('"selectionVerified": true', output)
  482. self.assertIn('"finalRequests": 0', output)
  483. self.assertIn("ITA_BOOK_CLEANUP_OK", output)
  484. self.assertNotIn("applicant-secret", output)
  485. self.assertNotIn("query-secret", output)
  486. def test_book_specific_environment_is_used_not_general_query_credentials(self):
  487. self.env.update(ITA_BOOK_USERNAME="book@example.test", ITA_BOOK_PASSWORD="book-secret")
  488. self.run_workflow()
  489. self.credentials.assert_called_once_with(
  490. {"ITA_USERNAME": "book@example.test", "ITA_PASSWORD": "book-secret"}, non_interactive=False)
  491. def test_no_candidate_does_not_claim_positive_acceptance(self):
  492. self.plugin.book.return_value = VSBookResult(success=False, label=BOOKING_RECHECK_NONE_AVAILABLE_LABEL)
  493. code, output = self.run_workflow()
  494. self.assertEqual(code, 2)
  495. self.assertIn('"selectionVerified": false', output)
  496. self.readback.assert_not_called()
  497. self.plugin.cleanup.assert_called_once()
  498. def test_selection_readback_failure_is_not_a_pass(self):
  499. self.readback.side_effect = BizLogicError("synthetic readback mismatch")
  500. self.stack.enter_context(patch.object(self.cli, "_print_failure_context"))
  501. code, output = self.run_workflow()
  502. self.assertEqual(code, 1)
  503. self.assertNotIn("ITA_BOOK_WORKFLOW_RESULT=", output)
  504. self.plugin.cleanup.assert_called_once()
  505. def test_unexpected_final_request_fails_and_never_retries(self):
  506. self.counts["finalRequests"] = 1
  507. self.stack.enter_context(patch.object(self.cli, "_print_failure_context"))
  508. code, output = self.run_workflow()
  509. self.assertEqual(code, 1)
  510. self.assertNotIn("ITA_BOOK_WORKFLOW_RESULT=", output)
  511. self.plugin.book.assert_called_once()
  512. self.plugin.cleanup.assert_called_once()
  513. def test_late_audit_failure_invalidates_exit_code(self):
  514. self.audit.settled_snapshot.side_effect = [self.counts, RuntimeError("audit lost")]
  515. code, output = self.run_workflow()
  516. self.assertEqual(code, 1)
  517. self.assertIn("ITA_BOOK_WORKFLOW_AUDIT_FAILED", output)
  518. self.audit.stop.assert_called_once()
  519. self.plugin.cleanup.assert_called_once()
  520. def test_cleanup_failure_invalidates_exit_code(self):
  521. self.plugin.cleanup.side_effect = RuntimeError("cleanup failed")
  522. with redirect_stderr(io.StringIO()):
  523. code, _ = self.run_workflow()
  524. self.assertEqual(code, 3)
  525. def test_legacy_flags_rejected_before_credentials(self):
  526. for kwargs in ({"non_interactive": True}, {"arm": True}, {"wait_for_local_signal": True}):
  527. with self.subTest(kwargs=kwargs), self.assertRaises(DebugConfigurationError):
  528. self.cli.run_book_recheck_once(self.env, production_workflow=True,
  529. **{"non_interactive": False, **kwargs})
  530. self.credentials.assert_not_called()
  531. self.plugin.create_session.assert_not_called()
  532. def test_cli_flag_defaults_off(self):
  533. self.assertFalse(self.cli.parse_args([]).production_workflow)
  534. self.assertTrue(self.cli.parse_args(["--production-workflow"]).production_workflow)
  535. if __name__ == "__main__":
  536. unittest.main()