Files
stemengine_old/backend/tests/test_optional_hardening.py
2026-04-04 11:01:11 +09:00

114 lines
4.4 KiB
Python

import importlib
import os
import sys
import tempfile
import unittest
from datetime import datetime, timedelta
from pathlib import Path
class OptionalHardeningTests(unittest.TestCase):
def setUp(self):
self._temp_dir = tempfile.TemporaryDirectory()
media_dir = Path(self._temp_dir.name) / "media"
self._env_keys = [
"MEDIA_DIR",
"UPLOAD_DIR",
"JOBS_DIR",
"PROJECTS_DIR",
"DB_PATH",
"LRC_SYNC_DIR",
"SECRET_KEY",
"HF_TOKEN",
"ADMIN_TOKEN",
"STEMENGINE_JOB_RETENTION_ENABLED",
"STEMENGINE_JOB_RETENTION_DAYS",
"STEMENGINE_JOB_RETENTION_PRUNE_BATCH",
"STEMENGINE_JOB_RETENTION_INTERVAL_SECS",
]
self._saved_env = {key: os.environ.get(key) for key in self._env_keys}
os.environ["MEDIA_DIR"] = str(media_dir)
os.environ["UPLOAD_DIR"] = str(media_dir / "uploads")
os.environ["JOBS_DIR"] = str(media_dir / "jobs")
os.environ["PROJECTS_DIR"] = str(media_dir / "projects")
os.environ["DB_PATH"] = str(media_dir / "db" / "stemengine.db")
os.environ["LRC_SYNC_DIR"] = str(media_dir / "lrc_sync")
os.environ["SECRET_KEY"] = "test-secret-key"
os.environ.pop("HF_TOKEN", None)
os.environ.pop("ADMIN_TOKEN", None)
os.environ["STEMENGINE_JOB_RETENTION_ENABLED"] = "true"
os.environ["STEMENGINE_JOB_RETENTION_DAYS"] = "30"
os.environ["STEMENGINE_JOB_RETENTION_PRUNE_BATCH"] = "100"
os.environ["STEMENGINE_JOB_RETENTION_INTERVAL_SECS"] = "3600"
self._clear_backend_modules()
self.jm = importlib.import_module("backend.job_manager")
self.jobs_repo = importlib.import_module("backend.repositories.jobs")
def tearDown(self):
self._clear_backend_modules()
for key, value in self._saved_env.items():
if value is None:
os.environ.pop(key, None)
else:
os.environ[key] = value
self._temp_dir.cleanup()
def _clear_backend_modules(self):
for name in list(sys.modules):
if name == "backend" or name.startswith("backend."):
sys.modules.pop(name, None)
def test_terminal_status_update_auto_cleans_cancel_flag(self):
job_id = self.jm.create_job("separate")
with self.jm._flags_lock:
self.assertIn(job_id, self.jm._cancel_flags)
self.jm.update_job(job_id, status=self.jm.JobStatus.DONE)
with self.jm._flags_lock:
self.assertNotIn(job_id, self.jm._cancel_flags)
def test_prune_old_non_project_jobs_retains_linked_and_active(self):
now = datetime.utcnow()
old = now - timedelta(days=45)
linked_old_done = self.jm.create_job("separate")
self.jm.update_job(linked_old_done, status=self.jm.JobStatus.DONE)
self.jobs_repo.update(linked_old_done, created_at=old, updated_at=old)
self.jm.find_or_create_project("Linked Project", linked_old_done)
unlinked_old_done = self.jm.create_job("transcribe")
# Intentionally bypass job_manager.update_job() to simulate legacy paths
# that can leave in-memory cancel flags behind for terminal jobs.
self.jobs_repo.update(unlinked_old_done, status="done")
self.jobs_repo.update(unlinked_old_done, created_at=old, updated_at=old)
unlinked_recent_done = self.jm.create_job("transcribe")
self.jm.update_job(unlinked_recent_done, status=self.jm.JobStatus.DONE)
unlinked_old_running = self.jm.create_job("pipeline")
self.jm.update_job(unlinked_old_running, status=self.jm.JobStatus.RUNNING)
self.jobs_repo.update(unlinked_old_running, created_at=old, updated_at=old)
with self.jm._flags_lock:
self.assertIn(unlinked_old_done, self.jm._cancel_flags)
result = self.jm.prune_old_non_project_jobs(now=now, force=True)
self.assertEqual(result["deleted"], 1)
self.assertIsNotNone(self.jm.get_job(linked_old_done))
self.assertIsNone(self.jm.get_job(unlinked_old_done))
self.assertIsNotNone(self.jm.get_job(unlinked_recent_done))
self.assertIsNotNone(self.jm.get_job(unlinked_old_running))
with self.jm._flags_lock:
self.assertNotIn(unlinked_old_done, self.jm._cancel_flags)
if __name__ == "__main__":
unittest.main()