astrbot_plugin_private_comp.../tests/test_p5c_gates.py

164 行
6.8 KiB
Python

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