from datetime import datetime, time, timedelta from types import SimpleNamespace from unittest.mock import Mock, call import pytest import script as script_module from module.config import anti_ban as anti_ban_module from tasks.Script.config_antiban import AntiBan from tasks.Script.config_optimization import Optimization, WhenTaskQueueEmpty @pytest.fixture def scheduler(monkeypatch): clock = SimpleNamespace(now=datetime(2026, 10, 23, 3)) class Clock(datetime): @classmethod def now(cls): return clock.now monkeypatch.setattr(script_module, 'datetime', Clock) monkeypatch.setattr(anti_ban_module, 'datetime', Clock) task = SimpleNamespace(command='Exploration', next_run=clock.now - timedelta(minutes=1)) script = object.__new__(script_module.Script) script._emulator_down = False script.instance_guard = None script.state_queue = None script.anti_ban_guard = anti_ban_module.AntiBanGuard() script.config = SimpleNamespace( script=SimpleNamespace( anti_ban=AntiBan(enable=True), optimization=Optimization( close_game_wait_duration=time(12), close_emulator_wait_duration=time(0, 1), ), ), get_next=Mock(return_value=task), ) script._try_acquire_queue_token = Mock(return_value=True) script.device = Mock() script.run = Mock(return_value=True) script._wait_until_with_emulator_preheat = Mock(return_value=True) def finish_wait(future): clock.now = future + timedelta(seconds=1) return True script.wait_until = Mock(side_effect=finish_wait) events = Mock() events.attach_mock(script.device.app_stop, 'close_game') events.attach_mock(script.device.emulator_stop, 'close_emulator') events.attach_mock(script.device.release_during_wait, 'release') events.attach_mock(script.run, 'run') events.attach_mock(script.wait_until, 'wait') return script, clock, task, events @pytest.mark.parametrize('method', list(WhenTaskQueueEmpty)) @pytest.mark.parametrize('trigger', ['sleep_window', 'active_limit']) def test_anti_ban_finishes_using_selected_action_before_waiting(scheduler, method, trigger): script, clock, task, events = scheduler script.config.script.optimization.when_task_queue_empty = method original_next_run = task.next_run if trigger == 'active_limit': config = script.config.script.anti_ban config.sleep_start = config.sleep_end = time(0) config.daily_active_limit = timedelta(hours=1) config.long_rest_duration = timedelta(minutes=5) script.anti_ban_guard.record_active(3600) wake = clock.now + config.long_rest_duration else: wake = clock.now.replace(hour=8) assert script.get_next_task() == 'Exploration' # Both ordinary idle thresholds would change the requested action: # the game-close threshold is longer than the rest, the emulator threshold shorter. if method == WhenTaskQueueEmpty.CLOSE_GAME: assert events.mock_calls == [ call.close_game(), call.release(), call.wait(wake), call.run('Restart'), ] else: assert events.mock_calls == [ call.run('GotoMain'), call.release(), call.wait(wake), ] assert script.config.get_next.call_count == 2 assert task.next_run == original_next_run script._wait_until_with_emulator_preheat.assert_not_called() @pytest.mark.parametrize('method', list(WhenTaskQueueEmpty)) @pytest.mark.parametrize('trigger', ['sleep_window', 'active_limit']) def test_anti_ban_waits_for_running_task_to_finish(scheduler, monkeypatch, method, trigger): script, clock, task, events = scheduler clock.now = datetime(2026, 10, 23, 1, 59, 30) task.next_run = clock.now - timedelta(minutes=1) script.config_name = 'anti_ban_test' script.is_first_task = False script.failure_record = {} script.config.model = SimpleNamespace(running_task='') script.config.script.device = SimpleNamespace(run_background_only=True) script.config.script.optimization.when_task_queue_empty = method script.device.is_desktop = False if trigger == 'active_limit': config = script.config.script.anti_ban config.sleep_start = config.sleep_end = time(0) config.daily_active_limit = timedelta(minutes=1) config.long_rest_duration = timedelta(minutes=5) check_anti_ban = Mock(wraps=script.anti_ban_guard.wake_time) monkeypatch.setattr(script.anti_ban_guard, 'wake_time', check_anti_ban) monkeypatch.setattr(script_module.logger, 'set_file_logger', Mock()) monkeypatch.setattr(script_module, 'del_cached_property', Mock()) task_finished = False def run(command): nonlocal task_finished if command == 'Exploration': assert script.config.model.running_task == 'Exploration' # Cross the sleep start / active limit while the same task is still running. clock.now += timedelta(minutes=1) assert check_anti_ban.call_count == 1 assert events.mock_calls == [call.run('Exploration')] clock.now += timedelta(minutes=1) task_finished = True events.task_complete() else: assert command == 'GotoMain' assert task_finished return True class RestStarted(Exception): pass def wait(future): assert task_finished assert script.config.model.running_task == '' assert check_anti_ban.call_count == 2 raise RestStarted script.run.side_effect = run script.wait_until.side_effect = wait with pytest.raises(RestStarted): script.loop() wake = (clock.now + timedelta(minutes=5) if trigger == 'active_limit' else clock.now.replace(hour=8, minute=0, second=0)) cleanup = call.close_game() if method == WhenTaskQueueEmpty.CLOSE_GAME else call.run('GotoMain') assert events.mock_calls == [ call.run('Exploration'), call.task_complete(), cleanup, call.release(), call.wait(wake), ] @pytest.mark.parametrize('method', list(WhenTaskQueueEmpty)) def test_disabling_anti_ban_during_wait_reloads_without_delaying_pending_task( scheduler, monkeypatch, method): script, clock, task, events = scheduler script.config.script.optimization.when_task_queue_empty = method original_next_run = task.next_run script.wait_until.side_effect = None script.wait_until.return_value = False def reload_config(instance, name): assert instance is script assert name == 'config' script.config.script.anti_ban.enable = False reload = Mock(side_effect=reload_config) monkeypatch.setattr(script_module, 'del_cached_property', reload) assert script.get_next_task() == 'Exploration' reload.assert_called_once_with(script, 'config') script.wait_until.assert_called_once_with(clock.now.replace(hour=8)) assert task.next_run == original_next_run assert call.run('Restart') not in events.mock_calls @pytest.mark.parametrize('method', list(WhenTaskQueueEmpty)) def test_anti_ban_keeps_stopped_emulator_off_without_preheating(scheduler, method): script, clock, task, events = scheduler script.config.script.optimization.when_task_queue_empty = method script._emulator_down = True assert script.get_next_task() == 'Exploration' assert events.mock_calls == [call.wait(datetime(2026, 10, 23, 8))] script._wait_until_with_emulator_preheat.assert_not_called() assert script._emulator_down is True def test_ordinary_short_idle_keeps_game_open_below_close_threshold(scheduler): script, clock, task, events = scheduler script.config.script.optimization.when_task_queue_empty = WhenTaskQueueEmpty.CLOSE_GAME next_run = clock.now + timedelta(seconds=30) assert script._handle_wait_during_idle(next_run) is True assert events.mock_calls == [call.release(), call.wait(next_run)] @pytest.mark.parametrize('method', list(WhenTaskQueueEmpty)) def test_ordinary_long_idle_still_closes_emulator_at_configured_threshold(scheduler, method): script, clock, task, events = scheduler script.config.script.optimization.when_task_queue_empty = method next_run = clock.now + timedelta(minutes=5) assert script._handle_wait_during_idle(next_run) is True assert events.mock_calls == [call.close_emulator(), call.run('Restart')] script._wait_until_with_emulator_preheat.assert_called_once_with(next_run)