test_ita_booking_final.py 29 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620
  1. """Offline final-stage contracts; reservation records are synthetic, not site fixtures."""
  2. import ast
  3. import json
  4. import shutil
  5. import subprocess
  6. import time
  7. import traceback
  8. import unittest
  9. from dataclasses import replace
  10. from datetime import date
  11. from pathlib import Path
  12. from types import SimpleNamespace
  13. from unittest.mock import Mock
  14. from urllib.parse import urlencode
  15. from plugins.ita_plugin import (
  16. FINAL_PATH, NATIVE_FINAL_SCRIPT, FinalBookingAttempt, FinalBookingError,
  17. FinalOutcomeUnknown, FinalTarget, NativeFinalSubmitter, ReservationRecord,
  18. ReservationSnapshot, ReservationState, SubmissionSignal, classify_final_packet,
  19. )
  20. from plugins.ita_plugin import CalendarBookError, select_slot_before_final, verify_precommit_selection
  21. from test.test_ita_calendar_book import DAY, SERVICE, FakePage, packets
  22. def target():
  23. page = FakePage()
  24. approval = select_slot_before_final(
  25. page, target_day=DAY, availability_packet=packets()[0], time_slots_packet=packets()[1],
  26. )
  27. return FinalTarget("applicant@example.test", "synthetic-session", "applicant-tab",
  28. "slot.fixture.it.tourist", "7001", SERVICE, approval)
  29. def receipt(state=ReservationState.ACTIVE, reference="NEW-1", **changes):
  30. return replace(ReservationRecord(reference, "7001", DAY, "10:05 - 11:05", state), **changes)
  31. def final_packet(booking_target=None, *, error="", destination="/Reservation"):
  32. booking_target = booking_target or target()
  33. slot = booking_target.approval.candidate
  34. return SimpleNamespace(
  35. url="https://prenotami.esteri.it" + FINAL_PATH, method="POST",
  36. tab_id=booking_target.tab_id, is_failed=False,
  37. request=SimpleNamespace(postData={
  38. "idCalendarioGiornaliero": slot.daily_calendar_id,
  39. "selectedDay": slot.day.isoformat(), "selectedHour": f"{slot.time_label}\n({slot.slots_free})",
  40. }),
  41. response=SimpleNamespace(status=200, raw_body=json.dumps({"errorMessage": error, "url": destination})),
  42. )
  43. class ReadPort:
  44. def __init__(self, booking_target, records=()):
  45. self.target = booking_target
  46. self.records = records
  47. self.calls = 0
  48. self.error = None
  49. self.overrides = {}
  50. def __call__(self):
  51. self.calls += 1
  52. if self.error:
  53. raise self.error
  54. return replace(ReservationSnapshot(
  55. self.target.applicant, self.target.session_key, time.monotonic(), True, self.records,
  56. ), **self.overrides)
  57. class FinalFlowTests(unittest.TestCase):
  58. def setUp(self):
  59. self.target = target()
  60. self.reader = ReadPort(self.target)
  61. self.current = Mock(return_value=True)
  62. self.signal = SubmissionSignal.ACCEPTED
  63. self.after = (receipt(),)
  64. self.submission_error = None
  65. self.after_hook = None
  66. self.submit = Mock(side_effect=self._submit)
  67. self.attempt = FinalBookingAttempt(
  68. self.target, read_reservations=self.reader, submit_native=self.submit,
  69. session_is_current=self.current,
  70. )
  71. def _submit(self):
  72. self.reader.records = self.after
  73. if self.after_hook:
  74. self.after_hook()
  75. if self.submission_error:
  76. raise self.submission_error
  77. return self.signal
  78. def test_disabled_by_default_and_truthy_values_do_not_authorize(self):
  79. for enabled in (False, None, 1, "true"):
  80. with self.subTest(enabled=enabled), self.assertRaises(FinalBookingError):
  81. self.attempt.execute(enabled=enabled)
  82. self.assertEqual(self.reader.calls, 0)
  83. self.submit.assert_not_called()
  84. self.assertEqual(self.attempt.state, "ready")
  85. def test_confirmed_new_record_returns_existing_framework_result(self):
  86. result = self.attempt.execute(enabled=True)
  87. self.assertTrue(result.success)
  88. self.assertEqual(result.urn, "NEW-1")
  89. self.assertEqual(result.account, self.target.applicant)
  90. self.assertEqual(result.book_date, DAY.isoformat())
  91. self.assertEqual(result.book_time, "10:05 - 11:05")
  92. self.assertEqual(self.attempt.state, "confirmed")
  93. self.assertEqual(self.reader.calls, 2)
  94. self.submit.assert_called_once_with()
  95. def test_cancelled_history_is_preserved_but_does_not_block(self):
  96. old = receipt(ReservationState.CANCELLED, "OLD-1")
  97. self.reader.records = (old,)
  98. self.after = (old, receipt())
  99. self.assertTrue(self.attempt.execute(enabled=True).success)
  100. def test_cancelled_history_may_have_only_an_assigned_appointment_time(self):
  101. old = receipt(ReservationState.CANCELLED, "OLD-TIME", time_label=None, appointment_time="10:25")
  102. self.reader.records = (old,)
  103. self.after = (old, receipt())
  104. self.assertTrue(self.attempt.execute(enabled=True).success)
  105. self.submit.assert_called_once_with()
  106. def test_unbound_cancelled_history_requires_fingerprint_and_is_preserved(self):
  107. old = receipt(ReservationState.CANCELLED, "OLD-UNBOUND", service_id=None,
  108. time_label=None, appointment_time="10:25", receipt_fingerprint="a" * 64)
  109. self.reader.records = (old,)
  110. self.after = (old, receipt())
  111. self.assertTrue(self.attempt.execute(enabled=True).success)
  112. def test_missing_service_never_allows_live_or_untracked_history(self):
  113. cases = [(ReservationState.ACTIVE, "a" * 64), (ReservationState.WAITLIST, "a" * 64),
  114. (ReservationState.CANCELLED, None), (ReservationState.CANCELLED, "SECRET"),
  115. (ReservationState.CANCELLED, True)]
  116. for state, fingerprint in cases:
  117. self.setUp()
  118. self.reader.records = (receipt(state, service_id=None, receipt_fingerprint=fingerprint),)
  119. with self.assertRaises(FinalBookingError):
  120. self.attempt.execute(enabled=True)
  121. self.submit.assert_not_called()
  122. def test_assigned_time_alone_never_proves_new_booking_slot(self):
  123. for assigned in ("10:05", "10:25", "11:05", "14:00"):
  124. with self.subTest(assigned=assigned):
  125. self.setUp()
  126. self.after = (receipt(time_label=None, appointment_time=assigned),)
  127. with self.assertRaises(FinalOutcomeUnknown):
  128. self.attempt.execute(enabled=True)
  129. with self.assertRaises(FinalOutcomeUnknown):
  130. self.attempt.reconcile()
  131. self.submit.assert_called_once_with()
  132. def test_existing_active_point_time_record_still_blocks_submission(self):
  133. self.reader.records = (receipt(time_label=None, appointment_time="10:25"),)
  134. with self.assertRaises(FinalBookingError):
  135. self.attempt.execute(enabled=True)
  136. self.submit.assert_not_called()
  137. def test_independently_bound_interval_preserves_assigned_receipt_time(self):
  138. # Synthetic trusted read-port data, NOT proof the website supplies an interval.
  139. self.after = (receipt(appointment_time="10:25"),)
  140. self.assertEqual(self.attempt.execute(enabled=True).book_time, "10:25")
  141. def test_conflicting_interval_and_assigned_time_is_not_confirmed(self):
  142. self.after = (receipt(appointment_time="14:00"),)
  143. with self.assertRaises(FinalOutcomeUnknown):
  144. self.attempt.execute(enabled=True)
  145. self.submit.assert_called_once_with()
  146. def test_missing_or_malformed_assigned_time_blocks_baseline(self):
  147. for assigned in (None, "", "24:00", "10:25:00", True, "10:25\n"):
  148. with self.subTest(assigned=assigned):
  149. self.setUp()
  150. self.reader.records = (receipt(ReservationState.CANCELLED, time_label=None, appointment_time=assigned),)
  151. with self.assertRaises(FinalBookingError):
  152. self.attempt.execute(enabled=True)
  153. self.submit.assert_not_called()
  154. def test_other_service_active_record_does_not_count_as_target_booking(self):
  155. other = receipt(reference="OTHER", service_id="8001")
  156. self.reader.records = (other,)
  157. self.after = (other, receipt())
  158. self.assertTrue(self.attempt.execute(enabled=True).success)
  159. def test_active_or_waitlist_blocks_before_submission(self):
  160. for state in (ReservationState.ACTIVE, ReservationState.WAITLIST):
  161. with self.subTest(state=state):
  162. self.setUp()
  163. self.reader.records = (receipt(state),)
  164. with self.assertRaisesRegex(FinalBookingError, "active reservation or waitlist"):
  165. self.attempt.execute(enabled=True)
  166. self.submit.assert_not_called()
  167. self.assertEqual(self.attempt.state, "blocked")
  168. def test_malformed_or_incomplete_baseline_blocks(self):
  169. cases = [
  170. {"complete": False}, {"complete": 1}, {"applicant": "another@example.test"},
  171. {"session_key": "older-session"}, {"captured_at": 0}, {"captured_at": float("nan")},
  172. {"captured_at": float("inf")}, {"captured_at": True},
  173. {"records": []}, {"records": (receipt(ReservationState.UNKNOWN),)},
  174. {"records": (receipt(), receipt())}, {"records": (receipt(reference=""),)},
  175. {"records": (receipt(state="cancelled"),)}, {"records": (receipt(time_label="25:00 - 26:00"),)},
  176. {"records": (receipt(time_label="11:05 - 10:05"),)},
  177. ]
  178. for overrides in cases:
  179. with self.subTest(fields=list(overrides)):
  180. self.setUp()
  181. self.reader.overrides = overrides
  182. with self.assertRaises(FinalBookingError):
  183. self.attempt.execute(enabled=True)
  184. self.submit.assert_not_called()
  185. def test_account_change_before_submission_blocks(self):
  186. self.current.return_value = False
  187. with self.assertRaises(FinalBookingError):
  188. self.attempt.execute(enabled=True)
  189. self.submit.assert_not_called()
  190. def test_account_change_during_baseline_read_blocks(self):
  191. self.current.side_effect = [True, False]
  192. with self.assertRaises(FinalBookingError):
  193. self.attempt.execute(enabled=True)
  194. self.submit.assert_not_called()
  195. def test_reader_exception_is_sanitized(self):
  196. self.reader.error = RuntimeError("secret-raw-password")
  197. with self.assertRaises(FinalBookingError) as caught:
  198. self.attempt.execute(enabled=True)
  199. self.assertNotIn("secret", str(caught.exception))
  200. self.assertNotIn("secret", "".join(traceback.format_exception(caught.exception)))
  201. self.submit.assert_not_called()
  202. def test_explicit_rejection_and_no_record_returns_failure_without_retry(self):
  203. self.signal = SubmissionSignal.REJECTED
  204. self.after = ()
  205. result = self.attempt.execute(enabled=True)
  206. self.assertFalse(result.success)
  207. self.assertEqual(result.label, "italy-final-rejected")
  208. self.assertEqual(self.attempt.state, "rejected")
  209. with self.assertRaises(FinalBookingError):
  210. self.attempt.execute(enabled=True)
  211. self.submit.assert_called_once_with()
  212. def test_timeout_after_write_can_be_confirmed_by_fresh_record(self):
  213. self.submission_error = TimeoutError("lost acknowledgement")
  214. self.assertTrue(self.attempt.execute(enabled=True).success)
  215. self.submit.assert_called_once_with()
  216. def test_unknown_response_cannot_be_reported_as_plain_no_availability(self):
  217. self.signal, self.after = SubmissionSignal.UNKNOWN, ()
  218. with self.assertRaises(FinalOutcomeUnknown):
  219. self.attempt.execute(enabled=True)
  220. self.assertEqual(self.attempt.state, "unknown")
  221. def test_accepted_without_receipt_is_unknown_and_only_readback_can_resume(self):
  222. self.after = ()
  223. with self.assertRaises(FinalOutcomeUnknown):
  224. self.attempt.execute(enabled=True)
  225. with self.assertRaises(FinalBookingError):
  226. self.attempt.execute(enabled=True)
  227. self.reader.records = (receipt(),)
  228. self.assertTrue(self.attempt.reconcile().success)
  229. self.submit.assert_called_once_with()
  230. self.assertEqual(self.reader.calls, 3)
  231. def test_unknown_reconciliation_never_submits(self):
  232. self.after = ()
  233. with self.assertRaises(FinalOutcomeUnknown):
  234. self.attempt.execute(enabled=True)
  235. for _ in range(2):
  236. with self.assertRaises(FinalOutcomeUnknown):
  237. self.attempt.reconcile()
  238. self.submit.assert_called_once_with()
  239. def test_mismatches_and_multiple_records_are_unknown(self):
  240. cases = [
  241. (receipt(service_id="wrong-service"),),
  242. (receipt(day=date(2026, 10, 14)),),
  243. (receipt(time_label="11:15 - 12:40"),),
  244. (receipt(ReservationState.CANCELLED),),
  245. (receipt(ReservationState.WAITLIST),),
  246. (receipt(), receipt(reference="SECOND")),
  247. (receipt(), receipt(reference="UNRELATED", service_id="another")),
  248. ]
  249. for records in cases:
  250. with self.subTest(records=len(records)):
  251. self.setUp()
  252. self.after = records
  253. with self.assertRaises(FinalOutcomeUnknown):
  254. self.attempt.execute(enabled=True)
  255. self.submit.assert_called_once_with()
  256. def test_rejection_conflicting_with_receipt_is_unknown(self):
  257. self.signal = SubmissionSignal.REJECTED
  258. with self.assertRaises(FinalOutcomeUnknown):
  259. self.attempt.execute(enabled=True)
  260. def test_removed_or_changed_cancelled_history_is_not_count_based_success(self):
  261. for records in ((receipt(),), (receipt(reference="OLD"),)):
  262. with self.subTest(records=records):
  263. self.setUp()
  264. self.reader.records = (receipt(ReservationState.CANCELLED, "OLD"),)
  265. self.after = records
  266. with self.assertRaises(FinalOutcomeUnknown):
  267. self.attempt.execute(enabled=True)
  268. def test_after_read_failures_remain_unknown_and_sanitized(self):
  269. self.after_hook = lambda: setattr(self.reader, "error", RuntimeError("secret-response-token"))
  270. with self.assertRaises(FinalOutcomeUnknown) as caught:
  271. self.attempt.execute(enabled=True)
  272. self.assertNotIn("secret", "".join(traceback.format_exception(caught.exception)))
  273. self.assertEqual(self.attempt.state, "unknown")
  274. def test_after_identity_change_is_unknown(self):
  275. self.after_hook = lambda: self.reader.overrides.update(applicant="other@example.test")
  276. with self.assertRaises(FinalOutcomeUnknown):
  277. self.attempt.execute(enabled=True)
  278. def test_success_and_blocked_attempts_cannot_be_reused(self):
  279. self.attempt.execute(enabled=True)
  280. with self.assertRaises(FinalBookingError):
  281. self.attempt.execute(enabled=True)
  282. with self.assertRaises(FinalBookingError):
  283. self.attempt.reconcile()
  284. self.submit.assert_called_once_with()
  285. def test_reentrant_submission_is_rejected(self):
  286. def reentrant():
  287. with self.assertRaises(FinalBookingError):
  288. self.attempt.execute(enabled=True)
  289. with self.assertRaises(FinalBookingError):
  290. self.attempt.reconcile()
  291. self.after_hook = reentrant
  292. self.assertTrue(self.attempt.execute(enabled=True).success)
  293. self.submit.assert_called_once_with()
  294. def test_interrupted_write_can_only_resume_read_only(self):
  295. self.submission_error = KeyboardInterrupt()
  296. with self.assertRaises(KeyboardInterrupt):
  297. self.attempt.execute(enabled=True)
  298. self.assertEqual(self.attempt.state, "unknown")
  299. with self.assertRaises(FinalBookingError):
  300. self.attempt.execute(enabled=True)
  301. self.assertTrue(self.attempt.reconcile().success)
  302. self.submit.assert_called_once_with()
  303. def test_interrupted_preflight_stays_blocked_without_submission(self):
  304. self.reader.error = KeyboardInterrupt()
  305. with self.assertRaises(KeyboardInterrupt):
  306. self.attempt.execute(enabled=True)
  307. self.assertEqual(self.attempt.state, "blocked")
  308. self.submit.assert_not_called()
  309. def test_objects_do_not_expose_identifiers_in_repr(self):
  310. self.assertNotIn(self.target.applicant, repr(self.target))
  311. self.assertNotIn("NEW-1", repr(receipt()))
  312. self.assertNotIn(self.target.applicant, repr(self.reader()))
  313. class FinalPacketTests(unittest.TestCase):
  314. def setUp(self):
  315. self.target = target()
  316. def test_known_static_schema_is_only_a_hint(self):
  317. self.assertIs(classify_final_packet(final_packet(self.target), self.target), SubmissionSignal.ACCEPTED)
  318. self.assertIs(classify_final_packet(final_packet(self.target, error="Qualsiasi errore"), self.target),
  319. SubmissionSignal.REJECTED)
  320. def test_form_urlencoded_native_whitespace_is_accepted(self):
  321. packet = final_packet(self.target)
  322. packet.request.postData = urlencode(packet.request.postData)
  323. self.assertIs(classify_final_packet(packet, self.target), SubmissionSignal.ACCEPTED)
  324. def test_mismatched_metadata_is_unknown(self):
  325. for field, value in (
  326. ("url", "https://attacker.test" + FINAL_PATH), ("url", "https://prenotami.esteri.it/elsewhere"),
  327. ("url", "https://prenotami.esteri.it" + FINAL_PATH + "?unexpected=1"),
  328. ("method", "GET"), ("tab_id", "other-tab"), ("is_failed", True),
  329. ):
  330. with self.subTest(field=field):
  331. packet = final_packet(self.target)
  332. setattr(packet, field, value)
  333. self.assertIs(classify_final_packet(packet, self.target), SubmissionSignal.UNKNOWN)
  334. def test_non_200_is_unknown_even_for_auth_or_rate_limit(self):
  335. for status in (True, "200", 302, 400, 401, 403, 409, 429, 500):
  336. with self.subTest(status=status):
  337. packet = final_packet(self.target)
  338. packet.response.status = status
  339. self.assertIs(classify_final_packet(packet, self.target), SubmissionSignal.UNKNOWN)
  340. def test_wrong_request_values_or_extra_fields_are_unknown(self):
  341. for key, value in (
  342. ("idCalendarioGiornaliero", "123"), ("selectedDay", "2026-10-14"),
  343. ("selectedHour", "10:05 - 11:05(0)"), ("selectedHour", None), ("extra", "secret"),
  344. ):
  345. with self.subTest(key=key):
  346. packet = final_packet(self.target)
  347. packet.request.postData[key] = value
  348. self.assertIs(classify_final_packet(packet, self.target), SubmissionSignal.UNKNOWN)
  349. def test_duplicate_post_field_is_unknown(self):
  350. packet = final_packet(self.target)
  351. packet.request.postData = urlencode(packet.request.postData) + "&selectedDay=2026-10-13"
  352. self.assertIs(classify_final_packet(packet, self.target), SubmissionSignal.UNKNOWN)
  353. def test_invalid_response_is_unknown_without_disclosing_text(self):
  354. for raw in ("<html>secret</html>", "null", "[]", "{}", '{"errorMessage": ""}',
  355. '{"errorMessage": null, "url": "/Reservation"}',
  356. '{"errorMessage": "", "errorMessage": "secret", "url": "/Reservation"}',
  357. '{"errorMessage": "", "url": "https://attacker.test"}', "x" * 1_000_001):
  358. with self.subTest(length=len(raw)):
  359. packet = final_packet(self.target)
  360. packet.response.raw_body = raw
  361. self.assertIs(classify_final_packet(packet, self.target), SubmissionSignal.UNKNOWN)
  362. class NativePage(FakePage):
  363. def __init__(self, booking_target):
  364. super().__init__()
  365. self.tab_id = booking_target.tab_id
  366. self.active = True
  367. self.final_clicks = 0
  368. self.final_ack = True
  369. self.final_exception = None
  370. self.final_packet = final_packet(booking_target)
  371. self.listen = SimpleNamespace(
  372. start=Mock(), wait=Mock(side_effect=lambda **kwargs: self.final_packet), stop=Mock(),
  373. )
  374. def run_js(self, script, *args):
  375. if script == NATIVE_FINAL_SCRIPT:
  376. self.listen.start.assert_called_once_with(FINAL_PATH, method="POST")
  377. if self.final_exception:
  378. raise self.final_exception
  379. self.final_clicks += int(self.final_ack)
  380. return {"clicked": self.final_ack}
  381. return super().run_js(script, *args)
  382. class NativeFinalTests(unittest.TestCase):
  383. def setUp(self):
  384. self.target = target()
  385. self.page = NativePage(self.target)
  386. self.current = Mock(return_value=True)
  387. self.submit = NativeFinalSubmitter(self.page, self.target, self.current)
  388. def test_real_adapter_uses_existing_listener_and_one_native_click(self):
  389. self.assertIs(self.submit(), SubmissionSignal.ACCEPTED)
  390. self.assertEqual(self.page.final_clicks, 1)
  391. self.assertEqual(self.page.clicks, 0)
  392. self.page.listen.stop.assert_called_once_with()
  393. with self.assertRaises(FinalBookingError):
  394. self.submit()
  395. self.assertEqual(self.page.final_clicks, 1)
  396. def test_wrong_context_or_unselected_slot_never_clicks(self):
  397. for change in (lambda: setattr(self.page, "tab_id", "other"),
  398. lambda: setattr(self.page, "url", "https://attacker.test/BookingCalendar"),
  399. lambda: setattr(self.page, "service", "other"),
  400. lambda: setattr(self.page, "active", False),
  401. lambda: setattr(self.current, "return_value", False)):
  402. self.setUp()
  403. change()
  404. self.assertIs(self.submit(), SubmissionSignal.UNKNOWN)
  405. self.assertEqual(self.page.final_clicks, 0)
  406. def test_context_change_after_listener_start_does_not_click(self):
  407. self.current.side_effect = [True, False]
  408. self.assertIs(self.submit(), SubmissionSignal.UNKNOWN)
  409. self.assertEqual(self.page.final_clicks, 0)
  410. self.page.listen.stop.assert_called_once_with()
  411. def test_no_packet_or_browser_ack_is_unknown_without_retry(self):
  412. for mode in ("timeout", "no_ack", "exception"):
  413. with self.subTest(mode=mode):
  414. self.setUp()
  415. if mode == "timeout":
  416. self.page.final_packet = None
  417. elif mode == "no_ack":
  418. self.page.final_ack = False
  419. else:
  420. self.page.final_exception = RuntimeError("secret")
  421. self.assertIs(self.submit(), SubmissionSignal.UNKNOWN)
  422. self.page.listen.stop.assert_called_once_with()
  423. with self.assertRaises(FinalBookingError):
  424. self.submit()
  425. self.assertLessEqual(self.page.final_clicks, 1)
  426. def test_precommit_readback_is_read_only(self):
  427. self.assertEqual(verify_precommit_selection(
  428. self.page, runtime_service=SERVICE, approval=self.target.approval,
  429. ), self.target.approval)
  430. self.assertEqual(self.page.clicks, 0)
  431. self.assertEqual(self.page.final_clicks, 0)
  432. def test_changed_candidate_is_not_reselected_during_readback(self):
  433. for changes in ({"candidateReady": False}, {"dayNegative": True},
  434. {"activeCapacityMatches": False}, {"activeIdMatches": False},
  435. {"activeCount": 2}, {"activeTimeMatches": False}):
  436. with self.subTest(changes=changes):
  437. self.page.overrides = changes
  438. with self.assertRaises(CalendarBookError):
  439. verify_precommit_selection(self.page, runtime_service=SERVICE, approval=self.target.approval)
  440. self.assertEqual(self.page.clicks, 0)
  441. self.assertEqual(self.page.final_clicks, 0)
  442. class ProductionBoundaryTests(unittest.TestCase):
  443. def test_production_final_flag_still_rejected_without_browser_creation(self):
  444. from plugins.ita_plugin import ItaPlugin
  445. from vs_types import BizLogicError
  446. # set_config rejects the flag before touching browser/profile paths.
  447. plugin = ItaPlugin.__new__(ItaPlugin)
  448. for value in (True, 1, "true"):
  449. with self.subTest(value=value), self.assertRaises(BizLogicError):
  450. plugin.set_config(SimpleNamespace(free_config={"final_submit_enabled": value}))
  451. def test_query_and_prefinal_tools_do_not_dispatch_final(self):
  452. root = Path(__file__).resolve().parents[1]
  453. from test.ita_source_sections import section
  454. sources = [section("calendar_query")]
  455. sources += [(root / name).read_text() for name in (
  456. "tools/debug_ita_book_gate.py", "tools/debug_ita_calendar_gate.py")]
  457. for source in sources:
  458. tree = ast.parse(source)
  459. for node in ast.walk(tree):
  460. if isinstance(node, ast.ImportFrom):
  461. self.assertFalse({a.name for a in node.names} & {
  462. "submit_final", "FinalBookingAttempt", "NativeFinalSubmitter"})
  463. if isinstance(node, ast.Call) and isinstance(node.func, ast.Name):
  464. self.assertNotIn(node.func.id, {"submit_final", "FinalBookingAttempt", "NativeFinalSubmitter"})
  465. # Actual composed JavaScript in a synthetic DOM. Slot snapshot logic is covered
  466. # by the existing Book JS suite; this harness reuses that suite's DOM below.
  467. NATIVE_JS_HARNESS = r"""
  468. const fs = require('fs'), vm = require('vm');
  469. const {script, mode} = JSON.parse(fs.readFileSync(0, 'utf8'));
  470. let clicks = 0;
  471. const classes = (...names) => ({contains: name => names.includes(name)});
  472. const input = {type: 'hidden', id: 'idHiddenFasciaServizio', value: '80001001'};
  473. const slot = {
  474. isConnected: true, classList: classes('fascia', 'act'),
  475. hasAttribute: () => false, getAttribute: () => null,
  476. querySelector: () => null,
  477. querySelectorAll: selector => selector === 'input' ? [input] :
  478. [{textContent: '10:05 - 11:05'}, {textContent: '(1)'}],
  479. getBoundingClientRect: () => ({left: 0, right: 100, top: 0, bottom: 40}),
  480. contains: e => e === slot,
  481. };
  482. const link = {dataset: {date: '2026-10-13'}, classList: classes('input-async-abilitato'),
  483. hasAttribute: () => false, getAttribute: () => null};
  484. const content = {dataset: {date: '2026-10-13'}, querySelectorAll: () => [slot], contains: e => e === slot};
  485. const button = {isConnected: true, disabled: true, dataset: {coordinateFinalGuard: 'enabled'},
  486. setAttribute: () => {}, removeAttribute: () => {}, click: () => {
  487. if (button.disabled) throw new Error('clicked while disabled');
  488. clicks++;
  489. if (mode === 'throw_after_click') throw new Error('lost acknowledgement');
  490. }};
  491. const service = {value: '7002'};
  492. if (mode === 'wrong_service') service.value = 'other';
  493. if (mode === 'wrong_day') link.dataset.date = '2026-10-14';
  494. if (mode === 'wrong_id') input.value = '80002002';
  495. if (mode === 'unavailable') slot.classList = classes('fascia', 'act', 'notAvailableFascia');
  496. if (mode === 'unguarded') button.disabled = false;
  497. if (mode === 'consumed') button.dataset.coordinateFinalAttemptConsumed = 'true';
  498. const document = {
  499. querySelectorAll: selector => ({
  500. '#idServizio': [service], '#btnPrenotaNoOtp': mode === 'duplicate_button' ? [button, button] : [button],
  501. '.events a.selected': [link], '.events-content li.selected': [content],
  502. '.events a[data-date]': [link], '.fascia.act': mode === 'no_active' ? [] : [slot],
  503. })[selector] || [],
  504. querySelector: () => link, elementFromPoint: () => slot,
  505. };
  506. const window = {location: {origin: 'https://prenotami.esteri.it', pathname: '/BookingCalendar'},
  507. innerWidth: 1000, innerHeight: 800,
  508. getComputedStyle: () => ({display: 'block', visibility: 'visible', pointerEvents: 'auto', opacity: '1'})};
  509. const context = vm.createContext({document, window});
  510. const action = new vm.Script('(function(){' + script + '})').runInContext(context);
  511. let result, thrown = false;
  512. try { result = action('7002', '2026-10-13', '80001001', '10:05 - 11:05', 1); }
  513. catch (_) { thrown = true; }
  514. if (mode === 'twice') action('7002', '2026-10-13', '80001001', '10:05 - 11:05', 1);
  515. process.stdout.write(JSON.stringify({clicks, disabled: button.disabled,
  516. consumed: Boolean(button.dataset.coordinateFinalAttemptConsumed), result, thrown}));
  517. """
  518. @unittest.skipUnless(shutil.which("node"), "node required for real JS offline execution")
  519. class NativeFinalJavaScriptTests(unittest.TestCase):
  520. def run_js(self, mode):
  521. proc = subprocess.run([shutil.which("node"), "-e", NATIVE_JS_HARNESS],
  522. input=json.dumps({"script": NATIVE_FINAL_SCRIPT, "mode": mode}),
  523. text=True, capture_output=True, timeout=10)
  524. self.assertEqual(proc.returncode, 0, proc.stderr)
  525. return json.loads(proc.stdout)
  526. def test_native_click_once_and_reguard(self):
  527. for mode in ("normal", "twice", "throw_after_click"):
  528. with self.subTest(mode=mode):
  529. state = self.run_js(mode)
  530. self.assertEqual(state["clicks"], 1)
  531. self.assertTrue(state["disabled"])
  532. self.assertTrue(state["consumed"])
  533. def test_unsafe_state_does_not_click(self):
  534. for mode in ("wrong_service", "wrong_day", "wrong_id", "unavailable", "unguarded",
  535. "consumed", "duplicate_button", "no_active"):
  536. with self.subTest(mode=mode):
  537. state = self.run_js(mode)
  538. self.assertFalse(state["thrown"])
  539. self.assertEqual(state["clicks"], 0)
  540. self.assertEqual(state["result"], {"clicked": False})
  541. if __name__ == "__main__":
  542. unittest.main()