from __future__ import annotations import base64 import shutil import threading import unittest from concurrent.futures import ThreadPoolExecutor from pathlib import Path from unittest.mock import patch from uuid import uuid4 from backend.routes.node_routes import generate_node, retry_node from backend.routes.workflow_routes import cancel_workflow from backend.dto.common import ApiError, ErrorCode from backend.dto.job_dto import GenerationTask from backend.dto.workflow_dto import WorkflowNode from backend.services.cost_guard_service import CostGuardService from backend.services.cost_service import CostService from backend.services.character_workflow_service import CharacterWorkflowService from backend.services.generation_service import GenerationService from backend.services.image_service import ImageService from backend.services.model_provider_service import ModelProviderService from backend.services.prompt_expansion_service import PromptExpansionService from backend.services.profile_service import ProfileService from backend.services.queue_service import QueueService from backend.services.workflow_service import WorkflowService from core.audit_service import AuditService from core.config_service import ConfigService from core.event_bus import EventBus from core.identity import RequestContext from core.media_proxy import MediaProxy from core.storage import VfsStorage 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.model_provider_repository import ModelProviderRepository from database.repositories.profile_repository import ProfileRepository from database.repositories.workflow_repository import WorkflowRepository from engines.single_flow import SingleFlowEngine from engines.image_provider import GeneratedImagePayload, ImageGenerationResult, ImageProviderError PNG_BYTES = base64.b64decode( "iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII=" ) class CapturingProvider: provider_id = "site_b" def __init__(self): self.requests = [] def generate_image(self, request): self.requests.append(request) return ImageGenerationResult( provider_id=self.provider_id, model=request.model or "image2", images=[ GeneratedImagePayload( b64_json=base64.b64encode(PNG_BYTES).decode("ascii"), revised_prompt=request.prompt, ) ], ) class SingleFlowGenerationTests(unittest.TestCase): def setUp(self): self.root = Path(".tmp") / f"test_single_flow_generation_{uuid4().hex}" self.root.mkdir(parents=True, exist_ok=False) self.config_path = self.root / "config.yaml" self.config_path.write_text( f""" plugin: name: astrbot_plugin_imagestudio storage: images_path: "{(self.root / "images").as_posix()}" thumbnails_path: "{(self.root / "thumbnails").as_posix()}" materials_path: "{(self.root / "materials").as_posix()}" styles_path: "{(self.root / "styles").as_posix()}" archives_path: "{(self.root / "archives").as_posix()}" temp_path: "{(self.root / "temp").as_posix()}" """, encoding="utf-8", ) for folder in ("images", "thumbnails", "materials", "styles", "archives", "temp"): (self.root / folder).mkdir(parents=True, exist_ok=True) self.database = Database( DatabaseSettings(sqlite=SqliteSettings(path=str(self.root / "imagestudio.db"))) ) self.database.initialize() self.audit_service = AuditService(self.database) self.profile_repository = ProfileRepository(self.database) self.workflow_repository = WorkflowRepository(self.database) self.image_repository = ImageRepository(self.database) self.job_repository = JobRepository(self.database) self.material_repository = MaterialRepository(self.database) self.model_provider_service = ModelProviderService(ModelProviderRepository(self.database)) self.profile_service = ProfileService(self.profile_repository, self.audit_service) self.workflow_service = WorkflowService( self.workflow_repository, self.profile_repository, self.audit_service, ) self.image_service = ImageService( self.image_repository, self.workflow_repository, self.audit_service, ) self.queue_service = QueueService(self.job_repository, self.audit_service) self.event_bus = EventBus() self.config_service = ConfigService(self.config_path) self.generation_service = GenerationService( workflow_service=self.workflow_service, queue_service=self.queue_service, image_service=self.image_service, single_flow_engine=SingleFlowEngine(VfsStorage(self.config_service), allow_mock_fallback=True), model_provider_service=self.model_provider_service, event_bus=self.event_bus, ) self.ctx = RequestContext.from_astrbot( username="admin", user_id="user_001", permissions={"can_write", "can_retry_tasks"}, ) def tearDown(self): shutil.rmtree(self.root, ignore_errors=True) def _provider_generation_service( self, provider: CapturingProvider, *, expand_prompts: bool = False, material_resolver=None, ) -> GenerationService: self.model_provider_service.upsert_provider( { "provider_id": provider.provider_id, "base_url": "https://botcf.com", "image_endpoint": "/v1/images/generations", } ) self.model_provider_service.upsert_route( { "route_name": "image_high", "provider_id": provider.provider_id, "model_id": "image2", "priority": 5, } ) return GenerationService( workflow_service=self.workflow_service, queue_service=self.queue_service, image_service=self.image_service, single_flow_engine=SingleFlowEngine( VfsStorage(self.config_service), image_provider_factory=lambda route: provider, ), model_provider_service=self.model_provider_service, prompt_expansion_service=PromptExpansionService() if expand_prompts else None, event_bus=self.event_bus, require_resolved_model_route=True, material_resolver=material_resolver, ) def _write_storage_image(self, uri: str, body: bytes) -> None: path = VfsStorage(self.config_service).resolve_uri(uri) path.parent.mkdir(parents=True, exist_ok=True) path.write_bytes(body) def test_generate_node_creates_task_images_and_vfs_files(self): profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) workflow = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Single"}, self.ctx, ) node_id = workflow.nodes[0].node_id response = generate_node( self.ctx, node_id, {"prompt_patch": "white shirt", "count": 2, "aspect_ratio": "3:4", "model_route": "image_low"}, generation_service=self.generation_service, ) self.assertTrue(response["ok"]) data = response["data"] self.assertTrue(data["task_id"].startswith("task_")) self.assertEqual(data["task_status"], "succeeded") self.assertEqual(data["node_status"], "completed") self.assertEqual(len(data["images"]), 2) self.assertTrue(data["images"][0]["is_selected"]) self.assertFalse(data["images"][1]["is_selected"]) self.assertEqual(data["images"][0]["width"], 768) self.assertEqual(data["images"][0]["height"], 1024) task = self.queue_service.get_job(data["task_id"]) self.assertEqual(task.status, "succeeded") self.assertEqual(task.result["image_ids"], [image["image_id"] for image in data["images"]]) node = self.workflow_service.get_node(node_id) self.assertEqual(node.status, "completed") self.assertEqual(node.selected_image_id, data["images"][0]["image_id"]) for image in data["images"]: self.assertTrue(VfsStorage(self.config_service).ensure_file(image["image_uri"]).exists()) self.assertTrue(VfsStorage(self.config_service).ensure_file(image["thumbnail_uri"]).exists()) self.assertEqual(self.event_bus.history("generation.node_queued")[0].payload["task_id"], data["task_id"]) self.assertEqual(self.event_bus.history("generation.node_completed")[0].payload["image_ids"][0], data["images"][0]["image_id"]) def test_generate_node_replays_existing_idempotent_task(self): profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) workflow = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Single"}, self.ctx, ) node_id = workflow.nodes[0].node_id payload = { "prompt_patch": "white shirt", "count": 2, "model_route": "image_low", "idempotency_key": "node-generate-001", } first = generate_node(self.ctx, node_id, payload, generation_service=self.generation_service) second = generate_node(self.ctx, node_id, payload, generation_service=self.generation_service) self.assertTrue(first["ok"]) self.assertTrue(second["ok"]) self.assertEqual(first["data"]["task_id"], second["data"]["task_id"]) self.assertTrue(second["data"]["idempotent_replay"]) self.assertEqual( [image["image_id"] for image in first["data"]["images"]], [image["image_id"] for image in second["data"]["images"]], ) self.assertEqual(self.queue_service.list_jobs(page=1, page_size=10).total, 1) self.assertEqual(len(self.image_service.list_by_node(node_id)), 2) self.assertEqual(len(self.event_bus.history("generation.node_queued")), 1) def test_virtual_single_image_node_allows_consecutive_generation_requests(self): profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) workflow = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Single"}, self.ctx, ) node_id = workflow.nodes[0].node_id first = generate_node( self.ctx, node_id, {"prompt_patch": "white shirt", "idempotency_key": "node-generate-lock-001"}, generation_service=self.generation_service, ) second = generate_node( self.ctx, node_id, {"prompt_patch": "black shirt", "idempotency_key": "node-generate-lock-002"}, generation_service=self.generation_service, ) self.assertTrue(first["ok"]) self.assertTrue(second["ok"]) self.assertNotEqual(first["data"]["task_id"], second["data"]["task_id"]) self.assertEqual(self.queue_service.list_jobs(page=1, page_size=10).total, 2) self.assertEqual(len(self.image_service.list_by_node(node_id)), 2) def test_virtual_single_image_serializes_concurrent_generation_requests(self): class BlockingProvider(CapturingProvider): def __init__(self): super().__init__() self.first_entered = threading.Event() self.second_entered = threading.Event() self.release_first = threading.Event() def generate_image(self, request): self.requests.append(request) if len(self.requests) == 1: self.first_entered.set() self.release_first.wait(timeout=2) else: self.second_entered.set() return ImageGenerationResult( provider_id=self.provider_id, model=request.model or "image2", images=[ GeneratedImagePayload( b64_json=base64.b64encode(PNG_BYTES).decode("ascii"), revised_prompt=request.prompt, ) ], ) provider = BlockingProvider() generation_service = self._provider_generation_service(provider) profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) workflow = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Single"}, self.ctx, ) node_id = workflow.nodes[0].node_id with ThreadPoolExecutor(max_workers=2) as executor: first = executor.submit( generate_node, self.ctx, node_id, {"model_route": "image_high", "idempotency_key": "concurrent-1"}, generation_service=generation_service, ) self.assertTrue(provider.first_entered.wait(timeout=2)) second = executor.submit( generate_node, self.ctx, node_id, {"model_route": "image_high", "idempotency_key": "concurrent-2"}, generation_service=generation_service, ) self.assertFalse(provider.second_entered.wait(timeout=0.1)) provider.release_first.set() results = [first.result(timeout=3), second.result(timeout=3)] self.assertTrue(all(result["ok"] for result in results)) self.assertEqual(len(provider.requests), 2) self.assertEqual(self.queue_service.list_jobs(page=1, page_size=10).total, 2) self.assertEqual(len(self.image_service.list_by_node(node_id)), 2) def test_cancel_during_provider_execution_rolls_back_generated_outputs(self): class BlockingProvider(CapturingProvider): def __init__(self): super().__init__() self.entered = threading.Event() self.release = threading.Event() def generate_image(self, request): self.requests.append(request) self.entered.set() self.release.wait(timeout=3) return ImageGenerationResult( provider_id=self.provider_id, model=request.model or "image2", images=[ GeneratedImagePayload( b64_json=base64.b64encode(PNG_BYTES).decode("ascii"), revised_prompt=request.prompt, ) ], ) provider = BlockingProvider() generation_service = self._provider_generation_service(provider) profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) detail = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Cancelable"}, self.ctx, ) node_id = detail.nodes[0].node_id with ThreadPoolExecutor(max_workers=1) as executor: future = executor.submit( generate_node, self.ctx, node_id, {"model_route": "image_high", "idempotency_key": "cancel-provider-run"}, generation_service=generation_service, ) self.assertTrue(provider.entered.wait(timeout=2)) running_jobs = self.queue_service.list_jobs(status="running", page=1, page_size=10).items self.assertEqual(len(running_jobs), 1) cancelled = self.queue_service.cancel_job( running_jobs[0].task_id, self.ctx, reason="user cancelled during provider execution", ) self.assertEqual(cancelled.status, "cancelled") self.assertFalse(future.done()) provider.release.set() response = future.result(timeout=3) self.assertTrue(response["ok"]) self.assertTrue(response["data"]["cancelled"]) self.assertEqual(response["data"]["task_status"], "cancelled") self.assertEqual(response["data"]["node_status"], "cancelled") self.assertEqual(response["data"]["images"], []) final_task = self.queue_service.get_job(cancelled.task_id) final_node = self.workflow_service.get_node(node_id) self.assertEqual(final_task.status, "cancelled") self.assertEqual(final_task.result, {}) self.assertEqual(final_node.status, "cancelled") self.assertEqual(self.image_service.list_by_node(node_id), []) self.assertEqual([path for path in (self.root / "images").rglob("*") if path.is_file()], []) self.assertEqual([path for path in (self.root / "thumbnails").rglob("*") if path.is_file()], []) cleanup = final_node.metadata["generation_cancellation"]["cleanup"] self.assertEqual(len(cleanup["files_removed"]), 2) self.assertEqual(cleanup["errors"], []) def test_cancel_workflow_cancels_active_tasks_nodes_and_blocked_generation(self): class BlockingProvider(CapturingProvider): def __init__(self): super().__init__() self.entered = threading.Event() self.release = threading.Event() def generate_image(self, request): self.requests.append(request) self.entered.set() self.release.wait(timeout=3) return ImageGenerationResult( provider_id=self.provider_id, model=request.model or "image2", images=[ GeneratedImagePayload( b64_json=base64.b64encode(PNG_BYTES).decode("ascii"), revised_prompt=request.prompt, ) ], ) provider = BlockingProvider() generation_service = self._provider_generation_service(provider) profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) detail = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Cancelable workflow"}, self.ctx, ) workflow_id = detail.workflow.workflow_id generation_node_id = detail.nodes[0].node_id queued_node = self.workflow_service.create_node( workflow_id, { "node_key": "queued_followup", "title": "Queued follow-up", "status": "queued", "sort_order": 99, }, self.ctx, ) queued_task = self.queue_service.create_task( { "profile_id": profile.profile_id, "workflow_id": workflow_id, "node_id": queued_node.node_id, "status": "queued", }, self.ctx, ) self.workflow_service.update_node( queued_node.node_id, {"metadata": {**queued_node.metadata, "last_task_id": queued_task.task_id}}, self.ctx, ) with ThreadPoolExecutor(max_workers=1) as executor: future = executor.submit( generate_node, self.ctx, generation_node_id, {"model_route": "image_high", "idempotency_key": "cancel-workflow-provider-run"}, generation_service=generation_service, ) self.assertTrue(provider.entered.wait(timeout=2)) running_task = self.queue_service.list_jobs( status="running", workflow_id=workflow_id, page=1, page_size=10, ).items[0] cancelled_workflow = cancel_workflow(self.ctx, workflow_id, self.workflow_service) self.assertTrue(cancelled_workflow["ok"]) self.assertEqual(cancelled_workflow["data"]["status"], "cancelled") self.assertEqual(self.queue_service.get_job(running_task.task_id).status, "cancelled") self.assertEqual(self.queue_service.get_job(queued_task.task_id).status, "cancelled") self.assertEqual(self.workflow_service.get_node(generation_node_id).status, "cancelled") self.assertEqual(self.workflow_service.get_node(queued_node.node_id).status, "cancelled") provider.release.set() response = future.result(timeout=3) self.assertTrue(response["ok"]) self.assertEqual(response["data"]["task_status"], "cancelled") self.assertEqual(response["data"]["node_status"], "cancelled") self.assertEqual(response["data"]["images"], []) self.assertEqual(self.workflow_service.get_workflow(workflow_id).workflow.status, "cancelled") self.assertEqual(self.image_service.list_by_node(generation_node_id), []) self.assertEqual([path for path in (self.root / "images").rglob("*") if path.is_file()], []) self.assertEqual([path for path in (self.root / "thumbnails").rglob("*") if path.is_file()], []) def test_terminal_task_cas_rejects_workflow_cancelled_during_commit(self): provider = CapturingProvider() generation_service = self._provider_generation_service(provider) profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) detail = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Commit race"}, self.ctx, ) workflow_id = detail.workflow.workflow_id node_id = detail.nodes[0].node_id original_update = self.job_repository.update_if_status_unless_workflow_cancelled injected_cancel = False def cancel_before_terminal_cas(task_id, expected_statuses, payload): nonlocal injected_cancel if payload.get("status") == "succeeded" and not injected_cancel: injected_cancel = True self.workflow_repository.update_workflow(workflow_id, {"status": "cancelled"}) return original_update(task_id, expected_statuses, payload) with patch.object( self.job_repository, "update_if_status_unless_workflow_cancelled", side_effect=cancel_before_terminal_cas, ): response = generate_node( self.ctx, node_id, {"model_route": "image_high", "idempotency_key": "workflow-terminal-cas"}, generation_service=generation_service, ) self.assertTrue(injected_cancel) self.assertTrue(response["ok"]) self.assertEqual(response["data"]["task_status"], "cancelled") self.assertEqual(response["data"]["node_status"], "cancelled") self.assertEqual(response["data"]["images"], []) task = self.queue_service.get_job(response["data"]["task_id"]) self.assertEqual(task.status, "cancelled") self.assertEqual(self.workflow_service.get_workflow(workflow_id).workflow.status, "cancelled") self.assertEqual(self.workflow_service.get_node(node_id).status, "cancelled") self.assertEqual(self.image_service.list_by_node(node_id), []) self.assertEqual([path for path in (self.root / "images").rglob("*") if path.is_file()], []) self.assertEqual([path for path in (self.root / "thumbnails").rglob("*") if path.is_file()], []) def test_virtual_single_image_repeat_failure_preserves_previous_image(self): profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) workflow = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Single"}, self.ctx, ) node_id = workflow.nodes[0].node_id first = generate_node( self.ctx, node_id, {"idempotency_key": "repeat-success"}, generation_service=self.generation_service, ) previous_image_id = first["data"]["images"][0]["image_id"] class FailingProvider: provider_id = "site_b" def generate_image(self, request): raise ImageProviderError( "remote unavailable", provider_id=self.provider_id, status_code=503, error_type="http_error", ) failing_service = self._provider_generation_service(FailingProvider()) second = generate_node( self.ctx, node_id, {"model_route": "image_high", "idempotency_key": "repeat-failure"}, generation_service=failing_service, ) self.assertFalse(second["ok"]) self.assertEqual(second["error_code"], "GENERATION_FAILED") node = self.workflow_service.get_node(node_id) self.assertEqual(node.status, "failed") self.assertEqual(node.selected_image_id, previous_image_id) self.assertEqual([image.image_id for image in self.image_service.list_by_node(node_id)], [previous_image_id]) def test_character_workflow_prepared_queue_can_start_real_generation(self): profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) detail = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "character_fast", "display_name": "Fast"}, self.ctx, ) execution = CharacterWorkflowService(self.workflow_service).execute_workflow( detail.workflow.workflow_id, self.ctx, ) prepared = next(node for node in execution["nodes"] if node["status"] == "queued") self.assertTrue(prepared["metadata"]["execution"]["prepared_only"]) self.assertNotIn("last_task_id", prepared["metadata"]) response = generate_node( self.ctx, prepared["node_id"], {"prompt_patch": "real generation"}, generation_service=self.generation_service, ) self.assertTrue(response["ok"]) task = self.queue_service.get_job(response["data"]["task_id"]) node = self.workflow_service.get_node(prepared["node_id"]) self.assertEqual(task.status, "succeeded") self.assertEqual(node.status, "completed") self.assertFalse(node.metadata["execution"]["prepared_only"]) self.assertEqual(node.metadata["execution"]["task_id"], task.task_id) def test_generate_node_records_resolved_model_route(self): self.model_provider_service.upsert_provider( { "provider_id": "site_b", "base_url": "https://botcf.com", "image_endpoint": "/v1/images/generations", "api_key_secret_ref": "secret/site_b", } ) self.model_provider_service.upsert_route( { "route_name": "image_high", "provider_id": "site_b", "model_id": "image2", "priority": 5, } ) profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) workflow = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Single"}, self.ctx, ) response = generate_node( self.ctx, workflow.nodes[0].node_id, {"prompt_patch": "white shirt", "model_route": "image_high"}, generation_service=self.generation_service, ) task = self.queue_service.get_job(response["data"]["task_id"]) resolution = task.metadata["model_route_resolution"] self.assertEqual(resolution["status"], "resolved") self.assertEqual(resolution["provider_id"], "site_b") self.assertEqual(resolution["model_id"], "image2") self.assertNotIn("api_key_secret_ref", str(task.metadata)) self.assertEqual(task.request["resolved_model_route"]["route_id"], "route_image_high_site_b_image2") def test_single_flow_engine_keeps_mock_outputs_vfs_safe(self): node = WorkflowNode( node_id="node_001", workflow_id="workflow_001", node_key="single", title="Single", description=None, step_name=None, node_type="single_image", status="running", branch_name="main", prompt="portrait", negative_prompt=None, model_route="image_low", selected_image_id=None, sort_order=1, metadata={}, created_at="2026-01-01T00:00:00Z", updated_at="2026-01-01T00:00:00Z", ) task = GenerationTask( task_id="task:../unsafe\\id", profile_id="profile_001", workflow_id="workflow_001", node_id="node_001", task_type="generate", status="running", model_route="image_low", progress=20, idempotency_key=None, request={}, result={}, error_message=None, metadata={}, created_at="2026-01-01T00:00:00Z", updated_at="2026-01-01T00:00:00Z", ) assets = self.generation_service.single_flow_engine.generate(node, task, {"count": 1}) self.assertEqual(len(assets), 1) asset = assets[0] self.assertEqual(asset.image_uri, "storage://images/single/task_unsafe_id_1.png") self.assertEqual(asset.thumbnail_uri, "storage://thumbnails/single/task_unsafe_id_1.png") self.assertTrue(VfsStorage(self.config_service).ensure_file(asset.image_uri).exists()) self.assertTrue(VfsStorage(self.config_service).ensure_file(asset.thumbnail_uri).exists()) serialized = asset.__dict__ self.assertFalse(any(":\\" in str(value) or str(self.root) in str(value) for value in serialized.values())) self.assertNotIn("local_path", asset.metadata) def test_single_flow_engine_can_persist_provider_payloads(self): class FakeProvider: provider_id = "site_b" def generate_image(self, request): return ImageGenerationResult( provider_id=self.provider_id, model=request.model or "image2", images=[ GeneratedImagePayload( b64_json="iVBORw0KGgoAAAANSUhEUgAAAAEAAAABCAQAAAC1HAwCAAAAC0lEQVR42mP8/x8AAwMCAO+/p9sAAAAASUVORK5CYII=", revised_prompt=request.prompt, ) ], usage={"total_tokens": 12}, ) engine = SingleFlowEngine( VfsStorage(self.config_service), image_provider_factory=lambda route: FakeProvider(), ) node = WorkflowNode( node_id="node_001", workflow_id="workflow_001", node_key="single", title="Single", description=None, step_name=None, node_type="single_image", status="running", branch_name="main", prompt="portrait", negative_prompt=None, model_route="image_high", selected_image_id=None, sort_order=1, metadata={}, created_at="2026-01-01T00:00:00Z", updated_at="2026-01-01T00:00:00Z", ) task = GenerationTask( task_id="task_provider", profile_id="profile_001", workflow_id="workflow_001", node_id="node_001", task_type="generate", status="running", model_route="image_high", progress=20, idempotency_key=None, request={}, result={}, error_message=None, metadata={}, created_at="2026-01-01T00:00:00Z", updated_at="2026-01-01T00:00:00Z", ) assets = engine.generate( node, task, { "model_route": "image_high", "resolved_model_route": {"status": "resolved", "route_name": "image_high", "model_id": "image2"}, }, ) self.assertEqual(len(assets), 1) self.assertFalse(assets[0].metadata["mock"]) self.assertEqual(assets[0].metadata["provider_id"], "site_b") self.assertEqual(assets[0].metadata["usage"]["total_tokens"], 12) self.assertTrue(VfsStorage(self.config_service).ensure_file(assets[0].image_uri).exists()) def test_provider_outputs_keep_signature_extension_bytes_and_media_mime_aligned(self): jpeg_bytes = b"\xff\xd8\xff\xe0" + (b"\x00" * 20) + b"\xff\xd9" webp_bytes = b"RIFF\x10\x00\x00\x00WEBPVP8 " + (b"\x00" * 8) gif_bytes = b"GIF89a\x01\x00\x01\x00\x00\x00\x00;" payloads = [jpeg_bytes, webp_bytes, gif_bytes] class FormatProvider: provider_id = "site_b" def generate_image(self, request): return ImageGenerationResult( provider_id=self.provider_id, model=request.model or "image2", images=[ GeneratedImagePayload(b64_json=base64.b64encode(body).decode("ascii")) for body in payloads ], ) generation_service = self._provider_generation_service(FormatProvider()) profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) workflow = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Provider formats"}, self.ctx, ) response = generate_node( self.ctx, workflow.nodes[0].node_id, {"model_route": "image_high", "count": 3}, generation_service=generation_service, ) self.assertTrue(response["ok"]) images = response["data"]["images"] self.assertEqual([Path(item["image_uri"]).suffix for item in images], [".jpg", ".webp", ".gif"]) self.assertEqual([Path(item["thumbnail_uri"]).suffix for item in images], [".jpg", ".webp", ".gif"]) storage = VfsStorage(self.config_service) media_proxy = MediaProxy(storage, signing_secret="format-test") for image, expected_body, expected_mime in zip( images, payloads, ("image/jpeg", "image/webp", "image/gif"), ): image_path = storage.ensure_file(image["image_uri"]) thumbnail_path = storage.ensure_file(image["thumbnail_uri"]) self.assertEqual(image_path.read_bytes(), expected_body) self.assertEqual(thumbnail_path.read_bytes(), expected_body) self.assertEqual(image["metadata"]["content_type"], expected_mime) self.assertEqual(image["metadata"]["file_extension"], image_path.suffix) self.assertEqual(media_proxy.sign(image["image_uri"])["content_type"], expected_mime) self.assertEqual(media_proxy.sign(image["thumbnail_uri"])["content_type"], expected_mime) def test_generate_node_records_provider_failure_attribution_on_fallback(self): class FailingProvider: provider_id = "site_b" def generate_image(self, request): raise ImageProviderError( "remote unauthorized", provider_id=self.provider_id, status_code=401, error_type="http_error", details={ "body_preview": ( 'Authorization: Bearer sk-live-secret-12345678 ' '{"api_key":"inline-secret-value","message":"invalid credentials"}' ), "api_key": "secret-value", }, ) self.model_provider_service.upsert_provider( { "provider_id": "site_b", "base_url": "https://botcf.com", "image_endpoint": "/v1/images/generations", } ) self.model_provider_service.upsert_route( { "route_name": "image_high", "provider_id": "site_b", "model_id": "image2", "priority": 5, } ) generation_service = GenerationService( workflow_service=self.workflow_service, queue_service=self.queue_service, image_service=self.image_service, single_flow_engine=SingleFlowEngine( VfsStorage(self.config_service), image_provider_factory=lambda route: FailingProvider(), allow_mock_fallback=True, ), model_provider_service=self.model_provider_service, event_bus=self.event_bus, ) profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) workflow = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Single"}, self.ctx, ) response = generate_node( self.ctx, workflow.nodes[0].node_id, {"prompt_patch": "white shirt", "model_route": "image_high"}, generation_service=generation_service, ) self.assertTrue(response["ok"]) task = self.queue_service.get_job(response["data"]["task_id"]) failure = task.result["provider_failure"] self.assertEqual(failure["category"], "auth_error") self.assertEqual(failure["provider_id"], "site_b") self.assertEqual(failure["route_name"], "image_high") self.assertFalse(failure["retryable"]) self.assertTrue(failure["fallback_used"]) self.assertEqual(failure["details"]["api_key"], "[REDACTED]") self.assertNotIn("secret-value", str(task.to_dict())) self.assertNotIn("sk-live-secret", str(task.to_dict())) self.assertNotIn("inline-secret-value", str(task.to_dict())) self.assertIn("[REDACTED]", failure["details"]["body_preview"]) image = self.image_service.get_image(response["data"]["images"][0]["image_id"]) self.assertTrue(image.metadata["mock"]) self.assertEqual(image.metadata["provider_error"]["category"], "auth_error") def test_generate_node_marks_task_and_node_failed_without_mock_fallback(self): class FailingProvider: provider_id = "site_b" def generate_image(self, request): raise ImageProviderError( "remote unavailable", provider_id=self.provider_id, status_code=503, error_type="http_error", ) self.model_provider_service.upsert_provider( { "provider_id": "site_b", "base_url": "https://botcf.com", "image_endpoint": "/v1/images/generations", } ) self.model_provider_service.upsert_route( { "route_name": "image_high", "provider_id": "site_b", "model_id": "image2", "priority": 5, } ) generation_service = GenerationService( workflow_service=self.workflow_service, queue_service=self.queue_service, image_service=self.image_service, single_flow_engine=SingleFlowEngine( VfsStorage(self.config_service), image_provider_factory=lambda route: FailingProvider(), allow_mock_fallback=False, ), model_provider_service=self.model_provider_service, event_bus=self.event_bus, require_resolved_model_route=True, ) profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) workflow = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Single"}, self.ctx, ) node_id = workflow.nodes[0].node_id response = generate_node( self.ctx, node_id, {"prompt_patch": "white shirt", "model_route": "image_high"}, generation_service=generation_service, ) self.assertFalse(response["ok"]) self.assertEqual(response["error_code"], "GENERATION_FAILED") task = self.queue_service.list_jobs(page=1, page_size=10).items[0] self.assertEqual(task.status, "failed") self.assertEqual(task.metadata["generation_failure"]["category"], "provider_unavailable") self.assertEqual(self.workflow_service.get_node(node_id).status, "failed") self.assertEqual(self.image_service.list_by_node(node_id), []) self.assertEqual(len(self.event_bus.history("generation.node_failed")), 1) def test_generate_node_rejects_request_when_cost_budget_would_be_exceeded(self): self.model_provider_service.upsert_provider( { "provider_id": "site_b", "base_url": "https://botcf.com", "image_endpoint": "/v1/images/generations", } ) self.model_provider_service.upsert_route( { "route_name": "image_high", "provider_id": "site_b", "model_id": "image2", "priority": 5, } ) profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) workflow = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Single"}, self.ctx, ) node_id = workflow.nodes[0].node_id self.image_service.create_image( { "profile_id": profile.profile_id, "workflow_id": workflow.workflow.workflow_id, "node_id": node_id, "task_id": "task_existing_paid", "image_uri": "storage://images/existing_paid.png", "model_route": "image_high", "metadata": { "provider_id": "site_b", "provider_model": "image2", "usage": {"total_tokens": 100}, }, }, self.ctx, ) generation_service = GenerationService( workflow_service=self.workflow_service, queue_service=self.queue_service, image_service=self.image_service, single_flow_engine=SingleFlowEngine(VfsStorage(self.config_service), allow_mock_fallback=True), model_provider_service=self.model_provider_service, cost_guard_service=CostGuardService(CostService(self.database)), event_bus=self.event_bus, ) response = generate_node( self.ctx, node_id, { "model_route": "image_high", "cost_budget": { "max_estimated_cost": 0.05, "unit_prices": {"site_b": 0.045}, }, }, generation_service=generation_service, ) self.assertFalse(response["ok"]) self.assertEqual(response["error_code"], "VALIDATION_FAILED") self.assertIn("cost_budget_exceeded", response["details"]["violations"]) self.assertEqual(self.queue_service.list_jobs(page=1, page_size=10).total, 0) def test_generate_node_uses_prompt_expansion_when_service_is_configured(self): profile = self.profile_service.create_profile( { "name": "Nova", "base_prompt": "portrait of {profile_name}", "appearance_prompt": "silver hair", "style_prompt": "watercolor", "negative_prompt": "low quality", }, self.ctx, ) workflow = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Single"}, self.ctx, ) node_id = workflow.nodes[0].node_id self.workflow_service.update_node( node_id, {"prompt": "calm expression", "negative_prompt": "bad hands"}, self.ctx, ) generation_service = GenerationService( workflow_service=self.workflow_service, queue_service=self.queue_service, image_service=self.image_service, single_flow_engine=SingleFlowEngine(VfsStorage(self.config_service), allow_mock_fallback=True), model_provider_service=self.model_provider_service, prompt_expansion_service=PromptExpansionService(), event_bus=self.event_bus, ) response = generate_node( self.ctx, node_id, { "prompt_patch": "white blouse", "negative_prompt_patch": "watermark", "dependency_context": { "prompt_context": "approved headshot, silver hair", "material_bindings": { "prompt_context": "silk ribbon, gold trim", "material_prompts": ["silk ribbon", "gold trim"], "generation_params": { "reference_prompts": ["silk ribbon", "gold trim"], }, }, }, }, generation_service=generation_service, ) self.assertTrue(response["ok"]) image = response["data"]["images"][0] self.assertEqual( image["positive_prompt"], "portrait of Nova, silver hair, watercolor, calm expression, approved headshot, silk ribbon, gold trim, white blouse", ) self.assertEqual(image["positive_prompt"].count("silk ribbon"), 1) self.assertEqual(image["positive_prompt"].count("gold trim"), 1) self.assertEqual(image["positive_prompt"].count("silver hair"), 1) self.assertEqual(image["negative_prompt"], "low quality, bad hands, watermark") task = self.queue_service.get_job(response["data"]["task_id"]) self.assertEqual(task.request["prompt_expansion"]["source"], "profile_node") def test_generate_node_passes_selected_upstream_storage_image_as_data_url(self): provider = CapturingProvider() generation_service = self._provider_generation_service(provider, expand_prompts=True) profile = self.profile_service.create_profile( { "name": "Nova", "base_prompt": "portrait of Nova", "negative_prompt": "low quality", }, self.ctx, ) detail = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "character_gradual", "display_name": "Gradual"}, self.ctx, ) headshot = next(node for node in detail.nodes if node.node_key == "headshot") half_body = next(node for node in detail.nodes if node.node_key == "half_body") upstream_uri = "storage://images/upstream-headshot.png" self._write_storage_image(upstream_uri, PNG_BYTES) upstream = self.image_service.create_image( { "node_id": headshot.node_id, "image_uri": upstream_uri, "is_selected": True, }, self.ctx, ) self.workflow_service.update_node( headshot.node_id, {"status": "completed", "prompt": "approved headshot identity"}, self.ctx, ) self.workflow_service.update_node( half_body.node_id, {"prompt": "half body portrait", "negative_prompt": "bad anatomy"}, self.ctx, ) response = generate_node( self.ctx, half_body.node_id, { "model_route": "image_high", "prompt_patch": "white blouse", "negative_prompt_patch": "watermark", }, generation_service=generation_service, ) self.assertTrue(response["ok"]) self.assertEqual(len(provider.requests), 1) provider_request = provider.requests[0] self.assertEqual(len(provider_request.input_images), 1) self.assertTrue(provider_request.input_images[0].startswith("data:image/png;base64,")) encoded = provider_request.input_images[0].split(",", 1)[1] self.assertEqual(base64.b64decode(encoded), PNG_BYTES) self.assertIn("approved headshot identity", provider_request.prompt) self.assertEqual(provider_request.negative_prompt, "low quality, bad anatomy, watermark") task = self.queue_service.get_job(response["data"]["task_id"]) self.assertNotIn("data:image", str(task.request)) self.assertEqual(task.request["prompt_expansion"]["node_injection"]["dependency_context"]["selected_image_ids"], [upstream.image_id]) def test_generate_node_combines_explicit_draft_and_stage_inputs_in_order(self): provider = CapturingProvider() generation_service = self._provider_generation_service(provider) profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) detail = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Single"}, self.ctx, ) node_id = detail.nodes[0].node_id image_payloads = ( ("storage://images/explicit.png", PNG_BYTES), ("storage://images/draft.gif", b"GIF89a-draft-reference"), ("storage://images/stage.webp", b"RIFF\x04\x00\x00\x00WEBP-stage-reference"), ) images = [] for uri, body in image_payloads: self._write_storage_image(uri, body) images.append(self.image_service.create_image({"node_id": node_id, "image_uri": uri}, self.ctx)) explicit, draft, stage = images direct_data_url = "data:image/jpeg;base64," + base64.b64encode(b"\xff\xd8\xff\xd9").decode("ascii") response = generate_node( self.ctx, node_id, { "model_route": "image_high", "input_images": [ explicit.image_id, "https://example.com/reference.png", direct_data_url, explicit.image_id, ], "selected_draft_image_ids": [draft.image_id], "metadata": {"selected_draft_image_ids": [draft.image_id]}, "stage_inputs": {"hires_fix": {"image_id": stage.image_id}}, }, generation_service=generation_service, ) self.assertTrue(response["ok"]) input_images = provider.requests[0].input_images self.assertEqual(len(input_images), 5) self.assertTrue(input_images[0].startswith("data:image/png;base64,")) self.assertEqual(input_images[1], "https://example.com/reference.png") self.assertEqual(input_images[2], direct_data_url) self.assertTrue(input_images[3].startswith("data:image/gif;base64,")) self.assertTrue(input_images[4].startswith("data:image/webp;base64,")) task = self.queue_service.get_job(response["data"]["task_id"]) self.assertNotIn("data:image", str(task.request)) self.assertEqual(task.request["reference_persistence"]["ephemeral_data_urls_omitted"], 1) self.assertEqual( task.request["input_images"], [explicit.image_id, "https://example.com/reference.png", explicit.image_id], ) def test_generate_node_passes_confirmed_material_image_after_explicit_references(self): provider = CapturingProvider() generation_service = self._provider_generation_service( provider, expand_prompts=True, material_resolver=self.material_repository, ) profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) detail = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Single"}, self.ctx, ) material_uri = "storage://materials/confirmed-style.png" self._write_storage_image(material_uri, PNG_BYTES) material = self.material_repository.create_material( { "material_id": "mat_confirmed_style", "display_name": "Confirmed style", "image_uri": material_uri, "prompt": "soft watercolor lighting", "recognition_status": "confirmed", } ) response = generate_node( self.ctx, detail.nodes[0].node_id, { "model_route": "image_high", "input_images": ["https://example.com/explicit-reference.png"], "dependency_context": { "material_bindings": { "material_prompts": [material.prompt], "generation_params": {"reference_material_ids": [material.material_id]}, "active_bindings": [ { "material": { "material_id": material.material_id, "prompt": material.prompt, } } ], } }, }, generation_service=generation_service, ) self.assertTrue(response["ok"]) provider_request = provider.requests[0] self.assertEqual(provider_request.input_images[0], "https://example.com/explicit-reference.png") self.assertEqual(len(provider_request.input_images), 2) self.assertTrue(provider_request.input_images[1].startswith("data:image/png;base64,")) self.assertIn("soft watercolor lighting", provider_request.prompt) def test_generate_node_rejects_missing_and_unconfirmed_material_references(self): provider = CapturingProvider() generation_service = self._provider_generation_service( provider, material_resolver=self.material_repository, ) profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) detail = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Single"}, self.ctx, ) missing = generate_node( self.ctx, detail.nodes[0].node_id, { "model_route": "image_high", "dependency_context": { "material_bindings": { "generation_params": {"reference_material_ids": ["mat_missing"]}, } }, }, generation_service=generation_service, ) self.assertFalse(missing["ok"]) self.assertEqual(missing["error_code"], "RESOURCE_NOT_FOUND") self.assertEqual(missing["details"]["material_id"], "mat_missing") material = self.material_repository.create_material( { "material_id": "mat_pending_style", "display_name": "Pending style", "image_uri": "storage://materials/pending-style.png", "recognition_status": "pending_confirm", } ) response = generate_node( self.ctx, detail.nodes[0].node_id, { "model_route": "image_high", "dependency_context": { "material_bindings": { "generation_params": {"reference_material_ids": [material.material_id]}, } }, }, generation_service=generation_service, ) self.assertFalse(response["ok"]) self.assertEqual(response["error_code"], "VALIDATION_FAILED") self.assertEqual(response["details"]["material_id"], material.material_id) self.assertEqual(response["details"]["recognition_status"], "pending_confirm") self.assertEqual(self.queue_service.list_jobs(page=1, page_size=10).total, 0) def test_generate_node_rejects_missing_reference_image_id_before_queueing(self): profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) detail = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Single"}, self.ctx, ) response = generate_node( self.ctx, detail.nodes[0].node_id, {"selected_draft_image_ids": ["img_missing"]}, generation_service=self.generation_service, ) self.assertFalse(response["ok"]) self.assertEqual(response["error_code"], "RESOURCE_NOT_FOUND") self.assertEqual(response["details"]["image_id"], "img_missing") self.assertIn("selected_draft_image_ids", response["details"]["source"]) self.assertEqual(self.queue_service.list_jobs(page=1, page_size=10).total, 0) def test_generate_node_rejects_reference_image_from_another_workflow(self): profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) first = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "First"}, self.ctx, ) second = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Second"}, self.ctx, ) uri = "storage://images/other-workflow.png" self._write_storage_image(uri, PNG_BYTES) other_image = self.image_service.create_image( {"node_id": second.nodes[0].node_id, "image_uri": uri}, self.ctx, ) response = generate_node( self.ctx, first.nodes[0].node_id, {"selected_draft_image_ids": [other_image.image_id]}, generation_service=self.generation_service, ) self.assertFalse(response["ok"]) self.assertEqual(response["error_code"], "VALIDATION_FAILED") self.assertEqual(response["details"]["image_id"], other_image.image_id) self.assertEqual(response["details"]["workflow_id"], first.workflow.workflow_id) self.assertEqual(self.queue_service.list_jobs(page=1, page_size=10).total, 0) def test_generate_node_rejects_when_last_task_is_still_active(self): profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) detail = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Single"}, self.ctx, ) node = detail.nodes[0] active_task = self.queue_service.create_task( { "profile_id": profile.profile_id, "workflow_id": detail.workflow.workflow_id, "node_id": node.node_id, "status": "queued", }, self.ctx, ) self.workflow_service.update_node( node.node_id, {"status": "queued", "metadata": {**node.metadata, "last_task_id": active_task.task_id}}, self.ctx, ) response = generate_node( self.ctx, node.node_id, {"idempotency_key": "another-task"}, generation_service=self.generation_service, ) self.assertFalse(response["ok"]) self.assertEqual(response["error_code"], "VALIDATION_FAILED") self.assertEqual(response["details"]["last_task_id"], active_task.task_id) self.assertEqual(response["details"]["task_status"], "queued") self.assertEqual(self.queue_service.list_jobs(page=1, page_size=10).total, 1) def test_retry_node_reexecutes_last_request_with_fresh_idempotency_and_overrides(self): profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) detail = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Retry"}, self.ctx, ) node = detail.nodes[0] previous_request = { "prompt_patch": "old prompt", "model_route": "image_low", "count": 1, "aspect_ratio": "1:1", "idempotency_key": "old-generation-key", "expanded_prompt": "stale expanded prompt", "expanded_negative_prompt": "stale negative prompt", "prompt_expansion": {"source": "stale"}, "resolved_model_route": {"status": "resolved", "provider_id": "stale-provider"}, "cost_guard": {"allowed": True, "stale": True}, "metadata": {"source": "initial", "preserved": True}, } self.workflow_repository.update_node( node.node_id, { "status": "failed", "metadata": {**node.metadata, "last_generate_request": previous_request}, }, ) response = retry_node( self.ctx, node.node_id, { "prompt_patch": "new retry prompt", "model_route": "image_high", "count": 2, "aspect_ratio": "3:4", "idempotency_key": "client-key-must-not-be-reused", "expanded_prompt": "client-derived prompt must be ignored", "cost_guard": {"allowed": True, "client_supplied": True}, "metadata": {"source": "retry_ui", "retry_reason": "provider recovered"}, }, service=self.workflow_service, generation_service=self.generation_service, ) self.assertTrue(response["ok"]) self.assertEqual(response["data"]["task_status"], "succeeded") self.assertEqual(response["data"]["node_status"], "completed") self.assertEqual(len(response["data"]["images"]), 2) self.assertEqual(response["data"]["images"][0]["positive_prompt"], "new retry prompt") self.assertEqual(response["data"]["images"][0]["width"], 768) self.assertEqual(response["data"]["images"][0]["height"], 1024) task = self.queue_service.get_job(response["data"]["task_id"]) self.assertTrue(task.idempotency_key.startswith(f"node-retry-{node.node_id}-")) self.assertNotEqual(task.idempotency_key, previous_request["idempotency_key"]) self.assertNotEqual(task.idempotency_key, "client-key-must-not-be-reused") self.assertEqual(task.request["prompt_patch"], "new retry prompt") self.assertEqual(task.request["model_route"], "image_high") self.assertEqual(task.request["metadata"]["source"], "retry_ui") self.assertTrue(task.request["metadata"]["preserved"]) self.assertNotIn("expanded_prompt", task.request) self.assertNotIn("expanded_negative_prompt", task.request) self.assertNotIn("prompt_expansion", task.request) self.assertNotIn("cost_guard", task.request) self.assertEqual(task.request["resolved_model_route"]["status"], "unresolved") def test_retry_node_requires_a_previous_generation_request(self): profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) detail = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Missing request"}, self.ctx, ) node = detail.nodes[0] self.workflow_repository.update_node(node.node_id, {"status": "failed"}) response = retry_node( self.ctx, node.node_id, service=self.workflow_service, generation_service=self.generation_service, ) self.assertFalse(response["ok"]) self.assertEqual(response["error_code"], "VALIDATION_FAILED") self.assertEqual(response["details"]["field"], "metadata.last_generate_request") self.assertEqual(self.queue_service.list_jobs(page=1, page_size=10).total, 0) def test_retry_node_requires_replacement_for_omitted_inline_reference(self): profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) detail = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Inline retry"}, self.ctx, ) node = detail.nodes[0] self.workflow_repository.update_node( node.node_id, { "status": "failed", "metadata": { **node.metadata, "last_generate_request": { "model_route": "image_low", "reference_persistence": {"ephemeral_data_urls_omitted": 1}, }, }, }, ) rejected = retry_node( self.ctx, node.node_id, service=self.workflow_service, generation_service=self.generation_service, ) accepted = retry_node( self.ctx, node.node_id, {"input_images": ["https://example.com/replacement.png"]}, service=self.workflow_service, generation_service=self.generation_service, ) self.assertFalse(rejected["ok"]) self.assertEqual(rejected["error_code"], "VALIDATION_FAILED") self.assertEqual(rejected["details"]["ephemeral_data_urls_omitted"], 1) self.assertTrue(accepted["ok"]) def test_retry_node_accepts_cancelled_status(self): profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) detail = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Cancelled retry"}, self.ctx, ) node = detail.nodes[0] self.workflow_repository.update_node( node.node_id, { "status": "cancelled", "metadata": { **node.metadata, "last_generate_request": {"prompt_patch": "resume portrait", "model_route": "image_low"}, }, }, ) response = retry_node( self.ctx, node.node_id, service=self.workflow_service, generation_service=self.generation_service, ) self.assertTrue(response["ok"]) self.assertEqual(response["data"]["task_status"], "succeeded") self.assertEqual(response["data"]["node_status"], "completed") self.assertEqual(response["data"]["images"][0]["positive_prompt"], "resume portrait") def test_retry_node_rejects_completed_non_virtual_node_and_requires_a_branch(self): profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) detail = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "character_fast", "display_name": "Locked retry"}, self.ctx, ) node = detail.nodes[0] completed = self.workflow_service.update_node( node.node_id, { "status": "completed", "metadata": { **node.metadata, "last_generate_request": {"prompt_patch": "old", "model_route": "image_low"}, }, }, self.ctx, ) response = retry_node( self.ctx, completed.node_id, {"prompt_patch": "changed"}, service=self.workflow_service, generation_service=self.generation_service, ) self.assertFalse(response["ok"]) self.assertEqual(response["error_code"], "VALIDATION_FAILED") self.assertEqual(response["details"]["status"], "completed") self.assertEqual(response["details"]["suggested_action"], "create_branch") self.assertEqual(response["details"]["base_node_id"], completed.node_id) self.assertEqual(self.queue_service.list_jobs(page=1, page_size=10).total, 0) def test_retry_node_rejects_non_retryable_draft_status(self): profile = self.profile_service.create_profile({"name": "Nova"}, self.ctx) detail = self.workflow_service.create_workflow( profile.profile_id, {"workflow_type": "single_image", "display_name": "Draft retry"}, self.ctx, ) node = detail.nodes[0] self.workflow_repository.update_node( node.node_id, {"metadata": {**node.metadata, "last_generate_request": {"model_route": "image_low"}}}, ) response = retry_node( self.ctx, node.node_id, service=self.workflow_service, generation_service=self.generation_service, ) self.assertFalse(response["ok"]) self.assertEqual(response["error_code"], "VALIDATION_FAILED") self.assertEqual(response["details"]["status"], "draft") self.assertEqual(response["details"]["allowed_statuses"], ["cancelled", "failed", "skipped"]) self.assertEqual(self.queue_service.list_jobs(page=1, page_size=10).total, 0) def test_queue_service_rejects_invalid_task_transition(self): task = self.queue_service.create_task({"status": "succeeded"}, self.ctx) with self.assertRaises(ApiError) as raised: self.queue_service.requeue_job(task.task_id, self.ctx) self.assertEqual(raised.exception.error_code, ErrorCode.TASK_NOT_RETRYABLE) with self.assertRaises(ApiError) as transition_error: self.queue_service.update_task(task.task_id, {"status": "queued"}, self.ctx) self.assertEqual(transition_error.exception.error_code, ErrorCode.VALIDATION_FAILED) if __name__ == "__main__": unittest.main()