astrbot_plugin_imagestudio/tests/test_workflow_service.py

620 行
25 KiB
Python

from __future__ import annotations
import shutil
import unittest
from pathlib import Path
from uuid import uuid4
from backend.dto.common import ApiError, ErrorCode
from backend.services.profile_service import ProfileService
from backend.services.workflow_service import WorkflowService
from core.audit_service import AuditService
from core.event_bus import EventBus
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
class WorkflowServiceTests(unittest.TestCase):
def setUp(self):
self.tmp_path = Path(".tmp") / f"test_workflow_service_{uuid4().hex}"
self.tmp_path.mkdir(parents=True, exist_ok=False)
db_path = self.tmp_path / "imagestudio.db"
self.database = Database(DatabaseSettings(sqlite=SqliteSettings(path=str(db_path))))
self.database.initialize()
self.audit_service = AuditService(self.database)
self.profile_repository = ProfileRepository(self.database)
self.workflow_repository = WorkflowRepository(self.database)
self.profile_service = ProfileService(
repository=self.profile_repository,
audit_service=self.audit_service,
)
self.workflow_service = WorkflowService(
workflow_repository=self.workflow_repository,
profile_repository=self.profile_repository,
audit_service=self.audit_service,
)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write"},
)
2026-07-05 09:35:49 +08:00
self.profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx)
def tearDown(self):
shutil.rmtree(self.tmp_path, ignore_errors=True)
def test_create_single_image_workflow_creates_virtual_node(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "single_image",
2026-07-05 09:35:49 +08:00
"display_name": "Single image 2026-07-04",
"mode": "quick",
},
self.ctx,
)
self.assertTrue(detail.workflow.workflow_id.startswith("workflow_"))
self.assertEqual(detail.workflow.workflow_type, "single_image")
self.assertEqual(len(detail.nodes), 1)
self.assertEqual(detail.nodes[0].node_key, "virtual_single_image")
self.assertEqual(detail.nodes[0].node_type, "virtual_single_image")
self.assertEqual(detail.workflow.current_node_id, detail.nodes[0].node_id)
conn = self.database.connect()
try:
audit = conn.execute(
"""
SELECT action, target_type
FROM audit_logs
WHERE target_id = ?
""",
(detail.workflow.workflow_id,),
).fetchone()
finally:
conn.close()
self.assertIsNotNone(audit)
self.assertEqual(audit["action"], "create_workflow")
self.assertEqual(audit["target_type"], "profile_workflow")
def test_workflow_and_initial_nodes_are_created_atomically(self):
workflow_id = "workflow_atomic_test"
duplicate_node_id = "node_atomic_duplicate"
with self.assertRaises(Exception):
self.workflow_repository.create_workflow_with_nodes(
{
"workflow_id": workflow_id,
"profile_id": self.profile.profile_id,
"workflow_type": "character_fast",
"display_name": "Atomic workflow",
"status": "draft",
"current_node_id": duplicate_node_id,
},
[
{
"node_id": duplicate_node_id,
"workflow_id": workflow_id,
"node_key": "fast_profile",
"title": "Profile",
},
{
"node_id": duplicate_node_id,
"workflow_id": workflow_id,
"node_key": "fast_candidates",
"title": "Candidates",
},
],
)
self.assertIsNone(self.workflow_repository.get_workflow(workflow_id))
self.assertEqual(self.workflow_repository.list_nodes(workflow_id), [])
def test_create_character_gradual_workflow_creates_ten_template_nodes(self):
2026-07-05 09:35:49 +08:00
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "character_gradual",
"display_name": "Character gradual",
"mode": "professional",
},
self.ctx,
)
self.assertEqual(len(detail.nodes), 10)
2026-07-05 09:35:49 +08:00
self.assertEqual(detail.nodes[0].node_key, "profile_brief")
self.assertEqual(detail.nodes[1].node_key, "prompt_plan")
self.assertEqual(detail.nodes[2].node_key, "material_bind")
2026-07-05 09:35:49 +08:00
self.assertEqual(detail.nodes[-1].node_key, "final_pack")
self.assertEqual(detail.workflow.current_node_id, detail.nodes[0].node_id)
self.assertEqual(
[node.sort_order for node in self.workflow_service.list_nodes(detail.workflow.workflow_id)],
[10, 20, 30, 40, 50, 60, 70, 80, 90, 100],
2026-07-05 09:35:49 +08:00
)
def test_material_bind_node_update_syncs_workflow_material_binding_schema(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "character_gradual",
"display_name": "Character gradual",
},
self.ctx,
)
material_bind = next(node for node in detail.nodes if node.node_key == "material_bind")
headshot = next(node for node in detail.nodes if node.node_key == "headshot")
full_body = next(node for node in detail.nodes if node.node_key == "full_body")
self.workflow_service.update_node(
material_bind.node_id,
{
"metadata": {
"material_bindings": {
"selected_material_ids": ["mat_style"],
"rules": [
{
"id": "rule_style",
"category": "风格",
"material_id": "mat_style",
"material_label": "Soft light",
"material_group": "style",
"material_prompt": "soft watercolor, clean line art",
"bind_to_stages": [
{"stage_id": "portrait-draft", "stage_title": "头像"},
{"stage_id": "body-sheet", "stage_title": "设定图"},
],
"inheritance_rule": "keep style consistent",
"reference_strength": "强",
"required": True,
"status": "ready",
},
{
"id": "rule_clothing",
"category": "服装",
"material_id": "",
"material_prompt": "",
"bind_to_stages": [{"stage_id": "halfbody-draft", "stage_title": "半身像"}],
"reference_strength": "中",
},
],
}
}
},
self.ctx,
)
workflow = self.workflow_service.get_workflow(detail.workflow.workflow_id).workflow
material_bindings = workflow.metadata["material_bindings"]
self.assertEqual(workflow.metadata["material_binding_schema_version"], "2026-07-09.material-binding-schema.v1")
self.assertEqual(material_bindings["summary"]["active_rule_count"], 1)
self.assertEqual(material_bindings["summary"]["disabled_categories"], ["服装"])
self.assertIn(headshot.node_id, material_bindings["by_node_id"])
self.assertIn(full_body.node_id, material_bindings["by_node_id"])
self.assertEqual(
material_bindings["by_node_id"][headshot.node_id]["generation_params"]["reference_material_ids"],
["mat_style"],
)
def test_prompt_plan_node_update_syncs_workflow_prompt_plan_schema(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "character_gradual",
"display_name": "Character gradual",
},
self.ctx,
)
prompt_plan = next(node for node in detail.nodes if node.node_key == "prompt_plan")
headshot = next(node for node in detail.nodes if node.node_key == "headshot")
full_body = next(node for node in detail.nodes if node.node_key == "full_body")
self.workflow_service.update_node(
prompt_plan.node_id,
{
"metadata": {
"prompt_plan": {
"items": [
{
"id": "portrait",
"title": "头像节点",
"prompt": "Nova, face reference, clear eyes",
"negative": "low quality, blurry",
"weight": "face identity 1.25",
"weightBasis": "lock identity first",
"inherits": ["name", "hair", "eyes"],
"status": "ready",
},
{
"id": "fullbody",
"title": "全身节点",
"prompt": "Nova, full body standing pose",
"negative": "bad anatomy",
"conflicts": ["shoe details need review"],
"status": "review",
},
],
"guard_checks": [
{"label": "负面提示词", "value": "low quality, blurry", "status": "ready"}
],
}
}
},
self.ctx,
)
workflow = self.workflow_service.get_workflow(detail.workflow.workflow_id).workflow
plan = workflow.metadata["prompt_plan"]
self.assertEqual(workflow.metadata["prompt_plan_schema_version"], "2026-07-09.prompt-plan-schema.v1")
self.assertEqual(plan["summary"]["target_count"], 2)
self.assertEqual(plan["summary"]["review_count"], 1)
self.assertIn(headshot.node_id, plan["by_node_id"])
self.assertIn(full_body.node_id, plan["by_node_id"])
self.assertEqual(plan["by_node_id"][headshot.node_id]["generation_params"]["prompt_patch"], "Nova, face reference, clear eyes")
2026-07-05 09:35:49 +08:00
def test_create_fast_character_workflow_creates_fast_template_nodes(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "character_fast",
"display_name": "Fast character",
},
self.ctx,
)
self.assertEqual([node.node_key for node in detail.nodes], ["fast_profile", "fast_candidates", "fast_final"])
self.assertEqual(detail.workflow.current_node_id, detail.nodes[0].node_id)
def test_create_quick_profile_workflow_creates_profile_draft_nodes(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "quick_profile",
"display_name": "Quick profile",
},
self.ctx,
)
self.assertEqual([node.node_key for node in detail.nodes], ["questionnaire", "preview"])
self.assertEqual(detail.nodes[0].node_type, "profile_draft")
2026-07-05 09:43:16 +08:00
def test_create_branch_copies_nodes_and_switches_current_branch(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "character_fast",
"display_name": "Fast character",
},
self.ctx,
)
branch = self.workflow_service.create_branch(
detail.workflow.workflow_id,
{"branch_name": "alt_pose", "copy_nodes": True},
self.ctx,
)
self.assertEqual(branch.branch_name, "alt_pose")
copied_nodes = self.workflow_repository.list_nodes(detail.workflow.workflow_id, branch_name="alt_pose")
self.assertEqual(len(copied_nodes), 3)
self.assertEqual([node.node_key for node in copied_nodes], ["fast_profile", "fast_candidates", "fast_final"])
self.assertTrue(copied_nodes[0].metadata["copied_from_node_id"].startswith("node_"))
switched = self.workflow_service.switch_branch(detail.workflow.workflow_id, "alt_pose", self.ctx)
self.assertEqual(switched.current_branch, "alt_pose")
self.assertEqual(switched.current_node_id, copied_nodes[0].node_id)
branches = self.workflow_service.list_branches(detail.workflow.workflow_id)
self.assertEqual([item.branch_name for item in branches], ["alt_pose"])
def test_create_branch_from_base_node_preserves_ancestors_and_resets_cut(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "character_fast",
"display_name": "Fast character",
},
self.ctx,
)
nodes = self.workflow_service.list_nodes(detail.workflow.workflow_id)
first, second, third = nodes
self.workflow_service.update_node(
first.node_id,
{"status": "completed", "selected_image_id": "img_first"},
self.ctx,
)
self.workflow_service.update_node(
second.node_id,
{"status": "completed", "selected_image_id": "img_second"},
self.ctx,
)
self.workflow_service.create_branch(
detail.workflow.workflow_id,
{
"branch_name": "change_candidates",
"base_node_id": second.node_id,
"copy_nodes": True,
},
self.ctx,
)
copied_nodes = self.workflow_repository.list_nodes(
detail.workflow.workflow_id,
branch_name="change_candidates",
)
copied_first, copied_second, copied_third = copied_nodes
self.assertEqual(copied_first.status, "completed")
self.assertEqual(copied_first.selected_image_id, "img_first")
self.assertTrue(copied_first.metadata["branch_locked_ancestor"])
self.assertEqual(copied_second.status, "draft")
self.assertIsNone(copied_second.selected_image_id)
self.assertTrue(copied_second.metadata["branch_editable_from_cut"])
self.assertEqual(copied_second.metadata["copied_from_node_id"], second.node_id)
self.assertEqual(copied_third.status, "draft")
self.assertIsNone(copied_third.selected_image_id)
self.assertEqual(copied_third.metadata["copied_from_node_id"], third.node_id)
def test_create_branch_rejects_unknown_base_node_without_persisting_branch(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "character_fast",
"display_name": "Fast character",
},
self.ctx,
)
with self.assertRaises(ApiError) as raised:
self.workflow_service.create_branch(
detail.workflow.workflow_id,
{
"branch_name": "bad_cut",
"base_node_id": "node_missing",
"copy_nodes": True,
},
self.ctx,
)
self.assertEqual(raised.exception.error_code, ErrorCode.VALIDATION_FAILED)
branch_names = [
branch.branch_name
for branch in self.workflow_service.list_branches(detail.workflow.workflow_id)
]
self.assertNotIn("bad_cut", branch_names)
def test_create_and_list_nodes_ordered_by_sort_order(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "character_gradual",
2026-07-05 09:35:49 +08:00
"display_name": "Manual character flow",
"mode": "standard",
2026-07-05 09:35:49 +08:00
"auto_create_nodes": False,
},
self.ctx,
)
second = self.workflow_service.create_node(
detail.workflow.workflow_id,
2026-07-05 09:35:49 +08:00
{"node_key": "full_body", "title": "Full body", "sort_order": 20},
self.ctx,
)
first = self.workflow_service.create_node(
detail.workflow.workflow_id,
2026-07-05 09:35:49 +08:00
{"node_key": "portrait", "title": "Portrait", "sort_order": 10},
self.ctx,
)
nodes = self.workflow_service.list_nodes(detail.workflow.workflow_id)
self.assertEqual([node.node_id for node in nodes], [first.node_id, second.node_id])
def test_update_node_changes_status_and_writes_audit(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "character_gradual",
2026-07-05 09:35:49 +08:00
"display_name": "Manual character flow",
"auto_create_nodes": False,
},
self.ctx,
)
node = self.workflow_service.create_node(
detail.workflow.workflow_id,
2026-07-05 09:35:49 +08:00
{"node_key": "portrait", "title": "Portrait"},
self.ctx,
)
updated = self.workflow_service.update_node(
node.node_id,
{
"status": "completed",
"prompt": "portrait, silver hair",
},
self.ctx,
)
self.assertEqual(updated.status, "completed")
self.assertEqual(updated.prompt, "portrait, silver hair")
conn = self.database.connect()
try:
count = conn.execute(
"""
SELECT COUNT(*) AS total
FROM audit_logs
WHERE target_id = ? AND action = 'update_node'
""",
(node.node_id,),
).fetchone()["total"]
finally:
conn.close()
self.assertEqual(count, 1)
def test_completed_node_rejects_mutating_update_until_branch_is_created(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "character_gradual",
"display_name": "Manual character flow",
"auto_create_nodes": False,
},
self.ctx,
)
node = self.workflow_service.create_node(
detail.workflow.workflow_id,
{"node_key": "portrait", "title": "Portrait"},
self.ctx,
)
completed = self.workflow_service.update_node(
node.node_id,
{"status": "completed", "prompt": "portrait, silver hair"},
self.ctx,
)
with self.assertRaises(ApiError) as raised:
self.workflow_service.update_node(
node.node_id,
{"prompt": "portrait, black hair"},
self.ctx,
)
self.assertEqual(raised.exception.error_code, ErrorCode.VALIDATION_FAILED)
self.assertEqual(raised.exception.details["suggested_action"], "create_branch")
self.assertEqual(raised.exception.details["base_node_id"], completed.node_id)
def test_workflow_service_publishes_status_events(self):
event_bus = EventBus()
workflow_service = WorkflowService(
workflow_repository=self.workflow_repository,
profile_repository=self.profile_repository,
audit_service=self.audit_service,
event_bus=event_bus,
)
detail = workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "single_image", "display_name": "Evented"},
self.ctx,
)
workflow_service.update_workflow(detail.workflow.workflow_id, {"status": "running"}, self.ctx)
workflow_service.update_node(detail.nodes[0].node_id, {"status": "queued"}, self.ctx)
self.assertEqual(event_bus.history("workflow.created")[0].payload["workflow_id"], detail.workflow.workflow_id)
self.assertEqual(event_bus.history("workflow.status_changed")[0].payload["after_status"], "running")
self.assertEqual(event_bus.history("workflow.node_status_changed")[0].payload["after_status"], "queued")
def test_invalid_workflow_status_transition_is_rejected(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "single_image", "display_name": "Archived"},
self.ctx,
)
self.workflow_service.update_workflow(detail.workflow.workflow_id, {"status": "archived"}, self.ctx)
with self.assertRaises(ApiError) as raised:
self.workflow_service.update_workflow(detail.workflow.workflow_id, {"status": "running"}, self.ctx)
self.assertEqual(raised.exception.error_code, ErrorCode.VALIDATION_FAILED)
def test_invalid_initial_workflow_status_is_rejected_without_persisting(self):
with self.assertRaises(ApiError) as raised:
self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "single_image",
"display_name": "Invalid initial status",
"status": "nonsense",
},
self.ctx,
)
self.assertEqual(raised.exception.error_code, ErrorCode.VALIDATION_FAILED)
self.assertEqual(raised.exception.details["field"], "status")
self.assertEqual(self.workflow_service.list_workflows(self.profile.profile_id), [])
with self.assertRaises(ApiError) as non_string_raised:
self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "single_image",
"display_name": "Invalid status type",
"status": ["draft"],
},
self.ctx,
)
self.assertEqual(non_string_raised.exception.error_code, ErrorCode.VALIDATION_FAILED)
def test_invalid_workflow_type_is_rejected(self):
with self.assertRaises(ApiError) as raised:
self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "unknown",
2026-07-05 09:35:49 +08:00
"display_name": "Bad workflow",
},
self.ctx,
)
self.assertEqual(raised.exception.error_code, ErrorCode.VALIDATION_FAILED)
def test_invalid_node_status_is_rejected(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "character_gradual",
2026-07-05 09:35:49 +08:00
"display_name": "Manual character flow",
"auto_create_nodes": False,
},
self.ctx,
)
with self.assertRaises(ApiError) as raised:
self.workflow_service.create_node(
detail.workflow.workflow_id,
{
"node_key": "portrait",
2026-07-05 09:35:49 +08:00
"title": "Portrait",
"status": "mystery",
},
self.ctx,
)
self.assertEqual(raised.exception.error_code, ErrorCode.VALIDATION_FAILED)
def test_node_cancelled_status_matches_fsm_and_can_be_requeued(self):
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{"workflow_type": "single_image", "display_name": "Cancelable node"},
self.ctx,
)
node = detail.nodes[0]
self.workflow_service.update_node(node.node_id, {"status": "queued"}, self.ctx)
cancelled = self.workflow_service.update_node(node.node_id, {"status": "cancelled"}, self.ctx)
requeued = self.workflow_service.update_node(node.node_id, {"status": "queued"}, self.ctx)
self.assertEqual(cancelled.status, "cancelled")
self.assertEqual(requeued.status, "queued")
def test_missing_profile_is_rejected(self):
with self.assertRaises(ApiError) as raised:
self.workflow_service.create_workflow(
"profile_missing",
{
"workflow_type": "single_image",
2026-07-05 09:35:49 +08:00
"display_name": "Orphan workflow",
},
self.ctx,
)
self.assertEqual(raised.exception.error_code, ErrorCode.RESOURCE_NOT_FOUND)
if __name__ == "__main__":
unittest.main()