632b730fff
Systematic rename of all semantic anchors (#region, [DEF], @RELATION) across 1400+ files — backend Python, frontend Svelte/TS, specs, docs: - Flat anchors become Namespace.Module.Entity - @RELATION references updated to match new anchor paths - Zero business logic changes
477 lines
20 KiB
Python
477 lines
20 KiB
Python
# #region Test.TranslationScheduler [C:3] [TYPE Module] [SEMANTICS test,scheduler,cron]
|
|
# @BRIEF Tests for scheduler.py — TranslationScheduler.
|
|
# @RELATION BINDS_TO -> [Plugin.Scheduler.TranslationScheduler]
|
|
# @TEST_EDGE: job_not_found -> ValueError
|
|
# @TEST_EDGE: schedule_not_found -> ValueError
|
|
# @TEST_EDGE: invalid_cron -> empty next_executions
|
|
|
|
import sys
|
|
import asyncio
|
|
from pathlib import Path
|
|
sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent / "src"))
|
|
|
|
import pytest
|
|
from unittest.mock import MagicMock, patch
|
|
|
|
from datetime import UTC, datetime, timedelta
|
|
|
|
from src.models.translate import TranslationJob, TranslationSchedule
|
|
from src.plugins.translate.scheduler import (
|
|
TranslationScheduler,
|
|
execute_scheduled_translation,
|
|
)
|
|
from .conftest import JOB_ID, db_session
|
|
|
|
|
|
def _make_coro_runner():
|
|
"""Mock runner whose dispatch() executes the coroutine synchronously via asyncio.run."""
|
|
r = MagicMock()
|
|
r.dispatch.side_effect = lambda coro: asyncio.run(coro)
|
|
return r
|
|
|
|
|
|
class TestCreateSchedule:
|
|
"""TranslationScheduler.create_schedule."""
|
|
|
|
def test_creates_schedule(self, db_session):
|
|
"""Creates a schedule for a job."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock(), "test-user")
|
|
schedule = scheduler.create_schedule(JOB_ID, "0 0 * * *")
|
|
assert schedule.job_id == JOB_ID
|
|
assert schedule.cron_expression == "0 0 * * *"
|
|
assert schedule.is_active is True
|
|
assert schedule.created_by == "test-user"
|
|
|
|
def test_job_not_found(self, db_session):
|
|
"""Non-existent job raises ValueError."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
with pytest.raises(ValueError, match="not found"):
|
|
scheduler.create_schedule("nonexistent", "0 0 * * *")
|
|
|
|
def test_custom_mode(self, db_session):
|
|
"""Custom execution_mode."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
schedule = scheduler.create_schedule(
|
|
JOB_ID, "0 0 * * *", execution_mode="new_key_only"
|
|
)
|
|
assert schedule.execution_mode == "new_key_only"
|
|
|
|
|
|
class TestUpdateSchedule:
|
|
"""TranslationScheduler.update_schedule."""
|
|
|
|
def test_update_cron(self, db_session):
|
|
"""Update cron expression."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
scheduler.create_schedule(JOB_ID, "0 0 * * *")
|
|
updated = scheduler.update_schedule(JOB_ID, cron_expression="0 30 * * *")
|
|
assert updated.cron_expression == "0 30 * * *"
|
|
|
|
def test_update_timezone(self, db_session):
|
|
"""Update timezone."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
scheduler.create_schedule(JOB_ID, "0 0 * * *")
|
|
updated = scheduler.update_schedule(JOB_ID, timezone_str="Europe/Moscow")
|
|
assert updated.timezone == "Europe/Moscow"
|
|
|
|
def test_update_is_active(self, db_session):
|
|
"""Update is_active."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
scheduler.create_schedule(JOB_ID, "0 0 * * *")
|
|
updated = scheduler.update_schedule(JOB_ID, is_active=False)
|
|
assert updated.is_active is False
|
|
|
|
def test_update_execution_mode(self, db_session):
|
|
"""Update execution_mode."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
scheduler.create_schedule(JOB_ID, "0 0 * * *")
|
|
updated = scheduler.update_schedule(JOB_ID, execution_mode="new_key_only")
|
|
assert updated.execution_mode == "new_key_only"
|
|
|
|
def test_not_found(self, db_session):
|
|
"""Non-existent schedule raises ValueError."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
with pytest.raises(ValueError, match="No schedule found"):
|
|
scheduler.update_schedule(JOB_ID)
|
|
|
|
|
|
class TestDeleteSchedule:
|
|
"""TranslationScheduler.delete_schedule."""
|
|
|
|
def test_delete(self, db_session):
|
|
"""Delete existing schedule."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
scheduler.create_schedule(JOB_ID, "0 0 * * *")
|
|
scheduler.delete_schedule(JOB_ID)
|
|
assert db_session.query(TranslationSchedule).filter(
|
|
TranslationSchedule.job_id == JOB_ID
|
|
).first() is None
|
|
|
|
def test_not_found(self, db_session):
|
|
"""Non-existent schedule raises ValueError."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
with pytest.raises(ValueError, match="No schedule found"):
|
|
scheduler.delete_schedule(JOB_ID)
|
|
|
|
|
|
class TestSetScheduleActive:
|
|
"""TranslationScheduler.set_schedule_active."""
|
|
|
|
def test_disable(self, db_session):
|
|
"""Disable schedule."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
scheduler.create_schedule(JOB_ID, "0 0 * * *")
|
|
updated = scheduler.set_schedule_active(JOB_ID, False)
|
|
assert updated.is_active is False
|
|
|
|
def test_enable(self, db_session):
|
|
"""Enable schedule."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
scheduler.create_schedule(JOB_ID, "0 0 * * *", is_active=False)
|
|
updated = scheduler.set_schedule_active(JOB_ID, True)
|
|
assert updated.is_active is True
|
|
|
|
def test_not_found(self, db_session):
|
|
"""Non-existent raises ValueError."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
with pytest.raises(ValueError, match="No schedule found"):
|
|
scheduler.set_schedule_active(JOB_ID, True)
|
|
|
|
|
|
class TestGetSchedule:
|
|
"""TranslationScheduler.get_schedule."""
|
|
|
|
def test_get(self, db_session):
|
|
"""Get existing schedule."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
scheduler.create_schedule(JOB_ID, "0 0 * * *")
|
|
schedule = scheduler.get_schedule(JOB_ID)
|
|
assert schedule.job_id == JOB_ID
|
|
|
|
def test_not_found(self, db_session):
|
|
"""Non-existent raises ValueError."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
with pytest.raises(ValueError, match="No schedule found"):
|
|
scheduler.get_schedule(JOB_ID)
|
|
|
|
|
|
class TestListActiveSchedules:
|
|
"""TranslationScheduler.list_active_schedules."""
|
|
|
|
def test_list_active(self, db_session):
|
|
"""Returns only active schedules."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
scheduler.create_schedule(JOB_ID, "0 0 * * *", is_active=True)
|
|
|
|
# Create another job with inactive schedule
|
|
job2 = TranslationJob(id="job-2", name="Job 2", status="ACTIVE",
|
|
source_dialect="en", target_dialect="fr")
|
|
db_session.add(job2)
|
|
db_session.commit()
|
|
scheduler.create_schedule("job-2", "0 0 * * *", is_active=False)
|
|
|
|
active = TranslationScheduler.list_active_schedules(db_session)
|
|
assert len(active) == 1
|
|
assert active[0].job_id == JOB_ID
|
|
|
|
|
|
class TestGetNextExecutions:
|
|
"""TranslationScheduler.get_next_executions."""
|
|
|
|
def test_valid_cron(self):
|
|
"""Valid cron returns future times."""
|
|
results = TranslationScheduler.get_next_executions("0 0 * * *", "UTC", 3)
|
|
assert len(results) == 3
|
|
for r in results:
|
|
assert isinstance(r, str)
|
|
|
|
def test_invalid_cron(self):
|
|
"""Invalid cron returns empty list."""
|
|
results = TranslationScheduler.get_next_executions("invalid-cron", "UTC", 3)
|
|
assert results == []
|
|
|
|
def test_custom_count(self, db_session):
|
|
"""Custom N returns that many results."""
|
|
results = TranslationScheduler.get_next_executions("*/5 * * * *", "UTC", 5)
|
|
assert len(results) == 5
|
|
|
|
def test_default_count(self, db_session):
|
|
"""Default n=3."""
|
|
results = TranslationScheduler.get_next_executions("*/5 * * * *", "UTC")
|
|
assert len(results) == 3
|
|
|
|
|
|
class TestExecuteScheduledTranslation:
|
|
"""execute_scheduled_translation — APScheduler job handler."""
|
|
|
|
def _make_db_session_maker(self, db_session):
|
|
def maker():
|
|
return db_session
|
|
return maker
|
|
|
|
def test_schedule_inactive(self, db_session):
|
|
"""Inactive schedule returns early."""
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
schedule = scheduler.create_schedule(JOB_ID, "0 0 * * *", is_active=False)
|
|
db_session.commit()
|
|
|
|
maker = self._make_db_session_maker(db_session)
|
|
|
|
with (
|
|
patch("src.plugins.translate.scheduler.seed_trace_id"),
|
|
patch("src.core.database.SessionLocal", maker),
|
|
patch("src.dependencies.get_config_manager", return_value=MagicMock()),
|
|
):
|
|
execute_scheduled_translation(schedule.id, JOB_ID)
|
|
# Should return early without error
|
|
|
|
def test_schedule_not_found(self, db_session):
|
|
"""Non-existent schedule returns early."""
|
|
maker = self._make_db_session_maker(db_session)
|
|
|
|
with (
|
|
patch("src.plugins.translate.scheduler.seed_trace_id"),
|
|
patch("src.core.database.SessionLocal", maker),
|
|
patch("src.dependencies.get_config_manager", return_value=MagicMock()),
|
|
):
|
|
execute_scheduled_translation("nonexistent", JOB_ID)
|
|
# Should return early
|
|
|
|
def test_concurrent_run_skips(self, db_session):
|
|
"""Active concurrent run causes scheduled execution to be skipped."""
|
|
from src.plugins.translate.scheduler import TranslationScheduler
|
|
from src.models.translate import TranslationRun
|
|
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
schedule = scheduler.create_schedule(JOB_ID, "0 0 * * *", is_active=True)
|
|
db_session.commit()
|
|
|
|
# Create a PENDING run to simulate concurrency
|
|
# Use datetime.now() (naive) — SQLite stores naive datetimes
|
|
pending_run = TranslationRun(
|
|
id="concurrent-run", job_id=JOB_ID, status="PENDING",
|
|
created_at=datetime.now(),
|
|
)
|
|
db_session.add(pending_run)
|
|
db_session.commit()
|
|
|
|
maker = self._make_db_session_maker(db_session)
|
|
|
|
with (
|
|
patch("src.plugins.translate.scheduler.seed_trace_id"),
|
|
patch("src.plugins.translate.scheduler.UTC", None), # SQLite stores naive datetimes
|
|
patch("src.plugins.translate.scheduler.TranslationEventLog") as MockEventLog,
|
|
patch("src.core.database.SessionLocal", maker),
|
|
patch("src.dependencies.get_config_manager", return_value=MagicMock()),
|
|
):
|
|
mock_event_log = MagicMock()
|
|
MockEventLog.return_value = mock_event_log
|
|
|
|
execute_scheduled_translation(schedule.id, JOB_ID)
|
|
|
|
# Should have logged skipped event
|
|
mock_event_log.log_event.assert_called_once()
|
|
|
|
def test_stale_concurrent_run_cleared(self, db_session):
|
|
"""Stale PENDING run older than 1h is cleared and execution proceeds."""
|
|
from src.plugins.translate.scheduler import TranslationScheduler
|
|
from src.models.translate import TranslationRun
|
|
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
schedule = scheduler.create_schedule(JOB_ID, "0 0 * * *", is_active=True)
|
|
db_session.commit()
|
|
|
|
# Create a stale PENDING run (older than 1h)
|
|
# Use datetime.now() (naive) — SQLite stores naive datetimes
|
|
stale_time = datetime.now() - timedelta(hours=2)
|
|
stale_run = TranslationRun(
|
|
id="stale-run", job_id=JOB_ID, status="PENDING",
|
|
created_at=stale_time,
|
|
)
|
|
db_session.add(stale_run)
|
|
db_session.commit()
|
|
|
|
maker = self._make_db_session_maker(db_session)
|
|
|
|
# Prevent session close so we can still read stale_run after the call
|
|
original_close = db_session.close
|
|
db_session.close = MagicMock()
|
|
db_session.expire_on_commit = False
|
|
try:
|
|
with (
|
|
patch("src.plugins.translate.scheduler.seed_trace_id"),
|
|
patch("src.plugins.translate.scheduler.UTC", None), # SQLite stores naive datetimes
|
|
patch("src.plugins.translate.orchestrator.TranslationOrchestrator") as MockOrch,
|
|
patch("src.dependencies.get_async_job_runner", return_value=_make_coro_runner()),
|
|
patch("src.core.database.SessionLocal", maker),
|
|
patch("src.dependencies.get_config_manager", return_value=MagicMock()),
|
|
):
|
|
mock_orch = MagicMock()
|
|
mock_run = MagicMock()
|
|
mock_run.id = "new-run"
|
|
mock_run.status = "COMPLETED"
|
|
mock_run.insert_status = "succeeded"
|
|
mock_orch.start_run.return_value = mock_run
|
|
MockOrch.return_value = mock_orch
|
|
|
|
execute_scheduled_translation(schedule.id, JOB_ID)
|
|
|
|
# Stale run should be marked FAILED
|
|
assert stale_run.status == "FAILED"
|
|
assert "Stale" in stale_run.error_message
|
|
finally:
|
|
db_session.close = original_close
|
|
db_session.expire_on_commit = True
|
|
|
|
def test_execution_new_key_only(self, db_session):
|
|
"""execution_mode=new_key_only with fresh baseline."""
|
|
from src.plugins.translate.scheduler import TranslationScheduler
|
|
from src.models.translate import TranslationRun
|
|
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
schedule = scheduler.create_schedule(
|
|
JOB_ID, "0 0 * * *", is_active=True, execution_mode="new_key_only"
|
|
)
|
|
db_session.commit()
|
|
|
|
# Recent successful run (baseline not expired)
|
|
# Use datetime.now() (naive) — SQLite stores naive datetimes
|
|
recent = datetime.now()
|
|
recent_run = TranslationRun(
|
|
id="recent-run", job_id=JOB_ID, status="COMPLETED",
|
|
insert_status="succeeded", created_at=recent,
|
|
)
|
|
db_session.add(recent_run)
|
|
db_session.commit()
|
|
|
|
maker = self._make_db_session_maker(db_session)
|
|
|
|
with (
|
|
patch("src.plugins.translate.scheduler.seed_trace_id"),
|
|
patch("src.plugins.translate.scheduler.UTC", None), # SQLite stores naive datetimes
|
|
patch("src.plugins.translate.orchestrator.TranslationOrchestrator") as MockOrch,
|
|
patch("src.dependencies.get_async_job_runner", return_value=_make_coro_runner()),
|
|
patch("src.core.database.SessionLocal", maker),
|
|
patch("src.dependencies.get_config_manager", return_value=MagicMock()),
|
|
):
|
|
mock_orch = MagicMock()
|
|
mock_run = MagicMock()
|
|
mock_run.id = "new-run"
|
|
mock_run.status = "COMPLETED"
|
|
mock_run.insert_status = "succeeded"
|
|
mock_orch.start_run.return_value = mock_run
|
|
MockOrch.return_value = mock_orch
|
|
|
|
execute_scheduled_translation(schedule.id, JOB_ID, execution_mode="new_key_only")
|
|
|
|
# Should set trigger_type to "new_key_only" because baseline is fresh
|
|
assert mock_run.trigger_type == "new_key_only"
|
|
|
|
def test_execution_baseline_expired(self, db_session):
|
|
"""Baseline older than 90d triggers full translation even in new_key_only mode."""
|
|
from src.plugins.translate.scheduler import TranslationScheduler
|
|
from src.models.translate import TranslationRun
|
|
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
schedule = scheduler.create_schedule(
|
|
JOB_ID, "0 0 * * *", is_active=True, execution_mode="new_key_only"
|
|
)
|
|
db_session.commit()
|
|
|
|
# Very old successful run (baseline expired > 90 days)
|
|
# Use datetime.now() (naive) — SQLite stores naive datetimes
|
|
old_time = datetime.now() - timedelta(days=100)
|
|
old_run = TranslationRun(
|
|
id="old-run", job_id=JOB_ID, status="COMPLETED",
|
|
insert_status="succeeded", created_at=old_time,
|
|
)
|
|
db_session.add(old_run)
|
|
db_session.commit()
|
|
|
|
maker = self._make_db_session_maker(db_session)
|
|
|
|
with (
|
|
patch("src.plugins.translate.scheduler.seed_trace_id"),
|
|
patch("src.plugins.translate.scheduler.UTC", None), # SQLite stores naive datetimes
|
|
patch("src.plugins.translate.orchestrator.TranslationOrchestrator") as MockOrch,
|
|
patch("src.dependencies.get_async_job_runner", return_value=_make_coro_runner()),
|
|
patch("src.core.database.SessionLocal", maker),
|
|
patch("src.dependencies.get_config_manager", return_value=MagicMock()),
|
|
):
|
|
mock_orch = MagicMock()
|
|
mock_run = MagicMock()
|
|
mock_run.id = "new-run"
|
|
mock_run.status = "COMPLETED"
|
|
mock_run.insert_status = "succeeded"
|
|
mock_orch.start_run.return_value = mock_run
|
|
MockOrch.return_value = mock_orch
|
|
|
|
execute_scheduled_translation(schedule.id, JOB_ID, execution_mode="new_key_only")
|
|
|
|
# Should fall back to "scheduled" because baseline expired
|
|
assert mock_run.trigger_type == "scheduled"
|
|
|
|
def test_execution_failure_sends_notification(self, db_session):
|
|
"""Execution failure is handled by execute_background — scheduler dispatches fire-and-forget."""
|
|
from src.plugins.translate.scheduler import TranslationScheduler
|
|
from src.plugins.translate.orchestrator import TranslationOrchestrator
|
|
|
|
scheduler = TranslationScheduler(db_session, MagicMock())
|
|
schedule = scheduler.create_schedule(JOB_ID, "0 0 * * *", is_active=True)
|
|
db_session.commit()
|
|
|
|
maker = self._make_db_session_maker(db_session)
|
|
|
|
with (
|
|
patch("src.plugins.translate.scheduler.seed_trace_id"),
|
|
patch("src.plugins.translate.scheduler.UTC", None), # SQLite stores naive datetimes
|
|
patch("src.plugins.translate.orchestrator.TranslationOrchestrator") as MockOrch,
|
|
patch("src.dependencies.get_async_job_runner") as MockRunner,
|
|
patch("src.core.database.SessionLocal", maker),
|
|
patch("src.dependencies.get_config_manager", return_value=MagicMock()),
|
|
patch(
|
|
"src.plugins.translate.scheduler.NotificationService",
|
|
) as MockNotif,
|
|
):
|
|
mock_orch = MagicMock()
|
|
mock_run = MagicMock()
|
|
mock_run.id = "fail-run"
|
|
mock_run.status = "PENDING"
|
|
mock_run.insert_status = None
|
|
mock_orch.start_run.return_value = mock_run
|
|
MockOrch.return_value = mock_orch
|
|
|
|
# The runner is still used for the outer notification (crash outside execution),
|
|
# but NOT for execute_run dispatch. execute_background is called instead.
|
|
mock_runner = MagicMock()
|
|
mock_runner.dispatch.side_effect = lambda coro: asyncio.run(coro)
|
|
MockRunner.return_value = mock_runner
|
|
|
|
# Provider mock — notification is NOT sent from scheduler (moved to background task)
|
|
mock_notif = MagicMock()
|
|
mock_notif._providers = {}
|
|
MockNotif.return_value = mock_notif
|
|
|
|
execute_scheduled_translation(schedule.id, JOB_ID)
|
|
|
|
# Scheduler dispatches via execute_background instead of calling execute_run directly
|
|
MockOrch.execute_background.assert_called_once()
|
|
call_kwargs = MockOrch.execute_background.call_args.kwargs
|
|
assert call_kwargs["run_id"] == "fail-run"
|
|
assert call_kwargs["current_user"] == "scheduler"
|
|
# Notification is NOT sent from scheduler (moved to background task)
|
|
# (schedule.last_run_at tracking verified in test_scheduled_execution_uses_runner)
|
|
|
|
def test_get_next_executions_break_on_none(self):
|
|
"""get_next_executions breaks when cron trigger returns None."""
|
|
from src.plugins.translate.scheduler import TranslationScheduler
|
|
|
|
# Use a cron that's unlikely to have many future fires
|
|
# or mock the trigger to return None after one fire
|
|
results = TranslationScheduler.get_next_executions(
|
|
"0 0 30 2 5", "UTC", 10 # Feb 30 doesn't exist, trigger may produce fewer
|
|
)
|
|
# Should not crash; returns what it can
|
|
assert isinstance(results, list)
|
|
# #endregion Test.TranslationScheduler
|