astrbot_plugin_private_comp.../tests/test_req028_expression_contract.py

411 行
20 KiB
Python

from __future__ import annotations
from copy import deepcopy
import ast
from pathlib import Path
import sys
import unittest
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
from companion_interaction_expression import ( # noqa: E402
EXPRESSION_CONTRACT_VERSION,
ExpressionBand,
ExpressionDecision,
ExpressionInput,
allowed_expression_bands,
build_expression_decision,
current_interaction_projection,
expression_decision_prompt,
resolve_expression_decision,
)
class Req028ExpressionContractTests(unittest.TestCase):
def test_all_seven_bands_are_supported_for_owner_exclusive(self) -> None:
for band in ExpressionBand:
with self.subTest(band=band.value):
decision = build_expression_decision(
{
"relationship_role": "owner",
"relationship_mode": "owner_exclusive",
"current_interaction": band.value,
"administrator_override": band.value,
}
)
self.assertEqual(band.value, decision.expression_band)
self.assertIsNone(decision.blocker)
def test_owner_only_bands_are_downgraded_for_regular_users(self) -> None:
for band in ("close", "affectionate"):
with self.subTest(band=band):
decision = build_expression_decision(
{
"relationship_role": "friend",
"relationship_mode": "owner_exclusive",
"current_interaction": band,
}
)
self.assertEqual("warm", decision.expression_band)
self.assertIn("owner_role_required", decision.reason_codes)
def test_owner_role_can_use_owner_only_interaction_without_exclusive_mode(self) -> None:
decision = build_expression_decision(
{"relationship_role": "owner", "relationship_mode": "normal", "current_interaction": "affectionate"}
)
self.assertEqual("affectionate", decision.expression_band)
self.assertNotIn("owner_role_required", decision.reason_codes)
def test_p4_and_contact_boundaries_precede_administrator_override(self) -> None:
blocked = build_expression_decision(
{
"relationship_role": "owner",
"relationship_mode": "owner_exclusive",
"administrator_override": "affectionate",
"safety_constraints": {"contact_boundary": True, "p4_blocked": True},
}
)
self.assertEqual("p4_safety", blocked.blocker)
self.assertEqual("p4_blocked", blocked.safety_mode)
self.assertEqual("avoidant", blocked.expression_band)
self.assertEqual(0, blocked.proactive_budget)
boundary = build_expression_decision(
{
"relationship_role": "owner",
"relationship_mode": "owner_exclusive",
"administrator_override": "affectionate",
"safety_constraints": {"contact_boundary": {"active": True}},
}
)
self.assertEqual("contact_boundary", boundary.blocker)
self.assertEqual("avoidant", boundary.expression_band)
passive_reply = build_expression_decision(
{
"relationship_role": "owner",
"relationship_mode": "owner_exclusive",
"administrator_override": "affectionate",
"proactive_candidate": {"eligible": True, "daily_allowance": 5},
"safety_constraints": {
"contact_boundary": {"active": True},
"passive_reengagement": True,
},
}
)
self.assertIsNone(passive_reply.blocker)
self.assertEqual("contact_boundary_passive", passive_reply.safety_mode)
self.assertEqual("avoidant", passive_reply.expression_band)
self.assertEqual(0, passive_reply.proactive_budget)
self.assertFalse(passive_reply.followup)
self.assertIn("contact_boundary_passive_reengagement", passive_reply.reason_codes)
capped = build_expression_decision(
{
"relationship_role": "owner",
"relationship_mode": "owner_exclusive",
"current_interaction": "affectionate",
"safety_constraints": {"p4_warmth_cap": "neutral"},
}
)
self.assertEqual("relaxed", capped.expression_band)
self.assertIn("p4_warmth_cap_applied", capped.reason_codes)
def test_is_deterministic_and_has_no_input_mutation_or_persistence_effect(self) -> None:
payload = {
"relationship_score": 700,
"relationship_role": "owner",
"relationship_mode": "owner_exclusive",
"current_interaction": {"band": "close"},
"bot_state": {"energy": 88},
"schedule": {"mode": "free"},
"message_intent": {"kind": "question"},
"proactive_candidate": {"eligible": True, "daily_allowance": 3},
}
before = deepcopy(payload)
first = build_expression_decision(payload)
second = resolve_expression_decision(payload)
self.assertEqual(first, second)
self.assertEqual(before, payload)
self.assertIsInstance(first, ExpressionDecision)
self.assertEqual(EXPRESSION_CONTRACT_VERSION, first.contract)
self.assertEqual(3, first.proactive_budget)
self.assertEqual("allowed", first.initiative)
self.assertEqual("close", first.expression_band)
def test_invalid_or_maliciously_shaped_input_fails_safe_without_echoing_it(self) -> None:
marker = "PRIVATE_CONTEXT_DO_NOT_ECHO"
decision = build_expression_decision(
{
"relationship_score": object(),
"relationship_role": ["owner"],
"relationship_mode": {"unexpected": "owner_exclusive"},
"current_interaction": {"band": marker},
"bot_state": "not-a-mapping",
"schedule": [marker],
"message_intent": marker,
"proactive_candidate": {"eligible": "yes", "daily_allowance": 99},
"safety_constraints": marker,
"administrator_override": {"band": marker},
}
)
self.assertEqual("relaxed", decision.expression_band)
self.assertEqual(0, decision.proactive_budget)
self.assertNotIn(marker, repr(decision))
self.assertEqual("passive_only", decision.initiative)
def test_typed_input_is_accepted_and_decision_projection_is_detached(self) -> None:
decision = build_expression_decision(
ExpressionInput(current_interaction="warm", message_intent={"followup_allowed": False})
)
projection = decision.to_dict()
projection["reason_codes"] = ("changed_only_in_projection",)
self.assertEqual("warm", decision.expression_band)
self.assertFalse(decision.followup)
self.assertIn("intent_followup_suppressed", decision.reason_codes)
self.assertNotIn("changed_only_in_projection", decision.reason_codes)
def test_long_term_relationship_remains_the_baseline_when_interaction_is_relaxed(self) -> None:
decision = build_expression_decision(
{
"relationship_score": 900,
"relationship_role": "friend",
"current_interaction": "relaxed",
"relationship_baseline": {
"tone": "亲密、柔软、不过度黏人",
"address_level": "使用双方已确认的昵称",
"proactive_care_limit": 2,
"soft_behaviors": {"allow_followup": True},
},
"proactive_candidate": {"eligible": True, "daily_allowance": 5},
}
)
self.assertEqual("warm", decision.expression_band)
self.assertEqual("亲密、柔软、不过度黏人", decision.tone)
self.assertEqual("使用双方已确认的昵称", decision.address_style)
self.assertEqual(2, decision.proactive_budget)
self.assertIn("relationship_baseline_retained", decision.reason_codes)
def test_owner_exclusive_relationship_is_fixed_baseline_but_manual_interaction_can_adjust_it(self) -> None:
baseline = build_expression_decision(
{
"relationship_role": "owner",
"relationship_mode": "owner_exclusive",
"current_interaction": "relaxed",
}
)
adjusted = build_expression_decision(
{
"relationship_role": "owner",
"relationship_mode": "owner_exclusive",
"current_interaction": "relaxed",
"administrator_override": "relaxed",
}
)
self.assertEqual("close", baseline.expression_band)
self.assertEqual("relaxed", adjusted.expression_band)
self.assertIn("administrator_override_applied", adjusted.reason_codes)
def test_bot_state_and_schedule_change_the_single_expression_decision(self) -> None:
baseline = build_expression_decision(
{
"current_interaction": "warm",
"bot_state": {"energy": 80, "mood": "轻快"},
"proactive_candidate": {"eligible": True, "daily_allowance": 3},
}
)
constrained = build_expression_decision(
{
"current_interaction": "warm",
"bot_state": {"energy": 18, "mood": "疲惫低落"},
"schedule": {"label": "忙碌会议"},
"proactive_candidate": {"eligible": True, "daily_allowance": 3},
}
)
self.assertGreater(baseline.warmth, constrained.warmth)
self.assertTrue(baseline.followup)
self.assertFalse(constrained.followup)
self.assertEqual("brief", constrained.response_length)
self.assertEqual(0, constrained.proactive_budget)
self.assertIn("low_energy_expression_cap", constrained.reason_codes)
self.assertIn("down_mood_expression_cap", constrained.reason_codes)
self.assertIn("schedule_proactive_suppressed", constrained.reason_codes)
def test_page_projection_gates_owner_only_bands_and_expires_manual_override(self) -> None:
friend = current_interaction_projection(
{"expression_band": "affectionate", "source": "manual", "updated_at": 10},
relationship_role="friend",
)
owner = current_interaction_projection(
{"expression_band": "affectionate", "source": "manual", "expires_at": 20},
relationship_role="owner",
relationship_mode="owner_exclusive",
now=30,
)
self.assertEqual("warm", friend["expression_band"])
self.assertEqual(5, len(allowed_expression_bands("friend", "normal")))
self.assertEqual(7, len(allowed_expression_bands("owner", "normal")))
self.assertEqual("relaxed", owner["expression_band"])
self.assertFalse(owner["manual_override"])
def test_prompt_is_bounded_and_uses_single_decision(self) -> None:
decision = build_expression_decision({"current_interaction": "lively"})
prompt = expression_decision_prompt(decision)
self.assertIn("活泼", prompt)
self.assertNotIn("relationship_score", prompt)
def test_legacy_model_relationship_profile_has_no_active_runtime_consumer(self) -> None:
source = (ROOT / "user_memory.py").read_text(encoding="utf-8")
tree = ast.parse(source)
owner = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == "UserMemoryMixin")
profile_method = next(node for node in owner.body if isinstance(node, ast.FunctionDef) and node.name == "_relationship_profile")
constants = {node.value for node in ast.walk(profile_method) if isinstance(node, ast.Constant) and isinstance(node.value, str)}
self.assertNotIn("persona_relationship", constants)
default_source = (ROOT / "constants.py").read_text(encoding="utf-8")
self.assertNotIn('"persona_relationship": {}', default_source)
self.assertNotIn('"relationship_state": {}', default_source)
self.assertNotIn("def _refresh_persona_relationship", source)
qzone_source = (ROOT / "qzone_integration.py").read_text(encoding="utf-8")
self.assertNotIn("relationship_state: dict[str, Any]", qzone_source)
self.assertNotIn("relationship_state=", source)
self.assertNotIn("refresh_persona_relationship_inbound", (ROOT / "main.py").read_text(encoding="utf-8"))
self.assertNotIn("refresh_persona_relationship_proactive", (ROOT / "daily_state.py").read_text(encoding="utf-8"))
def test_proactive_contact_boundary_is_independent_of_legacy_state_toggle(self) -> None:
source = (ROOT / "proactive.py").read_text(encoding="utf-8")
tree = ast.parse(source)
owner = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == "ProactiveMixin")
method = next(node for node in owner.body if isinstance(node, ast.FunctionDef) and node.name == "_current_relationship_gate_mode")
constants = {node.value for node in ast.walk(method) if isinstance(node, ast.Constant) and isinstance(node.value, str)}
self.assertNotIn("enable_relationship_state_machine", constants)
module = ast.Module(
body=[ast.ImportFrom(module="__future__", names=[ast.alias(name="annotations")], level=0), deepcopy(method)],
type_ignores=[],
)
namespace: dict[str, object] = {}
exec(compile(ast.fix_missing_locations(module), str(ROOT / "proactive.py"), "exec"), namespace)
gate = namespace["_current_relationship_gate_mode"]
host = type("Host", (), {"enable_relationship_state_machine": False})()
self.assertEqual("backoff", gate(host, {"contact_preference": {"no_contact": True}}))
def test_proactive_chat_bridge_preflight_consumes_expression_budget_and_boundary(self) -> None:
source = (ROOT / "proactive_message.py").read_text(encoding="utf-8")
tree = ast.parse(source)
owner = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == "ProactiveMessageMixin")
method = next(node for node in owner.body if isinstance(node, ast.FunctionDef) and node.name == "_proactive_chat_bridge_preflight_block_reason")
constants = {node.value for node in ast.walk(method) if isinstance(node, ast.Constant) and isinstance(node.value, str)}
self.assertIn("_build_expression_decision_for_user", constants)
self.assertIn("expression_proactive_budget_exhausted", constants)
self.assertIn("expression_contact_boundary", constants)
module = ast.Module(
body=[ast.ImportFrom(module="__future__", names=[ast.alias(name="annotations")], level=0), deepcopy(method)],
type_ignores=[],
)
def safe_int(value: object, default: int = 0, *_args: object) -> int:
try:
return int(value) if not isinstance(value, bool) else default
except (TypeError, ValueError):
return default
namespace = {
"_safe_float": lambda value, default=0.0: float(value) if isinstance(value, (int, float)) else default,
"_safe_int": safe_int,
"_single_line": lambda value, _limit=0: value.strip() if isinstance(value, str) else "",
}
exec(compile(ast.fix_missing_locations(module), str(ROOT / "proactive_message.py"), "exec"), namespace)
preflight = namespace["_proactive_chat_bridge_preflight_block_reason"]
class Host:
def _is_quiet_time(self) -> bool:
return False
def _can_send_insomnia_night_message(self, _user: object) -> bool:
return False
def _current_relationship_gate_mode(self, _user: object, *, now: float) -> str:
return ""
def _current_emotion_gate_mode(self, _user: object, *, now: float) -> str:
return ""
def _effective_user_daily_limit(self, _user: object) -> int:
return 3
def _proactive_daily_limit_is_unlimited(self, _limit: int) -> bool:
return False
def _reset_daily_counter_if_needed(self, _user: object) -> None:
return None
def _build_expression_decision_for_user(self, _user: object, **_kwargs: object) -> dict[str, object]:
return {"proactive_budget": 3, "blocker": None}
host = Host()
self.assertEqual("expression_proactive_budget_exhausted", preflight(host, {"sent_today": 3}, now=100.0))
host._current_relationship_gate_mode = lambda _user, *, now: "backoff" # type: ignore[method-assign]
self.assertEqual("expression_contact_boundary", preflight(host, {"sent_today": 0}, now=100.0))
def test_page_dto_marks_legacy_relationship_state_read_only(self) -> None:
page_source = (ROOT / "page_api.py").read_text(encoding="utf-8")
users_source = (ROOT / "page_api_users_groups.py").read_text(encoding="utf-8")
self.assertIn('"compatibility": "legacy_read_only"', page_source)
self.assertIn('"current_authority": "current_interaction"', page_source)
self.assertIn('"expression_authority"', page_source)
self.assertIn('detail["expression_decision"]', users_source)
for source in (page_source, users_source):
tree = ast.parse(source)
for call in (node for node in ast.walk(tree) if isinstance(node, ast.Call)):
if not isinstance(call.func, ast.Name) or call.func.id != "current_interaction_projection":
continue
self.assertTrue(call.args)
first_arg = call.args[0]
self.assertFalse(
isinstance(first_arg, ast.BoolOp) and isinstance(first_arg.op, ast.Or),
"current_interaction must not fall back to legacy relationship_state",
)
def test_runtime_expression_projections_never_fall_back_to_legacy_state(self) -> None:
runtime_files = (
"proactive.py",
"proactive_engine.py",
"proactive_message.py",
"private_reading.py",
"main.py",
"user_memory.py",
)
for filename in runtime_files:
with self.subTest(filename=filename):
tree = ast.parse((ROOT / filename).read_text(encoding="utf-8"))
for call in (node for node in ast.walk(tree) if isinstance(node, ast.Call)):
if not isinstance(call.func, ast.Name) or call.func.id != "current_interaction_projection":
continue
self.assertTrue(call.args)
self.assertFalse(
isinstance(call.args[0], ast.BoolOp) and isinstance(call.args[0].op, ast.Or),
"current_interaction must not fall back to relationship_state",
)
def test_expression_context_has_no_legacy_state_consumer_or_sync_adapter(self) -> None:
source = (ROOT / "user_memory.py").read_text(encoding="utf-8")
tree = ast.parse(source)
owner = next(node for node in tree.body if isinstance(node, ast.ClassDef) and node.name == "UserMemoryMixin")
methods = {
node.name: node
for node in owner.body
if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef))
}
context = methods["_expression_companion_context"]
context_constants = {
node.value for node in ast.walk(context) if isinstance(node, ast.Constant) and isinstance(node.value, str)
}
self.assertNotIn("relationship_state", context_constants)
self.assertNotIn("_sync_current_interaction_from_legacy", methods)
if __name__ == "__main__":
unittest.main()