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 (
|
2026-07-05 09:55:03 +08:00
|
|
|
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,
|
2026-07-05 09:55:03 +08:00
|
|
|
recognize_material,
|
2026-07-05 09:52:13 +08:00
|
|
|
update_material,
|
2026-07-05 09:55:03 +08:00
|
|
|
upload_material,
|
2026-07-05 09:52:13 +08:00
|
|
|
)
|
2026-07-05 20:48:15 +08:00
|
|
|
from backend.services.media_service import MediaService
|
2026-07-05 09:52:13 +08:00
|
|
|
from backend.services.material_service import MaterialService
|
|
|
|
|
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
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
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,
|
|
|
|
|
)
|
|
|
|
|
|
2026-07-05 20:12:52 +08:00
|
|
|
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)
|
|
|
|
|
|
2026-07-05 09:55:03 +08:00
|
|
|
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",
|
|
|
|
|
"image_uri": "storage://materials/white_blouse.png",
|
|
|
|
|
},
|
|
|
|
|
self.ctx,
|
|
|
|
|
)
|
|
|
|
|
self.assertEqual(uploaded.recognition_status, "pending_recognition")
|
|
|
|
|
self.assertEqual(uploaded.thumbnail_uri, "storage://materials/white_blouse.png")
|
|
|
|
|
|
|
|
|
|
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)
|
|
|
|
|
|
|
|
|
|
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-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")
|
|
|
|
|
|
2026-07-05 09:55:03 +08:00
|
|
|
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")
|
2026-07-05 09:55:03 +08:00
|
|
|
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,
|
2026-07-05 09:55:03 +08:00
|
|
|
)
|
|
|
|
|
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-05 09:55:03 +08:00
|
|
|
|
|
|
|
|
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)
|
2026-07-05 09:55:03 +08:00
|
|
|
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"]))
|
2026-07-05 09:55:03 +08:00
|
|
|
|
|
|
|
|
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,
|
2026-07-05 09:55:03 +08:00
|
|
|
)
|
|
|
|
|
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 09:55:03 +08:00
|
|
|
|
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()
|