test_debug_ita_book.py 26 KB

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