303 行
12 KiB
Python
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
|