mirror of
https://github.com/jxxghp/MoviePilot.git
synced 2026-11-12 08:40:27 +08:00
455 lines
16 KiB
Python
455 lines
16 KiB
Python
"""验证整理执行证据、CAS fencing 与终态结算持久化。"""
|
||
|
||
from datetime import datetime, timezone
|
||
|
||
import pytest
|
||
from sqlalchemy import create_engine, select
|
||
from sqlalchemy.orm import sessionmaker
|
||
|
||
from app.application.transfer.execution import (
|
||
TransferExecutionCheckpoint,
|
||
TransferExecutionCommand,
|
||
TransferExecutionConflictError,
|
||
TransferExecutionState,
|
||
TransferManualReviewDecision,
|
||
TransferOperationObservation,
|
||
TransferOperationObservationState,
|
||
TransferStepIntent,
|
||
TransferStepResult,
|
||
TransferStepState,
|
||
build_transfer_checkpoint_fingerprint,
|
||
build_transfer_operation_id,
|
||
)
|
||
from app.db.adapters.transfer.execution import (
|
||
TransactionalTransferExecutionRepository,
|
||
)
|
||
from app.db.base import Base
|
||
from app.db.models.transferexecutionstep import TransferExecutionStep
|
||
from app.db.models.transferhistory import TransferHistory
|
||
from app.db.models.transferpending import TransferPending
|
||
|
||
|
||
@pytest.fixture
|
||
def execution_store():
|
||
"""构造只含整理执行相关表的独立内存数据库。"""
|
||
engine = create_engine("sqlite+pysqlite:///:memory:")
|
||
Base.metadata.create_all(
|
||
engine,
|
||
tables=[
|
||
TransferPending.__table__,
|
||
TransferHistory.__table__,
|
||
TransferExecutionStep.__table__,
|
||
],
|
||
)
|
||
factory = sessionmaker(bind=engine, expire_on_commit=False)
|
||
try:
|
||
yield factory
|
||
finally:
|
||
engine.dispose()
|
||
|
||
|
||
def _seed_pending(factory, *, task_id: str = "task-1", lease_token: str = "lease-1"):
|
||
"""写入一条带有效租约与合法 planning checkpoint 的待执行任务。"""
|
||
with factory() as session:
|
||
session.add(TransferPending(
|
||
task_id=task_id,
|
||
storage="local",
|
||
src_path=f"/{task_id}.mkv",
|
||
created_at="2026-08-27 09:00:00",
|
||
state="planned",
|
||
updated_at="2026-08-27 09:00:00",
|
||
input_version=1,
|
||
planning_input={"schema_version": 1, "source": task_id},
|
||
input_fingerprint="input-fingerprint",
|
||
checkpoint_version=1,
|
||
checkpoint_payload={"schema_version": 1, "task_id": task_id},
|
||
planned_at="2026-08-27 09:00:00",
|
||
lease_owner="worker-1",
|
||
lease_token=lease_token,
|
||
lease_expires_at="2099-01-01 00:00:00.000000",
|
||
heartbeat_at="2026-08-27 01:00:00.000000",
|
||
attempt_count=1,
|
||
execution_state="not_started",
|
||
retry_generation=0,
|
||
retry_count=0,
|
||
settlement_revision=0,
|
||
))
|
||
session.commit()
|
||
|
||
|
||
def _repository(factory, token_values: list[str] | None = None):
|
||
"""构造固定时钟与可预测 attempt token 的执行命令。"""
|
||
repository = TransactionalTransferExecutionRepository(
|
||
factory,
|
||
local_clock=lambda: datetime(2026, 8, 27, 9, 30, 0),
|
||
lease_clock=lambda: datetime(2026, 8, 27, 1, 30, 0, tzinfo=timezone.utc),
|
||
)
|
||
values = iter(token_values or ["attempt-1", "attempt-2", "attempt-3"])
|
||
return repository, TransferExecutionCommand(
|
||
repository,
|
||
attempt_token_factory=lambda: next(values),
|
||
)
|
||
|
||
|
||
def _intent(*, task_id: str = "task-1", ordinal: int = 0) -> TransferStepIntent:
|
||
"""构造稳定且可重复计算身份的测试步骤意图。"""
|
||
return TransferStepIntent.create(
|
||
task_id=task_id,
|
||
checkpoint_fingerprint="plan-fingerprint",
|
||
ordinal=ordinal,
|
||
phase="transfer",
|
||
kind="copy",
|
||
payload={"src": f"/{task_id}.mkv", "dest": f"/media/{task_id}.mkv"},
|
||
)
|
||
|
||
|
||
def test_stable_operation_and_checkpoint_identities_are_canonical():
|
||
"""字段顺序不能改变 operation ID 或执行 checkpoint 指纹。"""
|
||
first = build_transfer_operation_id(
|
||
task_id="task",
|
||
checkpoint_fingerprint="plan",
|
||
ordinal=2,
|
||
phase="scrape",
|
||
kind="write",
|
||
intent_payload={"b": 2, "a": 1},
|
||
)
|
||
second = build_transfer_operation_id(
|
||
task_id="task",
|
||
checkpoint_fingerprint="plan",
|
||
ordinal=2,
|
||
phase="scrape",
|
||
kind="write",
|
||
intent_payload={"a": 1, "b": 2},
|
||
)
|
||
assert first == second
|
||
assert build_transfer_checkpoint_fingerprint({"b": 2, "a": 1}) == (
|
||
build_transfer_checkpoint_fingerprint({"a": 1, "b": 2})
|
||
)
|
||
mutable_payload = {"path": "/original"}
|
||
intent = TransferStepIntent.create(
|
||
task_id="task",
|
||
checkpoint_fingerprint="plan",
|
||
ordinal=0,
|
||
phase="transfer",
|
||
kind="copy",
|
||
payload=mutable_payload,
|
||
)
|
||
mutable_payload["path"] = "/mutated"
|
||
assert intent.payload == {"path": "/original"}
|
||
|
||
|
||
def test_success_path_persists_steps_and_execution_checkpoint(execution_store):
|
||
"""成功路径应保留每步证据，并提交可供唯一 durable writer 结算的检查点。"""
|
||
_seed_pending(execution_store)
|
||
repository, command = _repository(execution_store)
|
||
prepared = command.prepare(
|
||
task_id="task-1",
|
||
lease_token="lease-1",
|
||
intent=_intent(),
|
||
)
|
||
assert prepared.state is TransferStepState.PREPARED
|
||
started = command.begin(
|
||
task_id="task-1",
|
||
lease_token="lease-1",
|
||
operation_id=prepared.operation_id,
|
||
)
|
||
assert started.attempt_token == "attempt-1"
|
||
succeeded = command.complete(
|
||
task_id="task-1",
|
||
lease_token="lease-1",
|
||
step=started,
|
||
result=TransferStepResult(payload={"dest_exists": True}),
|
||
)
|
||
checkpoint = TransferExecutionCheckpoint.create(
|
||
payload={"dest": "/media/task-1.mkv"},
|
||
operation_ids=(succeeded.operation_id,),
|
||
)
|
||
snapshot = command.checkpoint(
|
||
task_id="task-1",
|
||
lease_token="lease-1",
|
||
checkpoint=checkpoint,
|
||
)
|
||
assert snapshot.state is TransferExecutionState.SETTLING
|
||
with execution_store() as session:
|
||
pending = session.scalar(select(TransferPending))
|
||
assert pending is not None
|
||
assert pending.execution_fingerprint == checkpoint.fingerprint
|
||
step = session.scalar(select(TransferExecutionStep))
|
||
assert step is not None and step.state == "succeeded"
|
||
|
||
|
||
def test_retry_wait_resumes_same_failed_operation_with_new_attempt(execution_store):
|
||
"""到期重试必须复用 operation ID、保留失败证据并轮换 attempt token。"""
|
||
_seed_pending(execution_store)
|
||
repository, command = _repository(execution_store)
|
||
prepared = command.prepare(
|
||
task_id="task-1", lease_token="lease-1", intent=_intent()
|
||
)
|
||
started = command.begin(
|
||
task_id="task-1",
|
||
lease_token="lease-1",
|
||
operation_id=prepared.operation_id,
|
||
)
|
||
deferred = command.defer(
|
||
task_id="task-1",
|
||
lease_token="lease-1",
|
||
step=started,
|
||
error="destination unavailable",
|
||
retry_due_at="2026-08-27 01:30:01.000000",
|
||
evidence=TransferStepResult(payload={"applied": False}),
|
||
)
|
||
assert deferred.state is TransferExecutionState.RETRY_WAIT
|
||
assert deferred.retry_generation == 1
|
||
with execution_store() as session:
|
||
claimed = TransferPending.claim_task(
|
||
session,
|
||
task_id="task-1",
|
||
states=("planned",),
|
||
owner_id="worker-2",
|
||
lease_token="lease-2",
|
||
now_time="2026-08-27 01:30:02.000000",
|
||
lease_expires_at="2099-01-01 00:00:00.000000",
|
||
updated_at="2026-08-27 09:30:02",
|
||
)
|
||
session.commit()
|
||
assert claimed == 1
|
||
resumed = command.resume_failed(
|
||
task_id="task-1",
|
||
lease_token="lease-2",
|
||
step=deferred.steps[0],
|
||
)
|
||
assert resumed.operation_id == prepared.operation_id
|
||
assert resumed.attempt_token == "attempt-2"
|
||
assert resumed.attempt_count == 2
|
||
assert resumed.result == TransferStepResult(payload={"applied": False})
|
||
assert resumed.last_error == "destination unavailable"
|
||
|
||
|
||
def test_orphan_started_requires_observation_before_attempt_rotation(execution_store):
|
||
"""遗留 STARTED 只能凭 NOT_APPLIED 证据轮换 attempt，旧 attempt 随即失效。"""
|
||
_seed_pending(execution_store)
|
||
repository, command = _repository(execution_store)
|
||
prepared = command.prepare(
|
||
task_id="task-1", lease_token="lease-1", intent=_intent()
|
||
)
|
||
started = command.begin(
|
||
task_id="task-1",
|
||
lease_token="lease-1",
|
||
operation_id=prepared.operation_id,
|
||
)
|
||
observation = TransferOperationObservation(
|
||
state=TransferOperationObservationState.NOT_APPLIED,
|
||
evidence=TransferStepResult(payload={"dest_exists": False}),
|
||
)
|
||
restarted = command.restart_after_not_applied(
|
||
task_id="task-1",
|
||
lease_token="lease-1",
|
||
step=started,
|
||
evidence=observation.evidence,
|
||
)
|
||
assert restarted.attempt_token == "attempt-2"
|
||
assert restarted.attempt_count == 2
|
||
with pytest.raises(TransferExecutionConflictError):
|
||
repository.complete_step(
|
||
task_id="task-1",
|
||
lease_token="lease-1",
|
||
operation_id=started.operation_id,
|
||
attempt_token="attempt-1",
|
||
result=TransferStepResult(payload={"stale": True}),
|
||
)
|
||
|
||
|
||
def test_zero_side_effect_checkpoint_is_vacuously_complete(execution_store):
|
||
"""纯策略拒绝可在没有步骤行时提交带 skip_reason 的确定执行结果。"""
|
||
_seed_pending(execution_store)
|
||
_, command = _repository(execution_store)
|
||
checkpoint = TransferExecutionCheckpoint.create(
|
||
payload={"preview": True, "accepted": False},
|
||
operation_ids=(),
|
||
skip_reason="preview",
|
||
)
|
||
snapshot = command.checkpoint(
|
||
task_id="task-1",
|
||
lease_token="lease-1",
|
||
checkpoint=checkpoint,
|
||
)
|
||
assert snapshot.state is TransferExecutionState.SETTLING
|
||
assert snapshot.checkpoint == checkpoint
|
||
assert snapshot.steps == ()
|
||
|
||
|
||
def test_exhausted_step_builds_failure_checkpoint_and_keeps_lease(execution_store):
|
||
"""预算耗尽应原子建立失败结算检查点，并为 durable writer 保留 lease。"""
|
||
_seed_pending(execution_store)
|
||
_, command = _repository(execution_store)
|
||
prepared = command.prepare(
|
||
task_id="task-1", lease_token="lease-1", intent=_intent()
|
||
)
|
||
started = command.begin(
|
||
task_id="task-1",
|
||
lease_token="lease-1",
|
||
operation_id=prepared.operation_id,
|
||
)
|
||
snapshot = command.exhaust(
|
||
task_id="task-1",
|
||
lease_token="lease-1",
|
||
step=started,
|
||
error="retry budget exhausted",
|
||
evidence=TransferStepResult(payload={"applied": False}),
|
||
)
|
||
assert snapshot.state is TransferExecutionState.SETTLING
|
||
assert snapshot.checkpoint is not None
|
||
assert snapshot.checkpoint.payload["outcome"] == "failed"
|
||
assert snapshot.checkpoint.payload["error"] == "retry budget exhausted"
|
||
assert snapshot.checkpoint.operation_ids == (started.operation_id,)
|
||
assert snapshot.steps[0].state is TransferStepState.FAILED
|
||
with execution_store() as session:
|
||
pending = session.scalar(select(TransferPending))
|
||
assert pending is not None
|
||
assert pending.lease_token == "lease-1"
|
||
|
||
|
||
def test_user_retry_is_single_generation_and_rejects_manual_review(execution_store):
|
||
"""FAILED 用户重试只递增一次世代，重复请求幂等且人工复核必须拒绝。"""
|
||
_seed_pending(execution_store)
|
||
with execution_store() as session:
|
||
pending = session.scalar(select(TransferPending))
|
||
assert pending is not None
|
||
pending.execution_state = "failed"
|
||
pending.lease_owner = None
|
||
pending.lease_token = None
|
||
pending.lease_expires_at = None
|
||
pending.terminal_history_id = 42
|
||
pending.retry_count = 3
|
||
session.commit()
|
||
_, command = _repository(execution_store)
|
||
first = command.request_retry(
|
||
task_id="task-1",
|
||
reason="用户确认目标未落地",
|
||
requested_by="admin",
|
||
)
|
||
repeated = command.request_retry(
|
||
task_id="task-1",
|
||
reason="重复点击",
|
||
requested_by="admin",
|
||
)
|
||
assert first.accepted and repeated.accepted
|
||
assert first.retry_generation == repeated.retry_generation == 1
|
||
with execution_store() as session:
|
||
pending = session.scalar(select(TransferPending))
|
||
assert pending is not None
|
||
assert pending.execution_state == "retry_wait"
|
||
assert pending.retry_count == 3
|
||
assert pending.terminal_history_id == 42
|
||
assert pending.retry_reason == "用户确认目标未落地"
|
||
assert pending.retry_requested_by == "admin"
|
||
pending.execution_state = "manual_review"
|
||
session.commit()
|
||
rejected = command.request_retry(
|
||
task_id="task-1",
|
||
reason="强制重试",
|
||
requested_by="admin",
|
||
)
|
||
assert not rejected.accepted
|
||
assert rejected.state is TransferExecutionState.MANUAL_REVIEW
|
||
assert "人工" in rejected.message
|
||
|
||
|
||
def test_manual_not_applied_decision_is_audited_and_schedules_same_step(
|
||
execution_store,
|
||
) -> None:
|
||
"""人工判定未发生应无 lease 地恢复 FAILED，并只交给唯一调度器。"""
|
||
_seed_pending(execution_store)
|
||
_, command = _repository(execution_store)
|
||
prepared = command.prepare(
|
||
task_id="task-1", lease_token="lease-1", intent=_intent()
|
||
)
|
||
started = command.begin(
|
||
task_id="task-1",
|
||
lease_token="lease-1",
|
||
operation_id=prepared.operation_id,
|
||
)
|
||
manual = command.manual_review(
|
||
task_id="task-1",
|
||
lease_token="lease-1",
|
||
step=started,
|
||
error="external result unknown",
|
||
)
|
||
assert manual.state is TransferExecutionState.MANUAL_REVIEW
|
||
resolved = command.resolve_manual_review(
|
||
task_id="task-1",
|
||
operation_id=started.operation_id,
|
||
decision=TransferManualReviewDecision.NOT_APPLIED,
|
||
actor="admin",
|
||
reason="目标与临时文件均不存在",
|
||
result=TransferStepResult(payload={"dest_exists": False}),
|
||
)
|
||
assert resolved.state is TransferExecutionState.RETRY_WAIT
|
||
assert resolved.review_revision == 1
|
||
assert resolved.step.state is TransferStepState.FAILED
|
||
with execution_store() as session:
|
||
pending = session.scalar(select(TransferPending))
|
||
assert pending is not None
|
||
assert pending.lease_token is None
|
||
assert pending.reviewed_by == "admin"
|
||
assert pending.review_decision == "not_applied"
|
||
assert pending.review_reason == "目标与临时文件均不存在"
|
||
with pytest.raises(TransferExecutionConflictError):
|
||
command.resolve_manual_review(
|
||
task_id="task-1",
|
||
operation_id=started.operation_id,
|
||
decision=TransferManualReviewDecision.NOT_APPLIED,
|
||
actor="admin",
|
||
reason="重复判定",
|
||
)
|
||
|
||
|
||
def test_manual_applied_requires_result_and_failed_decision_is_rejected(
|
||
execution_store,
|
||
) -> None:
|
||
"""人工判定已发生必须带结果证据，FAILED 不得绕过 lease durable 结算。"""
|
||
_seed_pending(execution_store)
|
||
_, command = _repository(execution_store)
|
||
prepared = command.prepare(
|
||
task_id="task-1", lease_token="lease-1", intent=_intent()
|
||
)
|
||
started = command.begin(
|
||
task_id="task-1",
|
||
lease_token="lease-1",
|
||
operation_id=prepared.operation_id,
|
||
)
|
||
command.manual_review(
|
||
task_id="task-1",
|
||
lease_token="lease-1",
|
||
step=started,
|
||
error="external result unknown",
|
||
)
|
||
with pytest.raises(ValueError, match="结果证据"):
|
||
command.resolve_manual_review(
|
||
task_id="task-1",
|
||
operation_id=started.operation_id,
|
||
decision=TransferManualReviewDecision.APPLIED,
|
||
actor="admin",
|
||
reason="已确认目标存在",
|
||
)
|
||
with pytest.raises(TransferExecutionConflictError, match="durable"):
|
||
command.resolve_manual_review(
|
||
task_id="task-1",
|
||
operation_id=started.operation_id,
|
||
decision=TransferManualReviewDecision.FAILED,
|
||
actor="admin",
|
||
reason="确认失败",
|
||
)
|
||
resolved = command.resolve_manual_review(
|
||
task_id="task-1",
|
||
operation_id=started.operation_id,
|
||
decision=TransferManualReviewDecision.APPLIED,
|
||
actor="admin",
|
||
reason="目标摘要匹配",
|
||
result=TransferStepResult(payload={"dest_exists": True, "hash_match": True}),
|
||
)
|
||
assert resolved.step.state is TransferStepState.SUCCEEDED
|
||
assert resolved.step.result == TransferStepResult(
|
||
payload={"dest_exists": True, "hash_match": True}
|
||
)
|