astrbot_plugin_private_comp.../tests/test_p4_live_hook.py

458 行
20 KiB
Python

# -*- coding: utf-8 -*-
"""End-to-end host-seam tests for the live P4 reply path.
The real AstrBot host is replaced only at the import boundary. Effect events
use the actual unified-person registry so replay/idempotency and the live
runtime's ledger projection remain exercised together.
"""
from __future__ import annotations
import asyncio
from copy import deepcopy
import importlib
from pathlib import Path
import sys
from types import SimpleNamespace
import types
import unittest
from unittest.mock import patch
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 = "_p4_live_hook_companion"
if PACKAGE not in sys.modules:
package = types.ModuleType(PACKAGE)
package.__path__ = [str(Path(__file__).resolve().parents[1])]
sys.modules[PACKAGE] = package
main = importlib.import_module(f"{PACKAGE}.main")
contract = importlib.import_module(f"{PACKAGE}.context_orchestration")
person_contract = importlib.import_module(f"{PACKAGE}.unified_person_contract")
registry_module = importlib.import_module(f"{PACKAGE}.unified_person_registry")
runtime_gate = importlib.import_module(f"{PACKAGE}.p4_runtime_gate")
def _identity(subject_id: str) -> dict[str, str]:
return {
"companion_instance_id": "companion-live-test",
"bot_account_id": "bot-live-test",
"adapter_instance_id": "aiocqhttp-live-test",
"subject_namespace": "aiocqhttp.user",
"platform_subject_id": subject_id,
}
def _finalized_p3_state() -> dict:
state = contract.new_context_state(scope="group", created_at="2026-07-30T00:00:00.000Z")
contract.update_security(state, status="allowed", response_policy="inherit")
for layer in contract.LAYERS:
contract.complete_layer(state, layer)
contract.finalize_state(state)
assert state["finalized"] is True
return state
def _active_runtime_state() -> dict[str, str]:
return {
"schema_version": "p4.runtime_gate.state.v1",
"authority": "private_companion_p4",
"confinement_state": "active",
"confinement_until": "2099-01-01T00:00:00Z",
"warmth": "guarded",
}
def _high_risk_review(message_id: str) -> dict:
return {
"schema_version": "p4.review.v1",
"verdict": "violation",
"category": "doxxing",
"confidence": 0.99,
"risk_flags": [],
"evidence": [{
"message_id": message_id,
"code": "direct_instruction_override",
"source": "current_message",
}],
}
class _Event:
def __init__(self, *, message_id: str = "live-msg-1", text: str = "ordinary message") -> None:
self._sender_id = "sender-42"
self.message_id = message_id
self.message_str = text
self.unified_msg_origin = "aiocqhttp:group-1"
self.platform_name = "aiocqhttp"
# These payload-like fields are never a P4 authority.
self.sender_id = "forged-sender"
self.user_id = "forged-user"
self.result = None
self.stopped = False
def get_sender_id(self) -> str:
return self._sender_id
def get_group_id(self) -> str:
return "group-1"
def get_platform_name(self) -> str:
return "aiocqhttp"
def is_private_chat(self) -> bool:
return False
def set_result(self, value: object) -> None:
self.result = value
def stop_event(self) -> None:
self.stopped = True
class _ForgedEvent(_Event):
"""Prove that the final gate never reads event-controlled release claims."""
_POISONED = frozenset({
"authorized",
"owner_authorized",
"p4_state",
"p4_runtime_state",
"confinement_state",
"confinement_until",
"warmth",
})
def __getattribute__(self, name: str): # type: ignore[no-untyped-def]
if name in _ForgedEvent._POISONED:
raise AssertionError(f"forged event field was read: {name}")
return super().__getattribute__(name)
class _ToolSet:
def __init__(self) -> None:
self.cleared = False
def clear(self) -> None:
self.cleared = True
def _request() -> SimpleNamespace:
return SimpleNamespace(
system_prompt="Memory context must not reach the model",
prompt="Bridge and external context must not reach the model",
extra_user_content=[{"external": "untrusted"}],
images=["memory-image"],
image_urls=["https://external.invalid/image"],
tool_calls=[{"name": "sensitive_tool"}],
func_tool=_ToolSet(),
)
class _Plain:
def __init__(self, text: str) -> None:
self.text = text
class _LiveHost:
"""Small host with a real P4 effect registry and narrow observable seams."""
_p4_live_runtime_state_from_ledger = main.PrivateCompanionPlugin._p4_live_runtime_state_from_ledger
_p4_live_authority = main.PrivateCompanionPlugin._p4_live_authority
_p4_live_injection_candidate = staticmethod(main.PrivateCompanionPlugin._p4_live_injection_candidate)
_p4_live_candidate_for_text = main.PrivateCompanionPlugin._p4_live_candidate_for_text
_p4_live_mark_state = main.PrivateCompanionPlugin._p4_live_mark_state
_p4_live_refresh_event_state = main.PrivateCompanionPlugin._p4_live_refresh_event_state
_p4_live_clear_request_payload = staticmethod(main.PrivateCompanionPlugin._p4_live_clear_request_payload)
_p4_manual_review_expiry = staticmethod(main.PrivateCompanionPlugin._p4_manual_review_expiry)
_p4_manual_review_runtime_sender_id = staticmethod(main.PrivateCompanionPlugin._p4_manual_review_runtime_sender_id)
_p4_manual_review_attestation_registry = main.PrivateCompanionPlugin._p4_manual_review_attestation_registry
def __init__(self) -> None:
self.enable_p4_live_runtime = True
self.enable_p4_manual_review = True
self.enabled = True
self.assurance = "verified"
self.intent: dict[str, str] = {"emotion_event": "neutral", "emotion_target": "none"}
self.fail_effect_readback = False
self.effect_write_seen = False
self.effect_results: list[dict] = []
self.lifecycle_calls: list[tuple[str, tuple, dict]] = []
self.manual_candidates: dict[str, dict] = {}
self.prompt_records: list[dict] = []
self.context_collector_calls = 0
self.fail_on_context_collection = False
self.store = {"unified_person": person_contract.empty_unified_person_store()}
self.registry = registry_module.UnifiedPersonRegistry(self.store)
observed = self.registry.upsert_observed_identity(
_identity("sender-42"), operation_id="observe-live-sender-42"
)
assert observed["ok"] is True
self.person_id = observed["person_id"]
self._p4_manual_review_registry = main._new_p4_review_attestation_registry()
@staticmethod
def _p4_live_now_iso() -> str:
return "2026-07-30T12:00:00Z"
@staticmethod
def _safe_event_sender_id(event: _Event) -> str:
try:
return str(event.get_sender_id())
except Exception:
return ""
@staticmethod
def _event_message_id(event: _Event) -> str:
return str(event.message_id or "")
def _memory_companion_unified_person_authority(self, event: _Event, *, expected_user_id: str = "") -> dict:
if expected_user_id != "sender-42":
return {}
return {
"unified_person_projection": {
"person_id": self.person_id,
"profile_status": "active",
"identity_assurance": self.assurance,
},
"unified_person_source_identity": {"platform_subject_id": "sender-42"},
}
def _analyze_inbound_intent(self, text: str) -> dict:
del text
return dict(self.intent)
async def _p4_live_append_warmth_to_request(self, event: _Event, req: SimpleNamespace) -> None:
self.context_collector_calls += 1
if self.fail_on_context_collection:
raise AssertionError("P4 confinement should skip every context collector")
await main.PrivateCompanionPlugin._p4_live_append_warmth_to_request(self, event, req)
@staticmethod
def _append_turn_prompt_fragment_by_position(*args, **kwargs) -> bool:
del args, kwargs
return False
async def _record_request_prompt_fragment(self, event: _Event, **kwargs) -> None:
del event
self.prompt_records.append(deepcopy(kwargs))
@staticmethod
def _safe_event_is_private(event: _Event) -> bool:
del event
return False
@staticmethod
def _build_result_from_chain(chain: list[object]) -> list[object]:
return list(chain)
def _apply_unified_person_lifecycle(self, operation: str, *args, **kwargs) -> dict:
# Producer attestations are deliberately opaque/non-serializable. The
# host log retains only ordinary operation metadata and never attempts
# to clone the capability handle.
logged_kwargs = {
key: deepcopy(value)
for key, value in kwargs.items()
if key not in {"producer_attestation", "producer_request", "producer_event", "producer_state"}
}
self.lifecycle_calls.append((operation, args, logged_kwargs))
if operation == "read_p4_effect_state":
if self.fail_effect_readback and self.effect_write_seen:
return {"ok": False, "code": "p4_effect_readback_failed"}
return self.registry.read_p4_effect_state(args[0])
if operation == "record_p4_effect_event":
self.effect_write_seen = True
result = self.registry.record_p4_effect_event(
args[0],
args[1],
operation_id=kwargs["operation_id"],
actor_id=kwargs.get("actor_id", "system"),
)
self.effect_results.append(deepcopy(result))
return result
if operation == "record_p4_manual_review_candidate":
candidate = deepcopy(args[1])
candidate_id = candidate["candidate_id"]
if candidate_id in self.manual_candidates:
return {"ok": True, "code": "p4_review_candidate_duplicate", "candidate_id": candidate_id}
self.manual_candidates[candidate_id] = candidate
return {"ok": True, "code": "p4_review_candidate_recorded", "candidate_id": candidate_id}
return {"ok": False, "code": "unsupported_lifecycle_operation"}
def _seed_third_confinement(host: _LiveHost) -> None:
"""Build rounds 1/2/3 by replaying real high-risk effect events."""
events = [
("third-v1", "2026-07-01T00:00:00Z", "violation"),
("third-expiry-1", "2026-07-11T00:00:00Z", "confinement_expiry"),
("third-v2", "2026-07-12T00:00:00Z", "violation"),
("third-expiry-2", "2026-07-22T00:00:00Z", "confinement_expiry"),
("third-v3", "2026-07-23T00:00:00Z", "violation"),
]
for event_id, occurred_at, kind in events:
event = {"event_id": event_id, "occurred_at": occurred_at, "kind": kind}
if kind == "violation":
event["review"] = _high_risk_review(f"review-{event_id}")
result = host.registry.record_p4_effect_event(
host.person_id,
event,
operation_id=f"seed-{event_id}",
actor_id="p4-live-hook-test",
)
assert result["ok"] is True
class P4LiveHookTests(unittest.TestCase):
def test_live_hook_writes_effect_ledger_and_replay_is_idempotent(self) -> None:
host = _LiveHost()
event = _Event(message_id="replay-message", text="hello")
asyncio.run(main.PrivateCompanionPlugin.observe_p4_live_inbound(host, event))
first = host.registry.read_p4_effect_state(host.person_id)
self.assertTrue(first["ok"])
self.assertEqual(1, first["event_count"])
self.assertEqual("normal", first["p4_effect_state"]["event_log"][0]["kind"])
first_event_id = first["p4_effect_state"]["event_log"][0]["event_id"]
asyncio.run(main.PrivateCompanionPlugin.observe_p4_live_inbound(host, event))
replay = host.registry.read_p4_effect_state(host.person_id)
self.assertEqual(1, replay["event_count"])
self.assertEqual(first_event_id, replay["p4_effect_state"]["event_log"][0]["event_id"])
self.assertEqual(2, len(host.effect_results))
self.assertTrue(host.effect_results[-1].get("idempotent"))
def test_positive_event_projects_warmth_fragment_without_security_change(self) -> None:
host = _LiveHost()
host.intent = {"emotion_event": "praise", "emotion_target": "bot"}
event = _Event(message_id="warm-message", text="thank you")
request = _request()
asyncio.run(main.PrivateCompanionPlugin.prepare_p4_live_runtime_request(host, event, request))
effect = host.registry.read_p4_effect_state(host.person_id)
self.assertEqual(1, effect["p4_effect_state"]["score"])
runtime_state = getattr(event, "_private_companion_p4_live_runtime_state")
self.assertEqual("warm", runtime_state["warmth"])
self.assertEqual(
{"schema_version", "authority", "confinement_state", "confinement_until", "warmth"},
set(runtime_state),
)
asyncio.run(host._p4_live_append_warmth_to_request(event, request))
self.assertIn("<!-- private_companion_p4_warmth_v1 -->", request.system_prompt)
self.assertEqual("warm", host.prompt_records[-1]["metadata"]["tier"])
self.assertFalse(getattr(event, "_private_companion_p4_confinement_active"))
def test_active_and_invalid_state_skip_collectors_and_send_fixed_reply(self) -> None:
# Active state: skip Memory/Bridge/tool/external collectors before they
# can consume the request, then seal the result immediately before send.
host = _LiveHost()
host.fail_on_context_collection = True
active_event = _Event(message_id="active-message")
setattr(active_event, "_private_companion_p4_confinement_active", True)
active_request = _request()
asyncio.run(main.PrivateCompanionPlugin.inject_humanized_state(host, active_event, active_request))
self.assertEqual(0, host.context_collector_calls)
self._assert_request_cleared(active_request)
setattr(active_event, "_private_companion_p4_live_scope_resolved", True)
setattr(active_event, "_private_companion_p4_live_runtime_state", _active_runtime_state())
asyncio.run(main.PrivateCompanionPlugin.enforce_p4_live_confinement_request(host, active_event, active_request))
self._assert_request_cleared(active_request)
self._assert_fixed_reply_before_send(host, active_event)
# The event was written, but an authoritative post-write effect read
# failed. The live hook must mark it as invalid/active, skip collectors,
# and block at the final gate rather than use its stale pre-write state.
invalid_host = _LiveHost()
invalid_host.fail_effect_readback = True
invalid_event = _Event(message_id="invalid-readback")
asyncio.run(main.PrivateCompanionPlugin.observe_p4_live_inbound(invalid_host, invalid_event))
persisted = invalid_host.registry.read_p4_effect_state(invalid_host.person_id)
self.assertEqual(1, persisted["event_count"])
self.assertTrue(getattr(invalid_event, "_private_companion_p4_live_state_invalid"))
self.assertTrue(getattr(invalid_event, "_private_companion_p4_confinement_active"))
self.assertIsNone(getattr(invalid_event, "_private_companion_p4_live_runtime_state"))
invalid_host.fail_on_context_collection = True
invalid_request = _request()
asyncio.run(main.PrivateCompanionPlugin.inject_humanized_state(invalid_host, invalid_event, invalid_request))
self.assertEqual(0, invalid_host.context_collector_calls)
self._assert_request_cleared(invalid_request)
asyncio.run(main.PrivateCompanionPlugin.enforce_p4_live_confinement_request(invalid_host, invalid_event, invalid_request))
self._assert_fixed_reply_before_send(invalid_host, invalid_event)
def test_forged_event_fields_cannot_release_active_confinement(self) -> None:
host = _LiveHost()
event = _ForgedEvent(message_id="forged-release")
# They are deliberately poisoned if the gate attempts to inspect them.
object.__setattr__(event, "authorized", True)
object.__setattr__(event, "owner_authorized", True)
object.__setattr__(event, "p4_state", {"confinement_state": "none"})
object.__setattr__(event, "p4_runtime_state", {"confinement_state": "none"})
object.__setattr__(event, "confinement_state", "none")
object.__setattr__(event, "confinement_until", "")
object.__setattr__(event, "warmth", "close")
setattr(event, "_private_companion_p4_live_scope_resolved", True)
setattr(event, "_private_companion_p4_live_runtime_state", _active_runtime_state())
request = _request()
asyncio.run(main.PrivateCompanionPlugin.enforce_p4_live_confinement_request(host, event, request))
self.assertTrue(getattr(event, "_private_companion_p4_confinement_active"))
self._assert_request_cleared(request)
self._assert_fixed_reply_before_send(host, event)
def test_third_confinement_reads_effect_state_and_emits_one_candidate(self) -> None:
host = _LiveHost()
_seed_third_confinement(host)
effect = host.registry.read_p4_effect_state(host.person_id)
self.assertEqual("active", effect["p4_effect_state"]["confinement_state"])
self.assertEqual(3, effect["p4_effect_state"]["confinement_round"])
for message_id in ("review-message-1", "review-message-2"):
event = _Event(message_id=message_id)
request = SimpleNamespace(system_prompt="unchanged")
state = _finalized_p3_state()
contract.attach_context_state(state, request, event)
asyncio.run(main.PrivateCompanionPlugin.observe_p4_manual_review_candidate(host, event, request))
self.assertEqual("unchanged", request.system_prompt)
reads = [call for call in host.lifecycle_calls if call[0] == "read_p4_effect_state"]
self.assertEqual(2, len(reads))
self.assertEqual(1, len(host.manual_candidates))
candidate = next(iter(host.manual_candidates.values()))
self.assertEqual(host.person_id, candidate["person_id"])
self.assertEqual("third_confinement_review_required", candidate["reason_code"])
self.assertNotIn("review-message-1", repr(candidate))
self.assertNotIn("review-message-2", repr(candidate))
def _assert_request_cleared(self, request: SimpleNamespace) -> None:
self.assertEqual("", request.system_prompt)
self.assertEqual("", request.prompt)
self.assertEqual([], request.extra_user_content)
self.assertEqual([], request.images)
self.assertEqual([], request.image_urls)
self.assertEqual([], request.tool_calls)
self.assertTrue(request.func_tool.cleared)
self.assertEqual("blocked", getattr(request, "_private_companion_p4_runtime_gate"))
def _assert_fixed_reply_before_send(self, host: _LiveHost, event: _Event) -> None:
fixed_reply = getattr(event, "_private_companion_p4_fixed_reply")
self.assertEqual(runtime_gate.SAFE_CONFINEMENT_REPLY, fixed_reply)
with patch.object(main, "Plain", _Plain):
asyncio.run(main.PrivateCompanionPlugin.enforce_p4_live_confinement_reply_before_send(host, event))
self.assertTrue(event.stopped)
self.assertIsInstance(event.result, list)
self.assertEqual(1, len(event.result))
self.assertIsInstance(event.result[0], _Plain)
self.assertEqual(runtime_gate.SAFE_CONFINEMENT_REPLY, event.result[0].text)
if __name__ == "__main__":
unittest.main()