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()