astrbot_plugin_imagestudio/tests/test_core_modules.py

173 行
7.2 KiB
Python

from __future__ import annotations
import os
import unittest
from core.event_bus import EventBus
from core.fsm import node_transition, task_transition, workflow_transition
from core.interactions import build_default_actions, filter_actions_for_permissions, normalize_action
from core.interop import PRIVATE_COMPANION, daily_outfit_request, is_allowed_plugin, normalize_plugin_request
from core.model_router import ModelRoute, route_from_capability_profile, select_model_route
from core.prompt_pipeline import PromptPart, compose_prompt, merge_prompt_sections
from core.queue_manager import QueueManager
from core.secret_service import MASK, env_ref, redact, resolve_env_value
from core.webhook import WebhookEvent, sign_event, to_sse, verify_signature
class EventBusTests(unittest.TestCase):
def test_publish_notifies_specific_and_wildcard_handlers(self):
bus = EventBus()
received = []
bus.subscribe("workflow.started", lambda event: received.append(("specific", event.event_type)))
bus.subscribe("*", lambda event: received.append(("wildcard", event.payload["workflow_id"])))
event = bus.publish("workflow.started", {"workflow_id": "workflow_001"})
self.assertEqual(event.event_type, "workflow.started")
self.assertEqual(received, [("specific", "workflow.started"), ("wildcard", "workflow_001")])
self.assertEqual(bus.history("workflow.started")[0].event_id, event.event_id)
class FsmTests(unittest.TestCase):
def test_known_state_transitions_are_checked(self):
self.assertTrue(workflow_transition("draft", "running").allowed)
self.assertFalse(workflow_transition("archived", "running").allowed)
self.assertTrue(node_transition("failed", "queued").allowed)
self.assertFalse(task_transition("succeeded", "queued").allowed)
class QueueManagerTests(unittest.TestCase):
def test_queue_is_idempotent_and_tracks_retry(self):
queue = QueueManager()
first = queue.enqueue({"prompt": "portrait"}, idempotency_key="idem_001")
second = queue.enqueue({"prompt": "portrait"}, idempotency_key="idem_001")
self.assertEqual(first.task_id, second.task_id)
running = queue.dequeue()
self.assertIsNotNone(running)
self.assertEqual(running.status, "running")
failed = queue.fail(running.task_id, "mock failure")
self.assertEqual(failed.status, "failed")
retried = queue.retry(running.task_id)
self.assertEqual(retried.status, "queued")
self.assertEqual(queue.summary()["queued"], 1)
class PromptPipelineTests(unittest.TestCase):
def test_compose_prompt_dedupes_and_substitutes_variables(self):
result = compose_prompt(
["portrait of {name}", "portrait of {name}", PromptPart("soft light", weight=1.2)],
negative_parts=["low quality"],
variables={"name": "Nova"},
)
self.assertEqual(result.prompt, "portrait of Nova, (soft light:1.2)")
self.assertEqual(result.negative_prompt, "low quality")
def test_merge_prompt_sections_combines_positive_and_negative(self):
result = merge_prompt_sections(
{"prompt": "anime", "negative_prompt": "blur"},
{"parts": ["clean line"], "negative_parts": ["noise"]},
)
self.assertEqual(result.parts, ["anime", "clean line"])
self.assertEqual(result.negative_parts, ["blur", "noise"])
class ModelRouterTests(unittest.TestCase):
def test_unconfirmed_route_is_not_treated_as_supported(self):
selection = select_model_route(
[ModelRoute("local", "draft", status="unconfirmed", capabilities={"text_to_image"})],
required_capabilities=["text_to_image"],
)
self.assertFalse(selection.valid)
self.assertEqual(selection.status, "unconfirmed")
def test_supported_route_wins_by_priority(self):
selection = select_model_route(
[
ModelRoute("slow", "model", status="confirmed_supported", capabilities={"text_to_image"}, priority=20),
ModelRoute("fast", "model", status="confirmed_supported", capabilities={"text_to_image"}, priority=5),
],
required_capabilities=["text_to_image"],
)
self.assertTrue(selection.valid)
self.assertEqual(selection.selected.provider_id, "fast")
def test_route_can_be_built_from_capability_profile(self):
route = route_from_capability_profile(
{
"provider_id": "p",
"model_id": "m",
"status": "confirmed_supported",
"capabilities": {"supports": ["image_edit"]},
}
)
self.assertEqual(route.capabilities, {"image_edit"})
class SecretServiceTests(unittest.TestCase):
def test_redact_masks_nested_secret_values(self):
redacted = redact(
{
"database": {"dsn": "postgresql://secret"},
"security": {"integration_token_set": True, "integration_token": "abc"},
}
)
self.assertEqual(redacted["database"]["dsn"], MASK)
self.assertTrue(redacted["security"]["integration_token_set"])
self.assertEqual(redacted["security"]["integration_token"], MASK)
def test_env_ref_reports_presence_without_value(self):
os.environ["IMAGESTUDIO_TEST_SECRET"] = "secret-value"
try:
reference = env_ref("IMAGESTUDIO_TEST_SECRET")
self.assertEqual(reference.to_dict()["value"], MASK)
self.assertEqual(resolve_env_value("env:IMAGESTUDIO_TEST_SECRET"), "secret-value")
finally:
os.environ.pop("IMAGESTUDIO_TEST_SECRET", None)
class InteractionTests(unittest.TestCase):
def test_actions_are_normalized_and_filtered_by_permission(self):
action = normalize_action({"type": "open_logs", "label": "Logs"})
self.assertEqual(action.action_type, "open_logs")
actions = build_default_actions(api_base="/api/plugin")
filtered = filter_actions_for_permissions(actions, {"write"})
self.assertIn("quick_profile", [item.action_id for item in filtered])
self.assertNotIn("open_settings", [item.action_id for item in filtered])
class InteropTests(unittest.TestCase):
def test_plugin_request_normalization_and_allow_list(self):
request = normalize_plugin_request(
{"plugin_name": PRIVATE_COMPANION, "action": "daily_outfit", "payload": {"profile_id": "profile_001"}}
)
self.assertTrue(is_allowed_plugin(request.plugin_name))
self.assertEqual(request.payload["profile_id"], "profile_001")
self.assertEqual(daily_outfit_request({"profile_id": "profile_001"}).plugin_name, PRIVATE_COMPANION)
class WebhookTests(unittest.TestCase):
def test_webhook_signature_and_sse_format(self):
event = WebhookEvent("task.completed", {"task_id": "task_001"}, event_id="wh_test")
signature = sign_event(event, "secret")
self.assertTrue(verify_signature(event, "secret", signature))
self.assertFalse(verify_signature(event, "secret", "bad"))
sse = to_sse(event)
self.assertIn("event: task.completed", sse)
self.assertIn("data:", sse)
if __name__ == "__main__":
unittest.main()