593 行
26 KiB
Python
593 行
26 KiB
Python
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 core.storage import VfsStorage
|
|
from database.db_helper import Database, DatabaseSettings, SqliteSettings
|
|
from database.repositories.material_repository import MaterialRepository
|
|
from engines.vision_provider import MockVisionProvider, VisionProviderError, VisionRecognitionResult
|
|
|
|
|
|
PNG_BYTES = b"\x89PNG\r\n\x1a\n" + (b"\x00" * 24)
|
|
GIF_BYTES = b"GIF89a\x01\x00\x01\x00\x00\x00\x00;"
|
|
|
|
|
|
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.config_service = ConfigService(self.config_path)
|
|
self.storage = VfsStorage(self.config_service)
|
|
self.material_service = MaterialService(
|
|
MaterialRepository(self.database),
|
|
self.audit_service,
|
|
vision_provider_factory=lambda route: MockVisionProvider(),
|
|
storage=self.storage,
|
|
)
|
|
self.media_service = MediaService(self.config_service)
|
|
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)
|
|
(self.root / "materials" / "white_blouse.png").write_bytes(PNG_BYTES)
|
|
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,
|
|
storage=self.storage,
|
|
)
|
|
category = service.create_category({"name": "Upper"}, self.ctx)
|
|
(self.root / "materials" / "white_blouse.png").write_bytes(PNG_BYTES)
|
|
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.assertTrue(provider.requests[0].image_uri.startswith("data:image/png;base64,"))
|
|
self.assertNotIn("storage://", provider.requests[0].image_uri)
|
|
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_keeps_pending_state_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(),
|
|
storage=self.storage,
|
|
)
|
|
category = service.create_category({"name": "Upper"}, self.ctx)
|
|
(self.root / "materials" / "white_blouse.png").write_bytes(PNG_BYTES)
|
|
uploaded = service.upload_material(
|
|
{
|
|
"category_id": category.category_id,
|
|
"filename": "white_blouse.png",
|
|
"image_uri": "storage://materials/white_blouse.png",
|
|
},
|
|
self.ctx,
|
|
)
|
|
|
|
with self.assertRaises(ApiError) as caught:
|
|
service.recognize_material(uploaded.material_id, self.ctx)
|
|
|
|
self.assertEqual(caught.exception.error_code, ErrorCode.GENERATION_FAILED)
|
|
failed = service.get_material(uploaded.material_id)
|
|
self.assertEqual(failed.recognition_status, "pending_recognition")
|
|
self.assertIsNone(failed.prompt)
|
|
self.assertEqual(failed.tags, [])
|
|
self.assertNotIn("recognition", failed.metadata)
|
|
failure = failed.metadata["recognition_failure"]
|
|
self.assertEqual(failure["provider_id"], "broken_vlm")
|
|
self.assertEqual(failure["error_type"], "timeout")
|
|
self.assertTrue(failure["retryable"])
|
|
self.assertNotIn("details", failure)
|
|
self.assertNotIn("message", failure)
|
|
|
|
def test_recognize_material_requires_a_configured_vision_route(self):
|
|
service = MaterialService(
|
|
MaterialRepository(self.database),
|
|
self.audit_service,
|
|
storage=self.storage,
|
|
)
|
|
category = service.create_category({"name": "Upper"}, self.ctx)
|
|
(self.root / "materials" / "white_blouse.png").write_bytes(PNG_BYTES)
|
|
uploaded = service.upload_material(
|
|
{
|
|
"category_id": category.category_id,
|
|
"filename": "white_blouse.png",
|
|
"image_uri": "storage://materials/white_blouse.png",
|
|
},
|
|
self.ctx,
|
|
)
|
|
|
|
with self.assertRaises(ApiError) as caught:
|
|
service.recognize_material(uploaded.material_id, self.ctx)
|
|
|
|
self.assertEqual(caught.exception.error_code, ErrorCode.MODEL_CAPABILITY_UNCONFIRMED)
|
|
self.assertEqual(service.get_material(uploaded.material_id).recognition_status, "pending_recognition")
|
|
routed = recognize_material(self.ctx, uploaded.material_id, service, self.media_service)
|
|
self.assertFalse(routed["ok"])
|
|
self.assertEqual(routed["error_code"], "MODEL_CAPABILITY_UNCONFIRMED")
|
|
|
|
def test_recognize_material_rejects_file_signature_mismatch(self):
|
|
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
|
|
(self.root / "materials" / "not_png.png").write_bytes(b"not an image")
|
|
uploaded = self.material_service.upload_material(
|
|
{
|
|
"category_id": category.category_id,
|
|
"filename": "not_png.png",
|
|
"image_uri": "storage://materials/not_png.png",
|
|
},
|
|
self.ctx,
|
|
)
|
|
|
|
with self.assertRaises(ApiError) as caught:
|
|
self.material_service.recognize_material(uploaded.material_id, self.ctx)
|
|
|
|
self.assertEqual(caught.exception.error_code, ErrorCode.UNSUPPORTED_FILE_TYPE)
|
|
|
|
def test_recognize_material_rejects_actual_file_over_size_limit(self):
|
|
category = self.material_service.create_category({"name": "Upper"}, self.ctx)
|
|
image_path = self.root / "materials" / "too_large.png"
|
|
with image_path.open("wb") as handle:
|
|
handle.seek(MAX_UPLOAD_BYTES)
|
|
handle.write(b"\x00")
|
|
uploaded = self.material_service.upload_material(
|
|
{
|
|
"category_id": category.category_id,
|
|
"filename": "too_large.png",
|
|
"image_uri": "storage://materials/too_large.png",
|
|
},
|
|
self.ctx,
|
|
)
|
|
|
|
with self.assertRaises(ApiError) as caught:
|
|
self.material_service.recognize_material(uploaded.material_id, 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_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.bmp",
|
|
"content_type": "image/bmp",
|
|
"image_uri": "storage://materials/white_blouse.bmp",
|
|
},
|
|
self.ctx,
|
|
)
|
|
|
|
self.assertEqual(caught.exception.error_code, ErrorCode.UNSUPPORTED_FILE_TYPE)
|
|
|
|
def test_gif_material_recognition_uses_matching_data_url_mime(self):
|
|
class GifVisionProvider:
|
|
provider_id = "gif_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="animated ribbon reference",
|
|
negative_prompt=None,
|
|
tags=["ribbon"],
|
|
confidence=0.9,
|
|
description="ribbon",
|
|
)
|
|
|
|
provider = GifVisionProvider()
|
|
service = MaterialService(
|
|
MaterialRepository(self.database),
|
|
self.audit_service,
|
|
vision_provider_factory=lambda route: provider,
|
|
storage=self.storage,
|
|
)
|
|
category = service.create_category({"name": "Accessory"}, self.ctx)
|
|
(self.root / "materials" / "ribbon.gif").write_bytes(GIF_BYTES)
|
|
uploaded = service.upload_material(
|
|
{
|
|
"category_id": category.category_id,
|
|
"filename": "ribbon.gif",
|
|
"content_type": "image/gif",
|
|
"image_uri": "storage://materials/ribbon.gif",
|
|
},
|
|
self.ctx,
|
|
)
|
|
|
|
recognized = service.recognize_material(uploaded.material_id, self.ctx)
|
|
|
|
self.assertTrue(provider.requests[0].image_uri.startswith("data:image/gif;base64,"))
|
|
self.assertEqual(provider.requests[0].metadata["vision_input"]["content_type"], "image/gif")
|
|
self.assertEqual(recognized.recognition_status, "pending_confirm")
|
|
|
|
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": "配饰"}, self.material_service)
|
|
self.assertTrue(category["ok"])
|
|
category_id = category["data"]["category_id"]
|
|
child_category = create_material_category(
|
|
self.ctx,
|
|
{"name": "头部", "parent_id": category_id, "category_type": "accessory_group"},
|
|
self.material_service,
|
|
)
|
|
self.assertTrue(child_category["ok"])
|
|
self.assertEqual(child_category["data"]["parent_id"], category_id)
|
|
self.assertEqual(child_category["data"]["category_type"], "accessory_group")
|
|
|
|
categories = list_material_categories(self.ctx, self.material_service)
|
|
self.assertTrue(categories["ok"])
|
|
self.assertEqual(len(categories["data"]), 2)
|
|
self.assertTrue(any(item["name"] == "头部" and item["parent_id"] == category_id for item in categories["data"]))
|
|
|
|
bad_child = create_material_category(
|
|
self.ctx,
|
|
{"name": "断链分类", "parent_id": "cat_missing", "category_type": "accessory_group"},
|
|
self.material_service,
|
|
)
|
|
self.assertFalse(bad_child["ok"])
|
|
self.assertEqual(bad_child["error_code"], "RESOURCE_NOT_FOUND")
|
|
|
|
(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/plug/"))
|
|
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/plug/"))
|
|
|
|
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/plug/"))
|
|
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(PNG_BYTES)
|
|
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/plug/"))
|
|
self.assertTrue(uploaded["data"]["thumbnail_url"].startswith("/api/plug/"))
|
|
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/plug/"))
|
|
self.assertTrue(recognized["data"]["thumbnail_url"].startswith("/api/plug/"))
|
|
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/plug/"))
|
|
self.assertTrue(confirmed["data"]["thumbnail_url"].startswith("/api/plug/"))
|
|
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/plug/"))
|
|
self.assertTrue(re_recognized["data"]["thumbnail_url"].startswith("/api/plug/"))
|
|
self.assertNotIn(str(self.root), str(re_recognized["data"]))
|
|
|
|
|
|
if __name__ == "__main__":
|
|
unittest.main()
|