| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929 |
- """Offline production-entry tests: no credentials, site calls, or cloud writes."""
- import ast
- import logging
- import itertools
- from dataclasses import replace
- from contextlib import ExitStack
- from datetime import datetime
- from pathlib import Path
- from io import StringIO
- from contextlib import redirect_stdout
- from types import MethodType, SimpleNamespace
- from unittest import TestCase
- from unittest.mock import Mock, patch
- from plugins import ita_workflow as workflow
- from plugins import ita_calendar_session as preparation
- from plugins.ita_booking_final import FinalOutcomeUnknown, SubmissionSignal, VerifiedSubmission
- from plugins.ita_plugin import ItaPlugin
- from plugins import ita_otp
- from plugins import ita_turnstile
- from plugins.ita_protocol import OtpMailConfig
- from test import test_ita_calendar_book_flow as flow
- from test.test_debug_ita_calendar_gate import booking_preflight_snapshot
- from test import test_ita_final_attribution as attribution
- from vs_types import AvailabilityStatus, BizLogicError, PermissionDeniedError, VSBookResult, VSPlgConfig, VSQueryResult
- class PreparationTests(TestCase):
- def setUp(self):
- _, self.route, _ = flow.prepared_plugin(flow.FlowPage())
- self.path = f"/Services/Booking/{self.route.service_id}"
- self.page = SimpleNamespace(url="https://prenotami.esteri.it" + self.path,
- tab_id="fixture-tab", wait=Mock(), set=Mock())
- self.otp_present = False
- self.clicks = []
- self.page.run_js = Mock(side_effect=lambda _: booking_preflight_snapshot(
- otpValuePresent=self.otp_present, otpDisabled=self.otp_present))
- otp_input = Mock()
- otp_input.input.side_effect = lambda *a, **k: setattr(self, "otp_present", True)
- otp_input.run_js.return_value = True
- otp_input.selector = "#otp-input"
- controls = {"#otp-input": otp_input, "#otp-send": SimpleNamespace(selector="#otp-send"),
- "#btnAvanti": SimpleNamespace(selector="#btnAvanti")}
- self.page.ele = Mock(side_effect=lambda selector, **kwargs: controls[selector])
- self.plugin = SimpleNamespace(
- page=self.page, session_create_time=1, free_config={"otp_mode": "manual"},
- config=SimpleNamespace(account=SimpleNamespace(username="fixture@example.test")),
- mouse=SimpleNamespace(human_click_ele=lambda ele: self.clicks.append(ele.selector)),
- _booking_path=lambda route: self.path, _log=Mock(),
- _record_calendar_query_prepared_route=Mock(), _record_calendar_book_prepared_route=Mock(),
- )
- self.plugin._book_final_configuration_valid = MethodType(ItaPlugin._book_final_configuration_valid, self.plugin)
- self.stack = ExitStack()
- self.addCleanup(self.stack.close)
- self.tty = self.stack.enter_context(patch.object(workflow.sys.stdin, "isatty", return_value=True))
- self.reader = self.stack.enter_context(patch.object(preparation, "_read_manual_otp", return_value="123456"))
- self.listener = self.stack.enter_context(patch.object(workflow, "listen_once", side_effect=self.listen))
- self.stack.enter_context(patch.object(workflow, "guard_calendar"))
- self.stack.enter_context(patch.object(workflow, "wait_for_calendar_service", return_value="9001"))
- def listen(self, page, *, target, method, timeout, action):
- action()
- if target == self.path:
- page.url = "https://prenotami.esteri.it/BookingCalendar?selectedService=Example"
- return SimpleNamespace(tab_id=page.tab_id, is_failed=False, method=method,
- url="https://prenotami.esteri.it" + target + ("?ServiceID=9001" if method == "GET" else ""),
- response=SimpleNamespace(status=200, raw_body='"SENT"', url=page.url))
- def test_native_preparation_sends_once_writes_once_and_records_query_role(self):
- workflow.prepare_calendar(self.plugin, self.route, role="query")
- self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"])
- self.assertEqual(self.listener.call_count, 2)
- self.reader.assert_called_once()
- self.plugin._record_calendar_query_prepared_route.assert_called_once_with(self.route)
- self.plugin._record_calendar_book_prepared_route.assert_not_called()
- self.assertEqual(self.page.run_js.call_count, 2)
- self.assertIn("form-boundary", self.page.run_js.call_args.args[0])
- def test_book_role_does_not_mark_query_prepared(self):
- workflow.prepare_calendar(self.plugin, self.route, role="book")
- self.plugin._record_calendar_book_prepared_route.assert_called_once_with(self.route)
- self.plugin._record_calendar_query_prepared_route.assert_not_called()
- def test_no_terminal_stops_before_otp_or_form_changes(self):
- self.tty.return_value = False
- with self.assertRaises(PermissionDeniedError):
- workflow.prepare_calendar(self.plugin, self.route, role="query")
- self.listener.assert_not_called()
- self.page.run_js.assert_not_called()
- def test_wrong_otp_readback_prevents_avanti_and_repeated_otp(self):
- self.page.ele("#otp-input").run_js.return_value = False
- with self.assertRaisesRegex(preparation.CalendarGateError, "verification failed"):
- workflow.prepare_calendar(self.plugin, self.route, role="book")
- with self.assertRaises(PermissionDeniedError):
- workflow.prepare_calendar(self.plugin, self.route, role="book")
- self.assertEqual(self.clicks, ["#otp-send", "#otp-input"])
- self.assertEqual(self.listener.call_count, 1)
- def test_wrong_tab_response_never_reads_otp_or_submits_form(self):
- self.listener.side_effect = None
- self.listener.return_value = SimpleNamespace(tab_id="foreign", is_failed=False)
- with self.assertRaises(preparation.CalendarGateError):
- workflow.prepare_calendar(self.plugin, self.route, role="query")
- self.reader.assert_not_called()
- self.plugin._record_calendar_query_prepared_route.assert_not_called()
- class CloudPreparationTests(TestCase):
- """Reuse the manual site's fixture, replacing only the OTP provider."""
- listen = PreparationTests.listen
- def setUp(self):
- PreparationTests.setUp(self)
- self.plugin.free_config["otp_mode"] = "cloud"
- self.route = replace(self.route, mail=OtpMailConfig("mailbox@example.test"))
- self.tty.return_value = False
- self.stack.enter_context(patch.object(ita_otp.vs_log_macros, "_active_logger",
- logging.Logger("offline-otp", logging.INFO)))
- self.fetch = self.stack.enter_context(patch.object(workflow, "fetch_otp_from_cloud",
- return_value="001234"))
- self.utc = self.stack.enter_context(patch.object(workflow, "utc_sent_at",
- return_value="2026-08-31 01:02:03"))
- def test_automatic_preparation_without_tty_reuses_native_controls_and_readback(self):
- observed = []
- def fetch(mail, **kwargs):
- observed.extend(self.clicks)
- return "001234"
- self.fetch.side_effect = fetch
- output = StringIO()
- with redirect_stdout(output):
- workflow.prepare_calendar(self.plugin, self.route, role="book")
- self.assertEqual(observed, ["#otp-send"])
- self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"])
- self.fetch.assert_called_once_with(self.route.mail, recipient="fixture@example.test",
- sent_at="2026-08-31 01:02:03")
- self.page.ele("#otp-input").input.assert_called_once_with("001234", clear=True)
- self.reader.assert_not_called()
- self.assertNotIn("001234", output.getvalue() + str(self.plugin._log.call_args_list))
- self.plugin._record_calendar_book_prepared_route.assert_called_once_with(self.route)
- self.plugin._record_calendar_query_prepared_route.assert_not_called()
- def test_send_timestamp_is_captured_before_native_send(self):
- def click(ele):
- if ele.selector == "#otp-send":
- self.utc.assert_called_once()
- self.clicks.append(ele.selector)
- self.plugin.mouse.human_click_ele = click
- workflow.prepare_calendar(self.plugin, self.route, role="book")
- def test_mail_failure_has_no_avanti_no_manual_fallback_no_same_session_resend(self):
- self.fetch.side_effect = preparation.CalendarGateError("Italy OTP mailbox read failed")
- with self.assertRaises(preparation.CalendarGateError):
- workflow.prepare_calendar(self.plugin, self.route, role="book")
- with self.assertRaises(PermissionDeniedError):
- workflow.prepare_calendar(self.plugin, self.route, role="book")
- self.assertEqual(self.clicks, ["#otp-send"])
- self.fetch.assert_called_once()
- self.reader.assert_not_called()
- def test_late_response_is_discarded_before_dom_write(self):
- with patch.object(workflow, "monotonic", side_effect=[0, 1, 300]):
- with self.assertRaisesRegex(preparation.CalendarGateError, "window expired"):
- workflow.prepare_calendar(self.plugin, self.route, role="book")
- self.assertEqual(self.clicks, ["#otp-send"])
- def test_expiration_during_preflight_prevents_avanti(self):
- with patch.object(workflow, "monotonic", side_effect=[0, 1, 2, 300]):
- with self.assertRaisesRegex(preparation.CalendarGateError, "window expired"):
- workflow.prepare_calendar(self.plugin, self.route, role="book")
- self.assertEqual(self.clicks, ["#otp-send", "#otp-input"])
- def test_account_change_during_read_discards_code(self):
- def changed(*args, **kwargs):
- self.plugin.config.account.username = "other@example.test"
- return "001234"
- self.fetch.side_effect = changed
- with self.assertRaises(preparation.CalendarGateError):
- workflow.prepare_calendar(self.plugin, self.route, role="book")
- self.assertEqual(self.clicks, ["#otp-send"])
- def test_cloud_dom_write_failure_is_redacted_and_stops_avanti(self):
- self.page.ele("#otp-input").input.side_effect = RuntimeError("private typed 001234")
- with self.assertRaisesRegex(preparation.CalendarGateError, "DOM write verification failed") as caught:
- workflow.prepare_calendar(self.plugin, self.route, role="book")
- self.assertNotIn("001234", str(caught.exception))
- self.assertEqual(self.clicks, ["#otp-send", "#otp-input"])
- def test_wrong_cloud_role_or_invalid_final_flag(self):
- with self.assertRaises(PermissionDeniedError):
- workflow.prepare_calendar(self.plugin, self.route, role="query")
- self.plugin.free_config["final_submit_enabled"] = 1
- with self.assertRaises(PermissionDeniedError):
- workflow.prepare_calendar(self.plugin, self.route, role="book")
- self.listener.assert_not_called()
- self.fetch.assert_not_called()
- def test_missing_mail_and_debug_logger_stop_before_any_site_action(self):
- with self.assertRaises(preparation.CalendarGateError):
- workflow.prepare_calendar(self.plugin, replace(self.route, mail=None), role="book")
- ita_otp.vs_log_macros._active_logger.setLevel(logging.DEBUG)
- with self.assertRaises(preparation.CalendarGateError):
- workflow.prepare_calendar(self.plugin, self.route, role="book")
- self.listener.assert_not_called()
- self.page.run_js.assert_not_called()
- class CloudFinalPreparationTests(CloudPreparationTests):
- """Run the same OTP/session/expiry/privacy cases with final explicitly on."""
- def setUp(self):
- super().setUp()
- self.plugin.free_config["final_submit_enabled"] = True
- def test_preparation_does_not_itself_submit_final(self):
- with patch.object(workflow, "submit_final") as submit:
- workflow.prepare_calendar(self.plugin, self.route, role="book")
- submit.assert_not_called()
- self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"])
- class CloudQueryPreparationTests(TestCase):
- """Use the same preparation, mail adapter and fixtures as applicant Book."""
- listen = PreparationTests.listen
- def setUp(self):
- CloudPreparationTests.setUp(self)
- self.plugin.free_config.update(query_mode="calendar", final_submit_enabled=False)
- def prepare(self):
- workflow.prepare_calendar(self.plugin, self.route, role="query")
- def query_plugin(self, results):
- self.plugin.query = MethodType(ItaPlugin.query, self.plugin)
- self.plugin._resolve_route = Mock(return_value=self.route)
- self.plugin._query_once = Mock(side_effect=results)
- self.plugin._clear_calendar_query_state = Mock()
- return self.plugin
- def test_public_query_prepares_once_with_shared_mail_adapter_and_no_terminal(self):
- strong = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available,
- earliest_date=datetime(2026, 10, 13))
- plugin = self.query_plugin([VSQueryResult(success=True), strong, strong])
- client = Mock()
- client.fetch_mail_content.return_value = "OTP Code:001234"
- self.fetch.side_effect = lambda *args, **kwargs: ita_otp.fetch_otp_from_cloud(
- *args, **kwargs, api=client)
- output = StringIO()
- with patch.object(workflow, "submit_final") as final, redirect_stdout(output):
- self.assertIs(plugin.query(Mock()), strong)
- self.assertIs(plugin.query(Mock()), strong)
- client.fetch_mail_content.assert_called_once_with(
- email=self.route.mail.authorization_email, sender="noreply-prenotami@esteri.it",
- recipient=plugin.config.account.username, subject_keywords="OTP Code",
- body_keywords="OTP Code:", sent_date="2026-08-31 01:02:03", expiry=300, only_text=True)
- client.fetch_mail_content_from_top.assert_not_called()
- self.assertEqual(plugin._query_once.call_count, 3)
- self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"])
- self.assertEqual(self.listener.call_count, 2)
- self.reader.assert_not_called()
- final.assert_not_called()
- self.plugin._record_calendar_query_prepared_route.assert_called_once_with(self.route)
- self.plugin._record_calendar_book_prepared_route.assert_not_called()
- self.assertNotIn("001234", output.getvalue() + str(plugin._log.call_args_list))
- def test_account_mailbox_query_uses_the_new_pool_account_without_fixed_address(self):
- self.route = replace(self.route, mail=OtpMailConfig(authorization_source="account"))
- self.plugin.config.account.username = "new-pool-account@example.test"
- strong = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available,
- earliest_date=datetime(2026, 10, 13))
- plugin = self.query_plugin([VSQueryResult(success=True), strong, strong])
- client = Mock()
- client.fetch_mail_content.return_value = "OTP Code:001234"
- self.fetch.side_effect = lambda *args, **kwargs: ita_otp.fetch_otp_from_cloud(*args, **kwargs, api=client)
- with patch.object(workflow, "submit_final") as final, redirect_stdout(StringIO()):
- self.assertIs(plugin.query(Mock()), strong)
- self.assertIs(plugin.query(Mock()), strong)
- client.fetch_mail_content.assert_called_once()
- self.assertEqual(client.fetch_mail_content.call_args.kwargs["email"], "new-pool-account@example.test")
- self.assertEqual(client.fetch_mail_content.call_args.kwargs["recipient"], "new-pool-account@example.test")
- self.assertIsNone(self.route.mail.authorization_email)
- self.assertEqual(self.clicks, ["#otp-send", "#otp-input", "#btnAvanti"])
- self.reader.assert_not_called()
- final.assert_not_called()
- def test_negative_entry_never_sends_otp_or_reads_mail(self):
- negative = VSQueryResult(success=False)
- plugin = self.query_plugin([negative])
- self.assertIs(plugin.query(Mock()), negative)
- self.page.run_js.assert_not_called()
- self.listener.assert_not_called()
- self.fetch.assert_not_called()
- self.reader.assert_not_called()
- def test_mail_failure_never_resends_or_falls_back_to_manual_in_same_session(self):
- self.fetch.side_effect = preparation.CalendarGateError("Italy OTP mailbox read failed")
- with redirect_stdout(StringIO()):
- with self.assertRaises(preparation.CalendarGateError):
- self.prepare()
- with self.assertRaises(PermissionDeniedError):
- self.prepare()
- self.fetch.assert_called_once()
- self.reader.assert_not_called()
- self.assertEqual(self.clicks, ["#otp-send"])
- self.plugin._record_calendar_query_prepared_route.assert_not_called()
- def test_expired_mail_is_not_written(self):
- with patch.object(workflow, "monotonic", side_effect=[0, 1, 300]), redirect_stdout(StringIO()):
- with self.assertRaisesRegex(preparation.CalendarGateError, "window expired"):
- self.prepare()
- self.assertEqual(self.clicks, ["#otp-send"])
- self.reader.assert_not_called()
- def test_account_change_during_mail_read_prevents_code_write(self):
- def changed(*args, **kwargs):
- self.plugin.config.account.username = "other@example.test"
- return "001234"
- self.fetch.side_effect = changed
- with redirect_stdout(StringIO()), self.assertRaises(preparation.CalendarGateError):
- self.prepare()
- self.assertEqual(self.clicks, ["#otp-send"])
- self.reader.assert_not_called()
- def test_ambiguous_mail_rejected_by_existing_parser_before_avanti(self):
- client = Mock()
- client.fetch_mail_content.return_value = "OTP Code:001234 OTP Code:654321"
- self.fetch.side_effect = lambda *args, **kwargs: ita_otp.fetch_otp_from_cloud(
- *args, **kwargs, api=client)
- with redirect_stdout(StringIO()), self.assertRaisesRegex(preparation.CalendarGateError, "mail rejected"):
- self.prepare()
- self.assertEqual(self.clicks, ["#otp-send"])
- self.reader.assert_not_called()
- client.fetch_mail_content_from_top.assert_not_called()
- def test_missing_mail_configuration_stops_before_site_actions(self):
- self.route = replace(self.route, mail=None)
- with self.assertRaisesRegex(preparation.CalendarGateError, "configuration is missing"):
- self.prepare()
- self.page.run_js.assert_not_called()
- self.listener.assert_not_called()
- self.fetch.assert_not_called()
- def test_query_cannot_enable_final_submission_or_use_book_preparation(self):
- for values, role in (({}, "book"), ({"final_submit_enabled": True}, "query")):
- with self.subTest(role=role):
- self.plugin.free_config.update(values)
- with self.assertRaises(PermissionDeniedError):
- workflow.prepare_calendar(self.plugin, self.route, role=role)
- self.page.run_js.assert_not_called()
- self.listener.assert_not_called()
- self.fetch.assert_not_called()
- class RecoveryWorkflowTests(TestCase):
- listen = PreparationTests.listen
- def setUp(self):
- PreparationTests.setUp(self)
- self.token_ready = False
- self.page.run_js.side_effect = lambda _: booking_preflight_snapshot(
- turnstileTokenPresent=self.token_ready,
- otpValuePresent=self.otp_present, otpDisabled=self.otp_present)
- self.helper = Mock()
- self.helper.click_verification_button.return_value = False
- self.factory = self.stack.enter_context(patch.object(ita_turnstile, 'CloudflareBypasser',
- return_value=self.helper))
- self.stack.enter_context(patch.object(preparation.time, 'sleep'))
- def assert_preparation_recovers(self, role):
- def clicked(**kwargs):
- self.assertEqual(self.clicks, [])
- self.token_ready = True
- return True
- self.helper.click_verification_button.side_effect = clicked
- times = itertools.chain([0, 0, 5, 6], itertools.count(7))
- output = StringIO()
- with patch.object(preparation.time, 'monotonic', side_effect=lambda: next(times)), redirect_stdout(output):
- workflow.prepare_calendar(self.plugin, self.route, role=role)
- self.helper.click_verification_button.assert_called_once_with(is_dfs=False)
- self.assertEqual(self.clicks, ['#otp-send', '#otp-input', '#btnAvanti'])
- self.reader.assert_called_once()
- self.assertEqual(self.listener.call_count, 2)
- self.assertIn('"state": "ready"', output.getvalue())
- self.factory.assert_called_once_with(self.page, log=False)
- self.helper.bypass.assert_not_called()
- def test_book_interaction_is_followed_by_real_readback_before_one_otp(self):
- self.assert_preparation_recovers('book')
- self.plugin._record_calendar_book_prepared_route.assert_called_once_with(self.route)
- self.plugin._record_calendar_query_prepared_route.assert_not_called()
- def test_query_reuses_book_recovery_then_records_only_query_preparation(self):
- self.assert_preparation_recovers('query')
- self.plugin._record_calendar_query_prepared_route.assert_called_once_with(self.route)
- self.plugin._record_calendar_book_prepared_route.assert_not_called()
- def test_query_three_clicks_without_token_cannot_release_otp(self):
- self.helper.click_verification_button.return_value = True
- with patch.object(preparation.time, 'monotonic', side_effect=[0, 0, 5, 15, 25, 35, 121]), \
- redirect_stdout(StringIO()), self.assertRaisesRegex(preparation.CalendarGateError, 'turnstile_token_pending'):
- workflow.prepare_calendar(self.plugin, self.route, role='query')
- self.assertEqual(self.helper.click_verification_button.call_count, 3)
- self.listener.assert_not_called()
- self.reader.assert_not_called()
- self.assertEqual(self.clicks, [])
- self.plugin._record_calendar_query_prepared_route.assert_not_called()
- def test_query_stages_share_one_recovery_budget(self):
- # The third click yields a real token. Expiry after sending OTP must not
- # create a fresh recovery budget or allow AVANTI without a new token.
- def clicked(**kwargs):
- if self.helper.click_verification_button.call_count == 3:
- self.token_ready = True
- return True
- self.helper.click_verification_button.side_effect = clicked
- def click(ele):
- self.clicks.append(ele.selector)
- if ele.selector == '#otp-send':
- self.token_ready = False
- self.plugin.mouse.human_click_ele = click
- ticks = [0, 0, 5, 15, 25, 26, 27, 27, 32, 42, 52, 148]
- with patch.object(preparation.time, 'monotonic', side_effect=ticks), \
- redirect_stdout(StringIO()), self.assertRaisesRegex(preparation.CalendarGateError, 'turnstile_token_pending'):
- workflow.prepare_calendar(self.plugin, self.route, role='query')
- self.factory.assert_called_once_with(self.page, log=False)
- self.assertEqual(self.helper.click_verification_button.call_count, 3)
- self.assertEqual(self.clicks, ['#otp-send', '#otp-input'])
- self.assertEqual(self.listener.call_count, 1)
- self.plugin._record_calendar_query_prepared_route.assert_not_called()
- def test_query_ready_widget_does_not_invoke_helper(self):
- self.token_ready = True
- with redirect_stdout(StringIO()):
- workflow.prepare_calendar(self.plugin, self.route, role='query')
- self.factory.assert_not_called()
- self.assertEqual(self.clicks, ['#otp-send', '#otp-input', '#btnAvanti'])
- def test_prepared_query_skips_recovery_and_all_preparation_actions(self):
- self.page.url = 'https://prenotami.esteri.it/BookingCalendar'
- with patch.object(workflow, 'ItalyTurnstileRecovery') as recovery:
- self.assertIsNone(workflow.prepare_query_if_needed(self.plugin, Mock()))
- recovery.assert_not_called()
- self.factory.assert_not_called()
- self.listener.assert_not_called()
- self.page.run_js.assert_not_called()
- def test_book_timeout_is_diagnostic_and_sends_no_otp(self):
- output = StringIO()
- with patch.object(preparation.time, 'monotonic', side_effect=[0, 0, 5, 121]), \
- redirect_stdout(output), self.assertRaisesRegex(preparation.CalendarGateError, 'turnstile_token_pending'):
- workflow.prepare_calendar(self.plugin, self.route, role='book')
- self.listener.assert_not_called()
- self.reader.assert_not_called()
- self.assertEqual(self.clicks, [])
- self.assertIn('"outcome": "timeout"', output.getvalue())
- self.helper.bypass.assert_not_called()
- def test_cloud_book_timeout_never_calls_mail_api(self):
- self.plugin.free_config['otp_mode'] = 'cloud'
- self.route = replace(self.route, mail=OtpMailConfig('mailbox@example.test'))
- with patch.object(preparation.time, 'monotonic', side_effect=[0, 0, 5, 121]), \
- patch.object(workflow, 'fetch_otp_from_cloud') as fetch, \
- patch.object(ita_otp.vs_log_macros, '_active_logger', logging.Logger('offline-cf', logging.INFO)), \
- redirect_stdout(StringIO()), self.assertRaises(preparation.CalendarGateError):
- workflow.prepare_calendar(self.plugin, self.route, role='book')
- fetch.assert_not_called()
- self.listener.assert_not_called()
- self.reader.assert_not_called()
- class ProductionEntryTests(TestCase):
- def setUp(self):
- self.plugin, self.route, self.trigger = flow.prepared_plugin(flow.FlowPage())
- self.plugin.free_config["otp_mode"] = "manual"
- self.inputs = {"username": self.plugin.config.account.username}
- self.plugin.is_healthy = True
- self.plugin._log = Mock()
- self.addCleanup(setattr, self.plugin, "_cleanup_attempted", True)
- def test_prepared_book_reuses_real_calendar_adapter_and_defaults_to_prefinal(self):
- with patch.object(workflow, "submit_final") as submit, patch.object(workflow, "prepare_calendar") as prepare:
- result = self.plugin.book(self.trigger, self.inputs)
- self.assertFalse(result.success)
- self.assertIsNotNone(self.plugin.last_booking_precommit)
- self.assertEqual(result.label, "calendar-ready-before-final")
- self.assertEqual(self.plugin.page.guard_final_count, 0)
- submit.assert_not_called()
- prepare.assert_not_called()
- def test_cloud_book_reuses_selection_without_enabling_final(self):
- self.plugin.free_config["otp_mode"] = "cloud"
- with patch.object(workflow, "submit_final") as submit:
- result = self.plugin.book(self.trigger, self.inputs)
- self.assertEqual(result.label, "calendar-ready-before-final")
- self.assertIsNotNone(self.plugin.last_booking_precommit)
- self.assertFalse(result.success)
- submit.assert_not_called()
- def test_cloud_final_uses_the_existing_submitter_after_fresh_selection(self):
- self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True)
- confirmed = VSBookResult(success=True, book_date="2026-10-13", book_time="09:26")
- with patch.object(workflow, "submit_final", return_value=confirmed) as submit:
- result = self.plugin.book(self.trigger, self.inputs)
- self.assertIs(result, confirmed)
- self.assertIsNotNone(self.plugin.last_booking_precommit)
- submit.assert_called_once_with(self.plugin, self.route)
- def test_invalid_final_flag_is_rejected_before_site_actions(self):
- self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled="true")
- with patch.object(workflow, "submit_final") as submit, \
- patch.object(workflow, "prepare_calendar") as prepare, self.assertRaises(PermissionDeniedError):
- self.plugin.book(self.trigger, self.inputs)
- submit.assert_not_called()
- prepare.assert_not_called()
- def test_cloud_final_no_inventory_never_submits(self):
- self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True)
- self.plugin.page = flow.FlowPage([flow.month(m, {}) for m in ("2026-10", "2026-11", "2026-12")])
- self.plugin._record_calendar_book_prepared_route(self.route)
- with patch.object(workflow, "submit_final") as submit, flow.browser_navigation(self.plugin.page):
- result = self.plugin.book(self.trigger, self.inputs)
- self.assertFalse(result.success)
- submit.assert_not_called()
- def test_enabled_book_returns_standard_result_after_real_slot_selection(self):
- self.plugin.free_config["final_submit_enabled"] = True
- confirmed = VSBookResult(success=True, book_date="2026-10-13", book_time="09:26")
- with patch.object(workflow, "submit_final", return_value=confirmed) as submit:
- result = self.plugin.book(self.trigger, self.inputs)
- self.assertIs(result, confirmed)
- self.assertIsNotNone(self.plugin.last_booking_precommit)
- submit.assert_called_once_with(self.plugin, self.route)
- def test_one_public_book_call_prepares_and_selects_from_dashboard(self):
- plugin = self.plugin
- plugin.page.url = "https://prenotami.esteri.it/UserArea"
- plugin._calendar_book_prepared_context = None
- plugin._inspect_booking_form_structure = Mock()
- def entry(apt):
- plugin.page.url = "https://prenotami.esteri.it" + plugin._booking_path(self.route)
- return VSQueryResult(success=True)
- plugin.query.side_effect = entry
- def prepare(p, route, *, role):
- self.assertEqual(role, "book")
- p.page.url = "https://prenotami.esteri.it/BookingCalendar"
- p._record_calendar_book_prepared_route(route)
- with patch.object(workflow, "prepare_calendar", side_effect=prepare) as prep:
- result = plugin.book(self.trigger, self.inputs)
- prep.assert_called_once()
- plugin.query.assert_called_once()
- self.assertEqual(result.label, "calendar-ready-before-final")
- self.assertIsNotNone(plugin.last_booking_precommit)
- def test_final_config_requires_explicit_supported_applicant_mode(self):
- for values, accepted in (({}, True), ({"otp_mode": "manual"}, True),
- ({"otp_mode": "cloud"}, True),
- ({"otp_mode": "cloud", "final_submit_enabled": True}, True),
- ({"otp_mode": "cloud", "query_mode": "calendar"}, True),
- ({"otp_mode": "cloud", "query_mode": "calendar", "final_submit_enabled": True}, False),
- ({"otp_mode": "cloud", "final_submit_enabled": "true"}, False),
- ({"otp_mode": "cloud", "final_submit_enabled": 1}, False),
- ({"otp_mode": "manual", "final_submit_enabled": True}, True),
- ({"final_submit_enabled": True}, False),
- ({"otp_mode": "manual", "final_submit_enabled": 1}, False),
- ({"otp_mode": "manual", "final_submit_enabled": True, "query_mode": "calendar"}, False)):
- with self.subTest(values=values):
- config = VSPlgConfig(free_config=values)
- if accepted:
- self.plugin.set_config(config)
- else:
- with self.assertRaises(BizLogicError):
- self.plugin.set_config(config)
- def test_no_inventory_never_calls_final(self):
- self.plugin.page = flow.FlowPage([flow.month(m, {}) for m in ("2026-10", "2026-11", "2026-12")])
- self.plugin._record_calendar_book_prepared_route(self.route)
- with patch.object(workflow, "submit_final") as submit, flow.browser_navigation(self.plugin.page):
- result = self.plugin.book(self.trigger, self.inputs)
- self.assertFalse(result.success)
- submit.assert_not_called()
- def test_query_or_another_applicant_cannot_book(self):
- for query_key, username in ((self.route.routing_key, self.inputs["username"]), (None, "other@example.test")):
- self.plugin._calendar_query_route_key = query_key
- with self.assertRaises(BizLogicError), patch.object(workflow, "submit_final") as submit:
- self.plugin.book(self.trigger, {"username": username})
- submit.assert_not_called()
- def test_unknown_attempt_cannot_rescan_or_submit_again(self):
- self.plugin._production_final_attempt = SimpleNamespace(state="unknown")
- with self.assertRaises(FinalOutcomeUnknown), patch.object(workflow, "submit_final") as submit:
- self.plugin.book(self.trigger, self.inputs)
- submit.assert_not_called()
- self.assertEqual(self.plugin.page.refreshes, 0)
- def test_cloud_unknown_attempt_is_not_retried(self):
- self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True)
- self.plugin._production_final_attempt = SimpleNamespace(state="unknown")
- with patch.object(workflow, "submit_final") as submit, \
- patch.object(workflow, "prepare_calendar") as prepare, self.assertRaises(FinalOutcomeUnknown):
- self.plugin.book(self.trigger, self.inputs)
- submit.assert_not_called()
- prepare.assert_not_called()
- self.assertEqual(self.plugin.page.refreshes, 0)
- def test_cloud_final_rejects_query_session_and_other_applicant(self):
- self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True)
- for query_key, username in ((self.route.routing_key, self.inputs["username"]), (None, "other@example.test")):
- self.plugin._calendar_query_route_key = query_key
- with patch.object(workflow, "submit_final") as submit, self.assertRaises(BizLogicError):
- self.plugin.book(self.trigger, {"username": username})
- submit.assert_not_called()
- def test_cloud_confirmed_result_does_not_create_second_booking(self):
- self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True)
- self.test_confirmed_result_can_be_reported_again_without_another_booking()
- def test_confirmed_result_can_be_reported_again_without_another_booking(self):
- result = VSBookResult(success=True, book_date="2026-10-13", book_time="09:26")
- self.plugin._production_final_attempt = SimpleNamespace(state="confirmed", target=SimpleNamespace(
- applicant=self.inputs["username"], routing_key=self.route.routing_key))
- self.plugin._production_book_result = result
- self.assertIs(self.plugin.book(self.trigger, self.inputs), result)
- self.assertEqual(self.plugin.page.refreshes, 0)
- def test_query_from_dashboard_prepares_once_and_never_returns_weak_positive(self):
- plugin = self.plugin
- plugin.query = MethodType(ItaPlugin.query, plugin)
- plugin.free_config["query_mode"] = "calendar"
- plugin.page.url = "https://prenotami.esteri.it/UserArea"
- plugin._calendar_book_prepared_context = None
- strong = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available,
- earliest_date=datetime(2026, 10, 13), apt_type=self.trigger.apt_type)
- plugin._query_once = Mock(side_effect=lambda apt, **kwargs: (
- VSQueryResult(success=True) if kwargs else strong))
- def prepare(p, route, *, role):
- self.assertEqual(role, "query")
- p.page.url = "https://prenotami.esteri.it/BookingCalendar"
- with patch.object(workflow, "prepare_calendar", side_effect=prepare) as prep:
- self.assertIs(plugin.query(self.trigger.apt_type), strong)
- self.assertIs(plugin.query(self.trigger.apt_type), strong)
- self.assertEqual(prep.call_count, 1)
- self.assertEqual(plugin._query_once.call_count, 3)
- def test_entry_no_availability_does_not_send_otp(self):
- self.plugin.page.url = "https://prenotami.esteri.it/UserArea"
- negative = VSQueryResult(success=False)
- self.plugin._query_once = Mock(return_value=negative)
- with patch.object(workflow, "prepare_calendar") as prep:
- self.assertIs(workflow.prepare_query_if_needed(self.plugin, self.trigger.apt_type), negative)
- prep.assert_not_called()
- def test_production_modules_never_import_debug_tools(self):
- root = Path(__file__).resolve().parents[1]
- for filename in ("ita_workflow.py", "ita_calendar_session.py"):
- tree = ast.parse((root / "plugins" / filename).read_text())
- imports = [n.module for n in ast.walk(tree) if isinstance(n, ast.ImportFrom)]
- self.assertFalse(any(name and name.startswith("tools") for name in imports))
- class FinalCompositionTests(TestCase):
- def setUp(self):
- attribution.AttributionTests.setUp(self)
- self.plugin._log = Mock()
- self.audit = Mock()
- self.before = {k: 0 for k in ("otpRequests", "avantiPosts", "availabilityRequests", "finalRequests", "timeSlotRequests")}
- self.after = {**self.before, "finalRequests": 1}
- self.audit.settled_snapshot.side_effect = [self.before, self.after]
- def add_confirmed(self):
- attribution.AttributionTests.add_confirmed(self)
- def run_final(self):
- def native_factory(page, target, current):
- native = Mock(side_effect=lambda: (self.add_confirmed(), SubmissionSignal.UNKNOWN)[1])
- native.submitted_selection = VerifiedSubmission(target)
- return native
- with patch.object(workflow.preparation, "CalendarRequestAudit", return_value=self.audit), \
- patch.object(workflow, "NativeFinalSubmitter", side_effect=native_factory) as factory:
- result = workflow.submit_final(self.plugin, self.route)
- self.assertEqual(factory.call_count, 1)
- return result
- def test_real_read_port_and_core_return_success_with_assigned_time(self):
- result = self.run_final()
- self.assertTrue(result.success)
- self.assertEqual(result.book_time, "09:26")
- self.assertEqual(self.plugin._production_final_attempt.state, "confirmed")
- self.assertIs(self.plugin._production_book_result, result)
- self.audit.stop.assert_called_once()
- def test_missing_request_audit_leaves_unknown_attempt_not_false_result(self):
- self.after["finalRequests"] = 0
- with self.assertRaises(FinalOutcomeUnknown):
- self.run_final()
- self.assertEqual(self.plugin._production_final_attempt.state, "unknown")
- self.audit.stop.assert_called_once()
- def test_audit_cleanup_failure_does_not_erase_confirmed_result(self):
- self.audit.stop.side_effect = RuntimeError("fixture")
- self.assertTrue(self.run_final().success)
- self.plugin._log.assert_called_once()
- class CloudFinalCompositionTests(FinalCompositionTests):
- """Cloud mode shares the real read-port, receipt attribution and no-retry core."""
- def setUp(self):
- super().setUp()
- self.plugin.free_config.update(otp_mode="cloud", final_submit_enabled=True)
- class RealFinalAuditTests(TestCase):
- """Real audit ownership + production final core, synthetic CDP/receipts."""
- def setUp(self):
- from test.test_debug_ita_production_query_gate import FakeAuditPage
- attribution.AttributionTests.setUp(self)
- self.plugin._log = Mock()
- transport = FakeAuditPage()
- self.main.driver = transport.driver
- self.main.run_cdp = transport.run_cdp
- self.transport = transport
- self.audit = preparation.CalendarRequestAudit(self.main, include_time_slots=True)
- self.audit.start = Mock(wraps=self.audit.start)
- self.audit.stop = Mock(wraps=self.audit.stop)
- self.addCleanup(self.audit.stop)
- clock = itertools.count(0, 0.1)
- self.enterContext(patch.object(preparation, "time", SimpleNamespace(
- monotonic=lambda: next(clock), sleep=lambda _seconds: None)))
- self.on_submit = lambda: transport.emit("/BookingCalendar/InsertNewBooking")
- self.native = Mock(side_effect=self.dispatch)
- def native_factory(page, target, current):
- self.assertIs(page, self.main)
- self.native.submitted_selection = VerifiedSubmission(target)
- return self.native
- self.factory = self.enterContext(patch.object(workflow, "NativeFinalSubmitter", side_effect=native_factory))
- def dispatch(self):
- self.on_submit()
- attribution.AttributionTests.add_confirmed(self)
- return SubmissionSignal.UNKNOWN
- def borrow(self):
- return workflow.submit_final(self.plugin, self.route, request_audit=self.audit)
- def test_shared_audit_counts_one_submit_and_remains_owned_by_caller(self):
- self.audit.start()
- callback = self.main.driver.immediate_event_handlers[self.audit.EVENT]
- self.assertTrue(self.borrow().success)
- self.native.assert_called_once()
- self.audit.start.assert_called_once()
- self.audit.stop.assert_not_called()
- self.audit.require_active_on(self.main)
- self.assertIs(self.main.driver.immediate_event_handlers[self.audit.EVENT], callback)
- self.assertEqual(self.audit.snapshot()["finalRequests"], 1)
- self.assertEqual(self.transport.commands.count("Network.enable"), 1)
- def test_standalone_production_still_owns_start_and_stop(self):
- with patch.object(preparation, "CalendarRequestAudit", return_value=self.audit) as factory:
- self.assertTrue(workflow.submit_final(self.plugin, self.route).success)
- factory.assert_called_once_with(self.main, include_time_slots=True)
- self.audit.start.assert_called_once()
- self.audit.stop.assert_called_once()
- self.assertEqual(self.main.driver.immediate_event_handlers, {})
- def test_nested_registration_without_explicit_borrow_still_refused(self):
- self.audit.start()
- with self.assertRaisesRegex(preparation.CalendarGateError, "existing callback"):
- workflow.submit_final(self.plugin, self.route)
- self.factory.assert_not_called()
- self.audit.require_active_on(self.main)
- self.browser.new_tab.assert_not_called()
- def test_existing_reservation_blocks_without_stopping_borrowed_audit(self):
- from plugins.ita_booking_final import FinalBookingError
- self.audit.start()
- attribution.AttributionTests.add_confirmed(self)
- with self.assertRaises(FinalBookingError):
- self.borrow()
- self.factory.assert_not_called()
- self.audit.stop.assert_not_called()
- self.audit.require_active_on(self.main)
- self.assertEqual(self.audit.snapshot()["finalRequests"], 0)
- def test_wrong_page_driver_stopped_or_disconnected_audit_never_submits(self):
- self.audit.start()
- for target, attribute, replacement in (
- (self.audit, "page", self.transport),
- (self.main, "driver", object()),
- (self.audit, "_started", False),
- (self.audit.driver, "is_running", False)):
- with self.subTest(attribute=attribute), patch.object(target, attribute, replacement):
- with self.assertRaises(preparation.CalendarGateError):
- self.borrow()
- self.factory.assert_not_called()
- self.browser.new_tab.assert_not_called()
- self.audit.stop.assert_not_called()
- def test_replaced_callback_is_not_overwritten_or_accepted_as_proof(self):
- self.audit.start()
- for handlers in (self.audit.driver.event_handlers, self.audit.driver.immediate_event_handlers):
- foreign = Mock()
- with patch.dict(handlers, {self.audit.EVENT: foreign}):
- with self.assertRaisesRegex(preparation.CalendarGateError, "callback changed"):
- self.borrow()
- self.assertIs(handlers[self.audit.EVENT], foreign)
- self.factory.assert_not_called()
- self.audit.stop.assert_not_called()
- def test_borrowed_audit_must_cover_time_slots(self):
- self.audit.start()
- with patch.dict(self.audit._counts, {"finalRequests": 0}, clear=True):
- with self.assertRaisesRegex(preparation.CalendarGateError, "include time slots"):
- self.borrow()
- self.factory.assert_not_called()
- self.browser.new_tab.assert_not_called()
- def test_callback_lost_during_submission_cannot_confirm_from_stale_counters(self):
- self.audit.start()
- foreign = Mock()
- handlers = self.audit.driver.immediate_event_handlers
- def lose_callback():
- self.transport.emit("/BookingCalendar/InsertNewBooking")
- handlers[self.audit.EVENT] = foreign
- self.on_submit = lose_callback
- with patch.dict(handlers):
- with self.assertRaises(FinalOutcomeUnknown):
- self.borrow()
- self.assertIs(handlers[self.audit.EVENT], foreign)
- self.assertEqual(self.plugin._production_final_attempt.state, "unknown")
- self.audit.stop.assert_not_called()
- self.native.assert_called_once()
- self.audit.require_active_on(self.main)
- def test_missing_duplicate_or_mixed_requests_do_not_become_success(self):
- for requests in ([], ["/BookingCalendar/InsertNewBooking"] * 2,
- ["/BookingCalendar/InsertNewBooking", "/BookingCalendar/RetrieveTimeSlots"]):
- with self.subTest(requests=requests):
- before_listing = self.browser.raw
- self.audit.start()
- self.on_submit = lambda: [self.transport.emit(path) for path in requests]
- try:
- with self.assertRaises(FinalOutcomeUnknown):
- self.borrow()
- self.assertEqual(self.plugin._production_final_attempt.state, "unknown")
- self.audit.require_active_on(self.main)
- finally:
- self.audit.stop()
- self.browser.raw = before_listing
- self.assertEqual(self.native.call_count, 3)
- class BookerReuseTests(TestCase):
- def setUp(self):
- # Reuse existing offline Redis import fixture; never open Redis/cloud.
- from test.test_ita_plugin import OrderBookerGCO
- from threading import RLock
- self.booker = OrderBookerGCO.__new__(OrderBookerGCO)
- self.booker.m_lock = RLock()
- self.booker.m_task_data_cache = {"fixture": {"status": "running", "order_id": "order", "user_inputs": {}}}
- self.booker._log = Mock()
- self.booker._remove_task = Mock()
- self.booker._push_success_notification = Mock()
- self.booker.redis_client = Mock()
- self.booker.m_tracker_key = "fixture"
- self.task = SimpleNamespace(task_ref="fixture", book_allowed=True, instance=Mock())
- self.api = Mock()
- api_patch = patch.dict(self.booker._execute_book_job.__func__.__globals__, VSCloudApi=self.api)
- api_patch.start()
- self.addCleanup(api_patch.stop)
- def test_standard_success_still_uses_existing_reporting(self):
- result = VSBookResult(success=True, book_date="2026-10-13", book_time="09:26")
- self.task.instance.book.return_value = result
- self.booker._execute_book_job(self.task, VSQueryResult())
- self.booker._push_success_notification.assert_called_once_with("fixture", "order", result)
- def test_unknown_pauses_using_existing_api_and_next_signal_does_nothing(self):
- self.task.instance.book.side_effect = FinalOutcomeUnknown()
- self.booker._execute_book_job(self.task, VSQueryResult())
- self.booker._execute_book_job(self.task, VSQueryResult())
- self.api.Instance.return_value.update_vas_task.assert_called_once_with("fixture", {"status": "pause"})
- self.assertFalse(self.task.book_allowed)
- self.task.instance.book.assert_called_once()
- self.booker._push_success_notification.assert_not_called()
- def test_pause_failure_keeps_task_blocked_locally(self):
- self.task.instance.book.side_effect = FinalOutcomeUnknown()
- self.api.Instance.return_value.update_vas_task.side_effect = RuntimeError("fixture")
- self.booker._execute_book_job(self.task, VSQueryResult())
- self.booker._execute_book_job(self.task, VSQueryResult())
- self.assertFalse(self.task.book_allowed)
- self.task.instance.book.assert_called_once()
- self.booker._remove_task.assert_not_called()
- class QueryCliTests(TestCase):
- def test_workflow_flag_reuses_route_builder_and_calls_standard_query(self):
- from tools import debug_ita_query as cli
- from test.test_debug_ita_calendar_gate import gate_env
- plugin = Mock()
- plugin.query.return_value = VSQueryResult(success=True, availability_status=AvailabilityStatus.Available,
- earliest_date=datetime(2026, 10, 13))
- stdout = StringIO()
- with patch.object(cli, "ItaPlugin", return_value=plugin), \
- patch.object(cli, "resolve_chrome_path", return_value=Path("/offline/chrome")), \
- patch.object(cli, "_get_query_credentials", return_value=("query@example.test", "fixture")), \
- patch.object(cli, "_prepare_query_profile", return_value=Path("/offline/profile")), \
- redirect_stdout(stdout):
- code = cli.run_query_once(gate_env(), non_interactive=False, production_workflow=True)
- self.assertEqual(code, 0)
- config = plugin.set_config.call_args.args[0]
- self.assertEqual(config.free_config["query_mode"], "calendar")
- self.assertEqual(config.free_config["otp_mode"], "manual")
- self.assertIs(config.free_config["final_submit_enabled"], False)
- plugin.query.assert_called_once()
- plugin.book.assert_not_called()
- plugin.cleanup.assert_called_once()
- self.assertIn("ITA_QUERY_WORKFLOW_RESULT=", stdout.getvalue())
- def test_headless_workflow_rejected_before_credentials(self):
- from tools import debug_ita_query as cli
- with patch.object(cli, "_get_query_credentials") as credentials:
- with self.assertRaises(cli.DebugConfigurationError):
- cli.run_query_once({}, non_interactive=True, production_workflow=True)
- credentials.assert_not_called()
|