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