"""Real read-port orchestration + receipt parsers, offline browser only.""" import copy import ast import traceback import unittest from dataclasses import replace from pathlib import Path from types import MethodType, SimpleNamespace from unittest.mock import Mock, patch from plugins.ita_plugin import FinalBookingAttempt, FinalBookingError, FinalOutcomeUnknown, SubmissionSignal from plugins.ita_plugin import FinalReceiptReadPort, LIST_URL, MAX_DETAIL_READS from plugins.ita_plugin import ItaPlugin from plugins.ita_plugin import ItaCapability, ItaRouteConfig, CalendarScanConfig from plugins.ita_plugin import DETAIL_READ_SCRIPT, LIST_READ_SCRIPT from test.test_ita_booking_final import target from test.test_ita_reservation import detail, listing class ReceiptTab: def __init__(self, browser, index): self.browser = browser self.tab_id = f"receipt-{index}" self.url = "about:blank" self.urls = [] self.list_visits = 0 self.close = Mock(side_effect=lambda: browser.on_close(self)) def get(self, url, *, retry, timeout): assert retry == 0 and timeout == 30 self.urls.append(url) self.url = url self.list_visits += url == LIST_URL self.browser.on_get(self) return True def run_js(self, script): if script == LIST_READ_SCRIPT: raw = self.browser.after if self.list_visits > 1 and self.browser.after else self.browser.raw return copy.deepcopy(raw) if script == DETAIL_READ_SCRIPT: return copy.deepcopy(self.browser.receipts.get(self.url, self.browser.receipt)) raise AssertionError("Unexpected non-receipt browser action") class Browser: def __init__(self): self.id = "synthetic-browser" self.raw, self.receipt = listing(), detail() self.receipts = {} self.after = None self.pages = [] self.on_get = lambda page: None self.on_close = lambda page: None self.new_tab = Mock(side_effect=self.open_tab) def open_tab(self, *, background, new_context): assert background is True and new_context is False tab = ReceiptTab(self, len(self.pages)) self.pages.append(tab) return tab class FinalReadPortTests(unittest.TestCase): def setUp(self): self.sleeper = patch("plugins.ita_plugin.time.sleep").start() self.addCleanup(patch.stopall) self.browser = Browser() self.main = SimpleNamespace(browser=self.browser, tab_id="calendar-tab", url="https://prenotami.esteri.it/BookingCalendar") self.main.get = Mock(side_effect=AssertionError("Calendar navigation forbidden")) self.main.close = Mock(side_effect=AssertionError("Calendar close forbidden")) self.main.run_js = Mock(side_effect=AssertionError("Calendar mutation forbidden")) approval = target().approval self.route = ItaRouteConfig("slot.fixture.it.tourist", 7001, ItaCapability.SINGLE_SCHENGEN_TOURISM, CalendarScanConfig(3)) self.plugin = SimpleNamespace(page=self.main, session_create_time=1, is_healthy=True, config=SimpleNamespace(account=SimpleNamespace(username="Applicant@example.test")), free_config={"final_submit_enabled": False}, last_booking_precommit=approval, _calendar_query_route_key=None) self.plugin._calendar_book_prepared_context = ( id(self.plugin), self.main, "applicant@example.test", 1, self.route, "7001", self.main.tab_id) self.plugin._resolve_route = lambda apt: self.route self.plugin._book_final_configuration_valid = MethodType(ItaPlugin._book_final_configuration_valid, self.plugin) self.plugin._calendar_book_context_matches = MethodType(ItaPlugin._calendar_book_context_matches, self.plugin) self.port = FinalReceiptReadPort(self.plugin, self.route) def test_constructor_never_opens_or_changes_browser(self): self.browser.new_tab.assert_not_called() self.assertTrue(self.port.session_is_current()) self.assertEqual(self.port.target.applicant, "applicant@example.test") self.assertEqual(self.port.target.service_id, "7001") def test_real_parsers_create_bound_cancelled_baseline_without_invented_ids(self): snapshot = self.port() self.assertTrue(snapshot.complete) self.assertEqual(snapshot.applicant, self.port.target.applicant) self.assertEqual(snapshot.session_key, self.port.target.session_key) row, = snapshot.records self.assertIsNone(row.service_id) self.assertIsNone(row.time_label) self.assertEqual(row.appointment_time, "10:25") self.assertRegex(row.receipt_fingerprint, r"^[0-9a-f]{64}$") self.assertNotIn("SYNTHETIC-REFERENCE", repr(snapshot)) self.assertEqual(self.browser.pages[0].urls, [LIST_URL, listing()["tables"][0]["rows"][0]["detailUrl"], LIST_URL]) self.browser.pages[0].close.assert_called_once() self.main.get.assert_not_called() self.main.close.assert_not_called() self.main.run_js.assert_not_called() def test_no_query_preparation_can_be_used(self): self.plugin._calendar_query_route_key = "slot.fixture.it.tourist" with self.assertRaises(FinalBookingError): FinalReceiptReadPort(self.plugin, self.route) self.browser.new_tab.assert_not_called() def test_capture_requires_precommit_and_final_disabled(self): for change in (lambda: setattr(self.plugin, "last_booking_precommit", None), lambda: self.plugin.free_config.update(final_submit_enabled=True)): self.setUp() change() with self.assertRaises(FinalBookingError): FinalReceiptReadPort(self.plugin, self.route) def test_each_binding_change_rejects_before_opening_a_tab(self): changes = ( lambda: setattr(self.plugin.config.account, "username", "OTHER"), lambda: setattr(self.plugin, "session_create_time", 2), lambda: setattr(self.main, "tab_id", "OTHER"), lambda: setattr(self.browser, "id", "OTHER"), lambda: setattr(self.plugin, "is_healthy", False), lambda: setattr(self.plugin, "last_booking_precommit", replace(self.port.target.approval)), lambda: setattr(self, "route", replace(self.route, service_id=8001)), ) for change in changes: self.setUp() change() with self.assertRaises(FinalBookingError): self.port() self.browser.new_tab.assert_not_called() def test_context_change_during_read_closes_only_owned_tab(self): self.browser.on_get = lambda page: setattr(self.plugin, "session_create_time", 2) with self.assertRaises(FinalBookingError): self.port() self.browser.pages[0].close.assert_called_once() self.main.close.assert_not_called() def test_factory_returning_calendar_or_foreign_tab_is_not_owned(self): for candidate in (self.main, SimpleNamespace(browser=Browser(), tab_id="foreign", close=Mock())): self.browser.new_tab.side_effect = None self.browser.new_tab.return_value = candidate with self.assertRaises(FinalBookingError): self.port() candidate.close.assert_not_called() def test_wrong_origin_login_redirect_or_detail_identity_rejects(self): self.browser.on_get = lambda page: setattr(page, "url", "https://iam.esteri.it/signin/") with self.assertRaises(FinalBookingError): self.port() self.browser.pages[0].close.assert_called_once() self.browser.on_get = lambda page: None self.browser.receipt["fields"]["Codice Prenotazione"] = "OTHER" with self.assertRaises(FinalBookingError): self.port() self.browser.pages[-1].close.assert_called_once() def test_list_change_during_read_rejects(self): self.browser.after = listing() self.browser.after["tables"][0]["rows"][0]["time"] = "10:26" with self.assertRaises(FinalBookingError): self.port() def test_unknown_status_and_code_do_not_become_active_or_cancelled(self): self.browser.raw["tables"][0]["rows"][0]["status"] = "Confermata" with self.assertRaises(FinalBookingError): self.port() self.assertEqual(self.browser.pages[0].urls, [LIST_URL]) self.browser.raw = listing() self.browser.receipt["statusCode"] = "1" with self.assertRaises(FinalBookingError): self.port() def test_cancelled_display_metadata_changes_are_preserved_in_fingerprint(self): first = self.port() self.browser.receipt["fields"]["Tipo Prenotazione"] = "Changed type" second = self.port() self.assertNotEqual(first.records[0], second.records[0]) self.assertNotEqual(first.records[0].receipt_fingerprint, second.records[0].receipt_fingerprint) def test_detail_limit_never_produces_partial_snapshot(self): main = self.browser.raw["tables"][0] base = main["rows"][0] count = MAX_DETAIL_READS + 1 main["rows"] = [{**base, "reference": f"REF-{i}", "detailUrl": f"https://prenotami.esteri.it/ReservationDetail/Index/{i}"} for i in range(count)] main.update(count=count) main["info"].update(recordsTotal=count, recordsDisplay=count, end=10, pages=3) with self.assertRaises(FinalBookingError): self.port() self.assertEqual(self.browser.pages[0].urls, [LIST_URL]) def test_empty_verified_history_can_be_read(self): table = self.browser.raw["tables"][0] table.update(count=0, rows=[]) table["info"].update(recordsTotal=0, recordsDisplay=0, end=0, pages=0) self.assertEqual(self.port().records, ()) self.assertEqual(self.browser.pages[0].urls, [LIST_URL, LIST_URL]) def test_cleanup_failure_poisoned_port_cannot_be_reused(self): def bad_close(page): raise RuntimeError("PRIVATE-CONTENT") self.browser.on_close = bad_close with self.assertRaises(FinalBookingError) as caught: self.port() self.assertNotIn("PRIVATE", "".join(traceback.format_exception(caught.exception))) self.assertFalse(self.port.session_is_current()) with self.assertRaises(FinalBookingError): self.port() self.assertEqual(self.browser.new_tab.call_count, 1) def test_error_or_keyboard_interrupt_always_closes_owned_tab(self): for error in (RuntimeError("PRIVATE-CONTENT"), KeyboardInterrupt()): self.setUp() self.browser.on_get = Mock(side_effect=error) with self.assertRaises((FinalBookingError, KeyboardInterrupt)): self.port() self.browser.pages[0].close.assert_called_once() def test_changed_calendar_during_cleanup_cannot_return_snapshot(self): self.browser.on_close = lambda page: setattr(self.main, "url", "https://prenotami.esteri.it/UserArea") with self.assertRaises(FinalBookingError): self.port() def test_observer_brackets_navigation_and_finishes_before_owned_close(self): events = [] def observe(page): self.assertEqual(page.url, "about:blank") events.append("start") return lambda: events.append("finish") self.browser.on_get = lambda page: events.append("get") self.browser.on_close = lambda page: events.append("close") port = FinalReceiptReadPort(self.plugin, self.route, observe_tab=observe) port() self.assertEqual(events, ["start", "get", "get", "get", "finish", "close"]) def test_observer_failure_or_interrupt_closes_tab_and_releases_lock(self): for error in (RuntimeError("PRIVATE-CONTENT"), KeyboardInterrupt()): self.setUp() finish = Mock(side_effect=error) port = FinalReceiptReadPort(self.plugin, self.route, observe_tab=lambda page: finish) with self.assertRaises((FinalBookingError, KeyboardInterrupt)): port() self.browser.pages[0].close.assert_called_once() self.assertFalse(port.session_is_current()) self.assertFalse(port._lock.locked()) def test_read_port_has_no_booking_or_cookie_operations(self): from test.ita_source_sections import section tree = ast.parse(section("final_read_port")) for node in ast.walk(tree): if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute): self.assertNotIn(node.func.attr, {"click", "submit", "input", "book", "query", "cookies", "quit"}) def test_read_port_composes_with_final_core_without_retries(self): submit = Mock(return_value=SubmissionSignal.REJECTED) attempt = FinalBookingAttempt(self.port.target, read_reservations=self.port, submit_native=submit, session_is_current=self.port.session_is_current) with self.assertRaises(FinalBookingError): attempt.execute() submit.assert_not_called() result = attempt.execute(enabled=True) # Explicit offline double; no native submit. self.assertFalse(result.success) self.assertEqual(attempt.state, "rejected") submit.assert_called_once() with self.assertRaises(FinalBookingError): attempt.execute(enabled=True) def test_new_unverified_live_receipt_leaves_outcome_unknown_and_reconcile_only(self): def submitted(): self.browser.raw["tables"][0]["rows"][0]["status"] = "Confermata" return SubmissionSignal.ACCEPTED submit = Mock(side_effect=submitted) attempt = FinalBookingAttempt(self.port.target, read_reservations=self.port, submit_native=submit, session_is_current=self.port.session_is_current) with self.assertRaises(FinalOutcomeUnknown): attempt.execute(enabled=True) with self.assertRaises(FinalOutcomeUnknown): attempt.reconcile() with self.assertRaises(FinalBookingError): attempt.execute(enabled=True) submit.assert_called_once() self.assertEqual(attempt.state, "unknown") def test_cancelled_detail_metadata_change_after_write_cannot_be_rejected_as_no_change(self): def submitted(): self.browser.receipt["fields"]["Tipo Prenotazione"] = "Changed type" return SubmissionSignal.REJECTED attempt = FinalBookingAttempt(self.port.target, read_reservations=self.port, submit_native=submitted, session_is_current=self.port.session_is_current) with self.assertRaises(FinalOutcomeUnknown): attempt.execute(enabled=True) if __name__ == "__main__": unittest.main()