"""Offline final-stage contracts; reservation records are synthetic, not site fixtures.""" import ast import json import shutil import subprocess import time import traceback import unittest from dataclasses import replace from datetime import date from pathlib import Path from types import SimpleNamespace from unittest.mock import Mock from urllib.parse import urlencode from plugins.ita_plugin import ( FINAL_PATH, NATIVE_FINAL_SCRIPT, FinalBookingAttempt, FinalBookingError, FinalOutcomeUnknown, FinalTarget, NativeFinalSubmitter, ReservationRecord, ReservationSnapshot, ReservationState, SubmissionSignal, classify_final_packet, ) from plugins.ita_plugin import CalendarBookError, select_slot_before_final, verify_precommit_selection from test.test_ita_calendar_book import DAY, SERVICE, FakePage, packets def target(): page = FakePage() approval = select_slot_before_final( page, target_day=DAY, availability_packet=packets()[0], time_slots_packet=packets()[1], ) return FinalTarget("applicant@example.test", "synthetic-session", "applicant-tab", "slot.fixture.it.tourist", "7001", SERVICE, approval) def receipt(state=ReservationState.ACTIVE, reference="NEW-1", **changes): return replace(ReservationRecord(reference, "7001", DAY, "10:05 - 11:05", state), **changes) def final_packet(booking_target=None, *, error="", destination="/Reservation"): booking_target = booking_target or target() slot = booking_target.approval.candidate return SimpleNamespace( url="https://prenotami.esteri.it" + FINAL_PATH, method="POST", tab_id=booking_target.tab_id, is_failed=False, request=SimpleNamespace(postData={ "idCalendarioGiornaliero": slot.daily_calendar_id, "selectedDay": slot.day.isoformat(), "selectedHour": f"{slot.time_label}\n({slot.slots_free})", }), response=SimpleNamespace(status=200, raw_body=json.dumps({"errorMessage": error, "url": destination})), ) class ReadPort: def __init__(self, booking_target, records=()): self.target = booking_target self.records = records self.calls = 0 self.error = None self.overrides = {} def __call__(self): self.calls += 1 if self.error: raise self.error return replace(ReservationSnapshot( self.target.applicant, self.target.session_key, time.monotonic(), True, self.records, ), **self.overrides) class FinalFlowTests(unittest.TestCase): def setUp(self): self.target = target() self.reader = ReadPort(self.target) self.current = Mock(return_value=True) self.signal = SubmissionSignal.ACCEPTED self.after = (receipt(),) self.submission_error = None self.after_hook = None self.submit = Mock(side_effect=self._submit) self.attempt = FinalBookingAttempt( self.target, read_reservations=self.reader, submit_native=self.submit, session_is_current=self.current, ) def _submit(self): self.reader.records = self.after if self.after_hook: self.after_hook() if self.submission_error: raise self.submission_error return self.signal def test_disabled_by_default_and_truthy_values_do_not_authorize(self): for enabled in (False, None, 1, "true"): with self.subTest(enabled=enabled), self.assertRaises(FinalBookingError): self.attempt.execute(enabled=enabled) self.assertEqual(self.reader.calls, 0) self.submit.assert_not_called() self.assertEqual(self.attempt.state, "ready") def test_confirmed_new_record_returns_existing_framework_result(self): result = self.attempt.execute(enabled=True) self.assertTrue(result.success) self.assertEqual(result.urn, "NEW-1") self.assertEqual(result.account, self.target.applicant) self.assertEqual(result.book_date, DAY.isoformat()) self.assertEqual(result.book_time, "10:05 - 11:05") self.assertEqual(self.attempt.state, "confirmed") self.assertEqual(self.reader.calls, 2) self.submit.assert_called_once_with() def test_cancelled_history_is_preserved_but_does_not_block(self): old = receipt(ReservationState.CANCELLED, "OLD-1") self.reader.records = (old,) self.after = (old, receipt()) self.assertTrue(self.attempt.execute(enabled=True).success) def test_cancelled_history_may_have_only_an_assigned_appointment_time(self): old = receipt(ReservationState.CANCELLED, "OLD-TIME", time_label=None, appointment_time="10:25") self.reader.records = (old,) self.after = (old, receipt()) self.assertTrue(self.attempt.execute(enabled=True).success) self.submit.assert_called_once_with() def test_unbound_cancelled_history_requires_fingerprint_and_is_preserved(self): old = receipt(ReservationState.CANCELLED, "OLD-UNBOUND", service_id=None, time_label=None, appointment_time="10:25", receipt_fingerprint="a" * 64) self.reader.records = (old,) self.after = (old, receipt()) self.assertTrue(self.attempt.execute(enabled=True).success) def test_missing_service_never_allows_live_or_untracked_history(self): cases = [(ReservationState.ACTIVE, "a" * 64), (ReservationState.WAITLIST, "a" * 64), (ReservationState.CANCELLED, None), (ReservationState.CANCELLED, "SECRET"), (ReservationState.CANCELLED, True)] for state, fingerprint in cases: self.setUp() self.reader.records = (receipt(state, service_id=None, receipt_fingerprint=fingerprint),) with self.assertRaises(FinalBookingError): self.attempt.execute(enabled=True) self.submit.assert_not_called() def test_assigned_time_alone_never_proves_new_booking_slot(self): for assigned in ("10:05", "10:25", "11:05", "14:00"): with self.subTest(assigned=assigned): self.setUp() self.after = (receipt(time_label=None, appointment_time=assigned),) with self.assertRaises(FinalOutcomeUnknown): self.attempt.execute(enabled=True) with self.assertRaises(FinalOutcomeUnknown): self.attempt.reconcile() self.submit.assert_called_once_with() def test_existing_active_point_time_record_still_blocks_submission(self): self.reader.records = (receipt(time_label=None, appointment_time="10:25"),) with self.assertRaises(FinalBookingError): self.attempt.execute(enabled=True) self.submit.assert_not_called() def test_independently_bound_interval_preserves_assigned_receipt_time(self): # Synthetic trusted read-port data, NOT proof the website supplies an interval. self.after = (receipt(appointment_time="10:25"),) self.assertEqual(self.attempt.execute(enabled=True).book_time, "10:25") def test_conflicting_interval_and_assigned_time_is_not_confirmed(self): self.after = (receipt(appointment_time="14:00"),) with self.assertRaises(FinalOutcomeUnknown): self.attempt.execute(enabled=True) self.submit.assert_called_once_with() def test_missing_or_malformed_assigned_time_blocks_baseline(self): for assigned in (None, "", "24:00", "10:25:00", True, "10:25\n"): with self.subTest(assigned=assigned): self.setUp() self.reader.records = (receipt(ReservationState.CANCELLED, time_label=None, appointment_time=assigned),) with self.assertRaises(FinalBookingError): self.attempt.execute(enabled=True) self.submit.assert_not_called() def test_other_service_active_record_does_not_count_as_target_booking(self): other = receipt(reference="OTHER", service_id="8001") self.reader.records = (other,) self.after = (other, receipt()) self.assertTrue(self.attempt.execute(enabled=True).success) def test_active_or_waitlist_blocks_before_submission(self): for state in (ReservationState.ACTIVE, ReservationState.WAITLIST): with self.subTest(state=state): self.setUp() self.reader.records = (receipt(state),) with self.assertRaisesRegex(FinalBookingError, "active reservation or waitlist"): self.attempt.execute(enabled=True) self.submit.assert_not_called() self.assertEqual(self.attempt.state, "blocked") def test_malformed_or_incomplete_baseline_blocks(self): cases = [ {"complete": False}, {"complete": 1}, {"applicant": "another@example.test"}, {"session_key": "older-session"}, {"captured_at": 0}, {"captured_at": float("nan")}, {"captured_at": float("inf")}, {"captured_at": True}, {"records": []}, {"records": (receipt(ReservationState.UNKNOWN),)}, {"records": (receipt(), receipt())}, {"records": (receipt(reference=""),)}, {"records": (receipt(state="cancelled"),)}, {"records": (receipt(time_label="25:00 - 26:00"),)}, {"records": (receipt(time_label="11:05 - 10:05"),)}, ] for overrides in cases: with self.subTest(fields=list(overrides)): self.setUp() self.reader.overrides = overrides with self.assertRaises(FinalBookingError): self.attempt.execute(enabled=True) self.submit.assert_not_called() def test_account_change_before_submission_blocks(self): self.current.return_value = False with self.assertRaises(FinalBookingError): self.attempt.execute(enabled=True) self.submit.assert_not_called() def test_account_change_during_baseline_read_blocks(self): self.current.side_effect = [True, False] with self.assertRaises(FinalBookingError): self.attempt.execute(enabled=True) self.submit.assert_not_called() def test_reader_exception_is_sanitized(self): self.reader.error = RuntimeError("secret-raw-password") with self.assertRaises(FinalBookingError) as caught: self.attempt.execute(enabled=True) self.assertNotIn("secret", str(caught.exception)) self.assertNotIn("secret", "".join(traceback.format_exception(caught.exception))) self.submit.assert_not_called() def test_explicit_rejection_and_no_record_returns_failure_without_retry(self): self.signal = SubmissionSignal.REJECTED self.after = () result = self.attempt.execute(enabled=True) self.assertFalse(result.success) self.assertEqual(result.label, "italy-final-rejected") self.assertEqual(self.attempt.state, "rejected") with self.assertRaises(FinalBookingError): self.attempt.execute(enabled=True) self.submit.assert_called_once_with() def test_timeout_after_write_can_be_confirmed_by_fresh_record(self): self.submission_error = TimeoutError("lost acknowledgement") self.assertTrue(self.attempt.execute(enabled=True).success) self.submit.assert_called_once_with() def test_unknown_response_cannot_be_reported_as_plain_no_availability(self): self.signal, self.after = SubmissionSignal.UNKNOWN, () with self.assertRaises(FinalOutcomeUnknown): self.attempt.execute(enabled=True) self.assertEqual(self.attempt.state, "unknown") def test_accepted_without_receipt_is_unknown_and_only_readback_can_resume(self): self.after = () with self.assertRaises(FinalOutcomeUnknown): self.attempt.execute(enabled=True) with self.assertRaises(FinalBookingError): self.attempt.execute(enabled=True) self.reader.records = (receipt(),) self.assertTrue(self.attempt.reconcile().success) self.submit.assert_called_once_with() self.assertEqual(self.reader.calls, 3) def test_unknown_reconciliation_never_submits(self): self.after = () with self.assertRaises(FinalOutcomeUnknown): self.attempt.execute(enabled=True) for _ in range(2): with self.assertRaises(FinalOutcomeUnknown): self.attempt.reconcile() self.submit.assert_called_once_with() def test_mismatches_and_multiple_records_are_unknown(self): cases = [ (receipt(service_id="wrong-service"),), (receipt(day=date(2026, 10, 14)),), (receipt(time_label="11:15 - 12:40"),), (receipt(ReservationState.CANCELLED),), (receipt(ReservationState.WAITLIST),), (receipt(), receipt(reference="SECOND")), (receipt(), receipt(reference="UNRELATED", service_id="another")), ] for records in cases: with self.subTest(records=len(records)): self.setUp() self.after = records with self.assertRaises(FinalOutcomeUnknown): self.attempt.execute(enabled=True) self.submit.assert_called_once_with() def test_rejection_conflicting_with_receipt_is_unknown(self): self.signal = SubmissionSignal.REJECTED with self.assertRaises(FinalOutcomeUnknown): self.attempt.execute(enabled=True) def test_removed_or_changed_cancelled_history_is_not_count_based_success(self): for records in ((receipt(),), (receipt(reference="OLD"),)): with self.subTest(records=records): self.setUp() self.reader.records = (receipt(ReservationState.CANCELLED, "OLD"),) self.after = records with self.assertRaises(FinalOutcomeUnknown): self.attempt.execute(enabled=True) def test_after_read_failures_remain_unknown_and_sanitized(self): self.after_hook = lambda: setattr(self.reader, "error", RuntimeError("secret-response-token")) with self.assertRaises(FinalOutcomeUnknown) as caught: self.attempt.execute(enabled=True) self.assertNotIn("secret", "".join(traceback.format_exception(caught.exception))) self.assertEqual(self.attempt.state, "unknown") def test_after_identity_change_is_unknown(self): self.after_hook = lambda: self.reader.overrides.update(applicant="other@example.test") with self.assertRaises(FinalOutcomeUnknown): self.attempt.execute(enabled=True) def test_success_and_blocked_attempts_cannot_be_reused(self): self.attempt.execute(enabled=True) with self.assertRaises(FinalBookingError): self.attempt.execute(enabled=True) with self.assertRaises(FinalBookingError): self.attempt.reconcile() self.submit.assert_called_once_with() def test_reentrant_submission_is_rejected(self): def reentrant(): with self.assertRaises(FinalBookingError): self.attempt.execute(enabled=True) with self.assertRaises(FinalBookingError): self.attempt.reconcile() self.after_hook = reentrant self.assertTrue(self.attempt.execute(enabled=True).success) self.submit.assert_called_once_with() def test_interrupted_write_can_only_resume_read_only(self): self.submission_error = KeyboardInterrupt() with self.assertRaises(KeyboardInterrupt): self.attempt.execute(enabled=True) self.assertEqual(self.attempt.state, "unknown") with self.assertRaises(FinalBookingError): self.attempt.execute(enabled=True) self.assertTrue(self.attempt.reconcile().success) self.submit.assert_called_once_with() def test_interrupted_preflight_stays_blocked_without_submission(self): self.reader.error = KeyboardInterrupt() with self.assertRaises(KeyboardInterrupt): self.attempt.execute(enabled=True) self.assertEqual(self.attempt.state, "blocked") self.submit.assert_not_called() def test_objects_do_not_expose_identifiers_in_repr(self): self.assertNotIn(self.target.applicant, repr(self.target)) self.assertNotIn("NEW-1", repr(receipt())) self.assertNotIn(self.target.applicant, repr(self.reader())) class FinalPacketTests(unittest.TestCase): def setUp(self): self.target = target() def test_known_static_schema_is_only_a_hint(self): self.assertIs(classify_final_packet(final_packet(self.target), self.target), SubmissionSignal.ACCEPTED) self.assertIs(classify_final_packet(final_packet(self.target, error="Qualsiasi errore"), self.target), SubmissionSignal.REJECTED) def test_form_urlencoded_native_whitespace_is_accepted(self): packet = final_packet(self.target) packet.request.postData = urlencode(packet.request.postData) self.assertIs(classify_final_packet(packet, self.target), SubmissionSignal.ACCEPTED) def test_mismatched_metadata_is_unknown(self): for field, value in ( ("url", "https://attacker.test" + FINAL_PATH), ("url", "https://prenotami.esteri.it/elsewhere"), ("url", "https://prenotami.esteri.it" + FINAL_PATH + "?unexpected=1"), ("method", "GET"), ("tab_id", "other-tab"), ("is_failed", True), ): with self.subTest(field=field): packet = final_packet(self.target) setattr(packet, field, value) self.assertIs(classify_final_packet(packet, self.target), SubmissionSignal.UNKNOWN) def test_non_200_is_unknown_even_for_auth_or_rate_limit(self): for status in (True, "200", 302, 400, 401, 403, 409, 429, 500): with self.subTest(status=status): packet = final_packet(self.target) packet.response.status = status self.assertIs(classify_final_packet(packet, self.target), SubmissionSignal.UNKNOWN) def test_wrong_request_values_or_extra_fields_are_unknown(self): for key, value in ( ("idCalendarioGiornaliero", "123"), ("selectedDay", "2026-10-14"), ("selectedHour", "10:05 - 11:05(0)"), ("selectedHour", None), ("extra", "secret"), ): with self.subTest(key=key): packet = final_packet(self.target) packet.request.postData[key] = value self.assertIs(classify_final_packet(packet, self.target), SubmissionSignal.UNKNOWN) def test_duplicate_post_field_is_unknown(self): packet = final_packet(self.target) packet.request.postData = urlencode(packet.request.postData) + "&selectedDay=2026-10-13" self.assertIs(classify_final_packet(packet, self.target), SubmissionSignal.UNKNOWN) def test_invalid_response_is_unknown_without_disclosing_text(self): for raw in ("secret", "null", "[]", "{}", '{"errorMessage": ""}', '{"errorMessage": null, "url": "/Reservation"}', '{"errorMessage": "", "errorMessage": "secret", "url": "/Reservation"}', '{"errorMessage": "", "url": "https://attacker.test"}', "x" * 1_000_001): with self.subTest(length=len(raw)): packet = final_packet(self.target) packet.response.raw_body = raw self.assertIs(classify_final_packet(packet, self.target), SubmissionSignal.UNKNOWN) class NativePage(FakePage): def __init__(self, booking_target): super().__init__() self.tab_id = booking_target.tab_id self.active = True self.final_clicks = 0 self.final_ack = True self.final_exception = None self.final_packet = final_packet(booking_target) self.listen = SimpleNamespace( start=Mock(), wait=Mock(side_effect=lambda **kwargs: self.final_packet), stop=Mock(), ) def run_js(self, script, *args): if script == NATIVE_FINAL_SCRIPT: self.listen.start.assert_called_once_with(FINAL_PATH, method="POST") if self.final_exception: raise self.final_exception self.final_clicks += int(self.final_ack) return {"clicked": self.final_ack} return super().run_js(script, *args) class NativeFinalTests(unittest.TestCase): def setUp(self): self.target = target() self.page = NativePage(self.target) self.current = Mock(return_value=True) self.submit = NativeFinalSubmitter(self.page, self.target, self.current) def test_real_adapter_uses_existing_listener_and_one_native_click(self): self.assertIs(self.submit(), SubmissionSignal.ACCEPTED) self.assertEqual(self.page.final_clicks, 1) self.assertEqual(self.page.clicks, 0) self.page.listen.stop.assert_called_once_with() with self.assertRaises(FinalBookingError): self.submit() self.assertEqual(self.page.final_clicks, 1) def test_wrong_context_or_unselected_slot_never_clicks(self): for change in (lambda: setattr(self.page, "tab_id", "other"), lambda: setattr(self.page, "url", "https://attacker.test/BookingCalendar"), lambda: setattr(self.page, "service", "other"), lambda: setattr(self.page, "active", False), lambda: setattr(self.current, "return_value", False)): self.setUp() change() self.assertIs(self.submit(), SubmissionSignal.UNKNOWN) self.assertEqual(self.page.final_clicks, 0) def test_context_change_after_listener_start_does_not_click(self): self.current.side_effect = [True, False] self.assertIs(self.submit(), SubmissionSignal.UNKNOWN) self.assertEqual(self.page.final_clicks, 0) self.page.listen.stop.assert_called_once_with() def test_no_packet_or_browser_ack_is_unknown_without_retry(self): for mode in ("timeout", "no_ack", "exception"): with self.subTest(mode=mode): self.setUp() if mode == "timeout": self.page.final_packet = None elif mode == "no_ack": self.page.final_ack = False else: self.page.final_exception = RuntimeError("secret") self.assertIs(self.submit(), SubmissionSignal.UNKNOWN) self.page.listen.stop.assert_called_once_with() with self.assertRaises(FinalBookingError): self.submit() self.assertLessEqual(self.page.final_clicks, 1) def test_precommit_readback_is_read_only(self): self.assertEqual(verify_precommit_selection( self.page, runtime_service=SERVICE, approval=self.target.approval, ), self.target.approval) self.assertEqual(self.page.clicks, 0) self.assertEqual(self.page.final_clicks, 0) def test_changed_candidate_is_not_reselected_during_readback(self): for changes in ({"candidateReady": False}, {"dayNegative": True}, {"activeCapacityMatches": False}, {"activeIdMatches": False}, {"activeCount": 2}, {"activeTimeMatches": False}): with self.subTest(changes=changes): self.page.overrides = changes with self.assertRaises(CalendarBookError): verify_precommit_selection(self.page, runtime_service=SERVICE, approval=self.target.approval) self.assertEqual(self.page.clicks, 0) self.assertEqual(self.page.final_clicks, 0) class ProductionBoundaryTests(unittest.TestCase): def test_production_final_flag_still_rejected_without_browser_creation(self): from plugins.ita_plugin import ItaPlugin from vs_types import BizLogicError # set_config rejects the flag before touching browser/profile paths. plugin = ItaPlugin.__new__(ItaPlugin) for value in (True, 1, "true"): with self.subTest(value=value), self.assertRaises(BizLogicError): plugin.set_config(SimpleNamespace(free_config={"final_submit_enabled": value})) def test_query_and_prefinal_tools_do_not_dispatch_final(self): root = Path(__file__).resolve().parents[1] from test.ita_source_sections import section sources = [section("calendar_query")] sources += [(root / name).read_text() for name in ( "tools/debug_ita_book_gate.py", "tools/debug_ita_calendar_gate.py")] for source in sources: tree = ast.parse(source) for node in ast.walk(tree): if isinstance(node, ast.ImportFrom): self.assertFalse({a.name for a in node.names} & { "submit_final", "FinalBookingAttempt", "NativeFinalSubmitter"}) if isinstance(node, ast.Call) and isinstance(node.func, ast.Name): self.assertNotIn(node.func.id, {"submit_final", "FinalBookingAttempt", "NativeFinalSubmitter"}) # Actual composed JavaScript in a synthetic DOM. Slot snapshot logic is covered # by the existing Book JS suite; this harness reuses that suite's DOM below. NATIVE_JS_HARNESS = r""" const fs = require('fs'), vm = require('vm'); const {script, mode} = JSON.parse(fs.readFileSync(0, 'utf8')); let clicks = 0; const classes = (...names) => ({contains: name => names.includes(name)}); const input = {type: 'hidden', id: 'idHiddenFasciaServizio', value: '80001001'}; const slot = { isConnected: true, classList: classes('fascia', 'act'), hasAttribute: () => false, getAttribute: () => null, querySelector: () => null, querySelectorAll: selector => selector === 'input' ? [input] : [{textContent: '10:05 - 11:05'}, {textContent: '(1)'}], getBoundingClientRect: () => ({left: 0, right: 100, top: 0, bottom: 40}), contains: e => e === slot, }; const link = {dataset: {date: '2026-10-13'}, classList: classes('input-async-abilitato'), hasAttribute: () => false, getAttribute: () => null}; const content = {dataset: {date: '2026-10-13'}, querySelectorAll: () => [slot], contains: e => e === slot}; const button = {isConnected: true, disabled: true, dataset: {coordinateFinalGuard: 'enabled'}, setAttribute: () => {}, removeAttribute: () => {}, click: () => { if (button.disabled) throw new Error('clicked while disabled'); clicks++; if (mode === 'throw_after_click') throw new Error('lost acknowledgement'); }}; const service = {value: '7002'}; if (mode === 'wrong_service') service.value = 'other'; if (mode === 'wrong_day') link.dataset.date = '2026-10-14'; if (mode === 'wrong_id') input.value = '80002002'; if (mode === 'unavailable') slot.classList = classes('fascia', 'act', 'notAvailableFascia'); if (mode === 'unguarded') button.disabled = false; if (mode === 'consumed') button.dataset.coordinateFinalAttemptConsumed = 'true'; const document = { querySelectorAll: selector => ({ '#idServizio': [service], '#btnPrenotaNoOtp': mode === 'duplicate_button' ? [button, button] : [button], '.events a.selected': [link], '.events-content li.selected': [content], '.events a[data-date]': [link], '.fascia.act': mode === 'no_active' ? [] : [slot], })[selector] || [], querySelector: () => link, elementFromPoint: () => slot, }; const window = {location: {origin: 'https://prenotami.esteri.it', pathname: '/BookingCalendar'}, innerWidth: 1000, innerHeight: 800, getComputedStyle: () => ({display: 'block', visibility: 'visible', pointerEvents: 'auto', opacity: '1'})}; const context = vm.createContext({document, window}); const action = new vm.Script('(function(){' + script + '})').runInContext(context); let result, thrown = false; try { result = action('7002', '2026-10-13', '80001001', '10:05 - 11:05', 1); } catch (_) { thrown = true; } if (mode === 'twice') action('7002', '2026-10-13', '80001001', '10:05 - 11:05', 1); process.stdout.write(JSON.stringify({clicks, disabled: button.disabled, consumed: Boolean(button.dataset.coordinateFinalAttemptConsumed), result, thrown})); """ @unittest.skipUnless(shutil.which("node"), "node required for real JS offline execution") class NativeFinalJavaScriptTests(unittest.TestCase): def run_js(self, mode): proc = subprocess.run([shutil.which("node"), "-e", NATIVE_JS_HARNESS], input=json.dumps({"script": NATIVE_FINAL_SCRIPT, "mode": mode}), text=True, capture_output=True, timeout=10) self.assertEqual(proc.returncode, 0, proc.stderr) return json.loads(proc.stdout) def test_native_click_once_and_reguard(self): for mode in ("normal", "twice", "throw_after_click"): with self.subTest(mode=mode): state = self.run_js(mode) self.assertEqual(state["clicks"], 1) self.assertTrue(state["disabled"]) self.assertTrue(state["consumed"]) def test_unsafe_state_does_not_click(self): for mode in ("wrong_service", "wrong_day", "wrong_id", "unavailable", "unguarded", "consumed", "duplicate_button", "no_active"): with self.subTest(mode=mode): state = self.run_js(mode) self.assertFalse(state["thrown"]) self.assertEqual(state["clicks"], 0) self.assertEqual(state["result"], {"clicked": False}) if __name__ == "__main__": unittest.main()