1055 行
40 KiB
Python
1055 行
40 KiB
Python
from __future__ import annotations
|
||
|
||
import json
|
||
from pathlib import Path
|
||
import threading
|
||
import time
|
||
from typing import Any
|
||
|
||
import pytest
|
||
|
||
from backend.dto.common import ApiError, ErrorCode
|
||
from backend.services.generation_service import GenerationService
|
||
from backend.services.image_service import ImageService
|
||
from backend.services.queue_service import QueueService
|
||
from backend.services.workflow_material_snapshot_service import WorkflowMaterialSnapshotService
|
||
from backend.services.workflow_round_feedback_service import WorkflowRoundFeedbackService
|
||
from backend.services.workflow_round_service import WorkflowRoundService
|
||
from backend.services.workflow_round_worker_runtime import WorkflowRoundWorkerRuntime
|
||
from backend.services.workflow_service import WorkflowService
|
||
from core.audit_service import AuditService
|
||
from core.identity import RequestContext
|
||
from database.db_helper import Database, DatabaseSettings, SqliteSettings
|
||
from database.repositories.image_repository import ImageRepository
|
||
from database.repositories.job_repository import JobRepository
|
||
from database.repositories.material_repository import MaterialRepository
|
||
from database.repositories.profile_repository import ProfileRepository
|
||
from database.repositories.workflow_repository import WorkflowRepository
|
||
from database.repositories.workflow_round_repository import WorkflowRoundRepository
|
||
from engines.single_flow import SingleFlowEngine
|
||
|
||
|
||
class _TempStorage:
|
||
def __init__(self, root: Path):
|
||
self.root = root
|
||
|
||
def resolve_uri(self, uri: str) -> Path:
|
||
assert uri.startswith("storage://")
|
||
storage_root, relative = uri[len("storage://") :].split("/", 1)
|
||
return self.root / storage_root / relative
|
||
|
||
def ensure_file(self, uri: str) -> Path:
|
||
path = self.resolve_uri(uri)
|
||
if not path.is_file():
|
||
raise FileNotFoundError(path)
|
||
return path
|
||
|
||
|
||
class _CountingPromptExpansion:
|
||
def __init__(self) -> None:
|
||
self.calls = 0
|
||
|
||
def expand_for_node(self, _profile, node, payload: dict[str, Any]) -> dict[str, Any]:
|
||
self.calls += 1
|
||
return {
|
||
"prompt": str(payload.get("prompt") or node.prompt or "portrait") + ", expanded once",
|
||
"negative_prompt": str(payload.get("negative_prompt") or node.negative_prompt or ""),
|
||
}
|
||
|
||
|
||
def _database(tmp_path: Path) -> Database:
|
||
database = Database(
|
||
DatabaseSettings(
|
||
backend="sqlite",
|
||
sqlite=SqliteSettings(path=str(tmp_path / "workflow-round-runtime.sqlite3")),
|
||
)
|
||
)
|
||
database.initialize()
|
||
return database
|
||
|
||
|
||
def _fixture(tmp_path: Path):
|
||
database = _database(tmp_path)
|
||
profiles = ProfileRepository(database)
|
||
profiles.create(
|
||
{
|
||
"profile_id": "profile-round-runtime",
|
||
"name": "Round runtime",
|
||
"owner_platform": "webui",
|
||
"owner_user_id": "system",
|
||
"status": "active",
|
||
"metadata": {},
|
||
}
|
||
)
|
||
workflows = WorkflowRepository(database)
|
||
workflows.create_workflow(
|
||
{
|
||
"workflow_id": "workflow-round-runtime",
|
||
"profile_id": "profile-round-runtime",
|
||
"workflow_type": "character_gradual",
|
||
"display_name": "Round runtime",
|
||
"status": "running",
|
||
"current_node_id": "node-round-runtime",
|
||
"current_branch": "main",
|
||
"metadata": {
|
||
"character_execution": {
|
||
"executor": "character_workflow",
|
||
"import_confirmed": True,
|
||
"progression_version": "character_gradual_sequential_v1",
|
||
}
|
||
},
|
||
}
|
||
)
|
||
workflows.create_node(
|
||
{
|
||
"node_id": "node-round-runtime",
|
||
"workflow_id": "workflow-round-runtime",
|
||
"node_key": "headshot",
|
||
"title": "头像",
|
||
"node_type": "generation",
|
||
"status": "draft",
|
||
"branch_name": "main",
|
||
"prompt": "one stable character portrait",
|
||
"negative_prompt": "identity drift",
|
||
"model_route": "portrait-route",
|
||
"sort_order": 40,
|
||
"metadata": {},
|
||
}
|
||
)
|
||
workflows.create_node(
|
||
{
|
||
"node_id": "node-round-runtime-next",
|
||
"workflow_id": "workflow-round-runtime",
|
||
"node_key": "upper_body",
|
||
"title": "上半身",
|
||
"node_type": "generation",
|
||
"status": "draft",
|
||
"branch_name": "main",
|
||
"prompt": "same character upper body",
|
||
"negative_prompt": "identity drift",
|
||
"model_route": "portrait-route",
|
||
"sort_order": 50,
|
||
"metadata": {},
|
||
}
|
||
)
|
||
audit = AuditService(database)
|
||
workflow_service = WorkflowService(workflows, profiles, audit)
|
||
queue = QueueService(JobRepository(database), audit)
|
||
image_service = ImageService(ImageRepository(database), workflows, audit)
|
||
expansion = _CountingPromptExpansion()
|
||
materials = MaterialRepository(database)
|
||
generation = GenerationService(
|
||
workflow_service=workflow_service,
|
||
queue_service=queue,
|
||
image_service=image_service,
|
||
single_flow_engine=SingleFlowEngine(
|
||
storage=_TempStorage(tmp_path / "storage"),
|
||
allow_mock_fallback=True,
|
||
),
|
||
prompt_expansion_service=expansion,
|
||
material_resolver=materials,
|
||
material_snapshot_service=WorkflowMaterialSnapshotService(workflows, materials),
|
||
require_resolved_model_route=False,
|
||
)
|
||
rounds = WorkflowRoundService(
|
||
WorkflowRoundRepository(database),
|
||
workflows,
|
||
image_service.image_repository,
|
||
queue.repository,
|
||
audit,
|
||
generation_service=generation,
|
||
)
|
||
return database, generation, rounds, expansion
|
||
|
||
|
||
def _wait_for_round(rounds: WorkflowRoundService, round_id: str, statuses: set[str], timeout: float = 15.0):
|
||
deadline = time.monotonic() + timeout
|
||
while time.monotonic() < deadline:
|
||
detail = rounds.get_round(round_id).to_dict()
|
||
if detail["round"]["status"] in statuses:
|
||
return detail
|
||
time.sleep(0.02)
|
||
raise AssertionError(f"round {round_id} did not reach {sorted(statuses)}")
|
||
|
||
|
||
def _complete_round(
|
||
generation: GenerationService,
|
||
rounds: WorkflowRoundService,
|
||
*,
|
||
count: int = 4,
|
||
idempotency_key: str,
|
||
):
|
||
created = rounds.create_round(
|
||
"node-round-runtime",
|
||
{"count": count, "idempotency_key": idempotency_key},
|
||
RequestContext.system("round-runtime-test"),
|
||
)
|
||
runtime = WorkflowRoundWorkerRuntime(generation, rounds, worker_count=count, interval_seconds=0.01)
|
||
runtime.start()
|
||
try:
|
||
return _wait_for_round(rounds, created["round"]["round_id"], {"completed"})
|
||
finally:
|
||
runtime.stop()
|
||
|
||
|
||
def test_chat_terminal_notification_is_durable_and_replayed_after_reload(tmp_path: Path) -> None:
|
||
_database_handle, generation, rounds, _expansion = _fixture(tmp_path)
|
||
created = rounds.create_round(
|
||
"node-round-runtime",
|
||
{
|
||
"count": 4,
|
||
"idempotency_key": "runtime-chat-notification",
|
||
"chat_notification": {
|
||
"notify_on_terminal": True,
|
||
"reply_target": {
|
||
"platform": "qq",
|
||
"message_origin": "qq:group:100",
|
||
"message_id": "message-1",
|
||
"user_id": "user-1",
|
||
"group_id": "100",
|
||
},
|
||
},
|
||
},
|
||
RequestContext.from_astrbot(
|
||
username="system",
|
||
user_id="system",
|
||
source="astrbot_chat:qq",
|
||
platform="qq",
|
||
session_key="qq:group:100",
|
||
permissions={"*"},
|
||
),
|
||
)
|
||
received: list[dict[str, Any]] = []
|
||
runtime = WorkflowRoundWorkerRuntime(
|
||
generation,
|
||
rounds,
|
||
worker_count=4,
|
||
interval_seconds=0.01,
|
||
terminal_notification_callback=received.append,
|
||
)
|
||
runtime.start()
|
||
try:
|
||
_wait_for_round(rounds, created["round"]["round_id"], {"completed"})
|
||
deadline = time.monotonic() + 2
|
||
while not received and time.monotonic() < deadline:
|
||
time.sleep(0.02)
|
||
finally:
|
||
runtime.stop()
|
||
|
||
assert len(received) == 1
|
||
assert received[0]["reply_target"]["message_origin"] == "qq:group:100"
|
||
assert len(received[0]["candidates"]) == 4
|
||
|
||
# Simulate a reload after the callback was scheduled but before AstrBot
|
||
# acknowledged send_message. A new runtime must recover the pending row.
|
||
reloaded = WorkflowRoundWorkerRuntime(generation, rounds, worker_count=1)
|
||
pending = reloaded.pending_terminal_notifications()
|
||
assert [item["round_id"] for item in pending] == [created["round"]["round_id"]]
|
||
reloaded.mark_terminal_notification(created["round"]["round_id"], delivered=True)
|
||
|
||
second_reload = WorkflowRoundWorkerRuntime(generation, rounds, worker_count=1)
|
||
assert second_reload.pending_terminal_notifications() == []
|
||
|
||
|
||
def test_round_prepare_runs_once_and_returns_independent_queued_tasks(tmp_path: Path) -> None:
|
||
_database_handle, generation, rounds, expansion = _fixture(tmp_path)
|
||
ctx = RequestContext.system("round-runtime-test")
|
||
|
||
created = rounds.create_round(
|
||
"node-round-runtime",
|
||
{"count": 4, "idempotency_key": "runtime-round-1", "prompt": "silver-haired knight"},
|
||
ctx,
|
||
)
|
||
|
||
assert created["round"]["status"] == "queued"
|
||
assert expansion.calls == 1
|
||
tasks = [item["task"] for item in created["candidates"]]
|
||
assert len({task["task_id"] for task in tasks}) == 4
|
||
assert all(task["status"] == "queued" for task in tasks)
|
||
assert all(task["request"]["count"] == 1 for task in tasks)
|
||
assert all(task["metadata"]["source"] == "workflow_round" for task in tasks)
|
||
assert [task["request"]["output_scope"]["candidate_display_code"] for task in tasks] == [
|
||
"TX-01-01",
|
||
"TX-01-02",
|
||
"TX-01-03",
|
||
"TX-01-04",
|
||
]
|
||
assert generation.image_service.list_by_node("node-round-runtime") == []
|
||
|
||
replay = rounds.create_round(
|
||
"node-round-runtime",
|
||
{"count": 5, "idempotency_key": "runtime-round-1", "prompt": "must not replan"},
|
||
ctx,
|
||
)
|
||
assert replay["idempotent_replay"] is True
|
||
assert expansion.calls == 1
|
||
assert [item["task"]["task_id"] for item in replay["candidates"]] == [
|
||
task["task_id"] for task in tasks
|
||
]
|
||
|
||
|
||
def test_four_candidates_execute_concurrently_with_isolated_outputs(tmp_path: Path) -> None:
|
||
_database_handle, generation, rounds, _expansion = _fixture(tmp_path)
|
||
created = rounds.create_round(
|
||
"node-round-runtime",
|
||
{"count": 4, "idempotency_key": "runtime-round-concurrent"},
|
||
RequestContext.system("round-runtime-test"),
|
||
)
|
||
active = 0
|
||
max_active = 0
|
||
guard = threading.Lock()
|
||
barrier = threading.Barrier(4)
|
||
original_execute = generation.execute_claimed_generation
|
||
|
||
def tracked_execute(task, ctx):
|
||
nonlocal active, max_active
|
||
with guard:
|
||
active += 1
|
||
max_active = max(max_active, active)
|
||
try:
|
||
barrier.wait(timeout=10.0)
|
||
return original_execute(task, ctx)
|
||
finally:
|
||
with guard:
|
||
active -= 1
|
||
|
||
generation.execute_claimed_generation = tracked_execute # type: ignore[method-assign]
|
||
runtime = WorkflowRoundWorkerRuntime(generation, rounds, worker_count=4, interval_seconds=0.01)
|
||
runtime.start()
|
||
try:
|
||
detail = _wait_for_round(rounds, created["round"]["round_id"], {"completed"})
|
||
finally:
|
||
runtime.stop()
|
||
|
||
assert max_active == 4
|
||
assert all(item["candidate"]["generation_status"] == "succeeded" for item in detail["candidates"])
|
||
assert len({item["candidate"]["image_id"] for item in detail["candidates"]}) == 4
|
||
assert all(item["image"]["is_selected"] is False for item in detail["candidates"])
|
||
assert all("workflows/workflow-round-runtime/main/headshot" in item["image"]["image_uri"] for item in detail["candidates"])
|
||
assert generation.workflow_service.get_node("node-round-runtime").status == "completed"
|
||
|
||
|
||
def test_one_candidate_timeout_produces_partial_success_without_poisoning_siblings(tmp_path: Path) -> None:
|
||
_database_handle, generation, rounds, _expansion = _fixture(tmp_path)
|
||
created = rounds.create_round(
|
||
"node-round-runtime",
|
||
{"count": 4, "idempotency_key": "runtime-round-partial"},
|
||
RequestContext.system("round-runtime-test"),
|
||
)
|
||
original_execute = generation.execute_claimed_generation
|
||
|
||
def sometimes_timeout(task, ctx):
|
||
if int(task.metadata.get("candidate_index") or 0) == 2:
|
||
raise TimeoutError("candidate-specific timeout")
|
||
return original_execute(task, ctx)
|
||
|
||
generation.execute_claimed_generation = sometimes_timeout # type: ignore[method-assign]
|
||
runtime = WorkflowRoundWorkerRuntime(generation, rounds, worker_count=4, interval_seconds=0.01)
|
||
runtime.start()
|
||
try:
|
||
detail = _wait_for_round(rounds, created["round"]["round_id"], {"partial_success"})
|
||
finally:
|
||
runtime.stop()
|
||
|
||
statuses = [item["candidate"]["generation_status"] for item in detail["candidates"]]
|
||
assert statuses == ["succeeded", "failed", "succeeded", "succeeded"]
|
||
assert detail["candidates"][1]["candidate"]["failure"]["error_type"] == "TimeoutError"
|
||
assert generation.workflow_service.get_node("node-round-runtime").status == "completed"
|
||
|
||
|
||
def test_startup_recovery_requeues_only_stale_round_tasks(tmp_path: Path) -> None:
|
||
database, generation, rounds, _expansion = _fixture(tmp_path)
|
||
created = rounds.create_round(
|
||
"node-round-runtime",
|
||
{"count": 2, "idempotency_key": "runtime-round-recovery"},
|
||
RequestContext.system("round-runtime-test"),
|
||
)
|
||
task_ids = [item["task"]["task_id"] for item in created["candidates"]]
|
||
generation.queue_service.repository.update(task_ids[0], {"status": "running"})
|
||
generation.queue_service.repository.update(task_ids[1], {"status": "retrying"})
|
||
unrelated = generation.queue_service.repository.create(
|
||
{
|
||
"task_id": "unrelated-running",
|
||
"status": "running",
|
||
"request": {},
|
||
"metadata": {"source": "nodes.generate"},
|
||
}
|
||
)
|
||
conn = database.connect()
|
||
try:
|
||
conn.execute(
|
||
"UPDATE generation_tasks SET updated_at = ? WHERE task_id IN (?, ?, ?)",
|
||
("2020-01-01 00:00:00", task_ids[0], task_ids[1], unrelated.task_id),
|
||
)
|
||
conn.commit()
|
||
finally:
|
||
conn.close()
|
||
|
||
recovery = generation.queue_service.recover_stale_tasks(
|
||
RequestContext.system("round-runtime-recovery"),
|
||
stale_after_seconds=1,
|
||
)
|
||
|
||
assert set(recovery["recovered_task_ids"]) == set(task_ids)
|
||
assert all(generation.queue_service.get_job(task_id).status == "queued" for task_id in task_ids)
|
||
assert generation.queue_service.get_job(unrelated.task_id).status == "running"
|
||
assert all(
|
||
generation.queue_service.get_job(task_id).metadata["recovery"]["previous_status"]
|
||
in {"running", "retrying"}
|
||
for task_id in task_ids
|
||
)
|
||
|
||
|
||
def test_persisted_round_route_is_secret_free_and_runtime_detects_route_drift(tmp_path: Path) -> None:
|
||
_database_handle, generation, rounds, _expansion = _fixture(tmp_path)
|
||
|
||
def original_route(_route_name: str) -> dict[str, Any]:
|
||
return {
|
||
"route_name": "portrait-route",
|
||
"route_id": "route-portrait",
|
||
"status": "resolved",
|
||
"provider_id": "provider-a",
|
||
"provider_type": "openai_compatible",
|
||
"model_id": "model-a",
|
||
"modality": "image_generation",
|
||
"settings": {
|
||
"extra_headers": {"Authorization": "Bearer must-not-persist"},
|
||
"api_key": "must-not-persist",
|
||
},
|
||
}
|
||
|
||
generation._resolve_model_route = original_route # type: ignore[method-assign]
|
||
created = rounds.create_round(
|
||
"node-round-runtime",
|
||
{"count": 1, "idempotency_key": "runtime-round-secret-safe"},
|
||
RequestContext.system("round-runtime-test"),
|
||
)
|
||
persisted = json.dumps(created, ensure_ascii=False, sort_keys=True)
|
||
assert "must-not-persist" not in persisted
|
||
assert "extra_headers" not in persisted
|
||
assert '"api_key"' not in persisted
|
||
|
||
generation._resolve_model_route = lambda _route_name: { # type: ignore[method-assign]
|
||
**original_route("portrait-route"),
|
||
"model_id": "model-b",
|
||
"settings": {},
|
||
}
|
||
runtime = WorkflowRoundWorkerRuntime(generation, rounds, worker_count=1, interval_seconds=0.01)
|
||
runtime.start()
|
||
try:
|
||
detail = _wait_for_round(rounds, created["round"]["round_id"], {"all_failed"})
|
||
finally:
|
||
runtime.stop()
|
||
assert detail["candidates"][0]["candidate"]["generation_status"] == "failed"
|
||
assert "model route changed" in detail["candidates"][0]["candidate"]["failure"]["message"]
|
||
|
||
|
||
def test_feedback_persists_strict_rejection_and_limits_liked_candidates(tmp_path: Path) -> None:
|
||
_database_handle, generation, rounds, _expansion = _fixture(tmp_path)
|
||
detail = _complete_round(
|
||
generation,
|
||
rounds,
|
||
count=4,
|
||
idempotency_key="round-feedback-persist",
|
||
)
|
||
round_id = detail["round"]["round_id"]
|
||
candidates = [item["candidate_id"] for item in detail["candidates"]]
|
||
assert all(item["is_final"] is False for item in detail["candidates"])
|
||
assert all(item["image"]["is_selected"] is False for item in detail["candidates"])
|
||
|
||
updated = rounds.update_feedback(
|
||
round_id,
|
||
{
|
||
"updates": [
|
||
{"candidate_id": candidates[0], "preference_status": "liked", "reason": "五官最好"},
|
||
{"candidate_id": candidates[1], "preference_status": "liked"},
|
||
{
|
||
"candidate_id": candidates[2],
|
||
"preference_status": "strict_rejected",
|
||
"reason": "身份偏差严重",
|
||
},
|
||
]
|
||
},
|
||
RequestContext.system("feedback-test"),
|
||
)
|
||
by_id = {item["candidate_id"]: item for item in updated["candidates"]}
|
||
assert by_id[candidates[0]]["preference_status"] == "liked"
|
||
assert by_id[candidates[0]]["preference_reason"] == "五官最好"
|
||
assert by_id[candidates[2]]["preference_status"] == "strict_rejected"
|
||
assert rounds.get_round(round_id).to_dict()["round"]["feedback_snapshot"][candidates[2]][
|
||
"preference_status"
|
||
] == "strict_rejected"
|
||
assert all(item["image"]["is_selected"] is False for item in updated["candidates"])
|
||
|
||
with pytest.raises(ApiError) as too_many:
|
||
rounds.update_feedback(
|
||
round_id,
|
||
{
|
||
"updates": [
|
||
{"candidate_id": candidates[2], "preference_status": "liked"},
|
||
{"candidate_id": candidates[3], "preference_status": "liked"},
|
||
]
|
||
},
|
||
RequestContext.system("feedback-test"),
|
||
)
|
||
assert too_many.value.details["maximum"] == 3
|
||
|
||
with pytest.raises(ApiError) as rejected_confirm:
|
||
rounds.confirm_candidate(
|
||
round_id,
|
||
{"candidate_id": candidates[2]},
|
||
RequestContext.system("feedback-test"),
|
||
)
|
||
assert rejected_confirm.value.details["reason"] == "candidate_rejected"
|
||
|
||
|
||
def test_conversational_feedback_and_next_round_share_safe_persisted_context(tmp_path: Path) -> None:
|
||
_database_handle, generation, rounds, _expansion = _fixture(tmp_path)
|
||
detail = _complete_round(
|
||
generation,
|
||
rounds,
|
||
count=4,
|
||
idempotency_key="round-conversation-parent",
|
||
)
|
||
round_id = detail["round"]["round_id"]
|
||
captured: list[dict[str, Any]] = []
|
||
|
||
def complete(payload: dict[str, Any]) -> dict[str, Any]:
|
||
captured.append(payload)
|
||
return {
|
||
"feedback": {
|
||
"liked": ["TX-01-01", "TX-01-02"],
|
||
"strict_rejected": ["TX-01-03"],
|
||
},
|
||
"positive_patch": "keep the masculine face and short silver hair",
|
||
"negative_patch": "avoid the oversized shoulder ornament",
|
||
"material_intent": "matte black wool coat",
|
||
}
|
||
|
||
rounds.feedback_service = WorkflowRoundFeedbackService(
|
||
structured_text_callable=complete,
|
||
model_route="prompt-planning-test",
|
||
)
|
||
updated = rounds.update_feedback(
|
||
round_id,
|
||
{
|
||
"feedback_text": "1、2喜欢,3严格拒绝;下一轮统一短银发;素材:黑色羊毛外套",
|
||
"idempotency_key": "feedback-conversation-1",
|
||
},
|
||
RequestContext.system("feedback-conversation"),
|
||
)
|
||
|
||
assert len(captured) == 1
|
||
serialized_request = json.dumps(captured[0], ensure_ascii=False)
|
||
assert all(
|
||
item["candidate_id"] not in serialized_request for item in detail["candidates"]
|
||
)
|
||
assert "candidate_id" not in serialized_request
|
||
assert "expanded once" in captured[0]["candidate_whitelist"][0]["positive_prompt"]
|
||
conversation = updated["round"]["feedback_snapshot"]["_conversation"]
|
||
assert conversation["source_text"].startswith("1、2喜欢")
|
||
assert conversation["positive_patch"] == "keep the masculine face and short silver hair"
|
||
assert conversation["negative_patch"] == "avoid the oversized shoulder ornament"
|
||
assert updated["interpretation"]["source"] == "llm_validated"
|
||
|
||
replay = rounds.update_feedback(
|
||
round_id,
|
||
{
|
||
"feedback_text": "1、2喜欢,3严格拒绝;下一轮统一短银发;素材:黑色羊毛外套",
|
||
"idempotency_key": "feedback-conversation-1",
|
||
},
|
||
RequestContext.system("feedback-conversation"),
|
||
)
|
||
assert replay["feedback_operation"]["idempotent_replay"] is True
|
||
assert len(captured) == 1
|
||
|
||
child = rounds.create_next_round(
|
||
round_id,
|
||
{"count": 4, "idempotency_key": "next-round-from-feedback-1"},
|
||
RequestContext.system("feedback-conversation"),
|
||
)
|
||
assert child["round"]["parent_round_id"] == round_id
|
||
assert rounds.get_round(round_id).round_record.status == "superseded"
|
||
assert child["feedback_context"]["source_text"].startswith("1、2喜欢")
|
||
assert child["feedback_context"]["feedback_summary"].startswith("喜欢 TX-01-01、TX-01-02")
|
||
assert child["feedback_context"]["strict_rejected"][0]["display_code"] == "TX-01-03"
|
||
prepared = child["round"]["metadata"]["prepared_generation"]
|
||
request = prepared["generation_request"]
|
||
liked_image_ids = [
|
||
item["candidate"]["image_id"]
|
||
for item in updated["candidates"]
|
||
if item["preference_status"] == "liked"
|
||
]
|
||
assert request["selected_draft_image_ids"] == liked_image_ids
|
||
assert request["negative_prompt_patch"] == "avoid the oversized shoulder ornament"
|
||
assert "TX-01-03" not in request["negative_prompt_patch"]
|
||
assert [
|
||
item["candidate"]["source_candidate_id"] for item in child["candidates"]
|
||
] == [updated["candidates"][0]["candidate_id"]] * 4
|
||
|
||
child_replay = rounds.create_next_round(
|
||
round_id,
|
||
{"count": 4, "idempotency_key": "next-round-from-feedback-1"},
|
||
RequestContext.system("feedback-conversation"),
|
||
)
|
||
assert child_replay["round"]["round_id"] == child["round"]["round_id"]
|
||
assert child_replay["idempotent_replay"] is True
|
||
|
||
|
||
def test_feedback_transaction_rolls_back_pool_snapshot_and_history_together(tmp_path: Path) -> None:
|
||
database, generation, rounds, _expansion = _fixture(tmp_path)
|
||
detail = _complete_round(
|
||
generation,
|
||
rounds,
|
||
count=2,
|
||
idempotency_key="round-feedback-rollback",
|
||
)
|
||
round_id = detail["round"]["round_id"]
|
||
candidate_id = detail["candidates"][0]["candidate_id"]
|
||
conn = database.connect()
|
||
try:
|
||
conn.execute(
|
||
"""
|
||
CREATE TRIGGER fail_round_feedback_history
|
||
BEFORE INSERT ON workflow_history
|
||
WHEN NEW.action = 'round_feedback_updated'
|
||
BEGIN
|
||
SELECT RAISE(ABORT, 'simulated feedback history failure');
|
||
END
|
||
"""
|
||
)
|
||
conn.commit()
|
||
finally:
|
||
conn.close()
|
||
|
||
with pytest.raises(Exception):
|
||
rounds.update_feedback(
|
||
round_id,
|
||
{
|
||
"updates": [
|
||
{"candidate_id": candidate_id, "preference_status": "liked"}
|
||
]
|
||
},
|
||
RequestContext.system("feedback-rollback"),
|
||
)
|
||
|
||
after = rounds.get_round(round_id).to_dict()
|
||
assert all(item["preference_status"] == "neutral" for item in after["candidates"])
|
||
assert after["round"]["feedback_snapshot"] == {}
|
||
|
||
|
||
def test_draft_final_selection_survives_refresh_without_adopting_image(tmp_path: Path) -> None:
|
||
_database_handle, generation, rounds, _expansion = _fixture(tmp_path)
|
||
detail = _complete_round(
|
||
generation,
|
||
rounds,
|
||
count=3,
|
||
idempotency_key="round-draft-final",
|
||
)
|
||
round_id = detail["round"]["round_id"]
|
||
chosen = detail["candidates"][1]
|
||
|
||
updated = rounds.update_feedback(
|
||
round_id,
|
||
{
|
||
"updates": [],
|
||
"draft_final_candidate_id": chosen["candidate_id"],
|
||
"idempotency_key": "draft-final-1",
|
||
},
|
||
RequestContext.system("draft-final"),
|
||
)
|
||
assert updated["round"]["feedback_snapshot"]["draft_final_candidate_id"] == chosen[
|
||
"candidate_id"
|
||
]
|
||
refreshed = rounds.get_round(round_id).to_dict()
|
||
assert refreshed["round"]["feedback_snapshot"]["draft_final_candidate_id"] == chosen[
|
||
"candidate_id"
|
||
]
|
||
assert all(item["is_final"] is False for item in refreshed["candidates"])
|
||
assert all(item["image"]["is_selected"] is False for item in refreshed["candidates"])
|
||
assert generation.workflow_service.get_node("node-round-runtime").selected_image_id is None
|
||
|
||
with pytest.raises(ApiError) as rejected:
|
||
rounds.update_feedback(
|
||
round_id,
|
||
{
|
||
"updates": [
|
||
{
|
||
"candidate_id": chosen["candidate_id"],
|
||
"preference_status": "rejected",
|
||
}
|
||
],
|
||
"draft_final_candidate_id": chosen["candidate_id"],
|
||
},
|
||
RequestContext.system("draft-final"),
|
||
)
|
||
assert rejected.value.details["reason"] == "candidate_rejected"
|
||
after = rounds.get_round(round_id).to_dict()
|
||
assert after["round"]["feedback_snapshot"]["draft_final_candidate_id"] == chosen[
|
||
"candidate_id"
|
||
]
|
||
assert after["candidates"][1]["preference_status"] == "neutral"
|
||
|
||
|
||
def test_conversational_final_is_persisted_as_draft_only(tmp_path: Path) -> None:
|
||
_database_handle, generation, rounds, _expansion = _fixture(tmp_path)
|
||
detail = _complete_round(
|
||
generation,
|
||
rounds,
|
||
count=2,
|
||
idempotency_key="round-conversation-final",
|
||
)
|
||
round_id = detail["round"]["round_id"]
|
||
chosen = detail["candidates"][1]
|
||
|
||
updated = rounds.update_feedback(
|
||
round_id,
|
||
{"feedback_text": f"{chosen['display_code']} 采用"},
|
||
RequestContext.system("conversation-final"),
|
||
)
|
||
|
||
assert updated["round"]["feedback_snapshot"]["draft_final_candidate_id"] == chosen[
|
||
"candidate_id"
|
||
]
|
||
assert updated["interpretation"]["final"]["candidate_id"] == chosen["candidate_id"]
|
||
assert all(item["is_final"] is False for item in updated["candidates"])
|
||
assert all(item["image"]["is_selected"] is False for item in updated["candidates"])
|
||
|
||
|
||
def test_failed_model_and_local_interpretation_do_not_mutate_parent_round(tmp_path: Path) -> None:
|
||
_database_handle, generation, rounds, _expansion = _fixture(tmp_path)
|
||
detail = _complete_round(
|
||
generation,
|
||
rounds,
|
||
count=2,
|
||
idempotency_key="round-feedback-no-pollution",
|
||
)
|
||
round_id = detail["round"]["round_id"]
|
||
rounds.feedback_service = WorkflowRoundFeedbackService(
|
||
structured_text_callable=lambda _payload: {"feedback": {"liked": ["TX-99-99"]}},
|
||
model_route="prompt-planning-test",
|
||
)
|
||
|
||
with pytest.raises(ApiError) as captured:
|
||
rounds.update_feedback(
|
||
round_id,
|
||
{"feedback_text": "99喜欢", "idempotency_key": "bad-feedback-1"},
|
||
RequestContext.system("feedback-no-pollution"),
|
||
)
|
||
assert captured.value.details["reason"] == "unknown_candidate_reference"
|
||
after = rounds.get_round(round_id).to_dict()
|
||
assert after["round"]["feedback_snapshot"] == {}
|
||
assert all(item["preference_status"] == "neutral" for item in after["candidates"])
|
||
|
||
|
||
def test_round_resource_owner_chain_protects_every_public_operation(tmp_path: Path) -> None:
|
||
_database_handle, _generation, rounds, _expansion = _fixture(tmp_path)
|
||
owner = RequestContext.system("round-owner")
|
||
created = rounds.create_round(
|
||
"node-round-runtime",
|
||
{"count": 2, "idempotency_key": "round-owner-chain"},
|
||
owner,
|
||
)
|
||
round_id = created["round"]["round_id"]
|
||
candidate_id = created["candidates"][0]["candidate_id"]
|
||
intruder = RequestContext.from_astrbot(
|
||
username="intruder",
|
||
user_id="intruder",
|
||
permissions={"can_write"},
|
||
)
|
||
|
||
operations = (
|
||
lambda: rounds.list_node_rounds("node-round-runtime", ctx=intruder),
|
||
lambda: rounds.get_round(round_id, intruder),
|
||
lambda: rounds.create_round(
|
||
"node-round-runtime",
|
||
{"count": 1, "idempotency_key": "round-owner-intruder"},
|
||
intruder,
|
||
),
|
||
lambda: rounds.update_feedback(
|
||
round_id,
|
||
{
|
||
"updates": [
|
||
{
|
||
"candidate_id": candidate_id,
|
||
"preference_status": "liked",
|
||
}
|
||
]
|
||
},
|
||
intruder,
|
||
),
|
||
lambda: rounds.create_next_round(round_id, {}, intruder),
|
||
lambda: rounds.confirm_candidate(
|
||
round_id,
|
||
{"candidate_id": candidate_id},
|
||
intruder,
|
||
),
|
||
)
|
||
for operation in operations:
|
||
with pytest.raises(ApiError) as captured:
|
||
operation()
|
||
assert captured.value.error_code == ErrorCode.RESOURCE_NOT_FOUND
|
||
|
||
admin = RequestContext.from_astrbot(
|
||
username="admin",
|
||
user_id="admin",
|
||
permissions={"can_manage_all_profiles"},
|
||
)
|
||
assert rounds.get_round(round_id, admin).round_record.round_id == round_id
|
||
assert rounds.list_node_rounds("node-round-runtime", ctx=admin)["total"] == 1
|
||
|
||
|
||
def test_next_round_rejects_feedback_changed_after_consistent_parent_snapshot(
|
||
tmp_path: Path,
|
||
) -> None:
|
||
_database_handle, generation, rounds, _expansion = _fixture(tmp_path)
|
||
ctx = RequestContext.system("next-round-cas")
|
||
detail = _complete_round(
|
||
generation,
|
||
rounds,
|
||
count=2,
|
||
idempotency_key="round-next-cas-parent",
|
||
)
|
||
round_id = detail["round"]["round_id"]
|
||
liked_id = detail["candidates"][0]["candidate_id"]
|
||
rounds.update_feedback(
|
||
round_id,
|
||
{
|
||
"updates": [
|
||
{"candidate_id": liked_id, "preference_status": "liked"}
|
||
]
|
||
},
|
||
ctx,
|
||
)
|
||
child_count_before = len(
|
||
[
|
||
item
|
||
for item in rounds.round_repository.list_rounds(node_id="node-round-runtime")
|
||
if item.parent_round_id == round_id
|
||
]
|
||
)
|
||
create_round = rounds.create_round
|
||
|
||
def create_after_concurrent_feedback(node_id, payload, request_ctx):
|
||
rounds.update_feedback(
|
||
round_id,
|
||
{
|
||
"updates": [
|
||
{
|
||
"candidate_id": liked_id,
|
||
"preference_status": "liked",
|
||
"reason": "newer feedback revision",
|
||
}
|
||
]
|
||
},
|
||
ctx,
|
||
)
|
||
return create_round(node_id, payload, request_ctx)
|
||
|
||
rounds.create_round = create_after_concurrent_feedback # type: ignore[method-assign]
|
||
with pytest.raises(ApiError) as captured:
|
||
rounds.create_next_round(
|
||
round_id,
|
||
{"count": 4, "idempotency_key": "round-next-cas-child"},
|
||
ctx,
|
||
)
|
||
assert captured.value.details["reason"] == "parent_feedback_changed"
|
||
assert captured.value.details["required_action"] == "refresh_parent_round_and_retry"
|
||
child_count_after = len(
|
||
[
|
||
item
|
||
for item in rounds.round_repository.list_rounds(node_id="node-round-runtime")
|
||
if item.parent_round_id == round_id
|
||
]
|
||
)
|
||
assert child_count_after == child_count_before
|
||
|
||
|
||
def test_confirm_candidate_atomically_selects_and_advances_server_derived_node(tmp_path: Path) -> None:
|
||
_database_handle, generation, rounds, _expansion = _fixture(tmp_path)
|
||
detail = _complete_round(
|
||
generation,
|
||
rounds,
|
||
count=3,
|
||
idempotency_key="round-confirm-atomic",
|
||
)
|
||
round_id = detail["round"]["round_id"]
|
||
chosen = detail["candidates"][1]
|
||
|
||
with pytest.raises(ApiError) as missing:
|
||
rounds.confirm_candidate(round_id, {}, RequestContext.system("confirm-test"))
|
||
assert missing.value.details["count"] == 0
|
||
with pytest.raises(ApiError) as multiple:
|
||
rounds.confirm_candidate(
|
||
round_id,
|
||
{"candidate_ids": [detail["candidates"][0]["candidate_id"], chosen["candidate_id"]]},
|
||
RequestContext.system("confirm-test"),
|
||
)
|
||
assert multiple.value.details["count"] == 2
|
||
with pytest.raises(ApiError) as client_next:
|
||
rounds.confirm_candidate(
|
||
round_id,
|
||
{"candidate_id": chosen["candidate_id"], "next_node_id": "client-chosen-node"},
|
||
RequestContext.system("confirm-test"),
|
||
)
|
||
assert client_next.value.details["forbidden_fields"] == ["next_node_id"]
|
||
|
||
confirmed = rounds.confirm_candidate(
|
||
round_id,
|
||
{"candidate_id": chosen["candidate_id"], "idempotency_key": "confirm-request-1"},
|
||
RequestContext.system("confirm-test"),
|
||
)
|
||
assert confirmed["round"]["status"] == "confirmed"
|
||
assert confirmed["confirmed_candidate_id"] == chosen["candidate_id"]
|
||
assert confirmed["node"]["status"] == "selected"
|
||
assert confirmed["node"]["selected_image_id"] == chosen["candidate"]["image_id"]
|
||
assert confirmed["next_node"]["node_id"] == "node-round-runtime-next"
|
||
assert confirmed["history"]["action"] == "confirm_round_candidate"
|
||
assert sum(1 for item in confirmed["candidates"] if item["is_final"]) == 1
|
||
assert next(item for item in confirmed["candidates"] if item["is_final"])["candidate_id"] == chosen[
|
||
"candidate_id"
|
||
]
|
||
assert sum(1 for item in confirmed["candidates"] if item["image"]["is_selected"]) == 1
|
||
workflow = generation.workflow_service.get_workflow("workflow-round-runtime").workflow
|
||
assert workflow.current_node_id == "node-round-runtime-next"
|
||
assert workflow.metadata["stage_inputs"]["node-round-runtime-next"]["candidate_id"] == chosen[
|
||
"candidate_id"
|
||
]
|
||
assert workflow.metadata["branch_state"]["main"]["stage_inputs"]["node-round-runtime-next"][
|
||
"image_id"
|
||
] == chosen["candidate"]["image_id"]
|
||
|
||
replay = rounds.confirm_candidate(
|
||
round_id,
|
||
{"candidate_id": chosen["candidate_id"], "idempotency_key": "confirm-request-1"},
|
||
RequestContext.system("confirm-test"),
|
||
)
|
||
assert replay["created"] is False
|
||
assert replay["idempotent_replay"] is True
|
||
with pytest.raises(ApiError) as conflicting:
|
||
rounds.confirm_candidate(
|
||
round_id,
|
||
{"candidate_id": detail["candidates"][0]["candidate_id"]},
|
||
RequestContext.system("confirm-test"),
|
||
)
|
||
assert conflicting.value.details["reason"] == "round_already_confirmed"
|
||
with pytest.raises(ApiError) as locked_feedback:
|
||
rounds.update_feedback(
|
||
round_id,
|
||
{"updates": [{"candidate_id": chosen["candidate_id"], "preference_status": "neutral"}]},
|
||
RequestContext.system("confirm-test"),
|
||
)
|
||
assert locked_feedback.value.details["required_action"] == "create_branch"
|
||
|
||
|
||
def test_legacy_round_feedback_is_read_only(tmp_path: Path) -> None:
|
||
_database_handle, _generation, rounds, _expansion = _fixture(tmp_path)
|
||
|
||
with pytest.raises(ApiError) as captured:
|
||
rounds.update_feedback(
|
||
"legacy-round-node-round-runtime",
|
||
{"updates": [{"candidate_id": "legacy-candidate", "preference_status": "liked"}]},
|
||
RequestContext.system("legacy-feedback"),
|
||
)
|
||
assert captured.value.details["reason"] == "round_read_only"
|
||
|
||
|
||
def test_confirm_transaction_rolls_back_every_write_on_history_failure(tmp_path: Path) -> None:
|
||
database, generation, rounds, _expansion = _fixture(tmp_path)
|
||
detail = _complete_round(
|
||
generation,
|
||
rounds,
|
||
count=2,
|
||
idempotency_key="round-confirm-rollback",
|
||
)
|
||
round_id = detail["round"]["round_id"]
|
||
chosen = detail["candidates"][0]
|
||
conn = database.connect()
|
||
try:
|
||
conn.execute(
|
||
"""
|
||
CREATE TRIGGER fail_round_confirmation_history
|
||
BEFORE INSERT ON workflow_history
|
||
WHEN NEW.action = 'confirm_round_candidate'
|
||
BEGIN
|
||
SELECT RAISE(ABORT, 'simulated history failure');
|
||
END
|
||
"""
|
||
)
|
||
conn.commit()
|
||
finally:
|
||
conn.close()
|
||
|
||
with pytest.raises(Exception):
|
||
rounds.confirm_candidate(
|
||
round_id,
|
||
{"candidate_id": chosen["candidate_id"]},
|
||
RequestContext.system("confirm-test"),
|
||
)
|
||
|
||
after = rounds.get_round(round_id).to_dict()
|
||
assert after["round"]["status"] == "completed"
|
||
assert all(item["is_final"] is False for item in after["candidates"])
|
||
assert all(item["image"]["is_selected"] is False for item in after["candidates"])
|
||
node = generation.workflow_service.get_node("node-round-runtime")
|
||
assert node.status == "completed"
|
||
assert node.selected_image_id is None
|
||
workflow = generation.workflow_service.get_workflow("workflow-round-runtime").workflow
|
||
assert workflow.current_node_id == "node-round-runtime"
|
||
|
||
|
||
def test_concurrent_double_confirmation_allows_only_one_final_candidate(tmp_path: Path) -> None:
|
||
_database_handle, generation, rounds, _expansion = _fixture(tmp_path)
|
||
detail = _complete_round(
|
||
generation,
|
||
rounds,
|
||
count=2,
|
||
idempotency_key="round-confirm-race",
|
||
)
|
||
round_id = detail["round"]["round_id"]
|
||
candidate_ids = [item["candidate_id"] for item in detail["candidates"]]
|
||
barrier = threading.Barrier(2)
|
||
successes: list[dict[str, Any]] = []
|
||
errors: list[Exception] = []
|
||
|
||
def confirm(candidate_id: str) -> None:
|
||
try:
|
||
barrier.wait(timeout=2)
|
||
successes.append(
|
||
rounds.confirm_candidate(
|
||
round_id,
|
||
{"candidate_id": candidate_id},
|
||
RequestContext.system("confirm-race"),
|
||
)
|
||
)
|
||
except Exception as exc:
|
||
errors.append(exc)
|
||
|
||
threads = [threading.Thread(target=confirm, args=(candidate_id,)) for candidate_id in candidate_ids]
|
||
for thread in threads:
|
||
thread.start()
|
||
for thread in threads:
|
||
thread.join(timeout=5)
|
||
|
||
assert len(successes) == 1
|
||
assert len(errors) == 1
|
||
after = rounds.get_round(round_id).to_dict()
|
||
assert after["round"]["status"] == "confirmed"
|
||
assert sum(1 for item in after["candidates"] if item["is_final"]) == 1
|
||
|
||
|
||
def test_legacy_synchronous_generate_node_remains_compatible(tmp_path: Path) -> None:
|
||
_database_handle, generation, _rounds, expansion = _fixture(tmp_path)
|
||
|
||
result = generation.generate_node(
|
||
"node-round-runtime",
|
||
{"count": 1, "idempotency_key": "legacy-sync-generation"},
|
||
RequestContext.system("legacy-sync-test"),
|
||
)
|
||
|
||
assert result["task_status"] == "succeeded"
|
||
assert result["node_status"] == "completed"
|
||
assert len(result["images"]) == 1
|
||
assert result["images"][0]["is_selected"] is False
|
||
assert generation.workflow_service.get_node("node-round-runtime").selected_image_id is None
|
||
assert expansion.calls == 1
|