Spaces:
Running
Running
File size: 6,455 Bytes
8deacaf | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 | import os
import tempfile
import unittest
from pathlib import Path
from unittest.mock import patch
from app.services import cache_manager
class TestVideoCacheManager(unittest.TestCase):
"""验证缓存管理只处理受控文件,并按元数据完成轻量统计与清理。"""
def setUp(self):
self.temp_dir = tempfile.TemporaryDirectory()
self.cache_dir = Path(self.temp_dir.name)
self.storage_patch = patch.object(
cache_manager.utils,
"storage_dir",
return_value=str(self.cache_dir),
)
self.storage_patch.start()
def tearDown(self):
self.storage_patch.stop()
self.temp_dir.cleanup()
def _create_cache_file(self, digest: str, size: int, mtime: float) -> Path:
path = self.cache_dir / f"vid-{digest}.mp4"
path.write_bytes(b"x" * size)
os.utime(path, (mtime, mtime))
return path
def test_stats_only_include_managed_top_level_regular_files(self):
"""
未知文件、嵌套文件和符号链接可能属于用户,不能进入容量统计或清理候选。
"""
now = 2_000_000_000.0
self._create_cache_file("a" * 32, 10, now - 40 * 86400)
self._create_cache_file("b" * 32, 20, now - 2 * 86400)
(self.cache_dir / "personal.mp4").write_bytes(b"user-video")
nested_dir = self.cache_dir / "nested"
nested_dir.mkdir()
(nested_dir / f"vid-{'c' * 32}.mp4").write_bytes(b"nested")
symlink_path = self.cache_dir / f"vid-{'d' * 32}.mp4"
try:
symlink_path.symlink_to(self.cache_dir / "personal.mp4")
except (OSError, NotImplementedError):
# Windows 未开启开发者模式时创建符号链接可能没有权限,不影响其余断言。
pass
with patch.object(cache_manager.time, "time", return_value=now):
total = cache_manager.get_video_cache_stats()
older_than_30_days = cache_manager.get_video_cache_stats(30)
self.assertEqual(total.file_count, 2)
self.assertEqual(total.total_size, 30)
self.assertEqual(older_than_30_days.file_count, 1)
self.assertEqual(older_than_30_days.total_size, 10)
def test_cleanup_rescans_and_preserves_new_or_unknown_files(self):
now = 2_000_000_000.0
old_file = self._create_cache_file("a" * 32, 10, now - 40 * 86400)
new_file = self._create_cache_file("b" * 32, 20, now - 2 * 86400)
unknown_file = self.cache_dir / "keep-me.mp4"
unknown_file.write_bytes(b"user-video")
with patch.object(cache_manager.time, "time", return_value=now):
result = cache_manager.clean_video_cache(30)
self.assertEqual(result.deleted_count, 1)
self.assertEqual(result.deleted_size, 10)
self.assertEqual(result.failed_count, 0)
self.assertFalse(old_file.exists())
self.assertTrue(new_file.exists())
self.assertTrue(unknown_file.exists())
def test_cleanup_continues_when_one_file_cannot_be_deleted(self):
first = self._create_cache_file("a" * 32, 10, 1_000_000_000.0)
second = self._create_cache_file("b" * 32, 20, 1_000_000_000.0)
real_unlink = os.unlink
def unlink_with_failure(path):
if os.path.basename(path) == first.name:
raise PermissionError("file is busy")
return real_unlink(path)
with patch.object(cache_manager.os, "unlink", side_effect=unlink_with_failure):
result = cache_manager.clean_video_cache()
self.assertEqual(result.deleted_count, 1)
self.assertEqual(result.deleted_size, 20)
self.assertEqual(result.failed_count, 1)
self.assertTrue(first.exists())
self.assertFalse(second.exists())
def test_cleanup_preserves_file_replaced_after_scan(self):
"""A fresh atomic download must survive a cleanup that scanned its old file."""
now = 2_000_000_000.0
cache_file = self._create_cache_file("a" * 32, 10, now - 40 * 86400)
original_iterator = cache_manager._iter_video_cache_entries
def replace_after_scan(include_temp=False):
scanned_entries = list(original_iterator(include_temp=include_temp))
replacement = self.cache_dir / "new-download.tmp"
replacement.write_bytes(b"new complete video")
os.utime(replacement, (now, now))
os.replace(replacement, cache_file)
yield from scanned_entries
with (
patch.object(cache_manager.time, "time", return_value=now),
patch.object(
cache_manager,
"_iter_video_cache_entries",
side_effect=replace_after_scan,
),
):
result = cache_manager.clean_video_cache(30)
self.assertEqual(result.deleted_count, 0)
self.assertEqual(result.failed_count, 0)
self.assertEqual(cache_file.read_bytes(), b"new complete video")
def test_cleanup_reclaims_only_stale_atomic_downloads(self):
"""An interrupted download must not accumulate without deleting an active one."""
now = 2_000_000_000.0
stale = self.cache_dir / f".vid-{'a' * 32}-abcdefgh.mp4"
active = self.cache_dir / f".vid-{'b' * 32}-abcdefgh.mp4"
unrelated = self.cache_dir / ".personal-download.mp4"
for path, mtime in (
(stale, now - 2 * 86400),
(active, now - 3600),
(unrelated, now - 2 * 86400),
):
path.write_bytes(b"unfinished")
os.utime(path, (mtime, mtime))
with patch.object(cache_manager.time, "time", return_value=now):
stats = cache_manager.get_video_cache_stats()
result = cache_manager.clean_video_cache()
self.assertEqual(stats.file_count, 1)
self.assertEqual(stats.total_size, len(b"unfinished"))
self.assertEqual(result.deleted_count, 1)
self.assertFalse(stale.exists())
self.assertTrue(active.exists())
self.assertTrue(unrelated.exists())
def test_invalid_cleanup_age_is_rejected(self):
with self.assertRaises(ValueError):
cache_manager.get_video_cache_stats(0)
with self.assertRaises(ValueError):
cache_manager.clean_video_cache(-1)
with self.assertRaises(ValueError):
cache_manager.clean_video_cache(1.5)
|