| from contextlib import contextmanager |
| from pathlib import Path |
| import threading |
| import asyncio |
| from types import SimpleNamespace |
|
|
| from src.config.constants import EmailServiceType |
| from src.core.register import RegistrationResult |
| from src.database.models import Account, Base, EmailService, RegistrationTask |
| from src.database.session import DatabaseSessionManager |
| from src.web.routes import registration as registration_routes |
|
|
|
|
| def _make_session_manager(name): |
| runtime_dir = Path("tests_runtime") |
| runtime_dir.mkdir(exist_ok=True) |
| db_path = runtime_dir / name |
| if db_path.exists(): |
| db_path.unlink() |
| manager = DatabaseSessionManager(f"sqlite:///{db_path}") |
| Base.metadata.create_all(bind=manager.engine) |
| return manager |
|
|
|
|
| @contextmanager |
| def _patched_get_db(manager): |
| session = manager.SessionLocal() |
| try: |
| yield session |
| finally: |
| session.close() |
|
|
|
|
| def _seed_outlook_services(session): |
| first = EmailService( |
| service_type="outlook", |
| name="Outlook A", |
| config={ |
| "email": "reserved-a@example.com", |
| "client_id": "client-a", |
| "refresh_token": "refresh-a", |
| }, |
| enabled=True, |
| priority=0, |
| ) |
| second = EmailService( |
| service_type="outlook", |
| name="Outlook B", |
| config={ |
| "email": "available-b@example.com", |
| "client_id": "client-b", |
| "refresh_token": "refresh-b", |
| }, |
| enabled=True, |
| priority=1, |
| ) |
| session.add_all([first, second]) |
| session.commit() |
| session.refresh(first) |
| session.refresh(second) |
| return first, second |
|
|
|
|
| def _seed_failed_outlook_placeholder(session, email, service_name="placeholder"): |
| account = Account( |
| email=email, |
| password="", |
| email_service="outlook", |
| email_service_id=str(service_name), |
| status="failed", |
| source="register", |
| extra_data={ |
| "register_failed_reason": "username_rejected_or_existing_account", |
| }, |
| ) |
| session.add(account) |
| session.commit() |
| session.refresh(account) |
| return account |
|
|
|
|
| def _seed_recoverable_outlook_account(session, email, service_name="placeholder"): |
| account = Account( |
| email=email, |
| password="saved-password", |
| email_service="outlook", |
| email_service_id=str(service_name), |
| status="failed", |
| source="register", |
| extra_data={ |
| "register_failed_reason": "token_recovery_pending", |
| "recovery_ready": True, |
| "account_created": True, |
| "token_acquired": False, |
| }, |
| ) |
| session.add(account) |
| session.commit() |
| session.refresh(account) |
| return account |
|
|
|
|
| def _patch_registration_selection(monkeypatch, selected): |
| def fake_create(service_type, config, name=None): |
| selected["service_type"] = service_type |
| selected["config"] = dict(config) |
| selected["name"] = name |
| return SimpleNamespace(service_type=service_type, config=config, name=name) |
|
|
| def fake_run(self): |
| return RegistrationResult(success=False, error_message="stop after selection") |
|
|
| monkeypatch.setattr(registration_routes.EmailServiceFactory, "create", fake_create) |
| monkeypatch.setattr(registration_routes.RegistrationEngine, "run", fake_run) |
|
|
|
|
| def test_outlook_execution_uses_task_bound_email_service_id_when_runtime_arg_is_none(monkeypatch): |
| manager = _make_session_manager("outlook-selection-bound.db") |
| selected = {} |
|
|
| with manager.session_scope() as session: |
| first, second = _seed_outlook_services(session) |
| session.add( |
| RegistrationTask( |
| task_uuid="task-bound-email-service", |
| status="pending", |
| email_service_id=second.id, |
| ) |
| ) |
| session.commit() |
|
|
| @contextmanager |
| def fake_get_db(): |
| with _patched_get_db(manager) as session: |
| yield session |
|
|
| monkeypatch.setattr(registration_routes, "get_db", fake_get_db) |
| _patch_registration_selection(monkeypatch, selected) |
|
|
| registration_routes._run_sync_registration_task( |
| task_uuid="task-bound-email-service", |
| email_service_type="outlook", |
| proxy=None, |
| email_service_config=None, |
| email_service_id=None, |
| ) |
|
|
| assert selected["service_type"] == EmailServiceType.OUTLOOK |
| assert selected["config"]["email"] == "available-b@example.com" |
| assert selected["config"]["client_id"] == "client-b" |
|
|
|
|
| def test_outlook_auto_selection_skips_failed_placeholder_account(monkeypatch): |
| manager = _make_session_manager("outlook-selection-failed-placeholder.db") |
| selected = {} |
|
|
| with manager.session_scope() as session: |
| first, second = _seed_outlook_services(session) |
| _seed_failed_outlook_placeholder(session, "reserved-a@example.com") |
| session.add( |
| RegistrationTask( |
| task_uuid="task-skip-failed-placeholder", |
| status="pending", |
| ) |
| ) |
| session.commit() |
|
|
| @contextmanager |
| def fake_get_db(): |
| with _patched_get_db(manager) as session: |
| yield session |
|
|
| monkeypatch.setattr(registration_routes, "get_db", fake_get_db) |
| _patch_registration_selection(monkeypatch, selected) |
|
|
| registration_routes._run_sync_registration_task( |
| task_uuid="task-skip-failed-placeholder", |
| email_service_type="outlook", |
| proxy=None, |
| email_service_config=None, |
| email_service_id=None, |
| ) |
|
|
| assert selected["service_type"] == EmailServiceType.OUTLOOK |
| assert selected["config"]["email"] == "available-b@example.com" |
| assert selected["config"]["client_id"] == "client-b" |
|
|
|
|
| def test_outlook_auto_selection_reports_consumed_accounts_with_clear_error(monkeypatch): |
| manager = _make_session_manager("outlook-selection-all-consumed.db") |
|
|
| with manager.session_scope() as session: |
| first, second = _seed_outlook_services(session) |
| _seed_failed_outlook_placeholder(session, "reserved-a@example.com") |
| _seed_failed_outlook_placeholder(session, "available-b@example.com") |
| session.add( |
| RegistrationTask( |
| task_uuid="task-all-consumed", |
| status="pending", |
| ) |
| ) |
| session.commit() |
|
|
| @contextmanager |
| def fake_get_db(): |
| with _patched_get_db(manager) as session: |
| yield session |
|
|
| monkeypatch.setattr(registration_routes, "get_db", fake_get_db) |
|
|
| registration_routes._run_sync_registration_task( |
| task_uuid="task-all-consumed", |
| email_service_type="outlook", |
| proxy=None, |
| email_service_config=None, |
| email_service_id=None, |
| ) |
|
|
| with _patched_get_db(manager) as session: |
| task = session.query(RegistrationTask).filter_by(task_uuid="task-all-consumed").first() |
|
|
| assert task.status == "failed" |
| assert "已消耗" in (task.error_message or "") |
| assert "Outlook" in (task.error_message or "") |
|
|
|
|
| def test_outlook_bound_consumed_service_is_rejected_before_engine_runs(monkeypatch): |
| manager = _make_session_manager("outlook-selection-bound-consumed.db") |
| selected = {} |
|
|
| with manager.session_scope() as session: |
| first, second = _seed_outlook_services(session) |
| _seed_failed_outlook_placeholder(session, "available-b@example.com") |
| session.add( |
| RegistrationTask( |
| task_uuid="task-bound-consumed", |
| status="pending", |
| email_service_id=second.id, |
| ) |
| ) |
| session.commit() |
|
|
| @contextmanager |
| def fake_get_db(): |
| with _patched_get_db(manager) as session: |
| yield session |
|
|
| monkeypatch.setattr(registration_routes, "get_db", fake_get_db) |
|
|
| def fake_create(service_type, config, name=None): |
| selected["service_type"] = service_type |
| selected["config"] = dict(config) |
| selected["name"] = name |
| return SimpleNamespace(service_type=service_type, config=config, name=name) |
|
|
| def fake_run(self): |
| selected["engine_ran"] = True |
| return RegistrationResult(success=False, error_message="should not be reached") |
|
|
| monkeypatch.setattr(registration_routes.EmailServiceFactory, "create", fake_create) |
| monkeypatch.setattr(registration_routes.RegistrationEngine, "run", fake_run) |
|
|
| registration_routes._run_sync_registration_task( |
| task_uuid="task-bound-consumed", |
| email_service_type="outlook", |
| proxy=None, |
| email_service_config=None, |
| email_service_id=None, |
| ) |
|
|
| with _patched_get_db(manager) as session: |
| task = session.query(RegistrationTask).filter_by(task_uuid="task-bound-consumed").first() |
|
|
| assert selected == {} |
| assert task.status == "failed" |
| assert "已消耗" in (task.error_message or "") |
| assert "Outlook" in (task.error_message or "") |
|
|
|
|
| def test_outlook_auto_selection_skips_reserved_pending_task_and_uses_next_available_service(monkeypatch): |
| manager = _make_session_manager("outlook-selection-reserved.db") |
| selected = {} |
|
|
| with manager.session_scope() as session: |
| first, second = _seed_outlook_services(session) |
| session.add_all( |
| [ |
| RegistrationTask( |
| task_uuid="reserved-task", |
| status="running", |
| email_service_id=first.id, |
| ), |
| RegistrationTask( |
| task_uuid="selected-task", |
| status="pending", |
| ), |
| ] |
| ) |
| session.commit() |
|
|
| @contextmanager |
| def fake_get_db(): |
| with _patched_get_db(manager) as session: |
| yield session |
|
|
| monkeypatch.setattr(registration_routes, "get_db", fake_get_db) |
| _patch_registration_selection(monkeypatch, selected) |
|
|
| registration_routes._run_sync_registration_task( |
| task_uuid="selected-task", |
| email_service_type="outlook", |
| proxy=None, |
| email_service_config=None, |
| email_service_id=None, |
| ) |
|
|
| assert selected["service_type"] == EmailServiceType.OUTLOOK |
| assert selected["config"]["email"] == "available-b@example.com" |
| assert selected["config"]["client_id"] == "client-b" |
|
|
|
|
| def test_outlook_auto_selection_reserves_account_atomically_across_concurrent_tasks(monkeypatch): |
| manager = _make_session_manager("outlook-selection-concurrent.db") |
| selections = {} |
|
|
| with manager.session_scope() as session: |
| first, second = _seed_outlook_services(session) |
| session.add_all( |
| [ |
| RegistrationTask(task_uuid="task-1", status="pending"), |
| RegistrationTask(task_uuid="task-2", status="pending"), |
| ] |
| ) |
| session.commit() |
|
|
| @contextmanager |
| def fake_get_db(): |
| with _patched_get_db(manager) as session: |
| yield session |
|
|
| real_update = registration_routes.crud.update_registration_task |
| task_1_reached_reservation = threading.Event() |
| allow_task_1_reservation = threading.Event() |
|
|
| def fake_update_registration_task(db, task_uuid, **kwargs): |
| if "email_service_id" in kwargs and task_uuid == "task-1": |
| task_1_reached_reservation.set() |
| allow_task_1_reservation.wait(timeout=5) |
| return real_update(db, task_uuid, **kwargs) |
|
|
| def fake_create(service_type, config, name=None): |
| selections[threading.current_thread().name] = dict(config) |
| return SimpleNamespace(service_type=service_type, config=config, name=name) |
|
|
| def fake_run(self): |
| return RegistrationResult(success=False, error_message="stop after selection") |
|
|
| monkeypatch.setattr(registration_routes, "get_db", fake_get_db) |
| monkeypatch.setattr(registration_routes.crud, "update_registration_task", fake_update_registration_task) |
| monkeypatch.setattr(registration_routes.EmailServiceFactory, "create", fake_create) |
| monkeypatch.setattr(registration_routes.RegistrationEngine, "run", fake_run) |
|
|
| errors = [] |
|
|
| def run_task(task_uuid, release_after_entry=False): |
| try: |
| if release_after_entry: |
| task_1_reached_reservation.wait(timeout=5) |
| registration_routes._run_sync_registration_task( |
| task_uuid=task_uuid, |
| email_service_type="outlook", |
| proxy=None, |
| email_service_config=None, |
| email_service_id=None, |
| ) |
| except Exception as exc: |
| errors.append(exc) |
| finally: |
| if release_after_entry: |
| allow_task_1_reservation.set() |
|
|
| thread_1 = threading.Thread(target=run_task, args=("task-1", False), name="task-1-thread") |
| thread_2 = threading.Thread(target=run_task, args=("task-2", True), name="task-2-thread") |
|
|
| thread_1.start() |
| thread_2.start() |
| thread_1.join(timeout=10) |
| thread_2.join(timeout=10) |
|
|
| assert not errors |
| assert selections["task-1-thread"]["email"] == "reserved-a@example.com" |
| assert selections["task-2-thread"]["email"] == "available-b@example.com" |
|
|
|
|
| def test_outlook_auto_selection_keeps_recoverable_account_available(monkeypatch): |
| manager = _make_session_manager("outlook-selection-recoverable.db") |
| selected = {} |
|
|
| with manager.session_scope() as session: |
| _seed_outlook_services(session) |
| _seed_recoverable_outlook_account(session, "reserved-a@example.com") |
| session.add( |
| RegistrationTask( |
| task_uuid="task-recoverable-selection", |
| status="pending", |
| ) |
| ) |
| session.commit() |
|
|
| @contextmanager |
| def fake_get_db(): |
| with _patched_get_db(manager) as session: |
| yield session |
|
|
| monkeypatch.setattr(registration_routes, "get_db", fake_get_db) |
| _patch_registration_selection(monkeypatch, selected) |
|
|
| registration_routes._run_sync_registration_task( |
| task_uuid="task-recoverable-selection", |
| email_service_type="outlook", |
| proxy=None, |
| email_service_config=None, |
| email_service_id=None, |
| ) |
|
|
| assert selected["service_type"] == EmailServiceType.OUTLOOK |
| assert selected["config"]["email"] == "reserved-a@example.com" |
|
|
|
|
| def test_outlook_bound_recoverable_service_runs_instead_of_being_rejected(monkeypatch): |
| manager = _make_session_manager("outlook-selection-bound-recoverable.db") |
| selected = {} |
|
|
| with manager.session_scope() as session: |
| first, second = _seed_outlook_services(session) |
| _seed_recoverable_outlook_account(session, "available-b@example.com") |
| session.add( |
| RegistrationTask( |
| task_uuid="task-bound-recoverable", |
| status="pending", |
| email_service_id=second.id, |
| ) |
| ) |
| session.commit() |
|
|
| @contextmanager |
| def fake_get_db(): |
| with _patched_get_db(manager) as session: |
| yield session |
|
|
| monkeypatch.setattr(registration_routes, "get_db", fake_get_db) |
|
|
| def fake_create(service_type, config, name=None): |
| selected["service_type"] = service_type |
| selected["config"] = dict(config) |
| selected["name"] = name |
| return SimpleNamespace(service_type=service_type, config=config, name=name) |
|
|
| def fake_run(self): |
| selected["engine_ran"] = True |
| return RegistrationResult(success=False, error_message="recovery still failed") |
|
|
| monkeypatch.setattr(registration_routes.EmailServiceFactory, "create", fake_create) |
| monkeypatch.setattr(registration_routes.RegistrationEngine, "run", fake_run) |
|
|
| registration_routes._run_sync_registration_task( |
| task_uuid="task-bound-recoverable", |
| email_service_type="outlook", |
| proxy=None, |
| email_service_config=None, |
| email_service_id=None, |
| ) |
|
|
| with _patched_get_db(manager) as session: |
| task = session.query(RegistrationTask).filter_by(task_uuid="task-bound-recoverable").first() |
|
|
| assert selected["engine_ran"] is True |
| assert selected["config"]["email"] == "available-b@example.com" |
| assert task.status == "failed" |
| assert task.error_message == "recovery still failed" |
|
|
|
|
| def test_outlook_batch_skip_registered_keeps_recoverable_accounts(monkeypatch): |
| manager = _make_session_manager("outlook-batch-recoverable.db") |
|
|
| with manager.session_scope() as session: |
| first, _second = _seed_outlook_services(session) |
| first_id = first.id |
| _seed_recoverable_outlook_account(session, "reserved-a@example.com") |
|
|
| @contextmanager |
| def fake_get_db(): |
| with _patched_get_db(manager) as session: |
| yield session |
|
|
| monkeypatch.setattr(registration_routes, "get_db", fake_get_db) |
|
|
| async def fake_batch_runner(*args, **kwargs): |
| return None |
|
|
| monkeypatch.setattr(registration_routes, "run_outlook_batch_registration", fake_batch_runner) |
|
|
| async def invoke(): |
| from fastapi import BackgroundTasks |
|
|
| return await registration_routes.start_outlook_batch_registration( |
| registration_routes.OutlookBatchRegistrationRequest( |
| service_ids=[first_id], |
| skip_registered=True, |
| ), |
| BackgroundTasks(), |
| ) |
|
|
| response = asyncio.run(invoke()) |
|
|
| assert response.to_register == 1 |
| assert response.service_ids == [first_id] |
|
|
