test_ita_final_evidence.py 10 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233
  1. """Offline one-shot discovery; no credentials, browser launch or website calls."""
  2. import json
  3. import os
  4. import tempfile
  5. import unittest
  6. from concurrent.futures import ThreadPoolExecutor
  7. from contextlib import redirect_stdout
  8. from io import StringIO
  9. from pathlib import Path
  10. from unittest.mock import Mock, patch
  11. from plugins.ita_plugin import FinalBookingError, SubmissionSignal
  12. from test import test_ita_final_read_port as port_fixtures
  13. from test.test_ita_reservation import listing, detail
  14. from tools import ita_final_evidence as evidence
  15. class ClaimTests(unittest.TestCase):
  16. def setUp(self):
  17. self.temp = tempfile.TemporaryDirectory()
  18. self.addCleanup(self.temp.cleanup)
  19. self.path = Path(self.temp.name) / "private" / "once.claim"
  20. def test_preflight_does_not_create_directory(self):
  21. evidence.require_unused_claim(self.path)
  22. self.assertFalse(self.path.parent.exists())
  23. def test_claim_is_exclusive_private_and_contains_no_identity(self):
  24. evidence.claim_once(self.path)
  25. self.assertEqual(json.loads(self.path.read_text()), {
  26. "schema": 1, "state": "possibly_submitted", "automaticRetry": False})
  27. self.assertEqual(self.path.stat().st_mode & 0o777, 0o600)
  28. self.assertEqual(self.path.parent.stat().st_mode & 0o777, 0o700)
  29. with self.assertRaises(FileExistsError):
  30. evidence.claim_once(self.path)
  31. with self.assertRaises(FinalBookingError):
  32. evidence.require_unused_claim(self.path)
  33. def test_partial_claim_blocks_and_is_not_removed_after_fsync_failure(self):
  34. with patch.object(evidence.os, "fsync", side_effect=OSError("synthetic")):
  35. with self.assertRaises(OSError):
  36. evidence.claim_once(self.path)
  37. with self.assertRaises(FinalBookingError):
  38. evidence.require_unused_claim(self.path)
  39. def test_dangling_symlink_and_directory_are_blocked(self):
  40. self.path.parent.mkdir()
  41. self.path.symlink_to(self.path.parent / "missing")
  42. with self.assertRaises(FinalBookingError):
  43. evidence.require_unused_claim(self.path)
  44. with self.assertRaises(FileExistsError):
  45. evidence.claim_once(self.path)
  46. self.assertFalse((self.path.parent / "missing").exists())
  47. def test_symlink_parent_is_not_written_through(self):
  48. other = Path(self.temp.name) / "other"
  49. other.mkdir()
  50. self.path.parent.symlink_to(other, target_is_directory=True)
  51. with self.assertRaises(ValueError):
  52. evidence.claim_once(self.path)
  53. self.assertEqual(list(other.iterdir()), [])
  54. def test_concurrent_claims_have_one_winner(self):
  55. def claim(_):
  56. try:
  57. evidence.claim_once(self.path)
  58. return True
  59. except FileExistsError:
  60. return False
  61. with ThreadPoolExecutor(max_workers=4) as pool:
  62. self.assertEqual(sum(pool.map(claim, range(4))), 1)
  63. class FinalEvidenceTests(unittest.TestCase):
  64. def setUp(self):
  65. port_fixtures.FinalReadPortTests.setUp(self)
  66. self.temp = tempfile.TemporaryDirectory()
  67. self.addCleanup(self.temp.cleanup)
  68. self.path = Path(self.temp.name) / "private" / "once.claim"
  69. self.check = patch.object(evidence, "verify_precommit_selection").start()
  70. self.native = Mock(return_value=SubmissionSignal.ACCEPTED)
  71. self.factory = patch.object(evidence, "NativeFinalSubmitter", return_value=self.native).start()
  72. self.output = StringIO()
  73. patcher = redirect_stdout(self.output)
  74. patcher.__enter__()
  75. self.addCleanup(lambda: patcher.__exit__(None, None, None))
  76. def run_object(self):
  77. return evidence.FinalEvidenceRun(self.plugin, self.route, claim_path=self.path)
  78. def confirm(self, _prompt):
  79. slot = self.plugin.last_booking_precommit.candidate
  80. return f"BOOK {slot.day.isoformat()} {slot.time_label}"
  81. def test_decline_never_reads_or_submits_or_claims(self):
  82. run = self.run_object()
  83. report = run.execute(confirm=lambda _: "no")
  84. self.assertEqual(report["outcome"], "confirmation_declined")
  85. self.assertFalse(self.path.exists())
  86. self.native.assert_not_called()
  87. self.browser.new_tab.assert_not_called()
  88. with self.assertRaises(FinalBookingError):
  89. run.execute(confirm=self.confirm)
  90. def test_existing_fence_blocks_before_prompt(self):
  91. evidence.claim_once(self.path)
  92. prompt = Mock()
  93. with self.assertRaises(FinalBookingError):
  94. self.run_object().execute(confirm=prompt)
  95. prompt.assert_not_called()
  96. self.native.assert_not_called()
  97. def test_unknown_response_uses_core_and_persists_fence_before_click(self):
  98. def native():
  99. self.assertTrue(self.path.exists())
  100. return SubmissionSignal.UNKNOWN
  101. self.native.side_effect = native
  102. run = self.run_object()
  103. report = run.execute(confirm=self.confirm)
  104. self.native.assert_called_once()
  105. self.assertTrue(report["attempted"])
  106. self.assertEqual(report["outcome"], "unknown_do_not_retry")
  107. self.assertTrue(report["receiptEvidence"]["readVerified"])
  108. self.assertTrue(report["receiptEvidence"]["historicalRecordsUnchanged"])
  109. self.assertFalse(report["bookingConfirmed"])
  110. with self.assertRaises(FinalBookingError):
  111. self.run_object().execute(confirm=self.confirm)
  112. self.assertTrue(self.path.exists())
  113. def test_rejection_is_not_a_retry_instruction(self):
  114. self.native.return_value = SubmissionSignal.REJECTED
  115. report = self.run_object().execute(confirm=self.confirm)
  116. self.assertEqual(report["outcome"], "rejected_do_not_retry")
  117. self.assertTrue(self.path.exists())
  118. self.native.assert_called_once()
  119. def test_native_exception_or_interrupt_still_leaves_fence(self):
  120. for error in (RuntimeError("SECRET"), KeyboardInterrupt()):
  121. with self.subTest(error=type(error).__name__):
  122. path = Path(self.temp.name) / type(error).__name__ / "claim"
  123. self.native.side_effect = error
  124. run = evidence.FinalEvidenceRun(self.plugin, self.route, claim_path=path)
  125. if isinstance(error, KeyboardInterrupt):
  126. with self.assertRaises(KeyboardInterrupt):
  127. run.execute(confirm=self.confirm)
  128. else:
  129. run.execute(confirm=self.confirm)
  130. self.assertTrue(path.exists())
  131. self.assertTrue(run.possibly_submitted)
  132. self.assertFalse(run.report["bookingConfirmed"])
  133. self.assertNotIn("SECRET", self.output.getvalue())
  134. def test_claim_failure_never_calls_native(self):
  135. with patch.object(evidence, "claim_once", side_effect=OSError("PRIVATE")):
  136. with self.assertRaises(FinalBookingError):
  137. self.run_object().execute(confirm=self.confirm)
  138. self.native.assert_not_called()
  139. self.assertNotIn("PRIVATE", self.output.getvalue())
  140. def test_unknown_old_receipt_blocks_before_claim(self):
  141. self.browser.raw["tables"][0]["rows"][0]["status"] = "Unverified"
  142. with self.assertRaises(FinalBookingError):
  143. self.run_object().execute(confirm=self.confirm)
  144. self.native.assert_not_called()
  145. self.assertFalse(self.path.exists())
  146. def test_selection_changes_during_confirmation_blocks_before_claim(self):
  147. def confirm(prompt):
  148. answer = self.confirm(prompt)
  149. self.check.side_effect = RuntimeError("changed")
  150. return answer
  151. with self.assertRaises(FinalBookingError):
  152. self.run_object().execute(confirm=confirm)
  153. self.assertFalse(self.path.exists())
  154. self.native.assert_not_called()
  155. def test_new_unknown_receipt_is_observed_without_assigning_success_or_leaking_reference(self):
  156. # Empty initial baseline, then one new unknown receipt. Values are
  157. # synthetic evidence shapes, NOT an asserted mapping for the live site.
  158. table = self.browser.raw["tables"][0]
  159. table["rows"], table["count"] = [], 0
  160. table["info"].update(pages=0, end=0, recordsTotal=0, recordsDisplay=0)
  161. def native():
  162. self.browser.raw = listing()
  163. self.browser.receipt = detail()
  164. self.browser.raw["tables"][0]["rows"][0]["status"] = "SYNTHETIC-NEW-STATE"
  165. self.browser.receipt["fields"]["Stato"] = "SYNTHETIC-NEW-STATE"
  166. self.browser.receipt["statusCode"] = "999"
  167. return SubmissionSignal.ACCEPTED
  168. self.native.side_effect = native
  169. run = self.run_object()
  170. report = run.execute(confirm=self.confirm)
  171. observation = report["receiptEvidence"]
  172. self.assertTrue(observation["readVerified"])
  173. self.assertEqual(observation["newRecordCount"], 1)
  174. self.assertEqual(observation["newRecords"][0]["classifiedState"], "unknown")
  175. self.assertEqual(observation["newRecords"][0]["statusCode"], "999")
  176. self.assertFalse(report["bookingConfirmed"])
  177. self.assertNotIn("SYNTHETIC-REFERENCE", json.dumps(report))
  178. self.assertNotIn("synthetic-link", json.dumps(report))
  179. self.assertEqual(self.main.url, "https://prenotami.esteri.it/BookingCalendar")
  180. self.assertTrue(all(p.close.call_count == 1 for p in self.browser.pages))
  181. def test_unknown_observation_does_not_relax_strict_read_port(self):
  182. self.browser.raw["tables"][0]["rows"][0]["status"] = "Unverified"
  183. self.browser.receipt["fields"]["Stato"] = "Unverified"
  184. self.browser.receipt["statusCode"] = "999"
  185. observation = self.port.observe_receipts()
  186. self.assertEqual(observation.records[0][1].state.value, "unknown")
  187. with self.assertRaises(FinalBookingError):
  188. self.port()
  189. def test_observation_mismatch_and_context_change_are_blocked(self):
  190. self.browser.receipt["fields"]["Ora"] = "12:00"
  191. with self.assertRaises(FinalBookingError):
  192. self.port.observe_receipts()
  193. self.browser.new_tab.reset_mock()
  194. self.plugin.is_healthy = False
  195. with self.assertRaises(FinalBookingError):
  196. self.port.observe_receipts()
  197. self.browser.new_tab.assert_not_called()
  198. def test_review_keeps_browser_until_reader_returns(self):
  199. reader = Mock(return_value="")
  200. evidence.wait_for_receipt_review(reader=reader)
  201. reader.assert_called_once()
  202. self.assertIn("Do NOT rerun", self.output.getvalue())
  203. self.main.close.assert_not_called()
  204. if __name__ == "__main__":
  205. unittest.main()