from __future__ import annotations import tempfile import unittest from pathlib import Path from backend.routes.material_routes import ( confirm_material, create_material, create_material_category, delete_material, get_material, list_material_categories, list_materials, re_recognize_material, recognize_material, update_material, upload_material, ) from backend.dto.common import ApiError, ErrorCode from backend.services.media_service import MediaService from backend.services.material_service import MAX_UPLOAD_BYTES, MaterialService from core.audit_service import AuditService from core.config_service import ConfigService from core.identity import RequestContext from database.db_helper import Database, DatabaseSettings, SqliteSettings from database.repositories.material_repository import MaterialRepository from engines.vision_provider import VisionProviderError, VisionRecognitionResult class MaterialServiceTests(unittest.TestCase): def setUp(self): self.tmp = tempfile.TemporaryDirectory() 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", ) self.database = Database( DatabaseSettings(sqlite=SqliteSettings(path=str(self.root / "imagestudio.db"))) ) self.database.initialize() self.audit_service = AuditService(self.database) self.material_service = MaterialService(MaterialRepository(self.database), self.audit_service) self.media_service = MediaService(ConfigService(self.config_path)) 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", "content_type": "image/png; charset=binary", "size_bytes": "2048", "image_uri": "storage://materials/white_blouse.png", "metadata": {"source": "unit_test"}, }, self.ctx, ) self.assertEqual(uploaded.recognition_status, "pending_recognition") self.assertEqual(uploaded.thumbnail_uri, "storage://materials/white_blouse.png") 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) 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"]) 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) 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") 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) 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) (self.root / "materials" / "ribbon.png").write_bytes(b"ribbon") material = create_material( self.ctx, { "category_id": category_id, "display_name": "Blue ribbon", "image_uri": "storage://materials/ribbon.png", }, self.material_service, self.media_service, ) self.assertTrue(material["ok"]) material_id = material["data"]["material_id"] 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"])) detail = get_material(self.ctx, material_id, self.material_service, self.media_service) self.assertTrue(detail["ok"]) self.assertTrue(detail["data"]["image_url"].startswith("/api/v1/plugins/extensions/")) updated = update_material(self.ctx, material_id, {"recognition_status": "confirmed"}, self.material_service) self.assertTrue(updated["ok"]) self.assertEqual(updated["data"]["recognition_status"], "confirmed") listed = list_materials(self.ctx, {"keyword": "ribbon"}, self.material_service, self.media_service) self.assertTrue(listed["ok"]) self.assertEqual(listed["data"]["total"], 1) self.assertTrue(listed["data"]["items"][0]["image_url"].startswith("/api/v1/plugins/extensions/")) self.assertNotIn(str(self.root), str(listed["data"]["items"][0])) 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) (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, self.media_service, ) self.assertTrue(uploaded["ok"]) self.assertEqual(uploaded["data"]["recognition_status"], "pending_recognition") 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"])) 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"] 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"]) 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, self.media_service, ) self.assertTrue(confirmed["ok"]) self.assertEqual(confirmed["data"]["recognition_status"], "confirmed") 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"])) re_recognized = re_recognize_material(self.ctx, material_id, self.material_service, self.media_service) self.assertTrue(re_recognized["ok"]) self.assertEqual(re_recognized["data"]["recognition_status"], "pending_confirm") 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"])) if __name__ == "__main__": unittest.main()