astrbot_plugin_imagestudio/tests/test_quick_character_consistency.py

356 行
13 KiB
Python

from dataclasses import replace
from types import SimpleNamespace
import pytest
from backend.dto.common import ApiError
from backend.dto.profile_dto import CharacterProfile
from backend.dto.workflow_dto import ProfileWorkflow, WorkflowDetail, WorkflowNode
from backend.services.generation_service import (
GenerationService,
_assignment_key,
_inject_identity_lock_into_prompt_payload,
_locked_quick_character_prompt_expansion,
)
from backend.services.quick_character_consistency import (
append_identity_lock,
build_identity_lock,
consistency_metadata,
identity_lock_hash,
safe_route_snapshot,
)
from backend.services.workflow_service import WorkflowService
from core.identity import RequestContext
def _profile() -> CharacterProfile:
return CharacterProfile(
profile_id="profile-1",
name="港区巡查员",
description="负责夜间巡逻的角色",
base_prompt="港区巡查员, 冷静可靠",
appearance_prompt="black short hair, teal eyes",
style_prompt="character illustration",
negative_prompt="low quality",
default_model_route=None,
owner_platform="webui",
owner_context_id=None,
owner_user_id="system",
owner_session_key=None,
avatar_image_uri=None,
status="active",
metadata={
"identity": "负责夜间巡逻的成年男性",
"hair_color": "black",
"hairstyle": "short hair",
"eye_color": "teal",
},
created_at="2026-07-15T00:00:00Z",
updated_at="2026-07-15T00:00:00Z",
)
def _workflow(metadata: dict | None = None) -> ProfileWorkflow:
return ProfileWorkflow(
workflow_id="workflow-1",
profile_id="profile-1",
workflow_type="character_fast",
display_name="港区巡查员 快速角色",
mode=None,
status="running",
current_node_id="node-avatar",
current_branch="main",
session_key=None,
metadata=metadata or {},
created_at="2026-07-15T00:00:00Z",
updated_at="2026-07-15T00:00:00Z",
)
def _node(node_key: str) -> WorkflowNode:
return WorkflowNode(
node_id=f"node-{node_key}",
workflow_id="workflow-1",
node_key=node_key,
title=node_key,
description=None,
step_name=node_key,
node_type="generation",
status="draft",
branch_name="main",
prompt=None,
negative_prompt=None,
model_route="legacy-per-node-route",
selected_image_id=None,
sort_order=10,
metadata={},
created_at="2026-07-15T00:00:00Z",
updated_at="2026-07-15T00:00:00Z",
)
class _ProfileRepository:
def __init__(self, profile: CharacterProfile):
self.profile = profile
def get(self, _profile_id: str) -> CharacterProfile:
return self.profile
class _WorkflowService:
def __init__(self, profile: CharacterProfile):
self.workflow = _workflow()
self.nodes = {key: _node(key) for key in ("quick_avatar", "quick_bust", "quick_stand", "quick_sheet")}
self.profile_repository = _ProfileRepository(profile)
def get_workflow(self, _workflow_id: str) -> WorkflowDetail:
return WorkflowDetail(self.workflow, list(self.nodes.values()))
def update_workflow(self, _workflow_id: str, payload: dict, _ctx: RequestContext) -> ProfileWorkflow:
self.workflow = replace(self.workflow, **payload)
return self.workflow
def get_node(self, node_id: str) -> WorkflowNode:
return next(node for node in self.nodes.values() if node.node_id == node_id)
class _ModelProviderService:
def resolve_route(self, route_name: str, *, modality: str) -> dict:
return {
"route_name": route_name,
"route_id": f"route-{route_name}",
"provider_id": "provider-1",
"model_id": "image-model-1",
"modality": modality,
"priority": 10,
"settings": {"api_key": "must-not-be-snapshotted", "timeout_seconds": 180},
"provider": {
"provider_type": "openai_compatible",
"capabilities": {"reference_images": True},
},
}
class _ImageService:
def __init__(self):
self.images: dict[str, object] = {}
def get_image(self, image_id: str):
return self.images[image_id]
def _generation_service() -> tuple[GenerationService, _WorkflowService, _ImageService]:
workflow_service = _WorkflowService(_profile())
image_service = _ImageService()
service = GenerationService(
workflow_service=workflow_service,
queue_service=SimpleNamespace(),
image_service=image_service,
model_provider_service=_ModelProviderService(),
model_assignments={"quick_generation": "quick-route"},
)
return service, workflow_service, image_service
def test_identity_lock_normalizes_request_fields_and_age_stage() -> None:
lock = build_identity_lock(
_profile(),
{
"metadata": {
"identity_fields": {
"gender_presentation": "男",
"age_stage": "成年",
"species": "human",
"height_build": "tall athletic build",
"body_features": "scar on left hand",
}
}
},
)
assert lock["fields"]["gender_presentation"] == "male/masculine"
assert lock["fields"]["age_group"] == "adult"
assert lock["fields"]["species"] == "human"
assert "scar on left hand" in lock["prompt"]
assert len(identity_lock_hash(lock)) == 64
def test_direct_prompt_cannot_bypass_identity_lock_and_append_is_idempotent() -> None:
lock = build_identity_lock(_profile(), {"identity_fields": {"gender": "male", "age_stage": "adult"}})
lock_hash = identity_lock_hash(lock)
context = {"identity_lock": lock, "identity_lock_hash": lock_hash, "batch_id": "qcb-test"}
governed_payload = _inject_identity_lock_into_prompt_payload(
{"prompt_patch": "direct user prompt", "prompt_processing_mode": "direct"},
lock,
_node("quick_avatar"),
)
expanded = _locked_quick_character_prompt_expansion(
prompt_expansion={"prompt": "direct user prompt", "negative_prompt": "bad anatomy"},
payload=governed_payload,
node=_node("quick_avatar"),
quick_context=context,
)
assert lock["prompt"] in expanded["prompt"]
assert lock["prompt"] in governed_payload["prompt_patch"]
assert expanded["identity_lock_hash"] == lock_hash
assert expanded["quick_character_batch_id"] == "qcb-test"
assert append_identity_lock(expanded["prompt"], lock) == expanded["prompt"]
def test_all_quick_targets_use_quick_generation_assignment() -> None:
assert {
_assignment_key(_node(node_key))
for node_key in ("quick_avatar", "quick_bust", "quick_stand", "quick_sheet")
} == {"quick_generation"}
def test_first_quick_node_freezes_batch_identity_and_route_for_later_nodes() -> None:
service, workflow_service, _ = _generation_service()
ctx = RequestContext.system("test")
avatar_context = service._prepare_quick_character_context(
workflow=workflow_service.workflow,
profile=_profile(),
node=workflow_service.nodes["quick_avatar"],
payload={
"batch_id": "qcb-client-batch",
"metadata": {"identity_fields": {"gender": "male", "age_stage": "adult"}},
},
requested_route="quick-route",
ctx=ctx,
)
bust_context = service._prepare_quick_character_context(
workflow=workflow_service.workflow,
profile=_profile(),
node=workflow_service.nodes["quick_bust"],
payload={"model_route": "attempted-other-route"},
requested_route="attempted-other-route",
ctx=ctx,
)
assert bust_context["batch_id"] == avatar_context["batch_id"]
assert avatar_context["batch_id"] == "qcb-client-batch"
assert bust_context["identity_lock_hash"] == avatar_context["identity_lock_hash"]
assert bust_context["requested_route"] == "quick-route"
metadata = workflow_service.workflow.metadata
assert metadata["quick_character_identity_managed"] == "generation_service_v1"
assert metadata["quick_character_batch_id"] == avatar_context["batch_id"]
assert metadata["identity_lock_hash"] == avatar_context["identity_lock_hash"]
assert metadata["quick_character_route_snapshot"]["requested_route"] == "quick-route"
assert "api_key" not in metadata["quick_character_route_snapshot"]
def test_workflow_metadata_normalization_preserves_server_owned_quick_lock() -> None:
current = _workflow(
{
"quick_character_identity_managed": "generation_service_v1",
"quick_character_batch_id": "qcb-server",
"identity_lock_hash": "hash-server",
"identity_lock": {"schema_version": "v1", "fields": {}, "prompt": "locked"},
"quick_character_route_snapshot": {"requested_route": "quick-route"},
"quick_character_target": "all",
}
)
service = object.__new__(WorkflowService)
normalized = service._normalize_workflow_metadata(current, {"client_field": "keep"})
assert normalized["client_field"] == "keep"
assert normalized["quick_character_batch_id"] == "qcb-server"
assert normalized["identity_lock_hash"] == "hash-server"
assert normalized["quick_character_route_snapshot"] == {"requested_route": "quick-route"}
def test_downstream_avatar_reference_requires_same_batch_and_identity_hash() -> None:
service, workflow_service, image_service = _generation_service()
context = service._prepare_quick_character_context(
workflow=workflow_service.workflow,
profile=_profile(),
node=workflow_service.nodes["quick_avatar"],
payload={"identity_fields": {"gender": "male", "age_stage": "adult"}},
requested_route="quick-route",
ctx=RequestContext.system("test"),
)
image_service.images["img-avatar"] = SimpleNamespace(
image_id="img-avatar",
workflow_id="workflow-1",
profile_id="profile-1",
node_id=workflow_service.nodes["quick_avatar"].node_id,
batch_id=context["batch_id"],
metadata={"identity_lock_hash": context["identity_lock_hash"]},
)
service._validate_quick_character_references(
workflow=workflow_service.workflow,
node=workflow_service.nodes["quick_bust"],
payload={"input_images": ["img-avatar"]},
quick_context=context,
)
image_service.images["img-wrong-batch"] = SimpleNamespace(
image_id="img-wrong-batch",
workflow_id="workflow-1",
profile_id="profile-1",
node_id=workflow_service.nodes["quick_avatar"].node_id,
batch_id="qcb-other",
metadata={"identity_lock_hash": "other-hash"},
)
with pytest.raises(ApiError, match="another identity batch"):
service._validate_quick_character_references(
workflow=workflow_service.workflow,
node=workflow_service.nodes["quick_stand"],
payload={"input_images": ["img-wrong-batch"]},
quick_context=context,
)
with pytest.raises(ApiError, match="generation image_id"):
service._validate_quick_character_references(
workflow=workflow_service.workflow,
node=workflow_service.nodes["quick_sheet"],
payload={"input_images": ["storage://images/avatar.png"]},
quick_context=context,
)
def test_route_snapshot_excludes_sensitive_settings() -> None:
snapshot = safe_route_snapshot(
"quick-route",
{
"route_name": "quick-route",
"route_id": "route-1",
"provider_id": "provider-1",
"model_id": "model-1",
"modality": "image_generation",
"settings": {"api_key": "secret", "Authorization": "Bearer secret"},
},
)
assert snapshot == {
"requested_route": "quick-route",
"route_name": "quick-route",
"route_id": "route-1",
"status": "unresolved",
"provider_id": "provider-1",
"provider_type": "",
"model_id": "model-1",
"modality": "image_generation",
}
assert "secret" not in repr(snapshot)
def test_consistency_metadata_contains_batch_hash_target_lock_and_route_snapshot() -> None:
lock = build_identity_lock(_profile(), {})
metadata = consistency_metadata(
batch_id="qcb-1",
lock_hash=identity_lock_hash(lock),
identity_lock=lock,
target="quick_avatar",
route_snapshot={"requested_route": "quick-route"},
)
assert metadata["quick_character_batch_id"] == "qcb-1"
assert metadata["quick_character_target"] == "quick_avatar"
assert metadata["identity_lock"] == lock
assert metadata["quick_character_route_snapshot"] == {"requested_route": "quick-route"}