astrbot_plugin_imagestudio/tests/test_material_service.py

442 行
19 KiB
Python

2026-07-05 09:52:13 +08:00
from __future__ import annotations
import tempfile
import unittest
from pathlib import Path
from backend.routes.material_routes import (
confirm_material,
2026-07-05 09:52:13 +08:00
create_material,
create_material_category,
delete_material,
get_material,
list_material_categories,
list_materials,
2026-07-05 17:24:35 +08:00
re_recognize_material,
recognize_material,
2026-07-05 09:52:13 +08:00
update_material,
upload_material,
2026-07-05 09:52:13 +08:00
)
2026-07-06 03:28:34 +08:00
from backend.dto.common import ApiError, ErrorCode
2026-07-05 20:48:15 +08:00
from backend.services.media_service import MediaService
2026-07-06 03:28:34 +08:00
from backend.services.material_service import MAX_UPLOAD_BYTES, MaterialService
2026-07-05 09:52:13 +08:00
from core.audit_service import AuditService
2026-07-05 20:48:15 +08:00
from core.config_service import ConfigService
2026-07-05 09:52:13 +08:00
from core.identity import RequestContext
from database.db_helper import Database, DatabaseSettings, SqliteSettings
from database.repositories.material_repository import MaterialRepository
2026-07-06 03:37:17 +08:00
from engines.vision_provider import VisionProviderError, VisionRecognitionResult
2026-07-05 09:52:13 +08:00
class MaterialServiceTests(unittest.TestCase):
def setUp(self):
self.tmp = tempfile.TemporaryDirectory()
2026-07-05 20:48:15 +08:00
self.root = Path(self.tmp.name)
self.config_path = self.root / "config.yaml"
(self.root / "materials").mkdir(parents=True, exist_ok=True)
self.config_path.write_text(
f"""
storage:
materials_path: "{(self.root / "materials").as_posix()}"
""",
encoding="utf-8",
)
2026-07-05 09:52:13 +08:00
self.database = Database(
2026-07-05 20:48:15 +08:00
DatabaseSettings(sqlite=SqliteSettings(path=str(self.root / "imagestudio.db")))
2026-07-05 09:52:13 +08:00
)
self.database.initialize()
self.audit_service = AuditService(self.database)
self.material_service = MaterialService(MaterialRepository(self.database), self.audit_service)
2026-07-05 20:48:15 +08:00
self.media_service = MediaService(ConfigService(self.config_path))
2026-07-05 09:52:13 +08:00
self.ctx = RequestContext.from_astrbot(
username="admin",
user_id="user_001",
permissions={"can_manage_materials"},
)
def tearDown(self):
self.tmp.cleanup()
def test_category_and_material_crud(self):
category = self.material_service.create_category(
{"name": "Upper", "category_id": "cat_upper", "sort_order": 10},
self.ctx,
)
self.assertEqual(category.name, "Upper")
material = self.material_service.create_material(
{
"category_id": category.category_id,
"display_name": "White blouse",
"image_uri": "storage://materials/white_blouse.png",
"thumbnail_uri": "storage://materials/white_blouse_thumb.png",
"prompt": "white blouse, clean collar",
"tags": ["upper", "white"],
"recognition_status": "confirmed",
},
self.ctx,
)
self.assertTrue(material.material_id.startswith("mat_"))
self.assertEqual(material.tags, ["upper", "white"])
listed = self.material_service.list_materials(category_id=category.category_id, keyword="blouse")
self.assertEqual(listed.total, 1)
self.assertEqual(listed.items[0].material_id, material.material_id)
updated = self.material_service.update_material(
material.material_id,
{"display_name": "White short sleeve blouse", "tags": ["summer"]},
self.ctx,
)
self.assertEqual(updated.display_name, "White short sleeve blouse")
self.assertEqual(updated.tags, ["summer"])
deleted = self.material_service.delete_material(material.material_id, self.ctx)
self.assertEqual(deleted.recognition_status, "archived")
self.assertEqual(self.material_service.list_materials().total, 0)
def test_material_requires_storage_uri(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
with self.assertRaises(Exception):
self.material_service.create_material(
{
"category_id": category.category_id,
"display_name": "Bad path",
"image_uri": "C:/real/path.png",
},
self.ctx,
)
def test_material_repository_pagination_is_normalized(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
for index in range(3):
self.material_service.create_material(
{
"category_id": category.category_id,
"display_name": f"Material {index}",
"image_uri": f"storage://materials/item_{index}.png",
},
self.ctx,
)
zero_items, zero_total = self.material_service.repository.list_materials(page=0, page_size=0)
huge_items, huge_total = self.material_service.repository.list_materials(page=1, page_size=999)
self.assertEqual(len(zero_items), 1)
self.assertEqual(zero_total, 3)
self.assertEqual(len(huge_items), 3)
self.assertEqual(huge_total, 3)
def test_upload_recognize_and_confirm_material(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
uploaded = self.material_service.upload_material(
{
"category_id": category.category_id,
"filename": "white_blouse.png",
2026-07-06 03:28:34 +08:00
"content_type": "image/png; charset=binary",
"size_bytes": "2048",
"image_uri": "storage://materials/white_blouse.png",
2026-07-06 03:28:34 +08:00
"metadata": {"source": "unit_test"},
},
self.ctx,
)
self.assertEqual(uploaded.recognition_status, "pending_recognition")
self.assertEqual(uploaded.thumbnail_uri, "storage://materials/white_blouse.png")
2026-07-06 03:28:34 +08:00
self.assertEqual(uploaded.display_name, "white blouse")
self.assertEqual(uploaded.metadata["source"], "unit_test")
self.assertEqual(uploaded.metadata["upload"]["filename"], "white_blouse.png")
self.assertEqual(uploaded.metadata["upload"]["content_type"], "image/png")
self.assertEqual(uploaded.metadata["upload"]["extension"], ".png")
self.assertEqual(uploaded.metadata["upload"]["size_bytes"], 2048)
recognized = self.material_service.recognize_material(uploaded.material_id, self.ctx)
self.assertEqual(recognized.recognition_status, "pending_confirm")
self.assertIn("white", recognized.tags)
self.assertIn("clean product reference", recognized.prompt)
2026-07-06 03:37:17 +08:00
self.assertEqual(recognized.metadata["recognition"]["provider_id"], "mock")
self.assertFalse(recognized.metadata["recognition"]["fallback_used"])
confirmed = self.material_service.confirm_material(
uploaded.material_id,
{
"display_name": "White short-sleeve blouse",
"prompt": "white short-sleeve blouse, clean collar",
"tags": ["upper", "white", "summer"],
},
self.ctx,
)
self.assertEqual(confirmed.recognition_status, "confirmed")
self.assertEqual(confirmed.tags, ["upper", "white", "summer"])
2026-07-05 17:24:35 +08:00
re_recognized = self.material_service.re_recognize_material(uploaded.material_id, self.ctx)
self.assertEqual(re_recognized.recognition_status, "pending_confirm")
self.assertIn("white", re_recognized.tags)
2026-07-06 03:37:17 +08:00
def test_recognize_material_uses_injected_vlm_adapter(self):
class FakeVisionProvider:
provider_id = "fake_vlm"
def __init__(self):
self.requests = []
def recognize_material(self, request):
self.requests.append(request)
return VisionRecognitionResult(
provider_id=self.provider_id,
model="vision-test",
prompt="white lace blouse, product reference",
negative_prompt="body",
tags=["white", "lace", "upper"],
confidence=0.93,
description="white lace blouse",
raw_metadata={"test": True},
)
provider = FakeVisionProvider()
service = MaterialService(
MaterialRepository(self.database),
self.audit_service,
vision_provider_factory=lambda route: provider,
)
category = service.create_category({"name": "Upper"}, self.ctx)
uploaded = service.upload_material(
{
"category_id": category.category_id,
"filename": "white_blouse.png",
"image_uri": "storage://materials/white_blouse.png",
"recognition_model_route": "material_vlm",
},
self.ctx,
)
recognized = service.recognize_material(uploaded.material_id, self.ctx)
self.assertEqual(provider.requests[0].display_name, "white blouse")
self.assertEqual(recognized.prompt, "white lace blouse, product reference")
self.assertEqual(recognized.negative_prompt, "body")
self.assertIn("lace", recognized.tags)
self.assertEqual(recognized.metadata["recognition"]["provider_id"], "fake_vlm")
self.assertEqual(recognized.metadata["recognition"]["model"], "vision-test")
self.assertEqual(recognized.metadata["recognition"]["route_name"], "material_vlm")
self.assertFalse(recognized.metadata["recognition"]["fallback_used"])
def test_recognize_material_falls_back_when_vlm_adapter_fails(self):
class FailingVisionProvider:
provider_id = "broken_vlm"
def recognize_material(self, request):
raise VisionProviderError(
"vision endpoint timeout",
provider_id=self.provider_id,
error_type="timeout",
details={"retryable": True},
)
service = MaterialService(
MaterialRepository(self.database),
self.audit_service,
vision_provider_factory=lambda route: FailingVisionProvider(),
)
category = service.create_category({"name": "Upper"}, self.ctx)
uploaded = service.upload_material(
{
"category_id": category.category_id,
"filename": "white_blouse.png",
"image_uri": "storage://materials/white_blouse.png",
},
self.ctx,
)
recognized = service.recognize_material(uploaded.material_id, self.ctx)
self.assertIn("white", recognized.tags)
self.assertEqual(recognized.metadata["recognition"]["provider_id"], "mock")
self.assertTrue(recognized.metadata["recognition"]["fallback_used"])
self.assertEqual(recognized.metadata["recognition"]["provider_error"]["provider_id"], "broken_vlm")
self.assertEqual(recognized.metadata["recognition"]["provider_error"]["error_type"], "timeout")
2026-07-06 03:28:34 +08:00
def test_upload_rejects_unsafe_filename(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
with self.assertRaises(ApiError) as caught:
self.material_service.upload_material(
{
"category_id": category.category_id,
"filename": "../white_blouse.png",
"image_uri": "storage://materials/white_blouse.png",
},
self.ctx,
)
self.assertEqual(caught.exception.error_code, ErrorCode.VALIDATION_FAILED)
self.assertEqual(caught.exception.details["field"], "filename")
def test_upload_rejects_unsupported_file_type(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
with self.assertRaises(ApiError) as caught:
self.material_service.upload_material(
{
"category_id": category.category_id,
"filename": "white_blouse.gif",
"content_type": "image/gif",
"image_uri": "storage://materials/white_blouse.gif",
},
self.ctx,
)
self.assertEqual(caught.exception.error_code, ErrorCode.UNSUPPORTED_FILE_TYPE)
def test_upload_rejects_mismatched_content_type(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
with self.assertRaises(ApiError) as caught:
self.material_service.upload_material(
{
"category_id": category.category_id,
"filename": "white_blouse.jpg",
"content_type": "image/png",
"image_uri": "storage://materials/white_blouse.jpg",
},
self.ctx,
)
self.assertEqual(caught.exception.error_code, ErrorCode.UNSUPPORTED_FILE_TYPE)
self.assertEqual(caught.exception.details["field"], "content_type")
def test_upload_rejects_oversized_payload(self):
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
with self.assertRaises(ApiError) as caught:
self.material_service.upload_material(
{
"category_id": category.category_id,
"filename": "white_blouse.png",
"content_type": "image/png",
"size_bytes": MAX_UPLOAD_BYTES + 1,
"image_uri": "storage://materials/white_blouse.png",
},
self.ctx,
)
self.assertEqual(caught.exception.error_code, ErrorCode.UPLOAD_TOO_LARGE)
self.assertEqual(caught.exception.details["max_size_bytes"], MAX_UPLOAD_BYTES)
2026-07-05 09:52:13 +08:00
def test_material_routes_wrap_responses_and_require_permission(self):
category = create_material_category(self.ctx, {"name": "Accessory"}, self.material_service)
self.assertTrue(category["ok"])
category_id = category["data"]["category_id"]
categories = list_material_categories(self.ctx, self.material_service)
self.assertTrue(categories["ok"])
self.assertEqual(len(categories["data"]), 1)
2026-07-05 20:48:15 +08:00
(self.root / "materials" / "ribbon.png").write_bytes(b"ribbon")
2026-07-05 09:52:13 +08:00
material = create_material(
self.ctx,
{
"category_id": category_id,
"display_name": "Blue ribbon",
"image_uri": "storage://materials/ribbon.png",
},
self.material_service,
2026-07-05 20:48:15 +08:00
self.media_service,
2026-07-05 09:52:13 +08:00
)
self.assertTrue(material["ok"])
material_id = material["data"]["material_id"]
2026-07-05 20:48:15 +08:00
self.assertTrue(material["data"]["image_url"].startswith("/api/v1/plugins/extensions/"))
self.assertIsNone(material["data"]["thumbnail_url"])
self.assertNotIn(str(self.root), str(material["data"]))
2026-07-05 09:52:13 +08:00
2026-07-05 20:48:15 +08:00
detail = get_material(self.ctx, material_id, self.material_service, self.media_service)
2026-07-05 09:52:13 +08:00
self.assertTrue(detail["ok"])
2026-07-05 20:48:15 +08:00
self.assertTrue(detail["data"]["image_url"].startswith("/api/v1/plugins/extensions/"))
2026-07-05 09:52:13 +08:00
updated = update_material(self.ctx, material_id, {"recognition_status": "confirmed"}, self.material_service)
self.assertTrue(updated["ok"])
self.assertEqual(updated["data"]["recognition_status"], "confirmed")
2026-07-05 20:48:15 +08:00
listed = list_materials(self.ctx, {"keyword": "ribbon"}, self.material_service, self.media_service)
2026-07-05 09:52:13 +08:00
self.assertTrue(listed["ok"])
self.assertEqual(listed["data"]["total"], 1)
2026-07-05 20:48:15 +08:00
self.assertTrue(listed["data"]["items"][0]["image_url"].startswith("/api/v1/plugins/extensions/"))
2026-07-05 20:58:26 +08:00
self.assertNotIn(str(self.root), str(listed["data"]["items"][0]))
2026-07-05 09:52:13 +08:00
read_only = RequestContext.from_astrbot(username="viewer", user_id="viewer_001")
denied = create_material(read_only, {"display_name": "Denied"}, self.material_service)
self.assertFalse(denied["ok"])
self.assertEqual(denied["error_code"], "FORBIDDEN")
deleted = delete_material(self.ctx, material_id, self.material_service)
self.assertTrue(deleted["ok"])
missing = get_material(self.ctx, material_id, self.material_service)
self.assertFalse(missing["ok"])
self.assertEqual(missing["error_code"], "RESOURCE_NOT_FOUND")
def test_material_upload_recognize_confirm_routes(self):
category = create_material_category(self.ctx, {"name": "Dress"}, self.material_service)
2026-07-05 20:58:26 +08:00
(self.root / "materials" / "blue_dress.png").write_bytes(b"blue dress")
uploaded = upload_material(
self.ctx,
{
"category_id": category["data"]["category_id"],
"filename": "blue_dress.png",
"image_uri": "storage://materials/blue_dress.png",
},
self.material_service,
2026-07-05 20:58:26 +08:00
self.media_service,
)
self.assertTrue(uploaded["ok"])
self.assertEqual(uploaded["data"]["recognition_status"], "pending_recognition")
2026-07-05 20:58:26 +08:00
self.assertTrue(uploaded["data"]["image_url"].startswith("/api/v1/plugins/extensions/"))
self.assertTrue(uploaded["data"]["thumbnail_url"].startswith("/api/v1/plugins/extensions/"))
self.assertNotIn(str(self.root), str(uploaded["data"]))
2026-07-06 03:28:34 +08:00
rejected = upload_material(
self.ctx,
{
"category_id": category["data"]["category_id"],
"filename": "blue_dress.exe",
"content_type": "application/octet-stream",
"image_uri": "storage://materials/blue_dress.exe",
},
self.material_service,
self.media_service,
)
self.assertFalse(rejected["ok"])
self.assertEqual(rejected["error_code"], "UNSUPPORTED_FILE_TYPE")
material_id = uploaded["data"]["material_id"]
2026-07-05 20:58:26 +08:00
recognized = recognize_material(self.ctx, material_id, self.material_service, self.media_service)
self.assertTrue(recognized["ok"])
self.assertEqual(recognized["data"]["recognition_status"], "pending_confirm")
self.assertIn("blue", recognized["data"]["tags"])
2026-07-05 20:58:26 +08:00
self.assertTrue(recognized["data"]["image_url"].startswith("/api/v1/plugins/extensions/"))
self.assertTrue(recognized["data"]["thumbnail_url"].startswith("/api/v1/plugins/extensions/"))
self.assertNotIn(str(self.root), str(recognized["data"]))
confirmed = confirm_material(
self.ctx,
material_id,
{"display_name": "Blue dress", "tags": ["dress", "blue"]},
self.material_service,
2026-07-05 20:58:26 +08:00
self.media_service,
)
self.assertTrue(confirmed["ok"])
self.assertEqual(confirmed["data"]["recognition_status"], "confirmed")
2026-07-05 20:58:26 +08:00
self.assertTrue(confirmed["data"]["image_url"].startswith("/api/v1/plugins/extensions/"))
self.assertTrue(confirmed["data"]["thumbnail_url"].startswith("/api/v1/plugins/extensions/"))
self.assertNotIn(str(self.root), str(confirmed["data"]))
2026-07-05 20:58:26 +08:00
re_recognized = re_recognize_material(self.ctx, material_id, self.material_service, self.media_service)
2026-07-05 17:24:35 +08:00
self.assertTrue(re_recognized["ok"])
self.assertEqual(re_recognized["data"]["recognition_status"], "pending_confirm")
2026-07-05 20:58:26 +08:00
self.assertTrue(re_recognized["data"]["image_url"].startswith("/api/v1/plugins/extensions/"))
self.assertTrue(re_recognized["data"]["thumbnail_url"].startswith("/api/v1/plugins/extensions/"))
self.assertNotIn(str(self.root), str(re_recognized["data"]))
2026-07-05 17:24:35 +08:00
2026-07-05 09:52:13 +08:00
if __name__ == "__main__":
unittest.main()