astrbot_plugin_private_comp.../tests/test_req029_relationship_caps.py

303 行
12 KiB
Python

from __future__ import annotations
import ast
import json
from pathlib import Path
import sys
ROOT = Path(__file__).resolve().parents[1]
sys.path.insert(0, str(ROOT))
from companion_interaction_expression import ( # noqa: E402
build_expression_decision,
current_interaction_projection,
)
from relationship_ledger import ( # noqa: E402
apply_relationship_event,
migrate_relationship_positive_stage_cap,
)
def test_positive_event_and_manual_runtime_cap_keep_normal_scores_bounded() -> None:
user = {
"relationship_role": "friend",
"relationship_mode": "normal",
"relationship_score": 598,
"relationship_positive_stage_cap_key": "familiar",
}
result = apply_relationship_event(user, 4, reason_code="support", now=1_700_000_000, event_id="cap")
assert result["changed"] is True
assert result["score"] == 599
assert user["relationship_score"] == 599
blocked = apply_relationship_event(user, 4, reason_code="support", now=1_700_000_001, event_id="second")
assert blocked["changed"] is False
assert blocked["code"] == "positive_stage_cap"
negative = {
"relationship_role": "friend",
"relationship_mode": "normal",
"relationship_score": -500,
"relationship_positive_stage_cap_key": "familiar",
}
assert apply_relationship_event(negative, -4, reason_code="boundary", now=1_700_000_000)["score"] == -504
owner = {
"relationship_role": "owner",
"relationship_mode": "owner_exclusive",
"relationship_score": 1200,
"relationship_positive_stage_cap_key": "familiar",
}
assert apply_relationship_event(owner, 4, reason_code="support", now=1_700_000_000)["code"] == "owner_exclusive_frozen"
def test_lowering_migration_is_idempotent_but_runs_again_after_a_real_upgrade() -> None:
user = {"relationship_role": "friend", "relationship_mode": "normal", "relationship_score": 1000}
first = migrate_relationship_positive_stage_cap(
user,
old_cap_key="deeply_bonded",
new_cap_key="close",
now=1_700_000_000,
)
assert first["changed"] is True
assert first["score"] == round(1000 / 1200 * 899)
assert first["entry"]["reason_code"] == "relationship_positive_stage_cap_migration"
replay = migrate_relationship_positive_stage_cap(
user,
old_cap_key="deeply_bonded",
new_cap_key="close",
now=1_700_000_001,
)
assert replay["code"] == "positive_stage_cap_already_migrated"
upgrade = migrate_relationship_positive_stage_cap(
user,
old_cap_key="close",
new_cap_key="deeply_bonded",
now=1_700_000_002,
)
assert upgrade["changed"] is False
assert "relationship_positive_stage_cap_migration" not in user
user["relationship_score"] = 1000 # Later normal interaction may grow after the cap is raised.
second = migrate_relationship_positive_stage_cap(
user,
old_cap_key="deeply_bonded",
new_cap_key="close",
now=1_700_000_003,
)
assert second["changed"] is True
assert second["score"] == round(1000 / 1200 * 899)
exempt_during_upgrade = {
"relationship_role": "friend",
"relationship_mode": "normal",
"relationship_score": -1,
"relationship_positive_stage_cap_migration": {"transition": "deeply_bonded->close"},
}
migrate_relationship_positive_stage_cap(
exempt_during_upgrade,
old_cap_key="close",
new_cap_key="deeply_bonded",
now=1_700_000_004,
)
assert "relationship_positive_stage_cap_migration" not in exempt_during_upgrade
exempt_during_upgrade["relationship_score"] = 1000
resumed = migrate_relationship_positive_stage_cap(
exempt_during_upgrade,
old_cap_key="deeply_bonded",
new_cap_key="close",
now=1_700_000_005,
)
assert resumed["changed"] is True
def test_normal_interaction_cap_applies_to_decision_projection_and_not_to_exemptions() -> None:
decision = build_expression_decision(
{
"relationship_role": "friend",
"relationship_score": 300,
"current_interaction": "warm",
"normal_interaction_band_cap": "lively",
}
)
assert decision.expression_band == "lively"
assert "normal_interaction_band_cap_applied" in decision.reason_codes
projection = current_interaction_projection(
{"expression_band": "warm"},
relationship_role="friend",
relationship_score=300,
normal_interaction_band_cap="relaxed",
)
assert projection["expression_band"] == "relaxed"
assert projection["normal_interaction_band_cap"] == "relaxed"
negative = build_expression_decision(
{
"relationship_role": "friend",
"relationship_score": -1,
"current_interaction": "warm",
"normal_interaction_band_cap": "relaxed",
}
)
assert negative.expression_band == "relaxed"
owner = build_expression_decision(
{
"relationship_role": "owner",
"relationship_mode": "owner_exclusive",
"relationship_score": 1200,
"current_interaction": "affectionate",
"normal_interaction_band_cap": "relaxed",
}
)
assert owner.expression_band == "affectionate"
def test_automatic_settlement_uses_the_same_interaction_cap_and_schema_exposes_both_settings() -> 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")
settlement = next(node for node in owner.body if isinstance(node, ast.FunctionDef) and node.name == "_update_relationship_state_from_intent")
calls = [
node for node in ast.walk(settlement)
if isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == "current_interaction_projection"
]
assert calls
assert any(any(keyword.arg == "normal_interaction_band_cap" for keyword in call.keywords) for call in calls)
schema = json.loads((ROOT / "_conf_schema.json").read_text(encoding="utf-8-sig"))
items = schema["basic_config"]["items"]
assert items["relationship_positive_stage_cap_key"]["default"] == "deeply_bonded"
assert items["relationship_positive_stage_cap_key"]["options"] == ["familiar", "close", "intimate", "deeply_bonded"]
assert items["normal_interaction_band_cap"]["default"] == "warm"
assert items["normal_interaction_band_cap"]["options"] == ["relaxed", "lively", "warm"]
def test_core_group_manual_and_config_paths_use_the_same_cap_helpers() -> None:
sources = {
name: ast.parse((ROOT / name).read_text(encoding="utf-8"))
for name in ("core_store.py", "page_api_users_groups.py", "page_api.py")
}
names = {
name: {node.id for node in ast.walk(tree) if isinstance(node, ast.Name)}
for name, tree in sources.items()
}
assert "clamp_relationship_positive_stage_cap" in names["core_store.py"]
assert "relationship_positive_score_cap" in names["page_api_users_groups.py"]
assert "migrate_relationship_positive_stage_cap" in names["page_api.py"]
assert any(
isinstance(node, ast.FunctionDef) and node.name == "_reconcile_relationship_cap_config"
for node in ast.walk(sources["page_api.py"])
)
def test_runtime_cap_clamps_are_coalesced_into_one_store_save_and_group_settlement_receives_the_cap() -> None:
core_tree = ast.parse((ROOT / "core_store.py").read_text(encoding="utf-8"))
core_owner = next(node for node in core_tree.body if isinstance(node, ast.ClassDef) and node.name == "CoreStoreMixin")
get_user = next(node for node in core_owner.body if isinstance(node, ast.FunctionDef) and node.name == "_get_user")
assigned_names = {
target.id
for node in ast.walk(get_user)
if isinstance(node, ast.Assign)
for target in node.targets
if isinstance(target, ast.Name)
}
assert {"cap_result", "interaction_changed"} <= assigned_names
save_conditions = [
node.test
for node in ast.walk(get_user)
if isinstance(node, ast.If)
and any(
isinstance(child, ast.Call)
and isinstance(child.func, ast.Name)
and child.func.id == "getattr"
for child in ast.walk(node)
)
]
assert any(
{child.id for child in ast.walk(condition) if isinstance(child, ast.Name)}
>= {"cap_configuration_changed", "cap_result", "interaction_changed", "decay_result"}
for condition in save_conditions
)
group_tree = ast.parse((ROOT / "group_observation.py").read_text(encoding="utf-8"))
group_owner = next(node for node in group_tree.body if isinstance(node, ast.ClassDef) and node.name == "GroupObservationMixin")
settlement = next(node for node in group_owner.body if isinstance(node, ast.AsyncFunctionDef) and node.name == "_settle_confirmed_group_relationship")
relationship_calls = [
node
for node in ast.walk(settlement)
if isinstance(node, ast.Call) and isinstance(node.func, ast.Name) and node.func.id == "apply_relationship_event"
]
assert len(relationship_calls) == 1
assert any(keyword.arg == "positive_stage_cap_key" for keyword in relationship_calls[0].keywords)
def test_interaction_cap_lowering_writes_one_administrator_migration_marker() -> None:
source = (ROOT / "page_api.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 == "PrivateCompanionPageApi")
reconcile = next(node for node in owner.body if isinstance(node, ast.FunctionDef) and node.name == "_reconcile_relationship_cap_config")
namespace = {
"Any": object,
"current_interaction_projection": current_interaction_projection,
"migrate_relationship_positive_stage_cap": migrate_relationship_positive_stage_cap,
"normalize_normal_interaction_band_cap": __import__("companion_interaction_expression").normalize_normal_interaction_band_cap,
"normalize_relationship_mode": __import__("relationship_ledger").normalize_relationship_mode,
"normalize_relationship_positive_stage_cap_key": __import__("relationship_ledger").normalize_relationship_positive_stage_cap_key,
"time": __import__("time"),
}
module = ast.Module(body=[reconcile], type_ignores=[])
ast.fix_missing_locations(module)
exec(compile(module, str(ROOT / "page_api.py"), "exec"), namespace)
class Plugin:
def __init__(self) -> None:
self.data = {
"users": {
"u": {
"user_id": "u",
"relationship_role": "friend",
"relationship_mode": "normal",
"relationship_score": 300,
"current_interaction": {"expression_band": "warm", "updated_at": 1},
}
}
}
self.saves = 0
@staticmethod
def _private_user_role(user: dict[str, object], _user_id: str) -> str:
return str(user.get("relationship_role") or "friend")
def _save_data_sync(self) -> None:
self.saves += 1
class Host:
def __init__(self) -> None:
self.plugin = Plugin()
@staticmethod
def _single_line(value: object, limit: int) -> str:
return str(value or "")[:limit]
Host._reconcile_relationship_cap_config = namespace["_reconcile_relationship_cap_config"]
host = Host()
host._reconcile_relationship_cap_config(
old_positive_cap="deeply_bonded",
new_positive_cap="deeply_bonded",
old_interaction_cap="warm",
new_interaction_cap="lively",
)
interaction = host.plugin.data["users"]["u"]["current_interaction"]
assert interaction["expression_band"] == "lively"
assert interaction["source"] == "administrator_interaction_cap_migration"
assert interaction["reason"] == "administrator_interaction_cap_migration"
assert interaction["updated_at"] > 1
assert host.plugin.saves == 1
host._reconcile_relationship_cap_config(
old_positive_cap="deeply_bonded",
new_positive_cap="deeply_bonded",
old_interaction_cap="lively",
new_interaction_cap="lively",
)
assert host.plugin.saves == 1