"""Exercise the existing soak loop with real Italy Query and fake browser IO.""" import io import json import tempfile import time import unittest from contextlib import ExitStack, redirect_stderr, redirect_stdout from pathlib import Path from unittest.mock import Mock, patch from DrissionPage.errors import BrowserConnectError from plugins.ita_plugin import ItaPlugin from test.test_debug_ita_production_query_gate import gate_env from test.test_debug_ita_soak import FakeClock from test.test_ita_query_recovery import RecoveryPage, prepared_plugin from tools.debug_ita_calendar_gate import CalendarRequestAudit, ReservationSnapshot from tools.debug_ita_soak import ( CalendarSoakContext, calendar_soak_limits, main, run_soak, ) from tools.debug_ita_session import DebugConfigurationError class CalendarSoakLifecycleTests(unittest.TestCase): def run_case( self, outcomes=("available",), *, restored_outcomes=("available",), restore_outcome="calendar", duration=900, restart=0, max_sessions=0, end_snapshot=None, cleanup_failure=False, create_outcomes=("ok",), interrupt_wait=False, interrupt_health=False, soak_env=None, ): clock = FakeClock() output = io.StringIO() statuses = [] instances = [] pages = [] with tempfile.TemporaryDirectory() as task_tmp, ExitStack() as stack: profile = Path(task_tmp) / "profile" profile.mkdir(mode=0o700) profile = profile.resolve() # Match set_config's canonical macOS /private/var path. stack.enter_context(patch.object( CalendarRequestAudit, "settled_snapshot", CalendarRequestAudit.snapshot, )) stack.enter_context(patch("plugins.ita_plugin.time.sleep", clock.sleep)) stack.enter_context(patch( "tools.debug_ita_calendar_gate.read_reservation_snapshot", return_value=end_snapshot or ReservationSnapshot(0, 0), )) credentials = stack.enter_context(patch( "tools.debug_ita_soak._get_query_credentials", side_effect=AssertionError("must not reload credentials after preparation"), )) def make_instance(query_outcomes, *, restoring=False): page = RecoveryPage(query_outcomes, restore_outcome=restore_outcome) plugin, route = prepared_plugin(page) plugin.instance_id = f"offline-{len(instances)}" plugin._transient_user_data_path = str(Path(task_tmp) / plugin.instance_id / "user-data") plugin.root_workspace = str(Path(task_tmp) / plugin.instance_id) plugin._persistent_profile_path = profile plugin.user_data_path = str(profile) plugin.free_config["persistent_browser_profile_path"] = str(profile) plugin._profile_lock_handle = None plugin.tunnel = None plugin.book = Mock(side_effect=AssertionError("Book must not run in Query soak")) create_index = max(0, len(instances) - 1) create_outcome = create_outcomes[min(create_index, len(create_outcomes) - 1)] def create(): plugin._clear_calendar_query_state() if create_outcome == "connect-error": raise BrowserConnectError("offline connection failed") plugin.page.url = "https://prenotami.esteri.it/UserArea" plugin.is_healthy = True plugin.session_create_time = time.time() plugin.create_session = Mock(side_effect=create) def cleanup(): page.driver.is_running = False plugin.page = None plugin.is_healthy = False plugin._clear_calendar_query_state() if cleanup_failure: raise RuntimeError("private@example.test secret-token") plugin.cleanup = Mock(side_effect=cleanup) instances.append(plugin) pages.append(page) return plugin, route initial, route = make_instance(outcomes) audit = CalendarRequestAudit(initial.page, include_time_slots=True) audit.start() initial.page.emit("/BookingCalendar/GenerateOTP?ServiceID=9001", "GET") initial.page.emit("/Services/Booking/9001", "POST") context = CalendarSoakContext( plugin=initial, route=route, request_audit=audit, before=ReservationSnapshot(0, 0), ) if interrupt_health: initial.page.run_js = Mock(side_effect=KeyboardInterrupt) def factory(_group_id): return make_instance(restored_outcomes, restoring=True)[0] def sleep(seconds): if interrupt_wait: raise KeyboardInterrupt clock.sleep(seconds) with redirect_stdout(output), redirect_stderr(output): code = run_soak( gate_env() if soak_env is None else soak_env, apply=True, non_interactive=True, duration_seconds=duration, min_wait=300, max_wait=300, max_session_attempts=max_sessions, restart_after_probes=restart, plugin_factory=factory, prepared_calendar=context, sleep=sleep, monotonic=clock.monotonic, wall_time=clock.wall_time, randint=lambda minimum, maximum: minimum, status_writer=lambda body: statuses.append(json.loads(json.dumps(body))), ) credentials.assert_not_called() for instance in instances: instance.book.assert_not_called() for page in pages: self.assertEqual(page.driver.immediate_event_handlers, {}) result_lines = [line for line in output.getvalue().splitlines() if line.startswith("ITA_SOAK_CALENDAR_RESULT=")] self.assertEqual(len(result_lines), 1) report = json.loads(result_lines[0].split("=", 1)[1]) # Assert ownership before object finalizers can call cleanup again. cleanup_calls = [instance.cleanup.call_count for instance in instances] for instance in instances: instance.cleanup = Mock() # neutralize __del__, not loop verification return SimpleResult(code, report, statuses, output.getvalue(), instances, pages, cleanup_calls) def test_positive_negative_positive_continues_with_fresh_results(self): result = self.run_case(["available", "none", "available"]) self.assertEqual(result.code, 0, result.output) self.assertTrue(result.report["passed"]) self.assertEqual(result.report["positiveQueries"], 2) self.assertEqual(result.report["negativeQueries"], 1) self.assertEqual(result.report["queryRequests"]["availabilityRequests"], 5) self.assertEqual(result.report["queryRequests"]["timeSlotRequests"], 3) self.assertEqual(result.cleanup_calls, [1]) self.assertEqual(len(result.instances), 1) self.assertEqual(result.report["latestQuery"]["earliestDate"], "2026-08-12") self.assertNotIn("private@example.test", result.output) def test_controlled_restart_uses_same_profile_and_new_query_without_otp(self): result = self.run_case(restart=1) self.assertEqual(result.code, 0, result.output) self.assertTrue(result.report["controlledRestart"]) self.assertEqual(result.report["restores"], 1) self.assertEqual(result.cleanup_calls, [1, 1]) self.assertEqual(result.pages[0].refresh_calls, 1) self.assertGreater(result.pages[1].refresh_calls, 0) self.assertEqual(result.pages[1].get_calls, ["https://prenotami.esteri.it/BookingCalendar"]) for key in ("otpRequests", "avantiPosts", "finalRequests"): self.assertEqual(result.report["queryRequests"][key], 0) def test_prepared_context_owns_route_without_reloading_environment(self): result = self.run_case(restart=1, soak_env={}) self.assertEqual(result.code, 0, result.output) self.assertEqual(result.report["restores"], 1) self.assertEqual(result.cleanup_calls, [1, 1]) self.assertEqual(result.statuses[-1]["service_id"], 9001) def test_expired_session_rebuilds_then_continues_new_queries(self): result = self.run_case(["expired"]) self.assertEqual(result.code, 0, result.output) self.assertEqual(result.report["restores"], 1) self.assertEqual(result.cleanup_calls, [1, 1]) self.assertGreater(result.report["positiveQueries"], 0) self.assertEqual(result.instances[1].create_session.call_count, 1) def test_disconnect_recovers_but_reports_audit_gap_not_false_pass(self): result = self.run_case(["disconnect"]) self.assertEqual(result.code, 6, result.output) self.assertFalse(result.report["passed"]) self.assertEqual(result.report["auditGaps"], 1) self.assertEqual(result.report["restores"], 1) self.assertGreater(result.report["positiveQueries"], 0) self.assertEqual(result.cleanup_calls, [1, 1]) def test_two_expirations_stop_without_third_session(self): result = self.run_case(["expired"], restored_outcomes=["expired"]) self.assertEqual(result.code, 1, result.output) self.assertEqual(result.report["reason"], "consecutive-session-expirations") self.assertEqual(len(result.instances), 2) self.assertEqual(result.cleanup_calls, [1, 1]) def test_transient_network_failure_retries_same_browser(self): result = self.run_case(["timeout", "available"]) self.assertEqual(result.code, 0, result.output) self.assertEqual(len(result.instances), 1) self.assertGreater(result.report["positiveQueries"], 0) self.assertEqual(result.report["restores"], 0) def test_two_transient_failures_stop_without_relogin_or_third_probe(self): result = self.run_case(["timeout"]) self.assertEqual(result.code, 1, result.output) self.assertEqual(result.pages[0].attempts, 2) self.assertEqual(result.report["reason"], "consecutive-calendar-network-errors") self.assertEqual(len(result.instances), 1) def test_otp_reentry_is_pending_todo_not_attempted_again(self): result = self.run_case(["expired"], restore_outcome="form") self.assertEqual(result.code, 4, result.output) self.assertEqual(result.report["state"], "needs_manual") self.assertEqual(result.report["automaticOtpTodo"], "ITA-OTP-01") self.assertIsNone(result.report["latestQuery"]) self.assertEqual(result.pages[1].refresh_calls, 0) self.assertEqual(result.report["queryRequests"]["otpRequests"], 0) self.assertEqual(result.report["queryRequests"]["avantiPosts"], 0) def test_rate_limit_stops_without_account_rotation_or_relogin(self): result = self.run_case(["available", "rate"]) self.assertEqual(result.code, 5, result.output) self.assertEqual(result.report["state"], "rate_limited") self.assertEqual(len(result.instances), 1) self.assertEqual(result.pages[0].attempts, 2) self.assertIsNone(result.report["latestQuery"]) def test_permission_denied_stops_for_operator(self): result = self.run_case(["denied"]) self.assertEqual(result.code, 4, result.output) self.assertEqual(result.report["state"], "needs_manual") self.assertEqual(result.pages[0].attempts, 1) def test_unknown_schema_stops_without_false_inventory_or_secret_log(self): result = self.run_case(["malformed"]) self.assertEqual(result.code, 1, result.output) self.assertEqual(result.report["positiveQueries"], 0) self.assertEqual(result.report["negativeQueries"], 0) self.assertEqual(result.pages[0].attempts, 1) self.assertNotIn("secret-token", result.output) self.assertNotIn("private@example.test", result.output) def test_unexpected_write_request_cannot_pass(self): result = self.run_case(["unexpected-otp"]) self.assertNotEqual(result.code, 0, result.output) self.assertFalse(result.report["passed"]) self.assertEqual(result.report["queryRequests"]["otpRequests"], 1) self.assertEqual(result.report["positiveQueries"], 0) def test_wrong_service_after_relogin_stops_without_querying_it(self): result = self.run_case(["expired"], restore_outcome="wrong-service") self.assertEqual(result.code, 1, result.output) self.assertEqual(result.pages[1].refresh_calls, 0) self.assertFalse(result.report["passed"]) def test_unverified_reservation_counts_cannot_pass(self): result = self.run_case(end_snapshot=ReservationSnapshot(1, 0)) self.assertEqual(result.code, 6, result.output) self.assertFalse(result.report["passed"]) self.assertFalse(result.report["reservationVerified"]) def test_cancel_does_not_recreate_or_submit(self): result = self.run_case(interrupt_wait=True) self.assertEqual(result.code, 130, result.output) self.assertEqual(result.cleanup_calls, [1]) self.assertFalse(result.report["passed"]) def test_cancel_during_health_probe_cleans_up_without_relogin(self): result = self.run_case(interrupt_health=True) self.assertEqual(result.code, 130, result.output) self.assertEqual(result.cleanup_calls, [1]) self.assertEqual(len(result.instances), 1) self.assertEqual(result.pages[0].attempts, 0) self.assertFalse(result.report["passed"]) def test_cleanup_failure_is_not_reported_as_success(self): result = self.run_case(cleanup_failure=True) self.assertEqual(result.code, 3, result.output) self.assertFalse(result.report["passed"]) self.assertNotIn("secret-token", result.output) def test_connect_error_reuses_existing_bounded_creation_retry(self): result = self.run_case(["expired"], create_outcomes=["connect-error", "ok"]) self.assertEqual(result.code, 0, result.output) self.assertEqual(len(result.instances), 3) self.assertEqual(result.cleanup_calls, [1, 1, 1]) def test_session_attempt_cap_stops_instead_of_silently_finishing(self): result = self.run_case(["expired"], max_sessions=1) self.assertEqual(result.code, 1, result.output) self.assertEqual(result.report["reason"], "max-session-attempts-reached") self.assertEqual(len(result.instances), 1) def test_failed_cleanup_during_recovery_prevents_another_browser(self): result = self.run_case(["expired"], cleanup_failure=True) self.assertEqual(result.code, 3, result.output) self.assertEqual(result.report["reason"], "cleanup-failed") self.assertEqual(len(result.instances), 1) self.assertNotIn("ITA_SOAK_CLEANUP_OK", result.output) def test_two_connection_failures_stop_using_existing_cap(self): result = self.run_case(["expired"], create_outcomes=["connect-error"]) self.assertEqual(result.code, 1, result.output) self.assertEqual(result.report["reason"], "consecutive-browser-connect-failures") self.assertEqual(len(result.instances), 3) # prepared + two failed starts def test_two_disconnections_stop_without_third_browser(self): result = self.run_case(["disconnect"], restored_outcomes=["disconnect"]) self.assertEqual(result.code, 1, result.output) self.assertEqual(result.report["reason"], "consecutive-browser-disconnects") self.assertEqual(len(result.instances), 2) def test_hourly_reauthentication_cap_survives_successful_queries_between_failures(self): result = self.run_case(["expired"], restored_outcomes=["available", "expired"], duration=7200) self.assertEqual(result.code, 1, result.output) self.assertEqual(result.report["reason"], "reauthentication-rate-limit") self.assertEqual(len(result.instances), 7) def test_deadline_before_successful_retry_is_incomplete_not_a_pass(self): result = self.run_case(["timeout"], duration=60) self.assertEqual(result.code, 6, result.output) self.assertEqual(result.report["positiveQueries"], 0) def test_unexercised_requested_restart_is_not_marked_verified(self): result = self.run_case(restart=100) self.assertEqual(result.code, 6, result.output) self.assertFalse(result.report["controlledRestart"]) class SimpleResult: def __init__(self, code, report, statuses, output, instances, pages, cleanup_calls): self.code, self.report, self.statuses, self.output = code, report, statuses, output self.instances, self.pages, self.cleanup_calls = instances, pages, cleanup_calls class CalendarSoakCliTests(unittest.TestCase): def test_gate_transfers_the_same_prepared_instance_and_cleanup_once(self): from test import test_debug_ita_production_query_gate as workflow from tools.debug_ita_calendar_gate import CalendarGateMode def soak(_env, *, plugin, route, request_audit, before): self.assertEqual(route.service_id, 9001) self.assertEqual(before, ReservationSnapshot(0, 0)) self.assertEqual(request_audit.snapshot()["otpRequests"], 1) self.assertEqual(request_audit.snapshot()["avantiPosts"], 1) plugin.page.set.auto_handle_alert.assert_called_with(accept=False) request_audit.stop() plugin.cleanup() return 0 with patch("tools.debug_ita_calendar_gate.resolve_qcal_mode", return_value=CalendarGateMode.CALENDAR_SOAK), \ patch("tools.debug_ita_soak.run_prepared_calendar_soak", side_effect=soak) as handoff: code, output, plugin, page, mocks, otp_reader = workflow.ProductionGateWorkflowTests()._run_gate() self.assertEqual(code, 0, output) handoff.assert_called_once() otp_reader.assert_called_once() plugin.cleanup.assert_called_once() mocks["run_production_query_acceptance"].assert_not_called() mocks["scan_calendar_horizon"].assert_not_called() def test_preflight_checks_calendar_config_without_credentials_or_browser(self): output = io.StringIO() with patch.dict("os.environ", gate_env(), clear=True), \ patch("tools.debug_ita_calendar_gate.run_calendar_gate") as run, \ patch("tools.debug_ita_soak._get_query_credentials") as credentials, \ redirect_stdout(output): code = main(["--calendar", "--duration-seconds", "900"]) self.assertEqual(code, 0) run.assert_not_called() credentials.assert_not_called() self.assertIn("external_request=false", output.getvalue()) def test_unsafe_cadence_is_rejected_before_gate_or_otp(self): with patch.dict("os.environ", gate_env(), clear=True), \ patch("tools.debug_ita_calendar_gate.run_calendar_gate") as run, \ redirect_stderr(io.StringIO()): code = main(["--calendar", "--run", "--min-wait", "10"]) self.assertEqual(code, 2) run.assert_not_called() def test_actual_gate_is_only_entered_with_run(self): with patch.dict("os.environ", gate_env(), clear=True), \ patch("tools.debug_ita_calendar_gate.run_calendar_gate", return_value=0) as run: self.assertEqual(main(["--calendar", "--run", "--restart-after-probes", "1"]), 0) env = run.call_args.args[0] self.assertEqual(env["ITA_QCAL_MODE"], "calendar_soak") self.assertEqual(env["ITA_SOAK_RESTART_AFTER_PROBES"], "1") def test_limits_reject_bad_values_before_external_actions(self): for value in ("nan", "0", "86401"): with self.subTest(value=value), self.assertRaises(DebugConfigurationError): calendar_soak_limits({"ITA_SOAK_DURATION_SECONDS": value}) if __name__ == "__main__": unittest.main()