mirror of
https://github.com/jxxghp/MoviePilot.git
synced 2026-08-29 03:56:43 +08:00
533 lines
23 KiB
Python
533 lines
23 KiB
Python
"""
|
|
整理历史表的查询行为。
|
|
|
|
整理历史同时承担三个职责：查重（这个文件整理过没有）、溯源（这个媒体库文件是从哪
|
|
来的）、统计。查重误判会重复整理或永久漏件——挂载故障那一类问题最终就落在这张表上；
|
|
溯源查错会让「重新整理」把不相干的文件搬走。
|
|
"""
|
|
import asyncio
|
|
import time as _time
|
|
|
|
import pytest
|
|
|
|
from app.db.models import transferhistory as transferhistory_module
|
|
from app.db.models.transferhistory import TransferHistory
|
|
from app.schemas.types import MediaSource, MediaType
|
|
|
|
TMDB = str(MediaSource.TMDB)
|
|
|
|
|
|
@pytest.fixture(autouse=True)
|
|
def _track(db):
|
|
"""把整理历史表纳入用例级回收。"""
|
|
db.watermark(TransferHistory)
|
|
|
|
|
|
def _hist(title: str = "片名", src: str = None, dest: str = None,
|
|
src_storage: str = "local", dest_storage: str = "local",
|
|
mode: str = "move", status: bool = True, mtype: str = None,
|
|
year: str = "2026", media_id: str = "6001", seasons: str = None,
|
|
episodes: str = None, date: str = "2026-08-13 10:00:00",
|
|
download_hash: str = None) -> TransferHistory:
|
|
"""构造一条整理历史。"""
|
|
return TransferHistory(src=src or f"/downloads/{title}.mkv", src_storage=src_storage,
|
|
dest=dest or f"/media/{title}.mkv", dest_storage=dest_storage,
|
|
mode=mode, type=mtype or MediaType.TV.value, title=title,
|
|
year=year, media_source=TMDB, media_id=media_id,
|
|
seasons=seasons, episodes=episodes, status=status,
|
|
date=date, download_hash=download_hash, files=[])
|
|
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
# 按路径溯源
|
|
# --------------------------------------------------------------------------- #
|
|
|
|
def test_get_by_src_scopes_by_storage(db):
|
|
"""
|
|
按源路径查询可限定存储，不限定时取主键最大的那条。
|
|
|
|
同一路径在不同存储下是不同文件；不限定存储会把本地盘的记录当成网盘的。
|
|
表上有 (src, src_storage) 唯一约束，所以「最新一条」只在跨存储时才有分歧。
|
|
"""
|
|
db.add(_hist("本地", src="/data/same.mkv", src_storage="local"))
|
|
latest = db.add(_hist("网盘", src="/data/same.mkv", src_storage="alist"))
|
|
|
|
assert TransferHistory.get_by_src(db.session, "/data/same.mkv",
|
|
storage="alist").title == "网盘"
|
|
assert TransferHistory.get_by_src(db.session, "/data/same.mkv",
|
|
storage="local").title == "本地"
|
|
assert TransferHistory.get_by_src(db.session, "/data/same.mkv").id == latest.id
|
|
assert TransferHistory.get_by_src(db.session, "/data/none.mkv") is None
|
|
|
|
|
|
def test_get_success_by_src_matches_path_verbatim(db):
|
|
"""
|
|
成功记录按源路径原样精确匹配，不做归一化。
|
|
|
|
蓝光原盘目录的记录带尾斜杠，归一化后反而匹配不到自己。
|
|
"""
|
|
db.add(_hist("原盘", src="/data/BDMV/", status=True),
|
|
_hist("失败的", src="/data/fail.mkv", status=False))
|
|
|
|
assert TransferHistory.get_success_by_src(db.session, "/data/BDMV/").title == "原盘"
|
|
assert TransferHistory.get_success_by_src(db.session, "/data/BDMV") is None
|
|
assert TransferHistory.get_success_by_src(db.session, "/data/fail.mkv") is None
|
|
|
|
|
|
def test_get_success_by_src_can_scope_by_storage(db):
|
|
"""
|
|
成功记录查询同样支持按源存储收窄。
|
|
"""
|
|
db.add(_hist("本地", src="/data/x.mkv", src_storage="local"),
|
|
_hist("网盘", src="/data/x.mkv", src_storage="alist"))
|
|
|
|
assert TransferHistory.get_success_by_src(db.session, "/data/x.mkv",
|
|
storage="alist").title == "网盘"
|
|
|
|
|
|
def test_get_by_dest_scopes_by_storage_and_takes_newest(db):
|
|
"""
|
|
按目标路径查询用于从媒体库反查来源，可限定目标存储并取最新一条。
|
|
"""
|
|
db.add(_hist("旧", src="/data/d1.mkv", dest="/media/same.mkv", dest_storage="local"))
|
|
newest = db.add(_hist("新", src="/data/d2.mkv", dest="/media/same.mkv",
|
|
dest_storage="local"))
|
|
db.add(_hist("别的存储", src="/data/d3.mkv", dest="/media/same.mkv",
|
|
dest_storage="alist"))
|
|
|
|
assert TransferHistory.get_by_dest(db.session, "/media/same.mkv",
|
|
storage="local").id == newest.id
|
|
assert TransferHistory.get_by_dest(db.session, "/media/same.mkv",
|
|
storage="alist").title == "别的存储"
|
|
assert TransferHistory.get_by_dest(db.session, "/media/none.mkv") is None
|
|
|
|
|
|
def test_list_success_by_src_normalizes_the_path(db):
|
|
"""
|
|
列举成功记录时对入参路径做归一化（反斜杠、尾斜杠）。
|
|
|
|
Windows 侧传来的路径带反斜杠，不归一化会一条都匹配不到。
|
|
"""
|
|
db.add(_hist("目录", src="/data/dir"))
|
|
|
|
for probe in ("/data/dir", "/data/dir/", "\\data\\dir"):
|
|
assert [h.title for h in TransferHistory.list_success_by_src(db.session, probe)] == ["目录"]
|
|
|
|
|
|
def test_list_success_by_src_recursive_matches_children_only(db):
|
|
"""
|
|
递归模式匹配目录自身及其子项，但不能误伤同前缀的兄弟目录。
|
|
|
|
直接用 `like("前缀%")` 会把 /data/dir2 也算成 /data/dir 的子项，
|
|
重新整理时会把邻居目录一起搬走。
|
|
"""
|
|
db.add(_hist("自身", src="/data/dir"),
|
|
_hist("子项", src="/data/dir/a.mkv"),
|
|
_hist("兄弟", src="/data/dir2/b.mkv"))
|
|
|
|
titles = {h.title for h in TransferHistory.list_success_by_src(
|
|
db.session, "/data/dir", recursive=True)}
|
|
|
|
assert titles == {"自身", "子项"}
|
|
|
|
|
|
def test_list_success_by_src_escapes_like_wildcards(db):
|
|
"""
|
|
路径中的 % 与 _ 必须被转义，否则会被当成通配符匹配到别的目录。
|
|
"""
|
|
db.add(_hist("含下划线", src="/data/a_b/x.mkv"),
|
|
_hist("被误伤", src="/data/axb/y.mkv"))
|
|
|
|
titles = {h.title for h in TransferHistory.list_success_by_src(
|
|
db.session, "/data/a_b", recursive=True)}
|
|
|
|
assert titles == {"含下划线"}
|
|
|
|
|
|
def test_list_success_move_by_dest_only_returns_move_mode(db):
|
|
"""
|
|
从媒体库现址发起重新整理时只认「移动」模式的记录。
|
|
|
|
硬链接/复制的源文件仍在原处，把它们算作可回溯的移动记录会导致重复整理。
|
|
"""
|
|
db.add(_hist("移动", src="/data/m.mkv", dest="/media/m.mkv", mode="move"),
|
|
_hist("硬链", src="/data/l.mkv", dest="/media/l.mkv", mode="link"),
|
|
_hist("移动失败", src="/data/f.mkv", dest="/media/f.mkv", mode="move",
|
|
status=False))
|
|
|
|
titles = {h.title for h in TransferHistory.list_success_move_by_dest(db.session, "/media/m.mkv")}
|
|
assert titles == {"移动"}
|
|
assert TransferHistory.list_success_move_by_dest(db.session, "/media/l.mkv") == []
|
|
assert TransferHistory.list_success_move_by_dest(db.session, "/media/f.mkv") == []
|
|
|
|
|
|
def test_list_success_move_by_dest_recursive_matches_children_only(db):
|
|
"""
|
|
目标侧的递归匹配同样不能误伤同前缀的兄弟目录。
|
|
"""
|
|
db.add(_hist("自身", src="/data/w1.mkv", dest="/media/show", mode="move"),
|
|
_hist("子项", src="/data/w2.mkv", dest="/media/show/s01.mkv", mode="move"),
|
|
_hist("兄弟", src="/data/w3.mkv", dest="/media/show2/s01.mkv", mode="move"))
|
|
|
|
titles = {h.title for h in TransferHistory.list_success_move_by_dest(
|
|
db.session, "/media/show", recursive=True)}
|
|
|
|
assert titles == {"自身", "子项"}
|
|
|
|
|
|
def test_replace_by_src_keeps_one_record_per_source(db):
|
|
"""
|
|
同一源路径在同一存储中只保留最新一条记录，且不波及其他存储。
|
|
|
|
先删后插是在同一事务内完成的：旧的「查一条再删一条」在遗留重复数据下会留下
|
|
脏记录，查重随后就会命中旧行。
|
|
"""
|
|
db.add(_hist("旧一", src="/data/dup.mkv", src_storage="local"),
|
|
_hist("别的存储", src="/data/dup.mkv", src_storage="alist"))
|
|
|
|
TransferHistory.replace_by_src(db.session, src="/data/dup.mkv", src_storage="local",
|
|
dest="/media/new.mkv", type=MediaType.TV.value,
|
|
title="新记录", status=True, date="2026-08-13 12:00:00")
|
|
|
|
local_rows = TransferHistory.list_success_by_src(db.session, "/data/dup.mkv",
|
|
storage="local")
|
|
assert [h.title for h in local_rows] == ["新记录"]
|
|
assert TransferHistory.get_by_src(db.session, "/data/dup.mkv",
|
|
storage="alist").title == "别的存储"
|
|
|
|
|
|
def test_replace_by_src_defaults_storage_to_local(db):
|
|
"""
|
|
未指定源存储时按 local 处理——历史数据没有这一列，缺省值必须与写入侧一致。
|
|
"""
|
|
created = TransferHistory.replace_by_src(db.session, src="/data/nostorage.mkv",
|
|
type=MediaType.TV.value, title="无存储",
|
|
status=True, date="2026-08-13 12:00:00")
|
|
|
|
assert created.src_storage == "local"
|
|
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
# 按 hash / 身份查询
|
|
# --------------------------------------------------------------------------- #
|
|
|
|
def test_hash_lookups_return_single_and_all(db):
|
|
"""
|
|
按下载 hash 既可取单条也可取全部，未命中时分别是 None 与空列表。
|
|
"""
|
|
db.add(_hist("文件一", download_hash="th-1", src="/data/1.mkv"),
|
|
_hist("文件二", download_hash="th-1", src="/data/2.mkv"))
|
|
|
|
assert TransferHistory.get_by_hash(db.session, "th-1") is not None
|
|
assert len(TransferHistory.list_by_hash(db.session, "th-1")) == 2
|
|
assert TransferHistory.get_by_hash(db.session, "th-none") is None
|
|
assert TransferHistory.list_by_hash(db.session, "th-none") == []
|
|
|
|
|
|
def test_get_by_media_identity_requires_matching_type(db):
|
|
"""
|
|
按媒体身份查询时类型必须参与匹配，否则电影会命中同 ID 的剧集记录。
|
|
"""
|
|
db.add(_hist("剧集", media_id="6100", mtype=MediaType.TV.value))
|
|
|
|
assert TransferHistory.get_by_media_identity(
|
|
db.session, MediaSource.TMDB, "6100", MediaType.TV.value) is not None
|
|
assert TransferHistory.get_by_media_identity(
|
|
db.session, MediaSource.TMDB, "6100", MediaType.MOVIE.value) is None
|
|
|
|
|
|
def test_update_download_hash_writes_only_the_target_row(db):
|
|
"""
|
|
补写下载 hash 只影响指定的那一条记录。
|
|
"""
|
|
target = db.add(_hist("目标", src="/data/t.mkv"))
|
|
db.add(_hist("其他", src="/data/o.mkv"))
|
|
|
|
TransferHistory.update_download_hash(db.session, historyid=target.id,
|
|
download_hash="new-hash")
|
|
|
|
assert TransferHistory.get_by_src(db.session, "/data/t.mkv").download_hash == "new-hash"
|
|
assert TransferHistory.get_by_src(db.session, "/data/o.mkv").download_hash is None
|
|
|
|
|
|
@pytest.mark.parametrize("season,episode,dest,expected", [
|
|
("S01", "E01", "/media/s1e1.mkv", {"季集"}),
|
|
("S01", None, None, {"季集", "整季"}),
|
|
(None, None, None, {"季集", "整季", "另一季"}),
|
|
])
|
|
def test_list_by_media_identity_narrows_by_season_episode_and_dest(
|
|
db, season, episode, dest, expected):
|
|
"""
|
|
按媒体身份查询时季、集、目标路径逐级收窄。
|
|
|
|
收窄失效会让「这一集整理过没有」误判成整季都整理过，剩余剧集被永久跳过。
|
|
"""
|
|
db.add(_hist("季集", src="/data/e1.mkv", seasons="S01", episodes="E01",
|
|
dest="/media/s1e1.mkv"),
|
|
_hist("整季", src="/data/s1.mkv", seasons="S01", episodes=None,
|
|
dest="/media/s1.mkv"),
|
|
_hist("另一季", src="/data/s2.mkv", seasons="S02", episodes=None,
|
|
dest="/media/s2.mkv"))
|
|
|
|
got = TransferHistory.list_by(db.session, mtype=MediaType.TV.value,
|
|
media_source=MediaSource.TMDB, media_id="6001",
|
|
season=season, episode=episode, dest=dest)
|
|
|
|
assert {h.title for h in got} == expected
|
|
|
|
|
|
def test_list_by_media_identity_uses_dest_for_movies(db):
|
|
"""
|
|
电影没有季集，靠目标路径区分不同版本；给出目标路径即须生效。
|
|
"""
|
|
db.add(_hist("4K 版", src="/data/m4k.mkv", mtype=MediaType.MOVIE.value,
|
|
media_id="6200", dest="/media/movie-4k.mkv"),
|
|
_hist("1080 版", src="/data/m1080.mkv", mtype=MediaType.MOVIE.value,
|
|
media_id="6200", dest="/media/movie-1080.mkv"))
|
|
|
|
got = TransferHistory.list_by(db.session, mtype=MediaType.MOVIE.value,
|
|
media_source=MediaSource.TMDB, media_id="6200",
|
|
dest="/media/movie-4k.mkv")
|
|
|
|
assert [h.title for h in got] == ["4K 版"]
|
|
|
|
|
|
def test_list_by_falls_back_to_title_and_year(db):
|
|
"""
|
|
没有媒体身份时退回「标题 + 年份」，服务于识别失败的历史数据。
|
|
"""
|
|
db.add(_hist("回退标题", src="/data/fb.mkv", media_id="6300", year="2020",
|
|
seasons="S01"))
|
|
|
|
assert [h.title for h in TransferHistory.list_by(
|
|
db.session, title="回退标题", year="2020")] == ["回退标题"]
|
|
assert [h.title for h in TransferHistory.list_by(
|
|
db.session, title="回退标题", year="2020", season="S01")] == ["回退标题"]
|
|
assert TransferHistory.list_by(db.session, title="回退标题", year="1999") == []
|
|
|
|
|
|
def test_list_by_supports_type_season_and_dest_prefix(db):
|
|
"""
|
|
媒体服务器 webhook 缺少远端身份时，按「类型 + 季 + 目标路径前缀」查询。
|
|
|
|
这是该场景下唯一能定位记录的路径，丢了会让 webhook 触发的刮削全部落空。
|
|
"""
|
|
db.add(_hist("剧集一", src="/data/wh1.mkv", mtype=MediaType.TV.value, seasons="S01",
|
|
dest="/media/Show/Season 01/e01.mkv"),
|
|
_hist("别的剧", src="/data/wh2.mkv", mtype=MediaType.TV.value, seasons="S01",
|
|
dest="/media/Other/Season 01/e01.mkv"))
|
|
|
|
got = TransferHistory.list_by(db.session, mtype=MediaType.TV.value, season="S01",
|
|
dest="/media/Show/")
|
|
|
|
assert [h.title for h in got] == ["剧集一"]
|
|
|
|
|
|
def test_list_by_without_usable_criteria_returns_empty(db):
|
|
"""
|
|
条件不足以定位时返回空列表，不能退化成返回全表。
|
|
"""
|
|
db.add(_hist("任意"))
|
|
|
|
assert TransferHistory.list_by(db.session) == []
|
|
assert TransferHistory.list_by(db.session, title="只有标题") == []
|
|
|
|
|
|
# --------------------------------------------------------------------------- #
|
|
# 列表、计数与统计
|
|
# --------------------------------------------------------------------------- #
|
|
|
|
def test_list_by_page_filters_status_and_supports_unbounded_count(db):
|
|
"""
|
|
分页可按成功状态收窄；count 为负表示不分页返回全部。
|
|
|
|
负数这条约定是「导出全部历史」依赖的，当成普通 limit 处理会返回空。
|
|
"""
|
|
db.add(_hist("成功一", src="/data/ok1.mkv", status=True, date="2026-08-13 10:00:01"),
|
|
_hist("成功二", src="/data/ok2.mkv", status=True, date="2026-08-13 10:00:02"),
|
|
_hist("失败", src="/data/ng.mkv", status=False, date="2026-08-13 10:00:03"))
|
|
|
|
assert [h.title for h in TransferHistory.list_by_page(db.session, page=1, count=1,
|
|
status=True)] == ["成功二"]
|
|
assert {h.title for h in TransferHistory.list_by_page(db.session, count=-1,
|
|
status=False)} == {"失败"}
|
|
assert len(TransferHistory.list_by_page(db.session, count=-1)) >= 3
|
|
|
|
|
|
def test_list_by_title_searches_title_source_and_destination(db):
|
|
"""
|
|
标题检索同时匹配标题、源路径与目标路径，且大小写不敏感。
|
|
|
|
只匹配标题会让用户按文件名搜不到任何记录。
|
|
"""
|
|
db.add(_hist("Alpha", src="/downloads/zzz.mkv", dest="/media/zzz.mkv"),
|
|
_hist("Beta", src="/downloads/AlphaFile.mkv", dest="/media/beta.mkv"),
|
|
_hist("Gamma", src="/downloads/g.mkv", dest="/media/alpha-dir/g.mkv"))
|
|
|
|
titles = {h.title for h in TransferHistory.list_by_title(db.session, "alpha", count=-1)}
|
|
|
|
assert titles == {"Alpha", "Beta", "Gamma"}
|
|
|
|
|
|
def test_list_by_title_wildcard_mode_takes_the_pattern_verbatim(db):
|
|
"""
|
|
通配模式下调用方自带 % 通配符，不再额外包裹。
|
|
"""
|
|
db.add(_hist("PrefixMatch", src="/downloads/p.mkv", dest="/media/p.mkv"),
|
|
_hist("NoPrefix", src="/downloads/n.mkv", dest="/media/n.mkv"))
|
|
|
|
titles = {h.title for h in TransferHistory.list_by_title(
|
|
db.session, "Prefix%", count=-1, wildcard=True)}
|
|
|
|
assert titles == {"PrefixMatch"}
|
|
|
|
|
|
def test_list_by_title_can_filter_status(db):
|
|
"""
|
|
检索结果同样支持按成功状态收窄。
|
|
"""
|
|
db.add(_hist("SearchOk", status=True, src="/downloads/ok.mkv"),
|
|
_hist("SearchFail", status=False, src="/downloads/fail.mkv"))
|
|
|
|
assert [h.title for h in TransferHistory.list_by_title(
|
|
db.session, "SearchFail", count=-1, status=False)] == ["SearchFail"]
|
|
|
|
|
|
def test_list_by_title_matches_async_twin(db):
|
|
"""
|
|
同步与异步的标题检索必须返回同一批记录。
|
|
"""
|
|
db.add(_hist("ParallelSearch", src="/downloads/par.mkv"))
|
|
|
|
sync_titles = [h.title for h in TransferHistory.list_by_title(
|
|
db.session, "ParallelSearch", count=-1)]
|
|
async_titles = [h.title for h in db.run_async_session(
|
|
lambda session: TransferHistory.async_list_by_title(
|
|
session, title="ParallelSearch", count=-1
|
|
)
|
|
)]
|
|
|
|
assert sync_titles == async_titles
|
|
|
|
|
|
def test_count_and_count_by_title_match_async_twins(db):
|
|
"""
|
|
计数与带条件计数的同步、异步结果必须一致——分页总数由它决定，
|
|
对不上就会出现「翻到最后一页是空的」。
|
|
"""
|
|
db.add(_hist("CountMe", status=True, src="/downloads/c1.mkv", dest="/media/c1.mkv"),
|
|
_hist("CountMe", status=False, src="/downloads/c2.mkv", dest="/media/c2.mkv"))
|
|
|
|
assert TransferHistory.count(db.session) == db.run_async_session(
|
|
TransferHistory.async_count
|
|
)
|
|
assert TransferHistory.count(db.session, status=True) == \
|
|
db.run_async_session(
|
|
lambda session: TransferHistory.async_count(session, status=True)
|
|
)
|
|
assert TransferHistory.count_by_title(db.session, "CountMe") == 2
|
|
assert TransferHistory.count_by_title(db.session, "CountMe", status=False) == 1
|
|
assert TransferHistory.count_by_title(db.session, "CountMe") == \
|
|
db.run_async_session(
|
|
lambda session: TransferHistory.async_count_by_title(
|
|
session, title="CountMe"
|
|
)
|
|
)
|
|
|
|
|
|
def test_statistic_groups_by_day_within_the_window(db):
|
|
"""
|
|
统计按日期分组，且只统计窗口内的记录。
|
|
"""
|
|
today = _time.strftime("%Y-%m-%d", _time.localtime())
|
|
db.add(_hist("今天一", src="/data/t1.mkv", date=f"{today} 10:00:00"),
|
|
_hist("今天二", src="/data/t2.mkv", date=f"{today} 11:00:00"),
|
|
_hist("很久以前", src="/data/t3.mkv", date="2000-01-01 10:00:00"))
|
|
|
|
rows = dict(TransferHistory.statistic(db.session, days=7))
|
|
|
|
assert rows.get(today, 0) >= 2
|
|
assert "2000-01-01" not in rows
|
|
|
|
|
|
def test_statistic_includes_the_window_start_boundary(db, frozen_now):
|
|
"""
|
|
统计窗口是闭区间起点（``date >= 起点``），正好落在起点的记录必须计入，同步异步一致。
|
|
|
|
起点由「调用时刻 - N 天」现算，不冻结时钟就摆不到边界上；上面那条用例用的是「今天」
|
|
与 2000 年两个极端值，起点比较符改成 ``>`` 照样绿。
|
|
"""
|
|
now = frozen_now(transferhistory_module)
|
|
window_start = _time.strftime("%Y-%m-%d %H:%M:%S", _time.localtime(now - 86400 * 7))
|
|
boundary_day = window_start[:10]
|
|
db.add(_hist("窗口起点上", src="/data/bstat.mkv", date=window_start))
|
|
|
|
rows = dict(TransferHistory.statistic(db.session, days=7))
|
|
async_rows = dict(db.run_async_session(
|
|
lambda session: TransferHistory.async_statistic(session, days=7)
|
|
))
|
|
|
|
assert rows.get(boundary_day, 0) == 1
|
|
assert async_rows.get(boundary_day, 0) == 1
|
|
|
|
|
|
def test_list_by_date_returns_newest_first(db):
|
|
"""
|
|
按时间查询返回该时间之后的记录，按主键倒序。
|
|
"""
|
|
db.add(_hist("旧", src="/data/od.mkv", date="2026-08-01 10:00:00"),
|
|
_hist("新", src="/data/nd.mkv", date="2026-08-12 10:00:00"))
|
|
|
|
titles = [h.title for h in TransferHistory.list_by_date(db.session, "2026-08-05")]
|
|
|
|
assert titles == ["新"]
|
|
|
|
|
|
def test_list_by_date_excludes_the_row_exactly_at_the_boundary(db):
|
|
"""
|
|
取的是「该时刻之后」的记录（``date > date``），正好等于该时刻的那条不算在内。
|
|
|
|
上面那条用例两侧数据各离边界四天与七天，比较符放宽成 ``>=`` 一样绿；
|
|
这里把行压在边界上，让开闭区间之差可观测。
|
|
"""
|
|
boundary = "2026-08-05 00:00:00"
|
|
db.add(_hist("边界上", src="/data/bd0.mkv", date=boundary),
|
|
_hist("边界后一秒", src="/data/bd1.mkv", date="2026-08-05 00:00:01"))
|
|
|
|
titles = [h.title for h in TransferHistory.list_by_date(db.session, boundary)]
|
|
|
|
assert titles == ["边界后一秒"]
|
|
|
|
|
|
def test_delete_before_is_batched_and_keeps_recent(db):
|
|
"""
|
|
历史清理分批执行且不碰保留期内的记录。
|
|
"""
|
|
for index in range(4):
|
|
db.add(_hist(f"old-{index}", src=f"/data/old{index}.mkv",
|
|
date=f"2026-01-01 10:00:0{index}"))
|
|
db.add(_hist("recent", src="/data/recent.mkv", date="2026-08-13 10:00:00"))
|
|
|
|
assert TransferHistory.delete_before(db.session, before_time="2026-08-01", limit=2) == 2
|
|
assert TransferHistory.delete_before(db.session, before_time="2026-08-01", limit=100) == 2
|
|
assert TransferHistory.delete_before(db.session, before_time="2026-08-01", limit=100) == 0
|
|
|
|
assert TransferHistory.get_by_src(db.session, "/data/recent.mkv") is not None
|
|
|
|
|
|
def test_delete_before_keeps_the_row_exactly_at_the_boundary(db):
|
|
"""
|
|
保留时间点上的整理历史属于「保留期内」，不能被清理（``date < before_time``）。
|
|
|
|
整理历史被删掉就等于丢失溯源，同一文件会被重新整理一次；
|
|
上面那条用例的数据离水位半年，``<`` 写成 ``<=`` 完全不可观测。
|
|
"""
|
|
boundary = "2026-05-01 00:00:00"
|
|
db.add(_hist("边界上", src="/data/bdel0.mkv", date=boundary),
|
|
_hist("边界前一秒", src="/data/bdel1.mkv", date="2026-04-30 23:59:59"))
|
|
|
|
assert TransferHistory.delete_before(db.session, before_time=boundary, limit=100) == 1
|
|
|
|
assert TransferHistory.get_by_src(db.session, "/data/bdel0.mkv") is not None
|
|
assert TransferHistory.get_by_src(db.session, "/data/bdel1.mkv") is None
|