# -*- coding: utf-8 -*- """Focused proof that enabled P5-C Companion sinks deny before egress.""" from __future__ import annotations import importlib import inspect import json from pathlib import Path import sys from types import SimpleNamespace import types import unittest sys.path.insert(0, str(Path(__file__).resolve().parent)) import _host_stub # noqa: E402 _host_stub.install() event_module = importlib.import_module("astrbot.api.event") event_module.filter.EventMessageType = SimpleNamespace( ALL="ALL", PRIVATE_MESSAGE="PRIVATE_MESSAGE", GROUP_MESSAGE="GROUP_MESSAGE" ) PACKAGE = "_p5c_gate_companion" if PACKAGE not in sys.modules: package = types.ModuleType(PACKAGE) package.__path__ = [str(Path(__file__).resolve().parents[1])] sys.modules[PACKAGE] = package gate = importlib.import_module(f"{PACKAGE}.p5c_gate") main = importlib.import_module(f"{PACKAGE}.main") private_image = importlib.import_module(f"{PACKAGE}.private_image") forward = importlib.import_module(f"{PACKAGE}.forward_message") tool_actions = importlib.import_module(f"{PACKAGE}.llm_tool_actions") class _Host: enable_p5c_raw_image_provider_gate = True enable_p5c_group_image_vision_gate = True enable_p5c_context_image_caption_gate = True enable_p5c_tool_parameter_gate = True class _ImageHost(_Host): async def _prepare_private_image_sources_for_model(self, *_args, **_kwargs): raise AssertionError("enabled raw-image gate must stop before image preparation") class _ForwardHost(_Host): forward_message_image_vision = True async def _prepare_private_image_sources_for_model(self, *_args, **_kwargs): raise AssertionError("enabled forward-image gate must stop before image preparation") class _ToolHost(_Host): def _atrelay_target_umo_candidates(self, *_args, **_kwargs): raise AssertionError("enabled tool gate must stop before target resolution") class P5CCompanionGateTests(unittest.IsolatedAsyncioTestCase): async def test_default_off_does_not_change_paths_and_audit_has_no_carrier_values(self) -> None: off = SimpleNamespace() self.assertTrue(gate.p5c_gate_allows(off, gate.RAW_IMAGE_PROVIDER_SINK)) host = _Host() host.event = "event-secret" self.assertFalse(gate.p5c_gate_allows(host, gate.RAW_IMAGE_PROVIDER_SINK)) audit = host._p5c_denial_audit[-1] self.assertEqual( {"sink", "outcome", "reason_code", "ref_hash"}, set(audit), ) self.assertNotIn("event-secret", repr(audit)) bound = _Host() bound._p5c_gate_allows = main.PrivateCompanionPlugin._p5c_gate_allows.__get__(bound, _Host) self.assertFalse(bound._p5c_gate_allows(gate.TOOL_PARAMETER_SINK)) async def test_enabled_media_sinks_stop_before_prepare_task_and_context_mutation(self) -> None: image_host = _ImageHost() result = await private_image.PrivateImageMixin._transcribe_private_inbound_images( image_host, ["https://example.invalid/raw.png"] ) self.assertEqual("", result) group_host = _Host() group_request = SimpleNamespace(system_prompt="unchanged", prompt="") appended = await private_image.PrivateImageMixin._append_group_image_understanding_to_request( group_host, SimpleNamespace(), group_request ) self.assertFalse(appended) self.assertEqual("unchanged", group_request.system_prompt) context_host = _Host() caption = await private_image.PrivateImageMixin._caption_context_image_sources( context_host, ["https://example.invalid/context.png"] ) self.assertEqual("", caption) task = private_image.PrivateImageMixin._start_group_image_understanding( group_host, SimpleNamespace() ) self.assertIsNone(task) request = SimpleNamespace(contexts=["[image placeholder]"]) result = await private_image.PrivateImageMixin._enrich_request_context_image_placeholders( context_host, SimpleNamespace(), request ) self.assertEqual({"contexts": 0, "replaced": 0, "missed": 0}, result) self.assertEqual(["[image placeholder]"], request.contexts) forward_host = _ForwardHost() result = await forward.ForwardMessageMixin._transcribe_forward_message_images( forward_host, SimpleNamespace(), ["https://example.invalid/forward.png"] ) self.assertEqual("", result) async def test_enabled_tool_gate_stops_before_target_resolution_and_final_send(self) -> None: host = _ToolHost() result = await tool_actions.LlmToolActionsMixin._pc_send_to_group_impl( host, SimpleNamespace(), message="secret", group_id="123" ) self.assertEqual(gate.P5C_CONTROLLED_DENY_REASON, result) ok, reason, used_umo = await tool_actions.LlmToolActionsMixin._send_atrelay_chain_to_target( host, SimpleNamespace(), message_type="group", target_id="123", chain=[], ) self.assertFalse(ok) self.assertEqual(gate.P5C_CONTROLLED_DENY_REASON, reason) self.assertEqual("", used_umo) scheduled = await tool_actions.LlmToolActionsMixin._pc_schedule_group_relay_impl( host, SimpleNamespace(), message="secret", group_id="123" ) self.assertEqual(gate.P5C_CONTROLLED_DENY_REASON, scheduled) async def test_direct_raw_mount_is_gated_before_source_preparation_and_schema_is_default_off(self) -> None: source = inspect.getsource(main.PrivateCompanionPlugin.inject_humanized_state) buffered_start = source.index("direct_image_mounted = False") direct_start = source.index('buffered_image_mode == "direct"', buffered_start) gate_at = source.index("raw_image_provider_allowed = self._p5c_gate_allows(RAW_IMAGE_PROVIDER_SINK)", buffered_start) prepare_at = source.index("self._private_image_sources_for_astrbot_request", direct_start) self.assertLess(gate_at, direct_start) self.assertLess(gate_at, prepare_at) fallback_start = source.index('"image.fallback"', direct_start) fallback_end = source.index('elif bool(getattr(event, "private_companion_deferred_private_image_only_ready"', fallback_start) fallback = source[fallback_start:fallback_end] self.assertIn("if raw_image_provider_allowed else \"\"", fallback) self.assertNotIn('"\\n".join(f"- {path}" for path in buffered_images),', fallback) schema = json.loads((Path(__file__).resolve().parents[1] / "_conf_schema.json").read_text(encoding="utf-8")) items = schema["p5c_safety_config"]["items"] self.assertEqual(set(gate.P5C_SINK_FLAGS.values()), set(items)) self.assertTrue(all(entry["default"] is False for entry in items.values())) if __name__ == "__main__": unittest.main()