| 123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257 |
- """Offline regressions for notification, booking and traffic controls."""
- import json
- import os
- import tempfile
- import threading
- import types
- import unittest
- from datetime import datetime
- from pathlib import Path
- from unittest.mock import MagicMock, patch
- from booker import BuiltinBookerGCO
- from core_types import (AppointmentType, AvailabilityStatus, BookResult, BookerStandaloneConfig,
- DateAvailability, GroupConfig, PluginConfig, QueryResult, Task, BizLogicError)
- from plugins.grc_plugin import GrcPlugin
- from plugins.usa_plugin import UsaPlugin
- from plugins.vfs_plugin import VfsPlugin
- from sentinel import SentinelGCO
- from standalone import StandaloneGCO
- from toolkit.notifier import notify_book_result, notify_date_changes
- from utils.booking_outbox import BookingOutbox
- from toolkit import notifier
- from collections import OrderedDict
- from plugin_factory import PluginFactory
- class BookingReliabilityTests(unittest.TestCase):
- def setUp(self):
- self.tmp = tempfile.TemporaryDirectory()
- self.addCleanup(self.tmp.cleanup)
- env = patch.dict(os.environ, {'BOOKING_OUTBOX_PATH': str(Path(self.tmp.name) / 'outbox.sqlite3')})
- env.start()
- self.addCleanup(env.stop)
- network = patch('socket.socket.connect', side_effect=AssertionError('Network forbidden in tests'))
- network.start()
- self.addCleanup(network.stop)
- for name, value in (('_pending', {}), ('_sent', OrderedDict()), ('_slot_states', {})):
- state = patch.object(notifier, name, value)
- state.start()
- self.addCleanup(state.stop)
- self.cloud = MagicMock()
- cloud = patch('toolkit.cloud_api.CloudApi.Instance', return_value=self.cloud)
- cloud.start()
- self.addCleanup(cloud.stop)
- self.apt = AppointmentType(routing_key='audit.slot')
- self.available = QueryResult(success=True, apt_type=self.apt,
- availability_status=AvailabilityStatus.Available,
- earliest_date=datetime(2026, 11, 1),
- availability=[DateAvailability(date=datetime(2026, 11, 1))])
- def pending(self):
- return len(notifier._pending)
- def test_notifications_do_not_use_telemetry_executor(self):
- with patch('toolkit.task_executor.submit_background', return_value=False):
- self.assertTrue(notify_date_changes(self.available))
- self.assertTrue(notify_book_result(BookResult(success=True, urn='confirmed')))
- self.assertEqual(self.pending(), 2)
- notifier._flush_pending(self.cloud, lambda _: None)
- self.assertEqual(self.cloud.push_weixin_text.call_count, 2)
- self.assertEqual(self.pending(), 0)
- def test_full_memory_queue_does_not_advance_slot_cache(self):
- cache = {}
- with patch.object(notifier, '_MAX_PENDING', 0):
- self.assertFalse(notify_date_changes(self.available, cache, logger=lambda _: None))
- self.assertEqual(cache, {})
- self.assertTrue(notify_date_changes(self.available, cache))
- def test_plugin_preferences_mutation_does_not_change_configuration(self):
- preferences = {'email': 'audit@example.invalid'}
- g = BuiltinBookerGCO(GroupConfig(identifier='audit', enable=True), {}, logger=lambda _: None)
- self.addCleanup(g.redis_client.close)
- g.redis_client = MagicMock()
- self.cloud.get_vas_task_pop.return_value = {'id': 42, 'user_inputs': preferences}
- def book(_, inputs):
- inputs['alias_email'] = 'generated@example.invalid'
- return BookResult(success=False)
- plugin = MagicMock(config=PluginConfig())
- plugin.book.side_effect = book
- g._execute_book_job(Task(instance=plugin), self.available)
- plugin.book.assert_called_once()
- self.assertNotIn('alias_email', preferences)
- def test_failed_delivery_retries_without_duplicate_enqueue(self):
- self.cloud.push_weixin_text.side_effect = RuntimeError('offline')
- notify_date_changes(self.available)
- notifier._flush_pending(self.cloud, lambda _: None)
- self.assertFalse(notify_date_changes(self.available))
- self.assertEqual(self.pending(), 1)
- self.cloud.push_weixin_text.side_effect = None
- with patch('toolkit.notifier.time.time', return_value=9999999999):
- notifier._flush_pending(self.cloud, lambda _: None)
- self.assertEqual(self.pending(), 0)
- def test_reopened_same_date_and_new_time_and_waitlist_notify(self):
- notify_date_changes(self.available)
- notify_date_changes(QueryResult(apt_type=self.apt))
- notify_date_changes(self.available)
- from core_types import TimeSlot
- modified = self.available.model_copy(deep=True)
- modified.availability[0].times.append(TimeSlot(time='10:00'))
- notify_date_changes(modified)
- notify_date_changes(QueryResult(success=True, apt_type=self.apt,
- availability_status=AvailabilityStatus.Waitlist))
- self.assertEqual(self.pending(), 4)
- def sentinel(self):
- g = SentinelGCO(GroupConfig(identifier='audit', enable=True), {}, logger=lambda _: None)
- self.addCleanup(g.redis_client.close)
- g.redis_client = MagicMock()
- g.redis_client.get.return_value = None
- plugin = MagicMock(config=PluginConfig())
- return g, plugin, Task(instance=plugin, next_health_check=float('inf'))
- def test_unavailable_result_replaces_positive_signal(self):
- g, plugin, task = self.sentinel()
- plugin.query.side_effect = [self.available, QueryResult()]
- with patch('sentinel.notify_date_changes'):
- g._monitor_task(task, self.apt)
- g._monitor_task(task, self.apt)
- self.assertEqual(g.redis_client.setex.call_count, 2)
- last = json.loads(g.redis_client.setex.call_args.args[2])
- self.assertFalse(last['query_result']['success'])
- self.assertEqual(last['query_result']['availability_status'], AvailabilityStatus.NoneAvailable.value)
- def test_vfs_window_has_hard_six_month_budget(self):
- self.assertEqual(len(VfsPlugin._get_filtered_covered_months(None, '2000-01-01', '2100-01-01', '2026-10-25')), 6)
- def test_grc_does_not_replay_post_on_read_timeout(self):
- session = MagicMock()
- session.request.side_effect = TimeoutError('response lost after commit')
- plugin = types.SimpleNamespace(session=session, config=PluginConfig(), _log=lambda _: None,
- _init_session=lambda **_: session)
- plugin._perform_request = types.MethodType(GrcPlugin._perform_request, plugin)
- with self.assertRaises(TimeoutError), patch('plugins.grc_plugin.time.sleep'):
- plugin._perform_request('POST', 'https://example.invalid/reservation')
- session.request.assert_called_once()
- def test_booking_outbox_queues_success_notification(self):
- outbox = BookingOutbox()
- outbox.put(42, 'tracker', {'status': 'grabbed', 'grabbed_history': {'urn': 'receipt'}})
- BookingOutbox(outbox.path).flush(self.cloud, MagicMock(), lambda _: None)
- self.assertEqual(self.pending(), 1)
- self.assertIsNone(outbox.get(42))
- def test_standalone_success_stops_further_booking_in_current_process(self):
- cfg = BookerStandaloneConfig(identifier='audit', appointment_types=[self.apt])
- g = StandaloneGCO(cfg, {}, logger=lambda _: None)
- self.addCleanup(g.redis_client.close)
- plugin = MagicMock()
- plugin.query.return_value = self.available
- plugin.book.return_value = BookResult(success=True, urn='receipt')
- g.m_instance = plugin
- stopped = threading.Event()
- g.m_stop_event = MagicMock()
- g.m_stop_event.is_set.side_effect = stopped.is_set
- waits = []
- def wait(*_):
- waits.append(1)
- if len(waits) >= 2:
- stopped.set()
- return stopped.is_set()
- g.m_stop_event.wait.side_effect = wait
- with patch.object(g, '_get_wait_interval', return_value=0):
- g._worker_loop()
- plugin.book.assert_called_once()
- self.assertEqual(g._booking_outcome[1].urn, 'receipt')
- def test_usa_rejects_click_as_success_and_accepts_confirmation(self):
- element = MagicMock()
- element.parent.return_value.text = '09:00'
- element.text = ''
- page = MagicMock()
- page.url = 'https://example.invalid/schedule'
- page.ele.return_value = element
- plugin = types.SimpleNamespace(page=page, mouse=MagicMock(), config=PluginConfig(),
- _random_sleep=lambda *_: None, _log=lambda _: None)
- with patch('plugins.usa_plugin.time.sleep'), self.assertRaises(BizLogicError):
- UsaPlugin.book(plugin, self.available, {})
- page.url = 'https://example.invalid/appointment-confirmation/'
- element.text = 'Confirmed: 2026-11-01'
- self.assertTrue(UsaPlugin.book(plugin, self.available, {}).success)
- def test_vfs_payment_resolution_error_preserves_confirmed_booking(self):
- route = {'subcategory_code': 'sub'}
- plugin = types.SimpleNamespace(
- _log=lambda _: None, config=PluginConfig(), free_config={'apt_configs': {self.apt.routing_key: route}},
- subcategory_conf={'sub': {}}, booking_wait_applied=True,
- _fetch_configurations=MagicMock(), _add_primary_applicant=MagicMock(return_value='receipt'),
- _get_filtered_covered_months=MagicMock(return_value=['2026-11-01']),
- _query_slot_calendar=MagicMock(return_value=['2026-11-01']),
- _saveuseractionaudit=MagicMock(return_value=True),
- _query_slot_time=MagicMock(return_value=[{'allocationId': '1', 'slot': '09:00'}]),
- _submit_no_addition_service=MagicMock(), _query_fee=MagicMock(return_value=(1, 'EUR')),
- _schedule=MagicMock(return_value={'IsAppointmentBooked': True, 'isPaymentRequired': True}),
- _pay_request=MagicMock(side_effect=TimeoutError('payment redirect lost')))
- plugin.book = types.MethodType(VfsPlugin.book, plugin)
- receipt = plugin.book(self.available,
- {'email': 'audit@example.invalid', 'expected_start_date': '2026-11-01',
- 'expected_end_date': '2026-12-01'})
- self.assertTrue(receipt.success)
- self.assertEqual(receipt.urn, 'receipt')
- def test_unsupported_adapters_fail_before_browser_or_order_consumption(self):
- root = Path(__file__).resolve().parent.parent
- for name in ('bel', 'pol', 'prt'):
- factory = PluginFactory()
- factory.register_plugin(name + '_plugin', str(root / 'plugins' / (name + '_plugin.py')),
- name.title() + 'Plugin')
- with self.assertRaises(NotImplementedError):
- factory.ensure_booking_supported(name + '_plugin')
- def test_proxy_host_ports_and_native_listeners_default_to_loopback(self):
- import yaml
- from start_proxy import secure_listener_config
- root = Path(__file__).resolve().parent.parent
- compose = yaml.safe_load((root / 'docker-compose.yml').read_text(encoding='utf-8'))
- self.assertTrue(all(str(port).startswith('127.0.0.1:')
- for port in compose['services']['proxy']['ports']))
- cfg = secure_listener_config({'allow-lan': True, 'listeners': [{'listen': '0.0.0.0', 'port': 16001}]})
- self.assertFalse(cfg['allow-lan'])
- self.assertEqual(cfg['bind-address'], '127.0.0.1')
- self.assertEqual(cfg['listeners'][0]['listen'], '127.0.0.1')
- def test_expired_and_unavailable_signals_never_start_booking(self):
- g = BuiltinBookerGCO(GroupConfig(identifier='audit', enable=True,
- appointment_types=[self.apt]), {}, logger=lambda _: None)
- self.addCleanup(g.redis_client.close)
- g.redis_client = MagicMock()
- g.redis_client.get.return_value = None
- g.m_tasks = [Task(instance=MagicMock(), acceptable_routing_keys=[self.apt.routing_key])]
- for payload in [
- {'apt_type': self.apt.model_dump(), 'query_result': self.available.to_snapshot_payload(), 'expires_at': 1},
- {'apt_type': self.apt.model_dump(), 'query_result': QueryResult().to_snapshot_payload()},
- ]:
- g.redis_client.mget.return_value = [json.dumps(payload)]
- with patch.object(g._executor, 'submit') as submit:
- g._poll_booking_signals()
- submit.assert_not_called()
- def test_confirmed_success_supersedes_pending_pause(self):
- outbox = BookingOutbox()
- outbox.put(42, 'tracker', {'status': 'pause'})
- outbox.put(42, 'tracker', {'status': 'grabbed', 'grabbed_history': {'urn': 'receipt'}})
- outbox.put(42, 'tracker', {'status': 'pause'})
- self.assertEqual(outbox.get(42)['status'], 'grabbed')
- if __name__ == '__main__':
- unittest.main()
|