458 行
20 KiB
Python
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()
|