astrbot_plugin_imagestudio/tests/test_model_route_chain.py

110 行
4.2 KiB
Python

from __future__ import annotations
import unittest
from backend.services.model_provider_runtime import ModelProviderRuntime
from core.model_route_chain import (
encode_model_route_chain,
model_route_candidates,
parse_model_route_chain,
)
from engines.vision_provider import (
VisionProviderError,
VisionRecognitionRequest,
VisionRecognitionResult,
)
class _UnusedModelService:
pass
class _FailingVisionProvider:
provider_id = "plugin-vlm"
def recognize_material(self, request: VisionRecognitionRequest) -> VisionRecognitionResult:
raise VisionProviderError(
"plugin route failed",
provider_id=self.provider_id,
error_type="provider_error",
)
class _SuccessfulVisionProvider:
provider_id = "astrbot-vlm"
def recognize_material(self, request: VisionRecognitionRequest) -> VisionRecognitionResult:
return VisionRecognitionResult(
provider_id=self.provider_id,
model="vlm",
prompt="fallback prompt",
)
class ModelRouteChainTests(unittest.TestCase):
def test_legacy_routes_are_classified_without_rewriting(self) -> None:
self.assertEqual(parse_model_route_chain("plugin-route").plugin, "plugin-route")
self.assertEqual(parse_model_route_chain("astrbot:vlm").astrbot, "astrbot:vlm")
def test_two_source_chain_keeps_plugin_before_astrbot(self) -> None:
encoded = encode_model_route_chain("plugin-vlm", "astrbot:vlm")
self.assertEqual(model_route_candidates(encoded), ("plugin-vlm", "astrbot:vlm"))
def test_vision_runtime_falls_back_after_plugin_failure(self) -> None:
route = encode_model_route_chain("plugin-vlm", "astrbot:vlm")
runtime = ModelProviderRuntime(_UnusedModelService()) # type: ignore[arg-type]
providers = {
"plugin-vlm": _FailingVisionProvider(),
"astrbot:vlm": _SuccessfulVisionProvider(),
}
runtime._vision_provider_for_single_route = providers.get # type: ignore[method-assign]
provider = runtime.vision_provider_for_route({"route_name": route})
self.assertIsNotNone(provider)
result = provider.recognize_material(
VisionRecognitionRequest(display_name="sample", image_uri="data:image/png;base64,AA==")
)
self.assertEqual(result.provider_id, "astrbot-vlm")
self.assertEqual(result.raw_metadata["route_fallback_failures"][0]["provider_id"], "plugin-vlm")
def test_text_runtime_falls_back_in_source_order(self) -> None:
route = encode_model_route_chain("plugin-text", "astrbot:text")
runtime = ModelProviderRuntime(_UnusedModelService()) # type: ignore[arg-type]
def factory(candidate: str):
if candidate == "plugin-text":
def fail(_payload):
raise RuntimeError("plugin unavailable")
return fail
return lambda _payload: {"route": candidate}
runtime._structured_text_callable_for_single_route = factory # type: ignore[method-assign]
completion = runtime.structured_text_callable(route)
self.assertIsNotNone(completion)
self.assertEqual(completion({"purpose": "test"}), {"route": "astrbot:text"})
def test_structured_vision_runtime_falls_back_in_source_order(self) -> None:
route = encode_model_route_chain("plugin-review", "astrbot:review")
runtime = ModelProviderRuntime(_UnusedModelService()) # type: ignore[arg-type]
def factory(candidate: str, *, storage=None):
del storage
if candidate == "plugin-review":
def fail(_payload):
raise RuntimeError("plugin vision review unavailable")
return fail
return lambda _payload: {"route": candidate, "action": "allow"}
runtime._structured_vision_callable_for_single_route = factory # type: ignore[method-assign]
review = runtime.structured_vision_callable(route)
self.assertIsNotNone(review)
self.assertEqual(
review({"image": {"image_uri": "data:image/png;base64,AA=="}}),
{"route": "astrbot:review", "action": "allow"},
)
if __name__ == "__main__":
unittest.main()