astrbot_plugin_imagestudio/tests/test_image_service.py

182 行
7.3 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.image_service import ImageService
from backend.services.profile_service import ProfileService
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.profile_repository import ProfileRepository
from database.repositories.workflow_repository import WorkflowRepository
class ImageServiceTests(unittest.TestCase):
def setUp(self):
self.tmp_path = Path(".tmp") / f"test_image_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.image_repository = ImageRepository(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.image_service = ImageService(
image_repository=self.image_repository,
workflow_repository=self.workflow_repository,
audit_service=self.audit_service,
)
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_write"},
)
self.profile = self.profile_service.create_profile({"name": "莉娅"}, self.ctx)
detail = self.workflow_service.create_workflow(
self.profile.profile_id,
{
"workflow_type": "single_image",
"display_name": "单图流",
},
self.ctx,
)
self.workflow = detail.workflow
self.node = detail.nodes[0]
def tearDown(self):
shutil.rmtree(self.tmp_path, ignore_errors=True)
def test_create_image_inherits_profile_and_workflow_from_node(self):
image = self.image_service.create_image(
{
"node_id": self.node.node_id,
"image_uri": "storage://images/2026/07/04/img_001.png",
"thumbnail_uri": "storage://thumbnails/2026/07/04/img_001.webp",
"positive_prompt": "masterpiece, 1girl",
"negative_prompt": "bad hands",
"model_used": "model_x",
"seed": 123,
"width": 1024,
"height": 1536,
"metadata": {"candidate": 1},
},
self.ctx,
)
self.assertTrue(image.image_id.startswith("img_"))
self.assertEqual(image.profile_id, self.profile.profile_id)
self.assertEqual(image.workflow_id, self.workflow.workflow_id)
self.assertEqual(image.node_id, self.node.node_id)
self.assertEqual(image.metadata, {"candidate": 1})
def test_create_image_rejects_non_vfs_uri(self):
with self.assertRaises(ApiError) as raised:
self.image_service.create_image(
{
"node_id": self.node.node_id,
"image_uri": "C:/real/path/image.png",
},
self.ctx,
)
self.assertEqual(raised.exception.error_code, ErrorCode.VALIDATION_FAILED)
def test_list_by_node_excludes_archived_images(self):
kept = self._create_image("storage://images/kept.png")
archived = self._create_image("storage://images/archived.png")
self.image_service.archive_image(archived.image_id, self.ctx)
visible = self.image_service.list_by_node(self.node.node_id)
all_images = self.image_service.list_by_node(self.node.node_id, include_archived=True)
self.assertEqual([image.image_id for image in visible], [kept.image_id])
self.assertEqual({image.image_id for image in all_images}, {kept.image_id, archived.image_id})
def test_select_image_is_exclusive_within_node(self):
first = self._create_image("storage://images/first.png")
second = self._create_image("storage://images/second.png")
self.image_service.select_image(first.image_id, self.ctx)
selected = self.image_service.select_image(second.image_id, self.ctx)
first_after = self.image_service.get_image(first.image_id)
node_after = self.workflow_repository.get_node(self.node.node_id)
self.assertTrue(selected.is_selected)
self.assertFalse(first_after.is_selected)
self.assertEqual(node_after.selected_image_id, second.image_id)
def test_unselect_image_clears_node_selected_image_id(self):
image = self._create_image("storage://images/selected.png")
self.image_service.select_image(image.image_id, self.ctx)
unselected = self.image_service.unselect_image(image.image_id, self.ctx)
node_after = self.workflow_repository.get_node(self.node.node_id)
self.assertFalse(unselected.is_selected)
self.assertIsNone(node_after.selected_image_id)
def test_select_image_rejects_locked_completed_node(self):
image = self._create_image("storage://images/locked.png")
self.workflow_service.update_node(self.node.node_id, {"status": "completed"}, self.ctx)
with self.assertRaises(ApiError) as raised:
self.image_service.select_image(image.image_id, self.ctx)
self.assertEqual(raised.exception.error_code, ErrorCode.VALIDATION_FAILED)
self.assertEqual(raised.exception.details["suggested_action"], "create_branch")
def test_delete_image_metadata_removes_record_and_writes_audit(self):
image = self._create_image("storage://images/delete.png")
deleted = self.image_service.delete_image_metadata(image.image_id, self.ctx)
self.assertEqual(deleted.image_id, image.image_id)
with self.assertRaises(ApiError):
self.image_service.get_image(image.image_id)
conn = self.database.connect()
try:
audit = conn.execute(
"""
SELECT action, target_type
FROM audit_logs
WHERE target_id = ? AND action = 'delete_image'
""",
(image.image_id,),
).fetchone()
finally:
conn.close()
self.assertIsNotNone(audit)
self.assertEqual(audit["target_type"], "generation_image")
def _create_image(self, image_uri: str):
return self.image_service.create_image(
{
"node_id": self.node.node_id,
"image_uri": image_uri,
"positive_prompt": "prompt",
},
self.ctx,
)
if __name__ == "__main__":
unittest.main()