"""Submission-to-receipt wiring, offline only. No historical attempt is replayed.""" import copy import json import tempfile import unittest from contextlib import redirect_stdout from dataclasses import replace from datetime import date, time from io import StringIO from pathlib import Path from unittest.mock import Mock, patch from plugins.ita_booking_final import ( FinalBookingAttempt, FinalBookingError, FinalOutcomeUnknown, NativeFinalSubmitter, ReservationState, SubmissionSignal, VerifiedSubmission, inspect_final_packet, ) from plugins.ita_final_read_port import FinalReceiptReadPort from test import test_ita_final_read_port as fixtures from test.test_ita_booking_final import final_packet, NativePage, target from test.test_ita_reservation import confirmed_detail, confirmed_listing from tools import ita_final_evidence as evidence class AttributionTests(unittest.TestCase): def setUp(self): fixtures.FinalReadPortTests.setUp(self) # Match the observed business shape, with synthetic IDs/account/links. old = self.plugin.last_booking_precommit day = date(2026, 9, 3) self.plugin.last_booking_precommit = replace(old, calendar_day=replace(old.calendar_day, day=day), candidate=replace(old.candidate, day=day, start_time=time(9, 15), end_time=time(10))) self.main.url += "?selectedService=Visti%20Nazionali%20e%20Schengen" self.port = FinalReceiptReadPort(self.plugin, self.route) def add_confirmed(self): self.browser.raw = confirmed_listing() self.browser.receipts[self.browser.raw["tables"][0]["rows"][1]["detailUrl"]] = confirmed_detail() def attempt(self, *, change=None, signal=SubmissionSignal.ACCEPTED, proof=True): def submit(): if proof: self.port.record_submission(inspect_final_packet(final_packet(self.port.target), self.port.target)[1]) self.add_confirmed() if change: change() return signal self.submit = Mock(side_effect=submit) return FinalBookingAttempt(self.port.target, read_reservations=self.port, submit_native=self.submit, session_is_current=self.port.session_is_current) def test_real_shape_returns_success_and_assigned_time_without_fabricated_receipt_fields(self): attempt = self.attempt() result = attempt.execute(enabled=True) self.assertTrue(result.success) self.assertEqual(result.book_date, "2026-09-03") self.assertEqual(result.book_time, "09:26") self.assertEqual(result.urn, "CONFIRMED-SYNTHETIC") snapshot = self.port() record = next(r for r in snapshot.records if r.state is ReservationState.ACTIVE) self.assertIsNone(record.service_id) self.assertIsNone(record.time_label) self.assertEqual(record.submission.target, self.port.target) self.assertTrue(all(p.close.call_count == 1 for p in self.browser.pages)) self.main.get.assert_not_called() self.submit.assert_called_once() with self.assertRaises(FinalBookingError): attempt.execute(enabled=True) def test_unknown_response_with_matched_request_and_new_confirmed_receipt_can_succeed(self): self.assertTrue(self.attempt(signal=SubmissionSignal.UNKNOWN).execute(enabled=True).success) def test_rejected_response_conflicting_with_new_receipt_remains_unknown(self): with self.assertRaises(FinalOutcomeUnknown): self.attempt(signal=SubmissionSignal.REJECTED).execute(enabled=True) def test_active_receipt_without_request_proof_cannot_be_attributed(self): with self.assertRaises(FinalOutcomeUnknown): self.attempt(proof=False).execute(enabled=True) def test_baseline_active_receipt_still_blocks_before_any_submission(self): self.add_confirmed() attempt = self.attempt() with self.assertRaises(FinalBookingError): attempt.execute(enabled=True) self.submit.assert_not_called() def test_proof_requires_baseline_current_session_and_exact_target(self): proof = VerifiedSubmission(self.port.target) with self.assertRaises(FinalBookingError): self.port.record_submission(proof) self.port() for key, value in (("session_key", "another"), ("tab_id", "other"), ("service_id", "other"), ("service_name", "other"), ("applicant", "other@example.test")): with self.subTest(key=key), self.assertRaises(FinalBookingError): self.port.record_submission(VerifiedSubmission(replace(self.port.target, **{key: value}))) self.plugin.session_create_time += 1 with self.assertRaises(FinalBookingError): self.port.record_submission(proof) def test_displayed_service_is_read_from_calendar_not_invented_from_route(self): self.assertEqual(self.port.target.service_name, "Visti Nazionali e Schengen") for query in ("", "?selectedService=one&selectedService=two"): self.main.url = self.main.url.split("?")[0] + query port = FinalReceiptReadPort(self.plugin, self.route) self.assertIsNone(port.target.service_name) port() with self.assertRaises(FinalBookingError): port.record_submission(VerifiedSubmission(port.target)) def test_service_date_time_type_and_status_mismatch_never_become_success(self): # Recreate for each trial: a final attempt cannot be reused. cases = [("service", "Servizio Erogato", "Wrong service"), ("date", "Data", "4 settembre 2026"), ("time", "Ora", "10:01"), ("status", "Stato", "Unverified"), (None, "Tipo Prenotazione", "Prenotazione Multipla"), (None, "statusCode", "3")] for row_key, detail_key, value in cases: with self.subTest(key=detail_key): self.setUp() def change(): raw = self.browser.raw["tables"][0]["rows"][1] d = self.browser.receipts[raw["detailUrl"]] if row_key: raw[row_key] = value (d if detail_key == "statusCode" else d["fields"])[detail_key] = value with self.assertRaises(FinalOutcomeUnknown): self.attempt(change=change).execute(enabled=True) def test_modified_history_or_multiple_new_receipts_remain_unknown(self): for mode in ("history", "multiple"): with self.subTest(mode=mode): self.setUp() def change(): table = self.browser.raw["tables"][0] if mode == "history": table["rows"][0]["time"] = "10:26" self.browser.receipt["fields"]["Ora"] = "10:26" else: row = {**table["rows"][1], "reference": "SECOND-NEW", "detailUrl": "https://prenotami.esteri.it/ReservationDetail/Index/second-new"} d = copy.deepcopy(self.browser.receipts[table["rows"][1]["detailUrl"]]) d["path"] = "/ReservationDetail/Index/second-new" d["fields"]["Codice Prenotazione"] = "SECOND-NEW" table["rows"].append(row) table["count"] = 3 table["info"].update(recordsTotal=3, recordsDisplay=3, end=3) self.browser.receipts[row["detailUrl"]] = d with self.assertRaises(FinalOutcomeUnknown): self.attempt(change=change).execute(enabled=True) def test_current_evidence_controller_reuses_core_and_keeps_claim_after_success(self): with tempfile.TemporaryDirectory() as directory, \ patch.object(evidence, "verify_precommit_selection"), redirect_stdout(StringIO()): run = evidence.FinalEvidenceRun(self.plugin, self.route, claim_path=Path(directory) / "claim", verify_submission=lambda: True) signal, proof, reason = inspect_final_packet(final_packet(run.port.target), run.port.target) native = Mock(side_effect=lambda: (self.add_confirmed(), signal)[1]) native.submitted_selection = proof native.diagnostic = {"requestMatched": True, "reason": reason} with patch.object(evidence, "NativeFinalSubmitter", return_value=native): report = run.execute(confirm=lambda prompt: prompt.split("'")[1]) self.assertTrue(run.result.success) self.assertTrue(report["bookingConfirmed"]) self.assertTrue(report["receiptEvidence"]["bookingConfirmed"]) self.assertEqual(report["confirmedTime"], "09:26") self.assertTrue(run.claim_path.exists()) self.assertNotIn("CONFIRMED-SYNTHETIC", json.dumps(report)) self.assertNotIn(run.port.target.applicant, json.dumps(report)) def test_missing_single_request_audit_prevents_attribution(self): with tempfile.TemporaryDirectory() as directory, \ patch.object(evidence, "verify_precommit_selection"), redirect_stdout(StringIO()): run = evidence.FinalEvidenceRun(self.plugin, self.route, claim_path=Path(directory) / "claim", verify_submission=lambda: False) native = Mock(side_effect=lambda: (self.add_confirmed(), SubmissionSignal.ACCEPTED)[1]) native.submitted_selection = VerifiedSubmission(run.port.target) native.diagnostic = {"requestMatched": True, "reason": "recognized"} with patch.object(evidence, "NativeFinalSubmitter", return_value=native): report = run.execute(confirm=lambda prompt: prompt.split("'")[1]) self.assertFalse(report["bookingConfirmed"]) self.assertFalse(report["receiptEvidence"]["bookingConfirmed"]) self.assertTrue(run.claim_path.exists()) class PacketEvidenceTests(unittest.TestCase): def test_diagnostic_preserves_matched_request_for_unknown_response_without_raw_data(self): t = target() p = final_packet(t) p.response.raw_body = "SECRET-not-json" signal, proof, reason = inspect_final_packet(p, t) self.assertIs(signal, SubmissionSignal.UNKNOWN) self.assertEqual(proof.target, t) self.assertEqual(reason, "response_body") self.assertNotIn("SECRET", repr((signal, proof, reason))) def test_request_mismatch_never_creates_proof(self): t = target() for key in ("idCalendarioGiornaliero", "selectedDay", "selectedHour"): p = final_packet(t) p.request.postData[key] = "wrong" self.assertIsNone(inspect_final_packet(p, t)[1]) p = final_packet(t) p.tab_id = "wrong" self.assertEqual(inspect_final_packet(p, t)[2], "request_metadata") def test_native_adapter_exposes_only_verified_request_and_fixed_diagnostic(self): t = target() page = NativePage(t) page.final_packet.response.raw_body = '{"errorMessage":null,"url":"/Reservation"}' native = NativeFinalSubmitter(page, t, lambda: True) self.assertIs(native(), SubmissionSignal.UNKNOWN) self.assertEqual(native.submitted_selection.target, t) self.assertEqual(native.diagnostic, {"requestMatched": True, "reason": "response_fields"}) self.assertEqual(page.final_clicks, 1) if __name__ == "__main__": unittest.main()